IO流

File类

1.如何创建File类的实例
File(String filePath)
File(String parentPath,String childPath)
File(File parentFile,String childPath)
2.路径：
相对路径：相较于某个路径下，指明的路径。
绝对路径：包含盘符在内的文件或文件目录的路径
3.路径分隔符
windows:\
unix:/

public String getAbsolutePath()：获取绝对路径
public String getPath() ：获取路径
public String getName() ：获取名称
public String getParent()：获取上层文件目录路径。若无，返回null
public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
public long lastModified() ：获取最后一次的修改时间，毫秒值

如下的两个方法适用于文件目录：
public String[] list() ：获取指定目录下的所有文件或者文件目录的名称数组
public File[] listFiles() ：获取指定目录下的所有文件或者文件目录的File数组

//递归搜索.java结尾的文件
public class dome3 {

    public static void main(String[] args) {
        File file = new File("D:\\Users\\YTFar\\IdeaProjects\\xuexi");
        dg(file);
    }

    private static void dg(File file) {
        //获取子文件或目录
        File[] files = file.listFiles();
        int num = 0;
        for (File files1 : files){
            if (files1.isFile()){
                if(files1.toString().toLowerCase().endsWith(".java")){
                    System.out.println(files1);
                }
            }else{
                dg(files1);
            }
        }
    }
}

IO流原理及流的分类

I/O是Input/Output的缩写，I/O技术是非常实用的技术，用于处理设备之间的数据传输。如读/写文件，网络通讯等。
Java程序中，对于数据的输入、输出操作以“流(stream)”的方式进行。
java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。

按操作数据单位不同分为：字节流(8 bit)，字符流(16 bit)
按数据流的流向不同分为：输入流，输出流
按流的角色的不同分为：节点流，处理流

 * 一、流的分类：
 * 1.操作数据单位：字节流、字符流
 * 2.数据的流向：输入流、输出流
 * 3.流的角色：节点流、处理流
 *
 * 二、流的体系结构
 * 抽象基类         节点流（或文件流）                               缓冲流（处理流的一种）
 * InputStream     FileInputStream   (read(byte[] buffer))        BufferedInputStream (read(byte[] buffer))
 * OutputStream    FileOutputStream  (write(byte[] buffer,0,len)  BufferedOutputStream (write(byte[] buffer,0,len) / flush()
 * Reader          FileReader (read(char[] cbuf))                 BufferedReader (read(char[] cbuf) / readLine())
 * Writer          FileWriter (write(char[] cbuf,0,len)           BufferedWriter (write(char[] cbuf,0,len) / flush()
 *

image.png

节点流（或文件流）

字符流

//文件复制
FileReader fr = null;
FileWriter fw = null;
try {
    //1.创建File类的对象，指明读入和写出的文件
    File srcFile = new File("123.txt");
    File destFile = new File("1234.txt");

    //不能使用字符流来处理图片等字节数据
    //File srcFile = new File("123.jpg");
    //File destFile = new File("1234.jpg");

    //2.创建输入流和输出流的对象
    fr = new FileReader(srcFile);
    fw = new FileWriter(destFile,true);//追加
    //fis = new FileInputStream(srcFile);
    //fos = new FileOutputStream(destFile);

    //3.数据的读入和写出操作
    char[] cbuf = new char[5];
    //byte[] bytes = new byte[5];
    int len;//记录每次读入到cbuf数组中的字符的个数
    while((len = fr.read(cbuf)) != -1){
        //String str = new String(cbuf,0,len);
        //System.out.print(str);
        //每次写出len个字符
        fw.write(cbuf,0,len);

    }
} catch (IOException e) {
    e.printStackTrace();
} finally {
    //4.关闭流资源
    try {
        if(fw != null) {
            fw.close();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    try {
        if(fr != null) {
            fr.close();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }

}

缓冲流

缓冲流：
作用：提供流的读取、写入的速度
提高读写速度的原因：内部提供了一个缓冲区
处理流，就是“套接”在已有的流的基础上
--> FileInputStream -- BufferedInputStream
--> FileOutSream -- BufferedOutStream
--> FileReader -- BufferedReader
--> FileWriter -- BufferedWriter

先关闭外层的流，在关闭内层的流
关闭外层流的同时，内层流也会自动地进行关闭。

BufferedReader br = null;
BufferedWriter bw = null;
try {
    //创建文件和相应的流
    br = new BufferedReader(new FileReader(new File("dbcp.txt")));
    bw = new BufferedWriter(new FileWriter(new File("dbcp1.txt")));

    //读写操作
    //方式一：使用char[]数组
//            char[] cbuf = new char[1024];
//            int len;
//            while((len = br.read(cbuf)) != -1){
//            bw.write(cbuf,0,len);
//            bw.flush();
//            }

    //方式二：使用String
    String data;
    while((data = br.readLine()) != null){
        //方法一：
//                bw.write(data + "\n");//data中不包含换行符
        //方法二：
        bw.write(data);//data中不包含换行符
        bw.newLine();//提供换行的操作
    }
} catch (IOException e) {
    e.printStackTrace();
} finally {
    //关闭资源
    if(bw != null){

        try {
            bw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    if(br != null){
        try {
            br.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

}

转换流

1.转换流：属于字符流
InputStreamReader：将一个字节的输入流转换为字符的输入流
OutputStreamWriter：将一个字符的输出流转换为字节的输出流
2.作用：提供字节流与字符流之间的转换

解码：字节、字节数组 --->字符数组、字符串
编码：字符数组、字符串 ---> 字节、字节数组

//1.造文件、造流
File file1 = new File("dbcp.txt");
File file2 = new File("dbcp_gbk.txt");

FileInputStream fis = new FileInputStream(file1);
FileOutputStream fos = new FileOutputStream(file2);

InputStreamReader isr = new InputStreamReader(fis,"utf-8");//解码
OutputStreamWriter osw = new OutputStreamWriter(fos,"gdk");//编码

//2.读写过程
char[] cbuf = new char[20];
int len;
while((len = isr.read(cbuf)) != -1){
    osw.write(cbuf,0,len);
}
//3.关闭资源
isr.close();
osw.close();
}

对象流

ObjectInputStream
ObjectOutputStream

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

序列化：用ObjectOutputStream类保存基本类型数据或对象的机制
反序列化：用ObjectInputStream类读取基本类型数据或对象的机制
ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量

/ 对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。//当其它程序获取了这种二进制流，就可以恢复成原来的Java对象。
/ 序列化的好处在于可将任何实现了Serializable接口的对象转化为字节数据，使其在保存和传输时可被还原
/ 序列化是 RMI（Remote Method Invoke – 远程方法调用）过程的参数和返回值都必须实现的机制，而 RMI 是 JavaEE 的基础。因此序列化机制是
JavaEE 平台的基础
/ 如果需要让某个对象支持序列化机制，则必须让对象所属的类及其属性是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一。否则，会抛出NotSerializableException异常
/ Serializable
/ Externalizable

* 对象流的使用
 * 1.ObjectInputStream 和 ObjectOutputStream
 * 2.作用：用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。
 *
 * 3.要想一个java对象是可序列化的，需要满足相应的要求。见Person.java
 *
 * 4.序列化机制：
 * 对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种
 * 二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。
 * 当其它程序获取了这种二进制流，就可以恢复成原来的Java对象。
/*
序列化过程：将内存中的java对象保存到磁盘中或通过网络传输出去
使用ObjectOutputStream实现
 */
@Test
public void testObjectOutputStream(){
    ObjectOutputStream oos = null;

    try {
        oos = new ObjectOutputStream(new FileOutputStream("object.dat"));
        oos.writeObject(new String("我爱北京天安门"));
        oos.flush();//刷新操作

        oos.writeObject(new Person("王铭",23));
        oos.flush();

        oos.writeObject(new Person("张学良",23,1001,new Account(5000)));
        oos.flush();

    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if(oos != null){
            try {
                oos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

/*
反序列化：将磁盘文件中的对象还原为内存中的一个java对象
使用ObjectInputStream来实现
 */
@Test
public void testObjectInputStream(){
    ObjectInputStream ois = null;
    try {
        ois = new ObjectInputStream(new FileInputStream("object.dat"));

        Object obj = ois.readObject();
        String str = (String) obj;

        Person p = (Person) ois.readObject();
        Person p1 = (Person) ois.readObject();

        System.out.println(str);
        System.out.println(p);
        System.out.println(p1);

    } catch (IOException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } finally {
        if(ois != null){
            try {
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量：

private static final long serialVersionUID;

时间：2019-12-14 09:00:02

IO流

File类

IO流原理及流的分类

节点流（或文件流）

缓冲流

转换流

对象流

你可能感兴趣的:(IO流)