Java入门级教学（超详细&中）

cocochimp

已于 2024-05-13 17:50:47 修改

阅读量676

点赞数

分类专栏： Java技术栈学习系列文章标签： java jvm 开发语言

于 2023-02-01 14:34:43 首次发布

本文链接：https://blog.csdn.net/m0_51634403/article/details/128833433

版权

Java技术栈学习系列专栏收录该内容

29 篇文章 18 订阅

订阅专栏

项目和markdown文件资料：
https://github.com/cocochimp/Java-H5-Study-Resources

文章目录

7. IO流
8. 经典案例

7. IO流

概述

IO流分为“字节流”和“字符流”两种形式

字节流

字符流

IO流介绍
- IO：输入/输出(Input/Output)
- 流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输
- IO流就是用来处理设备间数据传输问题的。常见的应用：文件复制；文件上传；文件下载
IO流的分类
- 按照数据的流向
  - 输入流：读数据
  - 输出流：写数据
- 按照数据类型来分
  - 字节流
    - 字节输入流
    - 字节输出流
  - 字符流
    - 字符输入流
    - 字符输出流
IO流的使用场景
- 如果操作的是纯文本文件，优先使用字符流
- 如果操作的是图片、视频、音频等二进制文件。优先使用字节流
- 如果不确定文件类型，优先使用字节流。字节流是万能的流

7.1 File类

File类介绍
- 它是文件和目录路径名的抽象表示
- 文件和目录是可以通过File封装成对象的
- 对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以是不存在的。将来是要通过具体的操作把这个路径的内容转换为具体存在的
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("E:\\itcast\\java.txt");
        System.out.println(f1);
        
        //File(String parent, String child)：从父路径名字符串和子路径名字符串创建新的File实例。
        File f2 = new File("E:\\itcast","java.txt");
        System.out.println(f2);
        
        //File(File parent, String child)：从父抽象路径名和子路径名字符串创建新的 File实例。
        File f3 = new File("E:\\itcast");
        File f4 = new File(f3,"java.txt");
        System.out.println(f4);
    }
}

1、File类的创建功能

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

public class FileDemo02 {
    public static void main(String[] args) throws IOException {
        //需求1：我要在E:\\itcast目录下创建一个文件java.txt
        File f1 = new File("E:\\itcast\\java.txt");
        System.out.println(f1.createNewFile());
        System.out.println("--------");
        
        //需求2：我要在E:\\itcast目录下创建一个目录JavaSE
        File f2 = new File("E:\\itcast\\JavaSE");
        System.out.println(f2.mkdir());
        System.out.println("--------");
        
        //需求3：我要在E:\\itcast目录下创建一个多级目录JavaWEB\\HTML
        File f3 = new File("E:\\itcast\\JavaWEB\\HTML");
        // System.out.println(f3.mkdir());
        System.out.println(f3.mkdirs());
        System.out.println("--------");
        
        //需求4：我要在E:\\itcast目录下创建一个文件javase.txt
        File f4 = new File("E:\\itcast\\javase.txt");
        // System.out.println(f4.mkdir());
        System.out.println(f4.createNewFile());
    }
}

2、File类的判断和获取功能

判断功能

方法名	说明
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对象数组

public class FileDemo04 {
    public static void main(String[] args) {
        //创建一个File对象
        File f = new File("myFile\\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:\\itcast");
        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);
            // System.out.println(file.getName());
            if(file.isFile()) {
                System.out.println(file.getName());
            }
        }
    }
}

3、File类删除功能

方法分类

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

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

绝对路径和相对路径的区别
- 绝对路径：完整的路径名，不需要任何其他信息就可以定位它所表示的文件。例如：E:\itcast\java.txt
- 相对路径：必须使用取自其他路径名的信息进行解释。例如：myFile\java.txt

4、递归遍历目录

案例需求

给定一个路径(E:\itcast)，通过递归完成遍历该目录下所有内容，并把所有文件的绝对路径输出在控制台

public class DiGuiDemo02 {
    public static void main(String[] args) {
        //根据给定的路径创建一个File对象
        // File srcFile = new File("E:\\itcast");
        File srcFile = new File("E:\\itheima");
        //调用方法
        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) {
                //判断该File对象是否是目录
                if(file.isDirectory()) {
                    //是：递归调用
                    getAllFilePath(file);
                } else {
                    //不是：获取绝对路径输出在控制台
                    System.out.println(file.getAbsolutePath());
                }
            }
        }
    }
}

7.2 字节流

概述

字节流抽象基类

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

7.2.1 字节输出流

1、字节流写数据

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

public class FileOutputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        //FileOutputStream(String name)：创建文件输出流以指定的名称写入文件
        FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");
        /*
        做了三件事情：
        A:调用系统功能创建了文件
        B:创建了字节输出流对象
        C:让字节输出流对象指向创建好的文件
        */
        
        //void write(int b)：将指定的字节写入此文件输出流
        fos.write(97);
        // fos.write(57);
        // fos.write(55);
        //最后都要释放资源
        //void close()：关闭此文件输出流并释放与此流相关联的任何系统资源。
        fos.close();
    }
}

字节流写数据的三种方式

方法名	说明
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("myByteStream\\fos.txt");
        //new File(name)
        // FileOutputStream fos = new FileOutputStream(new
        File("myByteStream\\fos.txt"));
        //FileOutputStream(File file)：创建文件输出流以写入由指定的 File对象表示的文件
        // File file = new File("myByteStream\\fos.txt");
        // FileOutputStream fos2 = new FileOutputStream(file);
        // FileOutputStream fos2 = new FileOutputStream(new
        File("myByteStream\\fos.txt"));
        //void write(int b)：将指定的字节写入此文件输出流
        // fos.write(97);
        // fos.write(98);
        // fos.write(99);
        // fos.write(100);
        // fos.write(101);
        // void write(byte[] b)：将 b.length字节从指定的字节数组写入此文件输出流
        // byte[] bys = {97, 98, 99, 100, 101};
        //byte[] getBytes()：返回字符串对应的字节数组
        byte[] bys = "abcde".getBytes();
        // fos.write(bys);
        //void write(byte[] b, int off, int len)：将 len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流
        // fos.write(bys,0,bys.length);
        fos.write(bys,1,3);
        //释放资源
        fos.close();
    }
}

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

字节流写数据如何实现换行
- windows:\r\n
- linux:\n
- mac:\r
字节流写数据如何实现追加写入
- public FileOutputStream(String name,boolean append)
- 创建文件输出流以指定的名称写入文件。如果第二个参数为true ，则字节将写入文件的末尾而不是开头

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

3、字节流写数据加异常处理

异常处理格式

try-catch-finally

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

finally特点
- 被finally控制的语句一定会执行，除非JVM退出

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

7.2.2 字节输入流

1、字节流读数据(一次读一个字节数据)

字节输入流
- FileInputStream(String name)：通过打开与实际文件的连接来创建一个FileInputStream ，该文件由文件系统中的路径名name命名
字节输入流读取数据的步骤
- 创建字节输入流对象
- 调用字节输入流对象的读数据方法
- 释放资源

public class FileInputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        //FileInputStream(String name)
        FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");
        int by;
        /*
        fis.read()：读数据
        by=fis.read()：把读取到的数据赋值给by
        by != -1：判断读取到的数据是否是-1
        */
        while ((by=fis.read())!=-1) {
            System.out.print((char)by);
        }
        //释放资源
        fis.close();
    }
}

2、字节流复制文本文件

案例需求

把“E:\itcast\窗里窗外.txt”复制到模块目录下的“窗里窗外.txt”
实现步骤
- 复制文本文件，其实就把文本文件的内容从一个文件中读取出来(数据源)，然后写入到另一个文件中(目的地)
- 数据源： E:\itcast\窗里窗外.txt — 读数据 — InputStream — FileInputStream
- 目的地： myByteStream\窗里窗外.txt — 写数据 — OutputStream — FileOutputStream

public class CopyTxtDemo {
	public static void main(String[] args) throws IOException {
        //根据数据源创建字节输入流对象
        FileInputStream fis = new FileInputStream("E:\\itcast\\窗里窗外.txt");
        //根据目的地创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("myByteStream\\窗里窗外.txt");
        //读写数据，复制文本文件(一次读取一个字节，一次写入一个字节)
        int by;
        while ((by=fis.read())!=-1) {
        fos.write(by);

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

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

一次读一个字节数组的方法
- public int read(byte[] b)：从输入流读取最多b.length个字节的数据
- 返回的是读入缓冲区的总字节数,也就是实际的读取字节个数

public class FileInputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");
        /*
        hello\r\n
        world\r\n
        第一次：hello
        第二次：\r\nwor
        第三次：ld\r\nr
        */
        byte[] bys = new byte[1024]; //1024及其整数倍
        int len;
        while ((len=fis.read(bys))!=-1) {
            System.out.print(new String(bys,0,len));
        }
        //释放资源
        fis.close();
    }
}

4、字节流复制文本文件

案例需求

把“E:\itcast\窗里窗外.txt”复制到模块目录下的“窗里窗外.txt”
实现步骤
- 复制文本文件，其实就把文本文件的内容从一个文件中读取出来(数据源)，然后写入到另一个文件中(目的地)
- 数据源：
  
  E:\itcast\窗里窗外.txt — 读数据 — InputStream — FileInputStream
- 目的地：
  
  myByteStream\窗里窗外.txt — 写数据 — OutputStream — FileOutputStream

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

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

一次读一个字节数组的方法
- public int read(byte[] b)：从输入流读取最多b.length个字节的数据
- 返回的是读入缓冲区的总字节数,也就是实际的读取字节个数

public class FileInputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");
        /*
        hello\r\n
        world\r\n
        第一次：hello
        第二次：\r\nwor
        第三次：ld\r\nr
        */
        byte[] bys = new byte[1024]; //1024及其整数倍
        int len;
        while ((len=fis.read(bys))!=-1) {
            System.out.print(new String(bys,0,len));
        }
        //释放资源
        fis.close();
    }
}

6、字节流复制图片

案例需求

把“E:\itcast\mn.jpg”复制到模块目录下的“mn.jpg”
实现步骤
- 根据数据源创建字节输入流对象
- 根据目的地创建字节输出流对象
- 读写数据，复制图片(一次读取一个字节数组，一次写入一个字节数组)
- 释放资源

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

7.3 字节缓冲流(*)

1、概述

字节缓冲流介绍
- lBufferOutputStream：该类实现缓冲输出流。通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用
- lBufferedInputStream：创建BufferedInputStream将创建一个内部缓冲区数组。当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节
构造方法

方法名	说明
BufferedOutputStream(OutputStream out)	创建字节缓冲输出流对象
BufferedInputStream(InputStream in)	创建字节缓冲输入流对象

public class BufferStreamDemo {
    public static void main(String[] args) throws IOException {
        //字节缓冲输出流：BufferedOutputStream(OutputStream out)
        BufferedOutputStream bos = new BufferedOutputStream(new
                                                            FileOutputStream("myByteStream\\bos.txt"));
        //写数据
        bos.write("hello\r\n".getBytes());
        bos.write("world\r\n".getBytes());
        //释放资源
        bos.close();
        //字节缓冲输入流：BufferedInputStream(InputStream in)
        BufferedInputStream bis = new BufferedInputStream(new
                                                          FileInputStream("myByteStream\\bos.txt"));
        //一次读取一个字节数据
        // int by;
        // while ((by=bis.read())!=-1) {
        // System.out.print((char)by);
        // }
        //一次读取一个字节数组数据
        byte[] bys = new byte[1024];
        int len;
        while ((len=bis.read(bys))!=-1) {
            System.out.print(new String(bys,0,len));
        }

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

2、字节流复制视频

案例需求

把“E:\itcast\字节流复制图片.avi”复制到模块目录下的“字节流复制图片.avi”
实现步骤
- 根据数据源创建字节输入流对象
- 根据目的地创建字节输出流对象
- 读写数据，复制视频
- 释放资源

public class CopyAviDemo {
    public static void main(String[] args) throws IOException {
        //记录开始时间
        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("myByteStream\\字节流复制图片.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("myByteStream\\字节流复制图片.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("myByteStream\\字节流复制图片.avi");
        byte[] bys = new byte[1024];
        int len;
        while ((len=fis.read(bys))!=-1) {
            fos.write(bys,0,len);
        }
        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("myByteStream\\字节流复制图片.avi");
        int by;
        while ((by=fis.read())!=-1) {
            fos.write(by);
        }
        fos.close();
        fis.close();
    }
}

7.4 字符流

1、为什么会出现字符流

字符流的介绍

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

字符流 = 字节流 + 编码表
中文的字节存储方式

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

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

2、编码表

什么是字符集

是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等 l计算机要准确的存储和识别各种字符集符号，就需要进行字符编码，一套字符集必然至少有一套字符编码。常见字符集有ASCII字符集、GBXXX字符集、Unicode字符集等
常见的字符集
- ASCII字符集：
  
  lASCII：是基于拉丁字母的一套电脑编码系统，用于显示现代英语，主要包括控制字符(回车键、退格、换行键等)和可显示字符(英文大小写字符、阿拉伯数字和西文符号)
  
  基本的ASCII字符集，使用7位表示一个字符，共128字符。ASCII的扩展字符集使用8位表示一个字符，共 256字符，方便支持欧洲常用字符。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等
- GBXXX字符集：
  
  GBK：最常用的中文码表。是在GB2312标准基础上的扩展规范，使用了双字节编码方案，共收录了 21003个汉字，完全兼容GB2312标准，同时支持繁体汉字以及日韩汉字等
- Unicode字符集：
  
  UTF-8编码：可以用来表示Unicode标准中任意字符，它是电子邮件、网页及其他存储或传送文字的应用中，优先采用的编码。互联网工程工作小组（IETF）要求所有互联网协议都必须支持UTF-8编码。它使用一至四个字节为每个字符编码
- 编码规则： 128个US-ASCII字符，只需一个字节编码拉丁文等字符，需要二个字节编码大部分常用字（含中文），使用三个字节编码 其他极少使用的Unicode辅助字符，使用四字节编码

3、字符串中的编码解码问题

相关方法

方法名	说明
byte[] getBytes()	使用平台的默认字符集将该 String编码为一系列字节
byte[] getBytes(String charsetName)	使用指定的字符集将该 String编码为一系列字节
String(byte[] bytes)	使用平台的默认字符集解码指定的字节数组来创建字符串
String(byte[] bytes, String charsetName)	通过指定的字符集解码指定的字节数组来创建字符串

public class StringDemo {
    public static void main(String[] args) throws UnsupportedEncodingException {
        //定义一个字符串
        String s = "中国";
        //byte[] bys = s.getBytes(); //[-28, -72, -83, -27, -101, -67]
        //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 ss = new String(bys);
        //String ss = new String(bys,"UTF-8");
        String ss = new String(bys,"GBK");
        System.out.println(ss);
    }
}

4、字符流中的编码解码问题

字符流中和编码解码问题相关的两个类
- InputStreamReader：是从字节流到字符流的桥梁
  
  它读取字节，并使用指定的编码将其解码为字符
  
  它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集
- OutputStreamWriter：是从字符流到字节流的桥梁
  
  是从字符流到字节流的桥梁，使用指定的编码将写入的字符编码为字节
  
  它使用的字符集可以由名称指定，也可以被明确指定，或者可以接受平台的默认字符集
构造方法

方法名	说明
InputStreamReader(InputStream in)	使用默认字符编码创建InputStreamReader对象
InputStreamReader(InputStream in,String chatset)	使用指定的字符编码创建InputStreamReader对象
OutputStreamWriter(OutputStream out)	使用默认字符编码创建OutputStreamWriter对象
OutputStreamWriter(OutputStream out,String charset)	使用指定的字符编码创建OutputStreamWriter对象

public class ConversionStreamDemo {
    public static void main(String[] args) throws IOException {
        //OutputStreamWriter osw = new OutputStreamWriter(new
        FileOutputStream("myCharStream\\osw.txt"));
        OutputStreamWriter osw = new OutputStreamWriter(new
                                                        FileOutputStream("myCharStream\\osw.txt"),"GBK");
        osw.write("中国");
        osw.close();
        //InputStreamReader isr = new InputStreamReader(new
        FileInputStream("myCharStream\\osw.txt"));
        InputStreamReader isr = new InputStreamReader(new
                                                      FileInputStream("myCharStream\\osw.txt"),"GBK");
        //一次读取一个字符数据
        int ch;
        while ((ch=isr.read())!=-1) {
            System.out.print((char)ch);
        }
        isr.close();
    }
}

7.4.1 字符输出流

方法介绍

方法名	说明
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()	关闭流，释放资源，但是在关闭之前会先刷新流。一旦关闭，就不能再写数据

public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException {
        OutputStreamWriter osw = new OutputStreamWriter(new
                                                        FileOutputStream("myCharStream\\osw.txt"));
        //void write(int c)：写一个字符
        // osw.write(97);
        // osw.write(98);
        // osw.write(99);
        //void writ(char[] cbuf)：写入一个字符数组
        char[] chs = {'a', 'b', 'c', 'd', 'e'};
        // osw.write(chs);
        //void write(char[] cbuf, int off, int len)：写入字符数组的一部分
        // osw.write(chs, 0, chs.length);
        // 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();
    }
}

7.4.2 字符输入流

方法介绍

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

public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(new
                                                      FileInputStream("myCharStream\\ConversionStreamDemo.java"));
        //int read()：一次读一个字符数据
        // int ch;
        // while ((ch=isr.read())!=-1) {
        // System.out.print((char)ch);
        // }
        //int read(char[] cbuf)：一次读一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while ((len = isr.read(chs)) != -1) {
            System.out.print(new String(chs, 0, len));
        }
        //释放资源
        isr.close();
    }
}

1、字符流复制Java文件

案例需求

把模块目录下的“ConversionStreamDemo.java” 复制到模块目录下的“Copy.java”
实现步骤
- 根据数据源创建字符输入流对象
- 根据目的地创建字符输出流对象
- 读写数据，复制文件
- 释放资源

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

2、字符流复制Java文件改进版

案例需求

使用便捷流对象，把模块目录下的“ConversionStreamDemo.java” 复制到模块目录下的“Copy.java”
实现步骤
- 根据数据源创建字符输入流对象
- 根据目的地创建字符输出流对象
- 读写数据，复制文件
- 释放资源

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

7.5 字符缓冲流(*)

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

方法名	说明
BufferedWriter(Writer out)	创建字符缓冲输出流对象
BufferedReader(Reader in)	创建字符缓冲输入流对象

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

1、字符缓冲流复制Java文件

案例需求

把模块目录下的ConversionStreamDemo.java 复制到模块目录下的 Copy.java
实现步骤
- 根据数据源创建字符缓冲输入流对象
- 根据目的地创建字符缓冲输出流对象
- 读写数据，复制文件，使用字符缓冲流特有功能实现
- 释放资源

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

2、字符缓冲流特有功能

方法介绍

BufferedWriter

方法名说明
void newLine() 写一行行分隔符，行分隔符字符串由系统属性定义
BufferedReader

方法名说明
String readLine() 读一行文字。结果包含行的内容的字符串，不包括任何行终止字符如果流的结尾已经到达，则为null

方法名	说明
void newLine()	写一行行分隔符，行分隔符字符串由系统属性定义

方法名	说明
String readLine()	读一行文字。结果包含行的内容的字符串，不包括任何行终止字符如果流的结尾已经到达，则为null

public class BufferedStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //创建字符缓冲输出流
        BufferedWriter bw = new BufferedWriter(new
                                               FileWriter("myCharStream\\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("myCharStream\\bw.txt"));
        String line;
        while ((line=br.readLine())!=null) {
            System.out.println(line);
        }
        br.close();
    }
}

3、字符缓冲流特有功能复制Java文件

案例需求

使用特有功能把模块目录下的ConversionStreamDemo.java 复制到模块目录下的 Copy.java
实现步骤
- 根据数据源创建字符缓冲输入流对象
- 根据目的地创建字符缓冲输出流对象
- 读写数据，复制文件，使用字符缓冲流特有功能实现
- 释放资源

public class CopyJavaDemo02 {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new
                                               FileReader("myCharStream\\ConversionStreamDemo.java"));
        //根据目的地创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new
                                               FileWriter("myCharStream\\Copy.java"));
        //读写数据，复制文件
        //使用字符缓冲流特有功能实现
        String line;
        while ((line=br.readLine())!=null) {
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        //释放资源
        bw.close();
        br.close();
    }
}

7.6 字节字符案例

7.6.1 集合到文件

案例需求

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

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

7.6.2 文件到集合

案例需求

把ArrayList集合中的字符串数据写入到文本文件。要求：每一个字符串元素作为文件中的一行数据
实现步骤
- 创建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("myCharStream\\array.txt"));
        //遍历集合，得到每一个字符串数据
        for(String s : array) {
            //调用字符缓冲输出流对象的方法写数据
            bw.write(s);
            bw.newLine();
            bw.flush();
        }
        //释放资源
        bw.close();
    }
}

7.6.3 点名器

案例需求

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

public class CallNameDemo {
    public static void main(String[] args) throws IOException {
        //创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new
                                               FileReader("myCharStream\\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);
    }
}

7.6.4 集合到文件【改进版】

案例需求

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

public class Student {
    private String sid;
    private String name;
    private int age;
    private String address;
    public Student() {
    }
    public Student(String sid, String name, int age, String address) {
        this.sid = sid;
        this.name = name;
        this.age = age;
        this.address = address;
    }
    public String getSid() {
        return sid;
    }
    public void setSid(String sid) {
        this.sid = sid;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
}

测试类

public class ArrayListToFileDemo {
    public static void main(String[] args) throws IOException {
        //创建ArrayList集合
        ArrayList<Student> array = new ArrayList<Student>();
        //创建学生对象
        Student s1 = new Student("itheima001", "林青霞", 30, "西安");
        Student s2 = new Student("itheima002", "张曼玉", 35, "武汉");
        Student s3 = new Student("itheima003", "王祖贤", 33, "郑州");
        //把学生对象添加到集合中
        array.add(s1);
        array.add(s2);
        array.add(s3);
        //创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new
                                               FileWriter("myCharStream\\students.txt"));
        //遍历集合，得到每一个学生对象
        for (Student s : array) {
            //把学生对象的数据拼接成指定格式的字符串
            StringBuilder sb = new StringBuilder();
            sb.append(s.getSid()).append(",").append(s.getName()).append(",").append(s.ge
                                                                                     tAge()).append(",").append(s.getAddress());
            //调用字符缓冲输出流对象的方法写数据
            bw.write(sb.toString());
            bw.newLine();
            bw.flush();
        }
        //释放资源
        bw.close();
    }
}

7.6.5 文件到集合【改进版】

案例需求

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

同上
测试类

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

7.7 IO流案例

7.7.1 集合到文件数据排序【改进版】

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

public class Student {
    // 姓名
    private String name;
    // 语文成绩
    private int chinese;
    // 数学成绩
    private int math;
    // 英语成绩
    private int english;
    public Student() {
        super();
    }
    public Student(String name, int chinese, int math, int english) {
        super();
        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 int getSum() {
        return this.chinese + this.math + this.english;
    }
}

测试类

public class TreeSetToFileDemo {
    public static void main(String[] args) throws IOException {
        //创建TreeSet集合，通过比较器排序进行排序
        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                //成绩总分从高到低
                int num = s2.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;
            }
        });
        //键盘录入学生数据
        for (int i = 0; i < 5; 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("myCharStream\\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();
    }
}

7.7.2 复制单级文件夹

案例需求
- 把“E:\itcast”这个文件夹复制到模块目录下
分析步骤
- 创建数据源目录File对象，路径是E:\itcast
- 获取数据源目录File对象的名称
- 创建目的地目录File对象，路径由(模块名+第2步获取的名称)组成
- 判断第3步创建的File是否存在，如果不存在，就创建
- 获取数据源目录下所有文件的File数组
- 遍历File数组，得到每一个File对象，该File对象，其实就是数据源文件
- 获取数据源文件File对象的名称
- 创建目的地文件File对象，路径由(目的地目录+第7步获取的名称)组成
- 复制文件由于不清楚数据源目录下的文件都是什么类型的，所以采用字节流复制文件采用参数为File的构造方法

public class CopyFolderDemo {
    public static void main(String[] args) throws IOException {
        //创建数据源目录File对象，路径是E:\\itcast
        File srcFolder = new File("E:\\itcast");
        //获取数据源目录File对象的名称(itcast)
        String srcFolderName = srcFolder.getName();
        //创建目的地目录File对象，路径名是模块名+itcast组成(myCharStream\\itcast)
        File destFolder = new File("myCharStream",srcFolderName);
        //判断目的地目录对应的File是否存在，如果不存在，就创建
        if(!destFolder.exists()) {
            destFolder.mkdir();
        }
        //获取数据源目录下所有文件的File数组
        File[] listFiles = srcFolder.listFiles();
        //遍历File数组，得到每一个File对象，该File对象，其实就是数据源文件
        for(File srcFile : listFiles) {
            //数据源文件：E:\\itcast\\mn.jpg
            //获取数据源文件File对象的名称(mn.jpg)
            String srcFileName = srcFile.getName();
            //创建目的地文件File对象，路径名是目的地目录+mn.jpg组成
            (myCharStream\\itcast\\mn.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();
    }
}

7.7.3 复制多级文件夹

案例需求
- 把“E:\itcast”这个文件夹复制到 F盘目录下
分析步骤
- 创建数据源File对象，路径是E:\itcast
- 创建目的地File对象，路径是F:\
- 写方法实现文件夹的复制，参数为数据源File对象和目的地File对象
- 判断数据源File是否是文件
- 是文件：直接复制，用字节流
- 不是文件：在目的地下创建该目录遍历获取该目录下的所有文件的File数组，得到每一个File对象回到3继续(递归)

public class CopyFoldersDemo {
    public static void main(String[] args) throws IOException {
        //创建数据源File对象，路径是E:\\itcast
        File srcFile = new File("E:\\itcast");
        //创建目的地File对象，路径是F:\\
        File destFile = new File("F:\\");
        //写方法实现文件夹的复制，参数为数据源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:\\itcast
            if(!newFolder.exists()) {
                newFolder.mkdir();
            }
            //获取数据源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);
        }
        bos.close();
        bis.close();
    }
}

7.7.4 复制文件的异常处理

1、基本做法

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

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

2、JDK7版本改进

public class CopyFileDemo {
    public static void main(String[] args) {
    }
    //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();
        }
    }
}

3、JDK9版本改进

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

7.8 IO特殊操作流

7.8.1 标准输入流

System类中有两个静态的成员变量
- public static final InputStream in：标准输入流。通常该流对应于键盘输入或由主机环境或用户指定的另一个输入源
- public static final PrintStream out：标准输出流。通常该流对应于显示输出或由主机环境或用户指定的另一个输出目标
自己实现键盘录入数据

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

7.8.2 标准输出流

System类中有两个静态的成员变量
- public static final InputStream in：标准输入流。通常该流对应于键盘输入或由主机环境或用户指定的另一个输入源
- public static final PrintStream out：标准输出流。通常该流对应于显示输出或由主机环境或用户指定的另一个输出目标
输出语句的本质：是一个标准的输出流
- PrintStream ps = System.out;
- PrintStream类有的方法，System.out都可以使用

public class SystemOutDemo {
    public static void main(String[] args) {
        //public static final PrintStream out：标准输出流
        PrintStream ps = System.out;
        //能够方便地打印各种数据值
        // ps.print("hello");
        // ps.print(100);
        // ps.println("hello");
        // ps.println(100);
        //System.out的本质是一个字节输出流
        System.out.println("hello");
        System.out.println(100);
        System.out.println();
        // System.out.print();
    }
}

7.8.3 字节打印流

打印流分类
- 字节打印流：PrintStream
- 字符打印流：PrintWriter
打印流的特点
- 只负责输出数据，不负责读取数据
- 永远不会抛出IOException
- 有自己的特有方法
字节打印流
- PrintStream(String fileName)：使用指定的文件名创建新的打印流
- 使用继承父类的方法写数据，查看的时候会转码；使用自己的特有方法写数据，查看的数据原样输出
- 可以改变输出语句的目的地
  
  public static void setOut(PrintStream out)：重新分配“标准”输出流

public class PrintStreamDemo {
    public static void main(String[] args) throws IOException {
        //PrintStream(String fileName)：使用指定的文件名创建新的打印流
        PrintStream ps = new PrintStream("myOtherStream\\ps.txt");
        //写数据
        //字节输出流有的方法
        // ps.write(97);
        //使用特有方法写数据
        // ps.print(97);
        // ps.println();
        // ps.print(98);
        ps.println(97);
        ps.println(98);
        //释放资源
        ps.close();
    }
}

7.8.4 字符打印流

字符打印流构造房方法

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

public class PrintWriterDemo {
    public static void main(String[] args) throws IOException {
        //PrintWriter(String fileName) ：使用指定的文件名创建一个新的PrintWriter，而不需要自动执行行刷新
        // PrintWriter pw = new PrintWriter("myOtherStream\\pw.txt");
        // pw.write("hello");
        // pw.write("\r\n");
        // pw.flush();
        // pw.write("world");
        // pw.write("\r\n");
        // pw.flush();
        // pw.println("hello");
        /*
        pw.write("hello");
        pw.write("\r\n");
        */
        // pw.flush();
        // pw.println("world");
        // pw.flush();
        //PrintWriter(Writer out, boolean autoFlush)：创建一个新的PrintWriter
        PrintWriter pw = new PrintWriter(new
                                         FileWriter("myOtherStream\\pw.txt"),true);
        // PrintWriter pw = new PrintWriter(new
        FileWriter("myOtherStream\\pw.txt"),false);
        pw.println("hello");
        /*
        pw.write("hello");
        pw.write("\r\n");
        pw.flush();
        */
        pw.println("world");
        pw.close();
    }
}

7.8.5 复制Java文件打印流【改进版】

案例需求
- 把模块目录下的PrintStreamDemo.java 复制到模块目录下的 Copy.java
分析步骤
- 根据数据源创建字符输入流对象
- 根据目的地创建字符输出流对象
- 读写数据，复制文件
- 释放资源

public class CopyJavaDemo {
    public static void main(String[] args) throws IOException {
        /*
        //根据数据源创建字符输入流对象
        BufferedReader br = new BufferedReader(new
        FileReader("myOtherStream\\PrintStreamDemo.java"));
        //根据目的地创建字符输出流对象
        BufferedWriter bw = new BufferedWriter(new
        FileWriter("myOtherStream\\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("myOtherStream\\PrintStreamDemo.java"));
        //根据目的地创建字符输出流对象
        PrintWriter pw = new PrintWriter(new
                                         FileWriter("myOtherStream\\Copy.java"),true);
        //读写数据，复制文件
        String line;
        while ((line=br.readLine())!=null) {
            pw.println(line);
        }
        //释放资源
        pw.close();
        br.close();
    }
}

7.9 对象序列化

概述

对象序列化介绍
- 对象序列化：就是将对象保存到磁盘中，或者在网络中传输对象
- 这种机制就是使用一个字节序列表示一个对象，该字节序列包含：对象的类型、对象的数据和对象中存储的属性等信息
- 字节序列写到文件之后，相当于文件中持久保存了一个对象的信息
- 反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化

7.9.1 对象序列化流

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

方法名	说明
ObjectOutputStream(OutputStream out)	创建一个写入指定的OutputStream的 ObjectOutputStream

序列化对象的方法

方法名	说明
void writeObject(Object obj)	将指定的对象写入ObjectOutputStream

学生类

public class Student implements Serializable {
    private String name;
    private int age;
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" +
            "name='" + name + '\'' +
            ", age=" + age +
            '}';
    }
}

测试类

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

注意事项
- 一个对象要想被序列化，该对象所属的类必须必须实现Serializable 接口
- Serializable是一个标记接口，实现该接口，不需要重写任何方法

7.9.2 对象反序列化流

对象反序列化流： ObjectInputStream
- ObjectInputStream反序列化先前使用ObjectOutputStream编写的原始数据和对象
构造方法

方法名	说明
ObjectInputStream(InputStream in)	创建从指定的InputStream读取的ObjectInputStream

反序列化对象的方法

方法名	说明
Object readObject()	从ObjectInputStream读取一个对象

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

7.9.3 serialVersionUID & transient

serialVersionUID
- 用对象序列化流序列化了一个对象后，假如我们修改了对象所属的类文件，读取数据会不会出问题呢？
  - 会出问题，会抛出InvalidClassException异常
- 如果出问题了，如何解决呢？
  - 重新序列化
  - 给对象所属的类加一个serialVersionUID
    - private static final long serialVersionUID = 42L;
transient
- 如果一个对象中的某个成员变量的值不想被序列化，又该如何实现呢？
  - 给该成员变量加transient关键字修饰，该关键字标记的成员变量不参与序列化过程
学生类

public class Student implements Serializable {
    private static final long serialVersionUID = 42L;
    private String name;
    // private int age;
    private transient int age;
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    // @Override
    // public String toString() {
    // return "Student{" +
    // "name='" + name + '\'' +
    // ", age=" + age +
    // '}';
    // }
}

测试类

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("myOtherStream\\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("myOtherStream\\oos.txt"));
        Student s = new Student("林青霞", 30);
        oos.writeObject(s);
        oos.close();
    }
}

7.10 Properties集合

Properties介绍
- 是一个Map体系的集合类
- Properties可以保存到流中或从流中加载
- 属性列表中的每个键及其对应的值都是一个字符串

public class PropertiesDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        // Properties<String,String> prop = new Properties<String,String>(); //错误
        Properties prop = new Properties();
        //存储元素
        prop.put("itheima001", "林青霞");
        prop.put("itheima002", "张曼玉");
        prop.put("itheima003", "王祖贤");
        //遍历集合
        Set<Object> keySet = prop.keySet();
        for (Object key : keySet) {
            Object value = prop.get(key);
            System.out.println(key + "," + value);
        }
    }
}

1、Properties作为Map集合的特有方法

特有方法

方法名	说明
Object setProperty(String key, String value)	设置集合的键和值，都是String类型，底层调用 Hashtable方法 put
String getProperty(String key)	使用此属性列表中指定的键搜索属性
Set stringPropertyNames()	从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串

public class PropertiesDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        Properties prop = new Properties();
        //Object setProperty(String key, String value)：设置集合的键和值，都是String类型，底层调用Hashtable方法put
        prop.setProperty("itheima001", "林青霞");
        /*
        Object setProperty(String key, String value) {
        return put(key, value);
        }
        Object put(Object key, Object value) {
        return map.put(key, value);
        }
        */
        prop.setProperty("itheima002", "张曼玉");
        prop.setProperty("itheima003", "王祖贤");
        //String getProperty(String key)：使用此属性列表中指定的键搜索属性
        // System.out.println(prop.getProperty("itheima001"));
        // System.out.println(prop.getProperty("itheima0011"));
        // System.out.println(prop);
        //Set<String> stringPropertyNames()：从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串
        Set<String> names = prop.stringPropertyNames();
        for (String key : names) {
            // System.out.println(key);
            String value = prop.getProperty(key);
            System.out.println(key + "," + value);
        }
    }
}

2、Properties和IO流相结合的方法

和IO流结合的方法

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

public class PropertiesDemo03 {
    public static void main(String[] args) throws IOException {
        //把集合中的数据保存到文件
        // myStore();
        //把文件中的数据加载到集合
        myLoad();
    }
    private static void myLoad() throws IOException {
        Properties prop = new Properties();
        //void load(Reader reader)：
        FileReader fr = new FileReader("myOtherStream\\fw.txt");
        prop.load(fr);
        fr.close();
        System.out.println(prop);
    }
    private static void myStore() throws IOException {
        Properties prop = new Properties();
        prop.setProperty("itheima001","林青霞");
        prop.setProperty("itheima002","张曼玉");
        prop.setProperty("itheima003","王祖贤");
        //void store(Writer writer, String comments)：
        FileWriter fw = new FileWriter("myOtherStream\\fw.txt");
        prop.store(fw,null);
        fw.close();
    }
}

8. 经典案例

8.1 基础练习(基本语法)

逢七必过

从任意一个数字开始报数，当你要报的数字包含7或者是7 的倍数时都要说：过。为了帮助大家更好的玩这个游戏，这里我们直接在控制台打印出1-100之间的满足逢七必过规则的数据。这样，大家将来在玩游戏的时候，就知道哪些数据要说：过。

/*
    思路：
    1:数据在1-100之间，用for循环实现数据的获取
    2:根据规则，用if语句实现数据的判断：要么个位是7，要么十位是7，要么能够被7整除
    3:在控制台输出满足规则的数据
*/
public class Test03 {
    public static void main(String[] args) {
        //数据在1-100之间，用for循环实现数据的获取
        for(int x=1; x<=100; x++) {
        //根据规则，用if语句实现数据的判断：要么个位是7，要么十位是7，要么能够被7整除
            if(x%10==7 || x/10%10==7 || x%7==0) {
            //在控制台输出满足规则的数据
        		System.out.println(x);
    		}
    	}
    }
}

不死神兔

有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？

/*
    思路：
    1:为了存储多个月的兔子对数，定义一个数组，用动态初始化完成数组元素的初始化，长度为20
    2:因为第1个月，第2个月兔子的对数是已知的，都是1，所以数组的第1个元素，第2个元素值也都是1
    3:用循环实现计算每个月的兔子对数
    4:输出数组中最后一个元素的值，就是第20个月的兔子对数
*/
public class Test04 {
    public static void main(String[] args) {
        //为了存储多个月的兔子对数，定义一个数组，用动态初始化完成数组元素的初始化，长度为20
        int[] arr = new int[20];
        //因为第1个月，第2个月兔子的对数是已知的，都是1，所以数组的第1个元素，第2个元素值也都是1
        arr[0] = 1;
        arr[1] = 1;
        //用循环实现计算每个月的兔子对数
        for(int x=2; x<arr.length; x++) {
        	arr[x] = arr[x-2] + arr[x-1];
        }
        //输出数组中最后一个元素的值，就是第20个月的兔子对数
        System.out.println("第二十个月兔子的对数是：" + arr[19]);
    }
}

百钱百鸡

我国古代数学家张丘建在《算经》一书中提出的数学问题：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？

/*
    思路：
    1:第1层循环，用于表示鸡翁的范围，初始化表达式的变量定义为 x=0，判断条件是x<=20
    2:第2层循环，用于表示鸡母的范围，初始化表达式的变量定义为 y=0，判断条件是y<=33
    3:这个时候，用于表示鸡雏的变量 z = 100 – x – y
    4:判断表达式 z%3==0 和表达式 5*x + 3*y + z/3 = 100 是否同时成立，如果成立，输出对应的
    x，y，z 的值，就是对应的鸡翁，鸡母，鸡雏的值
*/
public class Test05 {
    public static void main(String[] args) {
        //第1层循环，用于表示鸡翁的范围，初始化表达式的变量定义为 x=0，判断条件是x<=20
        for(int x=0; x<=20; x++) {
            //第2层循环，用于表示鸡母的范围，初始化表达式的变量定义为 y=0，判断条件是y<=33
            for(int y=0; y<=33; y++) {
                //这个时候，用于表示鸡雏的变量 z = 100 – x – y
                int z = 100 - x - y;
                //判断表达式 z%3==0 和表达式 5*x + 3*y + z/3 = 100 是否同时成立
                if(z%3==0 && 5*x+3*y+z/3==100) {
                     System.out.println(x+","+y+","+z);
                }
            }
        }
    }
}

数组元素求和

有这样的一个数组，元素是{68,27,95,88,171,996,51,210}。求出该数组中满足要求的元素和，要求是：求和的元素个位和十位都不能是7，并且只能是偶数

/*
    思路：
    1:定义一个数组，用静态初始化完成数组元素的初始化
    2:定义一个求和变量，初始值是0
    3:遍历数组，获取到数组中的每一个元素
    4:判断该元素是否满足条件，如果满足条件就累加
    5:输出求和变量的值
*/
public class Test06 {
    public static void main(String[] args) {
        //定义一个数组，用静态初始化完成数组元素的初始化
        int[] arr = {68, 27, 95, 88, 171, 996, 51, 210};
        //定义一个求和变量，初始值是0
        int sum = 0;
            //遍历数组，获取到数组中的每一个元素
        for(int x=0; x<arr.length; x++) {
            //判断该元素是否满足条件，如果满足条件就累加
            if(arr[x]%10!=7 && arr[x]/10%10!=7 && arr[x]%2==0) {
            	sum += arr[x];
            }
        }
        //输出求和变量的值
        System.out.println("sum:" + sum);
    }
}

判断两个数组是否相同

定义一个方法，用于比较两个数组的内容是否相同

/*
    思路：
    1:定义两个数组，分别使用静态初始化完成数组元素的初始化
    2:定义一个方法，用于比较两个数组的内容是否相同
    3:比较两个数组的内容是否相同，按照下面的步骤实现就可以了
    首先比较数组长度，如果长度不相同，数组内容肯定不相同，返回false
    其次遍历，比较两个数组中的每一个元素，只要有元素不相同，返回false
    最后循环遍历结束后，返回true
    4:调用方法，用变量接收
    5:输出结果
*/
public class Test07 {
    public static void main(String[] args) {
        //定义两个数组，分别使用静态初始化完成数组元素的初始化
        int[] arr = {11, 22, 33, 44, 55};
        //int[] arr2 = {11, 22, 33, 44, 55};
        int[] arr2 = {11, 22, 33, 44, 5};
        //调用方法，用变量接收
        boolean flag = compare(arr,arr2);
        //输出结果
        System.out.println(flag);
    }

    //定义一个方法，用于比较两个数组的内容是否相同
    /*
    两个明确：
    返回值类型：boolean
    参数：int[] arr, int[] arr2
    */
    public static boolean compare(int[] arr, int[] arr2) {
        //首先比较数组长度，如果长度不相同，数组内容肯定不相同，返回false
        if(arr.length != arr2.length) {
        	return false;
        }
        //其次遍历，比较两个数组中的每一个元素，只要有元素不相同，返回false
        for(int x=0; x<arr.length; x++) {
        	if(arr[x] != arr2[x]) {
        return false;
        	}
        }
        //最后循环遍历结束后，返回true
        return true;
    }
}

查找元素在数组中出现的索引位置

已知一个数组 arr = {19, 28, 37, 46, 50}; 键盘录入一个数据，查找该数据在数组中的索引。并在控制台输出找到的索引值。如果没有查找到，则输出-1

/*
    思路：
    1:定义一个数组，用静态初始化完成数组元素的初始化
    2:键盘录入要查找的数据，用一个变量接收
    3:定义一个索引变量，初始值为-1
    4:遍历数组，获取到数组中的每一个元素
    5:拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同，就把该值对应的索引赋值给索引变量,并
    结束循环
    6:输出索引变量
*/
public class Test08 {
    public static void main(String[] args) {
        //定义一个数组，用静态初始化完成数组元素的初始化
        int[] arr = {19, 28, 37, 46, 50};
        //键盘录入要查找的数据，用一个变量接收
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要查找的数据：");
        int number = sc.nextInt();
        //调用方法
        int index = getIndex(arr, number);
        //输出索引变量
        System.out.println("index: " + index);

        //查找指定的数据在数组中的索引
        /*
        两个明确：
        返回值类型：int
        参数：int[] arr, int number
        */
        public static int getIndex(int[] arr, int number) {
        //定义一个索引变量，初始值为-1
        int index = -1;
        //遍历数组，获取到数组中的每一个元素
        for(int x=0; x<arr.length; x++) {
            //拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同，就把该值对应的索引赋值给索引变量,并结束循环
            if(arr[x] == number) {
                index = x;
                break;
            }
        }
        //返回索引
        return index;
    }
}

数组元素反转

已知一个数组 arr = {19, 28, 37, 46, 50}; 用程序实现把数组中的元素值交换，交换后的数组 arr = {50, 46, 37, 28, 19}; 并在控制台输出交换后的数组元素。

/*
    思路：
    1:定义一个数组，用静态初始化完成数组元素的初始化
    2:循环遍历数组，这一次初始化语句定义两个索引变量，判断条件是开始索引小于等于结束索引
    3:变量交换
    4:遍历数组
*/
public class Test09 {
    public static void main(String[] args) {
        //定义一个数组，用静态初始化完成数组元素的初始化
        int[] arr = {19, 28, 37, 46, 50};
        //调用反转的方法
        reverse(arr);
        //遍历数组
        printArray(arr);

        /*
        两个明确：
        返回值类型：void
        参数：int[] arr
        */
        public static void reverse(int[] arr) {
            //循环遍历数组，这一次初始化语句定义两个索引变量，判断条件是开始索引小于等于结束索引
            for (int start = 0, end = arr.length - 1; start <= end; start++, end--) {
                //变量交换
                int temp = arr[start];
                arr[start] = arr[end];
                arr[end] = temp;
            }
        }
        /*
        两个明确：
        返回值类型：void
        参数：int[] arr
        */
        public static void printArray(int[] arr) {
            System.out.print("[");
            for (int x = 0; x < arr.length; x++) {
                if (x == arr.length - 1) {
                    System.out.print(arr[x]);
                } else {
                    System.out.print(arr[x] + ", ");
                }
            }
            System.out.println("]");
        }
    }

评委打分

在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。选手的最后得分为：去掉一个最高分和一个最低分后的4个评委平均值 (不考虑小数部分)。

/*
    思路：
    1:定义一个数组，用动态初始化完成数组元素的初始化，长度为6
    2:键盘录入评委分数
    3:由于是6个评委打分，所以，接收评委分数的操作，用循环改进
    4:定义方法实现获取数组中的最高分(数组最大值)，调用方法
    5:定义方法实现获取数组中的最低分(数组最小值) ，调用方法
    6:定义方法实现获取数组中的所有元素的和(数组元素求和) ，调用方法
    7:按照计算规则进行计算得到平均分
    8:输出平均分
*/
public class Test10 {
    public static void main(String[] args) {
        //定义一个数组，用动态初始化完成数组元素的初始化，长度为6
        int[] arr = new int[6];
        //键盘录入评委分数
        Scanner sc = new Scanner(System.in);
        //由于是6个评委打分，所以，接收评委分数的操作，用循环改进
        for(int x=0; x<arr.length; x++) {
            System.out.println("请输入第" + (x + 1) + "个评委的打分：");
            arr[x] = sc.nextInt();
    	}	
        //printArray(arr);
        //定义方法实现获取数组中的最高分(数组最大值)，调用方法
        int max = getMax(arr);
        //定义方法实现获取数组中的最低分(数组最小值) ，调用方法
        int min = getMin(arr);
        //定义方法实现获取数组中的所有元素的和(数组元素求和) ，调用方法
        int sum = getSum(arr);
        //按照计算规则进行计算得到平均分
        int avg = (sum - max - min) / (arr.length - 2);
        //输出平均分
        System.out.println("选手的最终得分是：" + avg);
	}
    /*
    两个明确：
    返回值类型：int
    参数：int[] arr
    */
    public static int getSum(int[] arr) {
    	int sum = 0;
        for(int x=0; x<arr.length; x++) {
        	sum += arr[x];
        }
        return sum;
    }
	/*
    两个明确：
    返回值类型：int
    参数：int[] arr
	*/
    public static int getMin(int[] arr) {
        int min = arr[0];
        for(int x=1; x<arr.length; x++) {
            if(arr[x] < min) {
            	min = arr[x];
            }
        }
        return min;
    }
    /*
    两个明确：
    返回值类型：int
    参数：int[] arr
    */
    public static int getMax(int[] arr) {
        int max = arr[0];
        for(int x=1; x<arr.length; x++) {
            if(arr[x] > max) {
                max = arr[x];
            }
        }
        return max;
    }
    //遍历数组
    public static void printArray(int[] arr) {
    	System.out.print("[");
        for (int x = 0; x < arr.length; x++) {
            if (x == arr.length - 1) {
            	System.out.print(arr[x]);
            } else {
            	System.out.print(arr[x] + ", ");
            }
        }
        System.out.println("]");
    }
}

冒泡排序

概述：一种排序的方式，对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，依次对所有的数据进行操作，直至所有数据按要求完成排序

如果有n个数据进行排序，总共需要比较n-1次
每一次比较完毕，下一次的比较就会少一个数据参与

/*
冒泡排序：
一种排序的方式，对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，
依次对所有的数据进行操作，直至所有数据按要求完成排序
*/
public class ArrayDemo {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {24, 69, 80, 57, 13};
            System.out.println("排序前：" + arrayToString(arr));
            // 这里减1，是控制每轮比较的次数
            for (int x = 0; x < arr.length  1; x++) {
                // 1是为了避免索引越界，x是为了调高比较效率
                for (int i = 0; i < arr.length  1  x; i++) {
                    if (arr[i] > arr[i + 1]) {
                        int temp = arr[i];
                            arr[i] = arr[i + 1];
                            arr[i + 1] = temp;
                    }
                }
            }
        System.out.println("排序后：" + arrayToString(arr));
    }
    //把数组中的元素按照指定的规则组成一个字符串：[元素1, 元素2, ...]
    public static String arrayToString(int[] arr) {
        StringBuilder sb = new StringBuilder();
            sb.append("[");
            for (int i = 0; i < arr.length; i++) {
                if (i == arr.length  1) {
                    sb.append(arr[i]);
                } else {
                    sb.append(arr[i]).append(", ");
                }
            }
        sb.append("]");
            String s = sb.toString();
            return s;
    }
}

8.2 运动员案例(面向对象)

我们现在有乒乓球运动员和篮球运动员，乒乓球教练和篮球教练。

为了出国交流，跟乒乓球相关的人员都需要学习英语。

请用所学知识分析，这个案例中有哪些具体类，哪些抽象类，哪些接口，并用代码实现。

抽象人类

public abstract class Person {
    private String name;
        private int age;
        public Person() {
    }
    public Person(String name, int age) {
        this.name = name;
            this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public abstract void eat();
}

抽象运动员类

public abstract class Player extends Person {
    public Player() {
    }
    public Player(String name, int age) {
        super(name, age);
    }
    public abstract void study();
}

抽象教练类

public abstract class Player extends Person {
    public Player() {
    }
    public Player(String name, int age) {
        super(name, age);
    }
    public abstract void study();
}

学英语接口

public interface SpeakEnglish {
    public abstract void speak();
}

篮球教练

public class BasketballCoach extends Coach {
    public BasketballCoach() {
    }
    public BasketballCoach(String name, int age) {
        super(name, age);
    }
    @Override
    public void teach() {
        System.out.println("篮球教练教如何运球和投篮");
    }
    @Override
    public void eat() {
        System.out.println("篮球教练吃羊肉，喝羊奶");
    }
}

乒乓球教练

public class PingPangCoach extends Coach implements SpeakEnglish {
    public PingPangCoach() {
    }
    public PingPangCoach(String name, int age) {
        super(name, age);
    }
    @Override
    public void teach() {
        System.out.println("乒乓球教练教如何发球和接球");
    }
    @Override
    public void eat() {
        System.out.println("乒乓球教练吃小白菜，喝大米粥");
    }
    @Override
    public void speak() {
        System.out.println("乒乓球教练说英语");
    }
}

乒乓球运动员

public class PingPangPlayer extends Player implements SpeakEnglish {
    public PingPangPlayer() {
    }
    public PingPangPlayer(String name, int age) {
        super(name, age);
    }
    @Override
    public void study() {
        System.out.println("乒乓球运动员学习如何发球和接球");
    }
    @Override
    public void eat() {
        System.out.println("乒乓球运动员吃大白菜，喝小米粥");
    }
    @Override
    public void speak() {
        System.out.println("乒乓球运动员说英语");
    }
}

篮球运动员

public class BasketballPlayer extends Player {
    public BasketballPlayer() {
    }
    public BasketballPlayer(String name, int age) {
        super(name, age);
    }
    @Override
    public void study() {
        System.out.println("篮球运动员学习如何运球和投篮");
    }
    @Override
    public void eat() {
        System.out.println("篮球运动员吃牛肉，喝牛奶");
    }
}

8.3 学生管理系统(面向对象)

实现步骤

案例需求

针对目前我们的所学内容，完成一个综合案例：学生管理系统！该系统主要功能如下：

添加学生：通过键盘录入学生信息，添加到集合中

删除学生：通过键盘录入要删除学生的学号，将该学生对象从集合中删除

修改学生：通过键盘录入要修改学生的学号，将该学生对象其他信息进行修改

查看学生：将集合中的学生对象信息进行展示

退出系统：结束程序

实现步骤

定义学生类，包含以下成员变量

private String sid // 学生id

private String name // 学生姓名

private String age // 学生年龄

private String address // 学生所在地
学生管理系统主界面的搭建步骤

2.1 用输出语句完成主界面的编写

2.2 用Scanner实现键盘输入

2.3 用switch语句完成选择的功能

2.4 用循环完成功能结束后再次回到主界面
学生管理系统的添加学生功能实现步骤

3.1 定义一个方法，接收ArrayList集合

3.2 方法内完成添加学生的功能 ①键盘录入学生信息 ②根据录入的信息创建学生对象 ③将学生对象添加到集合中 ④提示添加成功信息

3.3 在添加学生的选项里调用添加学生的方法
学生管理系统的查看学生功能实现步骤

4.1 定义一个方法，接收ArrayList集合

4.2 方法内遍历集合，将学生信息进行输出

4.3 在查看所有学生选项里调用查看学生方法
学生管理系统的删除学生功能实现步骤

5.1 定义一个方法，接收ArrayList集合

5.2 方法中接收要删除学生的学号

5.3 遍历集合，获取每个学生对象

5.4 使用学生对象的学号和录入的要删除的学号进行比较,如果相同，则将当前学生对象从集合中删除 5.5 在删除学生选项里调用删除学生的方法
学生管理系统的修改学生功能实现步骤

6.1 定义一个方法，接收ArrayList集合

6.2 方法中接收要修改学生的学号

6.3 通过键盘录入学生对象所需的信息，并创建对象

6.4 遍历集合，获取每一个学生对象。并和录入的修改学生学号进行比较.如果相同，则使用新学生对象替换当前学生对象

6.5 在修改学生选项里调用修改学生的方法
退出系统

使用System.exit(0);退出JVM

实现流程

学生类的定义

public class Student {
    //学号
    private String sid;
    //姓名
    private String name;
    //年龄
    private String age;
    //居住地
    private String address;
    public Student() {
    }
    public Student(String sid, String name, String age, String address) {
        this.sid = sid;
        this.name = name;
        this.age = age;
        this.address = address;
    }
    public String getSid() {
        return sid;
    }
    public void setSid(String sid) {
        this.sid = sid;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAge() {
        return age;
    }
    public void setAge(String age) {
        this.age = age;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
}

测试类的定义

public class StudentManager {
    /*
1:用输出语句完成主界面的编写
2:用Scanner实现键盘录入数据
3:用switch语句完成操作的选择
4:用循环完成再次回到主界面
*/
    public static void main(String[] args) {
        //创建集合对象，用于保存学生数据信息
        ArrayList<Student> array = new ArrayList<Student>();
        //用循环完成再次回到主界面
        while (true) {
            //用输出语句完成主界面的编写
            System.out.println("--------欢迎来到学生管理系统--------");
            System.out.println("1 添加学生");
            System.out.println("2 删除学生");
            System.out.println("3 修改学生");
            System.out.println("4 查看所有学生");
            System.out.println("5 退出");
            System.out.println("请输入你的选择：");
            //用Scanner实现键盘录入数据
            Scanner sc = new Scanner(System.in);
            String line = sc.nextLine();
            //用switch语句完成操作的选择
            switch (line) {
                case "1":
                    addStudent(array);
                    break;
                case "2":
                    deleteStudent(array);
                    break;
                case "3":
                    updateStudent(array);
                    break;
                case "4":
                    findAllStudent(array);
                    break;
                case "5":
                    System.out.println("谢谢使用");
                    System.exit(0); //JVM退出
            }
        }
    }
    //定义一个方法，用于添加学生信息
    public static void addStudent(ArrayList<Student> array) {
        //键盘录入学生对象所需要的数据,显示提示信息，提示要输入何种信息
        Scanner sc = new Scanner(System.in);
        String sid;
        while (true) {
            System.out.println("请输入学生学号：");
            sid = sc.nextLine();
            boolean flag = isUsed(array, sid);
            if (flag) {
                System.out.println("你输入的学号已经被占用，请重新输入");
            } else {
                break;
            }
        }
        System.out.println("请输入学生姓名：");
        String name = sc.nextLine();
        System.out.println("请输入学生年龄：");
        String age = sc.nextLine();
        System.out.println("请输入学生居住地：");
        String address = sc.nextLine();
        //创建学生对象，把键盘录入的数据赋值给学生对象的成员变量
        Student s = new Student();
        s.setSid(sid);
        s.setName(name);
        s.setAge(age);
        s.setAddress(address);
        //将学生对象添加到集合中
        array.add(s);
        //给出添加成功提示
        System.out.println("添加学生成功");
    }
    //定义一个方法，判断学号是否被使用
    public static boolean isUsed(ArrayList<Student> array, String sid) {
        //如果与集合中的某一个学生学号相同，返回true;如果都不相同，返回false
        boolean flag = false;
        for(int i=0; i<array.size(); i++) {
            Student s = array.get(i);
            if(s.getSid().equals(sid)) {
                flag = true;
                break;
            }
        }
        return flag;
    }
    //定义一个方法，用于查看学生信息
    public static void findAllStudent(ArrayList<Student> array) {
        //判断集合中是否有数据，如果没有显示提示信息
        if (array.size() == 0) {
            System.out.println("无信息，请先添加信息再查询");
            //为了让程序不再往下执行，我们在这里写上return;
            return;
        }
        //显示表头信息
        //\t其实是一个tab键的位置
        System.out.println("学号\t\t\t姓名\t\t年龄\t\t居住地");
        //将集合中数据取出按照对应格式显示学生信息，年龄显示补充“岁”
        for (int i = 0; i < array.size(); i++) {
            Student s = array.get(i);
            System.out.println(s.getSid() + "\t" + s.getName() + "\t" + s.getAge() +
                               "岁\t\t" + s.getAddress());
        }
    }
    //定义一个方法，用于删除学生信息
    public static void deleteStudent(ArrayList<Student> array) {
        //键盘录入要删除的学生学号,显示提示信息
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你要删除的学生的学号：");
        String sid = sc.nextLine();
        //在删除/修改学生操作前，对学号是否存在进行判断
        //如果不存在，显示提示信息
        //如果存在，执行删除/修改操作
        int index = -1;
        for (int i = 0; i < array.size(); i++) {
            Student s = array.get(i);
            if (s.getSid().equals(sid)) {
                index = i;
                break;
            }
        }
        if (index == -1) {
            System.out.println("该信息不存在，请重新输入");
        } else {
            array.remove(index);
            //给出删除成功提示
            System.out.println("删除学生成功");
        }
    }
    //定义一个方法，用于修改学生信息
    public static void updateStudent(ArrayList<Student> array) {
        //键盘录入要修改的学生学号，显示提示信息
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你要修改的学生的学号：");
        String sid = sc.nextLine();
        //键盘录入要修改的学生信息
        System.out.println("请输入学生新姓名：");
        String name = sc.nextLine();
        System.out.println("请输入学生新年龄：");
        String age = sc.nextLine();
        System.out.println("请输入学生新居住地：");
        String address = sc.nextLine();
        //创建学生对象
        Student s = new Student();
        s.setSid(sid);
        s.setName(name);
        s.setAge(age);
        s.setAddress(address);
        //遍历集合修改对应的学生信息
        for (int i = 0; i < array.size(); i++) {
            Student student = array.get(i);
            if (student.getSid().equals(sid)) {
                array.set(i, s);
            }
        }
        //给出修改成功提示
        System.out.println("修改学生成功");
    }
}

8.4 斗地主案例(集合)

1、模拟斗地主案例-普通版本

通过程序实现斗地主过程中的洗牌，发牌和看牌

public class PokerDemo {
    public static void main(String[] args) {
        //创建一个牌盒，也就是定义一个集合对象，用ArrayList集合实现
        ArrayList<String> array = new ArrayList<String>();
        //往牌盒里面装牌
        /*
        ♦2,♦3,♦4...♦K,♦A
        ♣2,...
        ♥2,...
        ♠2,...
        小王，大王
        */
        //定义花色数组
        String[] colors = {"♦", "♣", "♥", "♠"};
        //定义点数数组
        String[] numbers = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "J","Q", "K", "A"};
        for (String color : colors) {
            for (String number : numbers) {
                array.add(color + number);
            }
        }
        array.add("小王");
        array.add("大王");
        //洗牌，也就是把牌打撒，用Collections的shuffle()方法实现
        Collections.shuffle(array);
        // System.out.println(array);
        //发牌，也就是遍历集合，给三个玩家发牌
        ArrayList<String> lqxArray = new ArrayList<String>();
        ArrayList<String> lyArray = new ArrayList<String>();
        ArrayList<String> fqyArray = new ArrayList<String>();
        ArrayList<String> dpArray = new ArrayList<String>();
        for (int i = 0; i < array.size(); i++) {
            String poker = array.get(i);
            if (i >= array.size() - 3) {
                dpArray.add(poker);
            } else if (i % 3 == 0) {
                lqxArray.add(poker);
            } else if (i % 3 == 1) {
                lyArray.add(poker);
            } else if (i % 3 == 2) {
                fqyArray.add(poker);
            }
        }
        //看牌，也就是三个玩家分别遍历自己的牌
        lookPoker("林青霞", lqxArray);
        lookPoker("柳岩", lyArray);
        lookPoker("风清扬", fqyArray);
        lookPoker("底牌", dpArray);
    }
    //看牌的方法
    public static void lookPoker(String name, ArrayList<String> array) {
        System.out.print(name + "的牌是：");
        for (String poker : array) {
            System.out.print(poker + " ");
        }
        System.out.println();
    }
}

2、模拟斗地主案例-升级版本

通过程序实现斗地主过程中的洗牌，发牌和看牌。要求：对牌进行排序

public class PokerDemo {
    public static void main(String[] args) {
        //创建HashMap，键是编号，值是牌
        HashMap<Integer, String> hm = new HashMap<Integer, String>();
        //创建ArrayList，存储编号
        ArrayList<Integer> array = new ArrayList<Integer>();
        //创建花色数组和点数数组
        String[] colors = {"♦", "♣", "♥", "♠"};
        String[] numbers = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q","K", "A", "2"};
        //从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);
        //洗牌(洗的是编号)，用Collections的shuffle()方法实现
        Collections.shuffle(array);
        //发牌(发的也是编号，为了保证编号是排序的，创建TreeSet集合接收)
        TreeSet<Integer> lqxSet = new TreeSet<Integer>();
        TreeSet<Integer> lySet = new TreeSet<Integer>();
        TreeSet<Integer> fqySet = 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) {
                lqxSet.add(x);
            } else if (i % 3 == 1) {
                lySet.add(x);
            } else if (i % 3 == 2) {
                fqySet.add(x);
            }
        }
        //调用看牌方法
        lookPoker("林青霞", lqxSet, hm);
        lookPoker("柳岩", lySet, hm);
        lookPoker("风清扬", fqySet, hm);
        lookPoker("底牌", dpSet, hm);
    }
    //定义方法看牌(遍历TreeSet集合，获取编号，到HashMap集合找对应的牌)
    public static void lookPoker(String name, TreeSet<Integer> ts,
                                 HashMap<Integer, String> hm) {
        System.out.print(name + "的牌是：");
        for (Integer key : ts) {
            String poker = hm.get(key);
            System.out.print(poker + " ");
        }
        System.out.println();
    }
}

8.5 游戏次数案例(IO流)

案例需求
- 实现猜数字小游戏只能试玩3次，如果还想玩，提示：游戏试玩已结束，想玩请充值(www.itcast.cn)
分析步骤
- 写一个游戏类，里面有一个猜数字的小游戏
- 写一个测试类，测试类中有main()方法，main()方法中写如下代码：
  
  从文件中读取数据到Properties集合，用load()方法实现
  
  文件已经存在：game.txt
  
  里面有一个数据值：count=0
  
  通过Properties集合获取到玩游戏的次数
  
  判断次数是否到到3次了
  
  如果到了，给出提示：游戏试玩已结束，想玩请充值(www.itcast.cn)
  
  如果不到3次：次数+1，重新写回文件，用Properties的store()方法实现玩游戏

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

cocochimp

关注

0
点赞
踩
14

收藏

觉得还不错? 一键收藏
0
评论
Java入门级教学（超详细&中）

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

扫一扫