IO流常用基类
字符流基类：Reader、Writer，基本数据：字符
字节流基类：OutputStream、InputStream，基本数据：字节
这四个类都是抽象的，必须由子类复写才能使用。IO流是用来操作数据的，数据的最基本体现形式是文件，描述该操作的类是：FileReader、FileWriter或FileOutputStream、FileInputStream。键盘录入：System.in，输出到控制台：System.out。为了提高读写流的效率，可以加入缓冲技术：BufferedReader、BufferedWriter或BufferedOutputStream、BufferedInputStream。
IO流练习：
1.FileReader、FileWriter
/*
复制一个文件。
分析：
源：Reader、InputStream
纯文本文件：Reader；
设备：硬盘，FileReader
暂时不用缓冲技术。
目的：Writer、OutputStream
纯文本文件：Writer
设备：硬盘，FileWriter
暂时不用缓冲技术。
其他说明： int read()
int read(char[] chs)
String readLine()//这个是BufferedReader里面的方法
*/
import java.io.*;
class CopyFile
{
public static void main(String[] args)
{
//建立读取流，并与文件相关联
FileReader fr = null;
//建立写流
FileWriter fw = null;
try
{
fr = new FileReader("C:\\Users\\cecy\\Desktop\\javastudy\\boke\\ArrayListTest.java");
fw = new FileWriter("C:\\Users\\cecy\\Desktop\\ArrayListTest.java");
//定义一个字符数组，存放读取的数据
char[] chs = new char[1024];
int len = 0;
//读取的字符装满字符数组后，将其写到目标文件中，然后再读一次，一直循环重复，直至读取的字符为-1为止
while((len=fr.read(chs)) != -1)
{
fw.write(chs,0,len);
fw.flush();
}
}
catch (IOException e)
{
System.out.println(e.toString());
throw new RuntimeException("读取流失败！");
}
//关闭流是必须操作的步骤，所以要房子啊finally里面
finally
{
if(fr != null)
{
try
{
fr.close();
}
catch (IOException e)
{
System.out.println(e.toString());
}
}
if(fw != null)
{
try
{
fw.close();
}
catch (IOException e)
{
System.out.println(e.toString());
}
}
}
}
}2.FileInputStream、FileOutputStream：
/*
复制一个音频文件。
分析：
源：Reader、InputStream
非纯文本文件：InputStream
设备：硬盘，FileInputStream
暂时不用缓冲技术。
目标：Writer、OutputStream
非纯文本文件：OutputStream
设备：硬盘，FileOutputStream
暂时不用缓冲技术。
*/
import java.io.*;
class CopyMp3
{
public static void main(String[] args)
{
//建立读取流并与文件关联
FileInputStream fis = null;
FileOutputStream fos = null;
try
{
//因为需要关闭流，所以流的建立（定义、赋值）需要分开。
fis = new FileInputStream("C:\\Users\\cecy\\Desktop\\javastudy\\boke\\周杰伦 - 红模仿.mp3");
fos = new FileOutputStream("C:\\Users\\cecy\\Desktop\\周杰伦 - 红模仿.mp3");
byte[] bts = new byte[1024];
int len = 0;
//读取数据写数据不停的循环
while((len = fis.read(bts)) != -1)
{
fos.write(bts,0,len);
fos.flush();
}
}
catch (IOException e)
{
//读取失败，后面的程序都不用运行了，所以抛RuntimeException，
System.out.println(e.toString());
throw new RuntimeException("读取流失败！");
}
//关闭流
finally
{
if(fis != null)
{
try
{
fis.close();
}
catch (IOException e)
{
System.out.println(e.toString());
}
}
if(fos != null)
{
try
{
fos.close();
}
catch (IOException e)
{
System.out.println(e.toString());
}
}
}
}
}
键盘录入数据并将其打印在控制台上：
/*
从键盘接收并将其大写打印在控制台上。
分析：
源：Reader、InputStream
纯文本文件：Reader
设备：键盘，System.in，应该用转换流：InputStreamReader
用缓冲技术
目标：Writer、OutputStream
纯文本文件：Writer
设备：控制台，System.out，应该使用转换流：OutputStream
用缓冲技术
*/
import java.io.*;
class TransStream
{
public static void main(String[] args)
{
//获取键盘录入对象
InputStream ips = System.in;
//获取打印在控制台对象
OutputStream ops = System.out;
//使用转换流，将字节流转换为字符流
InputStreamReader ipsr = null;
OutputStreamWriter opsw = null;
//为了提高效率，加入缓冲技术
BufferedReader bufr = null;
BufferedWriter bufw = null;
try
{
ipsr = new InputStreamReader(ips);
opsw = new OutputStreamWriter(ops);
bufr = new BufferedReader(ipsr);
bufw = new BufferedWriter(opsw);
String line = null;
//输入一行读取一行，并将其转换成大写打印在控制台上
//如果输入的是over，则停止输入
while((line = bufr.readLine()) != null)
{
if("over".equals(line))
break;
bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();
}
}
catch (IOException e)
{
System.out.println(e.toString());
}
//关闭流
finally
{
if(bufr != null)
{
try
{
bufr.close();
}
catch (IOException e)
{
System.out.println(e.toString());
}
}
if(bufw != null)
{
try
{
bufw.close();
}
catch (IOException e)
{
System.out.println(e.toString());
}
}
}
}
}集合、IO流综合应用(简单模式)：
/*
有五个学生，每个学生有3门课的成绩，
从键盘输入以上数据（包括姓名，三门课成绩），
输入的格式：如：zhagnsan，30，40，60计算出总成绩，
并把学生的信息和计算出的总分数高低顺序存放在磁盘文件"stud.txt"中。
1，描述学生对象。
2，定义一个可操作学生对象的工具类。
思想：
1，通过获取键盘录入一行数据，并将该行中的信息取出封装成学生对象。
2，因为学生有很多，那么就需要存储，使用到集合。因为要对学生的总分排序。
所以可以使用TreeSet。
3，将集合的信息写入到一个文件中。
数据的变化过程：键盘——学生对象——集合——文件。
先要获取键盘录入对象，并新建一个集合，将键盘录入的信息变成学生信息，再将学生
对象存储到集合中，并将集合返回给调用者，再将集合中的数据通过写流写入到文件中。
collections.reverseOrder(),返回值类型：Comparator<Student>,以参数的形式传递给TreeSet的构造函数，
可以将TreeSet的排序方式反转。
方法摘要：
1、public int hashCode(){}
2、public boolean equals(Object obj){}//不能用泛型
3、public int compareTo(Student stu){}//使用了泛型，提高安全性
4、BufferedReader bufr = new BufferedReader(new InputStream(System.in))
5、TreeSet<Student> stus = new TreeSet<Student>()
6、TreeSet<Studnet> stus = new TreeSet<Student>(Comparator<Student> com)
7、String line = bufr.redLine()
8、static parseInt(String str)
9、BufferedWriter bufw = new BufferedWriter(new FileWriter("stud.txt"))
10、for(Student stu : stus){}
11、Comparator<Student> com = Collections.reverseOrder()
其他说明：Collection和Collections的区别：
1、Collection是接口，Collections是类；
2、Collection是集合，相当于容器，里面存放对象；Collections是工具类，
针对集合操作的，他提供一系列静态方法实现对各种集合的搜索、排序、
线程安全化等操作。；
*/
import java.io.*;
import java.util.*;
//定义学生类，因不知会存储在HashSet还是在TreeSet，所以既要实现Comparable方法，
//也要复写hashCode和equals方法
class Student implements Comparable<Student>
{
private String name;
private int ma;
private int ch;
private int en;
private int sum;
Student(String name,int ma,int ch,int en)
{
this.name = name;
this.ma = ma;
this.ch = ch;
this.en = en;
sum = ma+ch+en;
}
public String toString()
{
return "["+name+","+ma+","+ch+","+en+"]";
}
public int getSum()
{
return sum;
}
public int hashCode()
{
return name.hashCode()+sum*34;
}
public boolean equals(Object obj)
{
if(!(obj instanceof Student))
throw new ClassCastException("不是学生类！");
Student s = (Student)obj;
return this.name.equals(s.name) && this.sum == s.sum;
}
public int compareTo(Student s)
{
int num = new Integer(this.sum).compareTo(new Integer(s.sum));
if(num == 0)
return this.name.compareTo(s.name);
return num;
}
}
//定义操作学生的工具类，既可以按照学生成绩的升序排序，也可以按照学生成绩的降序排序
class StudentInfoTool
{
//按照学生成绩升序排列
public static Set<Student> getStudents()
{
return getStudents(null);
}
//按照学生成绩降序排序
public static Set<Student> getStudents(Comparator<Student> com)
{
System.out.println("请输入学生信息，格式为：名字,语文成绩,数学成绩,英语成绩：");
//获取键盘录入对象
BufferedReader bufr = null;
//定义一个集合装学生对象
TreeSet<Student> stus = null;
if(com == null)
stus = new TreeSet<Student>();
else
stus = new TreeSet<Student>(com);
try
{
bufr = new BufferedReader(new InputStreamReader(System.in));
String line = null;
//从键盘输入数据，然后将数据封装成学生对象，并将其存储进集合
while(true)
{
line = bufr.readLine();
if("over".equals(line))
break;
String[] strs = line.split(",");
Student s = new Student(strs[0],Integer.parseInt(strs[1]),Integer.parseInt(strs[2]),Integer.parseInt(strs[3]));
stus.add(s);
}
}
catch (IOException e)
{
throw new RuntimeException("录入学生信息失败！请重新输入正确的。");
}
finally
{
if(bufr != null)
{
try
{
bufr.close();
}
catch (IOException e)
{
System.out.println("关闭流失败");
}
}
}
return stus;
}
//将集合中学生信息写到文件中。
public static void writeToFile(Set<Student> stus)
{
BufferedWriter bufw = null;
try
{
bufw = new BufferedWriter(new FileWriter("stud.txt"));
for(Student stu : stus)
{
bufw.write(stu.toString()+"\t");
bufw.write(stu.getSum()+"");
bufw.newLine();
bufw.flush();
}
}
catch (IOException e)
{
throw new RuntimeException("数据写入失败，请输入正确的信息！");
}
finally
{
if(bufw != null)
{
try
{
bufw.close();
}
catch (IOException e)
{
System.out.println(e.toString());
}
}
}
}
}
class StudentInfoTest
{
public static void main(String[] args)
{
//调用Collection中，使排序方式反转的方法
Comparator<Student> com = Collections.reverseOrder();
//获取存储学生对象的集合
Set<Student> stus = StudentInfoTool.getStudents(com);
//将集合中的学生对象写到文件中
StudentInfoTool.writeToFile(stus);
}
}
扫一扫
1835
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
