案例: 集合到文件
案例: 文件到集合
案例: 点名器
案例: 集合到文件(改进版)
案例: 文件到集合(改进版)
案例: 集合到文件(数据排序改进版)
案例: 复制单级文件夹
案例: 复制多级文件夹
复制文件加入异常处理

案例: 集合到文件

需求: 把ArrayList集合中的字符串数据写入到文本文件.
要求: 每一个字符串元素座位文件中的一行数据
思路:

     1. 创建ArrayList集合
     1. 往集合中存储字符串元素
     1. 创建字符缓冲输出流对象
     1. 遍历集合, 得到每一个字符串数据
     1. 调用字符缓冲输出流对象的方法写数据
     1. 释放资源

public static void main(_String[] args) throws IOException {
// 创建ArrayList集合
// Array集合回顾集合包含泛型提前定义参数类型
ArrayList<_String_> al = new ArrayList<>();
// 往集合中存储字符串元素
al.add(“hello”);
al.add(“world”);
al.add(“java”);
// 创建字符缓冲输出流对象
BufferedWriter bw = new BufferedWriter(new FileWriter(“D:\PgProject\test11\test.txt”));
// 遍历集合,得到每一个字符串数据
// 回顾集合遍历三种方法
/ 1. Iterator it = al.iterator();
// while循环遍历Iterator
while (it.hasNext()){
String next = it.next();
System.out.print(next);
}/
/ 2. ListIterator lit = al.listIterator();
while (lit.hasNext()){
String next = lit.next();
System.out.println(next);
}/
/ 3.for循环遍历索引,小于size()循环,使用get获取对应的值
for (int i = 0; i < al.size(); i++) {
System.out.println(al.get(i));
} /
// 增强for循环,根据类型遍历该集合
for (String s: al){
// 调用字符缓冲流输出流对象的方法三个步骤写数据
// 1.void write();
bw.write(s);
// 2.void newLine();
bw.newLine();
// 3. void flush();
bw.flush(); }
//释放资源
bw.close(); }_

案例: 文件到集合

需求: 文本文件的数据读取到ArrayList集合,并遍历集合
要求: 文件中的每一行数据是一个集合元素
思路:

     1. 创建字符缓冲输入流对象
     1. 创建ArrayList集合对象
     1. 调用字符缓冲输入流对象的方法读数据
     1. 把读取到的字符串数据存储到集合汇总
     1. 释放资源
     1. 遍历集合

public static void main(_String[] args) throws IOException {
// 创建字符缓冲输入流对象
BufferedReader bf = new BufferedReader(new FileReader(“D:\PgProject\test11\test.txt”));
// 创建ArrayList集合对象
ArrayList<_String_> al = new ArrayList<>();
// 调用字符缓冲输入流对象的方法读数据
String line;
while ((line= bf.readLine())!=null){
// 把读取到的字符串数据存储到集合汇总
al.add(line); }
// 释放资源
bf.close();
// 遍历集合
for (String s : al) { System._out.println(_s); } }_

案例: 点名器

需求: 我有一个文件里面存储了班级同学的姓名
要求: 每一个姓名占一行,要求通过程序实现随机点名器
思路:

     1. 创建字符缓冲输入流对象
     1. 创建ArrayList集合对象
     1. 调用字符缓冲输入流对象的方法读数据
     1. 把读取到的字符串数据存储到集合汇总
     1. 释放资源
     1. 使用Random产生一个随机数， 随机数的范围在：[0,集合的长度 )
     1. 把第6步产生的随机数座位索引到ArrayList集合中获取值
     1. 把第7步得到的数据输出在控制台

public static void main(_String[] args) throws IOException {
// 创建字符缓冲输入流对象
BufferedReader br = new BufferedReader(new FileReader(“D:\PgProject\test11\test.txt”));
// 创建ArrayList集合对象
ArrayList<_String_> al = new ArrayList<>();
// 调用字符缓冲输入流对象的方法读数据
String line;
while ((line = br.readLine()) != null) {
// 把读取到的字符串数据存储到集合汇总
al.add(line); }
// 释放资源
br.close();
// 使用Random产生一个随机数，随机数的范围在：[0,集合的长度 )
Random random = new Random();
int nextInt = random.nextInt(al.size());
// 把第6步产生的随机数座位索引到ArrayList集合中获取值
String s = al.get(nextInt);
// 把第7步得到的数据输出在控制台
System._out.println(“幸运数字是: “ + s); }

案例: 集合到文件(改进版)

需求: 把ArrayList集合中的学生数据写入到文本文件中.
要求: 每一个学生对象的数据座位文件中的一行数据
格式: 学号, 姓名, 年龄, 居住地
举例: 001, 李畅, 26, 四川
思路:

     1. 定义学生类
     1. 创建字符缓冲输出流对象
     1. 创建ArrayList集合对象,创建学生对象
     1.  添加学生对象
     1.  把学生对象的数据凭借称指定格式的字符串
     1. 使用StringBulider的方法,拼接字符串,使用append()
     1. 调用字符缓冲输出流对象的方法写数据,使用toString()转移
     1. 释放资源

public class Student {
_private int number;
private String name;
private int age;
private String address;
public Student() { }
public int getNumber() { return number; }
public void setNumber(int number) { this.number = number; }
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 Student(int number, String name, int age, String address) {
this.number = number;
this.name = name;
this.age = age;
this.address = address; } }
——————————————————————————————————————-
public static void main(String[] args) throws IOException {
// 创建大学生对象
Student s1 = new Student(001,”李畅”,26,”四川”);
Student s2 = new Student(002,”唐明”,21,”河南”);
Student s3 = new Student(003,”赵明”,16,”濮阳”);
Student s4 = new Student(004,”奥利”,23,”达州”);
Student s5 = new Student(005,”饼干”,29,”成都”);
// 创建集合对象
ArrayList<_Student_> al = new ArrayList<>();
// 添加学生信息
al.add(s1);
al.add(s2);
al.add(s3);
al.add(s4);
al.add(s5);
// 创建文本输出流对象
BufferedWriter bw = new BufferedWriter(new FileWriter(“D:\PgProject\test11\test.txt”));
// 遍历集合元素,得到每一个学生对象
for (Student s: al){
// 把学生对象的数据凭借称指定格式的字符串
// 使用StringBulider的方法,拼接字符串,使用append()
StringBuilder sb = new StringBuilder(); sb.append(s.getNumber()).append(“,”).append(s.getName()).append(s.getAge()).append(s.getAddress());
// 调用字符缓冲输出流对象的方法写数据,参数为字符串,需要toString()转移
bw.write(sb.toString());
bw.newLine();
bw.flush(); }
// 释放资源 bw.close();}_

案例: 文件到集合(改进版)

需求: 把文本文件中的数据写入到 ArrayList集合中
要求: 文件中的一行数据是每一个学生对象的数据
格式: 学号, 姓名, 年龄, 居住地
思路:

     1. 定义学生类
     1. 创建字符缓冲输入流对象
     1. 创建ArrayList集合对象
     1. 调用字符缓冲输入流对象的方法读数据
     1. 把读取到的字符串数据用split()进行分割,得到一个字符串数组
     1. 创建学生对象
     1. 把字符串数组中的每一个元素取出来对应的赋值给学生对象的成员变量值
     1. 把学生对象添加到集合中
     1. 释放资源
     1. 遍历集合

public static void main(_String[] args) throws IOException {
// 创建字符缓冲输入流对象
BufferedReader br = new BufferedReader(new FileReader(“D:\PgProject\test11\test.txt”));
// 创建ArrayList对象
ArrayList<_Student_> al = new ArrayList<>();
// 调用字符缓冲输入流对象方法读取数据
String line;
while ((line= br.readLine())!=null) {
// 把读取到的字符串数据用split()进行分割,得到一个字符串数组
String[] split = line.split(“,”);
// 创建大学生对象
Student s = new Student();
s.setNumber(Integer._parseInt(_split[0]));
s.setName(split[1]);
s.setAge(Integer._parseInt(_split[2]));
s.setAddress(split[3]);
// 把学生对象添加到结合
al.add(s); }
// 释放资源
br.close();
// 遍历集合
for (Student student: al){
System._out.println(_student); }}_

案例: 集合到文件(数据排序改进版)

需求: 键盘录入5个学生信息(姓名, 语文成绩, 数学成绩, 英语成绩) .
要求: 按照成绩总分从高到底写入文本文件(使用TreeSet集合排序)
格式: 姓名, 语文成绩, 数学成绩, 英语成绩
举例: 李畅 98 97 95
思路:

     1. 定义一个学生类
     1. 创建TreeSet集合, 通过比较器排序进行排序
     1. 键盘录入学生数据
     1. 创建学生对象, 把键盘录入的数据赋值给对应的学生对象的成员变量
     1. 把学生对象添加到TreeSet集合汇总
     1. 创建字符缓冲输出流对象
     1. 遍历集合,得到每一个学生对象
     1. 把学生对象的数据拼接成指定格式的字符串
     1. 调用字符缓冲输出流对象的方法写数据
     1. 释放资源

public class Student {
_private String name;
private int Chinese;
private int Math;
private int English;
public Student() { }
public Student(String name, int chinese, int math, int english) {
this.name = name;
Chinese = chinese;
Math = math;
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) { Chinese = chinese; }
public int getMath() { return Math; }
public void setMath(int math) { Math = math; }
public int getEnglish() { return English; }
public void setEnglish(int english) { English = english; }
// 添加总数
public int sum() { return this.Chinese + this.English + this.Math; } }
———————————————————————————————-
public static void main(String[] args) throws IOException {
// 创建TreeSet集合通过比较器排序进行排序
// 使用匿名内部类给TreeSet传递Comparator()比较器
TreeSet<_Student_> ts = new TreeSet<>(new Comparator<_Student_>() {
@Override
public int compare(Student s1, Student s2) {
// 按照总分从高到底
int num = s2.sum() - s1.sum();
// 次要条件，总分相同时，比较单个科目成绩
// 比较语文成绩,语文成绩不同返回总数num比较
int num1 = num == 0 ? s2.getChinese() - s1.getChinese() : num;
// 如果语文和总分相同，比较数学成绩，数学成绩不同返回语文和总分num1比较
int num2 = num1 == 0 ? s2.getMath() - s1.getMath() : num1;
// 语文成绩，总数，数学成绩都相等，代表英语也相等，判断人名
return num2 == 0 ? s2.getName().compareTo(s1.getName()) : num2; } });
// 键盘录入学生信息— 5个学生，使用for循环添加后继续添加
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(“D:\PgProject\test11\test.txt”));
// 遍历集合,得到每一个学生对象
for (Student student:ts){
// 把学生对象的数据拼接成指定格式的字符串
StringBuilder sb = new StringBuilder(); sb.append(student.getName()).append(“,”).append(student.getChinese()).append(“,”).append(student.getMath()).append(“,”).append(student.getEnglish());
// 调用字符缓冲输出流对象的方法写数据
bw.write(sb.toString());
bw.newLine();
bw.flush(); }
// 释放资源 bw.close();}_

案例: 复制单级文件夹

需求：把”D:\demo”这个文件夹复制到模块目录下
思路：

     1. 创建数据源目录File对象， 路径是D:\\demo
     1. 获取数据源目录File对象的名称(demo)
     1. 创建目的地目录File对象， 路径名是模块名+demo组成(test11\\demo)
     1. 判断目的地目录对应的File是否存在，不存在则创建
     1. 获取数据源目录下说有点File数组
     1. 遍历File数组，得到每一个File对象，该File对象，其实就是数据源文件
        1. 数据源文件：D:\\demo\\中国石化标识.jpg
     7. 获取数据源文件File对象的名称(中国石化标识.jpg)
     7. 创建目的地文件File对象，路径名是目的地目录+中国石化标识.jpg组成(test11\\demo\\中国石化标识.jpg)
     7. 复制文件
        1. 由于文件不仅仅是文本文件，还有图片、视屏等文件，所以采用字节流复制文件

public class CopyFileDemo01 {
_public static void main(String[] args) throws IOException {
// 创建数据源目录File对象，路径是D:\demo
File file = new File(“D:\demo”);
// 获取数据源目录File对象的名称(demo)，使用getName()方法获取文件名
String fileName = file.getName();
// 创建目的地目录File对象，路径名是模块名+demo(test11\demo)
// File对象名称可能会改变所以创建对象获取文件名
File folder = new File(“D:\PgProject\test11”,fileName);
// 判断目的地目录对应的File是否存在，不存在则创建
// 判断文件是否存在使用exists()方法
if (!folder.exists()){
// 创建文件使用mkdir()方法
folder.mkdir(); }
// 获取数据源目录下说有点File数组，使用listFiles()
File[] listFiles = file.listFiles();
// 遍历File数组，得到每一个File对象，该File对象，其实就是数据源文件
/for (int i = 0; i < listFiles.length; i++) { System.out.println(i); }/
for (File f : listFiles){
// 数据源文件：D:\demo\中国石化标识.jpg
// 获取数据源文件File对象的名称(中国石化标识.jpg)
String srcFileName = f.getName();
System._out.println(_srcFileName);
// 创建目的地文件File对象
// 路径名是目的地目录+中国石化标识.jpg组成(test11\demo\中国石化标识.jpg)
// folder是文件加名+ srcFileName是文件夹文件名
File folder1 = new File(folder,srcFileName);
// 复制文件，创建copyFile()方法，参数是两个文件源文件夹+源目录下的文件
_copyFile(_file,folder1); } }
// 使用alt+ enter自动生成方法，内容自写
private static void copyFile(File file, File folder1) throws IOException {
// 使用字节缓冲输入流传递文件
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
// 使用字节缓冲输出流传递文件
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(folder1));
// 写入文件字节流
byte[] bytes = new byte[1024];
int len;
while ((len= bis.read(bytes))!=-1){
bos.write(bytes,0,len); }
bis.close();
bos.close(); } }_

案例: 复制多级文件夹

需求：把”D:\Test”这个文件夹复制到模块目录下
思路：

     1. 创建数据源File对象，路径是D:\\Test
     1. 创建目的地File对象，路径是F:\\
     1. 写方法实现文件夹的复制，参数为数据源File对象和目的地File对象
     1. 判断数据源File是否是目录
        1. 判断数据源是目录需要以下操作
           1. 在目的地下创建和数据源File名称一样的目录
           1. 获取数据源File下所有文件或者目录的File数组
           1. 遍历该File数组， 得到每一个File对象
           1. 把该File作为数据源File对象，递归调用复制文件夹的方法
        2. 不是目录则说明是文件，可以直接复制，用字节流

public class CopyFoldersDemo {
_public static void main(String[] args) throws IOException {
// 创建数据源File对象，路径是C:\Users\76411\Desktop
File srcFile = new File(“C:\Users\76411\Desktop”);
// 创建目的地File对象，路径是D:\
File destFile = new File(“D:\“);
// 写方法实现文件夹的复制，参数为数据源File对象和目的地File对象
_copyFolder(_srcFile,destFile); }
// 复制文件夹方法参数为数据源File对象和目的地File对象
private static void copyFolder(File srcFile, File destFile) throws IOException {
// 判断数据源是目录需要以下操作
if (srcFile.isDirectory()){
// 在目的地下创建和数据源File名称一样的目录
// 封装一个新的文件名，和源文件的文件名一致
String srcFileName = srcFile.getName();
// 封装一下数据源目的地File获取文件目录名和文件名
File newFolder = new File(destFile,srcFileName);
// 判断一下该文件是否存在，不存在则创建 !标识符表示否定
if (!newFolder.exists()){ newFolder.mkdir(); }
// 获取数据源File下所有文件或者目录的File数组
File[] fileArray = srcFile.listFiles();
// 遍历该File数组，得到每一个File对象
for (File file: fileArray){
// 把该File作为数据源File对象，可能是文件也可能是文件夹
// 递归调用复制文件夹的方法,调用自身方法，参数是遍历创建新的文件夹数组以及新的文件名
_copyFolder(_file,newFolder); }
}// 不是目录则说明是文件，可以直接复制，用字节流
else{
// 调用文件缓冲流复制方法,参数是目的地文件以及数据源文件的getName()
File newFile = new File(destFile,srcFile.getName());
_copyFile(_srcFile,newFile); } }

_// 使用alt+enter自动生成自动字节缓冲流复制文件的方法<br />    private static void copyFile_(_File srcFile, File destFile_) _throws IOException _{<br />        _// 使用字节缓冲输入流传递文件<br />        BufferedInputStream bis = new BufferedInputStream_(_new FileInputStream_(_srcFile_))_;<br />        // 使用字节缓冲输出流传递文件<br />        BufferedOutputStream bos = new BufferedOutputStream_(_new FileOutputStream_(_destFile_))_;<br />        // 写入文件字节流<br />        byte_[] _bytes = new byte_[_1024_]_;<br />        int len;<br />        while _((_len= bis.read_(_bytes_))_!=-1_){        _bos.write_(_bytes,0,len_)_;      _}<br />        _bis.close_()_;<br />        bos.close_()_;    _}    }_

复制文件加入异常处理

try…catch…finally的做法:

try{
可能出现异常的代码
}catc(异常类名变量名){
异常的处理代码
}finally{
执行所有清除操作
}
try…catch…finally的做法:
private static void method(){
_FileReader fr = null;
FileWriter fw = null;
try {
fr = new FileReader(“test.txt”);
fw = new FileWriter(“test.avi”);
char[] chars = new char[1024];
int len;
while ((len= fr.read(chars))!=-1){ fw.write(chars,0,len); }
}catch (IOException e){
e.printStackTrace();
}finally {
try {
fw.close();
} catch (IOException e) {
e.printStackTrace(); }
try {
fr.close();
} catch (IOException e) {
e.printStackTrace(); } } }
—————————————————————_

JDK7改进方案:

try(定义流对象){
可能出现异常的代码
}catc(异常类名变量名){
异常的处理代码
}
自动释放资源
JDK7改进方案:
private static void jdk7(){
_try {
FileReader fr = new FileReader(“test.txt”);
FileWriter fw = new FileWriter(“test.avi”);
char[] chars = new char[1024];
int len;
while ((len= fr.read(chars))!=-1){
fw.write(chars,0,len);
}
}catch (IOException e){
e.printStackTrace(); } }_

JDK9改进方案:

定义输入流对象
定义输出流对象
try(输入流对象;输出流对象){
可能出现异常的代码
}catc(异常类名变量名){
异常的处理代码
}
自动释放资源
private static void jdk9() throw IOEception{
_FileReader fr = new FileReader(“test.txt”);
FileWriter fw = new FileWriter(“test.avi”);
try (fr;fw){
char[] chars = new char[1024];
int len;
while ((len= fr.read(chars))!=-1){
fw.write(chars,0,len);
}
}catch (IOException e){
e.printStackTrace(); } }_

JavaSE 学习笔记

Java 学习笔记XXXI -- IO流案例