IO流总结

InputStream ：字节输入流

 read():一个字节一个字节的读,每次读出一个字节 
       InputStream inputStream = new FileInputStream("test1.txt")) 
       num = inputStream.read();---System.out.println((char)num);
read(数组):一次可以读出多个字节,数组的作用:每次会将读出的字节临时放到这个数组中
     (InputStream inputStream = new FileInputStream("test1.txt")
      while ((num=inputStream.read(arr)) != -1)
一次读取全部字节
	 (InputStream inputStream = new FileInputStream("test1.txt")
      int num = inputStream.available();
      byte[] bytes = new byte[num]; inputStream.read(bytes); 
      System.out.println(new String(bytes));

OutputStream ：字节输出流

OutputStream outputStream = new FileOutputStream("test1.txt") 
文件的写：String message = "你好，师姐";
		outputStream.write(message.getBytes());
		outputStream.flush();

Reader ：字符输入流

try (Reader reader = new FileReader("file\\src")) { 
    // 1. 实例化一个字符数组
    char[] array = new char[100]; 
    // 2. 声明一个变量，用来记录每次读取到了多少个数据 
    int length = 0; 
    // 3. 循环读取数据 
    while ((length = reader.read(array)) != -1) {
        String str = new String(array, 0, length); 
        System.out.print(str); 
    }
}

Writer ：字符输出流

try (Writer writer = new FileWriter("file\\\target", true--写入不覆盖，接着写入)) { 
    // 2. 将数据写入到输出流中 
    writer.write("hello, world"); 
    // 3. 冲刷缓冲区 
    writer.flush();
}

常见的缓冲流:

BufferedInputStream: 缓冲字节输入流

(BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("file\\source")))
	try (BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("file\\source"))) { 
        // 1. 实例化一个字节数组 
        byte[] array = new byte[1024]; 
        // 2. 声明一个整型变量，用来记录每次读取了多少个字节数据 
        nt length = 0; 
        // 3. 循环读取
        while ((length = bufferedInputStream.read(array)) != -1) { 
            // 4. 将读取到的数据转成字符串输出到控制台 
            String msg = new String(array, 0, length);
            System.out.println(msg); 
        }
    }

BufferedOutputStream： 缓冲字节输出流

try (BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("file\\source"))) { 
    // 1. 实例化一个字节数组 
    byte[] array = new byte[1024];
    // 2. 声明一个整型变量，用来记录每次读取了多少个字节数据 
    int length = 0; 
    // 3. 循环读取
    while ((length = bufferedInputStream.read(array)) != -1) { 
        // 4. 将读取到的数据转成字符串输出到控制台 
        String msg = new String(array, 0, length); 
        System.out.println(msg); 
    }
}

BufferedReader： 缓冲字符输入流

(BufferedReader bufferedReader = new BufferedReader(new FileReader("file\\src")))
	String line = ""; 
	// 2. 循环读取数据 
	while ((line = reader.readLine()) != null) {
    	// 3. 将读取到的数据输出
    	System.out.println(line);

BufferedReader 类中多了一个方法 readLine()
 readLine() 是逐行读取， 但是， 只能读取到一行中的内容， 并不能读取走换行符。 可以逐行读取。 一直到读取到的数据是nul

LineNumberReader：

​ 是BufffferedReader的子类,不能读.但是可以提高效率,特有功能:设置行号,获取行号

LineNumberReader lineNumberReader = new LineNumberReader(new FileReader("src\\test\\Demo1.java")); 
	//设置行号,默认从0开始,从1开始打印 
	lineNumberReader.setLineNumber(10); 
	String data = null; 
	while ((data = lineNumberReader.readLine()) != null) { 	
        System.out.print(lineNumberReader.getLineNumber());
			//获取行号 
             System.out.print(data); 
             System.out.println(); 
              }
		lineNumberReader.close(); }

BufferedWriter： 缓冲字符输出流

try (BufferedReader reader = new BufferedReader(new FileReader("file\\src")); 	BufferedWriter writer = new BufferedWriter(new FileWriter("file\\destination"))) {
    String line = ""; 
    while ((line = reader.readLine()) != null) {
		writer.write(line); 
        writer.newLine(); 
    }
    writer.flush(); 
}

BufferedWriter 类中多了一个方法 newLine()
	bufferedWriter.write("hello world");
    bufferedWriter.newLine();

装饰设计模式

MyBufferedReader myBufferedReader = new MyBufferedReader(new FileReader("src\\test\\Demo1.java"));

class MyBufferedReader extends Reader{}

Scanner

标准的输入流

//创建了标准输入流并关联了键盘(默认的) 
//InputStream inputStream = System.in;


try (BufferedInputStream bis = new BufferedInputStream(System.in)) {
    byte[] array = new byte[128]; 
    int length = 0; 
    while ((length = bis.read(array)) != -1) {
        String str = new String(array, 0, length); 
        System.out.println(str); 
    } 
}

标准的输出流

//PrintStream original = System.out;

 // PrintStream: 是一个打印流，可以将数据输出到指定位置。 
try (PrintStream ps = new PrintStream(new FileOutputStream("file\\logs", true))) {
	// ps.println("hello world！"); 
	// 重定向标准输出流 
	System.setOut(ps); 
    System.out.println("123"); 
}catch (IOException e) { 
	e.printStackTrace(); 
} finally {
	System.setOut(original); 
}
System.out.println("你好");

转换流

转换流输入流：

private static void read() { 
// 当前的项目是 utf-8, 读取的文件是 GBK
// 如果需要以指定的字符集进行文件的读取，需要使用 I
//InputStreamReader(InputStream inputStream, String charsetName)
try (InputStreamReader reader = new InputStreamReader(new FileInputStream("file\\src"), "GBK")) {
	char[] array = new char[128]; 
	int length = 0;
    while ((length = reader.read(array)) != -1) { 
    	System.out.println(new String(array, 0, length)); 
    	} 
    } catch (IOException e) { 
    	e.printStackTrace(); 
    } 
}

​

转换输出流：

private static void write() { 
// 以指定的字符集写数据 
try (OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream("file\\dst", true), "GBK")) {
    writer.write("hello world");
    writer.write("你好，世界"); 
} catch (IOException e) { 
    e.printStackTrace();
} 
}

打印流

字节打印流:PrintStream

字符打印流:PrintWriter

public static void main(String[] args) throws IOException { 
    PrintWriter pWriter = new PrintWriter(new FileWriter("test5.txt")); 	
    pWriter.write("bingbing"); 
    pWriter.close(); 
}

序列化流

​ 将短期存储的数据实现长期存储,这个过程对应的流就是序列化流

ObjectOutputStream

//创建序列化流 
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("D:\\ideaProgram\\copyDe mo5.java")); //objectOutputStream.writeInt(2); 
	//对对象进行序列化
	p1 = new Person("zhangsan",20);
	objectOutputStream.writeObject(p1); //可序列化类的所有子类型本身都是可序列化的。 		
	//objectOutputStream.writeObject(new GoodPerson("hah",20,20)); 
	//序列化后要及时关闭流 
	objectOutputStream.close();
}

ObjectInputStream

ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("D:\\ideaProgram\\copyDem o5.java")); 
	// int num = objectInputStream.readInt(); 
	// System.out.println(num); 
	//反序列化 
	Object o = objectInputStream.readObject();
	System.out.println(o == p1);
	//false 说明反序列化后的对象与原来的对象是 两块儿空间.
	System.out.println(o); 
	//objectInputStream.close(); 
}

Properties

Properties也不是一个IO流， 是一个集合。 是Hashtable的子类。 >

public static void fun3() throws IOException { 
    //读取a.txt的内容到Properties对象里面 
    Properties properties = new Properties(); 
    //利用load方法将内容从磁盘读入Properties对象 
    properties.load(new FileReader("D:\\ideaProgram\\a.txt")); 		
    //System.out.println(properties); 
    //改变内容 
    properties.setProperty("bingbing","buok"); 
    //使用store方法将数据写入磁盘
	properties.store(new FileWriter("D:\\ideaProgram\\a.txt"),"改变了冰冰的值"); 
    //写入控制台---通过list 
    properties.list(System.out); 
}