IO流(二)之字节流,字符流,对象流

一、字节流

1.通过字节流对文件进行读取

package com.wenhua.project.bytestream;

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


public class FileInDemo1 {
	public static void main(String[] args) throws IOException {

        // 封装文件，确保该文件存在
		FileInputStream fileInputStream = new FileInputStream("demo2.txt");

		int by = 0;
		// 读取 赋值 判断
		while ((by = fileInputStream.read()) != -1) {
			// 注意当为汉字时会出现乱码
			System.out.print((char) by);
		}

		fileInputStream.close();
	}
}

2.通过字节流对字符进行输出

package com.wenhua.project.bytestream;

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


public class FileOutDemo1 {
	public static void main(String[] args) throws IOException {
		
		/* 1.调用系统功能创建文件  
			2.创建fileOutputStream对象  
			3.把fileOutputStream对象指向这个文件*/
		FileOutputStream fileOutputStream = new FileOutputStream("wenhua.txt");
		/* 源码:
		public FileOutputStream(String name) throws FileNotFoundException {
		        this(name != null ? new File(name) : null, false);
		    }*/
		
		// 字节流写数据
		String string = "hello,io!";
		byte[] bs = string.getBytes();
		fileOutputStream.write(bs);
		
		// 高级记事本的换行是"\n"而window自带的换行是"\r\n"
		fileOutputStream.write("\n".getBytes());
	
		// 写int型数据
		fileOutputStream.write(97);// 97相应存储的是a

		fileOutputStream.write("\n".getBytes());
		// 输出97
		fileOutputStream.write(57);
		fileOutputStream.write(55);
		
		/* 关闭流对象释放资源
		 1.让流对象成为垃圾,及时回收,释放内存
		 2.通知系统去释放跟该文件相关的资源
		 3.避免其他流继续写数据*/
		fileOutputStream.close();
	}
}

3.单个字节流和数组进行复制效率

package com.wenhua.project.bytestream;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileArrayDemo1 {
	public static void main(String[] args) throws IOException {

		// 需要读取的文件对象(封装文件)
		FileInputStream fileInputStream = new FileInputStream("demo1.txt");

		// 需要存储数据的文件对象(封装文件)
        // 注意此处如果没有true，存入的内容会覆盖以前的内容
		FileOutputStream fileOutputStream = new FileOutputStream("demo2.txt", true);

		long m = System.currentTimeMillis();
		// 读写字节流
		byte[] bs = new byte[8192];// 最好是1024的倍数
		int length = 0;// 用来记录数组中的实际装入的字节长度
		while ((length = fileInputStream.read(bs)) != -1) {
			System.out.println(length);
			fileOutputStream.write(bs, 0, length);
		}
		System.out.println("通过数组复制总用时：" + (System.currentTimeMillis() - m));

		long mm = System.currentTimeMillis();
		int i = 0;
		while ((i = fileInputStream.read()) != -1) {
			fileOutputStream.write(i);
		}
		// 单个字节流复制用时长
		System.out.println("单个字节流复制总用时：" + (System.currentTimeMillis() - mm));

		// 关闭流对象
		fileInputStream.close();
		fileOutputStream.close();
	}
}

二、字符流

1、FileReader

read() 读取文件的字符的int值，没有了就返回-1

为保证流的关闭，异常处理必须使用try-catch-finally

本节编写的代码暂时不处理异常，只是描述具体操作的步骤

1、使用read()读取数据

//指明要操作的文件
File file = new File("hello.txt");
//创建具体流，将文件传入构造器
FileReader fr = new FileReader(file);
//读取操作
int date;
while((date = fr.eead()) != -1{
    System.out.println((char) date);
}
//关闭流
fr.close();

2、使用read(char[] cbuf)读取数据(效率高)

//使用read(char[] cbuf)来读取文件
File file = new File("hello.txt");
FileReader fr = new FileReader(file);

char[] cbuf = new char[5];	//提前声明一个char[] 每次往数组里面读取5个字符
int len;	//记录每次读入到cbuf中字符的个数
while ((len = fr.read(cbuf)) 1= -1){
    
    //用for循环读取
    for(int i = 0;i < len;i++){
        System.out.println(char[i]);
    }
    //将数组传入string的构造器中，输出string
    String str = new String(cbuf,0,len);
	System.out.println(str);
}

2、FileWriter

从内存写入内存到文件

说明：

​ 要写入的文件可以不存在，不存在的话会自己创建

​ 如果已经存在，分为两种情况（写入时到底是覆盖，还是追加）

  FileWriter的构造器
  FileWriter(File file)   默认是覆盖
  FileWriter(File file, boolean append)   声明为true追加、声明为false是覆盖

//一、声明要写入的文件
File file = new File("dream.txt");
//二、创建相关流
FileWriter fr = new FileWriter(file);
//三、写入操作
fr.write("i have a dream");
//四、关闭资源
fr.close();

3、字符文件的复制

//指明要操作的文件
File srcFile = new File("hello1.txt");		
File destFile = new File("hello2.txt");		//写入的文件可以不存在，不存在会自动创建

//创建相关流
FileReader fr = new FileReader(srcFile);
FileWriter fw = new FileWriter(destFile);

//读写操作
char[] cbuf = new char[1024];	//将字符先读取到这个数组
int len;	//记录每次读入字符数组的个数
while ((len = fr.read(cbuf)) != -1){	//当读取字符个数不是-1时，进入循环
    fw.write(cbuf,0,len);	//将字符数组的内容写入文件，从0开始，到len结束
}

//资源的关闭
fw.close();
fr.close();

4、转换流

转换流是处理流的一种，有两个分别是

InputStreamReader 将一个字节的输入流转化为字符的输入流

OutputStreamWriter 将一个字符的输出流转化为字节的输出流

/*
将输入的字节流转化为输入的字符流
*/
class Demo{
    
    //创建流
    FileInputStream fis = new FileInputStream("hello.txt");
    InputStreamReader isr = new InputStreamReader(fis);
    //读入操作
    int len;
    char[] buffer = new char[1024];
    while((len = isr.read(buffer)) != -1){
        String str = new String(buffer,0,len);
        System.ot.println(str);
    }
    //流的关闭
    fis.close();
    isr.close();
}

三、对象流

1.简历

涉及到的两个流 ObjectInputStream 和 ObjectOutputStream

这是用于存储和读取基本数据类型和对象的处理流，它的强大之处在于可以把Java中的对象写入到数据源，也能把对象从数据源还原回来

• 序列化：用 ObjectOutputStream 类保存基本数据类型或对象的机制
• 反序列化：用 ObjectInputStream 类读取基本数据类型和对象的机制

2.对象的序列化

对象的序列化机制允许将Java对象转化为与平台无关的二进制流，从而允许把这个二进制流永久性的存在磁盘上，或者通过网络讲这个二进制流传输到另一个网络节点，当其他程序获得了这个二进制流，就可以恢复对象