黑马程序员———IO2

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

File

File类：用来将文件或者文件夹封装成对象

方便对文件与文件夹的属性信息进行操作

File对象可以作为参数传递给流的构造函数

File的构造函数：

File（File parent，String child）根据抽象路径名和child路径名字符串创建一个新File实例。

File（String pathname）通过给定路径名字符串转为抽象路径名来创建一个新的File实例

File（String parent，String child）根据parent路径名字符串和child路径名字符串创建一个新File实例。

 

import java.io.*;public class FileDemo {public static void main(String[] args) {//通过给定路径名字符串转为抽象路径名来创建一个新的File实例File fa = new File("a.txt");File fb = new File("d:\\a.txt");File fc = new File("d:\\ab");//根据parent路径名字符串和child路径名字符串创建一个新File实例。File fd = new File("d:\\ab","a.txt");//根据抽象路径名和child路径名字符串创建一个新File实例。File fe = new File(fc,"a.txt");}}

File中常用方法：

1,创建

boolean createNewFile() 当且仅当不存在具有此抽象路径名指定名称的文件时，不可分割地创建一个新的文件

boolean mkdir() 创建此抽象路径名指定的目录

boolean mkdirs() 创建此抽象路径名指定的目录，包括所有必需但不存在的父目录

2，删除

boolean delete() 删除此抽象路径名表示的文件或目录

boolean deleteOnExit() 在虚拟机终止时，请求删除此抽象路径名表示的文件或目录

3，判断

boolean exists() 测试此抽象路径名表示的文件或目录是否存在

boolean isAbsolute() 测试此抽象路径名是否为绝对路径名

boolean isDirectory() 测试此抽象路径名表示的文件是否是一个目录

boolean isFile() 测试此抽象路径名表示的文件是否是一个标准文件

boolean isHidden() 测试此抽象路径名指定的文件是否是一个隐藏文件

4，获取信息

File getAbsoluteFile() 返回此抽象路径名的绝对路径名形式

String getAbsolutePath() 返回此抽象路径名的绝对路径名字符串

String getName() 返回此抽象路径名表示的文件或目录的名称

String getParent() 返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定的父路径，则返回null

File  getParentFile()  返回此抽象路径名父目录的抽象路径名；如果此路径名没有指定父目录，则返回null。

String getPath() 将此抽象路径名转化为一个路径名字符串

5，列出文件以及文件的过滤

String[] list()返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。

String[] list(FilenameFilter filter)   返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。

File[] listFiles()  返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。

File[] listFiles(FileFilter filter)  返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。

FIle[] listFiles(FilenameFilter filter) 返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。

static File[] listRoots() 列出可用的文件系统跟

boolean renameTo(File dest) 重命名此抽象路径名表示的文件 相当于剪切

小练习：

<span style="font-size:18px;">import java.io.*;public class FileListDemo {public static void main(String[] args) {//创建文件File fa = new File("d:\\ab");//获取指定目录下的所有文件或目录名String[] names = fa.list();for(String name: names){System.out.println(name);}//列出所有可用的文件系统跟File[] files = File.listRoots();for(File file: files){System.out.println(file);}}}</span>

文件名过滤小练习：

<span style="font-size:18px;">//过滤出指定目录下所有的txt文件import java.io.*;public class FileListDemo2 {public static void main(String[] args) {File file = new File("d:\\ab");list_3(file);}//第一种方式public static void list_1(File file){String[] names = file.list(new FilenameFilter(){//传入FilenameFilter匿名内部类作为参数            //覆盖抽象方法@Overridepublic boolean accept(File arg0, String arg1) {// TODO Auto-generated method stubreturn arg1.endsWith(".txt");//判读文件是否一.txt结尾}});//用高级for迭代输出for(String name: names){System.out.println(name);}}//第二种方式public static void list_2(File file){File[] files = file.listFiles(new FileFilter(){//传入FileFilter类型匿名内部类            //覆盖抽象方法@Overridepublic boolean accept(File arg0) {// TODO Auto-generated method stubreturn arg0.getName().endsWith(".txt");//判读文件是否一.txt结尾}});//高级for 迭代输出for(File fi : files){System.out.println(fi);}}//第三种方式public static void list_3(File file){File[] files = file.listFiles(new FilenameFilter(){//传入FilenameFilter类型匿名内部类            //覆盖抽象方法@Overridepublic boolean accept(File arg0, String arg1) {// TODO Auto-generated method stubreturn arg1.endsWith(".txt");//判读文件是否一.txt结尾}});//用高级for 迭代输出for(File fi : files){System.out.println(fi);}}}</span>

递归

当函数内每一次循环还可以调用本功能来实现，也就是函数自身调用自身。这种表现形式，或者编程手法，称为递

归。

练习一：列出指定目录下文件或文件夹，包含子目录中的内容，有层次的输出

<span style="font-size:18px;">import java.io.*;public class ShowDirDemo {public static void main(String[] args)throws IOException {//给定文件目录File Dir = new File("d:\\ab");//有层次地输出目录中所有内容showDir(Dir,0);}public static void showDir(File Dir,int level)throws IOException{//获取本目录下的所有文件盒目录File[] files = Dir.listFiles();//有层次地输出System.out.println(getLevel(level)+Dir.getName());//层次加一level++;for(int i = 0; i < files.length; i++){//如果还是目录 继续递归if(files[i].isDirectory()){showDir(files[i],level);}else if(files[i].isFile()){//不是目录按照相应层次输出文件名System.out.println(getLevel(level)+files[i]);}}}//带层次的列表public static String getLevel(int level){StringBuilder sb = new StringBuilder();for(int i=0; i< level; i++){sb.append("|  ");}return sb.toString();}}</span>

练习二，删除一个带内容的目录

<span style="font-size:18px;">import java.io.*;public class DeleteDirDemo {public static void main(String[] args) {//给定目录File Dir = new File("d:\\ab");//删除给定目录文件夹内所有的内容deleteDir(Dir);}public static void deleteDir(File Dir){//得到给定目录文件内内所有的文件或文件夹File[] files = Dir.listFiles();for(File file: files){//如果是非隐藏文件夹 继续迭代if(!file.isHidden()&&file.isDirectory()){deleteDir(file);}else if(file.isFile()){//如果是文件就删除System.out.println(file.getAbsolutePath()+"删除"+file.delete());}}//当文件夹内的文件都删除完毕就删除此文件夹System.out.println(Dir.getAbsolutePath()+"删除"+Dir.delete());}}</span>

练习三：将一个指定目录下的Java文件的绝对路径，存储到一个文本文件中，建议一个Java文件的列表文件

<span style="font-size:18px;">import java.util.*;import java.io.*;public class JavaFileList {public static void main(String[] args) throws IOException{File Dir = new File("d:\\javasl");List<File> list = new ArrayList<File>();fileToList(Dir,list);File file = new File("d:\\javaList.txt");writeToFile(file,list);}    //将目录下的java文件写入到指定的list集合中public static void fileToList(File Dir,List<File> list ){//得到指定目录下所有的文件或文件夹File[] files = Dir.listFiles();for(File file : files){//如果是文件夹继续递归if(file.isDirectory()){fileToList(file,list);}else if( file.isFile()){//如果是java文件就加入到list集合中if(file.getName().endsWith(".java"))list.add(file);}}}//将list 写入到指定文件中public static void writeToFile(File file , List<File> list)throws IOException{//带缓冲的写入流BufferedWriter bw = new BufferedWriter(new FileWriter(file));//写入for(File fi : list){bw.write(fi.getAbsolutePath());bw.newLine();bw.flush();}//关闭流bw.close();}}</span>

复制多级文件夹

<span style="font-size:18px;">import java.io.*;public class CopyFile {public static void main(String[] args) throws IOException {File sfile = new File("d:\\ab");File tfile = new File("e:\\a");copyDir(sfile,tfile);}//复制文件夹public static void copyDir(File sdir , File tdir){//得到要复制的根目录String name = sdir.getName();//把根目录放到目的目录中File Tdir = new File(tdir+File.separator+name);//如果目的目录不存在，则创建if(!Tdir.exists())Tdir.mkdirs();//得到源目录中所有的文件或文件夹File[] files = sdir.listFiles();for(File file : files){//如果是文件夹 递归if(file.isDirectory()){copyDir(file,Tdir);//如果是文件拷贝}else if(file.isFile()){File copyFile = new File(Tdir+File.separator+file.getName());copyFile(file,copyFile);}}}    //复制文件public static void copyFile(File source, File target) {        BufferedInputStream bis = null;BufferedOutputStream bos = null;try {//输入缓冲流bis = new BufferedInputStream(new FileInputStream(source));//输出缓冲流bos = new BufferedOutputStream(new FileOutputStream(target));byte[] buf = new byte[1024];int len = 0;//读写while ((len = bis.read(buf)) != -1) {bos.write(buf, 0, len);}} catch (IOException e) {throw new RuntimeException("文件复制出错");//关闭流} finally {try {if (!(bis == null))bis.close();} catch (IOException e) {throw new RuntimeException("流关闭出错");}try {if (!(bos == null))bos.close();} catch (IOException e) {throw new RuntimeException("流关闭出错");}}}}</span>

Properties是hashtable的子类，也就是说它具备Map集合的特点。而且它里面存储的键值对都是字符串，是集合中和IO

相结合的集合容器。

该对象的特点：可以用于键值对形式的配置文件。那么在加载数据时，需要数据有固定的格式：键=值

方法：

String getProperty(String key) 用指定的键在此属性列表中搜索属性。

void list(PrintStream out)  将属性列表输出到指定的输出流。

void load(InputStream inStream) 从输入流中读取属性列表（键和元素对）。

void store 将此 Properties 表中的属性列表（键和元素对）写入输出流。

Set<String> stringPropertyNames() 返回此属性列表中的键集，其中该键及其对应值是字符串，如果在主属性列表中

未找到同名的键，则还包括默认属性列表中不同的键。

练习一，设置和获取元素：

<span style="font-size:18px;">import java.util.Properties;import java.util.*;public class PeopertiesDemo {public static void main(String[] args) {Properties pro = new Properties();    //设置元素pro.setProperty("lisi", "23");pro.setProperty("wangwu", "32");//获取元素 通过键值获取pro.getProperty("lisi");//通过stringPropertyNames()方法迭代获取Set<String> names = pro.stringPropertyNames();        for(String name : names){        System.out.println(name+"="+pro.getProperty(name));        }}}</span>

Properties的load()和store()方法

<span style="font-size:18px;">import java.util.*;import java.io.*;public class PeopertiesDemo {public static void main(String[] args) throws IOException {ls();}//Properties load方法的实现原理public static void load()throws IOException{//带缓冲的读取流BufferedReader br = new BufferedReader(new FileReader("d:\\j.txt"));Properties pro = new Properties();String line = null;while((line = br.readLine()) != null){//将读到的一行数据用等号分割String[] arrs = line.split("=");//将分割后的数据以键和值存到Properties中pro.setProperty(arrs[0], arrs[1]);}System.out.println(pro);}public static void ls()throws IOException{FileInputStream fis = new FileInputStream("d:\\j.txt");Properties pro = new Properties();//从流中加载属性列表pro.load(fis);pro.setProperty("lisi", "34");FileOutputStream fos = new FileOutputStream("d:\\j.txt");//将此 Properties 表中的属性列表（键和元素对）写入输出流。pro.store(fos, "haha");//关闭流fis.close();fos.close();System.out.println(pro);}}</span>

练习：用于记录程序运行的次数，如果使用次数已到，那么给出注册提示。

<span style="font-size:18px;">import java.io.*;import java.util.*;public class CountDemo {public static void main(String[] args) throws IOException {//创建Properties集合对象Properties pro = new Properties();//将文件进行封装File file = new File("d:\\pro.ini");//判断文件是否存在，如果不存在，则创建if(!file.exists())file.createNewFile();//将文件与读取流进行关联FileInputStream fis = new FileInputStream(file);//加载流中的数据到Properties集合中pro.load(fis);//定义计数器int count = 0;//获取程序运行的次数String value = pro.getProperty("time");//如果获取的值不等于null  将它的值转化为int型赋值给countif(value != null)count = Integer.parseInt(value);if(count >= 5){System.out.println("次数已到！");return;}count++;//程序每启动一次 计数器加一//将程序运行的次数以键time值count的形式存入集合pro.setProperty("time", count+"");//输出流FileOutputStream fos = new FileOutputStream(file);//将集合中的数据存入硬盘文件中pro.store(fos, "");fis.close();fos.close();}}</span>

打印流

PrintStream和PrintWriter 提供了打印方法，可以将各种数据类型的数据都原样打印

PrintStream 构造函数

1，file对象 File

2，字符串 String

3，字节输出流 OutputStream

PrintWriter构造函数

1，file对象 File

2，字符串路径，String

3，字节输出流 OutputStream

4，字符输出流 Writer

当打印流的构造函数中接受的是流对象，可以指定是否自动刷新

练习代码：

import java.io.*;public class PrintDemo {public static void main(String[] args) throws IOException {//带缓冲的读取流  源为键盘BufferedReader br = new BufferedReader(new InputStreamReader(System.in));//PrintWriter 带自动刷新PrintWriter pw = new PrintWriter(new FileWriter("d:\\b.txt"),true);String line = null;while((line = br.readLine()) != null){if("over".equals(line))break;//自动换行加自动刷新pw.println(line);}br.close();pw.close();}}

SequenceInputStream 表示其他输入流的逻辑串联。它从输入流的有序集合开始，并从第一个输入流开始读取，直到

到达文件末尾，接着从第二个输入流读取，以此类推，直到到达包含的最后一个文件末尾为止。

文件分割和合并练习：

<span style="font-size:18px;">import java.io.*;import java.util.*;public class SequenceInputStreamDemo {public static void main(String[] args)throws IOException {splitFile();add();}//文件的合并public static void add()throws IOException{//新建泛型为FileInputStream的ArrayList集合ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();al.add(new FileInputStream("d:\\1.part"));al.add(new FileInputStream("d:\\2.part"));al.add(new FileInputStream("d:\\3.part"));al.add(new FileInputStream("d:\\4.part"));final Iterator<FileInputStream> it = al.iterator();//创建Enumeration匿名内部类对象Enumeration en = new Enumeration(){@Overridepublic boolean hasMoreElements() {// TODO Auto-generated method stubreturn it.hasNext();}@Overridepublic Object nextElement() {// TODO Auto-generated method stubreturn it.next();}};//合并流SequenceInputStream sis = new SequenceInputStream(en);FileOutputStream fos = new FileOutputStream("d:\\2.mp3");byte[] buf = new byte[1024];int len = 0;//合并写入while((len = sis.read(buf)) != -1){fos.write(buf, 0, len);}//关闭流sis.close();fos.close();}    //文件的分割public static void splitFile() throws IOException {//字节读取流FileInputStream fis = new FileInputStream("d:\\1.mp3");int count = 1;//1MB的缓冲byte[] buf = new byte[1024*1024];int len = 0;//读写while ((len = fis.read(buf)) != -1) {//每读写完1MB就创建新的输出流FileOutputStream fos = new FileOutputStream("d:\\"+(count++)+".part");fos.write(buf, 0, len);fos.close();}//关闭流fis.close();}}</span>

 

管道流：PipedInputStream 和PipedOutputStream 输入输出可以直接进行连接，通过结合多线程使用

构造函数：PipedInputStream(PipedOutputStream src) 创建PipedInputStream，使其连接到管道输出流src。

PipedInputStream()创建尚未连接的PipedInputStream

PipedOutputStream() 创建尚未连接到管道输入流的管道输出流

PipedInputStream(PipedInputStream snk) 创建连接到指定管道输入流的管道输出流

连接方法：

void connect(PipedInputStream snk) 将此管道输出流连接到接受者

import java.io.*;public class PipedDemo {public static void main(String[] args) throws IOException {//创建管道流对象 并相关联PipedOutputStream out = new PipedOutputStream();PipedInputStream in = new PipedInputStream();in.connect(out);//开启线程new Thread(new Write(out)).start();new Thread(new Read(in)).start();}}//读取class Read implements Runnable{private PipedInputStream in;//构造函数中传入一个读取管道流Read(PipedInputStream in){this.in = in;}   //覆盖run方法@Overridepublic void run() {try{byte[] buf = new byte[1024];int len = 0;while((len = in.read(buf)) != -1){//将读到的数据封装成字符串String str = new String(buf,0,len);//将封装好的字符串打印到控制台System.out.println(str);}}catch(IOException e){throw new RuntimeException("管道流读取失败！");}finally{try{if(in != null)in.close();}catch(IOException e){throw new RuntimeException("流关闭失败！");}}}}//写入class Write implements Runnable{private PipedOutputStream out;//构造函数中传入一个写入管道流Write(PipedOutputStream out){this.out = out;}    //覆盖run方法@Overridepublic void run() {try{//管道流 写数据out.write("guan dao liu laile ".getBytes());}catch(IOException e){throw new RuntimeException("管道流写入失败！");}finally{try {if(out != null)   out.close();} catch (IOException e) {throw new RuntimeException("流关闭失败！");}}}}

 

用于操作基本数据类型的流对象： DataInputStream 和DataOutputStream

可以对基本数据类型直接读写

void writeUTF(String str)  以与机器无关方式使用 UTF-8 修改版编码将一个字符串写入基础输出流。

小练习：

import java.io.*;public class DataDemo {public static void main(String[] args)throws IOException {//write();//read();writeUTF();readUTF();}//读方法public static void read()throws IOException{//读取流DataInputStream dis = new DataInputStream(new FileInputStream("d:\\data.txt"));//读一个intint num1 = dis.readInt();//读一个doubledouble num2 = dis.readDouble();//读一个booleanboolean b = dis.readBoolean();System.out.println("num1="+num1+" num2="+num2+b);}//写方法public static void write()throws IOException{//写入流DataOutputStream dos = new DataOutputStream(new FileOutputStream("d:\\data.txt"));//写一个intdos.writeInt(34);//写一个doubledos.writeDouble(23.34);//写一个booleandos.writeBoolean(true);dos.close();}//readUTF读public static void readUTF()throws IOException{DataInputStream dis = new DataInputStream(new FileInputStream("d:\\data.txt"));String str =dis.readUTF();System.out.println(str);}//readUTF写public static void writeUTF()throws IOException{DataOutputStream dos = new DataOutputStream(new FileOutputStream("d:\\data.txt"));    dos.writeUTF("你好");dos.close();}}

 

编码表

计算机只能识别二进制数据，早期由来是电信号。

为了方便应用计算机，让它可以识别各个国家的文字，就将各个国家的文字用数字来表示，并一一对应，形成一张表，这就是编码表。

常用编码表：

ASCII： 美国标准信息交换码。用一个字节的7位可以表示。

ISO8859-1： 拉丁码表，欧洲码表，用一个字节的8位表示。

GB2312： 中国的中文编码表。

GBK： 中国的中文编码表升级，融合了更多的中文文字符号。

Unicode： 国际标准码，融合了多种文字。所有文字都用两个字节来表示，Java语言中的就是Unicode码表。

UTF-8： 最多用三个字节来表示一个字符。

练习：转换流编码练习

package Test;import java.io.*;public class CharsetDemo {public static void main(String[] args)throws IOException {write();read();}//分别以UTF-8和GBK编码public static void write()throws IOException{//GBK编码OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("d:\\gbk.txt"),"GBK");osw.write("你好");osw.close();//UTF-8编码OutputStreamWriter osw1 = new OutputStreamWriter(new FileOutputStream("d:\\utf.txt"),"UTF-8");osw1.write("你好");osw1.close();}public static void read()throws IOException{//GBK解码UTF-8InputStreamReader isr = new InputStreamReader(new FileInputStream("d:\\utf.txt"),"GBK");char[] buf = new char[10];int len = 0;len = isr.read(buf);String str = new String(buf,0,len);System.out.println(str);//UTF—8解码GBkInputStreamReader isr1 = new InputStreamReader(new FileInputStream("d:\\gbk.txt"),"UTF-8");char[] buf1 = new char[10];int len1 = 0;len1 = isr1.read(buf1);String str1 = new String(buf1,0,len);System.out.println(str1);}}

编码：字符串变成字节数组。

解码： 字节数组变成字符串。

String--->byte[]; str.getBytes(charsetName)

byte[]--->String: new String(byte[],charsetName)

GBK 编码 用ISO8859-1解码错误 可以通过再次使用ISO8859-1编码得到原来的GBK编码数据，然后再通过GBK正确

解码得到相应的数据

GBK编码 用UTF-8 解码错误 再次通过UTF-8 解码 已经不能得到正确的编码数据

小练习：

package Test;import java.util.Arrays;public class CharsetDemo2 {public static void main(String[] args)throws Exception {test_2();}//GBK编码 ISO8859-1 解码解错 可以把数据再编回来public static void test_1()throws Exception{String str = "你好";//用GBK编码byte[] buf = str.getBytes("GBK");System.out.println(Arrays.toString(buf));//用ISO8859-1解码解错str = new String(buf,"ISO8859-1");System.out.println(str);//再用ISO8859-1编码编回来buf = str.getBytes("ISO8859-1");System.out.println(Arrays.toString(buf));//再用GBK解码 str = new String(buf,"GBK");System.out.println(str);}//如果GBK编码UTF-8解码错误 再编就编不回原来了数据了public static void test_2()throws Exception{String str = "你好";//用GBK编码byte[] buf = str.getBytes("GBK");System.out.println(Arrays.toString(buf));//用UTF-8解码str = new String(buf,"UTF-8");System.out.println(str);//再用UTF-8编码  这时数据已经改变 buf = str.getBytes("UTF-8");System.out.println(Arrays.toString(buf));}}

练习：有五个学生，每个学生有3门课的成绩，从键盘上输入以上数据（包括姓名，三门课成绩），并把学生的信息

和计算出的总分数按高低顺序存放在磁盘文件中。

/* * 1,描述学生对象 * 2，定义一个可操作学生对象的工具类 * 思路： * 1通过键盘获取一行数据，并将改行数据封装成学生对象 * 2，将学生对象存入TreeSet集合中 * 3，将集合中的数据写入到文件中，*/package Test;import java.io.*;import java.util.*;public class StudentInfoDemo {public static void main(String[] args) {//比较器Comparator<Student> cmp = Collections.reverseOrder();    //测试Set<Student> set = StudentInfoTools.getStudents(cmp);StudentInfoTools.write2File(set);}}class StudentInfoTools{//按默认排序加入到set集合中public static Set<Student> getStudents(){return getStudents(null);}//将键盘输入的数据封装为Student对象添加到set集合中public static Set<Student> getStudents(Comparator<Student> cmp){BufferedReader br = null;Set<Student> set = null;try{//读取键盘br = new BufferedReader(new InputStreamReader(System.in));//创建set集合if(cmp == null)set = new TreeSet<Student>();elseset = new TreeSet<Student>(cmp);String line = null;while((line = br.readLine()) != null){if("over".equals(line))break;//将读到的一行数据切割为字符串数组String[] Infos =line.split(",");//将字符串数组封装为Student对象Student stu = new Student(Infos[0],Integer.parseInt(Infos[1]),Integer.parseInt(Infos[2]),Integer.parseInt(Infos[3]));//将Student对象添加到set 集合中set.add(stu);}}catch(IOException e){throw new RuntimeException("数据操作失败！");}finally{try{if(br != null)br.close();}catch(IOException e){throw new RuntimeException("流关闭失败！");}}return set;}//将set集合中的数据写入到文件中public static void write2File(Set<Student> set){BufferedWriter  bw  = null;try{bw = new BufferedWriter(new FileWriter("d:\\stuInfo.txt"));for(Student stu : set){bw.write(stu.toString()+"\t");bw.write(stu.getSum()+"");bw.newLine();bw.flush();}}catch(IOException e){}finally{try{if(bw!=null)bw.close();}catch(IOException e){}}}}//Student类class Student implements Comparable<Student>{private String name;private int ma,cn,en,sum;public Student(String name, int ma, int cn, int en) {this.name = name;this.ma = ma;this.cn = cn;this.en = en;this.sum = ma + cn +en;}//重写hashCode方法public int hashCode(){return name.hashCode()+ sum*29;}//重写equals方法public boolean equals(Object obj){if(!(obj instanceof Student))return false;Student st = (Student)obj;return this.name.equals(st.name)&&this.sum == st.sum;}//重写toString方法public String toString(){return "Student["+ma+","+cn+","+en+"]";}    //重写compareTo方法@Overridepublic int compareTo(Student stu) {int num = new Integer(this.sum).compareTo(new Integer(stu.sum));if(num ==0)return this.name.compareTo(stu.name);return num;}//属性sum的get方法public int getSum(){return sum;}}