1.IO流的概述

流：就是一个动态的运行过程
起点和终点—在编程过程中，整个的传输过程中不能中断，如果出现中断会重新开始传输

分类：

顶级父类：
输出流：OutputStream
输入流：InputStream

流的传输处理过程：IPO

在Java的api中有许多的流：

1.字节流（低级流，基本流）：通过字节为单位进行传输—byte
2.高级流（缓冲流）：使用高级流的时候必须传入一个低级流—高级流的构造函数中必须传入一个低级流的参数
比如：
文件传输：文件流
对象传输：对象流
图像传输：图片流
———-
具体通过api进行查询使用
底层都是byte

2.FileWriter流（输出流）

FileWriter是一个文件传输流，用于在文件中写数据
构造方法：FileWriter（String fileName）传入一个文件的路径
输出流的使用步骤：（死记）—后面使用其他的流都是这样的套路
1.创建输出流对象
2.调用输出流对象的书写数据的方法
3.关闭流—释放资源

  1. package com.igeek_01;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-11-26-14:07
  6.  */
  8. import java.io.FileWriter;//io包中提供了许多的流
  9. import java.io.IOException;
  11. /**
  12.  * FileWriter是一个文件传输流，用于在文件中写数据
  13.  *
  14.  * 需求：
  15.  * 向文件中写入数据
  16.  * 写数据--输出流--FileWriter
  17.  *
  18.  * 构造方法：FileWriter（String fileName）传入一个文件的路径
  19.  *
  20.  * 输出流的使用步骤：（死记）--后面使用其他的流都是这样的套路
  21.  * 1.创建输出流对象
  22.  * 2.调用输出流对象的书写数据的方法
  23.  * 3.关闭流--释放资源
  24.  *
  25.  */
  26. public class FileWriterDemo {
  27.     public static void main(String[] args) throws IOException {
  28.         //创建输出流对象--定义的路径会自动生成一个文件
  29.         FileWriter fw=new FileWriter("f:\\a.txt");
  30.         /**
  31.          * 创建输出流做了几件事情：
  32.          * 1.调用了系统中的资源创建一个对象
  33.          * 2.创建输出流对象--只要流不关闭就一直存在
  34.          * 3.把输出流对象指向文件
  35.          */
  37.         //调用输出流对象的书写数据的方法
  38.         fw.write("你好io");//写一个字符串
  39.         //flush();表示刷新缓存区,需要调用这个方法将缓存中的数据全部刷新到文件中
  40.         fw.flush();
  42.         //关闭流--释放资源
  43.         fw.close();
  44.     }
  45. }
  46. 结果：
  47. 运行代码
  48. 在f盘中自动生成a.txt文件

计算机中的路径问题：

  • （1）绝对路径—以盘符开始的路径—定位

  • （2）相对路径—相当于当前项目而言，在项目的根目录下—某一个参照物来进行处理的

    close和flash方法的区别：

  • （1）flash方法：刷新缓存区，流对象还是可以继续使用的

  • （2）close方法：先刷新缓存区，然后通知系统来释放资源，流对象就不存在了 ```java package com.igeek_02;

/**

  • @author Lynn
  • @create 2020-11-26-14:07 */

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

/**

  • FileWriter是一个文件传输流，用于在文件中写数据 *
  • 需求：
  • 向文件中写入数据
  • 写数据—输出流—FileWriter *
  • 构造方法：FileWriter（String fileName）传入一个文件的路径 *
  • 输出流的使用步骤：（死记）—后面使用其他的流都是这样的套路
  • 1.创建输出流对象
  • 2.调用输出流对象的书写数据的方法
  • 3.关闭流—释放资源 *
  • 计算机中的路径问题：
  • （1）绝对路径—以盘符开始的路径—定位
  • （2）相对路径—相当于当前项目而言，在项目的根目录下—某一个参照物来进行处理的 *
  • close和flash方法的区别：
  • （1）flash方法：刷新缓存区，流对象还是可以继续使用的

  • （2）close方法：先刷新缓存区，然后通知系统来释放资源，流对象就不存在了 */ public class FileWriterDemo2 { public static void main(String[] args) throws IOException {

    1.  //创建输出流对象--定义的路径会自动生成一个文件

    // FileWriter fw=new FileWriter(“f:\a.txt”);

    1.  FileWriter fw=new FileWriter("a.txt");//相对路径--当前项目的根目录
    2.  /**
    3.   * 创建输出流做了几件事情：
    4.   * 1.调用了系统中的资源创建一个对象
    5.   * 2.创建输出流对象--只要流不关闭就一直存在
    6.   * 3.把输出流对象指向文件
    7.   */
    9.  //调用输出流对象的书写数据的方法
    10.  fw.write("你好io");//写一个字符串
    11.  //flush();表示刷新缓存区,需要调用这个方法将缓存中的数据全部刷新到文件中
    12.  fw.flush();
    14.  //关闭流--释放资源
    15.  fw.close();

    } } 结果： 运行代码 在工程中自动生成该文件a.txt ```

    FileWriter其他方法的使用：

  • 1.void write（String str）：写一个字符串数据
  • 2.void write（String str,int index,int length）:写一个字符串中的部分数据—从index开始，写length个数据
  • 3.void write（int ch）：写一个字符数据

—这里的int类型的好处是既可以写char类型也可以写char类型所对应的值

  • 4.void write（int ch，int index,int length）：写一个数组数据的一部分数据—从index开始，写length个数据 ```java package com.igeek_03;

/**

  • @author Lynn
  • @create 2020-11-26-14:37 */

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

/**

  • FileWriter其他方法的使用：
  • 1.void write（String str）：写一个字符串数据
  • 2.void write（String str,int index,int length）:写一个字符串中的部分数据
  • 3.void write（int ch）：写一个字符数据—这里的int类型的好处是
  • 既可以写char类型也可以写char类型所对应的值

  • 4.void write（int ch，int index,int length）：写一个数组数据的一部分数据 */ public class FileWriterDemo3 { public static void main(String[] args)throws IOException {

    1.  char c='中';
    2.  System.out.println(c);//中
    4.  int a='中';
    5.  System.out.println(a);//20013
    7.  int b='A';
    8.  System.out.println(b);//65
    10.  int d='琳';
    11.  System.out.println(d);//王：29579，琳：29747
    13.  //创建一个对象
    14.  FileWriter fw=new FileWriter("b.txt");//相对路径
    16.  //数据操作
    17.  fw.write("画画的北北，画画的北北，压坏了小野马和带刺的玫瑰",0,7);
    18.  fw.write("\t\n");
    19.  fw.write(65);//A
    20.  fw.write("\t\n");
    21.  fw.write('A');//A
    22.  fw.write("\t\n");
    23.  fw.write("a");//a
    24.  fw.write("\t\n");
    25.  fw.write(20013);//中
    27.  char[] ch={'a','b','c','d'};
    28.  fw.write(ch);
    29.  fw.write(ch,2,2);//参数1表示截取的写入个数
    31.  //为了防止忘记关闭流
    32.  fw.close();

    } } ```

    FileWriter实现换行和追加：

  • 换行：\n可以实现换行，但是在某些版本的windows下的记事本中没有效果

    1. 如果没有效果，我们可以使用\r\n
    1. 在Windows系统中使用换行这个功能的时候，为了代码的健壮性，推荐使用\r\n，保证不出问题

  • 追加：FileWriter(String fileName,boolean append)：默认值是false ```java package com.igeek_01;

/**

  • @author Lynn
  • @create 2020-11-26-15:09 */

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

/**

  • FileWriter实现换行和追加： *
  • 换行：\n可以实现换行，但是在某些版本的windows下的记事本中没有效果
  • 如果没有效果，我们可以使用\r\n
  • 在Windows系统中使用换行这个功能的时候，为了代码的健壮性，推荐使用\r\n，保证不出问题 *
  • 追加：FileWriter(String fileName,boolean append)：默认值是false */ public class FileWriterDemo4 { public static void main(String[] args) throws IOException {
    1.  //创建一个对象--true表示默认追加
    2.  FileWriter fw=new FileWriter("c.txt",true);//相对路径
  1.     //追加字符串
  2.     for (int i = 0; i <5 ; i++) {
  3.         fw.write("hello");
  4.         fw.write("\r\n");//换行
  5.     }
  7.     fw.write(65);
  8.     fw.write("\r\n");
  9.     fw.write("a");
  10.     fw.write("\r\n");
  12.     //为了防止忘记关闭流
  13.     fw.close();
  14. }

}

  1. <a name="mvfOC"></a>
  2. # 3.FileReader（输入流）
  3. <a name="ADKgf"></a>
  4. ### 从文件中读取数据在控制台显示
  6. - 需求：
  7. - 从文件中读取数据在控制台显示
  8. - 读数据--输入流--FileReader
  9. - <br />
  10. - FileReader构造函数：
  11. - FileReader(String fileName)：传入一个文件的路径--保证存在的
  12. - <br />
  13. - 输出流的使用步骤：（死记）--后面使用其他的流都是这样的套路
  14. - 1.创建输入流对象
  15. - 2.调用输入流对象的书写数据的方法
  16. - 3.关闭流--释放资源
  17. - <br />
  18. - 注意：
  19. - 进行读取的时候不许保证文件存在，如果不存在会报错
  20. - Exception in thread "main" java.io.FileNotFoundException: fr.txt (系统找不到指定的文件。)
  21. ```java
  22. package com.igeek_02;
  24. /**
  25.  * @author Lynn
  26.  * @create 2020-11-26-15:21
  27.  */
  29. import java.io.FileNotFoundException;
  30. import java.io.FileReader;
  31. import java.io.IOException;
  33. /**
  34.  * 从文件中读取数据在控制台显示
  35.  *
  36.  * 需求：
  37.  * 从文件中读取数据在控制台显示
  38.  * 读数据--输入流--FileReader
  39.  *
  40.  * FileReader构造函数：
  41.  * FileReader(String fileName)：传入一个文件的路径--保证存在的
  42.  *
  43.  * 输出流的使用步骤：（死记）--后面使用其他的流都是这样的套路
  44.  * 1.创建输入流对象
  45.  * 2.调用输入流对象的书写数据的方法
  46.  * 3.关闭流--释放资源
  47.  *
  48.  * 注意：
  49.  * 进行读取的时候不许保证文件存在，如果不存在会报错
  50.  * Exception in thread "main" java.io.FileNotFoundException: fr.txt (系统找不到指定的文件。)
  51.  */
  52. public class FileReaderDemo1 {
  53.     public static void main(String[] args) throws IOException {
  54.         //创建一个输入流
  55.         FileReader fr=new FileReader("b.txt");
  57.         //调用输入流的方法
  58.         //通过循环的方式进行读取--当出现-1的时候表示该文件已经读取结束
  59.         int ch;//设定一个初始值
  60.         //遍历
  61.         while ((ch=fr.read()) != -1){//说明文件读取没有结束
  62.             //读
  63.             System.out.println((char)ch);//强制类型转换--把int转换为char
  65.         }
  66.         //释放资源
  67.         fr.close();
  68.     }
  69. }

读取数据

批量读取—其实就是将多个字符打包成一个数组，read()方法在读取的时候直接一次性读取一个数组

  1. package com.igeek_02;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-11-26-15:21
  6.  */
  8. import java.io.FileReader;
  9. import java.io.IOException;
  11. /**
  12.  * 从文件中读取数据在控制台显示
  13.  *
  14.  * 需求：
  15.  * 从文件中读取数据在控制台显示
  16.  * 读数据--输入流--FileReader
  17.  *
  18.  * FileReader构造函数：
  19.  * FileReader(String fileName)：传入一个文件的路径--保证存在的
  20.  *
  21.  * 输出流的使用步骤：（死记）--后面使用其他的流都是这样的套路
  22.  * 1.创建输入流对象
  23.  * 2.调用输入流对象的书写数据的方法
  24.  * 3.关闭流--释放资源
  25.  *
  26.  * 注意：
  27.  * 进行读取的时候不许保证文件存在，如果不存在会报错
  28.  * Exception in thread "main" java.io.FileNotFoundException: fr.txt (系统找不到指定的文件。)
  29.  */
  30. public class FileReaderDemo2 {
  31.     public static void main(String[] args) throws IOException {
  32.         //创建一个输入流
  33.         FileReader fr=new FileReader("b.txt");
  35.         //调用read方法--输入流中的方法
  36.         //int read();--一次读取一个字符
  38.         //第一次读取
  39.         int ch=fr.read();
  40.         System.out.println(ch);//30011
  41.         System.out.println((char)ch);//画
  43.         //第二次读取
  44.         ch=fr.read();
  45.         System.out.println(ch);//30011
  46.         System.out.println((char)ch);//画
  48.         //批量读取--其实就是将多个字符打包成一个数组，read()方法在读取的时候直接一次性读取一个数组
  49.         int len;//数组长度
  50.         char[] chs=new char[5];//一次性读取5个字符(5个5个的读取）
  51.         while ((len= fr.read(chs)) != -1){//表示文件正在读取
  52.             //一次性读取的是5个字符--多个字符其实就是字符串
  53.             System.out.print(new String(chs,0,len));
  55.         }
  58.         //释放资源
  59.         fr.close();
  60.     }
  61. }

4.文件的复制

文件的拷贝复制

  • 源文件，目标文件
  • 需求：
  • 把项目中的根路径下的c.txt中的内容复制到项目根路径下的Copy.java中
  • 文件的复制也是一个套路—操作步骤是一样的

  • 数据源：c.txt—读取文件—FileReader
  • 目的地：Copy.java—写入数据—FileWriter ```java package com.igeek_03;

/**

  • @author Lynn
  • @create 2020-11-26-16:16 */

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

/**

  • 文件的拷贝复制 *
  • 源文件，目标文件
  • 需求：
  • 把项目中的根路径下的c.txt中的内容复制到项目根路径下的Copy.java中
  • 文件的复制也是一个套路—操作步骤是一样的 *
  • 数据源：c.txt—读取文件—FileReader

  • 目的地：Copy.java—写入数据—FileWriter */ public class CopyFileDemo1 { public static void main(String[] args) throws IOException {

    1.  //创建文件的输入流对象
    2.  FileReader fr=new FileReader("c.txt");//保证源文件存在
    4.  //创建文件的输出流对象
    5.  FileWriter fw=new FileWriter("Copy.java");//程序自动创建
    7.  //读取源文件数据
    8.  //一次复制一个字符
    9.  int ch;
    10.  while ((ch=fr.read()) != -1){//读取
    11.      //写入数据到目标文件
    12.      fw.write(ch);
    13.  }
    15.  //释放资源--关闭流
    16.  fr.close();
    17.  fw.close();

    } } java package com.igeek_03;

/**

  • @author Lynn
  • @create 2020-11-26-16:16 */

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

/**

  • 文件的拷贝复制 *
  • 源文件，目标文件
  • 需求：
  • 把项目中的根路径下的c.txt中的内容复制到项目根路径下的Copy.java中
  • 文件的复制也是一个套路—操作步骤是一样的 *
  • 数据源：c.txt—读取文件—FileReader

  • 目的地：Copy.java—写入数据—FileWriter */ public class CopyFileDemo2 { public static void main(String[] args) throws IOException {

    1.  //创建文件的输入流对象
    2.  FileReader fr=new FileReader("c.txt");//保证源文件存在
    4.  //创建文件的输出流对象
    5.  FileWriter fw=new FileWriter("Copy.java");//程序自动创建
    7.  //读取源文件数据
    8.  //一次复制1024个字符
    9.  int len;
    10.  char[] chs=new char[1024];
    11.  while ((len=fr.read(chs)) != -1){//读取
    12.      //写入数据到目标文件
    13.      fw.write(chs,0,len);
    14.  }
    16.  //释放资源--关闭流
    17.  fr.close();
    18.  fw.close();

    } } ```

    5.BufferedStream

    BufferedStream是一个缓冲流

  • 包括：
  • BufferedWriter：将文本写入字符输出流，缓冲各个字符，从而实现单个字符，数组，字符串的高效写入
  • BufferedReader：从字符流中读取文本，缓冲各个字符，从而实现字符，数组和行的高效读取
  • 缓冲流属于高级流，在构造函数中必须传入一个低级流才可以使用
  • FileWriter就是一个低级流—因为它支持单个字符的写入 ```java package com.igeek_04;

/**

  • @author Lynn
  • @create 2020-11-26-16:32 */

import java.io.*;

/**

  • BufferedStream是一个缓冲流 *
  • 包括：
  • BufferedWriter：将文本写入字符输出流，缓冲各个字符，从而实现单个字符，数组，字符串的高效写入
  • BufferedReader：从字符流中读取文本，缓冲各个字符，从而实现字符，数组和行的高效读取 *
  • 缓冲流属于高级流，在构造函数中必须传入一个低级流才可以使用

  • FileWriter就是一个低级流—因为它支持单个字符的写入 */ public class BufferedStreamDemo { public static void main(String[] args) throws IOException {

    1.  //创建输入缓冲流对象--要输入一个低级流
    2.  BufferedReader br=new BufferedReader(new FileReader("c.txt"));
    4.  //读取
    5.  char[] chs=new char[1024];
    6.  int len;
    7.  while ((len=br.read(chs)) != -1){
    8.      System.out.print(new String(chs,0,len));
    9.  }
    10.  //释放资源--直接关闭高级流的同时，低级流自己关闭了
    11.  br.close();
    13.  //创建缓冲输出流
    14.  BufferedWriter bw=new BufferedWriter(new FileWriter("bw.txt"));
    15.  //写入
    16.  bw.write("我是一颗");
    17.  //关闭
    18.  bw.close();

    } } ```

    缓冲流实现复制

    ```java package com.igeek_04;

/**

  • @author Lynn
  • @create 2020-11-26-16:16 */

import java.io.*;

/**

  • 文件的拷贝复制
  • 利用缓冲流复制文件
  • 源文件，目标文件
  • 需求：
  • 把项目中的根路径下的c.txt中的内容复制到项目根路径下的Copy.java中
  • 文件的复制也是一个套路—操作步骤是一样的 *
  • 数据源：c.txt—读取文件—BufferedReader

  • 目的地：Copy.java—写入数据—BufferedWriter */ public class CopyBufferedDemo2 { public static void main(String[] args) throws IOException {

    1.  //创建文件的输入流对象
    2.  BufferedReader br=new BufferedReader(new FileReader("c.txt"));

    // FileReader fr=new FileReader(“c.txt”);//保证源文件存在

    1.  //创建文件的输出流对象
    2.  BufferedWriter bw=new BufferedWriter(new FileWriter("Copy1.java"));

    // FileWriter fw=new FileWriter(“Copy.java”);//程序自动创建

    1.  //读取源文件数据
    2.  //一次复制1024个字符
    3.  int len;
    4.  char[] chs=new char[1024];
    5.  while ((len=br.read(chs)) != -1){//读取
    6.      //写入数据到目标文件
    7.      bw.write(chs,0,len);
    8.  }
    10.  //释放资源--关闭流
    11.  br.close();
    12.  bw.close();

    } } ```

    BufferedStream的特殊功能

  • 特殊功能：
  • BufferedWriter中
  • void newLine（）方法：写一个换行符，这个换行符由系统决定的

  • BufferedReader中
  • String readLine（）方法：一次读取一行数据，但是不读取换行符 ```java package com.igeek_05;

/**

  • @author Lynn
  • @create 2020-11-27-9:36 */

import java.io.*;

/**

  • BufferedStream的特殊功能 *
  • 特殊功能：
  • BufferedWriter中
  • void newLine（）方法：写一个换行符，这个换行符由系统决定的 *
  • BufferedReader中

  • String readLine（）方法：一次读取一行数据，但是不读取换行符 / public class BufferedStreamDemo { public static void main(String[] args) throws IOException {

    1.  /**
    2.   * BufferedWriter中
    3.   * void newLine（）方法：写一个换行符，这个换行符由系统决定的
    4.   */
    5.  //创建一个缓冲输出流
    6.  BufferedWriter bw=new BufferedWriter(new FileWriter("bw2.txt",true));//文件自动生成
    7.  //验证
    8.  for (int i = 0; i <10 ; i++) {
    9.      bw.write("hello"+i);

    // bw.write(“\t\n”);//手动添加

    1.      bw.newLine();
    2.      bw.flush();//刷新缓冲流。在循环中，我们可以尽量调用这个刷新缓存区的方法，循环一次就刷新缓存区
    3.  }
    4.  //释放资源
    5.  bw.close();
    7.  /**
    8.   * BufferedReader中
    9.   * String readLine（）方法：一次读取一行数据，但是不读取换行符
    10.   */
    11.  //创建输入流
    12.  BufferedReader br=new BufferedReader(new FileReader("bw2.txt"));
    14.  //先尝试读取一行
    15.  /*String line=br.readLine();
    16.  System.out.println(line);//hello0*/
    18.  //用循环读取
    19.  String line;//初始变量
    20.  while ((line=br.readLine()) != null){
    21.      System.out.println(line);
    22.  }
    23.  br.close();

    } } ```

    汇总5种文件复制的方法

    第一种方式：基本流—一次读写一个字符
    第二种方式：基本流—一次读写一个字符数组
    第三种方式：缓冲流—一次读写一个字符
    第四种方式：缓冲流—一次读写一个字符数组
    第五种方式：缓冲流—一次读写一行 ```java package com.Copy_01;

/**

  • @author Lynn
  • @create 2020-11-27-10:23 */

import java.io.*;

/**

  • 汇总5种文件复制的方法 */ public class CopyFileTest { public static void main(String[] args) throws IOException {

    1.  //设置目标文件和源文件
    2.  String srcFile="b.txt";
    3.  String destFile="copyn.java";
    5.  method1(srcFile,destFile);
    6.  method2(srcFile,destFile);
    7.  method3(srcFile,destFile);
    8.  method4(srcFile,destFile);
    9.  method5(srcFile,destFile);

    }

    //第一种方式：基本流—一次读写一个字符 public static void method1(String srcFile,String destFile) throws IOException {

    1.  //创建基本流
    2.  FileReader fr=new FileReader(srcFile);
    3.  FileWriter fw=new FileWriter(destFile);
    5.  //一次读写一个字符
    6.  int ch;
    7.  while ((ch=fr.read()) != -1){
    8.      fw.write(ch);
    9.  }
    10.  //释放资源
    11.  fr.close();
    12.  fw.close();

    }

    //第二种方式：基本流—一次读写一个字符数组 public static void method2(String srcFile,String destFile) throws IOException {

    1.  //创建基本流
    2.  FileReader fr=new FileReader(srcFile);
    3.  FileWriter fw=new FileWriter(destFile);
    5.  //一次读写一个字符数组
    6.  char[] chs=new char[1024];
    7.  int len;
    8.  while ((len=fr.read(chs)) != -1){
    9.      fw.write(chs,0,len);
    10.  }
    11.  //释放资源
    12.  fr.close();
    13.  fw.close();

    }

    //第三种方式：缓冲流—一次读写一个字符 public static void method3(String srcFile,String destFile) throws IOException {

    1.  //
    2.  BufferedWriter bw=new BufferedWriter(new FileWriter(srcFile));
    3.  BufferedReader br=new BufferedReader(new FileReader(destFile));
    5.  //一次读写一个字符
    6.  int ch;
    7.  while ((ch=br.read()) != -1){
    8.      bw.write(ch);
    9.  }
    10.  //释放资源
    11.  br.close();
    12.  bw.close();

    }

    //第四种方式：缓冲流—一次读写一个字符数组 public static void method4(String srcFile,String destFile) throws IOException {

    1.  //
    2.  BufferedWriter bw=new BufferedWriter(new FileWriter(srcFile));
    3.  BufferedReader br=new BufferedReader(new FileReader(destFile));
    5.  //一次读写一个字符数组
    6.  char[] chs=new char[1024];
    7.  int len;
    8.  while ((len=br.read(chs)) != -1){
    9.      bw.write(chs,0,len);
    10.  }
    11.  //释放资源
    12.  br.close();
    13.  bw.close();

    }

    //第五种方式：缓冲流—一次读写一行 public static void method5(String srcFile,String destFile) throws IOException {

    1.  //
    2.  BufferedWriter bw=new BufferedWriter(new FileWriter(srcFile));
    3.  BufferedReader br=new BufferedReader(new FileReader(destFile));
    5.  //一次读写一行
    6.  String line;
    7.  while ((line=br.readLine()) != null){
    8.      bw.write(line);
    9.  }
    10.  //释放资源
    11.  br.close();
    12.  bw.close();

    } } ```

    当前案例用于实现数据持久化

    ```java package com.practice_01;

/**

  • @author Lynn
  • @create 2020-11-26-9:31 */

/**

  • 这是一个学生的实体类 */ public class Student { //属性—为了方便获取字符串的信息，统一设置为字符串类型 private String id; private String name; private String age; private String address;

    public Student() {

    }

    public Student(String id, String name, String age, String address) {

    1.  this.id = id;
    2.  this.name = name;
    3.  this.age = age;
    4.  this.address = address;

    }

    public String getId() {

    1.  return id;

    }

    public void setId(String id) {

    1.  this.id = id;

    }

    public String getName() {

    1.  return name;

    }

    public void setName(String name) {

    1.  this.name = name;

    }

    public String getAge() {

    1.  return age;

    }

    public void setAge(String age) {

    1.  this.age = age;

    }

    public String getAddress() {

    1.  return address;

    }

    public void setAddress(String address) {

    1.  this.address = address;

    } } java package com.practice_01;

/**

  • @author Lynn
  • @create 2020-11-27-10:58 */

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

/**

  • 当前案例用于实现数据持久化 *
  • 学生信息添加到文件中—-要求封装一个方法实现 *
  • 需求分析：
  • 1.键盘录入3个学生的信息（学号，姓名，年龄，居住地）存入到集合中，要求学生的学号不能重复
  • 2.遍历集合，把每个学生的信息存入到文件中—student.txt
  • 3.把每一个学生的信息作为一行数据，每行数据都是：学号，姓名，年龄，居住地 *
  • 步骤：
  • 1.定义一个学生类
  • 2.创建集合对象
  • 3.写方法实现键盘录入，并且把学生信息作为元素保存到集合中
  • 4.创建缓冲输出流
  • 5.遍历集合的同时，按照一定的格式把学生的信息保存到文件中—举例：1001，王嘉尔，27，香港

  • 6.释放资源 */ public class ArrayListToFileDemo { public static void main(String[] args) throws IOException {

    1.  //创建集合对象
    2.  ArrayList<Student> array=new ArrayList<Student>();
    4.  //封装一个方法--直接调用
    5.  addStudent(array);
    6.  addStudent(array);
    7.  addStudent(array);
    9.  //写出到文件中
    10.  BufferedWriter bw=new BufferedWriter(new FileWriter("student.txt"));
    11.  //
    12.  for (int i = 0; i < array.size() ; i++) {
    13.      //
    14.      Student s= array.get(i);
    15.      //
    16.      StringBuilder sb=new StringBuilder();
    17.      sb.append(s.getId()).append(",");//id
    18.      sb.append(s.getName()).append(",");//name
    19.      sb.append(s.getAge()).append(",");//age
    20.      sb.append(s.getAddress()).append(",");//address
    22.      //写出到文件
    23.      bw.write(sb.toString());//将可追加的字符串转换为字符串
    24.      bw.newLine();//换行
    25.      bw.flush();
    26.  }

    }

    //封装一个方法，添加学生—为了封装的彻底性直接使用私有方法—因为这个方法就在本类中使用 private static void addStudent(ArrayList array){

    1.  Scanner sc=new Scanner(System.in);
    2.  //判断学号是不是重复
    3.  String id;
    4.  while (true){
    5.      System.out.println("请输入学号：");
    6.      id= sc.nextLine();
    7.      //判断
    8.      //定义一个标记
    9.      boolean flag=false;
    10.      for (int i = 0; i < array.size() ; i++) {
    11.          Student s= array.get(i);
    12.          //获取学生学号与键盘录入的id比较
    13.          if(s.getId().equals(id)){
    14.              flag=true;
    15.              break;//如果已经存在就跳出
    16.          }
    17.      }
    18.      if(flag){
    19.          System.out.println("你输入的学号已经存在，请重新输入！");
    20.      }else {
    21.          //直接添加
    22.          break;
    23.      }
    24.  }
    25.  //继续下面的添加操作
    26.  System.out.println("请输入学生姓名：");
    27.  String name=sc.nextLine();
    28.  System.out.println("请输入学生年龄：");
    29.  String age=sc.nextLine();
    30.  System.out.println("请输入学生居住地：");
    31.  String address=sc.nextLine();
    33.  //封装成一个学生对象--直接利用构造函数
    34.  Student s=new Student(id,name,age,address);
    36.  //把学生对象保存到集合中
    37.  array.add(s);

    } } ```

    读取文件中的数据

    ```java package com.practice_01;

/**

  • @author Lynn
  • @create 2020-11-27-14:35 */

import java.io.BufferedReader; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; import java.lang.reflect.Member; import java.util.ArrayList;

/**

  • 把上一个案例中的student.txt文件中的内容读取出来 *
  • 步骤：
  • 1.定义一个学生类
  • 2.创建集合对象
  • 3.创建缓冲输入流对象
  • 4.读取文件，并且按照一定的格式保存到集合中
  • 5.释放资源

  • 6.遍历集合 */ public class FileToArrayListDemo { public static void main(String[] args) throws IOException {

    1.  //创建集合对象
    2.  ArrayList<Student> array=new ArrayList<Student>();
    4.  //创建缓冲输入流对象
    5.  BufferedReader br=new BufferedReader(new FileReader("student.txt"));
    7.  //读取文件，并且按照一定的格式进行分割
    8.  String line;
    9.  while ((line=br.readLine()) != null){
    10.      //分割字符串--返回的是字符串类型的数组--下标--根据下标进行取值
    11.      String[] strArray=line.split(",");
    12.      //创建学生对象并且赋值
    13.      Student s=new Student();
    14.      s.setId(strArray[0]);
    15.      s.setName(strArray[1]);
    16.      s.setAge(strArray[2]);
    17.      s.setAddress(strArray[3]);
    19.      //把学生对象作为元素保存到集合中
    20.      array.add(s);
    21.  }
    22.  //释放资源
    23.  br.close();
    25.  //遍历集合,并且输出到控制台
    26.  System.out.println("学号\t姓名\t年龄\t居住地");
    27.  for (int i = 0; i < array.size() ; i++) {
    28.      Student s= array.get(i);
    29.      System.out.println(s.getId()+"\t"+s.getName()+"\t"+s.getAge()+"\t"+s.getAddress());
    30.  }

    } } ```

    学生管理系统

    学生管理系统

    步骤：
    1.创建一个学生类 ```java package StudentManagement;

/**

  • @author Lynn
  • @create 2020-11-26-9:31 */

/**

  • 这是一个学生的实体类 */ public class Student { //属性—为了方便获取字符串的信息，统一设置为字符串类型 private String id; private String name; private String age; private String address;

    public Student() {

    }

    public Student(String id, String name, String age, String address) {

    1.  this.id = id;
    2.  this.name = name;
    3.  this.age = age;
    4.  this.address = address;

    }

    public String getId() {

    1.  return id;

    }

    public void setId(String id) {

    1.  this.id = id;

    }

    public String getName() {

    1.  return name;

    }

    public void setName(String name) {

    1.  this.name = name;

    }

    public String getAge() {

    1.  return age;

    }

    public void setAge(String age) {

    1.  this.age = age;

    }

    public String getAddress() {

    1.  return address;

    }

    public void setAddress(String address) {

    1.  this.address = address;

    } } 2.学生管理系统主界面的编写(原始的学生管理系统，只能键盘录入）<br />3.学生管理系统的查看所有学生的信息<br />4.添加学生信息<br />5.删除学生信息<br />6.修改学生信息java package practice03;

/**

  • @author Lynn
  • @create 2020-11-26-9:28 */

import java.util.ArrayList; import java.util.Scanner;

/**

  • 这是一个学生管理系统
  • 步骤：
  • 1.定义一个学生类
  • 2.学生管理系统主界面的编写
  • 3.学生管理系统的查看所有学生的信息
  • 4.添加学生信息
  • 5.删除学生信息

  • 6.修改学生信息 */ public class StudentMangerTest { public static void main(String[] args) {

    1.  //定义一个学生类型集合
    2.  ArrayList<Student> array=new ArrayList<Student>();
    3.  //为了用户体验度，设计一个界面
    4.  //利用循环的方式可以重复的展示界面，直到退出程序就结束循环
    5.  while(true){
    6.      //主界面的欢迎词
    7.      System.out.println("---------------------欢迎来到学生管理系统------------------------");
    8.      System.out.print("1 查看所有学生"+"\t");
    9.      System.out.print("2 添加学生"+"\t");
    10.      System.out.print("3 删除学生"+"\t");
    11.      System.out.print("4 修改学生"+"\t");
    12.      System.out.print("5 退出系统"+"\t");
    13.      System.out.println();
    14.      //键盘录入获取
    15.      Scanner sc=new Scanner(System.in);
    16.      String choiceString=sc.nextLine();
    18.      //用开关键--switch···case
    19.      switch (choiceString){
    20.          case "1":
    21.              //查看所有学生
    22.              findAllAtudent(array);
    23.              break;
    24.          case "2":
    25.              //添加学生
    26.              addStudent(array);
    27.              break;
    28.          case "3":
    29.              //删除学生
    30.              deleteStudent(array);
    31.              break;
    32.          case "4":
    33.              //修改学生
    34.              updateStudent(array);
    35.              break;
    36.          case "5":
    37.              //退出系统
    38.          default:
    39.              System.out.println("谢谢使用，欢迎下次再来！");
    40.              System.exit(0);//Java中提供的
    41.              break;
    43.      }
    44.  }

    } //封装一个方法用于查询学生的所有信息 public static void findAllAtudent(ArrayList array){

    1.  //首先来判断集合中是否有数据，如果没有数据，就给出提示，并让该方法不继续往下执行
    2.  if(array.size()==0){
    3.      System.out.println("抱歉！目前没有学生信息可供查询,请回去重新选择你的操作");
    4.      return;//将当前的方法直接结束
    5.  }
    6.  //有学生的情况下--遍历查询
    7.  //\t表示一个Tab键--制表符
    8.  System.out.println("学号\t姓名\t年龄\t居住地");
    9.  for (int i = 0; i < array.size() ; i++) {
    10.      Student s= array.get(i);
    11.      //输出属性
    12.      System.out.println(s.getId()+"\t"+
    13.              s.getName()+"\t"+
    14.              s.getAge()+"\t"+
    15.              s.getAddress());
    16.  }

    }

    //封装一个方法用于添加学生信息 public static void addStudent(ArrayList array){

    1.  //键盘录入对象
    2.  Scanner sc=new Scanner(System.in);
    3.  //所有的对学生的操作都是基于id，所以我们把id属性放到循环的外面
    4.  String id;
    5.  //能够实现重复添加学生的信息，所以使用循环
    6.  while (true){
    7.      //判断一下这个学号是不是已经存在
    8.      System.out.println("请输入学号：");
    9.      id=sc.nextLine();
    10.      //定义一个标记--假设不存在
    11.      boolean flag=false;
    12.      //遍历学号--就是遍历数组
    13.      for (int i = 0; i < array.size() ; i++) {
    14.          Student s= array.get(i);
    15.          //获取学号
    16.          if(s.getId().equals(id)){
    17.              flag=true;//学号存在
    18.              break;
    19.          }
    20.      }
    21.      //这个时候flag就是true
    22.      if(flag){
    23.          System.out.println("你的学号已经被占用，请重新输入！");
    24.      }else {
    25.          break;
    26.      }
    27.  }
    29.  //通过验证可以添加学生
    30.  System.out.println("请输入学生姓名：");
    31.  String name=sc.nextLine();
    33.  System.out.println("请输入学生年龄：");
    34.  String age=sc.nextLine();
    36.  System.out.println("请输入学生住址：");
    37.  String address=sc.nextLine();
    39.  //创建学生对象
    40.  Student s=new Student();
    41.  //赋值
    42.  s.setId(id);
    43.  s.setName(name);
    44.  s.setAge(age);
    45.  s.setAddress(address);
    47.  //把学生保存到集合中
    48.  array.add(s);
    50.  //给出提示
    51.  System.out.println("添加学生成功！");

    }

    //封装一个方法用于删除学生信息 public static void deleteStudent(ArrayList array) {

    1.  //删除学生的思路：键盘录入一个学号，到集合中去查找，看是否有学生使用的是该学号，如果有就删除该学生
    2.  //创建键盘录入对象
    3.  Scanner sc=new Scanner(System.in);
    4.  System.out.println("请输入你要删除的学生的学号：");
    5.  String id=sc.nextLine();
    7.  //遍历集合看看这个id所对应的学生是不是存在--设置一个索引
    8.  int index=-1;
    9.  for (int i = 0; i < array.size() ; i++) {
    10.      //获取每一个学生
    11.      Student s= array.get(i);
    12.      //判断学生的学号和键盘录入的id进行比较
    13.      if(s.getId().equals(id)){//要删除的对象存在
    14.          index=i;
    15.          break;
    16.      }
    17.  }
    18.  if(index==-1){
    19.      System.out.println("抱歉！你要删除的学号对应的学生信息不存在,请回去重新你的选择");
    20.  }else {
    21.      array.remove(index);
    22.      System.out.println("删除成功！");
    23.  }

    }

    //封装一个方法用于修改学生信息 public static void updateStudent(ArrayList array){

    1.  //删除学生的思路：键盘录入一个学号，到集合中去查找，看是否有学生使用的是该学号，如果有就修改该学生
    2.  //创建键盘录入对象
    3.  Scanner sc=new Scanner(System.in);
    4.  System.out.println("请输入你要修改的学生的学号：");
    5.  String id=sc.nextLine();
    7.  //遍历集合看看这个id所对应的学生是不是存在--设置一个索引
    8.  int index=-1;
    9.  for (int i = 0; i < array.size() ; i++) {
    10.      //获取每一个学生
    11.      Student s= array.get(i);
    12.      //判断学生的学号和键盘录入的id进行比较
    13.      if(s.getId().equals(id)){//要修改的对象存在
    14.          index=i;
    15.          break;
    16.      }
    17.  }
    18.  if(index==-1){
    19.      System.out.println("抱歉！你要修改的学号对应的学生信息不存在,请回去重新你的选择");
    20.  }else {
    21.      //开始进行修改
    22.      System.out.println("请输入新的学生姓名：");
    23.      String name=sc.nextLine();
    24.      System.out.println("请输入新的学生年龄：");
    25.      String age=sc.nextLine();
    26.      System.out.println("请输入新的学生住址：");
    27.      String address=sc.nextLine();
    29.      //创建一个新的对象
    30.      Student s=new Student();
    31.      s.setId(id);
    32.      s.setName(name);
    33.      s.setAge(age);
    34.      s.setAddress(address);
    36.      //修改集合中的学生对象--实际上就是把原来的信息替换
    37.      array.set(index,s);
    39.      System.out.println("修改成功！");
    40.  }

    } }

    1. <a name="8Le8t"></a>
    2. #### 学生管理系统IO版:
    3. A:在学生管理系统案例的基础上,添加新需求<br />B:查看所有的学生的数据需要从students.txt(提供好的)中读取出来     <br />C:增删改都需要先从students.txt中读出学生的数据然后再把改后的<br />![image.png](https://cdn.nlark.com/yuque/0/2020/png/2706946/1606480166349-74c2c5d2-d72c-48c2-b3e7-c3f14942b67a.png#align=left&display=inline&height=254&margin=%5Bobject%20Object%5D&name=image.png&originHeight=508&originWidth=1151&size=63889&status=done&style=none&width=575.5)<br />**注意：**<br />****1.创建集合对象要写在封装的各个方法中****<br />****2.每个封装的方法中首先要创建缓存输入流，用来读取文件****<br />****3.在添加、删除、修改的封装方法中还要创建输出流，将修改后的数据保存到文件中****<br />1.查看学生信息<br />①创建缓存输入流（BufferedReader）--读取文件<br />②创建集合对象
    4. ```java
    5. //1封装一个方法用于查询学生的所有信息
    6.  public static void findAllAtudent() throws IOException {
    7.      BufferedReader br=new BufferedReader(new FileReader("student.txt"));
    8.      String line;
    9.      while ((line=br.readLine())!=null){
    10.          System.out.println(line);
    11.      }
    12.      br.close();
    13.  }

    2.添加学生信息

①创建缓存输入流（BufferedReader）—读取文件
②创建集合对象
③添加学生信息
④创建缓存输出流（BufferedWriter）—添加学生后将集合写入文件中

  1. //2封装一个方法用于添加学生信息
  2.     public static void addStudent() throws IOException {
  3.         //创建集合
  4.         ArrayList<Student> array = new ArrayList<Student>();
  6.         BufferedReader br=new BufferedReader(new FileReader("student.txt"));
  8.         String line;
  9.         while ((line=br.readLine()) != null){
  10.             String[] strArr=line.split(",");
  11.             Student s=new Student(strArr[0], strArr[1],strArr[2],strArr[3]);
  12.             array.add(s);
  13.         }
  15.         //键盘录入对象
  16.         Scanner sc = new Scanner(System.in);
  17.         //所有的对学生的操作都是基于id，所以我们把id属性放到循环的外面
  18.         String id;
  19.         //能够实现重复添加学生的信息，所以使用循环
  20.         while (true) {
  21.             //判断一下这个学号是不是已经存在
  22.             System.out.println("请输入学号：");
  23.             id = sc.nextLine();
  24.             //定义一个标记--假设不存在
  25.             boolean flag = false;
  26.             //遍历学号--就是遍历数组
  27.             for (int i = 0; i < array.size(); i++) {
  28.                 Student s = array.get(i);
  29.                 //获取学号
  30.                 if (s.getId().equals(id)) {
  31.                     flag = true;//学号存在
  32.                     break;
  33.                 }
  34.             }
  35.             //这个时候flag就是true
  36.             if (flag) {
  37.                 System.out.println("你的学号已经被占用，请重新输入！");
  38.             } else {
  39.                 break;
  40.             }
  41.         }
  43.         //通过验证可以添加学生
  44.         System.out.println("请输入学生姓名：");
  45.         String name = sc.nextLine();
  47.         System.out.println("请输入学生年龄：");
  48.         String age = sc.nextLine();
  50.         System.out.println("请输入学生住址：");
  51.         String address = sc.nextLine();
  53.         //创建学生对象
  54.         Student s = new Student();
  55.         //赋值
  56.         s.setId(id);
  57.         s.setName(name);
  58.         s.setAge(age);
  59.         s.setAddress(address);
  61.         //把学生保存到集合中
  62.         array.add(s);
  64.         //把集合中的数据写入文件
  65.         BufferedWriter bw = new BufferedWriter(new FileWriter("student.txt",true));
  66.         String line1=s.getId()+","+s.getName()+","+s.getAge()+","+s.getAddress();
  67.         bw.write(line1);
  68.         bw.newLine();
  69.         bw.flush();
  72.         bw.close();
  73.         br.close();
  74.         //给出提示
  75.         System.out.println("添加学生成功！");
  76.     }

3.删除学生
①创建缓存输入流（BufferedReader）—读取文件
②创建集合对象
③删除学生
④创建缓存输出流（BufferedWriter）—添加学生后将集合写入文件中

  1. //3封装一个方法用于删除学生信息
  2.     public static void deleteStudent() throws IOException {
  3.         BufferedReader br=new BufferedReader(new FileReader("student.txt"));
  4.         //创建集合
  5.         ArrayList<Student> array = new ArrayList<Student>();
  7.         String line;
  8.         while ((line=br.readLine()) != null){
  9.             String[] strArr=line.split(",");
  10.             Student s=new Student(strArr[0], strArr[1],strArr[2],strArr[3]);
  11.             array.add(s);
  12.         }
  14.         //删除学生的思路：键盘录入一个学号，到集合中去查找，看是否有学生使用的是该学号，如果有就删除该学生
  15.         //创建键盘录入对象
  16.         Scanner sc = new Scanner(System.in);
  17.         System.out.println("请输入你要删除的学生的学号：");
  18.         String id = sc.nextLine();
  20.         //遍历集合看看这个id所对应的学生是不是存在--设置一个索引
  21.         int index = -1;
  22.         for (int i = 0; i < array.size(); i++) {
  23.             //获取每一个学生
  24.             Student s = array.get(i);
  25.             //判断学生的学号和键盘录入的id进行比较
  26.             if (s.getId().equals(id)) {//要删除的对象存在
  27.                 index = i;
  28.                 break;
  29.             }
  30.         }
  31.         if (index == -1) {
  32.             System.out.println("抱歉！你要删除的学号对应的学生信息不存在,请回去重新你的选择");
  33.         } else {
  34.             array.remove(index);
  35.             System.out.println("删除成功！");
  36.         }
  37.         BufferedWriter bw = new BufferedWriter(new FileWriter("student.txt"));
  38.         for (int i = 0; i <array.size(); i++) {
  39.             String s=array.get(i).getId()+","+array.get(i).getName()+","+array.get(i).getAge()+","+array.get(i).getAddress();
  40.             bw.write(s);
  41.             bw.newLine();
  42.         }
  43.         bw.close();
  44.         br.close();
  46.     }

4.修改学生
①创建缓存输入流（BufferedReader）—读取文件
②创建集合对象
③修改学生
④创建缓存输出流（BufferedWriter）—添加学生后将集合写入文件中

  1. //4封装一个方法用于修改学生信息
  2.     public static void updateStudent() throws IOException {
  3.         BufferedReader br=new BufferedReader(new FileReader("student.txt"));
  4.         //创建集合
  5.         ArrayList<Student> array = new ArrayList<Student>();
  6.         String line;
  7.         while ((line=br.readLine()) != null){
  8.             String[] strArr=line.split(",");
  9.             Student s=new Student(strArr[0], strArr[1],strArr[2],strArr[3]);
  10.             array.add(s);
  11.         }
  13.         //修改学生的思路：键盘录入一个学号，到集合中去查找，看是否有学生使用的是该学号，如果有就修改该学生
  14.         //创建键盘录入对象
  15.         Scanner sc = new Scanner(System.in);
  16.         System.out.println("请输入你要修改的学生的学号：");
  17.         String id = sc.nextLine();
  19.         //遍历集合看看这个id所对应的学生是不是存在--设置一个索引
  20.         int index = -1;
  21.         for (int i = 0; i < array.size(); i++) {
  22.             //获取每一个学生
  23.             Student s = array.get(i);
  24.             //判断学生的学号和键盘录入的id进行比较
  25.             if (s.getId().equals(id)) {//要修改的对象存在
  26.                 index = i;
  27.                 break;
  28.             }
  29.         }
  30.         if (index == -1) {
  31.             System.out.println("抱歉！你要修改的学号对应的学生信息不存在,请回去重新你的选择");
  32.         } else {
  33.             //开始进行修改
  34.             System.out.println("请输入新的学生姓名：");
  35.             String name = sc.nextLine();
  36.             System.out.println("请输入新的学生年龄：");
  37.             String age = sc.nextLine();
  38.             System.out.println("请输入新的学生住址：");
  39.             String address = sc.nextLine();
  41.             //创建一个新的对象
  42.             Student s = new Student();
  43.             s.setId(id);
  44.             s.setName(name);
  45.             s.setAge(age);
  46.             s.setAddress(address);
  48.             //修改集合中的学生对象--实际上就是把原来的信息替换
  49.             array.set(index, s);
  51.             System.out.println("修改成功！");
  52.         }
  53.         BufferedWriter bw = new BufferedWriter(new FileWriter("student.txt"));
  54.         for (int i = 0; i <array.size(); i++) {
  55.             String s=array.get(i).getId()+","+array.get(i).getName()+","+array.get(i).getAge()+","+array.get(i).getAddress();
  56.             bw.write(s);
  57.             bw.newLine();
  58.         }
  59.         bw.close();
  60.         br.close();
  61.     }

完整代码

  1. package StudentManagement;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-11-27-15:12
  6.  */
  8. import java.io.*;
  9. import java.util.ArrayList;
  10. import java.util.List;
  11. import java.util.Scanner;
  12. import java.util.TreeMap;
  14. /**
  15.  *这是一个学生管理系统
  16.  * 步骤：
  17.  * 1.定义一个学生类
  18.  * 2.学生管理系统主界面的编写
  19.  * 3.学生管理系统的查看所有学生的信息
  20.  * 4.添加学生信息
  21.  * 5.删除学生信息
  22.  * 6.修改学生信息
  23.  */
  24. public class StudentManagerTest {
  25.     public static void main(String[] args) throws IOException {
  26.         //设计界面，利用循环
  27.         while (true) {
  28.             System.out.println("---------------------欢迎来到学生管理系统------------------------");
  29.             System.out.print("1 查看所有学生" + "\t");
  30.             System.out.print("2 添加学生" + "\t");
  31.             System.out.print("3 删除学生" + "\t");
  32.             System.out.print("4 修改学生" + "\t");
  33.             System.out.print("5 退出系统" + "\t");
  34.             System.out.println();
  35.             //键盘录入获取
  36.             Scanner sc = new Scanner(System.in);
  37.             String choiceString = sc.nextLine();
  39.             //用开关键--switch···case
  40.             switch (choiceString) {
  41.                 case "1":
  42.                     //查看所有学生
  43.                     findAllAtudent();
  44.                     break;
  45.                 case "2":
  46.                     //添加学生
  47.                     addStudent();
  48.                     break;
  49.                 case "3":
  50.                     //删除学生
  51.                     deleteStudent();
  52.                     break;
  53.                 case "4":
  54.                     //修改学生
  55.                     updateStudent();
  56.                     break;
  57.                 case "5":
  58.                     //退出系统
  59.                     System.out.println("谢谢使用，欢迎下次再来！");
  60.                     System.exit(0);//Java中提供的
  61.                     break;
  62.                 default:
  63.                     System.out.println("输入格式错误");
  64.                     break;
  66.             }
  67.         }
  68.     }
  71.     //1封装一个方法用于查询学生的所有信息
  72.     public static void findAllAtudent() throws IOException {
  73.         BufferedReader br=new BufferedReader(new FileReader("student.txt"));
  74.         String line;
  75.         while ((line=br.readLine())!=null){
  76.             System.out.println(line);
  77.         }
  78.         br.close();
  79.     }
  81.     //2封装一个方法用于添加学生信息
  82.     public static void addStudent() throws IOException {
  83.         //创建集合
  84.         ArrayList<Student> array = new ArrayList<Student>();
  86.         BufferedReader br=new BufferedReader(new FileReader("student.txt"));
  88.         String line;
  89.         while ((line=br.readLine()) != null){
  90.             String[] strArr=line.split(",");
  91.             Student s=new Student(strArr[0], strArr[1],strArr[2],strArr[3]);
  92.             array.add(s);
  93.         }
  95.         //键盘录入对象
  96.         Scanner sc = new Scanner(System.in);
  97.         //所有的对学生的操作都是基于id，所以我们把id属性放到循环的外面
  98.         String id;
  99.         //能够实现重复添加学生的信息，所以使用循环
  100.         while (true) {
  101.             //判断一下这个学号是不是已经存在
  102.             System.out.println("请输入学号：");
  103.             id = sc.nextLine();
  104.             //定义一个标记--假设不存在
  105.             boolean flag = false;
  106.             //遍历学号--就是遍历数组
  107.             for (int i = 0; i < array.size(); i++) {
  108.                 Student s = array.get(i);
  109.                 //获取学号
  110.                 if (s.getId().equals(id)) {
  111.                     flag = true;//学号存在
  112.                     break;
  113.                 }
  114.             }
  115.             //这个时候flag就是true
  116.             if (flag) {
  117.                 System.out.println("你的学号已经被占用，请重新输入！");
  118.             } else {
  119.                 break;
  120.             }
  121.         }
  123.         //通过验证可以添加学生
  124.         System.out.println("请输入学生姓名：");
  125.         String name = sc.nextLine();
  127.         System.out.println("请输入学生年龄：");
  128.         String age = sc.nextLine();
  130.         System.out.println("请输入学生住址：");
  131.         String address = sc.nextLine();
  133.         //创建学生对象
  134.         Student s = new Student();
  135.         //赋值
  136.         s.setId(id);
  137.         s.setName(name);
  138.         s.setAge(age);
  139.         s.setAddress(address);
  141.         //把学生保存到集合中
  142.         array.add(s);
  144.         //把集合中的数据写入文件
  145.         BufferedWriter bw = new BufferedWriter(new FileWriter("student.txt",true));
  146.         String line1=s.getId()+","+s.getName()+","+s.getAge()+","+s.getAddress();
  147.         bw.write(line1);
  148.         bw.newLine();
  149.         bw.flush();
  152.         bw.close();
  153.         br.close();
  154.         //给出提示
  155.         System.out.println("添加学生成功！");
  156.     }
  158.     //3封装一个方法用于删除学生信息
  159.     public static void deleteStudent() throws IOException {
  160.         BufferedReader br=new BufferedReader(new FileReader("student.txt"));
  161.         //创建集合
  162.         ArrayList<Student> array = new ArrayList<Student>();
  164.         String line;
  165.         while ((line=br.readLine()) != null){
  166.             String[] strArr=line.split(",");
  167.             Student s=new Student(strArr[0], strArr[1],strArr[2],strArr[3]);
  168.             array.add(s);
  169.         }
  171.         //删除学生的思路：键盘录入一个学号，到集合中去查找，看是否有学生使用的是该学号，如果有就删除该学生
  172.         //创建键盘录入对象
  173.         Scanner sc = new Scanner(System.in);
  174.         System.out.println("请输入你要删除的学生的学号：");
  175.         String id = sc.nextLine();
  177.         //遍历集合看看这个id所对应的学生是不是存在--设置一个索引
  178.         int index = -1;
  179.         for (int i = 0; i < array.size(); i++) {
  180.             //获取每一个学生
  181.             Student s = array.get(i);
  182.             //判断学生的学号和键盘录入的id进行比较
  183.             if (s.getId().equals(id)) {//要删除的对象存在
  184.                 index = i;
  185.                 break;
  186.             }
  187.         }
  188.         if (index == -1) {
  189.             System.out.println("抱歉！你要删除的学号对应的学生信息不存在,请回去重新你的选择");
  190.         } else {
  191.             array.remove(index);
  192.             System.out.println("删除成功！");
  193.         }
  194.         BufferedWriter bw = new BufferedWriter(new FileWriter("student.txt"));
  195.         for (int i = 0; i <array.size(); i++) {
  196.             String s=array.get(i).getId()+","+array.get(i).getName()+","+array.get(i).getAge()+","+array.get(i).getAddress();
  197.             bw.write(s);
  198.             bw.newLine();
  199.         }
  200.         bw.close();
  201.         br.close();
  203.     }
  205.     //4封装一个方法用于修改学生信息
  206.     public static void updateStudent() throws IOException {
  207.         BufferedReader br=new BufferedReader(new FileReader("student.txt"));
  208.         //创建集合
  209.         ArrayList<Student> array = new ArrayList<Student>();
  210.         String line;
  211.         while ((line=br.readLine()) != null){
  212.             String[] strArr=line.split(",");
  213.             Student s=new Student(strArr[0], strArr[1],strArr[2],strArr[3]);
  214.             array.add(s);
  215.         }
  217.         //修改学生的思路：键盘录入一个学号，到集合中去查找，看是否有学生使用的是该学号，如果有就修改该学生
  218.         //创建键盘录入对象
  219.         Scanner sc = new Scanner(System.in);
  220.         System.out.println("请输入你要修改的学生的学号：");
  221.         String id = sc.nextLine();
  223.         //遍历集合看看这个id所对应的学生是不是存在--设置一个索引
  224.         int index = -1;
  225.         for (int i = 0; i < array.size(); i++) {
  226.             //获取每一个学生
  227.             Student s = array.get(i);
  228.             //判断学生的学号和键盘录入的id进行比较
  229.             if (s.getId().equals(id)) {//要修改的对象存在
  230.                 index = i;
  231.                 break;
  232.             }
  233.         }
  234.         if (index == -1) {
  235.             System.out.println("抱歉！你要修改的学号对应的学生信息不存在,请回去重新你的选择");
  236.         } else {
  237.             //开始进行修改
  238.             System.out.println("请输入新的学生姓名：");
  239.             String name = sc.nextLine();
  240.             System.out.println("请输入新的学生年龄：");
  241.             String age = sc.nextLine();
  242.             System.out.println("请输入新的学生住址：");
  243.             String address = sc.nextLine();
  245.             //创建一个新的对象
  246.             Student s = new Student();
  247.             s.setId(id);
  248.             s.setName(name);
  249.             s.setAge(age);
  250.             s.setAddress(address);
  252.             //修改集合中的学生对象--实际上就是把原来的信息替换
  253.             array.set(index, s);
  255.             System.out.println("修改成功！");
  256.         }
  257.         BufferedWriter bw = new BufferedWriter(new FileWriter("student.txt"));
  258.         for (int i = 0; i <array.size(); i++) {
  259.             String s=array.get(i).getId()+","+array.get(i).getName()+","+array.get(i).getAge()+","+array.get(i).getAddress();
  260.             bw.write(s);
  261.             bw.newLine();
  262.         }
  263.         bw.close();
  264.         br.close();
  265.     }
  266. }