JAVA自学教程之IO流（八）打印流 & 序列流



JAVA自学教程之IO流（八）打印流 & 序列流。

一、综合练习—文件清单列表

获取指定目录下，指定扩展名的文件（含子目录），并将这些文件的绝对路径写到一个文本文件中。也就是建立一个指定扩展名的文件列表

1.深度遍历

2.过滤器->容器

3.写入文件

 

  1. import java.util.List;
  2. import java.io.*;
  3. import java.util.ArrayList;
  5. public class Main
  6. {
  7.     public static void main(String[] args) throws IOException {
  9.         File dir = new File(“D:\\java”);//指定源文件
  10.         FilenameFilter filter = new FilenameFilter() {//过滤器
  12.             public boolean accept(File dir, String name) {
  14.                 return name.endsWith(“.java”);
  15.             }
  16.         };
  17.         List<File> list = new ArrayList<File>();//容器
  18.         GetFile(dir, filter, list);//获取符合条件的文件
  19.         File dFile = new File(dir,”javalist.txt”);
  20.         WriteToFile(list, dFile);//写入
  21.     }
  22.     /*
  23.      *
  24.      * */
  25.     public static void GetFile(File dir , FilenameFilter filter,List<File> list) throws IOException{
  26.         File[] files = dir.listFiles();
  27.         for(File file : files){
  28.             if(file.isDirectory()){
  29.                 GetFile(file,filter,list);
  30.             }else{
  31.                 if(filter.accept(dir, file.getName())){
  32.                     list.add(file);
  33.                 }
  34.             }
  35.         }
  36.     }
  37.     public static void WriteToFile(List<File> list,File destfile){
  38.         BufferedWriter bw = null;
  39.         try {
  40.             bw = new BufferedWriter(new FileWriter(destfile));
  41.             for(File file : list){
  42.                 bw.write(file.getAbsolutePath());
  43.                 bw.newLine();
  44.                 bw.flush();
  45.             }
  46.         } catch (Exception e) {
  47.             throw new RuntimeException(“写入失败”);
  49.         }finally{
  50.             if(bw!=null){
  51.                 try {
  52.                     bw.close();
  53.                 } catch (Exception e2) {
  54.                     // TODO: handle exception
  55.                     throw new RuntimeException(“关闭失败”);
  56.                 }
  58.             }
  59.         }
  60.     }
  61. }

二、IO包中的其他类

 

打印流：PrintWriter 、PrintStream：可以直接操作输入流和文件

序列流：SequenceInputStream：对多个流进行合并

操作对象：ObjectInputStream、ObjectOutputStream：被操作的对象需要实现Serializable（标记接口）

打印流

字节打印流：PrintStream

1.提供了打印方法可以对多种数据类型值进行打印，并保持数据的表示形式
2.永远不会抛出IOException


构造函数，接收三种类型的值
1.字符串路径
2.File对象
3.字节输出流

 

  1. public static void main(String[] args) throws IOException {
  3.         PrintStream ps = new PrintStream(“A.txt”);//指定写入文件
  4.         //ps.write(98);//保存是b，只写入二进制的最低8位
  5.         ps.print(98);//将数据变成字符串，原样打印，每次打印都会覆盖原有数据
  6.         ps.close();
  7.     }


字符打印流：PrintWriter

 

构造函数，接收四种类型的值
1.字符串路径
2.File对象
3.字节输出流

4.字符输出流

 

  1. public static void main(String[] args) throws IOException {
  3.     BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  4.     //PrintWriter pw = new PrintWriter(System.out,true)
  5.     PrintWriter pw = new PrintWriter(new FileWriter(“text.txt”),true);//自动刷新，且只有输出流才会自动刷新
  7.     String line = null;
  8.     while((line=br.readLine())!=null){
  9.         if(“over”.equals(line))
  10.             break;
  11.         pw.println(line);
  12.     }
  13.     pw.close();
  14.     br.close();
  15. }

序列流

 

SequenceInputStream 表示其他输入流的逻辑串联。它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。

将多个源，合成一个源

构造方法：

 

SequenceInputStream(Enumeration<? extends InputStream> e)

通过记住参数来初始化新创建的 SequenceInputStream，该参数必须是生成运行时类型为 InputStream 对象的 Enumeration 型参数。
SequenceInputStream(InputStream s1, InputStream s2)

通过记住这两个参数来初始化新创建的 SequenceInputStream（将按顺序读取这两个参数，先读取 s1，然后读取 s2），以提供从此SequenceInputStream 读取的字节。

 

 

 

  1. public static void main(String[] args) throws IOException {
  3.         //将a.txt,b.txt,c.txt的数据合并到一个文件
  4.         //SequenceInputStream的构造函数有两个，演示枚举
  5. //      Vector<FileInputStream> vec = new Vector<FileInputStream>();
  6. //
  7. //      vec.add(new FileInputStream(“a.txt”));
  8. //      vec.add(new FileInputStream(“b.txt”));
  9. //      vec.add(new FileInputStream(“c.txt”));
  10.     //  Enumeration<FileInputStream> en = vec.elements();
  12.         ArrayList<FileInputStream> ar = new ArrayList<FileInputStream>();//ar下没有枚举，但是有迭代器
  13.         ar.add(new FileInputStream(“a.txt”));
  14.         ar.add(new FileInputStream(“b.txt”));
  15.         ar.add(new FileInputStream(“c.txt”));
  17.         Enumeration<FileInputStream> en = Collections.enumeration(ar);//原理如下
  19.         /*final Iterator< FileInputStream> it = ar.iterator();
  21.         Enumeration<FileInputStream> en = new Enumeration<FileInputStream>() {//实现Enumeration
  23.             public boolean hasMoreElements() {
  25.                 return it.hasNext();
  26.             }
  28.             public FileInputStream nextElement() {
  30.                 return it.next();
  31.             }
  33.         };*/
  35.         SequenceInputStream sis = new SequenceInputStream(en);//合并
  36.         FileOutputStream fos = new FileOutputStream(“d.txt”);
  37.         byte[] by = new byte[1024];
  38.         int len =  0;
  39.         while((len = sis.read(by))!=-1){
  40.             fos.write(by,0,len);
  41.         }
  42.         fos.close();
  43.         sis.close();
  45.     }