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

一，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):将指定的字节写入此文件输出流
        
        //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 :rn
       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("rn".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 ;
        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[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)
        
      

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

练习

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();
    }
}

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();

    }
}

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 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 ( 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)
        
        //BufferedReader( Reader in)
        BufferedReader br = new BufferedReader(new FileReader("java.txt"));
        //一次读一个字符
        
        //一次读一个字符数组
        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();
            }
        }

    }
    //抛出处理
    
}

5 练习

1

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"));
        //读写数据,复制文件
        //一次读写一个字符数据
       
        //一次读写一个字符组数据
        char[] chs = new char[1024];
        int len;
        while ((len = isr.read(chs)) != -1){
            osw.write(chs,0,len);
        }
        //释放资源
        isr.close();
        osw.close();
    }
}

2

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

3

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"));
        //读写数据,复制文件
        //一次读写一个字符数据
       
        //一次读写一个字符组数据
        char[] chs = new char[1024];
        int len;
        while ((len = br.read(chs)) != -1){
            bw.write(chs,0,len);
        }
        //释放资源
        br.close();
        bw.close();

    }
}

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();
    }
}

5

public class ArrayListToTxtDemo {
    public static void main(String[] args) throws IOException {
        //创建ArrayList集合
        ArrayList list = new ArrayList();
        //往集合中存储字符串元素
        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();
        }
    }

6

测试类
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 list = new ArrayList();
        //调用字符缓冲输入流对象的方法读数据
        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文件
张三
李四
王五
韩梅梅

7

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

8

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 list = new ArrayList();
        //创建学生对象
        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();

    }
}

9

测试类
public class FileToArrayListDemo {
    public static void main(String[] args) throws IOException {
        //创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("Student.txt"));
        //创建ArrayList集合对家
        ArrayList list = new ArrayList();
        //调用字符缓冲输入流对象的方法读数据
        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文件

10

public class TreeSetToFileDemo {
    public static void main(String[] args) throws IOException {
        //创建TreeSet集合,通过比较器排序进行排序
        TreeSet ts = new TreeSet(new Comparator() {
            @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;
    }
}

11

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();

    }
}

12

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();

    }
}