IO流
输入流和输出流
Java中的IO流根据功能划分为：输入流和输出流。输入流：用于读取数据。输出流：用于写出数据。输入输出的参照方向是根据我们的程序的。
字节流和字符流
Java中的IO流根据处理的单位划分为：字节流和字符流。字节流：以字节为单位读写数据。字符流：以字符为单位读写数据。
高级流和低级流
Java中的IO流还分为：高级流和低级流。高级流：不能独立存在，必须基于另一个流工作。低级流：数据有明确的来源或者去向
字节流和字符流
字节流
InputStream：抽象类，是所有字节输入流的父类。
OutputStream：抽象类，是所有字节输出流的父类。
字符流
Reader与Writer 带有缓冲区。
Reader：抽象类，所有字符输入流的父类，不能实例化
Writer：抽象类，所有字符输出流的父类，不能实例化
字符流处理单位为字符：一次处理一个字符unicode。字符流本质上还是读写字节。
FIS和FOS
用于读写文件的流。FileInputStream：文件字节输入流，是低级流。FileOutputStream：文件字节输出流，是低级流。
写 FileOutputStream
构造器：
FileOutputStream(String name) 根据文件名创建用于写该文件的输出流。
FileOutputStream(File file)
FileOutputStream(File file, boolean append) append - 如果为 true，则将字节写入文件末尾处，而不是写入文件开始处。
如果文件不存在，会自动创建该文件。
方法：
void write(int d)写一个字节，写给定的int值的”低八位”
void write(byte[] d)将给定的字节数组中的所有字节一次性写出
void write(byte[] d, int start,int len)从下标start开始，写len个字节。
读 FileOutputStream
构造器：
FileOutputStream(File file)
FileOutputStream(String name)当前目录是相对于根目录下的
FileOutputStream(String name, boolean append)
方法：
int read() 读取1个字节，8位
int read(byte[] b) 从此输入流中将最多 b.length 个字节的数据读入 b 中
int read(byte[] b, int off, int len)
从输入流中将最多 len 个字节的数据读入一个 byte 数组中。从off处开始放
long skip(long n) 从输入流中跳过并丢弃 n 个字节的数据。
写
public class TestFile { public static void main(String[] args) throws Exception { OutputStream out = null; try{ out = new FileOutputStream("test.txt"); out.write(1); out.write('A'); byte[] bytes = "大家好".getBytes("utf-8"); out.write(bytes.length); out.write(bytes); } catch(Exception e){ } finally{ if(out != null){ try{ out.close(); } catch(IOException e){ } } } } }
读
public class TestFile { public static void main(String[] args) throws Exception { InputStream in = null; try{ in = new FileInputStream("test.txt"); System.out.println(in.read());// 1 System.out.println((char)in.read());// 'A' int len = in.read(); byte[] bytes = new byte[len]; in.read(bytes); String str = new String(bytes, "utf-8"); System.out.println(str); } catch(Exception e){ } finally{ if(in != null){ try{ in.close(); } catch(IOException e){ } } } } }
复制文件
public class TestFile { public static void main(String[] args) throws Exception { FileInputStream fis = new FileInputStream("E:\代码整体规范.pptx"); FileOutputStream fos = new FileOutputStream("E:\代码整体规范222.pptx"); byte[] buffer = new byte[1024 * 10];// 10k int len = -1; while((len = fis.read(buffer)) != -1){ fos.write(buffer, 0, len); } fis.close(); fos.close(); } }
BIS和BOS
BufferedInputStream：缓冲字节输入流
BufferedOutputStream：缓冲字节输出流
缓冲流的功能：内部维护一个缓冲区，用于减少读写次数，提高读写效率。
写 BufferedOutputStream
原理：BufferedOutputStream内部有一个缓冲区，大小8192k，每次调用write方法的时候，它首先把数据放入缓冲区中，等缓冲区存满后，调用方法out.write(buf,0,count)把缓冲区中的内容写出。这样提高的写的效率，不是一个字节一个字节的写。
构造器：
BufferedOutputStream(OutputStream out)
BufferedOutputStream(OutputStream out, int size) size:指定缓冲区大小
方法：
void flush() 刷新此缓冲的输出流。
void write(byte[] b, int off, int len)
void write(int b)
读 BufferedInputStream
原理：
BufferedInputStream内部有一个缓冲区，默认大小为8M，每次调用read方法的时候，它首先尝试从缓冲区里读取数据，若读取失败（缓冲区无可读数据），则选择从物理数据源（譬如文件）读取新数据（这里会尝试尽可能读取多的字节）放入到缓冲区中，最后再将缓冲区中的内容部分或全部返回给用户.由于从缓冲区里读取数据远比直接从物理数据源（譬如文件）读取速度快，所以BufferedInputStream的效率很高！
构造器：
BufferedInputStream(InputStream in)
BufferedInputStream(InputStream in, int size) size指的是缓冲区大小
方法：
read()
int read(byte[] b, int off, int len)
复制文件
public class TestFile { public static void main(String[] args) throws Exception { BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.zip")); BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("b")); int d = -1; // bis和bos内部都维护了一个缓冲数组,(8192) while((d = bis.read()) != -1){// read方法一次性读取多个字节放入缓冲区中 bos.write(d);// 把读到的字节放入缓冲数组中,数组装满了,再一次性写出 } bis.close(); bos.close(); } }
flush方法
public class TestFile { public static void main(String[] args) throws Exception { BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt")); bos.write("大家好".getBytes("utf-8")); // 没有真正写出,而是放入缓冲区中.等缓冲区满了才写出 bos.flush();// 把缓冲数组中的数据全部写出。 bos.close();// 先调用flush()方法后再关闭。所以最后一定要关闭,否则可能会丢数据 // 一般有缓冲区的flush方法有效，没有缓冲区的flush方法没有任何作用 } }
DIS和DOS
方便读写基本数据类型，但是效率不高，和RandomaccessFile的功能相似。
DataInputStream：可以方便的读取基本类型数据
DataOutputStream：可以方便的写出基本类型数据
写 DataOutputStream
构造器：DataOutputStream(OutputStream out),传入低级流，如FileOutputStream
方法：
size() 返回即到目前为止写入此数据输出流的字节数。
void write(byte[] b, int off, int len)
void write(int b) 将指定字节（参数 b 的八个低位）写入基础输出流。
void writeBoolean(boolean v)
void writeChar(int v)
void writeDouble(double v)
void writeFloat(float v)
void writeInt(int v)
void writeLong(long v)
void writeShort(int v)
void writeUTF(String str)
读 DataInputStream
构造器：
DataInputStream(InputStream in) ,传入低级流，如FileInputStream
方法：
int read(byte[] b)
int read(byte[] b, int off, int len)
boolean readBoolean()
char readChar()
double readDouble()
float readFloat()
int readInt()
long readLong()
short readShort()
String readUTF()
int skipBytes(int n)
写
DataOutputStream dos = new DataOutputStream(new FileOutputStream("dos.txt")); dos.writeInt(1000); dos.writeLong(34l); dos.writeDouble(2.34); dos.writeUTF("你好"); dos.close();
读
DataInputStream dis=new DataInputStream(new FileInputStream("dos.txt")); System.out.println(dis.readInt()); System.out.println(dis.readLong()); System.out.println(dis.readDouble()); System.out.println(dis.readUTF()); dis.close();
高级流的组合使用
我们既要可以方便的写出基本数据类型，又要写的效率高,那么我们可以联合使用DOS、BOS
FileOutputStream fos = new FileOutputStream("a.txt"); // 首先，为了提高些效率，包装为缓冲流。 BufferedOutputStream bos = new BufferedOutputStream(fos); // 为了方便的写出基本类型数据，包转为DOS DataOutputStream dos = new DataOutputStream(bos); // dos既可以方便的写出基本类型数据，又提高了效率 dos.writeInt(1234); dos.close();
ISR和OSW
InputStreamReader： 字符输入流 OutputStreamWriter：字符输出流
写 OutputStreamWriter
构造器：
OutputStreamWriter(OutputStream out) ,使用默认字符编码,平台默认的编码 window默认是gbk,liunx默认是utf-8
OutputStreamWriter(OutputStream out, String charsetName) 使用指定字符编码
方法：
void write(int c) 写入单个字符，即c的低16位
void write(char[] cbuf) 一次性将给定的字符数组中的所有字符写出
void write(char[] cbuf, int off, int len) 从start处开始连续将len字符写出
void write(String str)
void write(String str, int off, int len) 写入字符串的某一部分。
String getEncoding() 返回此流使用的字符编码的名称。
读 InputStreamReader
构造器：
InputStreamReader(InputStream in)
InputStreamReader(InputStream in, String charsetName)
方法：
String getEncoding() 返回此流使用的字符编码的名称。
int read() 读取单个字符。以int值形式返回,该int值”低16位”有效。如果是utf-8编码方案，会一个一个匹配，先读一个字符如果是英文字符，进行编码。不是英文字符则再读一个字符，中文字符占3个字符, 会一次性读取3个字符,把它按照utf-8解码成字符,再以unicode编码存在char中。
int read(char[] c) 一次最多尝试读取给定数组的length个字符，并存入数组返回值为实际读取到的字符
int read(char[] cbuf, int offset, int length)
写
OutputStreamWriter osw=new OutputStreamWriter(System.out);//写到控制台 osw.write(123); osw.write(new char[]{'A','B'}); osw.write("大家好！"); System.out.println(osw.getEncoding()); osw.close();
读
InputStreamReader reader=new InputStreamReader(new FileInputStream("b.txt")); int c=-1; while((c=reader.read())!=-1){ char chs=(char)c; System.out.print(chs); } reader.close();
从控制台读
InputStreamReader reader=new InputStreamReader(System.in); char[] chs=new char[3]; reader.read(chs);//阻塞方法,如果控制台没有数据会等待控制台输入 System.out.println(Arrays.toString(chs)); reader.close();
复制”文本文件”
只能复制文本文件，不是什么文件都能复制的
InputStreamReader reader=new InputStreamReader(new FileInputStream("src"+File.separator+"demo"+File.separator+"Demo01.java")); OutputStreamWriter writer=new OutputStreamWriter(new FileOutputStream("E:\a.java")); char[] chs=new char[1024*10]; int len=-1; while((len=reader.read(chs))!=-1){ writer.write(chs, 0, len); } reader.close(); writer.close();
BR和BW
BufferedReader：缓冲字符输入流
BufferedWriter：缓冲字符输出流
可以实现按行读取。
写 BufferedWriter
构造器：
BufferedWriter(Writer out) 传入一个字符流
BufferedWriter(Writer out, int size)传入一个字符流，size指的是缓冲区大小
方法：
void flush()
void newLine() 写入一个行分隔符。
void write(int c) 写入单个字符。
void write(char[] chs)
void write(char[] cbuf, int off, int len) 写入字符数组的某一部分。
void write(String str)
void write(String s, int off, int len) 写入字符串的某一部分。
读 BufferedReader
构造器：
BufferedReader(Reader in)
BufferedReader(Reader in, int sz)
方法：
int read() 读取单个字符。
int read(char[] chs)
int read(char[] cbuf, int off, int len) 将字符读入数组的某一部分。
String readLine() 读取一个文本行。
案例
写
BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("a.txt"),"utf-8")); writer.write("你好！"); writer.newLine(); writer.write("你好！"); writer.newLine(); writer.close();
读
BufferedReader reader=new BufferedReader(new InputStreamReader(new FileInputStream("a.txt"),"utf-8")); String str=null; while((str=reader.readLine())!=null){ System.out.println(str); } reader.close();
或者
BufferedReader reader=new BufferedReader(new InputStreamReader(new FileInputStream("a.txt"),"utf-8")); char[] chs=new char[5]; int len=-1; while((len=reader.read(chs))!=-1){ System.out.print(new String(chs)); } reader.close();
复制文件
BufferedReader reader=new BufferedReader(new InputStreamReader(new FileInputStream("src/demo/Demo01.java"),"gbk")); BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("E:\a.java"),"gbk")); String line=null; while((line=reader.readLine())!=null){ writer.write(line); writer.newLine(); } reader.close(); writer.close();
读取控制台中的数据，复制到文本文件中
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in)); BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("a.txt"))); String str=null; while(true){ str=reader.readLine(); if(str!=null&&str.equals("bye")){ break; } writer.write(str); writer.newLine(); } reader.close(); writer.close();
FileWriter和FileReader
可以直接读写文本文件的字符流。比较方便。但是使用FileWriter和FileReader就默认使用了当前系统默认的字符集进行读写。不能自己设置字符集，所以用的不是太多。
写 FileWriter extends OutputStreamWriter
构造器：
FileWriter(File file)
FileWriter(File file, boolean append)
FileWriter(String fileName)
FileWriter(String fileName, boolean append)
构造方法实现
public FileWriter(String fileName) throws IOException { super(new FileOutputStream(fileName)); } //即new FileWriter(“a.txt”)完全相当于new OutputStreamWriter(new FileOutputStream(a.txt))
方法：全部继承于OutputStreamWriter。
读 FileReader extends InputStreamReader
构造器：
FileReader(File file)
FileReader(String fileName)
public FileReader(String fileName) throws FileNotFoundException { super(new FileInputStream(fileName)); } //即new FileReader(“a.txt”)完全相当于new InputStreamReader(new FileInputSteam(“a.txt”))
方法：全部继承于InputStreamReader
写
FileWriter writer=new FileWriter("a.txt"); writer.write("你好"); //变成缓冲字符流 BufferedWriter br=new BufferedWriter(writer); br.write("%%%"); br.close();
读
FileReader reader=new FileReader("a.txt"); int c=-1; while((c=reader.read())!=-1){ System.out.println((char)c); } reader.close();
PrintWriter
缓冲字符输出流。在写文件时，可以指定字符集，比较方便。
构造器：
PrintWriter(File file)
PrintWriter(File file, String charset)
PrintWriter(String fileName)
PrintWriter(String fileName, String charset)
PrintWriter(OutputStream out)
PrintWriter(OutputStream out, boolean autoFlush) 自动刷新
创建带有自动刷新的缓冲字符输出流,每当调用"pringln()"注意是带有ln方法。就会在写操作后自动调用flush()方法，即自动刷新
PrintWriter(Writer out)
PrintWriter(Writer out, boolean autoFlush)
//该构造器既能指定字符集也能指定自动刷新
方法：
void print();输出,不带换行符,和System.out.print()差不多
void println() 带换行符
void write(char[] buf)
void write(char[] buf, int off, int len)
void write(int c)
void write(String s)
void write(String s, int off, int len)
案例
PrintWriter pw=new PrintWriter("p.txt","utf-8"); pw.println(true); pw.println(1234567); pw.println("你好!"); //注意，写入文件中的是字符串,true,1234567,你好 pw.close();
Serializable接口
public interface Serializable类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。
序列化接口没有方法或字段，仅用于标识可序列化的语义。
transient关键字
transient是Java语言的关键字，用来表示一个域不是该对象串行化的一部分。当一个对象呗串行化的时候，transient型的便利的值不包括再串行化的表示中，然而非transient型的变量是被包括进去的。
Transient修饰的属性可以通过其它手段进行序列化,可以参考ArrayList源码，ArrayList中底层数组是用transient修饰，但是进行了序列化。因为重写了readObject和writeObject方法。
OOS和OIS
将Object对象转换为byte序列,就是序列化,反之叫反序列化。
ObjectOutputStream：对象输出流
ObjectInputStream：对象输入流
写 ObjectOutputStream
构造器：ObjectOutputStream(OutputStream out)
方法：void writeObject(Object obj) 线程安全的方法
读 ObjectInputStream
构造器：ObjectInputStream(InputStream in)
方法：readObject() 线程安全的方法
public class Person implements Serializable { private String name; private int age; private int sex; private transient String info; private List<String> otherInfo; //...get/set方法 equals方法 hashcode方法 }
读写
public class Test { public static void main(String[] args) throws Exception { ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("a.txt")); List<String> list = new ArrayList<String>(); list.add("一"); list.add("二"); list.add("三"); Person p = new Person("zhansgan", 22, 1, "男", list); // 将p的name、age、sex、otherInfo值转换成二进制写入文件 // 比如name=zhangsan, 取’z’二进制为:1111010写入只有在写字符串时才有编码格式问题 out.writeObject(p); out.close(); ObjectInputStream in = new ObjectInputStream(new FileInputStream("a.txt")); Person p1 = (Person)in.readObject(); System.out.println(p1);// info值是null,没有被序列化 System.out.println(p1.equals(p)); in.close(); } }