file文件
path路径
directory目录
路径不能写死
pathSeparator路径分隔符,win;Linu:
separator名称 - 分隔符字符,,win\ Linux/
相对路径:相对于项目目录的路径
-
public String getAbsolutePath() :返回此File的绝对路径名字符串。
-
public String getPath() :将此File转换为路径名字符串。
-
public String getName() :返回由此File表示的文件或目录的名称。
判断 -
public long length() :返回由此File表示的文件的长度。
-
public boolean exists() :此File表示的文件或目录是否实际存在。
-
public boolean isDirectory() :此File表示的是否为目录。
-
public boolean isFile() :此File表示的是否为文件。
创建 -
public boolean createNewFile() :当且仅当具有该名称的文件尚不存在时,创建一个新的空文件。
-
public boolean delete() :删除由此File表示的文件或目录。 硬盘删除,不到回收站
-
public boolean mkdir() :创建由此File表示的目录。
-
public boolean mkdirs() :创建由此File表示的目录,包括任何必需但不存在的父目录。
遍历 -
public String[] list() :返回一个String数组,表示该File目录中的所有子文件或目录。
-
public File[] listFiles() :返回一个File数组,表示该File目录中的所有的子文件或目录。
递归
直接递归称为方法自身调用自己
间接递归可以A方法调用B方法,B方法调用C方法,C方法调用A方法。
构造方法,禁止递归
递归次数不能太多
求和效率低,还是for循环
文件遍历
import java.io.File;
public class Demo {
public static void getFullName(File dir){
System.out.println(dir);//目录
File[] files = dir.listFiles();
for (File file : files) {
if(file.isDirectory()){
getFullName(file);//递归
}else {
System.out.println(file);
}
}
}
public static void main(String[] args) {
File file = new File("c:\\zhangjushun.github.io");
getFullName(file);
}
}
c:\zhangjushun.github.io\themes\next\test\helpers.js
c:\zhangjushun.github.io\themes\next\test\intern.js
c:\zhangjushun.github.io\themes\next\_config.yml
c:\zhangjushun.github.io\_config.yml
c:\zhangjushun.github.io\_config_bak.yml
搜索
1.转字符串
getname
endwith
2.文件过滤器
- java.io.FileFilter是一个接口
boolean accept(File pathname) :测试pathname是否应该包含在当前File目录中,符合则返回true
File[] files = dir.listFiles(new FileFilter() {
@Override
public boolean accept(File file) {
return file.isDirectory()||file.getName().toLowerCase().endsWith(".yml");
}
});
lambda的改写
public static void printDir3(File dir) {
// lambda的改写
File[] files = dir.listFiles(f ->{
return f.getName().endsWith(".java") || f.isDirectory();
});
// 循环打印
for (File file : files) {
if (file.isFile()) {
System.out.println("文件名:" + file.getAbsolutePath());
} else {
printDir3(file);
}
}
}
IO
根据数据的流向分为:输入流和输出流。
- 输入流 :把数据从其他设备上读取到内存中的流。
- 输出流 :把数据从内存 中写出到其他设备上的流。
格局数据的类型分为:字节流和字符流。
- 字节流 :以字节为单位,读写数据的流。
- 字符流 :以字符为单位,读写数据的流。
字节输出流【OutputStream】
字节输出的超类
- public FileOutputStream(File file):创建文件输出流以写入由指定的 File对象表示的文件。
- public FileOutputStream(String name): 创建文件输出流以指定的名称写入文件。
public static void main(String[] args) throws IOException {
FileOutputStream fos =new FileOutputStream("a.txt");//创建文件,流指向
fos.write(97);//110001,0-127记事本查询ASCII表 A
fos.close();
}
一次多个字节
- 第一个是正数,查询ASCII
- 第一个是负数,一二拼成中文,查询GBK
追加写
getBytes
运行一次写一次,true - public FileOutputStream(File file, boolean append): 创建文件输出流以写入由指定的 File对象表示的文件。
- public FileOutputStream(String name, boolean append): 创建文件输出流以指定的名称写入文件。
换行
fos.write("\r\n".getBytes());
- 回车符\r和换行符\n :
- 回车符:回到一行的开头(return)。
- 换行符:下一行(newline)。
- 系统中的换行:
- Windows系统里,每行结尾是 回车+换行 ,即\r\n;
- Unix系统里,每行结尾只有 换行 ,即\n;
- Mac系统里,每行结尾是 回车 ,即\r。从 Mac OS X开始与Linux统一。
java.io.InputStream抽象类
是表示字节输入流的所有类的超类
- FileInputStream(File file): 通过打开与实际文件的连接来创建一个 FileInputStream ,该文件由文件系统中的 File对象 file命名。
- FileInputStream(String name): 通过打开与实际文件的连接来创建一个 FileInputStream ,该文件由文件系统中的路径名 name命名。
1.创建对象
2.read
3.释放资源 - read方法,每次可以读取一个字节的数据,提升为int类型,读取到文件末尾,返回-1
- read(byte[] b),每次读取b的长度个字节到数组中,返回读取到的有效字节个数,读取到末尾时,返回-1
FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde
// 定义变量,作为有效个数
int len ;
// 定义字节数组,作为装字节数据的容器
byte[] b = new byte[2];
// 循环读取
while (( len= fis.read(b))!=-1) {
// 每次读取后,把数组的有效字节部分,变成字符串打印
System.out.println(new String(b,0,len));// len 每次读取的有效字节个数
}
// 关闭资源
fis.close();
流的关闭原则:先开后关,后开先关。
public static void main(String[] args) throws IOException {
// 1.创建流对象
// 1.1 指定数据源
FileInputStream fis = new FileInputStream("D:\\test.jpg");
// 1.2 指定目的地
FileOutputStream fos = new FileOutputStream("test_copy.jpg");
// 2.读写数据
// 2.1 定义数组
byte[] b = new byte[1024];
// 2.2 定义长度
int len;
// 2.3 循环读取
while ((len = fis.read(b))!=-1) {
// 2.4 写出数据
fos.write(b, 0 , len);
}
// 3.关闭资源
fos.close();
fis.close();
}
字符流
GBK:中文2字节
UTF-8:3字节
可读中文
字符输入流【Reader】 抽象类
- public void close() :关闭此流并释放与此流相关联的任何系统资源。
- public int read(): 从输入流读取一个字符。
- public int read(char[] cbuf): 从输入流中读取一些字符,并将它们存储到字符数组 cbuf中
FileReader类
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象
FileReader fr = new FileReader("read.txt");
// 定义变量,保存有效字符个数
int len ;
// 定义字符数组,作为装字符数据的容器
char[] cbuf = new char[2];
// 循环读取
while ((len = fr.read(cbuf))!=-1) {
System.out.println(new String(cbuf,0,len));
}
// 关闭资源
fr.close();
}
字符输出流【Writer】
FileWriter类
1.对象
2.write-写到缓冲区
3.flush-刷新过去
4.关闭-close
write(String str) 和 write(String str, int off, int len) ,每次可以写出字符串中的数据,更为方便,代码使用
FileWriter fw = new FileWriter("fw.txt",true);
// 写出字符串
fw.write("张巨顺");
// 写出换行
fw.write("\r\n");
// 写出字符串
fw.write("牛逼");
// 关闭资源
fw.close();
注意:字符流,只能操作文本文件,不能操作图片,视频等非文本文件
Io异常
1.jdk7以前
try…catch…finally
// 声明变量
FileWriter fw = null;
try {
//创建流对象
fw = new FileWriter("fw.txt");
// 写出数据
fw.write("程序员");
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (fw != null) {
fw.close();//释放
}
} catch (IOException e) {
e.printStackTrace();
}
}
2.try-with-resource
try (创建流对象语句,如果多个,使用';'隔开) {
// 读写数据
} catch (IOException e) {
e.printStackTrace();
}
public class HandleException2 {
public static void main(String[] args) {
// 创建流对象
try ( FileWriter fw = new FileWriter("fw.txt"); ) {
// 写出数据
fw.write("程序员");
} catch (IOException e) {
e.printStackTrace();
}
}
}
3.jdk1.9 无需手动close
public static void main(String[] args) throws IOException {
// 创建流对象
final FileReader fr = new FileReader("in.txt");
FileWriter fw = new FileWriter("out.txt");
// 引入到try中
try (fr; fw) {
// 定义变量
int b;
// 读取数据
while ((b = fr.read())!=-1) {
// 写出数据
fw.write(b);
}
} catch (IOException e) {
e.printStackTrace();
}
}
Properties类
java.util.Properties 继承于Hashtable-map
与Io相结合的集合
键,值 默认字符串
- public Object setProperty(String key, String value) : 保存一对属性。
- public String getProperty(String key) :使用此属性列表中指定的键搜索属性值。
- public Set stringPropertyNames() :所有键的名称的集合。
store,集合写入数据
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
Properties prop = new Properties();
prop.setProperty("zhangjushun","175");
prop.setProperty("zhangwei","175");
prop.setProperty("张益达","175");
FileWriter fw = new FileWriter("a.txt");
prop.store(fw,"save data");
结果
#save data
#Sun Mar 29 16:42:52 CST 2020
zhangwei=175
张益达=175
zhangjushun=175
public void load(InputStream inStream): 从字节输入流中读取键值对。
Properties prop = new Properties();
prop.load(new FileReader("a.txt"));
Set<String> set = prop.stringPropertyNames();
for (String s : set) {
String value = prop.getProperty(s);
System.out.println(s + "=" + value);
缓冲流
缓冲区数组
- 字节缓冲流:
BufferedInputStream,BufferedOutputStream - 字符缓冲流:
BufferedReader,BufferedWriter
字节缓冲流
public static void main(String[] args) throws FileNotFoundException {
// 记录开始时间
long start = System.currentTimeMillis();
// 创建流对象
try (
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("jdk9.exe"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.exe"));
){
// 读写数据
int len;
byte[] bytes = new byte[8*1024];
while ((len = bis.read(bytes)) != -1) {
bos.write(bytes, 0 , len);
}
} catch (IOException e) {
e.printStackTrace();
}
// 记录结束时间
long end = System.currentTimeMillis();
System.out.println("缓冲流使用数组复制时间:"+(end - start)+" 毫秒");
}
缓冲流+数组 最快
字符缓冲流
特有方法:
- BufferedReader:public String readLine(): 读一行文字。
- BufferedWriter:public void newLine(): 写一行行分隔符,由系统属性定义符号。
public static void main(String[] args) throws IOException {
// 创建流对象
BufferedReader br = new BufferedReader(new FileReader("in.txt"));
// 定义字符串,保存读取的一行文字
String line = null;
// 循环读取,读取到最后返回null
while ((line = br.readLine())!=null) {
System.out.print(line);
System.out.println("------");
}
// 释放资源
br.close();
}
}
文本排序 案例
public class BufferedTest {
public static void main(String[] args) throws IOException {
// 创建map集合,保存文本数据,键为序号,值为文字
HashMap<String, String> lineMap = new HashMap<>();
// 创建流对象
BufferedReader br = new BufferedReader(new FileReader("in.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"));
// 读取数据
String line = null;
while ((line = br.readLine())!=null) {
// 解析文本
String[] split = line.split("\\.");
// 保存到集合
lineMap.put(split[0],split[1]);
}
// 释放资源
br.close();
// 遍历map集合
for (int i = 1; i <= lineMap.size(); i++) {
String key = String.valueOf(i);
// 获取map中文本
String value = lineMap.get(key);
// 写出拼接文本
bw.write(key+"."+value);
// 写出换行
bw.newLine();
}
// 释放资源
bw.close();
}
}
转换流
编码:字符(能看懂的)–字节(看不懂的)
解码:字节(看不懂的)–>字符(能看懂的)
字符编码:对应规则
字符集 Charset:也叫编码表
ASCII
ISO-8859-1
GBxxx字符集
Unicode字符集
UTF-8编码,可以用来表示Unicode标准中任何字符,它是电子邮件、网页及其他存储或传送文字的应用中,优先采用的编码。
- OutputStreamWriter(OutputStream in): 创建一个使用默认字符集的字符流。
- OutputStreamWriter(OutputStream in, String charsetName): 创建一个指定字符集的字符流。
public static void main(String[] args) {
// 1.定义文件路径
String srcFile = "file_gbk.txt";
String destFile = "file_utf8.txt";
// 2.创建流对象
// 2.1 转换输入流,指定GBK编码
InputStreamReader isr = new InputStreamReader(new FileInputStream(srcFile) , "GBK");
// 2.2 转换输出流,默认utf8编码
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(destFile));
// 3.读写数据
// 3.1 定义数组
char[] cbuf = new char[1024];
// 3.2 定义长度
int len;
// 3.3 循环读取
while ((len = isr.read(cbuf))!=-1) {
// 循环写出
osw.write(cbuf,0,len);
}
// 4.释放资源
osw.close();
isr.close();
}
序列化
字节----对象
public ObjectOutputStream(OutputStream out): 创建一个指定OutputStream的ObjectOutputStream。
- 该类必须实现java.io.Serializable 接口,Serializable 是一个标记接口,不实现此接口的类将不会使任何状态序列化或反序列化,会抛出NotSerializableException 。
- 该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的,则该属性必须注明是瞬态的,使用transient 关键字修饰。
public class SerializeDemo{
public static void main(String [] args) {
Employee e = new Employee();
e.name = "zhangsan";
e.address = "beiqinglu";
e.age = 20;
try {
// 创建序列化流对象
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("employee.txt"));
// 写出对象
out.writeObject(e);
// 释放资源
out.close();
fileOut.close();
System.out.println("Serialized data is saved"); // 姓名,地址被序列化,年龄没有被序列化。
} catch(IOException i) {
i.printStackTrace();
}
}
}
Serializable 接口给需要序列化的类,提供了一个序列版本号。serialVersionUID 该版本号的目的在于验证序列化的对象和对应类是否版本匹配。
private static final long serialVersionUID = 1L;
public class SerTest {
public static void main(String[] args) throws Exception {
// 创建 学生对象
Student student = new Student("老王", "laow");
Student student2 = new Student("老张", "laoz");
Student student3 = new Student("老李", "laol");
ArrayList<Student> arrayList = new ArrayList<>();
arrayList.add(student);
arrayList.add(student2);
arrayList.add(student3);
// 序列化操作
// serializ(arrayList);
// 反序列化
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("list.txt"));
// 读取对象,强转为ArrayList类型
ArrayList<Student> list = (ArrayList<Student>)ois.readObject();
for (int i = 0; i < list.size(); i++ ){
Student s = list.get(i);
System.out.println(s.getName()+"--"+ s.getPwd());
}
}
private static void serializ(ArrayList<Student> arrayList) throws Exception {
// 创建 序列化流
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("list.txt"));
// 写出对象
oos.writeObject(arrayList);
// 释放资源
oos.close();
}
}
打印流
java.io.PrintStream类
只负责输出
无异常
继承 父类write,但print方法对数据原样输出 97-97
public PrintStream(String fileName): 使用指定的文件名创建一个新的打印流。
public class PrintDemo {
public static void main(String[] args) throws IOException {
// 调用系统的打印流,控制台直接输出97
System.out.println(97);
// 创建打印流,指定文件的名称
PrintStream ps = new PrintStream("ps.txt");
// 设置系统的打印流流向,输出到ps.txt
System.setOut(ps);
// 调用系统的打印流,ps.txt中输出97
System.out.println(97);
}
}