Java学习记录四（IO流）

Java

24.IO流

24.1File

24.1.1File类概述和构造方法

File:它是文件和目录路径名的抽象表示
文件和目录是可以通过File封装成对象的
对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以是不存在的。将来是要通过具体的操作把这个路径的内容转换为具体存在的

方法名	说明
File(String pathname)	通过将给定的路径名字符串转换为抽象路径名来创建新的File实例
File(String parent, String child)	从父路径名字符串和子路径名字符串创建新的File实例
File(File parent, String child)	从父抽象路径名和子路径名字符串创建新的File实例

package walking003;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;

public class PokerDemo {
    public static void main(String[] args) {
        //创建HashMap，键是编号，值是牌
        HashMap<Integer,String> hm = new HashMap<Integer,String>();

        //创建ArrayList，存储编号
        ArrayList<Integer> array = new ArrayList<>();

        //创建花色数组和点数数组
        String[] colors = {"♦","♥","♠","♣"};
        String[] numbers = {"2","3","4","5","6","7","8","9","10","J","Q","K","A",};

        //从0开始往HashMap里面存储编号，并存储对应的牌。同时往ArrayList里面存储编号
        int index = 0;

        for(String number : numbers){
            for(String color : colors){
                hm.put(index,color+number);
                array.add(index);
                index++;
            }
        }
        hm.put(index,"小王");
        array.add(index);
        index++;
        hm.put(index,"大王");
        array.add(index);

        //洗牌(洗的是编号)，用Collection的shuffle()方法实现
        Collections.shuffle(array);
        //发牌(发的也是编号，为了保证编号是排序的，创建TreeSet集合接收)
        TreeSet<Integer> lldSet = new TreeSet<Integer>();
        TreeSet<Integer> yjqSet = new TreeSet<Integer>();
        TreeSet<Integer> ebdSet = new TreeSet<Integer>();
        TreeSet<Integer> dpSet = new TreeSet<Integer>(  );

        for(int i = 0;i< array.size();i++){
            int x = array.get(i);
            if(i>= array.size()-3){
                dpSet.add(x);
            }else if (i% 3 ==0){
                lldSet.add(x);
            }else if (i% 3 ==1){
                yjqSet.add(x);
            }else if (i% 3 ==2){
                ebdSet.add(x);
            }
        }

        //调用看牌方法
        lookPoker("利拉德",lldSet,hm);
        lookPoker("恩比德",ebdSet,hm);
        lookPoker("约基奇",ebdSet,hm);
        lookPoker("底牌",dpSet,hm);
    }
    //定义方法看牌(遍历TreeSet集合,获取编号,到HashMap集合找对应的牌)
    public static void lookPoker(String name,TreeSet<Integer> ts,HashMap<Integer,String> hm){
        System.out.println(name+"的牌是");
        for(Integer key : ts){
            String poker = hm.get(key);
            System.out.print(poker+" ");
        }
        System.out.println();
    }

}

24.2File类创建功能

方法名	说明
public boolean createNewFile()	当具有该名称的文件不存在时，创建一个由该抽象路径名命名的新空文件public
public boolean mkdir()	创建由此抽象路径名命名的目录
public boolean mkdirs()	创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录

package walking004;

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

public class FileDemo02 {
    public static void main(String[] args) throws IOException {
        //需求1：我要在...目录下创建一个文件java.txt
        File f1 = new File("E:\\learn\\LanguageJAVA\\JAVAcode\\JavaSE_Code\\walking\\src\\walking004\\java.txt");
        System.out.println(f1.createNewFile());
        System.out.println("-------");

        //需求2：我要在...目录下创建一个目录JavaSE
        File f2 = new File("E:\\learn\\LanguageJAVA\\JAVAcode\\JavaSE_Code\\walking\\src\\walking004\\JavaSE");
        System.out.println(f2.mkdir());
        System.out.println("-------");

        //需求3：我要在...目录下创建一个多级目录JavaWEB\\HTML
        File f3 = new File("E:\\learn\\LanguageJAVA\\JAVAcode\\JavaSE_Code\\walking\\src\\walking004\\JavaWEB\\HTML");
        System.out.println(f3.mkdirs());
        System.out.println("-------");

        //需求4：我要在...目录下创建一个文件Javase.txt
        File f4 = new File("E:\\learn\\LanguageJAVA\\JAVAcode\\JavaSE_Code\\walking\\src\\walking004\\java.txt");
        //System.out.println(f4.mkdir());
        System.out.println(f4.mkdir());
        //创建什么就要用什么方式
        System.out.println("-------");
    }
}

24.3File类删除功能

方法名	功能
public boolean delete( )	删除由此抽象路径名表示的文件或目录

绝对路径和相对路径的区别
绝对路径:完整的路径名，不需要任何其他信息就可以定位它所表示的文件。例如:E:\lxh\ljava.txt
相对路径:必须使用取自其他路径名的信息进行解释。例: myFilelliava.txt
删除目录时的注意事项:
如果一个目录中有内容(目录，文件)，不能直接删除。应该先删除目录中的内容，最后才能删除目录

24.4File类判断和获取功能

方法名	说明
public boolean isDirectory()	测试此抽象路径名表示的File是否为目录
public boolean isFile()	测试此抽象路径名表示的File是否为文件
public boolean exists()	测试此抽象路径名表示的File是否存在
public String getAbsolutePath()	返回此抽象路径名的绝对路径名字符串
public String getPath()	将此抽象路径名转换为路径名字符串
public String getName()	返回由此抽象路径名表示的文件或目录的名称
public String[ ] list()	返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
public File[ ] listFiles()	返回此抽象路径名表示的目录中的文件和目录的File对象数组

package walking004;

import jdk.swing.interop.SwingInterOpUtils;

import java.io.File;

public class FileDemo04 {
    public static void main(String[] args) {
        //创建一个File对象
        File f = new File("walking\\java.txt");
//        public boolean isDirectory()测试此抽象路径名表示的File是否为目录
//        public boolean isFile()测试此抽象路径名表示的File是否为文件
//        public boolean exists()测试此抽象路径名表示的File是否存在
        System.out.println(f.isDirectory());
        System.out.println(f.isFile());
        System.out.println(f.exists());

//        public String getAbsolutePath()返回此抽象路径名的绝对路径名字符串
//        public String getPath()将此抽象路径名转换为路径名字符串
//        public String getName()返回由此抽象路径名表示的文件或目录的名称
        System.out.println(f.getAbsolutePath());
        System.out.println(f.getPath());
        System.out.println(f.getName());
        System.out.println("-------");

//        public String[ ] list()返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
//        public File[ ] listFiles()返回此抽象路径名表示的目录中的文件和目录的File对象数组
        File f2 = new File("E:\\learn\\LanguageJAVA\\JAVAcode\\JavaSE_Code\\walking\\src\\walking004");
        String[] strArray = f2.list();
        for(String str : strArray){
            System.out.println(str);
        }
        System.out.println("------");

        File[] fileArray = f2.listFiles();
        for(File file:fileArray){
           // System.out.println(file);
            if (file.isFile()){
                System.out.println(file.getName());
            }
        }
    }
}

24.5递归

递归概述:以编程的角度来看，递归指的是方法定义中调用方法本身的现象
递归解决问题的思路:
把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解
递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算

递归解决问题要找到两个内容:
递归出口:否则会出现内存溢出
递归规则:与原问题相似的规模较小的问题

案例：递归求阶乘

需求:用递归求5的阶乘，并把结果在控制台输出
思路:
定义一个方法，用于递归求阶乘，参数为一个int类型的变量
在方法内部判断该变量的值是否是1
是:返回1
不是:返回n*(n-1)!
调用方法
输出结果

package walking006;

public class DiGuiDemo01 {
    public static void main(String[] args) {
        //调用方法
        int result = jc(5);
        //输出结果
        System.out.println("result "+result);
    }
    public static int jc(int n){

        if(n==1){
            //是：返回1
            return 1;
        }else {
            //不是返回n*(n-1)
            return n*jc(n-1);
        }
    }
}

*案例：遍历目录

需求:给定一个路径(E\itcast)，请通过递归完成遍历该目录下的所有内容，并把所有文件的绝对路径输出在控制台
思路:
根据给定的路径创建一个File对象
定义一个方法，用于获取给定目录下的所有内容，参数为第1步创建的File对象
获取给定的File目录下所有的文件或者目录的File数组
遍历该File数组，得到每一个File对象
判断该File对象是否是目录
是:递归调用
不是:获取绝对路径输出在控制台
调用方法

package walking006;

import java.io.File;

public class DiGuiDemo02 {
    public static void main(String[] args) {
        //根据给定的路径创建一个File对象
        File srcFile = new File("E:\\learn\\LanguageJAVA\\JAVAcode\\JavaSE_Code\\walking\\src\\walking004\\");

        //调用方法
        getAllFilePath(srcFile);
    }
    //定义一个方法，用于获取给定目录下的所有内容，参数为第1步创建的File对象
    public static void getAllFilePath(File srcFile){
        //获取给定的File目前下所有的文件或者目录的File数组
        File[] fileArray = srcFile.listFiles();
        //遍历该File数组，得到每一个File对象
        if(fileArray != null){
            for(File file : fileArray){
                if(file.isDirectory()){
                    //是：递归调用
                    getAllFilePath(file);
                }else{
                    //不是：获取绝对路径输出在控制台
                    System.out.println(file.getAbsolutePath());
                }
            }
        }
    }
}

24.2字节流

24.2.1IO流概述和分类

IO流概述:
lO:输入/输出(Input/Output)
流:是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输
IO流就是用来处理设备间数据传输问题的
常见的应用:文件复制;文件上传;文件下载

IO流分类:
按照数据的流向
输入流:读数据
输出流:写数据
按照数据类型来分
字节流
字节输入流;字节输出流

​ 字符流
​ 字符输入流;字符输出流
一般来说，我们说lO流的分类是按照数据类型来分的
那么这两种流都在什么情况下使用呢?
如果数据通过Window自带的记事本软件打开，我们还可以读懂里面的内容，就使用字符流，否则使用字节流。如果你不知道该使用哪种类型的流，就使用字节流

硬盘和内存：

24.2.2字节流写数据

字节流抽象基类
InputStream:这个抽象类是表示字节输入流的所有类的超类
OutputStream:这个抽象类是表示字节输出流的所有类的超类
子类名特点:子类名称都是以其父类名作为子类名的后缀

FileOutputStream:文件输出流用于将数据写入File
FileOutputStream(Stringname):创建文件输出流以指定的名称写入文件

使用字节输出流写数据的步骤:
创建字节输出流对象(调用系统功能创建了文件，创建字节输出流对象，让字节输出流对象指向文件)
调用字节输出流对象的写数据方法
释放资源(关闭此文件输出流并释放与此流相关联的任何系统资源)

package walking007;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        //FileOutputStream(String name)创建文件输出流以指定的名称写入文件
        FileOutputStream fos = new FileOutputStream("E:\\learn\\LanguageJAVA\\JAVAcode\\JavaSE_Code\\walking\\src\\walking007\\fos.txt");
        /*
            做了三件事情:
            A:调用系统功能创建了文件
            B:创建了字节输出流对象
            C:让字节输出流对象指向创建好的文件
         */

        //void write (int b):将指定的字节写入此文件输出流
        fos.write(97);
//        fos.write(57);
//        fos.write(55);

        //最后都要释放资源
        //void close()关闭此文件输出流并释放与此流相关联的任何系统资源
        fos.close();

    }
}

24.2.3字节流写数据的3种方式

方法名	说明
void write (int b)	将指定的字节写入此文件输出流一次写一个字节数据
void write (byte[] b)	将 b.Length字节从指定的字节数组写入此文件输出流一次写一个字节数组数据
void write (byte[] b, int off，int len)	将len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流一次写一个字节数组的部分数据

package walking007;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class FileOutputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        //FileOutputStream(String name):创建文件输出流以指定的名称写入文件
        FileOutputStream fos = new FileOutputStream("E:\\learn\\LanguageJAVA\\JAVAcode\\JavaSE_Code\\walking\\src\\walking007\\fos.txt");
        //new File(name)
        //FileOutputStream fos = new FileOutputStream(new File("E:\\learn\\LanguageJAVA\\JAVAcode\\JavaSE_Code\\walking\\src\\walking008\\fos.txt"));
        //和上面一致

        //FileOutputStream (File file)创建文件输出流以写入由指定的File对象表示的文件
//        File file = new File("E:\\learn\\LanguageJAVA\\JAVAcode\\JavaSE_Code\\walking\\src\\walking008\\fos.txt");
//        FileOutputStream fos2 = new FileOutputStream(file);
//        FileOutputStream fos2 = new FileOutputStream(new File("E:\\\\learn\\\\LanguageJAVA\\\\JAVAcode\\\\JavaSE_Code\\\\walking\\\\src\\\\walking008\\\\fos.txt"));
//        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};

        //byte[] getBytes()返回字符串对应的字节数组
        byte[] bys = "abcde".getBytes();
//        fos.write(bys);

        //void write (byte[] b, int off，int len)将len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流一次写一个字节数组的部分数据
        fos.write(bys,1,3);

        //释放资源
        fos.close();
    }
}

24.2.4字节流写数据的两个小问题

字节流写数据如何实现换行呢?

• 写完数据后，加换行符
  windows:\r\n
  linux:\n
  mac:\

字节流写数据如何实现追加写入呢?

• public FileOutputStream(String name,boolean append)
• 创建文件输出流以指定的名称写入文件。如果第二个参数为true，则字节将写入文件的末尾而不是开

package walking007;

import java.io.FileOutputStream;
import java.io.IOException;
/*
    字节流写数据的两个小问题:
    1:字节流写数据如何实现换行呢?
        window : \r\n
        linux: \n
        mac : \r
    2 :字节流写数据如何实现追加写入呢?
    public FileOutputStream (String name,booleanappend)
        创建文件输出流以指定的名称写入文件。
        如果第二个参数为true ，则字节将写入文件的末尾而不是开头


 */

public class FileOutputStreamDemo03 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("E:\\learn\\LanguageJAVA\\JAVAcode\\JavaSE_Code\\walking\\src\\walking008\\fos.txt");

        //写数据
        for(int i=0;i<10;i++){
            fos.write("hello".getBytes());
            fos.write("\r\n".getBytes());
        }

        //释放资源
        fos.close();
    }
}

24.2.5字节流写数据加入异常处理

finally:在异常处理时提供finally块来执行所有清除操作。比如说IO流中的释放资源
特点:被finally控制的语句一定会执行，除非JVM退出

package walking007;

import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo04 {
    public static void main(String[] args) {
//        try {
//            FileOutputStream fos = new FileOutputStream("E:\\learn\\LanguageJAVA\\JAVAcode\\JavaSE_Code\\walking\\src\\walking007\\fos.txt");
//            fos.write("hello".getBytes());
//            fos.close();
//        } catch (IOException e) {
//            e.printStackTrace();
//        }

        //加入finally来实现释放资源
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("E:\\learn\\LanguageJAVA\\JAVAcode\\JavaSE_Code\\walking\\src\\walking007\\fos.txt");
            fos.write("hello".getBytes());

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

24.2.6字节流读数据（一次读一个字节数据）

需求:把文件fos.txt中的内容读取出来在控制台输出
FilelnputStream:从文件系统中的文件获取输入字节

• FilelnputStream(String name):通过打开与实际文件的连接来创建一个FileInputStream，该文件由文件系统中的路径名name命名

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

package walking008;

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

public class FileInputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        FileInputStream fis = new FileInputStream("E:\\\\learn\\\\LanguageJAVA\\\\JAVAcode\\\\JavaSE_Code\\\\walking\\\\src\\\\walking008\\\\fos.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((char)by);

        //如果达到文件末尾,-1
        /*int by = fis.read();
        while(by!=-1){
            System.out.println((char)by);
            by = fis.read();
        }*/
        int by;
        /*
            fis.read()读数据
            by = fis.read()把读取到的数据赋值给by
            by != -1判断读取到的数据是否是-1
        * */
        while((by = fis.read()) != -1){
            System.out.print((char)by);
        }

        //释放资源
        fis.close();
    }
}

案例：复制文本文件

需求:把“E:\TCodel\nwdsl.txt”复制到模块目录下的“nwdsl.txt"
思路:
根据数据源创建字节输入流对象
根据目的地创建字节输出流对象
读写数据，复制文本文件(一次读取一个字节，一次写入一个字节)
释放资源

package walking008;

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

public class CopyTxtDemo {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字节输入流对象
        FileInputStream fis = new FileInputStream("E:\\TCode\\nwdsl.txt");
        //根据目的地创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("E:\\\\learn\\\\LanguageJAVA\\\\JAVAcode\\\\JavaSE_Code\\\\walking\\\\src\\\\walking008\\\\fis.txt");
        int by;
        while((by=fis.read())!=-1){
            fos.write(by);
        }
        //释放资源
        fos.close();
        fis.close();
    }
}

24.2.7字节流读数据(一次读一个字节数组数据)

需求:把文件fos.txt中的内容读取出来在控制台输出
使用字节输入流读数据的步骤:
创建字节输入流对象
调用字节输入流对象的读数据方法
释放资源

package walking008;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileInputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        FileInputStream fis = new FileInputStream("E:\\learn\\LanguageJAVA\\JAVAcode\\JavaSE_Code\\walking\\src\\walking008\\fos.txt");

        /*//调用字节输入流对象的读数据方法
        //int read(byte[] b)从该输入流最多读取b.length个字节的数据到一个字符数组
        byte[] bys = new byte[5];

        //第一次读取数据
        int len = fis.read(bys);
        System.out.println(len);
        //String (byte[] bytes)
        System.out.println(new String(bys));
        System.out.println(new String(bys,0,len));

        //第二次读取数据
        len = fis.read(bys);
        System.out.println(len);
        //String (byte[] bytes)
        //System.out.println(new String(bys));
        System.out.println(new String(bys,0,len));

        //第三次读取数据
        len = fis.read(bys);
        System.out.println(len);
        System.out.println(new String(bys,0,len));
        //len返回的是实际读取数据的个数

        //再多读取两次
        len = fis.read(bys);
        System.out.println(len);
        len = fis.read(bys);
        System.out.println(len);*/

        /*
        hello\r\n
        world\r\n
        第一次hello
        第二次\r\nwor
        第三次ld\r\n//四个

         */
        byte[] bys = new byte[1024];//1024及其整数倍

        int len;
        while((len= fis.read(bys))!=-1){
            System.out.println(new String(bys,0,len));
        }
        //释放资源
        fis.close();
    }
}

案例：复制图片

需求:把“E:\1itcast\mn.jpg”复制到模块目录下的“mn.jpg"
思路:
①根据数据源创建字节输入流对象
②根据目的地创建字节输出流对象
③读写数据，复制图片(一次读取一个字节数组，一次写入一个字节数组)
④释放资源

package walking008;

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

public class CopyJpgDemo {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字节输入流对象
        FileInputStream fis = new FileInputStream("E:\\\\learn\\\\LanguageJAVA\\\\JAVAcode\\\\JavaSE_Code\\\\walking\\\\src\\\\walking008\\\\lld.jpg");
        //根据目的地创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("E:\\\\learn\\\\LanguageJAVA\\\\JAVAcode\\\\JavaSE_Code\\\\walking\\\\src\\\\walking007\\\\lld.jpg");

        //读写数据，复制图片（一次读取一个字节数组，一次写入一个字节数组）
        byte[] bys = new  byte[1024];
        int len;
        while ((len=fis.read(bys))!=-1){
            fos.write(bys,0,len);
        }

        //释放资源
        fos.close();
        fis.close();
    }
}

24.2.8字节缓冲流

字节缓冲流:

• BufferOutputStream:该类实现缓冲输出流。通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用

• BufferedlnputStream:创建BufferedInputstream将创建一个内部缓冲区数组。当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节

构造方法:

• 字节缓冲输出流:BufferedOutputStream(OutputStream out)
• 字节缓冲输入流: BufferedInputStream(InputStream in)

为什么构造方法需要的是字节流，而不是具体的文件或者路径呢?

• 字节缓冲流仅仅提供缓冲区，而真正的读写数据还得依靠基本的字节流对象进行操作

package walking009;

import java.io.*;
import java.nio.charset.StandardCharsets;

public class BufferStreamDemo {
    public static void main(String[] args) throws IOException {
        //字节缓存输出流：BufferedOutpeuStream(OutputStream out)
//        FileOutputStream fos = new FileOutputStream("E:\\\\learn\\\\LanguageJAVA\\\\JAVAcode\\\\JavaSE_Code\\\\walking\\\\src\\\\walking008\\\\fos.txt");
//        BufferedOutputStream bos = new BufferedOutputStream(fos);
        /*BufferedOutputStream bos = new BufferedOutputStream (new FileOutputStream("E:\\\\\\\\learn\\\\\\\\LanguageJAVA\\\\\\\\JAVAcode\\\\\\\\JavaSE_Code\\\\\\\\walking\\\\\\\\src\\\\\\\\walking009\\\\\\\\fos.txt"));
        //写数据
        bos.write("hello\r\n".getBytes());
        bos.write("world\r\n".getBytes());
        //释放资源
        bos.close();*/

        //字节缓存输入流：BufferedInputStream(InputStream in)
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\\\learn\\\\LanguageJAVA\\\\JAVAcode\\\\JavaSE_Code\\\\walking\\\\src\\\\walking008\\\\fos.txt"));
        //一次读取一个字节数据
//        int by;
//        while((by = bis.read())!=-1){
//            System.out.println((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();
    }
}

案例：复制视频

（不写这个。。我没视频）

需求:把“E:\\learn\\LanguageJAVA\\JAVAcode\\JavaSE_Code\\walking\\src\\walking008\\字节流复制图片.avi”复制到模块目录下的“E:\\learn\\LanguageJAVA\\JAVAcode\\JavaSE_Code\\walking\\src\\walking009\\字节流复制图片.avi”
思路:
根据数据源创建字节输入流对象
根据目的地创建字节输出流对象
读写数据，复制视频
释放资源

package walking009;

import java.io.*;
/*
1.基本字节流一次读写一个字节
共耗时:64565毫秒
2.基本字节流一次读写一个字节数组
共耗时:107毫秒
3.字节缓冲流一次读写一个字节
共耗时:405毫秒
4.字节缓冲流一次读写一个字节数组

 */
public class CopyAviDemo {
    public static void main(String[] args) {
        //记录开始时间
        long startTime = System.currentTimeMillis();

        //复制视频
        //method1();
        //method2();
        //method3();
        //method4();

        //记录结束时间
        long endTime = System.currentTimeMillis();
        System.out.println("共耗时"+(endTime-startTime)+"毫秒");
    }
    //字节缓冲流一次读写一个字节
    public static void method4() throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\itcast\\字节复制流图片.avi"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("walking\\字节复制流图片.avi"));

        byte [ ]bys =new byte[1024];
        int len;
        while((len= bis.read(bys))!=-1){
            bos.write(bys,0,len);
        }

        bos.close();
        bis.close();
    }
    //字节缓冲流一次读写一个字节
    public static void method3() throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\itcast\\字节复制流图片.avi"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("walking\\字节复制流图片.avi"));

        int by;
        while((by= bis.read())!=-1){
            bos.write(by);
        }

        bos.close();
        bis.close();
    }

    //基本字节流一次读写一个字节
    public static void method2() throws IOException {
        //E:\\itcast\\字节复制流图片.avi
        //模块目录下的 字节复制流图片.avi
        FileInputStream fis = new FileInputStream("E:\\itcast\\字节复制流图片.avi");
        FileOutputStream fos = new FileOutputStream("walking\\字节复制流图片.avi");

        int by;
        while((by= fis.read())!=-1){
            fos.write(by);
        }

        fos.close();
        fis.close();
    }

    public static void method1() throws IOException {
        //E:\\itcast\\字节复制流图片.avi
        //模块目录下的 字节复制流图片.avi
        FileInputStream fis = new FileInputStream("E:\\itcast\\字节复制流图片.avi");
        FileOutputStream fos = new FileOutputStream("walking\\字节复制流图片.avi");

        byte [ ]bys =new byte[1024];
        int len;
        while((len= fis.read(bys))!=-1){
            fos.write(bys,0,len);
        }
        fos.close();
        fis.close();
    }
}

24.3字符流

由于字节流操作中文不是特别的方便，所以Java就提供字符流

• 字符流=字节流＋编码表

用字节流复制文本文件时，文本文件也会有中文，但是没有问题，原因是最终底层操作会自动进行字节拼接成中文，如何识别是中文的呢?

● 汉字在存储的时候，无论选择哪种编码存储，第一个字节都是负数

package walking010;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
/*
一个汉字存储:
    如果是GBK编码，占用2个字节
    如果是UTF-8编码，占用3个字节
 */

public class FileInputStreamDemo {
    public static void main(String[] args) throws IOException {
//        FileInputStream fis = new FileInputStream("walking\\a.txt");
//
//        int by;
//        while((by= fis.read())!=-1){
//            System.out.println((char)by);
//        }
//
//        fis.close();
        String s = "中国";//[-28, -72, -83, -27, -101, -67]
//        byte[] bys = s.getBytes();
        //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));
    }
}

24.3.1编码表

基础知识:

• 计算机中储存的信息都是用二进制数表示的;我们在屏幕上看到的英文、汉字等字符是二进制数转换之后的结果

• 按照某种规则，将字符存储到计算机中，称为编码。反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为解码。这里强调一下:按照A编码存储，必须按照A编码解析，这样才能显示正确的文本符号。否则就会导致乱码现象

  ​ 字符编码:就是一套自然语言的字符与二进制数之间的对应规则(A,65)

字符集:

• 是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等

• 计算机要准确的存储和识别各种字符集符号，就需要进行字符编码，一套字符集必然至少有一套字符编码。常见字符集有ASCII字符集、GBXXX字符集、Unicode字符集等

ASClI字符集:

• ASCII(American Standard Code for Information Interchange，美国信息交换标准代码):是基于拉丁字母的一套电脑编码系统，用于显示现代英语，主要包括控制字符(回车键、退格、换行键等)和可显示字符(英文大小写字符、阿拉伯数字和西文符号)

• 基本的ASCII字符集，使用7位表示一个字符，共128字符。ASCII的扩展字符集使用8位表示一个字符，共256字符，方便支持欧洲常用字符。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等

GBXXX字符集:

• GB2312:简体中文码表。一个小于127的字符的意义与原来相同，但两个大于127的字符连在一起时，就表示一个汉字，这样大约可以组合了包含7000多个简体汉字，此外数学符号、罗马希腊的字母、日文的假名等都编进去了，连在ASCII里本来就有的数字、标点、字母都统统重新编了两个字节长的编码，这就是常说的"全角"字符，而原来在127号以下的那些就叫"半角"字符了

• GBK:最常用的中文码表。是在GB2312标准基础上的扩展规范，使用了双字节编码方案
  共收录了21003个汉字，完全兼容GB2312标准，同时支持繁体汉字以及日韩汉字等

• GB18030:最新的中文码表。收录汉字70244个，采用多字节编码，每个字可以由1个、2个或4个字节组成。支持中国国内少数民族的文字，同时支持繁体汉字以及日韩汉字等

Unicode字符集:

• 为表达任意语言的任意字符而设计，是业界的一种标准，也称为统一码、标准万国码。它最多使用4个字节的数字来表达每个字母、符号，或者文字。有三种编码方案，UTF-8、UTF-16和UTF32。最为常用的UTF-8编码

• UTF-8编码:可以用来表示Unicode标准中任意字符，它是电子邮件、网页及其他存储或传送文字的应用中，优先采用的编码。互联网工程工作小组(IETF）要求所有互联网协议都必须支持UTF-8编码。它使用一至四个字节为每个字符编码
  编码规则:
  128个US-ASCl字符，只需一个字节编码
  拉丁文等字符，需要二个字节编码
  大部分常用字(含中文)，使用三个字节编码
  其他极少使用的Unicode辅助字符，使用四字节编码
  小结:采用何种规则编码，就要采用对应规则解码，否则就会出现乱码

24.3.2字符串中的编码解码问题

这里我们采用的是IDEA平台来编写代码的。

编码：

• bytel]getBytes():使用平台的默认字符集将该String编码为一系列字节，将结果存储到新的字节数组中
• byte[] getBytes(String charsetName):使用指定的字符集将该String编码为一系列字节，将结果存储到新的字节数组中

解码：

• String(byte[] bytes):通过使用平台的默认字符集解码指定的字节数组来构造新的String
• String(byte[ ] bytes, String charsetName):通过指定的字符集解码指定的字节数组来构造新的String

package walking010;

import java.io.UnsupportedEncodingException;
import java.lang.reflect.Array;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;

public class StringDemo {
    public static void main(String[] args) throws UnsupportedEncodingException {
        //定义一个字符串
        String s = "中国";

        //bytel]getBytes():使用平台的默认字符集将该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);

    }
}

24.3.3字符流中的编码解码问题

字符流抽象基类

• Reader:字符输入流的抽象类
• Writer:字符输出流的抽象类

字符流中和编码解码问题相关的两个类:

• lnputStreamReader
• OutputStreamWriter

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

import java.io.*;

public class ConversionStreamDemo {
    public static void main(String[] args) throws IOException {
        //OutputStreamWriter(OutputStream out) 创建一个使用默认字符编码的OutputStreamWriter
        //OutputStreamWriter(OutputStream out，String  charseName) 创建一个使用命名字符集的OutputStreamWriter。
//        FileOutputStream fos = new FileOutputStream("walking\\osw.txt");
//        OutputStreamWriter osw = new OutputStreamWriter(fos);

//        OutputStreamWriter osw = new OutputStreamWriter (new FileOutputStream("walking\\osw.txt"),);
//        OutputStreamWriter osw = new OutputStreamWriter (new FileOutputStream("walking\\osw.txt"),"UTF-8");
        OutputStreamWriter osw = new OutputStreamWriter (new FileOutputStream("walking\\osw.txt"),"GBK");
        osw.write("中国");
        osw.close();

//        InputStreamReader (InputStream in)创建一个使用默认字符集的InputStreamReadero
//        InputStreamReader (InputStream in，String charsetName)创建一个使用命名字符集的InputStreamReader。
        InputStreamReader isr = new InputStreamReader (new FileInputStream("walking\\osw.txt"),"GBK");

        //一次读取一个字符数据
        int ch;
        while((ch= isr.read())!=-1){
            System.out.println((char)ch);
        }
        isr.close();
    }
}

24.3.4字符流写数据的5种方式

方法名	说明
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)	写一个字符串的一部分
flush()	刷新流，还可以继续写数据
close()	关闭流，释放资源，但是在关闭之前会先刷新流 一旦关闭，就不能再写数据

package walking011;

import walking010.FileInputStreamDemo;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

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

        //void write(int c):写一个字符
//        osw.write(97);
//        //字符流不能直接写的，要通过字节流写
//        //void flush():刷新流
//        osw.write(98);
//        osw.flush();
//        osw.write(99);

        //void write (char[] cbuf)写入一个字符数组
        char[] chs = {'a','b','c','d','e'};
//        osw.write(chs);
        //osw.write(chs,1,3);

        //void write(String str)写一个字符串
        //osw.write("abcde");

        //void write(String str,int off,int len)写一个字符串的一部分
        //osw.write("abcde",0,"abcde".length());
        osw.write("abcde",1,3);

        //释放资源
        osw.close();//先刷新缓冲再释放资源
//        osw.write(99);
    }
}

24.3.5字符流读数据的2种方式

方法名	说明
int read()	一次读一个字符数据
int read(char[] cbuf)	一次读一个字符数组数据

package walking011;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException {
        //InputStreamReaderDemo (InputStream in)创建一个使用默认字符集的InputStreamReader
        InputStreamReader isr = new InputStreamReader(new FileInputStream("walking\\ConversionStreamDemo.txt"));

        //int readO()一次读一个字符数据
//        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.print(new String(chs,0,len));
        }
        //释放资源
        isr.close();
    }
}

案例：复制Java文件

需求:把模块目录下的“ConversionStreamDemo.java”复制到模块目录下的“Copyjava”
思路:
根据数据源创建字符输入流对象
根据目的地创建字符输出流对象
读写数据，复制文件
释放资源

package walking012;

import java.io.*;

import java.io.IOException;

public class CopyJavaDemo01 {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字符输入流对象
        InputStreamReader isr = new InputStreamReader(new FileInputStream("walking\\ConversionStreamDemo.txt"));
        //根据目的地创建字符输出流对象
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("walking\\ConversionStreamDemo.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);
        }
        //释放资源
        osw.close();
        isr.close();
    }
}

案例：复制Java文件(改进版)

需求:把模块目录下的“ConversionStreamDemo.java”复制到模块目录下的“Copy.jav
分析:
转换流的名字比较长，而我们常见的操作都是按照本地默认编码实现的，所以，为了简化书写，转换流提供了对应的子类
FileReader:用于读取字符文件的便捷类
FileReader(String fileName)
FileWriter:用于写入字符文件的便捷类
FileWriter(String fileName)
数据源和目的地的分析
数据源: myCharStreaml\ConversionStreamDemojava–读数据—Reader —InputStreamReader —FileReader
目的地: myCharStreamll Copy.java —写数据— Writer — OutputStreamWriter —FileWriter

思路:

根据数据源创建字符输入流对象
根据目的地创建字符输出流对象
读写数据，复制文件
释放资源

package walking012;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyJavaDemo02 {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字符输入流对象
        FileReader fr = new FileReader("walking\\ConversionStreamDemo.java");
        //根据目的地创建字符输出流对象
        FileWriter fw = new FileWriter("walking\\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);
        }

        //释放资源
        fw.close();
        fr.close();
    }
}

24.3.6字符缓冲流

字符缓冲流:

• BufferedWriter:将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可以指定缓冲区大小，或者可以接受默认大小。默认值足够大，可用于大多数用途

• BufferedReader:从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取，可以指定缓冲区大小，或者可以使用默认大小。默认值足够大，可用于大多数用途

构造方法:

• BufferedWriter(Writer out)
• BufferedReader(Reader in)

package walking013;

import java.io.*;

public class BufferedStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //BufferedWriter(Writer out)
//        FileWriter fw = new FileWriter("walking\\bw.txt");
//        BufferedWriter bw = new BufferedWriter(fw);
        BufferedWriter bw = new BufferedWriter(new FileWriter("walking\\bw.txt"));
        bw.write("hello");
        bw.write("world");
        bw.close();

        //BufferedReader(Reader in)
        BufferedReader br = new BufferedReader(new FileReader("walking\\bw.txt"));

        //一次读取一个字符数组
        int ch;
        while ((ch= br.read())!=-1){
            System.out.println((char)ch);
        }

        //一次读取一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while((len= br.read())!=-1){
            System.out.print (new String(chs,0,len));
        }
        br.close();
    }
}

案例：复制Java文件(字符缓冲流改进版)

需求:把模块目录下的“ConversionStreamDemo.java”复制到模块目录下的“Copy.java"
思路:
根据数据源创建字符缓冲输入流对象
根据目的地创建字符缓冲输出流对象
读写数据，复制文件
释放资源

package walking013;

import java.io.*;

public class CopyJavaDemo {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("walking\\ConversionStreamDemo.java"));
        //根据目的地创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("walking\\Copy.java"));

        //读写数据，复制文件
        //一次读写一个字符数据
        int ch;
        while((ch= br.read())!=-1){
            bw.write(ch);
        }

        //一次读写一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while((len= br.read(chs))!=-1){
            bw.write(chs,0,len);
        }

        //释放资源
        bw.close();
        br.close();
    }
}

24.3.7字符缓冲流特有功能

BufferedWriter:

• void newLine():写一行行分隔符，行分隔符字符串由系统属性定义

BufferedReader:

• publicString readLine():读一行文字。结果包含行的内容的字符串，不包括任何行终止字符，如果流的结尾已经到达，则为null

package walking013;

import java.io.*;

public class BufferedStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //创建字符缓冲输出流
       /* BufferedWriter bw = new BufferedWriter(new FileWriter("walking\\bw.txt"));

        //写数据
        for(int i = 0;i<10;i++){
            bw.write("hello"+i);
            //bw.write("\r\n");
            bw.newLine();
            bw.flush();
        }

        //释放资源
        bw.close();*/

        //创建字符缓冲输入流
        BufferedReader br = new BufferedReader(new FileReader("walking\\bw.txt"));

        //public String readline()读一行文字
        /*//第一次读取数据
        String line = br.readLine();
        System.out.println(line);//hello0

        //第二次读取数据
        line = br.readLine();
        System.out.println(line);//hello1

        //在多读两次
        line = br.readLine();
        System.out.println(line);//hello2

        line = br.readLine();
        System.out.println(line);//hello3*/

        String line;
        while((line= br.readLine())!=null){
            System.out.println(line);
        }

        br.close();
    }
}

案例：复制Java文件（字符缓冲流特有功能改进版）

需求:把模块目录下的“ConversionStreamDemo.java”复制到模块目录下的“Copy.java
思路:
根据数据源创建字符缓冲输入流对象
根据目的地创建字符缓冲输出流对象
读写数据，复制文件

• 使用字符缓冲流特有功能实现

释放资源

package walking013;

import java.io.*;

public class CopyJavaDemo02 {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("walking\\ConversionStreamDemo.java"));
        //根据目的地创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("walking\\Copy.java"));

        //读写数据，复制文件
        //使用字符缓冲流特有功能实现
        String line;
        while ((line=br.readLine())!=null){
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        //释放资源
        bw.close();
        br.close();

    }
}

24.3.8IO流小结

小结：字节流可以复制任意文件数据，有4种方式一般采用字节缓冲流一次读写一个字节数组的方式

小结：字符流只能复制文本数据，有5种方式，一般采用字符缓冲流的特有功能

案例：集合到文件

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

package walking014;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

public class ArrayListToTxtDemo {
    public static void main(String[] args) throws IOException {
        //创建ArrayList集合
        ArrayList<String> array = new ArrayList<String>();

        //往集合中存储字符串元素
        array.add("hello");
        array.add("world");
        array.add("java");

        //创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("walking.array.txt"));

        //遍历集合，得到每一个字符串数据
        for(String s : array){
            //调用字符缓冲输出流对象的方法写数据
            bw.write(s);
            bw.newLine();
            bw.flush();
        }
        //释放资源
        bw.close();
    }
}

案例：文件到集合

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

package walking014;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;

public class TxtToArrayListDemo {
    public static void main(String[] args) throws IOException {
        //创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("walking\\array.txt"));

        //创建ArrayList集合对象
        ArrayList<String> array = new ArrayList<>();

        //调用字符缓冲输入流对象的方法读数据
        String line;
        while((line = br.readLine())!=null){
            //把读到的字符串数据存储到集合中
            array.add(line);
        }

        //释放资源
        br.close();

        //遍历集合
        for(String s : array){
            System.out.println(s);
        }
    }
}

案例：点名器

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

package walking014;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.Random;

public class CallNameDemo {
    public static void main(String[] args) throws IOException {
        //创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("walking\\names.txt"));

        //创建ArrayList集合对象
        ArrayList<String> array = new ArrayList<String>();

        //调用字符缓冲输入流对象的方法读数据
        String line;
        while((line = br.readLine())!=null){
            //把读到的字符串数据存储到集合中
            array.add(line);
        }

        //释放资源
        br.close();

        //使用Random产生一个随机数，随机数的范围在:[0,集合的长度)
        Random r = new Random();
        int index = r.nextInt(array.size());

        //把第6步产生的随机数作为索引到ArrayList集合中获取值
        String name = array.get(index);

        //把第7步得到的数据输出在控制台
        System.out.println("幸运者是：" + name);
    }
}

案例：集合到文件（改进版）

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

package walking015;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

public class ArrayListToFileDemo {
    public static void main(String[] args) throws IOException {
        //创建ArrayList集合
        ArrayList<Student> array = new ArrayList<>();

        //创建学生对象
        Student s1 = new Student("001","利拉德",30,"西安");
        Student s2 = new Student("002","约基奇",30,"丹佛");
        Student s3 = new Student("003","恩比德",30,"费城");
        Student s4 = new Student("004","戴维斯",30,"洛杉矶");

        //把学生对象添加到集合中
        array.add(s1);
        array.add(s2);
        array.add(s3);
        array.add(s4);

        //创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("walking\\students.txt"));

        //遍历集合，得到每一个学生对象
        for(Student s : array){
            //吧学生对象的数据拼接成指定格式的字符串
            StringBuilder sb = new StringBuilder();
            sb.append(s.getSid()).append(",").append(s.getName()).append(",").append(s.getAge()).append(",").append(s.getAddress());

            //调用字符输出流对象的方法写数据
            bw.write(sb.toString());
            bw.newLine();
            bw.flush();
        }

        //释放资源
        bw.close();
    }
}

案例：文件到集合（改进版）

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

package walking015;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;

public class FileToArrayListDemo {
    public static void main(String[] args) throws IOException {
        //创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("walking\\students.txt"));

        //创建ArrayList集合对象
        ArrayList<Student> array = new ArrayList<>();

        //调用字符缓冲输入流对象的方法读数据
        String line;
        while((line = br.readLine())!=null){
             //把读取到的字符串数据用split()进行分割，得到一个字符串数组
            String[] strArray = line.split(",");

            //创建学生对象
            Student s = new Student();
            //把字符串数组中的每一个元素取出来对应的赋值给学生对象的成员变量值
            //001,利拉德,30,西安
            s.setSid(strArray[0]);
            s.setName(strArray[1]);
            s.setAge(Integer.parseInt(strArray[2]));
            s.setAddress(strArray[3]);

            //把学生对象添加到集合
            array.add(s);
        }

        //遍历集合
        for(Student s : array){
            System.out.println(s.getSid()+","+s.getName()+","+s.getAge()+","+s.getAddress());
        }
    }
}

案例：集合到文件（数据排序改进版）

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

package walking016;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;

public class TreeSetToFileDemo {
    public static void main(String[] args) throws IOException {
        //创建TreeSet集合，通过比较器排序进行排序
        TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                //成绩总分从高到低
                int num = s2.getSum()-s1.getSum();
                //次要条件
                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;
            }
        });

        //Scanner sc = new Scanner(System.in);

        //键盘录入学生数据
        for(int i = 0;i<2;i++){
            Scanner sc = new Scanner(System.in);
            System.out.println("请录入第"+(i+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("walking\\ts.txt"));

        //遍历集合，得到每一个学生对象
        for(Student s : ts){
            //把学生对象的数据拼接成指定格式的字符串
            //格式：姓名，语文成绩，数学成绩，英语成绩
            StringBuilder sb = new StringBuilder();
            sb.append(s.getName()).append(",").append(s.getChinese()).append(",").append(s.getMath()).append(",").append(s.getEnglish()).append(",").append(s.getSum());

            //调用字符缓冲输出流对象的方法写数据
            bw.write(sb.toString());
            bw.newLine();
            bw.flush();
        }
        
        //释放资源
        bw.close();
    }
}

案例：赋值单级文件夹

需求:把“CS”这个文件夹复制到模块目录下
思路:
创建数据源目录File对象，路径是E:\CS
获取数据源目录File对象的名称(CS)
创建目的地目录File对象，路径名是模块名+CS组成(walking\CS)
判断目的地目录对应的File是否存在，如果不存在，就创建
获取数据源目录下所有文件的File数组
遍历File数组，得到每一个File对象，该File对象，其实就是数据源文件
数据源文件:E:llitcast\lld.jpg
获取数据源文件File对象的名称(lld.jpg)
创建目的地文件File对象，路径名是目的地目录+mn.jpg组成(myCharStream\\CS\\lld.jpg)
复制文件
由千文件不仅仅是文本文件，还有图片，视频等文件，所以采用字节流复制文件

package walking017;

import java.io.*;

public class CopyFoldeDemo {
    public static void main(String[] args) throws IOException {
        //创建数据源目录File对象，路径是E:\CS
        File srcFolder = new File("E:\\CS");

        //获取数据源目录File对象的名称(CS)
        String srcFolderName = srcFolder.getName();

        //创建目的地目录File对象，路径名是模块名+CS组成(walking\CS)
        File destFolder = new File("walking",srcFolderName);

        //判断目的地目录对应的File是否存在，如果不存在，就创建
        if(!destFolder.exists()){
            destFolder.mkdir();
        }

        //获取数据源目录下所有文件的File数组
        File[] listFiles = srcFolder.listFiles();

        //遍历File数组，得到每一个File对象，该File对象，其实就是数据源文件
        for(File srcFile : listFiles){
            //数据源文件E\\CS\\lld.jpg
            //获取数据源文件File对象的名称(lld.jpg)
            String srcFileName = srcFile.getName();
            //创建目的地文件File对象，路径名是目的地的目录+lld.jpg组成(walking\\CS\\lld.jpg)
            File destFile = new File(destFolder,srcFileName);
            //复制文件
            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[] bys = new byte[1024];
        int len;
        while((len=bis.read(bys))!=-1){
            bos.write(bys,0,len);
        }

        bos.close();
        bis.close();
        
    }
}

案例：复制多级文件夹

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

package walking017;

import java.io.*;

public class CopyFolderDemo02 {
    public static void main(String[] args)  throws IOException{
        //创建数据源File对象，路径是E:\\CS
        File srcFile = new File("E:\\CS");
        //创建目的地File对象，路径是F:\\
        File destFile = new File("D:\\");

        //写方法实现文件夹的复制，参数为数据源File对象和的目的地File对象
        copyFolder(srcFile,destFile);
    }

    //复制文件夹
    private static void copyFolder(File srcFile,File destFile) throws IOException {
        //判断数据源File是否是目录
        if(srcFile.isDirectory()){
            //在目的地下创建和数据源File名称一样的目录
            String srcFileName = srcFile.getName();
            File newFolder = new File(destFile,srcFileName);//F:\\CS
            if(!newFolder.exists()){
                newFolder.mkdirs();
            }
            //获取数据源File下所有文件或者目录的File数组
            File[] fileArray = srcFile.listFiles();

            //遍历该File数组，得到每一个File对象
            for(File file : fileArray){
                //把该File作为数据源File对象，递归调用复制文件文件夹的方法
                copyFolder(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[] bys = new byte[1024];
       int len;
       while ((len = bis.read(bys))!=-1){
            bos.write(bys,0,len);
       }

       bis.close();
       bos.close();
    }
}

24.3.9复制文件的异常处理

try…catch…finally的做法:

try {
    可能出现异常的代码;
}catch(异常类名变量名){
    异常的处理代码;
}finally{
    执行所有清除操作;
}

JDK7改进方案:

try(定义流对象){
    可能出现异常的代码;
}catch(异常类名变量名){
    异常的处理代码;
}
				自动释放资源

JDK9改进方案:

定义输入流对象;定义输出流对象;
try(输入流对象;输出流对象){
    可能出现异常的代码;
}catch(异常类名变量名){
    异常的处理代码;
}
自动释放资源

package walking018;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

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() throws IOException {
        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 {
            if (fw != null)
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            if (fr != null)
                try {
                    fr.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);
        }

        fw.close();
        fr.close();
    }
}

24.4特殊操作流

24.4.1标准输入输出流

System类中有两个静态的成员变量:

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

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

自己实现键盘录入数据:

• BufferedReader br = new -BufferedReader(new InputStreamReader(System.in));

写起来太麻烦，Java就提供了一个类实现键盘录入

• Scanner sc = new Scanner(System.in);

标准输入流：

package walking019;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Scanner;

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.print((char)by);
//        }

        //如何把字节流转换为字符流？用转换流
//        InputStreamReader isr = new InputStreamReader(is);
        //使用字符流能不能够实现一次读取一行数据呢？可以
        //但是，一次读取一行数据的方法是字符缓冲输入流的特有方法
//        BufferedReader br = new BufferedReader(isr);

//        BufferedReader br = new BufferedReader(isr);
        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);

        //自己实现键盘录入数据太麻烦了，所以Java提供了一个类供我们使用
        Scanner sc = new Scanner(System.in);
    }
}

标准输出流：

输出语句的本质:是一个标准的输出流

• PrintStream ps = System.out;
• PrintStream类有的方法，System.out都可以使用

package walking019;

import java.io.PrintStream;

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

        //能够方便打印各种信息
//        ps.print("hello");
//        ps.print(100);

        //System.out本质是一个字节输出流
        System.out.println("hello");
        System.out.println(100);

        System.out.println();
        //System.out.print();//必须带参数
    }
}

24.4.2打印流

打印流分类:

• 字节打印流:PrintStream
• 字符打印流: PrintWriter

打印流的特点:

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

字节打印流

• PrintStream(String fileName):使用指定的文件名创建新的打印流
• 使用继承父类的方法写数据，查看的时候会转码;使用自己的特有方法写数据，查看的数据原样输出

package walking020;

import java.io.IOException;
import java.io.PrintStream;

public class PrintStreamDemo {
    public static void main(String[] args) throws IOException {
        //PrintStream (String fileName)使用指定的文件名创建新的打印流
        PrintStream ps = new PrintStream("walking\\ps.txt");

        //写数据
        //字节输出流有的方法
//        ps.write(97);

        //使用特有方法写数据
//        ps.println(97);
//        ps.print(98);
        ps.println(97);
        ps.println(98);

        //释放资源
        ps.close();
    }
}

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

package walking020;

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

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

        pw.write("hello\r\n");//字符流需要刷新
        pw.write("world");
        pw.flush();

        pw.println("hello");
        pw.println("world");
        pw.flush();*/

        //PrintWriter (Writer out,boolean autoFlush):创建一个新的PrintWriter
        PrintWriter pw = new PrintWriter(new FileWriter("walking\\pw.txt"),true);

        pw.println("hello");
        /*
            pw.write("hello\r\n");
            pw.write("world");
            pw.flush();
         */
        pw.println("world");

        pw.close();
    }
}

案例：复制Java文件（打印流改进版）

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

package walking020;

import java.io.*;

public class CopyJavaDemo {
    public static void main(String[] args) throws IOException {
        /*//根据数据源创建字符输入流对象
        BufferedReader br = new BufferedReader(new FileReader("walking\\PrintStreamDemo.java"));
        //根据目的地创建字符输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("walking\\Copy.java"));

        //读写数据，复制文件
        String line;
        while((line = br.readLine()) !=null){
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        //释放资源
        bw.close();
        br.close();*/

        //根据数据源创建字符输入流对象
        BufferedReader br = new BufferedReader(new FileReader("walking\\PrintStreamDemo.java"));
        //根据目的地创建字符输出流对象
        PrintWriter pw = new PrintWriter(new FileWriter("walking\\Copy.java"),true);

        //读写数据，复制文件
        String line;
        while((line = br.readLine()) !=null){
            pw.write(line);
        }

        //释放资源
        pw.close();
        br.close();
    }
}

24.4.3对象序列化流

对象序列化流: ObjectOutputStream

• 将Java对象的原始数据类型和图形写入OutputStream。可以使用ObjectInputStream读取（重构)对象。可以通过使用流的文件来实现对象的持久存储。如果流是网络套接字流，则可以在另一个主机上或另一个进程中重构对象

构造方法:

• ObjectOutputStream(OutputStream out):创建一个写入指定的OutputStream的ObjectOutputStream

序列化对象的方法:

• void writeObject(Object obj):将指定的对象写入ObjectOutputStream

package walking020;

import java.io.*;

public class CopyJavaDemo {
    public static void main(String[] args) throws IOException {
        /*//根据数据源创建字符输入流对象
        BufferedReader br = new BufferedReader(new FileReader("walking\\PrintStreamDemo.java"));
        //根据目的地创建字符输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("walking\\Copy.java"));

        //读写数据，复制文件
        String line;
        while((line = br.readLine()) !=null){
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        //释放资源
        bw.close();
        br.close();*/

        //根据数据源创建字符输入流对象
        BufferedReader br = new BufferedReader(new FileReader("walking\\PrintStreamDemo.java"));
        //根据目的地创建字符输出流对象
        PrintWriter pw = new PrintWriter(new FileWriter("walking\\Copy.java"),true);

        //读写数据，复制文件
        String line;
        while((line = br.readLine()) !=null){
            pw.write(line);
        }

        //释放资源
        pw.close();
        br.close();
    }
}

注意:

• 一个对象要想被序列化，该对象所属的类必须必须实现Serializable接口

• Serializable是个标记接口，实现该接口，不需要重写任何方法

24.4.3.1对象反序列化流

对象反序列化流:ObjectInputStream

• ObjectInputStream反序列化先前使用ObjectOutputStream编写的原始数据和对象

构造方法:

• ObjectInputStream(InputStream in):创建从指定的InputStream读取的ObjectInputStream

反序列化对象的方法:

• ·Object readObject(): 从ObjectInputStream读取一个对象

package walking021;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
/*
构造方法:
0bjectInputStream (InputStream in):创建从指定的InputStreami读取的ObjectInputStream
反序列化对象的方法:
Object readobject ():从0bjectInputStream读取一个对象

 */
public class ObjectInputStreamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //0bjectInputStream (InputStream in):创建从指定的InputStreami读取的objectInputStream
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("walking\\oos.txt"));

        //Object readobject ():从0bjectInputStream读取一个对象
        Object obj = ois.readObject();

        Student s = (Student) obj;
        System.out.println(s.getName()+","+s.getAge());

        ois.close();
    }
}

24.4.3.2serialVersionUID&transient

用对象序列化流序列化了一个对象后，假如我们修改了对象所属的类文件，读取数据会不会出问题呢?

• 会出问题，抛出InvalidClassException异常

如果出问题了，如何解决呢?

• 给对象所属的类加一个serialVersionUID
  private static final long serialVersionUID = 42L;

如果一个对象中的某个成员变量的值不想被序列化，又该如何实现呢?

• 给该成员变量加transient关键字修饰，该关键字标记的成员变量不参与序列化过程

package walking021;
/*
用对象序列化流序列化了一个对象后，假如我们修改了对象所属的类文件，读取数据会不会出问题呢?
java.io.InvalidClassException:
 walking021.Student; local class incompatible:
 stream classdesc serialVersionUID = -3667821032316295097,
 local class serialVersionUID = -8505330761121703770
 当予列化运行时检测到类中的以口题之—时抛出。
        类的串行版本与从流中读取的类描述符的类型不匹配
        该类包含未知的数据类型
        该类没有可访间的无参数构造函数

如果出问题了，如何解决呢?
    给对象所属的类加一个值：private static final long serialVersionUID = 42L;

如果一个对象中的某个成员变量的值不想被序列化，又该如何实现呢?

 */
import java.io.*;

public class ObjectStreamDemo {
    public static void main(String[] args) throws IOException,ClassNotFoundException{
        write();
        read();
    }
    //反序列化
    private static void read() throws IOException,ClassNotFoundException{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("walking\\oos.txt"));
        Object obj = ois.readObject();
        Student s = (Student) obj;
        System.out.println(s.getName()+s.getAge());
        ois.close();
    }

    //序列化
    private static void write() throws IOException{
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("walking\\oos.txt"));
        Student s = new Student("利拉德",30);
        oos.writeObject(s);
        oos.close();
    }
}

24.4.4Properties

Properties概述:

• 是一个Map体系的集合类
• Properties可以保存到流中或从流中加载

24.4.4.1Properties作为Map集合使用

练习: Properties作为Map集合的使用

package walking022;

import java.util.Properties;
import java.util.Set;

public class PropertiesDemo01 {
    public static void main(String[] args){
        //创建集合对象
        Properties prop = new Properties();

        //存储元素
        prop.put("开拓者1","利拉德");
        prop.put("开拓者2","达米安");
        prop.put("开拓者3","恩比德");

        //遍历集合
        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 stringPropertyNames()	从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串

package walking022;

import java.util.Properties;
import java.util.Set;

public class PropertiesDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        Properties prop = new Properties();

        //Object setProperty(String key, String value)设置集合的键和值，都是String类型，底层调用Hashtable方法put
        prop.setProperty("开拓者1","利拉德");
        /*
        0bject setProperty(String key,-String value)i
            return put( key, value) ;
        }
        Object put(object key, 0bject value) {
            return map.put ( key,value);
        }让本来是Object来接收String类型的设计
        底层用了HashTable的put方法
         */
        prop.setProperty("开拓者2","科比");
        prop.setProperty("开拓者3","乔丹");

        //String getProperty(String key)使用此属性列表中指定的键搜索属性
        System.out.println(prop.getProperty("开拓者1"));
        System.out.println(prop.getProperty("开拓者5"));

        System.out.println(prop);

        //Set<String> stringPropertyNames()从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串
        Set<String> names = prop.stringPropertyNames();
        for(String key : names){
            //System.out.println(key);只打印key
            String value = prop.getProperty(key);
            System.out.println(key + value);
        }
    }
}

24.4.4.2Properties和IO流结合使用

Properties和IO流结合的方法:

方法名	说明
void load(InputStream inStream)	从输入字节流读取属性列表(键和元素对)
void load(Reader reader)	从输入字符流读取属性列表（键和元素对)从文本文件数据加到Properties集合中
void store(OutputStream out, String comments)	将此属性列表(键和元素对)写入此Properties表中，以适合于使用load(InputStream)方法的格式写入输出字节流
void store(Writer writer, String comments)	将此属性列表(键和元素对)写入此Properties表中，以适合于使用使用load(Reader)方法的格式写入输出字符流

package walking022;

import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;

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

    private static void myStore() throws IOException {
        Properties prop = new Properties();

        prop.setProperty("开拓者1","利拉德");
        prop.setProperty("开拓者2","恩比德");
        prop.setProperty("开拓者3","约基奇");

        //void store(Writer writer, String comments)
        FileWriter fw = new FileWriter("walking\\fw.txt");
        prop.store(fw,"+65654");//第二个参数是注释。
        fw.close();
    }
}

案例：游戏次数

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

package walking022;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;

public class PropertiesTest {
    public static void main(String[] args) throws IOException {
        //从文件中读取数据到Properties集合，用load()方法实现
        Properties prop = new Properties();

        FileReader fr = new FileReader("walking\\game.txt");
        prop.load(fr);
        fr.close();

        //通过Properties集合获取到玩游戏的次数
        String count = prop.getProperty("count");
        int number = Integer.parseInt(count);

        //判断此时是否到3次了
        if(number >=3){
            //如果到了，给出提示：游戏试玩已结束，想玩请充值(www.lxh.cn)
            System.out.println("游戏试玩已结束，想玩请充值(www.lxh.cn)");
        }else{
            //玩游戏
            GuessNumber.start();

            //次数+1，重新写回文件,用Properties的store()方法实现
            number++;
            prop.setProperty("count",String.valueOf(number));
            FileWriter fw = new FileWriter("walking\\game.txt");
            prop.store(fw,"lxh");
            fw.close();
        }

    }
}

参考资料

https://www.bilibili.com/video/BV18J411W7cE?p=1