【Mark学Java】I/O流

I-input O-output stream-字符,字节; 1个字符=2个字节 1个字节=8个二进制位

输入:把硬盘中的数据,读取到内存中使用;字节输入流, InputStream字符输入流Reader

输出:把内存中的数据,写入到硬盘中保存;字节输出流OutputStream,字符输出流Writer

字节流

一切文件都是以字节形式存储

OutputStream

Object- OutputStream(Abstract) 此抽象类是输出字节流的所有类的超类

方法-close()关闭输出流并释放有关资源

flush()刷新此输出流并强制写出所有缓冲的输出字节

write(byte[ ] b) ,write(byte[ ],int off,int len),write(int b)将指定的字节写入此输出流

OutputStream-FileOutputStream

构造方法

FileOutputStream(String name) 创建一个向具有指定名称的文件中写入数据的文件输出流

FileOutputStream(File file) 创建一个向指定File对象表示的文件中写入数据的文件输出流

(1)创建一个FileOutputStream对象(2)根据构造方法中传递的文件/文件路径,创建一个空的文件(3)会把FileOutputStream对象指向创建好的文件

写出数据的原理(内存–>硬盘)

java程序—>JVM(java虚拟机)—>OS(操作系统)—>OS调用写数据的方法—>把数据写入到文件中

字节输出流的使用步骤

Step1.创建一个FileOutputStream对象,构造方法中传递写入数据的目的地(路径,文件)

Step2.调用FileOutputStream对象中的write( ),把数据写入到文件中(二进制 0-97 ASCII 其他 系统默认)

ps:一次写入多个字节:如果写的第一个字节是正数(0-127),那么显示的时候会查询ASCII表

​ 如果写的第一个字节是负数,那么第一个字节会和第二个字节,两个字节组成一个中文显示,查询系统默认码表

Step3.释放资源(流使用会占用一定的内存,使用完毕要把内存清空,提高程序的效率)

写入字符的方法–可以使用String类中的方法把字符串转换为字节数组 byte[ ] getBytes( ),对于中文字符 UTF-8下 三个字节代表一个字符,GBK下两个字节代表一个字符

追加写/换行

FileOutputStream(String name,boolean append)创建一个向指定name文件中写入数据的输出文件流

FileOutputStream(File file,boolean append)创建一个向指定File对象表示的文件中写入数据的文件输出流

true-追加 false-创建一个新文件,覆盖源文件

"\r\n"换行

InputStream

Object- InputStream(Abstract) 此抽象类是输出字节流的所有类的超类

方法-int read()从输入流中读取数据的下一个字节

int read(byte[ ] b)从输入流中读取一定数量的字节,并将其存储在缓冲区数组b中

数组的作用,缓冲作用,存储读取到的多个字节,数组的长度一般定义为1024

返回值,每回读取的有效个数

void close()关闭此输入流并释放与该流关联的所有系统资源

InputStream-FileInputStream

构造方法

FileInputStream(String name) 创建一个向具有指定名称的文件中写入数据的文件输入流

FileInputStream(File file) 创建一个向指定File对象表示的文件中写入数据的文件输入流

字节输出流的使用步骤

1.创建FileInputStream对象,构造方法中绑定要读取的数据源

2.使用FileInputStream对象中的read(),读取数据

3.释放资源

ps:String类的构造方法

String(byte[ ] bytes):把字节数组转为字符串

String(byte[ ] bytes,int offset,int length):把字节数组的一部分转换为字符串

String(char[ ] value) 把字符数组转换为字符串

String(char[ ] value,int offset,int count)把字符数组的一部分转换为字符串,offset数组的开始索引,count转换的个数

文件的复制(一读一写)

1.创建一个字节输入流对象,构造方法中绑定要读取的数据源

2.创建一个字节输出流对象,构造方法中绑定要写入的目的地

3.使用字节输入流的方法read()读取文件

4.使用字节输出流中的方法write(),把读取到的字节写入到目的地的文件中

5.释放资源

中文字符

使用字节流读取中文会产生乱码,因为1个中文 GBK占用两个字节,UTF-8占用3个字节.

字符流

Reader 字符输入流

int read()读取单个字符并返回

int read(char[ ] a)一次读取多个字符,将字符读入数组

java.io.FileReader extends InputStreamReader extends Reader

FileReader文件字符输入流 作用:把硬盘文件中的数据以字符的方式读取到内存中

构造方法(读取文件的数据源): FileReader(String filename)文件的路径

​ FileReader(File file)文件

FileReader构造方法作用:(1)创建一个FileReader对象(2)会把FileReader对象指向要读取的文件

***writer***字符输出流

write(int c)

void flush()刷新该流的缓冲

void close()关闭此流,但要先刷新它

flush() 刷新缓冲区,流对象可以继续使用

close() 先刷新缓冲区,然后通知系统释放资源.流对象不可以再被使用了

FileWriter把内存中字符写入到文件中

java.io.FileWriter extends OutputStreamWriter extends Writer

字符输出流的使用步骤(重点)

1.创建FileWriter对象,构造方法中绑定要写入数据的目的地

2.使用FileWriter中的方法write,把数据写入到内存缓冲区中(字符转换为字节的过程)

3.使用FileWriter中的方法flush,把内存缓冲区中的数据,刷新到文件中

4.释放资源(会把内存缓冲区中的数据刷新到文件中)

try{
    //可能会产生异常的代码
}catch(异常类变量 变量名){
    //异常的处理逻辑
}finally{
    // 一定会执行的代码(资源释放)
}
/*JDK 1.7以后新特性*/
try(定义流对象){
    //可能会产生异常的代码
}catch(异常类变量 变量名){
    //异常处理的逻辑
}
/*JDK1.9以后新特性*/
//try的前面可以定义流对象,try后边的()可以直接引入流对象的名称(变量名),try代码执行完毕后流对象被释放掉,不用finally
A a=new A();
B b=new B();
try(a,b){
    //可能产生异常的代码
}catch(异常类变量 变量名){
    //异常处理逻辑
}

properties

java.util.Properties集合 extends Hashtable<k,v> implements Map<k,v>

properties表示持久属性集,可保存在流中或从流中加载.

properties集合是一个唯一和IO流相结合的集合:可以使用properties集合中的方法store,把集合中的临时数据,持久化写入到硬盘中存储,可以使用properties集合中的方法load,把硬盘中保存的文件(键值对),读取到集合中使用.

属性列表中每个键及其对应值都是一个字符串.properties集合是一个双列集合,key和value默认都是字符串

Object setProperty(String key,String value)—Hashtable的方法put

String getProperty(String key)—通过key找到value值,此方法相当于Map集合中的get(key)方法

set<String> stringPropertyNames( )返回此属性列表中的键值,其中改键及其对应值是字符串,此方法相当于Map集合中的keyset方法

store()

把集合中的临时数据,持久化写入到硬盘中存储

void store(OutputStream out,String comments)字节输出流,不能写中文.commments用来解释保存的文件做什么,不能使用中文,默认Unicode,一般使用空字符串

void store(Writer writer,String comments)字符输出流,可以写中文.

//1.创建properties集合对象,添加数据
Properties prop = new Properties();
prop.setProperty("Mark","18");
prop.setProperty("WANGYan","19");
prop.setProperty("FENGAnqi","10");
//2.创建字节\字符输出流对象,构造方法中绑定要输出的目的地
FileWriter fw = new FileWriter("C:\\Users\\ThinkPad\\Desktop\\TEST\\prop.txt");
//3.使用store把集合中的临时数据持久化写入硬盘保存
prop.store(fw,"Save data");
//4.释放资源
fw.close();
//5.使用字节输出流,无法存储中文,这里匿名内部类无需关闭资源
prop.store(new FileOutputStream("C:\\Users\\ThinkPad\\Desktop\\TEST\\prop2.txt"),"save data");

load()

把硬盘中存储的文件(键值对),读取到集合中使用

void load(InputStream isStream)

void load(Reader reader)

步骤

1.创建properties集合对象

2.使用properties集合对象中的load读取保存键值对的文件(1)存储键值对的文件,键与值默认=,空格(2)#注释(3)键与值默认为字符串

3.遍历properties集合

缓冲流

字节缓冲流BufferedInputStream BufferedOutputStream

字符缓冲流BufferedReader BufferedWriter

BufferedOutputStream

BufferedOutputStream (OutputStream out)

BufferedOutputStream (OutputStream out,int size)

BufferedInputStream

int read()从输入流中读取数据的下一个字节

int read(byte[] b)从输入流中读取一定数量的字节,并将其存储在缓冲区数组b中

效率测试

BufferedWriter

BufferedWriter(Writer out)

BufferedWriter(Writer out,int sz)创建一个使用指定大小输出缓冲区的新缓冲字符输出流

void newLine( )写入一个行分隔符.会根据不同的操作系统,获取不同的行分隔符

BufferedReader

String readLine()读取一个文本行,读取一行数据.行的终止符号:通过下列字符之一 ‘\r’ ‘\n’ ‘\r\n’

编码\解码

ASCII字符集 GBK字符集 Unicode字符集(UTF-8,UTF-16,UTF-32),使用filereader读取项目文件,由于IDEA设置,都是默认的UTF-8编码,所以没任何问题.但由于Windows默认GBK,就会出现乱码.

转换流

eg.GBK 使用两个字节存储一个中文 ,UTF-8使用三个字节存储一个中文,IDE默认编码表 UTF-8

1.txt 你好(编码-55-44,-33-34)字节输入流FileInputStream->FileReader->查询IDE默认码表,把字节转换为字符(解码)->???乱码 内存java程序

public FileReader(String fileName)throws FileNotFoundException{
    super(new FileInputStream(fileName));
}

InputStreamReader—字节流通向字符流的桥梁,除了查询默认编码UTF-8,还可以指定编码集

OutputStreamWriter–字符流通向字节流的桥梁(编码:把能看懂的变成看不懂的)

OutputStreamWriter extends Writer

OutputStreamWriter(OutputStream out)

OutputStreamWriter(OutputStream out,String charsetName)编码集默认UTF-8/utf-8

1.创建OutputStreamWriter对象,构造方法中传递字节输出流和指定的编码表名称

2.使用OutputStreamWriter对象中的方法write,把字符转换为字节存储在缓冲区中(编码)

3.使用OutputStreamWriter对象中的方法flush,把内存缓冲区中的字节刷新到文件中(使用字节流写字节的过程)

4.释放资源

InputStreamReader extends Reader

转换文件编码(将GBK编码的文本文件转换为UTF-8编码的文本文件)

分析:1.指定GBK编码的转换流,读取文本文件 2.使用UTF-8编码的转换流,写出文本文件

    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(new FileInputStream("C:\\Users\\ThinkPad\\IdeaProjects" +
                "\\TestFile\\src\\Lesson02_IO\\TEST.txt"), "GBK");
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("C:\\Users\\ThinkPad\\IdeaProjects" +
                "\\TestFile\\src\\Lesson02_IO\\TEST1.txt"), "UTF-8");
        int len=0;
        while ((len=isr.read())!=-1){
            osw.write(len);
        }
        osw.close();
        isr.close();
    }

序列化\反序列化

Person p=new Person(“Mark”,18);

把对象以流的方式,写入到文件中保存,叫写对象,也叫对象的序列化.(对象中不仅仅是字符,使用字节流),ObjectOutputStream-对象的序列化流.writeObject§

1.创建ObjectOutputStream对象,构造方法中传递字节输出流

2.使用ObjectOutputStream对象中的方法writeObjectStream对象中的方法writeObject,把对象写入到文件中

3.释放资源

序列化与反序列化时,会抛出NotSerializableException异常,实现Serializable(标记型接口)

相反,把文件中保存的对象,以流的方式读取出来,叫读对象,也叫对象的反序列化.

ObjectInputStream:对象的反序列化流.使用Object object接收写出的对象.

Object readObject()从ObjectInputStream读取对象.抛出ClassNotFoundException(当不存在对象class文件时)

反序列化的前提(1)类必须实现Serialzable接口(2)必须存在类对应的class文件

transient被transient修饰的成员变量,不能被序列化

static-静态关键字,静态优先于非静态加载到内存中(静态优先于对象进入内存中).被static修饰的成员变量不能被序列化,序列化的都是对象.

private static final long serialVersionUID=1L避免序列号冲突异常InvalidClassException(当JVM反序列化对象时,虽然能找到class文件,但class文件在序列化对象之后发生了修改,那么反序列化操作也会失败,抛出一个InvalidClassException异常)

原因(1)该类的序列版本号与从流中读取的类描述符的版本号不匹配(2)该类包含未知数据类型(3)该类没有可访问的无参数构造方法

serializable接口给需要序列化的类,提供了一个序列版本号serialVersionUID

序列化集合:在文件中保存多个对象时,可以把多个对象存储到一个集合中,对集合进行序列化,反序列化.

public static void main(String[] args) throws IOException, ClassNotFoundException {    
    //1.定义一个存储person对象的ArrayList集合    
    ArrayList<Person> list = new ArrayList<>();    
    //2.往ArrayList集合中存储Person对象    
    list.add(new Person("Mark",18));    
    list.add(new Person("Tom",19));    
    list.add(new Person("Lucy",20));    
    //3.创建一个序列化流ObjectOutputStream对象    
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\ThinkPad\\Desktop\\TEST\\314.txt"));    
    //4.使用ObjectOutputStream对象中的方法writeObject,对集合进行序列化    
    oos.writeObject(list);    
    //5.创建一个反序列化ObjectInputStream对象    
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("C:\\Users\\ThinkPad\\Desktop\\TEST\\314.txt"));    
    //6.使用ObjectInputStream对象中的方法readObject读取文件中保存的集合    
    Object o = ois.readObject();   
    //7.把Object类型强制转换为ArrayList类型    
    ArrayList<Person> list2 = (ArrayList<Person>) o;    
    //8.遍历ArrayList集合    
    for (Person person : list2) {        System.out.println(person);    }    
    //释放资源    
    ois.close();    
    oos.close();}

打印流

java.io.PrintStream extends OutputStream

PrintStream为其他输出流添加了功能,使他们能够方便地打印各种数据值表示形式.

PrintStream特点:1.只负责数据的输出,不负责数据的读取 2.与其他输出流不同,PrintStream永远不会抛出IOException

3.有特有的方法 void print(任意类型的值) void println(任意类型的值并换行)

printStream(File file)

printStream(OutputStream out)

printStream(String fileName)

如果使用父类的write()写数据,查看数据时查询编码表.如果使用特有print/println方法写数据,写的数据原样输出

可以改变输出语句的目的地(打印流的流向),输出语句默认在控制台输出,使用System.setout方法改变输出语句的目的地为参数传递中的打印流的目的地

static void setout(PrintStream out)