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);
    }
}

欧气满满大顺顺

发布了41 篇原创文章 · 获赞 13 · 访问量 5893

私信关注

file-IO-Properties-缓冲流-转换流-序列化-打印流

递归

IO