File类，字节字符输入输出流，缓冲流，标准流，对象序列化流

cqq00

已于 2022-07-11 17:21:27 修改

阅读量436

点赞数

分类专栏： java基础文章标签： java 开发语言

于 2022-05-08 22:44:14 首次发布

本文链接：https://blog.csdn.net/cqq00/article/details/124645194

版权

java基础专栏收录该内容

10 篇文章 0 订阅

订阅专栏

一，File文件类

1

File类创建功能:
   public boolean createNewFiLe():当具有该名称的文件不存在时，创建一个由该抽象路径名命名的新空文件
      如果文件不存在,就创建文件,并返回true
      如果文件存在，就不创建文件，并返回false
public boolean mkdir():创建由此抽象路径名命名的目录
      如果目录不存在,就创建文件，并返回true
      如果文件存在，就不创建文件，并返回false
public boolean mkdirs ()。创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录
       如果目录不存在,就创建文件，并返回true
如果文件存在，就不创建文件，并返回false

public class FileDemo {
    public static void main(String[] args) throws IOException {
        //需求1：在D:\\xuexi\\file目录下创建一个文件java.txt
        File f1 = new File("D:\\xuexi\\file\\java.txt");
        System.out.println(f1.createNewFile());
        //需求2:在D:\\xuexi\\file目录下创建一个目录javase
        File f2 = new File("D:\\xuexi\\file\\javase");
        System.out.println(f2.mkdir());
        //需求3：在D:\\xuexi\\file目录下创建一个多级目录JavaWeb\\HTML
        File f3 = new File("D:\\xuexi\\file\\JavaWeb\\HTML");
        System.out.println(f3.mkdirs());
    }
}

2

File:文件和目录路径名的抽象表示
    1文件和目录是可以通过FiLe封装成对象的
    2:对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以是不存在的。
      将来是要通过具体的操作把这个路径的内容转换为具体存在的
构造方法:
    File(String pathname):通过将给定的路径名字符串转换为抽象路径名来创建新的FiLe实例。
    FiLe(String parent，String child):从父路径名字符串和子路径名字符串创建新的File实例。
    File(File parent，string child):从父抽象路径名和子路径名字将串创建新的File实例。

public class FileDemo01 {
    public static void main(String[] args) {
        //File(String pathname):通过将给定的路径名字符串转换为抽象路径名来创建新的FiLe实例。
        File f1 = new File("D:\\xuexi\\java.txt");
        System.out.println(f1);
        //FiLe(String parent，String child):从父路径名字符串和子路径名字符串创建新的File实例。
        File f2 = new File("D:\\xuexi","java.txt");
        System.out.println(f2);
        //File(File parent，string child):从父抽象路径名和子路径名字将串创建新的File实例。
        File f3 = new File("D:\\xuexi");
        File f4 = new File(f3,"java.txt");
        System.out.println(f4);
    }
}

3

File类的判断和获取功能:
public boolean isDirectory():测试此抽象路径名表示的FiLe是否为目录
public boolean isFile():测试此抽象路径名表示的FilLe是否为文件
public boolean exists()。测试此抽象路径名表示的FiLe是否存在

public String getAbsoLutePath():返回此抽象路径名的绝对路径名字符串
public String getPath()。将此抽象路径名转换为路径名字符串
public string getName()。返回由此抽象路径名表示的文件或自录的名称

public String[ ] list()，返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
public File[] listFiles( ),返回此抽象路径名表示的目录中的文件和目录的FiLe对象数组

public class FileDemo03 {
    public static void main(String[] args) throws IOException {
        //创建一个file对象
        File f1 = new File("D:\\xuexi\\myFile\\java.txt");
        System.out.println(f1.createNewFile());
        // public boolean isDirectory():测试此抽象路径名表示的FiLe是否为目录
        // public boolean isFile():测试此抽象路径名表示的FilLe是否为文件
        //public boolean exists()。测试此抽象路径名表示的FiLe是否存在
        System.out.println(f1.isFile());
        System.out.println(f1.isDirectory());
        System.out.println(f1.exists());
        System.out.println("--------");
        //public String getAbsoLutePath():返回此抽象路径名的绝对路径名字符串
        //public String getPath()。将此抽象路径名转换为路径名字符串
        //public string getName()。返回由此抽象路径名表示的文件或自录的名称
        System.out.println(f1.getAbsoluteFile());
        System.out.println(f1.getPath());
        System.out.println(f1.getName());
        System.out.println("--------");
//        System.out.println(f1.delete());
        //public String[] list()，返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
        //public File[] listFiles( ),返回此抽象路径名表示的目录中的文件和目录的FiLe对象数组
        File f2  = new File("D:\\xuexi\\file");
        String[] list = f2.list();
        for(String s : list){
            System.out.println(s);
        }
        System.out.println("--------");
        File[] files = f2.listFiles();
        for(File file : files){
            if(file.isFile()){
                System.out.println(file.getName());
            }
        }
    }
}

4

File类删除功能:
public boolean delete()。册除由此抽象路径名表示的文件或目录
删除目录时的注意事项:
如果一个目录中有内容(目录，文件)，不能直接删除。应该先删除目录中的内容，最后才能删除目录

public class FileDemo04 {
    public static void main(String[] args) throws IOException {
        //需求1：在当前模块目录下创建java.txt文件
        File f1 = new File("java.txt");
        System.out.println(f1.createNewFile());
        //需求2：删除当前模块目录下的java.txt文件
        System.out.println(f1.delete());
        System.out.println("---------");
        //需求3：在当前模块目录下创建itcast目录
        File f2 = new File("itcast");
//        System.out.println(f2.mkdir());
        //需求4：删除当前模块目录下的itcast目录
        System.out.println(f2.delete());
        System.out.println("---------");
        //需求5：在当前模块下创建一个目录itcast，然后在该目录下创建一个文件java.txt
        File f3 = new File("itcast");
        System.out.println(f3.mkdir());
        File f4 = new File("itcast\\java.txt");
        System.out.println(f4.createNewFile());
        //需求6:删除当前模块下的目录itcast
        System.out.println(f3.delete());
        System.out.println(f4.delete());
    }
}

二，字节流

字节输出流

1

FiLeOutputStream:文件输出流用于将数据写入file
FiLeOutputStream (String name):创建文件输出流以指定的名称写入文件

public class FileOutputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");
        //void write (int a),将指定的字节写入此文件输出流
        fos.write(98);//会转换为字符
        fos.write(57);
        fos.write(56);
        //最后都要释放资源
        //void close():关闭此文件输出流并释放与此流相关联的任何系统资源
        fos.close();
    }
}

2

构造方法:
FiLeOutputStream (String name)，创建文件输出流以指定的名称写入文件
FiLeOutputStream (File file)创建文件输出流以写入由指定的File对象表示的文件
两个方法相同第一个更简单
写数据的三种方式;
   void write (int b):将指定的字节写入此文件输出流
      —次写一个字节数据
   void write (byte[] b):将b.Length字节从指定的字节数组写入此文件输出流
      —次写一个字节数组数据
   void write(byte[] b, int off, int len)：将len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流
      —次写一个字节数组的部分数据

public class FileOutputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //FiLeOutputStream (String name)，创建文件输出流以指定的名称写入文件
        FileOutputStream fos = new FileOutputStream("java,txt");
        //void write (int b):将指定的字节写入此文件输出流
        /*fos.write(97);
        fos.write(98);
        fos.write(99);
        fos.write(100);
        fos.write(101);*/
        //void write (byte[] b):将b.Length字节从指定的字节数组写入此文件输出流
//        byte[] bys = {97,98,99,100,101,102};
        //byte[] getBytes (): 返回字符串对应的字节数组
        byte[] bys = "abcdefg".getBytes();
//        fos.write(bys);
        //void write(byte[] b, int off, int len)：将len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流
        fos.write(bys,1,2);
        //关闭资源
        fos.close();
    }
}

3

字节流写数据的两个小问题:
1:字节流写数据如何实现换行呢?
     写完数据后加入换行符
       window :\r\n
       Linux:\n
       mac:\r
2:字节流写数据如何实现追加写入呢?
    public FiLeOutputStream ( String name , booLean append )
       创建文件输出流以指定的名称写入文件。
       如具第二个参数为true ，则字节将写入文件的末尾而不是开头

public class FileOutputStreamDemo03 {
    public static void main(String[] args) throws IOException {
        //创建字节流输出对象
        FileOutputStream fos = new FileOutputStream("java.txt",true);
        //写数据
        for(int x = 0; x < 10; x++){
            fos.write("hello".getBytes());
            fos.write("\r\n".getBytes());
        }
        //释放资源
        fos.close();
    }
}

4

字节流数据加入异常处理

public class FileOutputStreamDemo04 {
    public static void main(String[] args) {
        //加入finally来实现释放资源
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("java.txt");
            fos.write("hello".getBytes());
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

字节输入流

1

需求：

把文件java.txt中的内容读取出来在控制台输出 (一次读一个字节)

使用字节输入流读数据的步骤:
   1:创建字节输人流对象
   2:调用字节输入流对象的读数据方法
   3:释放资源

public class FileInputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //创建字节输人流对象
        FileInputStream fis = new FileInputStream("java.txt");

        //调用字节输入流对象的读数据方法
        //int read():从该输入流读取一个字节的数据

        //第一次读取数据
       /* int by = fis.read();
        System.out.println(by);
        System.out.println((char)by);
        //第二次读取数据
        by = fis.read();
        System.out.println(by);
        System.out.println((char)by);
        //再多读取两次
        by = fis.read();
        System.out.println(by);
        by = fis.read();
        System.out.println(by);
        //如果到达文件末尾，输出-1*/

        //使用循环读取文件
        int by ;
        while ((by = fis.read()) != -1){
            System.out.print((char) by);
        }
        //释放资源
        fis.close();
    }
}

2

需求:把文件fos.txt中的内容读取出来在控制台输出(一次读一个字节数组数据)

使用字节输入流读数据的步骤;
1:创建字节输入流对象
2:调用字节输入流对象的读数据方法
3:释放资源

public class FileInputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        FileInputStream fis = new FileInputStream("java.txt");
        //调用字节输入流对象的读数据方法
        //int read (byte[] b):从该输入流读取最多b.length个字节的数据到一个字节数组
        /*byte[] bys = new byte[5];
        //第一次读取数据
        int len = fis.read(bys);
        System.out.println(len);
        System.out.println(new String(bys,0,len));

        //第二次读取数据
         len = fis.read(bys);
        System.out.println(len);
        System.out.println(new String(bys,o,len));

        //第三次读取数据
         len = fis.read(bys);
        System.out.println(len);
        System.out.println(new String(bys,0,len));

        //多次读取数据
        len = fis.read(bys);
        System.out.println(len);
        len = fis.read(bys);
        System.out.println(len);

         */
        /*
           hello\r\n
           java\r\n
           第一次：hello
           第二次：\r\njav
           第三次;a\r\nav
         */
        byte[] bys = new byte[1024];//1024及其整数倍
        int len;
        while ((len = fis.read(bys)) != -1){
            System.out.print(new String(bys,0,len));
        }
        //释放资源
        fis.close();
    }
}

字节缓冲流

字节缓冲流;
BufferOutputStream
BufferedInputStream
构造方法:
字节缓冲输出流:BufferedOutputStream (OutputStream out)
字节缓冲输八流:BufferedInputStream (inputStream in)

public class BufferStreamDemo {
    public static void main(String[] args) throws IOException {
        //字节缓冲输出流:BufferedOutputStream (OutputStream out)
        /*FileOutputStream fos = new FileOutputStream("java.txt");
        BufferedOutputStream bis = new BufferedOutputStream(fos);*/
      /*  BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("java.txt"));
        //写数据
        bos.write("dashabi\r\n".getBytes());
        bos.write("das\r\n".getBytes());
        //释放资源
        bos.close();*/

      //字节缓冲输八流:BufferedInputStream (inputStream in)
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("java.txt"));
        /*//一次读一个
        int by;
        while ((by = bis.read())  != -1){
            System.out.print((char)by);
        }*/
        //一次度一组
        byte[] bys = new byte[1024];
        int len;
        while ((len = bis.read(bys)) != -1){
            System.out.println(new String(bys,0,len));
        }
        //释放资源
        bis.close();
    }
}

练习

/*
    需求:
      把D:\1\33.png复制到模块目录下的33.png
   思路:
     1:根据数据源创建字节输入流对象
     2:根据目的地创建字节输出流对象
     3:读写数据，复制图片(一次读取一个字节数组，一次写入一个字节数组)
     4 :释放资源

 */
public class CopyPhotoTest {
    public static void main(String[] args) throws IOException {
        //1:根据数据源创建字节输入流对象
        FileInputStream fis = new FileInputStream("D:\\1\\33.png");
        //根据目的地创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("33.png");
        //读写数据，复制图片(一次读取一个字节数组，一次写入一个字节数组)
        byte[] bys = new byte[1024];//1024及其整数倍
        int len;
        while ((len = fis.read(bys)) != -1){
           fos.write(bys,0,len);
        }
        //释放资源
        fis.close();
        fos.close();
    }
}

/*
   需求：把"11.txt"文件内容复制到"2.txt"
   思路:
      1:根据数据源创建字节输入流对象
      2:根据目的地创建字节输出流对象
      3:读写数据,复制文本艾件(一次读取一个字节，一次写入一个字节)
      4:释故资源

 */
public class CopyTxtDemo {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字节输入流对象
        FileInputStream fis = new FileInputStream("D:\\1\\11.txt");
        //根据目的地创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("D:\\1\\2.txt");
        //读写数据,复制文本艾件(一次读取一个字节，一次写入一个字节)
        int by;
        while ((by = fis.read()) != -1){
            fos.write(by);
        }
        //释放资源
        fis.close();
        fos.close();

    }
}

/*
  字节缓冲流复制图片
   思路:
      1:根据数据源创建字节输入流对象
      2:根据目的地创建字节输出流对象
      3:读写数据,复制图片(一次读取一个字节数组，一次写入一个字节数组)
      4:释放资源
  四种方式实现复制视须,并记录每种方式复制视频的时间
      1:基本字节流一次读写—个字节
      2:基本字节流一次读写一个字节数组
      3:字节缓冲流一次读写一个字节
      4:字节缓冲流—次读写一个字节数组

 */
public class BufferStreamTest {
    public static void main(String[] args) throws IOException {
        //记录开始时间
        long startTime = System.currentTimeMillis();
        //复制视频
//        method1();//10171毫秒
//        method2();//10454毫秒
//          method3();//44ms
         method4();//333ms
        //记录结束时间
        long endTime = System.currentTimeMillis();
        System.out.println("共耗时" + (endTime - startTime) + "毫秒");
    }

    //基本字节流一次读写一个字节
    public static void method1() throws IOException{
        FileInputStream fis = new FileInputStream("D:\\1\\33.png");
        FileOutputStream fos = new FileOutputStream("2.png");
        int by;
        while ((by = fis.read()) != -1){
            fos.write(by);
        }
        fis.close();
        fos.close();
    }

    //基本字节流一次读写—个字节数组
     public static void method2() throws IOException{
         FileInputStream fis = new FileInputStream("D:\\1\\33.png");
         FileOutputStream fos = new FileOutputStream("1.png");
         byte[] bys = new byte[1024];
         int len;
         while ((len = fis.read()) != -1){
             fos.write(bys,0,len);
         }
         fis.close();
         fos.close();
     }

     //字节缓冲流一次读写一个字节
     public static void method3() throws IOException{
         BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\1\\33.png"));
         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("3.png"));
         int by;
         while ((by = bis.read()) != -1){
             bos.write(by);
         }
         bis.close();
         bos.close();
     }
     //字节缓冲流—次读写一个字节数组:
    public static void method4() throws IOException{
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\1\\33.png"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("4.png"));
        byte[] bys = new byte[1024];
        int len;
        while ((len = bis.read()) != -1){
            bos.write(bys,0,len);
        }
        bis.close();
        bos.close();
    }
}

三，字符流

1

编码:
   byte[ ] getBytes()﹔使用平台的默认字符集将该string编码为一系列字节，将结果存储到新的字节数组中
   byte[ ] getBytes(String charsetName)。使用指定的字符集将该string编码为一系列字节，将结果存储到新的字节数组中
解码:
   String(byte[ ] bytes):通过使用平台的默认字符集解码指定的字节数组来构造新的 String
   String(byte[ ] bytes，String charsetName ):通过指定的字符集解码指定的字节数组来构造新的string
   用什么方法编码就要用什么方法解码

public class StringDemo {
    public static void main(String[] args) throws UnsupportedEncodingException {
        //定义一个字符串
        String s = "中国";
        //编码
        //  byte[ ] getBytes()﹔使用平台的默认字符集将该string编码为一系列字节，将结果存储到新的字节数组中
       byte[] bys = s.getBytes();//[-28, -72, -83, -27, -101, -67]
        //byte[ ] getBytes(String charsetName)。使用指定的字符集将该―string编码为一系列字节，将结果存储到新的字节数组中
//        byte[] bys = s.getBytes("UTF-8");//[-28, -72, -83, -27, -101, -67]
//        byte[] bys = s.getBytes("GBK");//[-42, -48, -71, -6]
        System.out.println(Arrays.toString(bys));

        //解码
        //String(byte[ ] bytes):通过使用平台的默认字符集解码指定的字节数组来构造新的 String
//        String ss = new String(bys);
        //String(byte[ ] bytes，String charsetName ):通过指定的字符集解码指定的字节数组来构造新的string
        String ss = new String(bys,"GBK");
        System.out.println(ss);
    }
}

2 字符输入流

构造方法:
   InputStreamReader (InputStream in)。创建一个使用默认字符集的InputStreamReader
读教据的2种方式:
   int read :—次读—个字符数据
   int read ( char[] cbuf)。—次读一个字符数组数据

public class InputStreamReadDemo {
    public static void main(String[] args) throws IOException {
        //InputStreamReader (InputStream in)。创建一个使用默认字符集的InputStreamReader
        InputStreamReader isr = new InputStreamReader(new FileInputStream("java.txt"));
        //int read :—次读—个字符数据
       /* int ch;
        while ((ch = isr.read()) != -1){
            System.out.print((char)ch);
        }*/
        //int read ( char[] cbuf)。—次读一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while ((len = isr.read(chs)) != -1){
            System.out.println(new String(chs,0,len));
        }
        //释放资源
        isr.close();

    }
}

3 字符输出流

构造方法:
   OutputStreamWriter (OutputStream out)、创建一个使用默认字符编码的outputStreamWriter
写数据的4种方式:
   void write (int c):写一个字符
   void write ( char[ ]cbuf)。写入一个字符数组
   void write (char[ ]cbuf, int off, int len)。写入字符数组的一部分
   void write (String str)。写一个字符串
   void write (String str, int off , int len)。写一个字符串的一部分

public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException {
        //OutputStreamWriter (OutputStream out)、创建一个使用默认字符编码的outputStreamWriter
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("java.txt"));

      /*  //void write (int c):写一个字符
        osw.write(97);
        //void flush() 刷新信息
        osw.flush();
        osw.write(98);

        osw.close();*/
        //void write ( char[ ]cbuf)。写入一个字符数组
        char[] chs = {'a','b','c','d','e'};
//        osw.write(chs);
        //void write (char[ ]cbuf, int off, int len)。写入字符数组的一部分
//        osw.write(chs,0,1);
        //void write (String str)。写一个字符串
//        osw.write("abcde");
        //void write (String str, int off , int len)。写一个字符串的一部分
        osw.write("abcde",1,2);
        //释放资源
        osw.close();

    }
}

  InputStreamReader是从字节流到字符减的桥梁
     它读取字节,并使用指定的编码将其解码为宁符
     它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集
OutputStreamWriter:是从字符流到字节流的桥梁
      是从字符流到字节流的桥梁,使用指定的编码将写入的字符编码为字节
     它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集

public class ConversionStreamDemo {
    public static void main(String[] args) throws IOException {
        //OutputStreamWriter (OutputStream out)创建一个使用默认字符绵码的outputStreamWriter。
        //OutputStreamWriter (OutputStream out,String charsetName)创建一个使用命名字符集的OutputStreamWriter。
//        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("java.txt"));
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("java.txt"),"GBK");
        osw.write("中国");
        osw.close();
        //InputStreamReader (InputStream in)创建一个使用默认字符集的InputStreamReader。
        //InputStreamReader (InputStream in，String charsetName)创建一个使用命名字符集的InputStreamReader。
//        InputStreamReader isr = new InputStreamReader(new FileInputStream("java.txt"));
        InputStreamReader isr = new InputStreamReader(new FileInputStream("java.txt"),"GBK");
        int ch;
        while ((ch = isr.read()) != -1){
            System.out.print((char)ch);
        }
        isr.close();
    }
}

4 字符缓冲流

字符缓冲流:
BufferedWriter:将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可以指定缓冲区大小，或者可以接受默认大小。默认值足够大，可用于大多数用途
BufferedReader:从字符输入流读取文本，缓冲字符,以提供字符，数组和行的高效读取，可以靛缓冲区大小。或者可以使用默认大小。默认值足够大，可用于大多数用途
构造方法:
BufferedWriter(Writer out)
BufferedReader( Reader in)

public class BufferedStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //BufferedWriter(Writer out)
        /*BufferedWriter bw = new BufferedWriter(new FileWriter("java.txt"));
        bw.write("hello\r\n");
        bw.write("word\r\n");
        bw.close();*/
        //BufferedReader( Reader in)
        BufferedReader br = new BufferedReader(new FileReader("java.txt"));
        //一次读一个字符
        /*int ch;
        while ((ch = br.read()) != -1){
            System.out.print((char)ch);
        }*/
        //一次读一个字符数组
        char[] chs = new char[1024];
        int len;
        while ((len = br.read(chs)) != -1){
            System.out.println(new String(chs,0,len));
        }
    }
}

字符缓冲流的特有功能
BufferedWriter:
        void newLine():写一行行分隔符，行分隔符字符串由系统属性定义
BufferedReader:
        public String readline()。读一行文字。
          结果包含行的内容的字符串，不包括任何行终止字符，如果流的结尾已经到达，则为null

public class BufferedStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //创建字符输出流
        BufferedWriter bw = new BufferedWriter(new FileWriter("java.txt"));;
        //写数据
        for(int x = 0; x < 10; x++){
            bw.write("hello" + x);
            bw.newLine();
            bw.flush();
        }
        //释放资源
        bw.close();

        //创建字符输入流
        BufferedReader br = new BufferedReader(new FileReader("java.txt"));
        //读数据
        String line;
        while ((line = br.readLine()) != null){
            System.out.println(line);
        }
        //释放资源
        br.close();
    }
}

复制文件异常处理

public class CopyFileDemo {
    public static void main(String[] args) {

    }
    //jdk9
    private static void method4() throws IOException{
        FileReader fr = new FileReader("fr.txt");
        FileWriter fw = new FileWriter("fw.txt");
        try (fr;fw){
            char[] chs = new char[1024];
            int len;
            while ((len = fr.read()) != -1){
                fw.write(chs,0,len);
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }


    //jdk7
    private static void method3(){
        try(FileReader fr = new FileReader("fr.txt");
            FileWriter fw = new FileWriter("fw.txt");) {
            char[] chs = new char[1024];
            int len;
            while ((len = fr.read()) != -1){
                fw.write(chs,0,len);
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }


    //try...catch...finally
    private static void method2(){
        FileReader fr = null;
        FileWriter fw = null;
        try {
        fr = new FileReader("fr.txt");
        fw = new FileWriter("fw.txt");
        char[] chs = new char[1024];
        int len;
        while ((len = fr.read()) != -1){
            fw.write(chs,0,len);
        }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try {
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
    //抛出处理
    /*private static void method1() throws IOException{
        FileReader fr = new FileReader("fr.txt");
        FileWriter fw = new FileWriter("fw.txt");
        char[] chs = new char[1024];
        int len;
        while ((len = fr.read()) != -1){
            fw.write(chs,0,len);
        }
        fr.close();
        fw.close();
    }*/
}

5 练习


/*
    需求:
      把模块目录下的ConversionStreamDemo.java复制到模块目录下的Copy.java
    思路:
      1 :根据数据源创建字符输入流对象
      2:根据目的地创建字符输出流对象
      3:读写数据,复制文件
      4:释放资源

 */
public class CopyJavaDemo01 {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字符输入流对象
        InputStreamReader isr = new InputStreamReader(new FileInputStream("ConversionStreamDemo.java"));
        //根据目的地创建字符输出流对象
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("Copy.java"));
        //读写数据,复制文件
        //一次读写一个字符数据
       /* int ch;
        while ((ch = isr.read()) != -1){
            osw.write(ch);
        }*/
        //一次读写一个字符组数据
        char[] chs = new char[1024];
        int len;
        while ((len = isr.read(chs)) != -1){
            osw.write(chs,0,len);
        }
        //释放资源
        isr.close();
        osw.close();
    }
}

/*
   需求:
       把模块目录下的ConversionStreamDemo.java复制到模块目录下的Copy .java
   数据源和目的地的分析:
       数据源:myCharStream\lConversionStream0emo.java ---读数据---Reader --- InputStreamReader --- FileReader
       目的地:myCharStream]l Copy.java --.写数据--- Writer --- OutputStreamWriter .-- FiLeWriter
   思路:
    1:根据数据源创建字符输入流对象
    2:根据目的地创建字符输出流对象
    3:读写数据,复制文件
    4:释放资源

 */
public class CopyJavaDemo02 {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字符输入流对象
       FileReader fr = new FileReader("ConversionStreamDemo.java");
        //根据目的地创建字符输出流对象
       FileWriter fw = new FileWriter("Copy.java");
        //读写数据,复制文件
        //一次读写一个字符数据
       /* int ch;
        while ((ch = fr.read()) != -1){
            fw.write(ch);
        }*/
        //一次读写一个字符组数据
        char[] chs = new char[1024];
        int len;
        while ((len = fr.read(chs)) != -1){
            fw.write(chs,0,len);
        }
        //释放资源
        fr.close();
        fw.close();
    }
}

/*
  需求：
      把模块目录下的ConversionStreamDemo.java复制到模块目录下的Copy .java
  思路:
     1:根据数据源创建字符缓冲输入流对象
     2:根据目的地创建字符缓冲输出流对象
     3:读写数据。复制文件
     4:释放资源

 */
public class CopyJavaDemo01 {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("ConversionStreamDemo.java"));
        //根据目的地创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));
        //读写数据,复制文件
        //一次读写一个字符数据
       /* int ch;
        while ((ch = br.read()) != -1){
            fw.write(ch);
        }*/
        //一次读写一个字符组数据
        char[] chs = new char[1024];
        int len;
        while ((len = br.read(chs)) != -1){
            bw.write(chs,0,len);
        }
        //释放资源
        br.close();
        bw.close();

    }
}

/*
   需求:
      把模块目录下的ConversionStreamDemo.java复制到模块目录下的Copy .java
   思路:
     1:根据数据源创建字符缓冲输入流对象
     2:根据目的地创建字符缓冲输出流对象
     3:读写数据,复制文件
       使用字符缓冲流特有功能实现
     4:释放资源

 */
public class CopyJavaDemo02 {
    public static void main(String[] args) throws IOException {
        //创建字符输入流
        BufferedReader br = new BufferedReader(new FileReader("ConversionStreamDemo.java"));
        //创建字符输出流
        BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));;
        //读数据
        String line;
        while ((line = br.readLine()) != null){
            bw.write(line);
            //写换行符
            bw.newLine();
            //刷新
            bw.flush();
        }
        //释放资源
        br.close();
        bw.close();
    }
}

/*
   需求:
      把ArrayList集合中的字符串数据写入到文本文件。要求，每一个字符串元素作为文件中的一行数据
   思路:
      1:创建ArrayList集合
      2:往集合中存储字符串元素
      3:创建字符缓冲输出流对象
      4:遍历集合,得到每一个字符串数据
      5:调用字符缓冲输出流对象的方法写数据
      6:释放资源

 */
public class ArrayListToTxtDemo {
    public static void main(String[] args) throws IOException {
        //创建ArrayList集合
        ArrayList<String> list = new ArrayList<String>();
        //往集合中存储字符串元素
        list.add("hello");
        list.add("java");
        list.add("word");
        //创建字符缓冲输出流对象
       BufferedWriter bw = new BufferedWriter(new FileWriter("java.txt"));
        //遍历集合,得到每一个字符串数据
        for(String s :list){
            //调用字符缓冲输出流对象的方法写数据
            bw.write(s);
            bw.newLine();
            bw.flush();
            }
        //释放资源
        bw.close();
        }
    }

/*
   需求:
      我有一个文件里面存储了班级同学的姓名，每一个姓名占一行，要求通过程序实现随点名器
   思路:
      1:创建字符缓冲输入流对象
      2:创建ArrayList集合对象
      3:调用字符缓冲输入流对象的方法读数据
      4:把读取到的字符串数据存储到集合中
      5 :释放资源
      6:使用Random产生一个随机数，随机数的范围在:[e,集合的长度)
      7:把第6步产生的随机数作为索引到ArrayList集合中获取值
      8:把第7线得到的数据输出在控制台

 */
测试类
public class CallNameDemo {
    private static Object Random;

    public static void main(String[] args) throws IOException {
        //创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("java.txt"));
        //创建ArrayList集合对象
        ArrayList<String> list = new ArrayList<String>();
        //调用字符缓冲输入流对象的方法读数据
        String line;
        while ((line = br.readLine()) != null){
            //把读取到的字符串数据存储到集合中
            list.add(line);
        }
        //释放资源
        br.close();
        //使用Random产生一个随机数，随机数的范围在:[e,集合的长度)使用Random产生一个随机数，随机数的范围在:[e,集合的长度)
        Random r =new Random();
        int x = r.nextInt(list.size());
        //把第6步产生的随机数作为索引到ArrayList集合中获取值
        String name = list.get(x);
        //把第7线得到的数据输出在控制台
        System.out.println("被点名得是" + name);


    }
}


TXT文件
张三
李四
王五
韩梅梅

/*
   需求:
      把文本文件中的数据读取到集合中，并逾历集合。要求。文件中每一行数据是一个集合元素
   思路:
     1:创建字符缓冲输人流对象
     2:创建ArrayList集合对象
     3:调用字符缓冲输入流对象的方法读数据
     4:把读取到的字符串数据存储到集合中
     5 :释放资源
     6:遍历集合

 */
public class TxtToArrayListDemo {
    public static void main(String[] args) throws IOException {
        //创建字符缓冲输人流对象
        BufferedReader br = new BufferedReader(new FileReader("java.txt"));
        //创建ArrayList集合对象
        ArrayList<String> list = new ArrayList<String>();
        //调用字符缓冲输入流对象的方法读数据
        String line;
        while ((line = br.readLine()) != null){
            //把读取到的字符串数据存储到集合中
            list.add(line);
        }
          //释放资源
        br.close();
        //遍历集合
        for(String s : list){
            System.out.println(s);
        }
    }
}

/*
   需求:
     把ArrayList集合中的学生数据写入到文本文件。要求，每一个学生对象的数据作为文件中的一行数据格式:学号,姓名,年龄,居住地举例;itheimae81,林青霞, 30,西安
   思路:
     1 :定义学生类
     2:创建ArrayList集合
     3:创建学生对象
     4:把学生对象添加到集合中
     5:创建字符缓冲输出流对家
     6:遍历集合,得到每一个学生对象
     7:把学生对象的数据拼接成指定格式的字符串
     8:调用字符缓冲输出流对象的方法写数据
     9:释放资源

 */
Student类

public class Student {
    private String number;
    private String name;
    private int age;
    private String address;

    public Student() {
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getNumber() {
        return number;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getAddress() {
        return address;
    }

    public Student(String number, String name, int age, String address) {
        this.number = number;
        this.name = name;
        this.age = age;
        this.address = address;

    }

}


测试类
public class ArrayListFileDemo {
    public static void main(String[] args) throws IOException {
        //创建ArrayList集合
        ArrayList<Student> list = new ArrayList<Student>();
        //创建学生对象
        Student s1 = new Student("001","张三",21,"湖南");
        Student s2 = new Student("002","李四",43,"四川");
        Student s3 = new Student("003","王五",21,"山东");
        Student s4 = new Student("004","韩梅梅",21,"广西");
        //把学生对象添加到集合中
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);

        //创建字符缓冲输出流对家
        BufferedWriter bw = new BufferedWriter(new FileWriter("student.txt"));
        //遍历集合,得到每一个学生对象
        for(Student ss : list){
            //把学生对象的数据拼接成指定格式的字符串
//            String s = ss.getNumber() + "," + ss.getName() + "," + ss.getAge() + "," + ss.getAddress();
//            bw.write(s);
            StringBuilder sb = new StringBuilder();
            sb.append(ss.getNumber() + "," + ss.getName() + "," + ss.getAge() + "," + ss.getAddress());
            //调用字符缓冲输出流对象的方法写数据
            bw.write(sb.toString());
            bw.newLine();
            bw.flush();
        }
        //释放资源
        bw.close();

    }
}

/*
   需求:把文本文件中的数据读取到集合中，并遍历集合。要求，文件中每一行数据是一个学生对象的成员变量值
   举例:itheima0B1i,林青霞,30,西安
   思路:
      1:定义学生类
      2:创建字符缓冲输入流对象
      3:创建ArrayList集合对家
      4:调用字符缓冲输入流对象的方法读数据
      5:把读取到的字符串数据用split()进行分割，得到一个字符串数组
      6:创建学生对象
      7:把宁符串数组中的每一个元素取出来对应的赋值给学生对象的成员变量值
      8:把学生对象添加到集合
      9:释放资源
      10:遍历集合

 */
测试类
public class FileToArrayListDemo {
    public static void main(String[] args) throws IOException {
        //创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("Student.txt"));
        //创建ArrayList集合对家
        ArrayList<Student> list = new ArrayList<Student>();
        //调用字符缓冲输入流对象的方法读数据
        String line;
        while ((line = br.readLine()) != null){
            //把读取到的字符串数据用split()进行分割，得到一个字符串数组
            String[] array = line.split(",");
            //创建学生对象
            Student s = new Student();
            //把宁符串数组中的每一个元素取出来对应的赋值给学生对象的成员变量值
            s.setNumber(array[0]);
            s.setName(array[1]);
            s.setAge(Integer.parseInt(array[2]));
            s.setAddress(array[3]);
            //把学生对象添加到集合
            list.add(s);
        }
        //释放资源
        br.close();
        //遍历集合
        for(Student lists : list){
            System.out.println(lists.getNumber() + "," + lists.getName() + "," + lists.getAge() + "," + lists.getAddress());
        }
    }
}


Student类
package com.ithema_06;

public class Student {
    private String number;
    private String name;
    private int age;
    private String address;

    public Student() {
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getNumber() {
        return number;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getAddress() {
        return address;
    }

    public Student(String number, String name, int age, String address) {
        this.number = number;
        this.name = name;
        this.age = age;
        this.address = address;

    }

}


Student文件

/*
   需求:键盘录入5个学生信息.(姓名,语文成绩,数学成绩,英语成绩)。要求按照成绩总分从高到低写入文本文件
       格式:姓名,语文成绩,数学成绩,英语成绩
       举例，林青霞,98, 99,100
   思路:
     1:定义学生类
     2:创建TreeSet集合,通过比较器排序进行排序
     3:键盘录入学生数据
     4:创建学生对象．把键盘录入的数据对应赋值给学生对象的成员变量
     5:把学生对象添加到TreeSet集合
     6:创建字符缓冲输出流对象
     7:遍历集合，得到每一个学生对象
     8:把学生对象的数据拼接成指定格式的字符串
     9:调用字符缓冲输出流对象的方法写数据
     10:释放资源

 */
public class TreeSetToFileDemo {
    public static void main(String[] args) throws IOException {
        //创建TreeSet集合,通过比较器排序进行排序
        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
               int num = s2.getScore() - s1.getScore();
               int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num;
               int num3 = num2 == 0 ? s1.getMath() - s2.getMath() : num2;
               int num4 = num3 == 0 ? s1.getName().compareTo(s2.getName()) : num3;
               return num4;
            }
        });
        //键盘录入学生数据
        for(int x = 0; x < 5; x++) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入第" + (x+1) + "个学生信息");
            System.out.println("姓名：");
            String name = sc.nextLine();
            System.out.println("语文成绩：");
            int chinese = sc.nextInt();
            System.out.println("数学成绩：");
            int math = sc.nextInt();
            System.out.println("英语成绩：");
            int english = sc.nextInt();
            //创建学生对象．把键盘录入的数据对应赋值给学生对象的成员变量
            Student s = new Student();
            s.setName(name);
            s.setChinese(chinese);
            s.setMath(math);
            s.setEnglish(english);
            //把学生对象添加到TreeSet集合
            ts.add(s);
        }
        //创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("student1.txt"));
        //遍历集合，得到每一个学生对象
        for(Student list : ts){
            //把学生对象的数据拼接成指定格式的字符串
            StringBuilder sb = new StringBuilder();
            sb.append(list.getName()).append(",").append(list.getChinese()).append(",").append(list.getMath()).append(",").append(list.getEnglish()).append(",").append(list.getScore());
            //调用字符缓冲输出流对象的方法写数据
           bw.write(sb.toString());
           bw.newLine();
           bw.flush();
        }
        //释放资源
        bw.close();
    }
}


Student类
package com.ithema_07;

public class Student {
    private String name;
    private int chinese;
    private int math;
    private int english;
    private int score;
    public Student() {
    }

    public Student(int score) {
        this.score = score;
    }

    public Student(String name, int chinese, int math, int english) {
        this.name = name;
        this.chinese = chinese;
        this.math = math;
        this.english = english;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getChinese() {
        return chinese;
    }

    public void setChinese(int chinese) {
        this.chinese = chinese;
    }

    public int getMath() {
        return math;
    }

    public void setMath(int math) {
        this.math = math;
    }

    public int getEnglish() {
        return english;
    }

    public void setEnglish(int english) {
        this.english = english;
    }



    public void setScore(int score) {
        this.score = score;
    }

    public int getScore(){
        return this.chinese + this.math + this.english;
    }
}

/*
   需求:
     把"E: l1itcast”复制到d盘目录下
   思路:
     1:创建数据源FiLe对象，路径是E: llitcast
     2:创建目的地FiLe对象，路径是F:!
     3:写方法实现文件夹的复制,参数为数据源FiLe对象和目的地FiLe对象
     4:判断数据源FiLe是否是自录
       是:
         A:在目的地下创建和数据源File名称一样的目录
         B:获取数据源File下所有文件或者自录的FiLe数组
         C:遍历该File数组，得到每一个File对象
         D:把该File作为数据源File对象,递归调用复制文件夹的方法
       不是:说明是文件，直接复制,用字节流工

 */
public class CopyFlodersDemo {
    public static void main(String[] args) throws  IOException{
        //创建数据源FiLe对象
        File srcFile = new File("D:\\1");
        //创建目的地FiLe对象
        File destFile = new File("D:\\xuexi");
        //写方法实现文件夹的复制,参数为数据源FiLe对象和目的地FiLe对象
        copyFolders(srcFile,destFile);
    }
    //复制文件夹
    private static void copyFolders(File srcFile, File destFile) throws IOException{
        //判断数据源FiLe是否是 目录
        if(srcFile.isDirectory()){
            //在目的地下创建和数据源File名称一样的目录
            String srcFileName = srcFile.getName();
            File newFolder = new File(destFile,srcFileName);//复制首目录
            if(!newFolder.exists()){
                newFolder.mkdir();
            }
            //取数据源File下所有文件或者自录的FiLe数组
            File[] array = srcFile.listFiles();
            //遍历该File数组，得到每一个File对象
            for(File file : array){
                //把该File作为数据源File对象,递归调用复制文件夹的方法
                copyFolders(file,newFolder);
            }
        }else {
            //不是:说明是文件，直接复制,用字节流
            File newFile = new File(destFile,srcFile.getName());
            copyFile(srcFile,newFile);
        }
    }

    //字节缓冲流复制文件
    private static void copyFile(File srcFile, File destFile) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));
        byte[] chs = new byte[1024];
        int len;
        while ((len = bis.read()) != -1) {
            bos.write(chs, 0, len);
        }
        bos.close();
        bis.close();

    }
}

/*
   需求。
     把E:\\itcast这个文件夹复制到模块目录下
   思路,
    1:创建数据源目录FiLe对象,路径是E:\\itcast
    2:获取数据源目录File对象的名称(itcast)
    3:创建目的地目录FiLe对象，路径名是模块名+itcast组成(myCharStream \\itcast)
    4:判断目的地目录对应的File是否存在，如果不存在，就创建
    5 :获取数据源目录下所有文件的File故组
    6:遍历FiLe数组，得到每一个File对象，该FiLe对象，其实就是数据源文件
       数据源文件:E:\\itcast\\mn . jpg
    7:获取数据源文件FiLe对象的名称( mn.jpg)
    8 :创建目的地文件FiLe对象，路径名是目的地目录+mn.jpg组成(myCharStream\\itcast \\mrn.jpg)
    9:复制文件
      由于文件不仅仅是文本文件，还有图片，视频等文件，所以采用字节流复制文件

 */
public class CopyFolderDemo {
    public static void main(String[] args) throws IOException {
        //创建数据源目录FiLe对象,路径是
        File srcFolder = new File("D:\\1");
        //获取数据源目录File对象的名称
        String srcFolderName = srcFolder.getName();
        //创建目的地目录FiLe对象，
        File destFolder = new File(srcFolderName);
        //判断目的地目录对应的File是否存在，如果不存在，就创建
        if (!destFolder.isDirectory()) {
            destFolder.mkdir();
        }
        //获取数据源目录下所有文件的File数组
        File[] listFiles = srcFolder.listFiles();
        //遍历FiLe数组，得到每一个File对象，该FiLe对象，其实就是数据源文件
        for (File srcFile : listFiles) {
            //获取数据源文件FiLe对象的名称
            String srcFilesName = srcFile.getName();
            //创建目的地文件FiLe对象
            File destFile = new File(destFolder, srcFilesName);
            //复制文件
            copyFile(srcFile, destFile);

        }
    }

    private static void copyFile(File srcFile, File destFile) throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));
        byte[] chs = new byte[1024];
        int len;
        while ((len = bis.read()) != -1) {
            bos.write(chs, 0, len);
        }
        bos.close();
        bis.close();

    }
}

四，标准流

1标谁输入流

public static final InputStream in:标谁输入流。通常该流对应于键盘输入或由主机环境或用户指定的另一个输入源

public class SystemInDemo {
    public static void main(String[] args) throws IOException {
        //public static final InputStream in:标谁输入流。
    /*    InputStream is = System.in;

        int by;
        while ((by = is.read()) != -1){
            System.out.println((char)by);
        }*/
       //将字节流转换为字符流，并且能够一次读取一行数据
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("请输入一个字符串：");
        String line = br.readLine();
        System.out.println("你输入的字符串是：" + line);
        System.out.println("请输入一个整数：");
        int i = Integer.parseInt(br.readLine());
        System.out.println("你输入的整数是：" + i);
    }
}

2标准输出流

public static final PrintStream out。标准输出流。通常该流对应于显示输出或由主机环境或用户指定的另一个输出目标

public class SystemOutDemo {
    public static void main(String[] args) {
        //public static final PrintStream out。标准输出流
        PrintStream ps  = System.out;

        //能够方便打印各种数据
    /*   ps.print(10);
        ps.print("hello");
        ps.println(23);
        ps.println("word");*/
    //System.out本质是一个字节输出流
        System.out.println("hello");
        //print()必须要有参数
        System.out.print(2);
    }
}

3打印流的特点:

只负责输出数据,不负责读取数据
有自己的特有方法

字节打印流
PrintStream (String fileName):使用指定的文件名创建新的打印流

public class PrintStreamDemo {
    public static void main(String[] args) throws IOException {
        //PrintStream (String fileName):使用指定的文件名创建新的打印流
        PrintStream ps = new PrintStream("ps.txt");
        //写数据
        //字节输出流有的方法
//        ps.write(98);//会转码
        //自己特有的方法,不会转码原样输出
        ps.println(98);
        ps.println(99);
    }
}

字符打印流的构造方法:
PrintWriter (String fileName):使用指定的文件名创建一个新的PrintWriter，而不需要自动执行刷新
PrintWriter (Writer out，boolean autoFlush)。创建一个新的PrintWriter
out:字符输出流
autoFlush:一个布尔值，如果为真，则println , printf ，或format方法将刷新输出缓冲区

public class PrintWriterDemo {
    public static void main(String[] args) throws IOException {
        //PrintWriter (String fileName):使用指定的文件名创建一个新的PrintWriter，而不需要自动执行刷新
   /*     PrintWriter pw = new PrintWriter("pw.txt");

//        pw.write("hello");//换行要加\r\n
        pw.println("hello");
        pw.flush();
        pw.println("word");
        pw.flush();*/
   //   PrintWriter (Writer out，boolean autoFlush)。创建一个新的PrintWriter
        PrintWriter pw = new PrintWriter(new FileWriter("pw.txt"),true);
        pw.println("java");
        pw.println("dad");
    }
}

五，对象序列化流

1 输入流

构造方法:
ObjectInputStream (InputStream in):创建从指定的InputStream读取的ObjectInputStream
反序列化对象的方法:
Object readObject ():从ObjectInputStream读取一个对象

public class ObjectInputStreamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // ObjectInputStream (InputStream in):创建从指定的InputStream读取的ObjectInputStream
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("oos.txt"));
        //Object readObject ():从ObjectInputStream读取一个对象
        Object obj = ois.readObject();
        Student s = (Student) obj;
        System.out.println(s.getName() + "," + s.getAge() );
        ois.close();
    }
}


Student类
public class Student implements Serializable {
    private static final long serialVersionUID = 42L;
    private String name;
    private transient int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    /*@Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }*/
}

2

输出流

构造方法:
ObjectOutputStream (OutputStream out):创建一个写入指定的OutputStream的ObjectOutputStream
序列化对象的方法:
void writeObject (Object obj):将指定的对象写入ObjectOutputStream

NotSerializableException:抛出一个实例需要一个serializable接口。序列化运行时或实例的类可能会抛出此异常
类的序列化由实现java.io.Serializable接口的类启用。不实现此接口的类将不会使任何状态序列化或反序列化

public class ObjectOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        // ObjectOutputStream (OutputStream out):创建一个写入指定的OutputStream的ObjectOutputStream
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("oos.txt"));
        //创建对象
        Student s = new Student("张三",83);
        //void writeObject (Object obj):将指定的对象写入ObjectOutputStream
        oos.writeObject(s);
        //释放资源
        oos.close();
    }
}

用对象序列化流序列化了一个对象后，假如我们修改了对象所属的类文件，读取数据会不会出问题呢?
java.io.InvalidCLassException :
      当序列化运行时检初到类中的以下问题之一时抛出。
         类的串行版本与从流中读取的类描述符的英型不匹配
         该类包含未知的数据类型
         该类没有可访问的无参数构造函数
   com.itheima_03.Student; Local class incompatible:
   stream classdesc serialVersionUID = -3743788623620386195,
   local class serialVersionUID = -247282590948988173
如果出间题了，如何解决呢?
    显示声明，给对象所底的类加一个值: private static final long serialVersionUID = 42L;
如果—个对象中的某个成员变量的值不想被序列化,又该如何实现呢?
    把成员变量用transient修饰
    private transient int age;

测试类
public class ObjectStreamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
//        write();
        read();
    }

    //反序列化
    public static void read() throws IOException, ClassNotFoundException {
        // ObjectInputStream (InputStream in):创建从指定的InputStream读取的ObjectInputStream
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("oos.txt"));
        //Object readObject ():从ObjectInputStream读取一个对象
        Object obj = ois.readObject();
        Student s = (Student) obj;
        System.out.println(s.getName() + "," + s.getAge());
        ois.close();
    }

    //序列化
    public static void write() throws IOException {
        // ObjectOutputStream (OutputStream out):创建一个写入指定的OutputStream的ObjectOutputStream
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("oos.txt"));
        //创建对象
        Student s = new Student("张三", 83);
        //void writeObject (Object obj):将指定的对象写入ObjectOutputStream
        oos.writeObject(s);
        //释放资源
        oos.close();
    }
}


Student类

public class Student implements Serializable {
    private static final long serialVersionUID = 42L;
    private String name;
    private transient int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    /*@Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }*/
}

3

Properties函数

作为Map集合的使用

public class PropertiesDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        Properties prop = new Properties();
        //存储元素
        prop.put("001","张三");
        prop.put("002","王五");
        //遍历集合
        Set<Object> keySet = prop.keySet();
        for(Object key : keySet){
            Object value = prop.get(key);
            System.out.println(key + "," + value);
        }
    }
}

Properties作为集合的特有方法:
    Object setProperty(String key,String value)：设该集合的键和值，都是string类型，底层调用Hashtable方法put
    String getProperty(String key):使用此属性列表中指定的键搜索属性
    Set<String> stringPropertyNames():从该属性列表中返回一个不可修改的键集，其中链及其对应的值是字符串

public class PropertiesDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        Properties prop = new Properties();
        // Object setProperty(String key,String value)：设百集合的键和值，都是string类型，底层调用Hashtable方法put
        prop.setProperty("001","张三");
        prop.setProperty("002","李四");
        prop.setProperty("003","王五");
        //String getProperty(String key):使用此属性列表中指定的键搜索属性
        /*System.out.println(prop.getProperty("001"));
        System.out.println(prop.getProperty("0001"));
        System.out.println(prop);*/
        //Set<String> stringPropertyNames():从该属性列表中返回一个不可修改的键集，其中链及其对应的值是字符串
        Set<String> names = prop.stringPropertyNames();
        for(String key : names){
            Object value = prop.get(key);
            System.out.println(key + "," + value);
        }
    }
}

Properties和IO流结合的方法:
   void Load(Reader reader):
      从输入字符流读取压性列表(键和元素对)
   void store( Writer writer, String comments):
      将此属性列表（键和元素对)写入此Properties表中，以适合使用Load(Reader)方法的格式写入输出字符流

public class PropertiesDemo03 {
    public static void main(String[] args) throws IOException{
        //把集合中的数据保存到文件
//      myStore();

        //把文件中的数据加载到集合
        myLoad();
    }

    private static void myLoad() throws IOException{
        Properties prop = new Properties();
        FileReader fr = new FileReader("fw.txt");
        prop.load(fr);
        fr.close();
        System.out.println(prop);
    }

    private static void myStore() throws IOException {
        Properties prop = new Properties();
        prop.setProperty("001","张三");
        prop.setProperty("002","王五");
        prop.setProperty("003","李四");
        FileWriter fw = new FileWriter("fw.txt");
        prop.store(fw,null);
        fw.close();
    }
}

4

练习

/*
   需求:请写程序实现猜数字小游戏只能试玩3次，如果还想玩，提示。游戏试玩已结束，想玩请充值(mw .itcast.cn)

   思路:
    1:写一个游戏类,里面有—个猜数字的小游戏
    2:写一个测试类,测试类中有main方法，main()方法中按照下面步骤完成
         A:从文件中读取数据到Properties集合,用Load()方法实现
            文件已经存在:game.txt
            里面有一个数据值:count=0
         B:通过Properties集合获取到玩游戏的次数
         c:判断次数是否到3
         如果到了，给出提示:游戏试玩已结束,想玩请充值(www.itcast.cn)
         如果不到3次。
            玩游戏
           次数+1。重新写回文件,用Properties的store()方法实现

 */
测试类
public class PropertiesTest {
    public static void main(String[] args) throws IOException {
    //从文件中读取数据到Properties集合,用Load()方法实现
        Properties prop = new Properties();
        FileReader fr = new FileReader("game.txt");
        prop.load(fr);
        fr.close();
        //通过Properties集合获取到玩游戏的次数
        String count = prop.getProperty("count");
        int x = Integer.parseInt(count);
        //判断次数是否到3
        if(x >= 3){
            System.out.println("游戏试玩已结束,想玩请充值(www.baidu.com)");
        }else {
            //如果不到3次:玩游戏 次数+1。重新写回文件,用Properties的store()方法实现
            GuessNumber.start();
            x++;
            prop.setProperty("count",String.valueOf(x));
            FileWriter fw = new FileWriter("game.txt");
            prop.store(fw,null);
            fw.close();
        }
    }
}


游戏类
public class GuessNumber {
    private GuessNumber() {
    }

    public static void start() {
        Random r = new Random();
        int number = r.nextInt(100) + 1;

        while (true) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入你猜的数字：");
            int i = sc.nextInt();
            if (number > i) {
                System.out.println("你猜的数字" + i + "小了");
            }else if (number < i){
                System.out.println("你猜的数字" + i + "大了");
            }else {
                System.out.println("你猜对了");
                break;
            }

        }
    }
}

cqq00

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
File类，字节字符输入输出流，缓冲流，标准流，对象序列化流

一，File文件类1File类创建功能: public boolean createNewFiLe():当具有该名称的文件不存在时，创建一个由该抽象路径名命名的新空文件如果文件不存在,就创建文件,并返回true 如果文件存在，就不创建文件，并返回false public boolean mkdir():创建由此抽象路径名命名的目录如果目录不存在,就创建文件，并返回true 如果文件存在，就不创建文件，并返回false public b......
复制链接

扫一扫