Java笔记（七）

File类：

 import java.io.File;
 import java.io.IOException;

 public class Demo{
     public static void main(String[] args){
         //将a.txt封装成file对象。可以将已有的和未出现的文件或者文件夹封装成对象
         File f1 = new File("a.txt");

         //左边参数是父目录，右边是文件名
         File f2 = new File("C:", "demo.txt");

         File d = new File("C:\\abc");
         File f3 = new File(d, "c.txt");

         //因为\\是windows下的分割符，而File.separator是可以跨平台的
         ile f4 = new File("C:" + File.separator + "abc" + File.separator + "c.txt");
     }
 }

File类常见方法：

（1）创建：boolean createNewFile(); 在指定位置创建文件，如果该文件已经存在，则不创建，返回false。和输出流不一样，输出流对象一建立，就会创建文件，而且文件已经存在，会覆盖。

　　　　　  boolean mkdir();  创建文件夹。

　　　　　  boolean mkdirs();  创建多级文件夹。

（2）删除：boolean delete();   删除失败返回false。

　　　　　  boolean deleteOnExit();  在程序退出时删除指定文件。

（3）判断：boolean canExecute(); 测试应用程序是否可以执行此抽象路径名表示的文件。

　　　　　  boolean exists(); 文件是否存在。

　　　　　  isFile();

　　　　　  isDirectory();

　　　　     isHidden();

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

　　　　　  在判断文件对象是否是文件或者目录时，必须要先判断该文件对象封装的内容是否存在，通过exists判断。

（4）获取信息：

　　　　　  getName();   getPath();   getParent();   getAbsolutePath();  long lastModified(); 文件最后一次被修改的时间    long length();

输出C盘下所有文件和文件夹的名字：

 import java.io.File;
 import java.io.IOException;

 public class Demo{
     public static void main(String[] args){
         File f = new File("C:\\");
         String[] names = f.list();
         for(String name : names){
             System.out.println(name);
         }
     }
 }

输出G盘中后缀名为.txt的文件名：

 import java.io.File;
 import java.io.FilenameFilter;
 import java.io.IOException;

 public class Demo{
     public static void main(String[] args) throws IOException{
 //        File f = new File("G:\\");
 //        String[] arr = f.list(new FilenameFilter(){
 //            public boolean accept(File dir, String name){
 //                return name.endsWith(".txt");
 //            }
 //        });
 //        for(String name : arr){
 //            System.out.println(name);
 //        }

         File f = new File("G:\\");
         File[] files = f.listFiles(new FilenameFilter() {
             public boolean accept(File f, String name) {
                 return name.endsWith(".txt");
             }
         });
         for(File file : files){
             System.out.println(file.getName());
         }
     }
 }

列出指定目录下文件或文件夹，包含目录中的内容。也就是列出指定目录下所有内容（递归）：

 import java.io.File;
 import java.io.IOException;

 public class Demo{
     public static void main(String[] args){
         File dir = new File("F:\\text");
         showDir(dir);
     }
     public static void showDir(File dir){
         System.out.println(dir);
         File[] files = dir.listFiles();
         for(File f : files){
             if(f.isDirectory()){
                 showDir(f);
             }
             else{
                 System.out.println(f);
             }
         }
     }
 }

加入层次效果：

 import java.io.File;
 import java.io.IOException;

 public class Demo{
     public static void main(String[] args){
         File dir = new File("F:\\text");
         showDir(dir, 0);
     }
     public static String getLevel(int level){
         StringBuilder sb = new StringBuilder();
         for(int i = 0; i < level; i++){
             sb.append("    ");
         }
         return sb.toString();
     }
     public static void showDir(File dir, int level){
         System.out.println(getLevel(level) + dir);
         level++;
         File[] files = dir.listFiles();
         for(File f : files){
             if(f.isDirectory()){
                 showDir(f, level);
             }
             else{
                 System.out.println(getLevel(level) + f);
             }
         }
     }
 }

删除一个带内容的目录。删除原理：在windows中，删除目录从里往外删除。所以就需要递归：

 import java.io.File;

 public class Demo{
     public static void main(String[] args){
         File dir = new File("F:\\testdir");
         removeDir(dir);
     }
     public static void removeDir(File dir){
         File[] files = dir.listFiles();
         for(File file : files){
             if(file.isDirectory()){
                 removeDir(file);
             }
             else{
                 System.out.println(file.toString() + ":-file-" + file.delete());
             }
         }
         System.out.println(dir + "::dir::" + dir.delete());
     }
 }

将一个指定目录下的Java文件的绝对路径，存储到一个文本文件中。建立一个Java列表文件。

 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){
         File dir = new File("C:\\Users\\ZTQ\\Desktop\\JavaText");
         List<File> list = new ArrayList<File>();
         fileToList(dir, list);
         File file = new File(dir, "javalist.txt");
         writeToFile(list, file.toString());
     }
     //目录中的.java文件写入到list中
     public static void fileToList(File dir, List<File> list){
         File[] files = dir.listFiles();
         for(File f : files){
             if(f.isDirectory()){
                 fileToList(f, list);
             }
             else{
                 list.add(f);
             }
         }
     }
     //list写入到文件中
     public static void writeToFile(List<File> list, String path){
         BufferedWriter bufw = null;
         try{
             bufw = new BufferedWriter(new FileWriter(path));
             for(File f : list){
                 String p = f.getAbsolutePath();
                 bufw.write(p);
                 bufw.newLine();
                 bufw.flush();
             }
         }catch(IOException e){
             throw new RuntimeException(e.toString());
         }finally{
             if(bufw != null){
                 try{
                     bufw.close();
                 }catch(IOException e){
                     throw new RuntimeException(e.toString());
                 }
             }
         }
     }
 }

Properties是hashtable的子类。它具备map集合的特点，而且它里面存储的键值对都是字符串。是集合中与IO技术相结合的集合容器。对象特点：可以用于键值对形式的配置文件。

 import java.util.Properties;
 import java.util.Set;

 public class Demo{
     public static void main(String[] args){
         setAndGet();
     }
     public static void setAndGet(){
         Properties prop = new Properties();
         prop.setProperty("zhangsan", "30");
         prop.setProperty("lisi", "40");

         String value = prop.getProperty("lisi");
         System.out.println(value);

         prop.setProperty("lisi", "50");
         Set<String> names = prop.stringPropertyNames();
         for(String s : names){
             System.out.println(s + ":" + prop.getProperty(s));
         }
     }
 }

将info.txt中键值数据存到集合中进行操作：

（1）用一个流和info.txt文件关联

（2）读取一行数据，将该行数据用“=”进行切割

（3）“=”左边作为键，右边作为值，存入到Properties集合中即可。

 import java.io.BufferedReader;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.FileReader;
 import java.io.IOException;
 import java.util.Properties;

 public class Demo{
     public static void main(String[] args)throws IOException{
         method_02();
     }
     public static void method_01() throws IOException{
         BufferedReader bufr = new BufferedReader(new FileReader("F:\\demo.txt"));
         String line = null;
         Properties prop = new Properties();
         while((line = bufr.readLine()) != null){
             String[] arr = line.split("=");
             prop.setProperty(arr[0], arr[1]);
         }
         bufr.close();
         System.out.println(prop);
     }
     public static void method_02()throws IOException{
         FileInputStream fis = new FileInputStream("F:\\demo.txt");
         Properties prop = new Properties();
         //将流中的数据加载进集合
         prop.load(fis);

 //      prop.setProperty("wangwu", "39"); 只能设置内存中的内容，而文件中的内容不改变
         FileOutputStream fos = new FileOutputStream("F:\\demo.txt");
         prop.store(fos, "haha"); //第二个参数为注释信息

         prop.list(System.out);
         fis.close();
         fos.close();
     }

 }

记录应用程序运行次数，如果使用次数已到，给出注册提示：

 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.util.Properties;

 public class Demo{
     public static void main(String[] args)throws IOException{
         Properties prop = new Properties();

         File file = new File("F:\\count.ini");
         if(!file.exists())
             file.createNewFile();

         FileInputStream fis = new FileInputStream(file);

         prop.load(fis);

         int count = 0;
         String value = prop.getProperty("times");

         if(value != null){
             count = Integer.parseInt(value);
             if(count >= 5){
                 System.out.println("使用次数已到，请充值！");
                 return;
             }
         }
         count++;

         prop.setProperty("times", count + "");

         FileOutputStream fos = new FileOutputStream(file);
         prop.store(fos, "");

         fis.close();
         fos.close();
     }
 }

打印流：该流提供了打印方法，可以将各种数据类型的数据都原样打印。

字节打印流 PrintStream：

　　构造函数可以接收的参数类型：

　　（1）file对象。File

　　（2）字符串路径。String

　　（3）字节输出流。OutputStream

字符打印流 PrintWriter：

　　构造函数可以接收的参数类型：

　　（1）file对象。File

　　（2）字符串路径。String

　　（3）字节输出流。OutputStream

　　（4）字符输出流。Writer

 import java.io.BufferedReader;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.PrintWriter;

 public class Demo{
     public static void main(String[] args)throws IOException{
         BufferedReader bufr =
                 new BufferedReader(new InputStreamReader(System.in));
         PrintWriter out = new PrintWriter(new FileWriter("F:\\demo.txt"), true); //第二个参数为true，则println,printf或format方法将刷新输出缓冲区

         String line = null;
         while((line = bufr.readLine()) != null){
             if("over".equals(line)) break;
             out.println(line.toUpperCase());
         }
         out.close();
         bufr.close();
     }
 }

合并流SequenceInputStream：

 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.SequenceInputStream;
 import java.util.Enumeration;
 import java.util.Vector;

 public class Demo{
     public static void main(String[] args)throws IOException{
         Vector<FileInputStream> v = new Vector<FileInputStream>();
         v.add(new FileInputStream("F:\\1.txt"));
         v.add(new FileInputStream("F:\\2.txt"));
         v.add(new FileInputStream("F:\\3.txt"));

         Enumeration<FileInputStream> en = v.elements();
         SequenceInputStream sis = new SequenceInputStream(en);
         FileOutputStream fos = new FileOutputStream("F:\\4.txt");
         byte[] buf = new byte[1024];
         int len = 0;
         while((len = sis.read(buf)) != -1){
             fos.write(buf, 0, len);
         }
         fos.close();
         sis.close();
     }
 }

切割文件：

 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.SequenceInputStream;
 import java.util.ArrayList;
 import java.util.Enumeration;
 import java.util.Iterator;

 public class Demo{
     public static void main(String[] args)throws IOException{
         splitFile();
         merge();
     }
     public static void splitFile() throws IOException{
         FileInputStream fis = new FileInputStream("F:\\pic.jpg");
         FileOutputStream fos = null;

         byte[] buf = new byte[1024];
         int len = 0;
         int count = 1;
         while((len = fis.read(buf)) != -1){
             fos = new FileOutputStream("F:\\" + count++ + ".part");
             fos.write(buf, 0, len);
             fos.close();
         }
         fis.close();
     }
     public static void merge()throws IOException{
         ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
         for(int i = 1; i <= 4; i++){
             al.add(new FileInputStream("F:\\" + i + ".part"));
         }
         final Iterator<FileInputStream> it = al.iterator();
         Enumeration<FileInputStream> en = new Enumeration<FileInputStream>(){
             public boolean hasMoreElements() {
                 return it.hasNext();
             }
             public FileInputStream nextElement() {
                 return it.next();
             }
         };
         SequenceInputStream sis = new SequenceInputStream(en);
         FileOutputStream fos = new FileOutputStream("F:\\merge.jpg");
         int len = 0;
         byte[] buf = new byte[1024];
         while((len = sis.read(buf)) != -1){
             fos.write(buf, 0, len);
         }
         fos.close();
         sis.close();
     }
 }

对象的序列化：

 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;

 public class Demo{
     public static void main(String[] args)throws Exception{
         writeObj();
         readObj();
     }
     public static void readObj()throws Exception{
         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("F:\\obj.txt"));
         Person p = (Person)ois.readObject();
         System.out.println(p);
         ois.close();
     }
     public static void writeObj()throws Exception{
         ObjectOutputStream oos =
                 new ObjectOutputStream(new FileOutputStream("F:\\obj.txt"));
         oos.writeObject(new Person("ztq", 23));
         oos.close();
     }
 }

管道流：

管道输入流应该连接到管道输出流，管道输入流提供要写入管道输出流的所有数据字节。通常，数据由某个线程从PipedInputStream对象读取，并由其他线程将其写入到对应的PipedOutputStream。不建议对这两个对象尝试使用单个线程，因为这样可能死锁线程。

 import java.io.IOException;
 import java.io.PipedInputStream;
 import java.io.PipedOutputStream;

 class Read implements Runnable{
     private PipedInputStream in;
     Read(PipedInputStream in){
         this.in = in;
     }
     public void run(){
         try{
             byte[] buf = new byte[1024];
             int len = in.read(buf);
             String s = new String(buf, 0, len);
             System.out.println(s);
             in.close();
         }catch(IOException e){
             throw new RuntimeException("管道读取流失败！");
         }
     }
 }

 class Write implements Runnable{
     private PipedOutputStream out;
     Write(PipedOutputStream out){
         this.out = out;
     }
     public void run(){
         try{
             out.write("piped!~".getBytes());
             out.close();
         }catch(IOException e){
             throw new RuntimeException("管道输入流失败！");
         }
     }
 }
 public class Demo{
     public static void main(String[] args)throws Exception{
         PipedInputStream in = new PipedInputStream();
         PipedOutputStream out = new PipedOutputStream();
         in.connect(out);
         new Thread(new Read(in)).start();
         new Thread(new Write(out)).start();
     }

 }

RandomAccessFile：

该类不算是IO体系中的子类，直接继承的Object。但它却是IO包中的成员，因为它具备读和写功能，内部封装了一个数组，而且通过指针对数组的元素进行操作，可以通过getFilePointer获取指针位置，同时可以通过seek改变指针的位置。

其实完成读写的原理就是内部封装了字节输入输出流。

通过构造函数可以看出，该类只能操作文件。而且操作文件还有模式mode：如r只读，rw读和写等。如果模式为r，不会创建文件，会读取一个已存在的文件，如果文件不存在，则会出现异常。如果模式为rw，操作的文件不存在，会自动创建，如果存在则不会覆盖。

 import java.io.IOException;
 import java.io.RandomAccessFile;

 public class Demo{
     public static void main(String[] args)throws Exception{
         writeFile_2();
         readFile();
     }
     public static void readFile() throws IOException{
         RandomAccessFile raf = new RandomAccessFile("F:\\ran.txt", "r");

         //调整对象中的指针
         raf.seek(8);

         //跳过指定的字节数，只能往后跳
         //raf.skipBytes(8);

         byte[] buf = new byte[4];
         raf.read(buf);
         String name = new String(buf);
         int age = raf.readInt();
         System.out.println("name = " + name);
         System.out.println("age = " + age);
         raf.close();
     }
     public static void writeFile() throws IOException{
         RandomAccessFile raf = new RandomAccessFile("F:\\ran.txt", "rw");
         raf.write("李四".getBytes());
         raf.writeInt(97);
         raf.write("王五".getBytes());
         raf.writeInt(99);
         raf.close();
     }
     public static void writeFile_2() throws IOException{
         RandomAccessFile raf = new RandomAccessFile("F:\\ran.txt", "rw");
         raf.seek(8 * 1);
         raf.write("哈哈".getBytes());
         raf.close();
     }
 }

DataStream：

可以用于操作基本数据类型的流对象。

 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;

 public class Demo{
     public static void main(String[] args)throws Exception{
         writeData();
         readData();
     }
     public static void writeData() throws IOException{
         DataOutputStream dos = new DataOutputStream(new FileOutputStream("F:\\demo.txt"));
         dos.writeInt(123);
         dos.writeBoolean(true);
         dos.writeDouble(12.34);
         dos.close();
     }
     public static void readData() throws IOException{
         DataInputStream dis = new DataInputStream(new FileInputStream("F:\\demo.txt"));
         int n1 = dis.readInt();
         boolean n2 = dis.readBoolean();
         double n3 = dis.readDouble();
         System.out.println("n1 = " + n1);
         System.out.println("n2 = " + n2);
         System.out.println("n3 = " + n3);
         dis.close();
     }
 }

ByteArrayStream:

用于操作字节数组的流对象。

ByteArrayInputStream：在构造的时候，需要接受数据源，而且数据源是一个字节数组。

ByteArrayOutputStream：在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数组，这就是数据目的地。

因为这两个流对象都操作的数组，并没有使用系统资源，所以不用进行close关闭。

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;

 public class Demo{
     public static void main(String[] args){
         //数据源
         ByteArrayInputStream bis = new ByteArrayInputStream("ABCDEFG".getBytes());

         //数据目的
         ByteArrayOutputStream bos = new ByteArrayOutputStream();

         int by = 0;
         while((by = bis.read()) != -1){
             bos.write(by);
         }

         System.out.println(bos.size());
         System.out.println(bos.toString());
     }

 }

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

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

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

byte[]-->String   new String(byte[]);

有五个学生，每个学生有3门课的成绩，从键盘输入以上数据（包括姓名，三门课成绩），输入的格式，如：zhangsan，30,40,60计算出总成绩，并把学生的信息和计算出的总分数按照高低顺序存放在磁盘文件“stud.txt”中：

 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.Set;
 import java.util.TreeSet;

 class Student implements Comparable<Student>{
     private String name;
     private int c1, c2, c3;
     private int sum;

     public Student(String name, int c1, int c2, int c3){
         this.name = name;
         this.c1 = c1;
         this.c2 = c2;
         this.c3 = c3;
         sum = c1 + c2 + c3;
     }

     public String getName(){
         return name;
     }

     public int getSum(){
         return sum;
     }

     public int hashCode(){
         return name.hashCode() + sum * 78;
     }

     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;
     }

     public String toString(){
         return "Student[ " + name + ", " + c1 + ", " + c2 + ", " + c3 + " ]";
     }
 }

 class StudentInfoTool{
     //使用默认比较器的方法
     public static Set<Student> getStudents() throws IOException{
         return getStudents(null);
     }
     //使用传入的比较器的方法
     public static Set<Student> getStudents(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[] arr = line.split(",");
             Student stu = new Student(arr[0], Integer.parseInt(arr[1]),
                     Integer.parseInt(arr[2]),
                     Integer.parseInt(arr[3]));
             stus.add(stu);
         }
         bufr.close();
         return stus;
     }
     public static void write2File(Set<Student> stus) throws IOException{
         BufferedWriter bufw = new BufferedWriter(new FileWriter("F:\\students.txt"));
         for(Student stu : stus){
             bufw.write(stu.toString());
             bufw.write(" " + stu.getSum());
             bufw.newLine();
             bufw.flush();
         }
         bufw.close();
     }
 }
 public class Demo{
     public static void main(String[] args) throws IOException{
         Comparator<Student> cmp = Collections.reverseOrder();
         Set<Student> stus = StudentInfoTool.getStudents(cmp);
         StudentInfoTool.write2File(stus);
     }
 }