这一章涉及到流的操作：介绍下流操作的规律；
流操作的规律：选用那一个流对象？
通过两个明确：
1> 明确源和目的：
明确源 输入流:InputStream Reader
目的 输出流 : OutputStream Writer
2> 操作的数据是否纯文本：
纯文本--》字符流 否--》字节流
3>当体系明确后，在确定使用哪个对象
通过源设备来进行区分：源设备-->内存、 键盘、硬盘
目的设备-->内存、硬盘、控制台
分析一：将一个文件的内容复制到另一个文件
源： 文件 数据 纯文本 使用 Reader
FileReader fr = new FileReader("源文件名");
是否使用缓冲区： BufferedReader bufr = new BufferedReader(fr);
目的 ：文件 使用Writer
FileWriter fw = new FileWriter("目的文件名");
是否使用缓冲区：BufferedWreter bufw = new BufferedWriter(fw);
使用循环复制
练习：将一个图片文件中的数据存储到另一个文件；即复制文件
分析2: 将键盘录入的数据保存到一个文件中
源：InputStream Reader
纯文本：Reader
设备 :键盘。对应的对象是 System.in(字节流)
为了操作输数据文本的方便 ，转成字符流按照字符串操作是最方便的 ，
即：将system.in 转换成Reader
用到Reader体系中的转化流InputStreamReader
例：
InputStreanReader isr = new InputStreamReadr(Sywtem.in);
是否提高效率:
BufferedReader bufr = new BufferedReader(isr);
目的: OutputStream Writer
纯文本: Writer
设备: 硬盘 文件 使用 FileWeiter
FileWriter fw = new FileWriter("文件名");
是否提高效率:
BufferedWriter bufw = new BufferedWriter(fw);
使用循环连续录入
--------------------------------------------------------
扩展：把录入的数据按照指定的编码表(UTF-8)，将数据存到文件中
目的: OutputStream Writer
纯文本: Writer
设备: 硬盘 文件 使用 FileWriter
但是 FileWriter使用的默认的编码表，GBK
存储时，需要加入指定的编码表utf-8，而指定的编码表只用转化流可以指定
所以要使用的是OutputStreamWriter。
而转化流对象要接收一个字节输出流，而且还可以操作文件的字节输出流，FileOutputStream
所以： //将读取到的(指定编码的)字节流转化为字符流
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("文件名","utf-8"));
是否需要高效：
BufferedWriter bufw = new BufferedWriter(osw);
转化流是字节与字符之间转化的桥梁，通常涉及到字符编码转换时，需要用到转化流
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
流按操作分为：字节流、字符流
流按流向分为：输入流、输出流
字节流的两个基类：InputStream(输入流)、OutputStream(输出流)
字符流的两个基类：Reader(写入数据)、Writer(读出数据)
缓冲区是有助于提高数据的读写效率，缓冲区要结合流才可以使用，在流的基础上对流的功能进行了增强；
Reader对应的缓冲区：BufferReader；
Wrier对应的缓冲区：BufferWriter；
综合举例Reader和Writer:
<span style="font-size:18px;"><strong>public class Demo {
/*
在D盘加一个文件，将C盘的一个文件的内容写进去
*/
public static void main(String[] args) throws IOException {
//读取C盘中的文件
FileReader fr = new FileReader("D:\\Demo.java");
//写入D盘中的文件
FileWriter fw = new FileWriter("D:\\Demo_copy.java");
char[] buf = new char[1024];
int num = 0;
while((num = fr.read(buf)) != -1){/读取数据/
fw.write(buf,0,num);//写入数据
System.out.println(new String(buf,0,num));
}
fr.close();关闭流//
fw.close();
}
}
举例BufferReader和BufferWriter：
public class BufferReaderDemo {
public static void main(String[] args) throws IOException {
//创建一个读取流对象
FileReader fr = new FileReader("java.txt");
//创建缓冲区对象,需将被提高效率的流对象作为参数传递给缓冲区的构造函数
BufferedReader bufr = new BufferedReader(fr);
//读取行的方法读出
String line = null;
while((line = bufr.readLine()) != null){
System.out.println(line);
}
//按字节的方法读出
// char[] buf = new char[1024];
// int len = 0;
// while((len = bufr.read(buf)) != -1){
// System.out.println(new String(buf,0,len));
// }
}
}
public class BufferWriterDemo {
/*
* 创建缓冲区之前必须先创建 流对象
*/
public static void main(String[] args) throws IOException {
//创建流对象
FileWriter fw = new FileWriter("java.txt");
//创建缓冲区对象,需将被提高效率的流对象作为参数传递给缓冲区的构造函数
BufferedWriter bufw = new BufferedWriter(fw);
for(int x = 0; x < 5; x++){
bufw.write("abc" + x);
bufw.newLine();//换行操作
bufw.flush();
}
bufw.close();
}
}
综合举例BufferReader和BufferWriter：
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Demo {
public static void main(String[] args) throws IOException {
//使用缓冲区读取指定数据
BufferedReader bufr = new BufferedReader(new FileReader("G:\\a.txt"));
//使用缓冲将数据写入指定位置
BufferedWriter bufw = new BufferedWriter(new FileWriter("G:\\a_copy.txt"));
String line = null;
while((line = bufr.readLine()) != null){//读取出所有数据
bufw.write(line);//将读取的数据写入指定位置
}
bufr.close();//关闭流
bufw.close();
}
}</strong></span>-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
字节流：InputStream和OutputStream及相对应的缓冲区BufferedInputStream和BufferedOutputStream
综合举例InputStream和OutputStream
<span style="font-size:18px;"><strong>public class Demo {
public static void main(String[] args) throws IOException {
//读取指定的数据内容
FileInputStream fis = new FileInputStream("G:\\A.gif");
//写入指定的数据内容
FileOutputStream fos = new FileOutputStream("G:\\b.gif");
byte[] buf = new byte[1024];
int len = 0;
while((len = fis.read(buf)) != -1){//循环读出所用数据
fos.write(buf,0,len);//写入读取的数据
}
fis.close();//关闭流
fos.close();
}
}</strong></span>---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
转化流是字节流转化为字符流的桥梁
InputStream对应转化流InputStreamReader
OutputStream对应的转化流OutputStreamWriter
综合举例转化流：
<span style="font-size:18px;"><strong>import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
public class Demo {
/*
* 直接使用readLine方法来完成键盘录入的读取
*/
public static void main(String[] args) throws IOException {
//获取键盘录入对象
InputStream in = System.in;
//将字节流对象转化成字符流对象，使用InputStreamReader
InputStreamReader isr = new InputStreamReader(in);
//为了提高效率，将字符串进行缓冲区技术高效操作。使用BufferReader
BufferedReader bufr = new BufferedReader(isr);
//获取键盘输出对象
OutputStream out = System.out;
//将字节流转化成字符流，使用OutputStreamWriter
OutputStreamWriter osw = new OutputStreamWriter(out);
//为了提高效率。将字符串进行缓冲区技术高效操作，使用BuffferWriter
BufferedWriter bufw = new BufferedWriter(osw);
String len = null;
while((len = bufr.readLine()) != null){
if("over".equals(len)){
break;
}
//采用输出流的方式输出
bufw.write(len.toUpperCase());
bufw.newLine();
bufw.flush();//刷新
// System.out.println(len.toUpperCase());
}
bufr.close();
}
}
键盘录入练习1：
public class Demo{
/*
* 把键盘录入的数据存储到一个文件
* 源：键盘
* 目的：文件
*
*/
public static void main(String[] args) throws IOException {
//获取键盘录入数据
BufferedReader bufr = new BufferedReader(new InputStreamReader((System.in)));
//将录入数据写入到指定位置
BufferedWriter bufw = new BufferedWriter(new FileWriter("G:\\b.txt"));
String line = null;
while((line = bufr.readLine()) != null){
if("over".equals(line)){//设置关闭操作
break;
}
bufw.write(line);//将数据写入
bufw.newLine();//换行
bufw.flush();//刷新数据
}
bufr.close();//关闭了流
bufw.close();
}
}
键盘录入练习2：
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStreamWriter;
public class Demo {
/*
* 将文件的数据输出到控制台；
* 源：文件
* 目的：控制台
*/
public static void main(String[] args) throws IOException {
//读取指定的数据
BufferedReader bufr = new BufferedReader(new FileReader("G:\\b.txt"));
//将读取的数据输出到控制台
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));
String line = null;
while((line = bufr.readLine()) != null){//读取所有数据
bufw.write(line);//写入所有数据
bufw.newLine();//换行
bufw.flush();//刷新数据
}
bufr.close();
bufw.close();
}
}</strong></span>---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
File类基本功能：
/*
* 创建： boolean createNewFile() 创建文件，如果已经存在则不创建
* boolean mkdir()//创建文件夹
* boolean mkdirs()//创建多级文件夹
* 删除：
* boolean delete();删除失败返回false，当文件正在使用时不能删除
* void deleteOnExit()当文件退出时删除给文件(用于临时文件)
*
* 判断：boolean exists()文件是否存在
* boolean isDirectory()判断是此文件是否是一个目录
* boolean isFile()判断此文件是够是一个标准文件
*
* 获取：
* getName:
* getPath://返回绝对路径
* getPaent://返回绝对路径的上一层目录
* getAbsolutePath(获取绝对路径)：
*
* static File[] File.listRoots():获取系统的有效盘符(返回数组)
* String[] list();获取指定路径的所有文件和目录(返回数组)
*
* File[] listFiles(); (返回路径名数组，可对象进行操作)获取目录下的文件
*/
<span style="font-size:18px;"><strong>代码练习：
import java.io.File;
import java.io.IOException;
public class Demo {
public static void main(String[] args) throws IOException {
//将file.txt封装成对象，可以将已有的和未有的文件或文件夹封装成对象
File f = new File("file.txt");
// System.out.println(f.getName());
// System.out.println(f.getPath());//获取相对路径
// System.out.println(f.getAbsolutePath());//获取绝对路径
File f1 = new File("G:\\abc\\a.txt");//在G盘下创建abc文件夹又在abc文件夹次啊创建a.txt文件夹
System.out.println(f1.mkdirs());//创建文件夹
// System.out.println(f1.isDirectory());
System.out.println(f.createNewFile());//创建文件，如果已经存在则不创建
// System.out.println(f.isFile());//判断此文件是否是一个标准文件
// System.out.println(f.delete());//判断此文件是否是一个目录
// System.out.println(f.canExecute());//判断文件是否可执行
// System.out.println(f.exists());//判断文件是否存在
//listRoots方法
File[] files = File.listRoots();//返回系统的所有盘符
for(File k : files){
System.out.println(k);
}
//listFiles方法
File f2 = new File("D:\\");
File[] s = f2.listFiles();//返回D盘下的所有文件和目录
System.out.println(s.length);
for(File str : s){
System.out.println(str.getPath() + "-->" +str.getName());
}
}
}
import java.io.File;
import java.io.IOException;
public class Demo {
public static void main(String[] args) throws IOException {
//将file.txt封装成对象，可以将已有的和未有的文件或文件夹封装成对象
File f = new File("file.txt");
// System.out.println(f.getName());
// System.out.println(f.getPath());//获取相对路径
// System.out.println(f.getAbsolutePath());//获取绝对路径
File f1 = new File("G:\\abc\\a.txt");//在G盘下创建abc文件夹又在abc文件夹次啊创建a.txt文件夹
System.out.println(f1.mkdirs());//创建文件夹
// System.out.println(f1.isDirectory());
System.out.println(f.createNewFile());//创建文件，如果已经存在则不创建
// System.out.println(f.isFile());//判断此文件是否是一个标准文件
// System.out.println(f.delete());//判断此文件是否是一个目录
// System.out.println(f.canExecute());//判断文件是否可执行
// System.out.println(f.exists());//判断文件是否存在
//listRoots方法
File[] files = File.listRoots();//返回系统的所有盘符
for(File k : files){
System.out.println(k);
}
//listFiles方法
File f2 = new File("D:\\");
File[] s = f2.listFiles();//返回D盘下的所有文件和目录
System.out.println(s.length);
for(File str : s){
System.out.println(str.getPath() + "-->" +str.getName());
}
}
}</strong></span>
递归：获取指定目录文件夹或文件，包含子目录中的内容(列出指定目录下的所有文件)
*
* 因目录中还有目录，只要使用同一个列出目录功能的函数完成即可
* 当列出的功能还是目录时，可以再次此奥用本功能。也就是自身调用自身的函数
* 这种表现形式称为递归
<span style="font-size:18px;"><strong>递归练习：将文件夹中的某种类型数据存储到另一个文件中
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
public class Demo {
public static void main(String[] args) throws IOException {
File f = new File("G:\\shipin");
List<File> al = new ArrayList<File>();//建立集合
show(f,al);//调用方法
BufferedWriter bufw = new BufferedWriter(new FileWriter("G:\\ab.txt"));//设置存储位置
for(File k : al){
String path = k.getAbsolutePath();
bufw.write(path);//将过滤的文件写入指定的文件中
bufw.newLine();//换行
bufw.flush();//刷新
}
bufw.close();
}
public static void show(File dir,List<File> list){
File[] files = dir.listFiles();//获取目录下的所有文件
for(File file : files){
if(file.isDirectory()){//判断是否是文件夹
show(file,list);//再次调用自身方法
}else{
if(file.getName().endsWith(".flv")){//过滤文件
list.add(file);
}
}
}
}
}</strong></span>
------------------------------------------------------------------------------------
Properties是HashTable的子类，具有Map集合的特点，并且里面存储的键值对都是字符串
* 是集合中和IO技术相结合的集合容器；
* 该对象的特点：可以用键值对形式的配置文件
Properties练习1：
<span style="font-size:18px;"><strong>import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;
/*
* 如何将流中的数据存储到集合中：
* 1、用一个流和文件关联a.txt
* 2、读取一行数据，将该行数据用=号进行分割
* 3、等号左边为键，右边为为值，存入到Properties中即可
*/
public class Demo {
public static void main(String[] args) throws IOException {
//转化流
BufferedReader bufw = new BufferedReader(new FileReader("a.txt"));
String line = null;
Properties prop = new Properties();//新建集合
while((line = bufw.readLine()) != null){
String[] arr = line.split("=");//以=号分割
prop.setProperty(arr[0],arr[1]);//将数据添加到集合中
// System.out.println(arr[0] + "--" + arr[1]);
}
bufw.close();//关闭流
System.out.println(prop);
Set<String> name = prop.stringPropertyNames();//将姓名存取到集合
for(String k : name){//获取所有的姓名
System.out.println(k + ":" + prop.getProperty(k));
}
}
}
Properties：练习2
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;
/*
* 用于记录应用程序运行的次数，如果使用 次数已到，那么给出注册提示
*
* 程序结束时，该技术器的值也存在；
* 下次程序启动时，会先加载计数器的值并加1后重新存储起来
* 所以要建立一个配置文件，用于记录该文件的使用次数
*
* 该配置文件使用键值对形式，便于阅读，并操作数据
* 数据时以文件形式存储，使用IO技术
* 那么map +ＩＯ ＝ properties
* 配置文件可以实现应用程序的数据共享
*/
public class Demo {
public static void main(String[] args) throws IOException {
Properties prop = new Properties();
File file = new File("coun.ini");
if(!file.exists()){
file.createNewFile();
}
FileInputStream fis = new FileInputStream(file);
prop.load(fis);
int count = 0;
String value = prop.getProperty("time");
if(value != null){
count = Integer.parseInt(value);
if(count >= 5){
System.out.println("次数已到，请充值");
return;
}
}
count++;
prop.setProperty("time", count+"");
FileOutputStream fos = new FileOutputStream(file);
prop.store(fos, "");
fos.close();
fis.close();
}
}</strong></span>--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
和并流：将几个流放入一个文件中；
<span style="font-size:18px;"><strong>举例：
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;
import javax.sound.midi.Sequence;
public class Demo {
public static void main(String[] args) throws IOException {
Vector<FileInputStream> v = new Vector<FileInputStream>();
v.add(new FileInputStream("G:\\a.txt"));
v.add(new FileInputStream("G:\\b.txt"));
v.add(new FileInputStream("G:\\c.txt"));
Enumeration<FileInputStream> en = v.elements();
SequenceInputStream sis = new SequenceInputStream(en);
FileOutputStream fos = new FileOutputStream("G:\\d.txt");
byte[] buf = new byte[1024];
int len = 0;
while((len = sis.read(buf)) != -1){
fos.write(buf,0,len);
}
fos.close();
sis.close();
}
}</strong></span>
合并流：将几个流放入一个文件中；
<span style="font-size:18px;"><strong>举例：
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;
import javax.sound.midi.Sequence;
public class Demo {
public static void main(String[] args) throws IOException {
Vector<FileInputStream> v = new Vector<FileInputStream>();
v.add(new FileInputStream("G:\\a.txt"));
v.add(new FileInputStream("G:\\b.txt"));
v.add(new FileInputStream("G:\\c.txt"));
Enumeration<FileInputStream> en = v.elements();
SequenceInputStream sis = new SequenceInputStream(en);
FileOutputStream fos = new FileOutputStream("G:\\d.txt");
byte[] buf = new byte[1024];
int len = 0;
while((len = sis.read(buf)) != -1){
fos.write(buf,0,len);
}
fos.close();
sis.close();
}
}</strong></span>---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
对象的序列化：
将内存的对象存储到硬盘上 (对象的持久化存储)
* ObjectInputStream 和 ObjectOutputStream是成对出现的
* oos写入文件的数据只有ois能读出来;a
代码举例：
<span style="font-size:18px;"><strong>public class Person implements Serializable{//实现序列化接口
private String name;
private int age;//被tranaient修饰的变量不能被序列化
static String country = "cn";//静态变量不能被序列化
public Person(String name, int age){
this.name = name;
this.age = age;
}
public String toString(){
return name + "::" + age;
}
}
public class Demo {
public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
writeObj();
readObj();
}
public static void readObj() throws FileNotFoundException, IOException, ClassNotFoundException{
//读取指定文件夹的数据
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("G:\\oos.txt"));
Person p = (Person)ois.readObject();
System.out.println(p);
ois.close();
}
public static void writeObj() throws FileNotFoundException, IOException{
//将数据存储到指定文件中
ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream("G:\\oos.txt"));
//写入对象
oos.writeObject(new Person("Lili",20));
oos.close();
}
}</strong></span>
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
<span style="font-size:18px;"><strong>字符流的编码举例：
import java.io.BufferedOutputStream;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
public class Demo {
public static void main(String[] args) throws IOException {
//调用方法
writeShow();
readShow();
}
public static void readShow() throws IOException{
//以指定的编码格式读取指定文件里的数据
InputStreamReader isr = new InputStreamReader(new FileInputStream("G:\\utf.txt"),"GBK");
char[] buf = new char[1024];
int len = 0;
while((len = isr.read(buf)) != -1){
String str = new String(buf,0,len);
System.out.println(str);
}
isr.close();
}
public static void writeShow() throws IOException{
//以指定的编码格式将数据写入指定的文件
OutputStreamWriter osr = new OutputStreamWriter(new FileOutputStream("G:\\utf.txt"),"utf-8");
osr.write("你好，欢迎光临");//写入数据
osr.close();
}
}
------------------------------------------------------------------------------
字节编码：
编码：字符串变成字节数组；
解码：字节数组变成字符串
* String-->byte[]; str.getBytes(charsetName);
*
* byte[]-->String; new String(byte[],charsetName);
练习代码：
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Array;
import java.util.Arrays;
public class Demo {
public static void main(String[] args) throws UnsupportedEncodingException {
//编码和解码同一种格式
String s = "欢迎光临";
byte[] b = s.getBytes("gbk");//编码
String s1 = new String(b,"gbk");//解码
System.out.println(s1);
String str = "你好";
byte[] by = str.getBytes("utf-8");//utf-8编码
String st = new String(by,"ISO8859-1");//解用ISO8859-1解码，出现乱码
byte[] by1 = st.getBytes("ISO8859-1");//继续用ISO8859-1编码
String str1 = new String(by1,"utf-8");//再用utf-8解码
System.out.println(str1);
}
}</strong></span>---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
IO流的综合练习：
* 有个五个学生，每个学生有三门成绩；
* 从键盘输入以上数据(包括姓名和三门成绩)
* 输入的格式：如 ：zhangsan，30,40,60计算出总成绩
* 并把学生的信息和计算出的分数按高低顺序存放在磁盘文件中"stud.txt"中
*
* 思考：
* 1、通过键盘录入一行数据，将该行中的信息取出并封装成对象
* 学生很多。需用存储，用到集合，欧诺更是对学生进行排序
* 3、将集合的信息写入到一个文件
代码如下：
<span style="font-size:18px;"><strong>public class Student implements Comparable<Student>{
private String name;
private int cn,ma,en;
private int sum;
public Student() {}
public Student(String name, int cn, int ma, int en) {
super();
this.name = name;
this.cn = cn;
this.ma = ma;
this.en = en;
sum = en+ma+cn;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getCn() {
return cn;
}
public void setCn(int cn) {
this.cn = cn;
}
public int getMa() {
return ma;
}
public void setMa(int ma) {
this.ma = ma;
}
public int getEn() {
return en;
}
public void setEn(int en) {
this.en = en;
}
public int getSum() {
return sum;
}
public void setSum(int sum) {
this.sum = sum;
}
public String toString() {
return "Student [cn=" + cn + ", en=" + en + ", ma=" + ma + ", name="
+ name + ", sum=" + sum + "]";
}
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + cn;
result = prime * result + en;
result = prime * result + ma;
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + sum;
return result;
}
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (cn != other.cn)
return false;
if (en != other.en)
return false;
if (ma != other.ma)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if (sum != other.sum)
return false;
return true;
}
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;
}
}
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;
public class StudentTools {
public static Set<Student> getStudent() throws IOException{
getStudent(null);//没有比较器的方法
return null;
}
public static Set<Student> getStudent(Comparator<Student> cmp) throws IOException{
BufferedReader bufr = new BufferedReader(
new InputStreamReader(System.in));
String line = null;
Set<Student> stus = null;
if(cmp == null){//判断是否调用有比较器的方法
stus = new TreeSet<Student>();
}else{
stus = new TreeSet<Student>(cmp);
}
while((line = bufr.readLine()) != null){
if("over".equals(line)){//设置结束命令
break;
}
String[] info = line.split(",");//以,为分隔符，切割
Student stu = new Student(info[0],Integer.parseInt(info[1]),
Integer.parseInt(info[2]),
Integer.parseInt(info[3]));
stus.add(stu);//将键盘输入的数据添加到集合
}
bufr.close();
return stus;
}
public static void writeFile(Set<Student> stus) throws IOException{
BufferedWriter bufw = new BufferedWriter(new FileWriter("G:\\stuinfo.txt"));
for(Student k : stus){//遍历结合取出所有的数据
bufw.write(k.getName()+'\t');//将姓名写入文件
bufw.write(k.getSum()+"");//加""目的变成字符串的形式
bufw.newLine();//换行
bufw.flush();//刷新
System.out.println(k.toString()+"-->"+k.getSum());
}
bufw.close();
}
}
import java.io.IOException;
import java.util.Collections;
import java.util.Comparator;
import java.util.Set;
public class Demo {
public static void main(String[] args) throws IOException {
//设置比较器的强转方法
Comparator<Student> cmp = Collections.reverseOrder();
//调用将输入的数据放入集合的方法
Set<Student> stu = StudentTools.getStudent(cmp);
//将集合的数据写入指定文件
StudentTools.writeFile(stu);
}
}</strong></span>
5897
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
