黑马程序员-Java学习笔记之IO流（三）

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

这里总结的是IO包中扩展功能的流对象，基本上都是装饰设计模式。

一 打印流

只有两个：

1，PrintStream。

2，PrintWriter。

PrintWriter和PrintStream都属于输出流，分别针对字符和字节。

PrintWriter和PrintStream重载的print()和println()用于多种数据类型的输出。

print()里的参数不能为空；println()可以

PrintWriter和PrintStream输出操作不抛出异常

PrintStream调用println方法有自动flush功能;

Java.io.outputstream.PrintStream：打印流

1：提供了更多的功能，比如打印方法。可以直接打印任意类型的数据。

2：它有一个自动刷新机制，创建该对象，指定参数，对于指定方法可以自动刷新。

3：它使用的本机默认的字符编码. 

4：该流的print方法不抛出IOException。

 

该对象的构造函数。

PrintStream(File file)  ：创建具有指定文件且不带自动行刷新的新打印流。 

PrintStream(File file, String csn) ：创建具有指定文件名称和字符集且不带自动行刷新的新打印流。 

PrintStream(OutputStream out) ：创建新的打印流。 

PrintStream(OutputStream out, boolean autoFlush) ：创建新的打印流。 

PrintStream(OutputStream out, boolean autoFlush, String encoding) ：创建新的打印流。 

PrintStream(String fileName) ：创建具有指定文件名称且不带自动行刷新的新打印流。 

PrintStream(String fileName, String csn) 

 

PrintStream可以操作目的：1：File对象。2：字符串路径。3：字节输出流。

前两个都JDK1.5版本才出现。而且在操作文本文件时，可指定字符编码了。

 

当目的是一个字节输出流时，如果使用的println方法，可以在printStream对象上加入一个true参数。这样对于println方法可以进行自动的刷新，而不是等待缓冲区满了再刷新。最终print方法都将具体的数据转成字符串，而且都对IO异常进行了内部处理。

 

既然操作的数据都转成了字符串，那么使用PrintWriter更好一些。因为PrintWrite是字符流的子类，可以直接操作字符数据，同时也可以指定具体的编码。

 

Example:

import java.io.*;
class PrintStreamDemo1
{
	public static void main(String[] args)throws Exception
	{
		PrintStream ps=new PrintStream(new FileOutputStream("demo.txt",true),true);//创建打印流关联文件。
		ps.println(12);//打印整型。
		ps.println(false);//打印boolean。
		ps.println(12.9);//打印double类型
		System.out.println("Hello world！");
}
 
}

 

PrintWriter：具备了PrintStream的特点同时，还有自身特点：

该对象的目的地有四个：1：File对象。2：字符串路径。3：字节输出流。4：字符输出流。

开发时尽量使用PrintWriter。方法中直接操作文件的第二参数是编码表。直接操作输出流的，第二参数是自动刷新。

//读取键盘录入将数据转成大写显示在控制台.

Example:

import java.io.*;
class PrintWriterStreamDemo
{
	public static void main(String[] args)throws IOException
	{
		BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));//键盘录入。
		PrintWriter pw=new PrintWriter(System.out,true);//控制台输出，切自动刷新。
		String line=null;
		while((line=bufr.readLine())!=null)
		{
			if("over".equals(line))
			{
				break;
			}
				else
			{
					pw.println(line.toUpperCase());//转换成大写输出。
			}
		}
		//注意：System.in，System.out这两个标准的输入输出流，在jvm启动时已经存在了。随时可以使用。当jvm结束了，这两个流就结束了。但是，当使用了显示的close方法关闭时，这两个流在提前结束了。
		bufr.close();
		pw.close();
		System.out.println("Hello world！");
	}

}

 

 

 

二 内存操作流

操作内存流的时候（从读取出来，注意一定要把真正的数据用toByteArray或者toCharArray将数据读出来）

之前的文件操作流是以文件的输入输出为主的，当输出的位置变成了内存，那么就称为内存操作流。此时要使用内存流完成内存的输入和输出操作。

如果程序运行过程中要产生一些临时文件，可采用虚拟文件方式实现；

直接操作磁盘的文件很耗性能,使用内存流可以提升性能;jdk里提供了内存流可实现类似于内存虚拟文件的功能。

ByteArrayInputStream：将内容写到内存中     CharArrayReader

ByteArrayOutputStream：将内存中的数据写出      CharArrayWriter

ByteArrayInputStream：构造方法：

public ByteArrayInputStream(byte[] buf):全部内容

public ByteArrayInputStream(byte[] buf,int offset,int length)：指定范围的内容

ByteArrayOutputStream:

public ByteArrayOutputStream()；

ByteArrayInputStream：源：内存 

ByteArrayOutputStream：目的：内存。 

这两个流对象不涉及底层资源调用，操作的都是内存中数组，所以不需要关闭。

直接操作字节数组就可以了，为什么还要把数组封装到流对象中呢？因为数组本身没有方法，只有一个length属性。为了便于数组的操作，将数组进行封装，对外提供方法操作数组中的元素。

 

对于数组元素操作无非两种操作：设置（写）和获取（读），而这两操作正好对应流的读写操作。这两个对象就是使用了流的读写思想来操作数组。

Example:

import java.io.*;
class ArrayStremDemo
{
	public static void main(String[] args)throws IOException
	{
		//byteArrayInputStreamDemo_1();
		byteArrayInputStreamDemo_2();
		
	}
	public static void byteArrayInputStreamDemo_2()throws IOException
	{
		String s="haha";
		ByteArrayOutputStream bos=new ByteArrayOutputStream();
		bos.write(s.getBytes());//将数据写到内存中
		byte[] buf=bos.toByteArray();//将内存中的数据存储到数组中。
		ByteArrayInputStream bis=new ByteArrayInputStream(buf);
		byte[] b=new byte[1024];
		int ch=0;
		while((ch=bis.read(b))!=-1)//读取数据。
		{
			System.out.println(new String(b,0,ch));

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


	}
	public static void byteArrayInputStreamDemo_1()
	{
		String s="haha";
		ByteArrayInputStream bis=new ByteArrayInputStream(s.getBytes());//将数据写入内存中。
		ByteArrayOutputStream bos=new ByteArrayOutputStream();
		
		int ch=0;
		while((ch=bis.read())!=-1)//读取数据。
		{
		bos.write(ch);
		}
		System.out.println(bos.toString());
		
	}

}

三 序列流

序列流：作用就是将多个读取流合并成一个读取流。实现数据合并。

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

这样做，可以更方便的操作多个读取流，其实这个序列流内部会有一个有序的集合容器，用于存储多个读取流对象。

常见合并多个流文件步骤

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

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

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

        4、创建写入流对象，FileOutputStream关联写入文件

        5、利用SequenceInputStream对象和FileOutputStream对象读数据进行反复读写操作。

Example:

import java.io.*;
import java.util.*;
class SequenecStreamDemo
{
	public static void main(String[] args)throws IOException
	{
		Vector<InputStream> v=new Vector<InputStream>();//创建Vector集合。
		v.add(new FileInputStream("demo1.txt"));//添加流对象。
		v.add(new FileInputStream("demo2.txt"));
		v.add(new FileInputStream("demo3.txt"));
		Enumeration<InputStream> en=v.elements();//创建枚举对象。
		SequenceInputStream sis=new SequenceInputStream(en);
		FileOutputStream fos=new FileOutputStream("demo.txt");
		byte[] buf=new byte[1024];
		int ch=0;
		while((ch=sis.read(buf))!=-1)
		{
			fos.write(buf,0,ch);
		}
		sis.close();//关闭资源。
		fos.close();

		System.out.println("Hello world！");
	}

}

四 Properties

1概述

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

2特点

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

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

 

3 常用方法

        Object setProperty(String key,String value);

        //设置键和值，调用Hashtable的方法put

        String getProperty(String key);

        //指定key搜索value

        Set<String> stringPropertyName();

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

        void load(InputStream ism);

        //从输入字节流中读取属性列表（键和元素对）。又称将流中的数据加载进集合。

        void load(Readerreader);

        //从输入字符流中读取属性列表（键和元素对）。又称将流中的数据加载进集合。

        voidlist(PrintStream out);//将属性列表输出到指定的输出流

        void store(OutputStreamout,String comments);

        //对应load(InputStream )将属性列表（键值对）写入输出流。comments属性列表的描述。

        void store(Writerwriter, String comments);

        //对应load(Reader)将属性列表（键值对）写入输出流。comments属性列表的描述。

 

Example:

/*
练习：用于记录应用程序运行次数。如果使用次数已到，那么会给出注册提示。
	
*/
import java.util.*;
import java.io.*;

class  RunCount
{
	public static void main(String[] args)throws IOException 
	{
		int count=runCount();
		if(count>5)//如果程序被使用了超过5次，则终止使用，并提示
		{
			System.out.println("您的使用次数已到，请购买正版！");
			return ;
		}
		else
			System.out.println("程序第"+count+"次运行！");
	}
	//获取程序运行的次数
	public static int runCount()throws IOException
	{
		Properties ps=new Properties();//创建集合对象

		File file=new File("info.ini");//将文件进行封装
		if(!file.exists())//判断是否存在
			file.createNewFile();
		FileReader fr=new FileReader(file);//将文件于读取流进行关联
		
		ps.load(fr);//加载流中的文件数据到集合中

		int count=0;//定义计数器
		String value=ps.getProperty("time");//获取次数值
		
		if(value!=null)//如过值不等于null，则将其赋值给count
		{
			count=Integer.parseInt(value);
		}
		count++;//每启动一次自增
		ps.setProperty("time",count+"");//将次数记录住集合

		FileWriter fw=new FileWriter(file);
		ps.store(fw,"");//将集合中的数据存入硬盘文件中
		
		fr.close();//关流
		fw.close();

		return count;//返回程序启动的次数
	}
}