(44)Java学习笔记——IO流 / 分阶段总结和练习

IO流总结



练习01：复制文本文件

使用字符流更方便一些。采用字符缓冲区流的方式。

package cn.itcast_01;

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

/*
* 采用字符缓冲流复制文本文件
*/
public class CopyBufferedTest_01 {
public static void main(String[] args) throws IOException {
//创建字符缓冲流对象
BufferedReader br = new BufferedReader(new FileReader("a.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));

//输出输入数据
String line = null;
while((line = br.readLine())!=null){
bw.write(line);
bw.newLine();
bw.flush();
}

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

}
}

练习02：复制图片

package cn.itcast_01;

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

/*
* 复制图片不能用字符流
* 采用字节缓冲流的做法
*
*/
public class CopyImageTest_01 {
public static void main(String[] args) throws IOException {
//定义字节缓冲流的对象
BufferedInputStream bis = new BufferedInputStream(
new FileInputStream("f:\\马士兵JAVA.jpg"));
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream("g:\\mashibing.jpg"));

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

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

练习03：把ArrayList集合中的字符串数据储存到文本文件

package cn.itcast_01;

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

/*
* 把ArrayList集合中的字符串数据存储到文本文件
* 思路：
* A / 定义一个ArrayList集合，添加字符串数据
* B / 创建字符缓冲流对象
* C / 遍历集合写入数据
* D / 释放资源
*/
public class ArrayListTest_01 {
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("aa.txt"));

//遍历集合并写入数据
Iterator<String> it = array.iterator();
while (it.hasNext()){
String s = it.next();
bw.write(s);
bw.flush();
}

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

}
}

练习04：从文本文件中读取数据（每一行为一个字符串数据）到集合中，并遍历集合

package cn.itcast_01;

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

/*
* 练习04：从文本文件中读取数据（每一行为一个字符串数据）到集合中，并遍历集合
*
*/
public class ArrayListTest_02 {
public static void main(String[] args) throws IOException {
//创建字符缓冲输出流
BufferedReader bd = new BufferedReader(
new FileReader("aa.txt"));

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

//读取数据并添加到集合
String line = null;
while((line= bd.readLine())!= null){
//字符数组转成字符串
String s = line.toString();
array.add(s);
}

//遍历集合
Iterator<String> it = array.iterator();
while(it.hasNext()){
String s = it.next();
System.out.println(s);
}

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

}
}

练习05：随机获取文本文件中的姓名案例

package cn.itcast_01;

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

/*
* 练习05：随机获取文本文件中的姓名案例
* 思路：
* A / 读取文件中的姓名
* B / 传入集合 （采用ArrayList集合，因为他有get()功能）
* C / 随机获取集合内的元素
*
*/

public class RandomTest_01 {
public static void main(String[] args) throws IOException {
//创建字符缓冲读取流对象
BufferedReader bd =new BufferedReader(
new FileReader("bb.txt"));

//创建集合用存储文本中的名字
ArrayList<String> array =new ArrayList<String>();

//读取数据并添加到集合中
String line = null;
while ((line = bd.readLine())!= null){
array.add(line);
}

//随机获取集合中的元素
Random r = new Random();
int result = r.nextInt(array.size());
String s = array.get(result);
System.out.println(s);

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

练习06：复制单级文件夹

package cn.itcast_01;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
* 复制单级文件夹
* 数据源：F:\\demo
* 目的地：G:\\newDemo
*
* 思路：
* A / 封装目录
* B / 获取该目录下的所有文件的File数组
* C / 遍历File 数组，得到每一个File对象
* D / 把该File进行复制
*
*/
public class FolderTest_01 {
public static void main(String[] args) throws IOException {
//封装目录
File srcFolder = new File("f:\\demo");
//封装目的地
File destFolder = new File("g:\\newDemo");

//如果目的地文件夹不存在，就创建
if (!destFolder.exists()){
destFolder.mkdirs();
}

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

//遍历数组，得到每一个File对象
for(File file : fileArray){
//System.out.println(file);
//f:\demo\a.txt
String name = file.getName();	//a.txt
File newFile = new File(destFolder,name);	//g:\\newDemo\\a.txt

copyFile(file,newFile);
}
System.out.println("文件复制完成！");

}

private static void copyFile(File file, File newFile) throws IOException {

//创建字节缓冲流对象
BufferedInputStream bis =new BufferedInputStream(
new FileInputStream(file));
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream(newFile));

//读取每一个File对象并输入
byte[] bys = new byte[1024];
int len=0;
while((len = bis.read(bys))!= -1){
bos.write(bys, 0, len);

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

练习07：复制多级文件夹

package cn.itcast_01;

package cn.itcast_01;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
* 练习07：复制多级文件夹
* 数据源：F:\\demos
* 目的地：G:\\
*
* 思路：
* A / 封装目录FILE
* B / 判断该File是文件还是文件夹
* 			a / 是文件
* 					复制（字节流）
* 			b / 是文件夹
* 					就在目的地目录下创建该文件夹
* 					获取该File对象下的所有文件或者文件夹File对象
* 					遍历得到每一个File对象
* 					回到B
*/
public class CopyFolderTest_02 {
public static void main(String[] args) throws IOException {
//封装目录
File srcFile = new File("F:\\demos");
File destFile = new File("g:\\");

//复制文件夹的方法
copyFolder(srcFile,destFile);

}

private static void copyFolder(File srcFile, File destFile) throws IOException {
if(srcFile.isDirectory()){
//是文件夹就在目的地目录下创建该文件夹
File newFolder = new File(destFile,srcFile.getName());
newFolder.mkdir();
//获取该File对象下的所有文件或者文件夹File对象
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 {
BufferedInputStream bis = new BufferedInputStream(
new FileInputStream(srcFile));
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream(newFile));

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

}
}

练习08：键盘录入5个学生信息（姓名，语文成绩，数学成绩，英语成绩）按照总分从高到低存入文本文件

package cn.itcast_02;
/*
* Student
*/
public class Student {
private String name;

private int chinese;

private int math;

private int english;

public Student() {
super();
// TODO Auto-generated constructor stub
}

public Student(String name, int chinese, int math, int english) {
super();
this.name = name;
this.chinese = chinese
b549
;
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;
}

package cn.itcast_02;

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

/*
* 练习08：键盘录入5个学生信息（姓名，语文成绩，数学成绩，英语成绩）按照总分从高到低存入文本文件
* 思路：
* A / 创建学生对象
* B / 创建集合对象 TreeSet<Student>
* C / 键盘录入学生信息存储到集合
* D / 遍历集合，输出到文本
*/
public class IOTest_01 {
public static void main(String[] args) throws IOException {
//创建集合对象
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.getEnglish() - s2.getEnglish() : num3;
int num5 = num4 ==0?s1.getName().compareTo(s2.getName()) : num4;
return num5;
}

});

//键盘录入学生信息储存到集合
for(int x =0; x<=5 ;x++){
Scanner sc =new Scanner(System.in);
System.out.println("请录入第"+x+"个的学生信息");
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);

//把学生信息添加到集合
ts.add(s);
}

//遍历集合，把数据写到文本文件
BufferedWriter bw = new BufferedWriter(
new FileWriter("Student.txt"));
bw.write("学生信息如下：");
bw.newLine();
bw.flush();
bw.write("姓名，语文成绩，数学成绩，英语成绩");
bw.newLine();
bw.flush();
//遍历集合
for (Student s : ts){
StringBuilder sb = new StringBuilder();
sb.append(s.getName()).append(",").append(s.getChinese()).append(",").append(s.getMath()).append(",").append(s.getEnglish());
bw.write(sb.toString());
bw.newLine();
bw.flush();
}

//释放资源
bw.close();
System.out.println("学生信息存储完毕！");

}
}

练习09：把一个文件中的字符串排序后在写入另一个文件案例

package cn.itcast_02;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Arrays;

/*
* 已知s.txt文件中有这样一个字符串："jintiantianqihenhaoxinqingbuhao",读取数据内容，吧数据排序后写入ss.txt
* 思路：
* A/ 创建字符缓冲流
* B/ 读取文件内容，并转换成字符串
* C/ 字符串转换为字符数组，并对数组排序
* D/ 将排序后的字符串写入文件
*/
public class StringTest_01 {
public static void main(String[] args) throws IOException {
//创建字符缓冲流对象
BufferedReader br = new BufferedReader(
new FileReader("s.txt"));

//读取该文件内容，存储到一个字符串中
String line = br.readLine();
br.close();

//把字符串转成字符数组
char[] chs = line.toCharArray();

//对字符数组进行排序
Arrays.sort(chs);

//把排序后的数组转成字符串
String s = String.valueOf(chs);

//把排序后的字符串写入ss.txt文件
BufferedWriter bw = new BufferedWriter(
new FileWriter("ss.txt"));
bw.write(s);
bw.flush();
bw.close();

}
}