Java学习 --io流

filereader读入（从文件中读到程序中）数据的基本操作：

//1.实例化File类的对蒙，指明要操作的又件
File file = new File( pathname: "hello. txt");//相较于当前Module
//2.提供具体的流
FileReader fr = new FileReader(file);//文件一定要存在
//3.数据的读入
//read():返回读入的一一个字符。如果达到文件末尾，返回-1
//方式一:
int data = fr.read();
while(data != -1){//不是-1表示还有数据未读
	System. out. print((char)data);
	data = fr.read();
}
fr.close();//用完需要关闭资源

语法上进行改进

int data ;
while ((data = fr.read())！=-1）{
System.out.print((char)data);
}

异常处理， 直接抛出异常，容易导致资源未关闭，为了保证流资源一定可以执行关闭操作，需要使用try-catch-finally处理。

try{
File file = new File( pathname: "hello. txt");//相较于当前Module
//2.提供具体的流
FileReader fr = new FileReader(file);
int data;
while((data = fr.read()) != -1){//默认读一个字符
System. out. print( ( char)data);
} catch (IOException e) {
e. printStackTrace();
} finally {
//4.流的关闭操作
try {
if(fr!=null){
fr.close();
} catch (IOException e) {
e. printStackTrace();

每次读入多个（数目自定义）字符：

//3.读入的操作
//read(char[] cbuf): 返回每次读入cbuf数组中的字符的个数。如果龙
char[ ] cbuf = new char[5] ;//存放读入的数组
int len;
while((1en = fr.read(cbuf)) != -1){//len存放每次读的字符长度，当为-1时表示全部读完
for(int i = 0;i < 1en;i++){
	System. out . print(cbuf[i]);
}

//利用string类直接输出
String str = new String(cbuf, offset: 0,1en); 
System. out.print(str);

filewrite写出数据的操作
说明：如果不存在，会帮我们创建，
如果存在，如果参数设置为true,则不会覆盖原文件,会在原有文件基础上追加文件，默认为false会覆盖原文件

public void testFileWriter() throws IOException {
//1.提供File类的对象，指明写出到的文件
File file = new File( pathname: "he1lo1. txt");
//2.提供FileWriter的对象，用于数据的写出
FileWriter fw = new FileWriter(file，true);//文件不存在会自动帮我们创建
//3.写出的操作
fw.write( str: "I have a dream!");//不会自动换行，可以手动加换行
fw.write( str: "you need to have a dream!");
//4.流资源的关闭
fw.close();

使用 字符流 filewriter和filereader实现文本文件的复制

//1.创建File类的对象，指明读入和写出的文件
File srcFile = new File( pathname: "hello. txt");
File destFile = new File( pathname: "hello2.txt");
//2.创建输入流和输出流的对象
//字符流
FileReader fr = new FileReader(srcFile);
FileWriter fw = new FileWriter(destFile);
//3.数据的读入和写出操作
char[] cbuf = new char[5];
int len;// 记录每次读入到cbuf数组中的字符的个数
while((len = fr. read(cbuf)) != -1){
//每次写出Len个字符
fw.write(cbuf, off: 0,1en);//将读的内容写入另一个文件
}

// 字符流不能处理图片等字节数据

使用 字节流， FileInputStream和FileOutputStream读写非文本文件（例如图片），过程与上面类似。

处理流之一：缓冲流
套接在已有的流的基础上
BufferedInputStream
BufferedOutputStream（处理字节）
BufferedReader
BufferedWriter（处理字符）
作用：提升流的读取、写入的速度，原因：内部提供了一个缓冲区

//加快了文件复制速度
try {
//1.造文件
File srcFile = new File( pathname: "爱情与友情.jpg");
File destFile = new File( pathname: "爱情与友情3.jpg");
//2.造流
//2.1造节点流
FileInputStream fis = new FileInputStream( (srcFile));
FileOutputStream fos = new FileOutputStream(destFile);
//2.2造缓冲流
bis = new BufferedInputStream(fis);
bos = new BufferedoutputStream(fos );
//3.复制的细节:读取、入
byte[] buffer = new byte [10];
int 1en;
while((1en = bis.read(buffer)) != -1){
bos . write(buffer, off: 0,1en);
}

在利用缓冲流处理复制字符文件时，可以按行进行读取：
注意： 读取的每一行数据不包含换行符。

//方式二:使用String
String data;
while((data = br.readLine()) != nu11){
bw. write(data);//data中不包含换行符
bw.newline();// 手动加换行。

转换流
实现文件的读入和读出

//1.造文件、造流
File file1 = new File( pathname: "dbcp.txt");
File file2 = new File( pathname: "dbcp_ gbk. txt");
FileInputStream fis = new FileInputStream( file1);
File0utputStream fos = new File0utputStream(fi1e2);//字节流
InputStreamReader isr = new InputStreamReader(fis, charsetName: "utf-8") ;//编码
OutputStreamWriter OSW = new OutputStreamWriter( fos, charsetName: "gbk");//解码
//2.读写过程
char[] cbuf = new char[20];|
int 1en;
while((1en = isr.read(cbuf)) != -1){
osw. write(cbuf, off: 0,1en);
//3.关闭资源
isr . close();
osW. close( ):

标准的输入、输出流

BufferedReader br = nu11;
try {
InputStreamReader isr = new InputStreamReader(System. in);//system为字节流
br = new BufferedReader(isr);
while(true){
System. out.print1n("请输入字符串: ");
String pdata = br . readLine();//输入字符串
if("e".equalsIgnoreCase(data)|| " exit" . equalsIgnoreCase(data)){
System. out. print1n("程序结束");
break;
}
String upperCase = data. toUpperCase();
System. out . println(upperCase);
} catch (IOException e) {
e. printStackTrace();
} finally {
if(br != nu1l){ 

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

ObjectInputStream 和ObjectOutputStream

序列化机制：
对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。当其他程序获取了这种二进制流，就可以恢复成原来的java对象。

序列化过程: 将内存中的java对象保存到磁盘中或通过网络传输出去,使用ObjectOutputStream实现

objectOutputStream oos = new objectOutputStream(new. FileQutputStream( "a.dat");
oos . writeobject(new String( oriainal: "我爱北京天安门"))；
oos . flush();//刷新操作
oos .close();

反序列化过程 ：将磁盘文件中的对象还原为内存中的一个java对象

ObjectInputStream ois = new objectInputStream(new FileInputStream("a.dat")
Object obj = ois. readobject( );
String str = (String) obj ;
ois. close();

如果需要让某个对象支持序列化机制，则必须让对象所属的类及其属性是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一否则会抛出NotSerializableException异常
➢Serializable(当前类需提供一个全局变量：serialVersionUID),标识口。对象所在类要提供一个常量(序列版本号)->static final long serialVersionUID = - 3387516993124229948L ;
➢Externalizablel
ObjectOutputStream和objectInputStream不能序列化static transient修饰的成员变量

RandomAccessFile的使用

1. RandomAccessFile直接继承于java. lang. object类，实现了DataInput和DataOutput接口
2. RandomAccessFile既可以作为一个输入流，又可以作为一个输出流。

创建RandomAccessFile类实例需要指定一个mode参数，该参数指
定RaIndomAccessFile的访问模式:
➢r:以只读方式打开
➢rw:打开以便读取和写入
➢rwd:打开以便读取和写入;同步文件内容的更新
➢rws:打开以便读取和写入;同步文件内容和元数据的更新

对非字符文件的操作：

RandomAccessFile raf1 = new RandomAccessFile(new File( pathname: "0.jpg"), mode: "r");
RandomAccessFile raf2 = new RandomAccessFile(new File( pathname: "爱情1.jpg"), mode: "rw"); 
byte[] buffer = new byte[ 1024];
int 1en;
while((len = raf1.read(buffer)) != -1){
raf2. write(buffer, off: 0,1en);
}
raf1.close();
raf2.close();

对文本文件的写入
如果写出到的文件存在，则会对原有文件内容进行覆盖。(默认情况下， 从头覆盖）

RandomAccessFile raf1 = new RandomAccessFile( name: "hello. txt", mode: "rw")
raf1. write( "xyz" . getBytes());//需要传入byte类型的数组
raf1. close();

对文本文件从指定位置进行写入操作。
只需指定指针的位置即可，指针默认在文件的开头。

raf1.seek(3)//把指针位置调到角标为3的位置

如何实现数据的插入效果

RandomAccessFile raf1 = new RandomAccessFile( name: "hello.txt", mode: 
"rw")
raf1.seek( pos: 3);//将指针调到角标为3的位置
//保存指针3后面的所有数据到StringBuilder中
StringBuilder builder = new StringBuilder( (int) new File( pathname: "hello1");//指定长度
byte[] buffer = new byte[20];
int len;
while((l en = raf1. read(buffer)) != -1){
builder. append(new String(buffer, offset: 0,1en)) ;
}
//调回指针，写入“xyz”
raf1.seek( pos: 3);
raf1.write("xyz" . getBytes());
//将StringBuilder中的数据写入到文件中
raf1. write(builder . toString() . getBytes());
raf1. close();|