JAVA第十课 流

流

File类

1. 路径分隔符和系统有关：

• windows和DOS系统默认使用“\”来表示
• UNIX和URL使用“/”来表示

2. public static final String separator。根据操作系统，动态的提供分隔符。

File file1 = new File("d:\\atguigu\\info.txt");
File file2 = new File("d:" + File.separator +"atguigu"+ File.separator + "info.txt");
File file3 = new File("d:/atguigu");

3. File类的获取功能

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数组

4. file类的重命名功能

public boolean renameTo(File dest):把文件重命名为指定的文件路径

5. File类的判断功能

public boolean isDirectory()：判断是否是文件目录
public boolean isFile() ：判断是否是文件
public boolean exists() ：判断是否存在
public boolean canRead() ：判断是否可读
public boolean canWrite() ：判断是否可写
public boolean isHidden() ：判断是否隐藏

6. File类的创建功能

public boolean createNewFile() ：创建文件。若文件存在，则不创建，返回false
public boolean mkdir() ：创建文件目录。如果此文件目录存在，就不创建了。
如果此文件目录的上层目录不存在，也不创建。  
public boolean mkdirs() ：创建文件目录。如果上层文件目录不存在，一并创建

注意事项：如果你创建文件或者文件目录没有写盘符路径，那么，默认在项目路径下。 

7. File类的删除功能

public boolean delete()：删除文件或者文件夹

删除注意事项：Java中的删除不走回收站。 要删除一个文件目录，请注意该文件目录内不能包含文件或者文件目录

流的分类

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

(抽象基类)	字节流	字符流
输入流	InputStream	Reader
输出流	OutputStream	Writer

• Java的IO流共涉及40多个类，实际上非常规则，都是从如下4个抽象基类派生的。
• 由这四个类派生出来的子类名称都是以其父类名作为子类名后缀。
  

流的体系

字符流读写

字符流适合对文本文件进行读写但是能读写图像或视频

@Test
public void testFileReaderFileWriter() {
        FileReader fr = null;
        FileWriter fw = null;
        try {
            //1.创建File类的对象，指明读入和写出的文件
            File srcFile = new File("hello.txt");
            File destFile = new File("hello2.txt");
            //不能使用字符流来处理图片等字节数据
//            File srcFile = new File("爱情与友情.jpg");
//            File destFile = new File("爱情与友情1.jpg");
            //2.创建输入流和输出流的对象
            fr = new FileReader(srcFile);
            fw = new FileWriter(destFile);
            //3.数据的读入和写出操作
            char[] cbuf = new char[5];
            int len;//记录每次读入到cbuf数组中的字符的个数
            while((len = fr.read(cbuf)) != -1){
                //每次写出len个字符
                fw.write(cbuf,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭流资源
            //方式一：
//            try {
//                if(fw != null)
//                    fw.close();
//            } catch (IOException e) {
//                e.printStackTrace();
//            }finally{
//                try {
//                    if(fr != null)
//                        fr.close();
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            }
            //方式二：
            try {
                if(fw != null)
                    fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(fr != null)
                    fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

字节流读写

字节流适合图像或视频的读取，如果要输出在控制台就不适合文本文件的读写（因为可能出现乱码），如果只进行复制可以使用。

/*
实现对图片的复制操作
 */
@Test
public void testFileInputOutputStream()  {
    FileInputStream fis = null;
    FileOutputStream fos = null;
    try {
        //
        File srcFile = new File("爱情与友情.jpg");
        File destFile = new File("爱情与友情2.jpg");
        //
        fis = new FileInputStream(srcFile);
        fos = new FileOutputStream(destFile);

        //复制的过程
        byte[] buffer = new byte[5];
        int len;
        while((len = fis.read(buffer)) != -1){
            fos.write(buffer,0,len);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if(fos != null){
            //
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if(fis != null){
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

处理流之一：缓冲流的使用

1. 缓冲流：

• BufferedInputStream
• BufferedOutputStream
• BufferedReader
• BufferedWriter

2. 作用：提供流的读取、写入的速度
   提高读写速度的原因：内部提供了一个缓冲区

3. 处理流，就是“套接”在已有的流的基础上。

实现非文本文件的复制

public class BufferedTest {
      @Test
    public void BufferedStreamTest()  {
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            //1.造文件
            File srcFile = new File("爱情与友情.jpg");
            File destFile = new File("爱情与友情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 len;
            while((len = bis.read(buffer)) != -1){
                bos.write(buffer,0,len);
//                bos.flush();//刷新缓冲区
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.资源关闭
            //要求：先关闭外层的流，再关闭内层的流
            if(bos != null){
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(bis != null){
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
          //说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略.
//        fos.close();
//        fis.close();
        }
    }

使用BufferedReader和BufferedWriter实现文本文件的复制

   @Test
    public void testBufferedReaderBufferedWriter(){
        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. 转换流提供了在字节流和字符流之间的转换
   Java API提供了两个转换流：

• InputStreamReader：将InputStream转换为Reader
• OutputStreamWriter：将Writer转换为OutputStream

2. 字节流中的数据都是字符时，转成字符流操作更高效。 
   很多时候我们使用转换流来处理文件乱码问题。实现编码和
   解码的功能。
   

@Test
public void testInputStreamReaderOutputStreamWriter() {
    InputStreamReader isr=null;
    OutputStreamWriter osw=null;
    try {
        //1.造文件、造流
        File file1 = new File("dbcp.txt");
        File file2 = new File("dbcp_gbk.txt");
        FileInputStream fis = null;
        fis = new FileInputStream(file1);
        FileOutputStream fos = new FileOutputStream(file2);
        isr = new InputStreamReader(fis, "utf-8");
        osw = new OutputStreamWriter(fos, "gbk");
        //2.读写过程
        char[] cbuf = new char[20];
        int len;
        while ((len = isr.read(cbuf)) != -1) {
            osw.write(cbuf, 0, len);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        //3.关闭资源
        try {
            isr.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            osw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Object流

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

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

3. ObjectOutputStream和ObjectInputStream不能序列化static和transient修
   饰的成员变量
4. 对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从
   而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传
   输到另一个网络节点。//当其它程序获取了这种二进制流，就可以恢复成原
   来的Java对象
5. 序列化的好处在于可将任何实现了Serializable接口的对象转化为字节数据，
   使其在保存和传输时可被还原
6. 凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量：

• private static final long serialVersionUID;
• serialVersionUID用来表明类的不同版本间的兼容性。简言之，其目的是以序列化对象
  进行版本控制，有关各版本反序列化时是否兼容。

7. 如果类没有显示定义这个静态常量，它的值是Java运行时环境根据类的内部细节自
   动生成的。若类的实例变量做了修改，serialVersionUID 可能发生变化。故建议，
   显式声明。

  序列化
1.创建一个 ObjectOutputStream
2.调用 ObjectOutputStream 对象的 writeObject(对象) 方法输出可序列化对象
3.注意写出一次，操作flush()一次
  4.close()
反序列化
1. 创建一个 ObjectInputStream
2. 调用 readObject() 方法读取流中的对象
强调：如果某个类的属性不是基本数据类型或 String 类型，而是另一个引用类型，那么这个引用类型必须是可序列化的，否则拥有该类型的Field 的类也不能序列化
 3. close()

//序列化：将对象写入到磁盘或者进行网络传输。
//要求对象必须实现序列化
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(“data.txt"));
Person p = new Person("韩梅梅", 18, "中华大街", new Pet());
oos.writeObject(p);
oos.flush();
oos.close();
//反序列化：将磁盘中的对象数据源读出。
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(“data.txt"));
Person p1 = (Person)ois.readObject();
System.out.println(p1.toString());
ois.close();