JavaIO之字节流、字符流、缓冲流、转换流、序列化流、打印流

1、硬盘、内存与IO流的关系

2、字节输出流OutputStream（java.lang.Object）

package aaaa_io;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamTest {
    public static void main(String[] args) throws IOException {
		FileOutputStream fos = new FileOutputStream("写入文件的目的地");
		fos.write(97);
		fos.close();
	}
}

子类ByteArrayOutputStream、FileOutputStream、FilterOutputStream、ObjectOutputStream、OutputStream、PipedOutputStream

3、FileInputStream字节输入流写读取字节数据

package aaaa_io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class FileInputStreamTest {
    public static void main(String[] args) throws Exception {
		FileInputStream fis = new FileInputStream("读取文件的路径");
		
		//一个字节一个字节的读取
		int len = fis.read();
		int len2 = fis.read();
		int len3 = fis.read();		
		//多个字节一起读取
		byte[] bytes = new byte[1024];
		fis.read(bytes);
		fis.close();
	}
}

4、利用OutputStream、InputStream字节流实现文件复制

package aaaa_io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;

public class FileCobyTest {
    public static void main(String[] args) throws Exception {
		FileInputStream fis = new FileInputStream("读取文件路劲");
		FileOutputStream fos = new FileOutputStream("写入文件的路径");
		
		byte[] bytes = new byte[1024];
		
		int len = 0;
		while((len = fis.read()) != -1) {
			fos.write(bytes);
		}
		fos.close();
		fis.close();
	}
}

5、缓冲流

BufferedOutputStream 字节缓冲流

package aaaa_io;

import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;

public class BufferedOutputStreamTest {
      public static void main(String[] args) throws Exception {
		FileOutputStream fos = new FileOutputStream("要输出文件的目的地");
		BufferedOutputStream bos  = new BufferedOutputStream(fos);  //缓冲流
		bos.write("把数据写入缓冲区".getBytes());  //字节的方式写入缓冲区
	    bos.flush(); //刷新缓冲区
	    bos.close();
	}
}

BufferedInputStream字节输入缓冲流

package aaaa_io;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class BufferedInputStreamTest {
    public static void main(String[] args) throws IOException {
		FileInputStream fis = new FileInputStream("读取文件的地址");
		
	    BufferedInputStream bis = new BufferedInputStream(fis); 
	    byte[] bytes = new byte[1024];
	    int len = 0;
	    while((len = bis.read()) != -1) {
	    	System.out.println(new String(bytes,0,len));
	    }
	    bis.close();
	}
}

BufferedWriter字符写入缓冲流

package aaaa_io;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedWriterTest {
    public static void main(String[] args) throws IOException {
    	
		BufferedWriter bw = new BufferedWriter(new FileWriter("输出文件目的地"));
		
		for(int i = 0;i < 10;i++) {
			bw.write("你好你好");
			bw.newLine();
		}
		bw.flush();  //刷新缓冲区的数据到文件
		bw.close();
	}
}

BufferedReader字符读入缓冲流

package aaaa_io;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderTest {
     public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new FileReader("读取文件目的地"));
		String line;
		while((line = br.readLine()) == null) {
			System.out.println(line);
		}
		br.close();
	}
}

用缓冲流实现文本排序测试

package aaaa_io;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

import javax.annotation.processing.Filer;
import javax.lang.model.element.Element;
import javax.tools.FileObject;
import javax.tools.JavaFileObject;
import javax.tools.JavaFileManager.Location;

public class FileOrderTest {
    public static void main(String[] args) throws IOException {
		Map<String, String> hashMap = new HashMap<String, String>();
		BufferedReader br = new BufferedReader(new FileReader("读取文件的目的地"));
		BufferedWriter bw = new BufferedWriter(new FileWriter("写入文件的目的地"));
		
		String line;
		while((line =br.readLine()) != null) {
			String[] str = line.split("\\.");
			hashMap.put(str[0], str[1]);
		}
		
		for(Entry<String, String> map : hashMap.entrySet()) {
			line = map.getKey() + "." +map.getValue();
			bw.write(line);
			bw.newLine(); //写换行
		}
		for(String key : hashMap.keySet()) {
			String value = hashMap.get(key);
			line = key + "." + value;
			bw.write(line);
			bw.newLine(); //写换行
		}
		bw.close();
		br.close();
	}
}

6、转换流

字符编码和字符集
字符编码就是自然语言和计算机二进制转换存储的对应规则
字符集也是一个编码表表示一个系统支持的所有字符集合，包括各国语言

OutputStreamWriter输出转换流

package aaaa_io;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;

public class OutputStreamWriterTest {
       public static void main(String[] args) throws IOException {
		 write_utf_8();
		 write_gbk();
	}

	private static void write_gbk() throws IOException {
		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("输出文件目的地"),"utf-8");
		osw.write("你好");
		osw.flush();
		osw.close();
	}

	private static void write_utf_8() throws IOException {
		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("输出文件目的地"),"gbk");
		osw.write("你好");
		osw.flush();
		osw.close();
	}
}

InputStreamReade读取转换流

package aaaa_io;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class IInputStreamReaderTest {
     public static void main(String[] args) throws IOException {
		reader_utf_8();
		reader_gbk();
	}

	private static void reader_utf_8() throws IOException {
		InputStreamReader isr = new InputStreamReader(new FileInputStream("读取文件目的地"),"utf-8");
		int len = 0;
		while((len = isr.read()) != -1) {
			System.out.println((char)len);
		}
	}

	private static void reader_gbk() throws IOException {
		InputStreamReader isr = new InputStreamReader(new FileInputStream("读取文件目的地"),"gbk");
		int len = 0;
		while((len = isr.read()) != -1) {
			System.out.println((char)len);
		}
	}
}

用转换流实现文件编码格式转换

package aaaa_io;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class zhuanhuanTest {
      public static void main(String[] args) throws IOException {
		InputStreamReader isr = new InputStreamReader(new FileInputStream("读取文件的目的地"),"utf-8");
		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("输出文件目的地"),"gbk");
		
		char[] bytes = new char[1024];
		int len = 0;
		while((len = isr.read(bytes)) != -1) {
			osw.write(len);
		}
		osw.flush();
		osw.close();
		isr.close();
	}
}

7、序列化流

序列化和反序列化的概念

序列化： 就是把对象转换成字节
反序列化： 把字节转换成对象
要实现序列化或者反序列化必须满足
(1)序列化和反序列化都必须实现Serializable接口 形成一个标记
(2)必须存在对应的class文件或者字节码文件

ObjectOutputStream序列化流

package aaaa_io;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class ObjectOutputStreamTest implements Serializable{
   public static void main(String[] args) throws IOException {
	  ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("把对象序列化成二级制文件的地址"));
	  oos.writeObject(new Person("zzz","eee"));
	  oos.close();
   }
}

ObjectInputStream 反序列化流

package aaaa_io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class ObjectOInputStreamTest implements Serializable{
      public static void main(String[] args) throws Exception {
    	  ObjectInputStream ois = new ObjectInputStream(new FileInputStream("需要的子节流文件"));
          Object o = ois.readObject();
          Person person = (Person)o;
          ois.close();
	}
}
class Person{
	private String name;
	private String age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getAge() {
		return age;
	}
	public void setAge(String age) {
		this.age = age;
	}
	
}

static、transient关键字

静态优先于非静态加载到内存中（静态优先于对象进入内存中）
被staitic修饰的成员变量不能被序列化，序列化的都是对象
transient关键字：瞬态关键字
被transient关键字修饰的成员变量不能被序列化

InvalidClassException异常原理和解决方案

class Person{
	private final static Long serialVersionUID = 1L;   //让序列化编号不变
	private String name;
	private String age;
	public Person(String string, String string2) {
		// TODO Auto-generated constructor stub
	}
}

测试集合对象的序列化和反序列化

package aaaa_io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class ListSerilaizableTest {
	public static void main(String[] args) throws Exception {
		List<Person> list = new ArrayList<Person>();
		Arrays.asList(new Person("", ""), new Person("", ""));
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("序列化目的地"));
		oos.writeObject(list);
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("反序列环文件目的地"));
		List<Person> temp = (List<Person>) ois.readObject();
		for (Person person : temp) {

		}

	}
}

8、打印流

package aaaa_io;

import java.io.FileNotFoundException;
import java.io.PrintStream;

public class PrintStreamTest {
     public static void main(String[] args) throws FileNotFoundException {
		PrintStream ps = new PrintStream("输出数据的目的地");
	}
}