黑马程序员-基础-IO流-（Properties，打印流，合并流）

来源：互联网发布：华为删除内置软件编辑：程序博客网时间：2024/04/29 20:28

------- android培训、java培训、期待与您交流！ ----------

Properties 类

一、概述：

1、Properties是Hashtable的子类，它具备Map集合的特点，而且它里面还有存储的键值对，都是字符串，无泛型定义。是集合中和IO技术想结合的集合容器。

2、特点：

1）可用于键值对形式的配置文件

2）在加载时，需要数据有固定的格式，常用的是：键=值

二、特有方法：

1、设置和获取元素：

Object setProperty(String key,String value)

---> 调用Hashtable的方法put

String getProperty(String key)

---> 指定key搜索value

Set<String> stringPropertyName()

---> 返回属性列表的键集，存入Set集合

void load(InputStream ism)

---> 从输入字符流中读取属性列表

void load(Reader reader)

---> 从输入字符流中读取属性列表

load方法举例：

[java] view plaincopyprint?
//load方法  
public static void loadMthod()throws IOException  
{  
    Properties pop =new Properties();  
    FileInputStream fis = new FileInputStream("info.txt");  
    //将流中的数据加载进集合  
    pop.load(fis);  
      
    pop.setProperty("zz","25");  
    pop.setProperty("ww","24");  
    FileOutputStream fos = new FileOutputStream("info.txt");  
    pop.store(fos,"hehe");  
    pop.list(System.out);  
    fis.close();  
    fos.close();  
  
}  

举例：

如何将六种的数据存储到集合中？

将文本文件中的键值数据存到集合中：

1、用一个流和文件关联

2、读取一行数据，将改行数据用“=”切割

3、将等号左边作为键，右边作为值，存入到Properties集合即可

[java] view plaincopyprint?
//将流中的数据存储到集合中  
public static void method()throws IOException  
{  
    BufferedReader bufr = null;  
    try  
    {  
        Properties pop = new Properties();  
        bufr = new BufferedReader(new FileReader("info.txt"));  
        String line = null;  
        while((line=bufr.readLine())!=null)  
        {  
            String[] arr = line.split("=");  
            pop.setProperty(arr[0],arr[1]);  
        }  
        System.out.println(pop);  
    }  
    catch (IOException e)  
    {  
        throw new RuntimeException("文件操作失败");  
    }  
    finally  
    {  
        try  
        {  
            if(bufr!=null)  
                bufr.close();  
        }  
        catch (IOException e)  
        {  
            throw new RuntimeException("关闭流资源操作失败");  
        }  
    }         
}  

示例：用于记录应用程序运行次数

如果使用次数已到，那么给出注册提示需要使用计数器，但是在程序结束后，会在内存中消失，此时就需要将其存入到文件中，所以需要一个配置文件，用于记录该软件使用的次数。便于阅读和操作数据

键值对数据 ---> Map集合；数据以文件形式存储 ---> IO技术。 --->Map+IO=Properties

[java] view plaincopyprint?
import java.util.*;  
import java.io.*;  
class RunCount  
{  
    public static void main(String [] args)throws IOException  
    {  
        //创建一个Properties对象，集合和io的结合  
        Properties pop = new Properties();  
        //创建一个文件对象，用于操作文件  
        File file = new File("count.ini");  
        //先判断文件是否存在，如果不存在就创建一个  
        if(!file.exists())  
            file.createNewFile();  
  
        //创建读取流对象，读取文件中的信息  
        FileInputStream fis = new FileInputStream(file);  
        //将流中的文件信息存入集合中  
        pop.load(fis);  
          
        //定义计数器  
        int count = 0;  
        //获取文件中键所对应的值  
        String value = pop.getProperty("time");  
        //判断值是否为null，不为空就将值传给计数器  
        if(value!=null)  
        {  
            count = Integer.parseInt(value);  
            //判断计数器是否为到达次数  
            if(count>=5)  
            {  
                System.out.println("次数已到，请注册");  
                return ;  
            }  
        }  
        count++;  
        //将获得的键值设置后存入集合中  
        pop.setProperty("time",count+"");  
        FileOutputStream fos = new FileOutputStream(file);  
        pop.store(fos,"");  
        fos.close();  
        fis.close();  
    }  
}  

打印流

一、概述：

1、打印流包括：PrintStream和PrintWriter

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

二、字节打印流：PrintStream

构造方法中可接收的参数类型：

1、file对象。File

2、字符串路径：String

3、字符输出流：OutputStream

三、字符串打印流：PrintWriter

构造方法中可接受的参数类型

1、file对象：File

2、字符串路径：String

3、字节输出流：OutputStream

4、字符输出流：Writer

举例：

[java] view plaincopyprint?
import java.io.*;  
  
class PrintDemo  
{  
    public static void main(String[] args) throws IOException  
    {  
        //键盘录入，创建读取流对象  
        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));  
        //使用打印流，将文件输出  
        //输出到屏幕  
        PrintWriter out = new PrintWriter(new FileWriter("a.txt"),true);  
        String line = null;  
        while((line=bufr.readLine())!=null)  
        {  
            if("over".equals(line))  
                break;  
            out.println(line.toUpperCase());  
            //out.flush();  
        }  
        bufr.close();  
        out.close();  
    }  
}  

合并流

一、概述：

1、SequenceInputStream可以将多个流连接成一个源

2、构造函数：

1）SequenceInputStream(Enumeration<? extends FileInputStream> e)

二、如何合并多个文件：

1、创建集合，并将流对象添加进集合

2、创建Enumeration对象，将集合元素加入。

3、创建SequenceInputStream对象，合并流对象

4、创建写入流对象，FileOutputStream，将数据写入流资源

5、定义数组，将读取流数据存入数组，并将数组中元素写入文件中。

举例：

假设有三个文件，将三者合并到一个新文件中

[java] view plaincopyprint?
//合并流对象  
public static void sequenceFile()throws IOException  
{  
    FileOutputStream fos = null;  
    SequenceInputStream sis = null;  
    try  
    {  
        //创建集合，存储多个文件  
        ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();  
        for(int i=1;i<=3;i++)  
        {  
            al.add(new FileInputStream(i+".part"));  
        }  
        //匿名内部类访问局部变量要final  
        final Iterator<FileInputStream> it = al.iterator();  
        //创建Enumeration匿名对象  
        Enumeration<FileInputStream> en = new Enumeration<FileInputStream>()  
        {  
            public boolean hasMoreElements()  
            {  
                return it.hasNext();  
            }  
            public FileInputStream nextElement()  
            {  
                return it.next();  
            }  
        };  
        //合并流对象，将集合元素加入。  
        sis = new SequenceInputStream(en);  
        //创建写入流对象，FileOutputStream  
        fos = new FileOutputStream("7.bmp");  
        byte[] b = new byte[1024*1024];  
        int len = 0;  
        //循环，将数据写入流资源  
        while((len=sis.read(b))!=-1)  
        {  
            fos.write(b);  
        }  
  
    }  
    catch (IOException e)  
    {  
        throw new RuntimeException("文件操作失败");  
    }  
    //关闭流资源  
    finally  
    {  
        try  
        {  
            if(fos!=null)  
                fos.close();  
        }  
        catch (IOException e)  
        {  
            throw new RuntimeException("关闭流资源操作失败");  
        }  
        try  
        {  
            if(sis!=null)  
                sis.close();  
        }  
        catch (IOException e)  
        {  
            throw new RuntimeException("关闭流资源操作失败");  
        }  
    }         
}  

三、切割流资源：

1、先关联文件FileInputStream

2、定义写入流变量：FileOutputStream

3、创建数组，并定义切割所需的大小|

4、循环读写数据，并每次创建一个新写入流，创建完后并写入文件中

5、关闭流资源

[java] view plaincopyprint?
    //切割流对象  
    public static void splitFile()throws IOException  
    {  
        //创建全局变量  
        FileInputStream fis = null;  
        FileOutputStream fos = null;  
        try  
        {  
            //创建文件读取流  
            fis = new FileInputStream("0.bmp");  
            //创建数组  
            byte[] b = new byte[1024*1024];  
            int len = 0;  
            //计数器  
            int count = 1;  
            //循环写入数据  
            while((len=fis.read(b))!=-1)  
            {  
                //每次创建一个新写入流，写入后关闭流资源  
                fos = new FileOutputStream((count++)+".part");  
                fos.write(b,0,len);  
                fos.close();  
            }  
        }  
        catch (IOException e)  
        {  
                throw new RuntimeException("关闭流资源操作失败");  
        }  
        //关闭流资源  
        finally  
        {  
            try  
            {  
                if(fis!=null)  
                    fis.close();  
            }  
            catch (IOException e)  
            {  
                throw new RuntimeException("关闭流资源操作失败");  
            }  
        }  
          
    }  
}  