IO流综合案例
1. 集合到文件
- 要求把集合中的元素写入指定文件中
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
//集合到文件
/*
1.创建一个字符缓冲输出流对象
2.创建一个ArrayList集合对象
3.添加元素
4.遍历集合
5.写入数据 一次写入一行
*/
public class Test01 {
public static void main(String[] args) throws IOException {
//创建字符缓冲输出流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("iodemo\\demo.txt"));
//创建集合对象
ArrayList<String> arr = new ArrayList<>();
//添加元素
arr.add("hello");
arr.add("world");
arr.add("java");
//遍历集合
for (String s : arr) {
//写数据
bw.write(s);
//换行
bw.newLine();
bw.flush();
}
//释放资源
bw.close();
}
}
2. 文件到集合
- 要求把文件中的内容写入集合中
import java.io.*;
import java.util.ArrayList;
//文件到集合
/*
1.创建字符缓冲输入流对象
2.创建ArrayList集合
3.读取文件数据 一次读取一行
4.将读取的数据写入ArrayList集合中
5.遍历ArrayList集合
*/
public class Test02 {
public static void main(String[] args) throws IOException {
//创建字符缓冲输入流对象
BufferedReader br = new BufferedReader(new FileReader("iodemo\\demo.txt"));
//创建ArrayList集合对象
ArrayList<String> arr = new ArrayList<>();
//创建一个字符串 用于接收读取的数据
String line;
while ((line =br.readLine())!= null){
//将数据写入集合
arr.add(line);
}
//遍历集合
for (String s : arr) {
System.out.println(s);
}
}
}
3. 点名器
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Random;
//点名器
/*
1.创建字符缓冲输入流对象
2.创建ArrayList集合对象
3.读取数据 存入集合
4.生成一个随机数 整型接收并且给定范围
5.通过随机数作为索引输出集合对应元素
*/
public class Test03 {
public static void main(String[] args) throws IOException {
//创建字符缓冲输入流对象
BufferedReader br = new BufferedReader(new FileReader("iodemo\\dianming.txt"));
//创建ArrayList集合对象
ArrayList<String> arr = new ArrayList<>();
//读数据
String line;
while ((line = br.readLine())!= null){
//添加元素到集合
arr.add(line);
}
//随机生成索引
Random r = new Random();
//范围为arr.size() 如果不给规定范围会导致异常 索引越界
int index = r.nextInt(arr.size());
//索引指定元素
String name = arr.get(index);
System.out.println("幸运选手:" + name);
}
}
4. 集合到文件 (第2版)
- 集合存储类型是学生类
- 测试类
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
//集合到文件 集合类型为 学生类
/*
1.定义学生类
2.创建字符缓冲输出流对象
3.创建集合对象
4.创建学生对象
5.将学生对象添加到集合
6.遍历集合 得到的是学生对象
7.按要求拼接学生对象的信息 使用StringBuilder
8.写数据 一次写一行 这里注意把StringBuilder转为String类型写入
9.释放资源
*/
public class Test {
public static void main(String[] args) throws IOException {
//创建字符缓冲输出流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("iodemo\\student.txt"));
//创建集合对象
ArrayList<Student> arr = new ArrayList<>();
//创建学生对象
Student s1 = new Student("11111", "张三", 18);
Student s2 = new Student("22222", "李四", 19);
Student s3 = new Student("33333", "王五", 20);
//将学生对象添加到集合
arr.add(s1);
arr.add(s2);
arr.add(s3);
//遍历集合 得到的是学生对象
for (Student st : arr) {
StringBuilder sb = new StringBuilder();
sb.append(st.getSid()).append(",").append(st.getName()).append(",").append(st.getAge());
//写数据
bw.write(sb.toString());
//换行
bw.newLine();
//刷新
bw.flush();
}
//释放资源
bw.close();
}
}
- 学生类
public class Student {
private String sid;
private String name;
private int age;
public Student() {
}
public Student(String sid, String name, int age) {
this.sid = sid;
this.name = name;
this.age = age;
}
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;
}
}
5. 文件到集合(第2版)
-
集合存储类型为学生类
-
测试类
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
//文件到集合 第2版
/*
1.定义学生类
2.创建ArrayList集合对象
3.创建字符缓冲输入流对象
4.读取数据 一次读一行
5.使用split();方法对读取到的字符串进行切片
6.创建学生对象并set值
7.将学生对象添加到集合
8.释放资源
9.遍历集合
*/
public class Test02 {
public static void main(String[] args) throws IOException {
//创建集合对象
ArrayList<Student> arr = new ArrayList<>();
//创建字符缓冲输入流对象
BufferedReader br = new BufferedReader(new FileReader("iodemo\\student.txt"));
//读数据
String line;
while ((line = br.readLine()) != null){
//split();方法 切片
String[] strarr = line.split(",");
//创建学生对象
Student s = new Student();
s.setSid(strarr[0]);
s.setName(strarr[1]);
s.setAge(Integer.parseInt(strarr[2]));
//将学生对象添加到集合
arr.add(s);
}
//释放资源
br.close();
//遍历集合
for (Student s : arr) {
System.out.println(s.getSid() + "," + s.getName() + "," + s.getAge());
}
}
}
- 学生类
public class Student {
private String sid;
private String name;
private int age;
public Student() {
}
public Student(String sid, String name, int age) {
this.sid = sid;
this.name = name;
this.age = age;
}
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;
}
}
6. 集合到文件 (数据排序版)
- 采用键盘录入信息
- 写入文件的数据按要求排序
- 测试类
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;
//集合到文件数据排序 (第3版)
/*
1. 定义学生类
2. 创建TreeSet集合,通过比较器排序进行排序
3. 键盘录入学生数据
4. 创建学生对象,把键盘录入的数据对应赋值给学生对象的成员变量
5. 把学生对象添加到TreeSet集合
6. 创建字符缓冲输出流对象
7. 遍历集合,得到每一个学生对象
8. 把学生对象的数据拼接成指定格式的字符串
9. 调用字符缓冲输出流对象的方法写数据
10. 释放资源
*/
public class Test {
public static void main(String[] args) throws IOException {
BufferedWriter bw = new BufferedWriter(new FileWriter("iodemo\\demo.txt"));
TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
int num = s1.getsum()-s2.getsum();
int num1 = num == 0 ? s1.getMath()- s2.getMath(): num;
int num2 = num1 == 0 ? s1.getChinese() - s2.getChinese(): num1;
int num3 = num2 == 0 ? s2.getName().compareTo(s1.getName()) : num1;
return num3;
}
});
for (int i = 0; i < 3; i++) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入姓名");
String name = sc.nextLine();
System.out.println("请输入数学成绩");
int math = sc.nextInt();
System.out.println("请输入语文成绩");
int chinese = sc.nextInt();
System.out.println("请输入英语成绩");
int english = sc.nextInt();
Student s = new Student();
s.setName(name);
s.setMath(math);
s.setChinese(chinese);
s.setEnglish(english);
ts.add(s);
}
for (Student t : ts) {
StringBuilder sb = new StringBuilder();
sb.append(t.getName()).append(",").append(t.getMath()).append(",").append(t.getChinese()).append(",").append(t.getEnglish()).append(",").append(t.getsum());
bw.write(sb.toString());
bw.newLine();
bw.flush();
}
bw.close();
}
}
- 学生类
public class Student {
private String name;
private int math;
private int chinese;
private int english;
public Student() {
}
public Student(String name, int math, int chinese, int english) {
this.name = name;
this.math = math;
this.chinese = chinese;
this.english = english;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getMath() {
return math;
}
public void setMath(int math) {
this.math = math;
}
public int getChinese() {
return chinese;
}
public void setChinese(int chinese) {
this.chinese = chinese;
}
public int getEnglish() {
return english;
}
public void setEnglish(int english) {
this.english = english;
}
public int getsum(){
int sum = this.math + this.chinese + this.english;
return sum;
}
}
7. 复制单级文件夹
- 复制单级文件夹到指定目录下
- 复制这个文件夹包括文件夹里的文件
import java.io.*;
//复制单级文件夹
/*
1. 创建数据源目录File对象,路径是E:\Java_test\java
2. 获取数据源目录File对象的名称
3. 创建目的地目录File对象,路径由(模块名+第2步获取的名称)组成
4. 判断第3步创建的File是否存在,如果不存在,就创建
5. 获取数据源目录下所有文件的File数组
6. 遍历File数组,得到每一个File对象,该File对象,其实就是数据源文件
7. 获取数据源文件File对象的名称
8. 创建目的地文件File对象,路径由(目的地目录+第7步获取的名称)组成
9. 复制文件
由于不清楚数据源目录下的文件都是什么类型的,所以采用字节流复制文件
采用参数为File的构造方法
*/
public class test05 {
public static void main(String[] args) throws IOException{
//创建File对象
File srcFolder = new File("E:\\Java_test\\java");
//获取数据源目录名称
String srcFolderName = srcFolder.getName();
//创建目的地目录File对象
File destFolder = new File("E:\\java_test_copy",srcFolderName);
//判断创建的File是否存在,如果不存在,就创建
if (!destFolder.exists()){
destFolder.mkdir();
}
//获取数据源目录下所有文件的File数组
File[] listFiles = srcFolder.listFiles();
//遍历File数组,得到每一个File对象,该File对象,其实就是数据源文件
for (File listFile : listFiles) {
//获取数据源文件File对象的名称
String listFileName = listFile.getName();
//创建目的地文件File对象,路径由(目的地目录+获取的名称)组成
File destFile = new File(destFolder,listFileName);
//调用复制方法
copy(listFile,destFile);
}
}
//复制方法
private static void copy(File listFile, File destFile) throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(listFile));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));
//一次读写一个字节数组
byte[] bys = new byte[1024];
int len;
while ((len = bis.read(bys))!= -1){
bos.write(bys,0,len);
}
//释放资源
bis.close();
bos.close();
}
}
8. 复制多级文件夹
- 复制多级文件夹到指定目录下
- 复制文件夹以及文件夹里的内容,文件夹里可能包含文件夹
- 采用递归复制多级文件夹
import java.io.*;
//复制多级文件
/*
1. 创建数据源File对象,路径是E:\\Java_test
2. 创建目的地File对象,路径是E:\\java_test_copy
3. 写方法实现文件夹的复制,参数为数据源File对象和目的地File对象
4. 判断数据源File是否是文件
是文件:直接复制,用字节流
不是文件:
在目的地下创建该目录
遍历获取该目录下的所有文件的File数组,得到每一个File对象
回到3继续(递归)
*/
public class Test02 {
public static void main(String[] args) throws IOException{
File srcFile = new File("E:\\Java_test");
File destFile = new File("E:\\java_test_copy");
copyFolder(srcFile,destFile);
}
//复制文件夹
private static void copyFolder(File srcFile,File destFile) throws IOException {
//判断是否为文件夹
if (srcFile.isDirectory()){
//获取数据源目录名称
String srcFileName = srcFile.getName();
File newFolder = new File(destFile,srcFileName);
//判断目录是否存在
if (!newFolder.exists()){
newFolder.mkdir();
}
File[] fileArray = srcFile.listFiles();
for (File file : fileArray) {
//采用递归调用
copyFolder(file,newFolder);
}
}else {
File newFile = new File(destFile,srcFile.getName());
//调用复制文件方法
copyFile(srcFile,newFile);
}
}
//复制文件
private static void copyFile(File srcFile, File newFile) throws IOException {
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(newFile));
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
byte[] bys = new byte[1024];
int len;
while ((len = bis.read(bys))!=-1){
bos.write(bys,0,len);
}
bos.close();
bis.close();
}
}