黑马程序员_<<properties,打印流，合并流，分割流>>

来源：互联网发布：mac刷新dns 编辑：程序博客网时间：2024/05/16 12:07

分类： IO流2013-10-06 00:33 256人阅读评论(0) 收藏举报

Properties打印流分割流合并流黑马程序员

目录(?)[+]

--------------------ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ --------------------

1. Properties

1.概述

Properties是Hashtable的子类，存储的格式那么也是键值对，但是键和值都是字符串类型

2.常用方法

[java] view plaincopy
 public class PropertiesDemo1 {  
   public static void main(String[] args) {  
     Properties pro = new Properties();  
     /* setProperty(String key,String value)添加键和值 */  
     pro.setProperty("java01", "001");  
     pro.setProperty("java02", "002");  
     /* 通过键获得值：String getProperty(String key) */  
     System.out.println(pro.getProperty("java01"));  
     /* Set<String>stringPropertyNames()获得键集 */  
     Set<String> set = pro.stringPropertyNames();  
     for (String s : set)  
        System.out.println(s + ":" + pro.getProperty(s));  
   }  
   
}  
结果：  
001  
java02:002  
java01:001  

3.配置文件

将配置文件中的信息存到集合中，然后修改其键和值，然后在传给文件。配置文件中的信息都是用=号存储的，例如：张三=001

第一种方法：我们不使用Properties对象，就是用集合来操作，思路：我们将文件读取出来，然后对每一行进行用=分割，把左边的存为键，把右边的存为值。

[java] view plaincopy
import java.io.FileReader;  
import java.io.IOException;  
import java.util.HashMap;  
import java.util.Properties;  
import java.util.Set;  
   
public class PropertiesDemo1 {  
   public static void main(String[] args) throws IOException {  
     BufferedReader br = new BufferedReader(new FileReader("F:\\pro.txt"));//读取流  
     HashMap<String, String> map = new HashMap<String, String>();//map集合  
     String line = null;  
     while ((line = br.readLine()) != null) {  
        String[] s = line.split("=");  
        map.put(s[0], s[1]);  
     }  
     System.out.println(map);  
   }  
   
}  
结果：  
{java02=002, java03=003, java01=001}  

第二种方法：我们使用Properties对象，这样我们可以方便的加载流，来操作文件。

[java] view plaincopy
import java.io.FileReader;  
import java.io.FileWriter;  
import java.io.IOException;  
import java.util.HashMap;  
import java.util.Properties;  
import java.util.Set;  
   
public class PropertiesDemo1 {  
   public static void main(String[] args) throws IOException {  
     /* void load(Reader reader)将读取流字符流加载到集合中 */  
     Properties pro = new Properties();  
     FileReader fr = new FileReader("F:\\pro.txt");  
     pro.load(fr);// 将字符读取流中读取的文件放到Properties对象中  
     System.out.println("加载后的集合：" + pro);  
     /* 下面我们修改集合中的数值 */  
     pro.setProperty("java02", "hello");  
     /* 
      * store(Writer writer,String 
      * comments)通过字符写入流，把集合中的信息更新配置文件，comments是注视内容 
      */  
     FileWriter fw = new FileWriter("F:\\pro.txt");  
     pro.store(fw, "java");// 更新配置文件，注释为：java  
     fr.close();  
     fw.close();  
   }  
   
}  
结果：  
加载后的集合：{java03=003, java02=002, java01=001}  

4.计算程序运行次数

[java] view plaincopy
 importjava.io.File;  
import java.io.FileInputStream;  
import java.io.FileNotFoundException;  
import java.io.FileOutputStream;  
import java.io.IOException;  
import java.io.OutputStream;  
import java.io.PrintStream;  
import java.util.Properties;  
   
public class PropertiesDemo {  
   
      publicstatic void main(String[] args) throws IOException {  
           /* 
            * 计算程序的运行次数 思路： 1.创建一个配置文件，然后然后里面定义了一个计数器 
            * 2.每次运行的时候，都取出来，然后自增，然后再存回去 
            */  
   
           Filefile = new File("F:\\pro.ini");  
           if(!file.exists())  
                 file.createNewFile();  
   
           Propertiespro = new Properties();  
           pro.load(newFileInputStream(file));// 加载流  
           Stringvalue = pro.getProperty("count");  
           intcount = 0;  
           if(value != null)  
                 count= Integer.parseInt(value);  
           count++;//自增  
           pro.setProperty("count",count + "");// 改变值  
           pro.store(newFileOutputStream(file), "java for count");// 更新文件  
           System.out.println(pro);  
      }  
   
}结果：  
运行一次，count就+1.  

2. 打印流

PrintStream：字节打印流

其构造方法传入的参数：

File对象，字符串路径，字节流。

PrintWriter：字符打印流

其构造方法传入的参数有：

File对象，字符串路径，字节流，字符流。

另外注意的是：字符流中传入的是流的话，可以设置自动刷新，只有使用println，printf，format方法可以自动刷新。

[java] view plaincopy
import java.io.BufferedReader;  
import java.io.File;  
import java.io.IOException;  
import java.io.InputStreamReader;  
import java.io.PrintWriter;  
   
public class PrintStreamDemo {  
   public static void main(String[] agrs) throws IOException {  
     // File f=newFile("F:\\demo.txt");  
     BufferedReader br = new BufferedReader(new InputStreamReader(System.in));  
     PrintWriter pw = new PrintWriter(System.out,true);//true表示自动刷新，但是必须是println方法  
     String line = null;  
     while ((line = br.readLine()) != null) {  
        if ("over".equals(line))  
          return;  
        pw.println("内容是：" + line);  
        //pw.flush();  
   
     }  
     br.close();  
     pw.close();  
   }  
}  

现在是把内容打印在了控制台上，也可以打印在文件中，把PrintWriter流对象更改一下就可以的啊。

3. 合并流

将多个流合并成一个流，便于操作

例如：三个文件的内容写入到第四个文件中，那先把指定到前三个文件的流合并成一个流，然后指向第四个进行读取后，写入

1．可以现将两个流合并到一个流，然后再把合并流和另外一个流再合并，public SequenceInputStream(InputStreams1,InputStream s2)

2．也可以使用集合，public SequenceInputStream(Enumeration<? extends InputStream> e)

[java] view plaincopy
import java.io.FileOutputStream;  
import java.io.IOException;  
import java.io.SequenceInputStream;  
import java.util.Enumeration;  
import java.util.Vector;  
import java.io.FileInputStream;  
   
public class SqueDemo {  
  public static void main(String[] agrs) 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();  
    SequenceInputStreamsis = new SequenceInputStream(en);  
   
    FileOutputStream out = new FileOutputStream("F:\\4.txt");  
    byte[] b = new byte[1024];  
    int len = 0;  
    while ((len = sis.read(b)) != -1) {  
      out.write(b, 0, len);  
      out.flush();  
    }  
    sis.close();  
    out.close();  
   
  }  
}  

4. 切割流

将图片分割后，然后在合并

[java] view plaincopy
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;  
   
public class PhotoDemo {  
  public static void main(String[] args) throws IOException {  
   
    FenGe();  
   
    HeBing();  
   
  }  
   
  private static void HeBing() throws FileNotFoundException, IOException {  
    /* 其实这个也可以使用循环，然后添加到集合， */  
    Vector<FileInputStream> v = new Vector<FileInputStream>();  
    v.add(new FileInputStream("F:\\part\\1.part"));  
    v.add(new FileInputStream("F:\\part\\2.part"));  
    v.add(new FileInputStream("F:\\part\\3.part"));  
    v.add(new FileInputStream("F:\\part\\4.part"));  
    v.add(new FileInputStream("F:\\part\\5.part"));  
    Enumeration<FileInputStream> en = v.elements();  
    SequenceInputStream sis = new SequenceInputStream(en);  
   
    FileOutputStream out = new FileOutputStream("F:\\part\\1.bmp");  
    byte[] b = new byte[1024];  
    int len = 0;  
    while ((len = sis.read(b)) != -1) {  
      out.write(b, 0, len);  
      out.flush();  
    }  
    sis.close();  
    out.close();  
  }  
   
  /* 分割 */  
  private static void FenGe() throws FileNotFoundException, IOException {  
    FileInputStream input = new FileInputStream("F:\\1.png");  
   
    FileOutputStream out = null;  
    byte[] buf = new byte[1024 * 100];  
    int count = 1;  
    int len = 0;  
    while ((len = input.read(buf)) != -1) {  
      out = new FileOutputStream("F:\\part\\" + (count++) + ".part");// 分割后的后缀名自己可以自定义  
      out.write(buf, 0, len);  
      out.flush();  
      out.close();  
   
    }  
    input.close();  
  }  
   
}  

其实也可以分割媒体，电影和音乐的。