IO流的知识点总结

File类的使用

• File能创建、删除、重命名文件和目录，但是File不能访问文件内容本身。想要访问文件内容本身就需要使用输入输出流
• 想要在java程序中表示一个真实的文件或者目录，那么就必须有一个File的对象，但是java程序中的一个File对象，可能没有一个真实存在的文件或者目录
• File类的获取：

• • File类的三种构造器

• • • public File(String pathname); //型参列表为文件的绝对路径或者相对路径
    • public File(String parent , String child ); //parent 为父路径 ， child为子路径创建File对象
    • public File（File parent ，String child ）； //根据一个父File对象 和子文件路径创建File 对象

• • 路径分隔符的使用

    

• File类常用的方法：

  

判断功能

IO流的原理及其流的分类

IO流体系

• 节点流（文件流）----直接操作文件的流

• • 读入文件
  • 操作步骤：
  • ①实例化File类的对象，指明要操作的文件
  • File file = new File(" 文件的路径");
  • ②提供具体的流————例如：FileReader fr = new FileReader ( file);
  • ③数据的读入read();

//读入一个字符，如果文件达到末尾，就返回-1
int data = fr.read();
while(data!= -1){
	System.out.println((char)data);
	data= fr.read();//这里和移动指针类似   
}

//这是最耗时间和资源的方法
//一般我们用这种方法
int len ;
char [] str = new char[13];
while((len= fr.read(str))!=-1){
	String s = new String(str,0,len);
	System.out.println(s);
}

          ④关闭流

• • 写出文件---从程序中向系统文件中写出数据
  • 操作步骤：（和上面的基本相同）

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

/**
 * 如果FileWriter中使用的构造器是FileWriter(file , flase)\FileWriter(file),就会对原有文件进行覆盖操作
 * 如果构造器使用的是FileWriter(file,true),则就不会对原有文件进行覆盖操作，而是在原有文件的基础上追加内容
 */
public class FileWriterTest {
    public static void main(String[] args) throws IOException {
        File file = new File("day15\\src\\hello1.txt");
        FileWriter fw = new FileWriter(file,false);//看上面的注解
        fw.write("my name\n");
        fw.write(" is xiaownag");
        fw.close();
    }
}

使用File类实现两个文件的复制，也就是将一个读出之后再写入到另一个里面

• 字符流-----实现非文本文件的流
• 实现图片文件的复制

图片底层是一种纯字节的形式，因此将底层改一改就可以了

将FileReader改成FileInputStream

具体源码实现

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

/**
 * 读入：将文件中的内容读入到程序中InputStream
 * 写出：将程序中的内容写出到文件中OutputStream
 */
public class FileInputStreamTest {
    public static void main(String[] args) {
        File file =new File("day16\\src\\Seek.png");
        File file1 =new File("day16\\src\\Seek1.png");//写出操作用到

        FileInputStream fis = null;//先Input.,先读入再写出
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream(file);
            fos = new FileOutputStream(file1);

            int len ;
            byte[] b = new byte[51];
            while((len = fis.read(b))!=-1){
                //String str = new String(b,0,len);
                fos.write(b,0,len);//这一步就可以直接复制
               // System.out.println(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if(fos!=null)
                    fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    if(fis!=null)
                        fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                }
            }
        }

    }
}

• 缓冲流-----提高流写入和读出的速度的流

操作顺序基本相同，只是其中几个细节不同

import java.io.*;

/**
 * 实现BufferReader和BufferWriter对文本文件的操作
 * 其中的重点就在于创建匿名类的操作，也就是造文件和造流的操作
 * BufferReader br = new bufferReader(new FileReader(new File("文件路径")));
 * BufferWriter bw = new BufferWriter(new FileWriter(new File("复制后的路径名程")))
 *
 */
public class BufferTest {
    public static void main(String[] args) {
        BufferedWriter bw = null;
        BufferedReader br =null;
        try {
            br = new BufferedReader(new FileReader(new File("day16\\src\\name.txt")));
            bw = new BufferedWriter(new FileWriter(new File("day16\\src\\name1.txt")));

            int len;
            char[] c = new char[13];
            while((len = br.read(c))!=-1){
                bw.write(c,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if(bw!=null)
                    bw.close();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    if(br!=null)
                         br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

• 转换流-----提供了字节流与字符流之间的相互转换
• 其中InputStreamReader用于将字节输入流转换为字符输入流，其中OutputStreamWriter用于将字节输出流转换为字符输出流

• • 当字节流中的数据都是字符时，转换为字符流时更加方便

1. 从字节流转换到字符流

2. 从字符流转换到字节流

• 其他标准输入输出流

从控制台输入内容之前的方法是使用Scanner，现在我们可以用System.in来实现

package com.Exer17.java;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class SystemTest {
    public static void main(String[] args) {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        //输入字符串
        while(true){
            System.out.println("请输入字符串：");
            String str = null;
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            if("e".equalsIgnoreCase(str)||"exit".equalsIgnoreCase(str)){
                System.out.println("程序结束！");
                break;
            }
            //将输入的内容全部大写
            String up = str.toUpperCase();
            System.out.println(up);
        }
    }
}

• 对象流-----对象的处理

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

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

（注意：他们两个不能序列化Static和transient修饰的成员变量）

• 对象的序列化机制

  

• 随机存取文件流【RandomAccessFile类】

RandomAccessFile类继承与Java.long.io，并且实现了两个接口DataInput，DataOutput；这就意味着这它既可以读也可以写，它支持”随机访问“的方式，意味着程序可以随即跳转到任意位置来进行读写操作

两个方法：

创建RandomAccessFile类的对象时，构造器中的另一个参数为mode，具体的mode有

具体操作的源码如下

package com.Exer17.java;


import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.charset.StandardCharsets;

/**
 * RandomAccessFile类及可以当作输入流，也可以当作输出流
 *
 *
 */
public class RandomAccessTest {
    public static void main(String[] args) throws IOException {
        RandomAccessFile raf = new RandomAccessFile("day17\\src\\base.txt","rw");

        raf.seek(6);
        //保存指针6后面的所有数据
        StringBuffer sb = new StringBuffer((int)(new File("base.txt").length()));//重定义数据大小为File文件的大小
        
        int len;
        byte[] bytes = new byte[10];
        while((len = raf.read(bytes))!=-1){
            String str = new String(bytes,0,len);
            sb.append(str);//存储str中的数据
        }
        //调回指针
        raf.seek(6);
        raf.write("123name".getBytes(StandardCharsets.UTF_8));

        raf.close();
    }
}