黑马程序员——Java基础--IO流（二）

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

IO流（二）

一、Properties
    Properties是hashtable的子类。
    也就是说它具备Map集合的特点，而且它里面存储的键值对都是字符串。
    它是集合中和io技术相结合的集合容器。
    该对象的特点：可以用于键值对形式的配置文件。
    那么在加载数据时，需要数据有固定形式：键=值。

import java.io.*;
import java.util.*;

class PropertiesDemo
{
	public static void main(String[] args)throws IOException
	{
		loadDemo();
	}

	public static void loadDemo()throws IOException
	{
		Properties prop = new Properties();

		FileInputStream fis = new FileInputStream("info.txt");

		//将流中的数据加载进集合。
		prop.load(fis);
		//修改键值对数据
		prop.setProperty("wangwu","45");

		FileOutputStream fos = new FileOutputStream("info.txt");
<span style="white-space:pre">		</span>//将集合信息写入流中
		prop.store(fos,"haha");//haha为注释信息
		//System.out.println(prop);

		prop.list(System.out);//System.out属于PrintWriter

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

	//演示，如何将流中的数据存储到集合中。
	//想要将info.txt中的键值数据存到集合中进行操作。
	/*
	1.用一个流和info.txt文件关联。
	2.读取一行数据，将该行数据用“=”进行切割。
	3.等号左边作为键，右边作为值。存入到Properties集合中即可。
	*/
	
	public static void method_1()throws IOException
	{
		BufferedReader bufr = new BufferedReader(new FileReader("info.txt"));
		String line = null;
	
		Properties prop = new Properties();

		while((line  = bufr.readLine())!=null)
		{
			String[] arr = line.split("=");
	
			//System.out.println(arr[0]+"..."+arr[1]);

			prop.setProperty(arr[0],arr[1]);
		}

		bufr.close();

		System.out.println(prop);
	}

	//设置和获取元素
	public static void setAndGet()
	{
		Properties prop = new Properties();
		
		prop.setProperty("zhangsan","30");
		prop.setProperty("lisi","29");

		//System.out.println(prop);

		prop.setProperty("lisi",89+"");

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

		//返回键值集合
		Set<String> names = prop.stringPropertyNames();
		for(String s : names)
		{
			System.out.println(s+":"+prop.getProperty(s));
		}
	}

	
}

练习：

/*
用于记录应用程序运行次数。
如果使用次数已到，那么给出注册提示。

很容易想到的是：计数器。
可是该计数器定义在程序中随着程序的运行而在内存中存在，并进行了自增。
可是随着该应用程序的退出，该计数器也在内存中消失。

下一次再启动该程序，又重新开始从0计数。
这样不是我们想要的

程序即使结束，该计数器的值也存在。
下次程序启动会先加载该计数器的值并加1后在重新存储起来。

所以要建立一个配置文件，用于记录该软件的使用次数。


该配置文件使用键值对的形式。
这样便于阅读数据，并操作数据。

键值对数据是Map集合。
数据是以文件的形式存储，使用io技术。
那么map+io-->properties

配置文件可以实现应用程序数据的共享。	

*/

import java.io.*;
import java.util.*;

class RunCount
{
	public static void main(String[] args)throws IOException
	{
		Properties prop = new Properties();
<span style="white-space:pre">		</span>//创建配置文件
		File file = new File("count.ini");
		if(!file.exists())
			file.createNewFile();
	
		FileInputStream fis = new FileInputStream("count.ini");

		prop.load(fis);

		int count = 0;
<span style="white-space:pre">		</span>//value值为空，下面的if语句不执行
		String value = prop.getProperty("time");

		if(value!=null)
		{
			count = Integer.parseInt(value);
			if(count>5)
			{
				System.out.println("您好，使用次数已到，付款！");
				return;
			}		
		}

		count++;

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

		FileOutputStream fos = new FileOutputStream("count.ini");
<span style="white-space:pre">		</span>//写入流中
		prop.store(fos,"");

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

二、打印流
    该流提供了打印方法，可以将各种数据类型的数据都原样打印。
    1、字节打印流
	PrintStream
	构造函数可以接受的参数类型：
	a.file对象，File
	b.字符串路径。String
	c.字节输出流。OutputStream
    2、字符打印流
	PrintWriter
	构造函数可以接收的参数类型：
	a.file对象，File
	b.字符串路径。String
	c.字节输出流。OutputStream
	d.字符输出流。Writer

import java.io.*;

class PrintStreamDemo
{
	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);
							//true对流自动刷新

		String line = null;

		while((line=bufr.readLine())!=null)
		{
			if("over".equals(line))
				break;
		//换行标记存在才可以刷新
			out.println(line.toUpperCase());
			//out.flush();
		}
	
		bufr.close();
		out.close();
	}
}

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

import java.io.*;
import java.util.*;
class SequenceDemo
{
	public static void main(String[] args) throws IOException
	{
		Vector<FileInputStream> v = new Vector<FileInputStream>();

		v.add(new FileInputStream("c:\\1.txt"));
		v.add(new FileInputStream("c:\\2.txt"));
		v.add(new FileInputStream("c:\\3.txt"));
	
		//Vector独有的方法枚举，与迭代器功能一样
		Enumeration<FileInputStream> en = v.elements();	
	
		SequenceInputStream sis = new SequenceInputStream(en);

		FileOutputStream fos = new FileOutputStream("c:\\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.*;
import java.util.*;
class SplitFile
{
	public static void main(String[] args)throws IOException
	{
		//splitFile();
		merge();
	}

	public static void merge()throws IOException
	{
	//创建Vector集合效率比较低
	ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();

		for(int x=1;x<=3;x++)
		{
		al.add(new FileInputStream("c:\\splitfile\\"+x+".part"));
		}
		
		final Iterator<FileInputStream> it = al.iterator();
//因为SequenceInputStream要接受一个Enumeration对象，自己创建他的子类对象，匿名内部类
		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("c:\\splitfile\\0.bmp");
			
		byte[] buf = new byte[1024];

		int len =0;

		while((len=sis.read(buf))!=-1)
		{
			fos.write(buf,0,len);
		}
	
		fos.close();
		sis.close();
	}


	public static void splitFile()throws IOException
	{
		FileInputStream fis = new FileInputStream("c:\\1.png");
		
		FileOutputStream fos = null;

		byte[] buf = new byte[1024*1024];

		int len = 0;
		
		int count = 1;
		
		//创建多个流来达到切割文件
		while((len=fis.read(buf))!=-1);
		{
		fos = new FileOutputStream("c:\\splitfile\\"+(count++)+".part");

			fos.write(buf,0,len);
			fos.close();
		}

		fis.close();
	}
}

四、操作对象
    ObjectInputStream与ObjectOutputStream

import java.io.*;

class ObjectStreamDemo
{
	public static void main(String[] args) throws Exception
	{
		//writeObj();
		readObject();
	}
	
	public static void readObject() throws Exception
	{
		ObjectInputStream ois =
			new ObjectInputStream(new FileInputStream("obj.txt"));

		Person p = (Person)ois.readObject();

		System.out.println(p);

		ois.close();
	}

	public static void writeObj() throws IOException
	{
		ObjectOutputStream oos = 
			new ObjectOutputStream(new FileOutputStream("obj.txt"));
	
		oos.writeObject(new Person("lisi",39,"kr"));

		oos.close();
	}
}
import java.io.*;

class Person implements Serializable//标记几口
{
	public static final long serialVersionUID = 42L;

	String name;
	transient int age;//被修饰后也不可以序列化

	static String country = "cn";//静态不可以序列化
	Person(String name,int age,String country)
	{
		this.name = name;
		this.age = age;

		this.country = country;
	}
	public String toString()
	{
		return name+"::"+age+"::"+country;
	}
}

五、管道流
    PipedInputStream和PipedOutputStream
    输入输出可以直接进行连接，通过结合线程使用。

import java.io.*;
class Read implements Runnable
{
	private PipedInputStream in;
	Read(PipedInputStream in)
	{
		this.in = in;
	}
	public void run()
	{
		try
		{
			byte[] buf = new byte[1024];

			System.out.println("读取前。。没有数据阻塞");
	
			int len = in.read(buf);

			System.out.println("读到数据。。。阻塞结束");

			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
		{
			System.out.println("开始写入等待");
			Thread.sleep(6000);
			out.write("piped laile".getBytes());

			out.close();
		}
		catch(Exception e)
		{
			throw new RuntimeException("管道输出流失败");
		}
	}
}

class PipedStreamDemo
{
	public static void main(String[] args) throws IOException
	{
		PipedInputStream in = new PipedInputStream();
		PipedOutputStream out = new PipedOutputStream();
		//链接两个管道
		in.connect(out);

		Read r = new Read(in);
		Write w = new Write(out);

		new Thread(r).start();
		new Thread(w).start();
	}
}

六、RandomAccessFile
    该类不算是IO体系中子类。而是直接继承自Object。但是它是IO包中成员，因为它具备读和写功能。
    内部封装了一个数组，而且通过指针对数组的元素进行操作。
    可以通过getFilePointer获取指针位置。同时可以通过seek改变指针的位置。
    其实完成读写的原理就是内部封装了字节输入流和输出流。
    通过构造函数可以看出，该类只能操作文件。
    而且操作文件还有模式：只读r，读写rw等

    如果模式为只读r，不会创建文件，会去读取一个已存在的文件，如果该文件不存在，则会出现异常。
    如果模式为读写rw，操作的文件不存在，会自动创建，如果存在则不会覆盖。

import java.io.*;
class RandomAccessFileDemo
{
	public static void main(String[] args)throws IOException
	{
		//readFile();
		//writeFile();
		writeFile_2();
	}

	public static void readFile()throws IOException
	{
		RandomAccessFile raf = new RandomAccessFile("ran.txt","r");

		//raf.write("haha".getBytes());拒绝访问


		//调整对象中指针，通过8的倍数取名字和年龄

		//raf.seek(8*1);

		//跳过指定的字节数，不能往回走

		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_2()throws IOException
	{
		RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");
		//指定指针位置	
		raf.seek(8*3);
		raf.write("周期".getBytes());
		raf.writeInt(103);

		raf.close();
		
	}

	public static void writeFile()throws IOException
	{
		RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");

		raf.write("李四".getBytes());
		//readInt() 从此文件读取一个有符号的 32 位整数。
		raf.writeInt(97);
		raf.write("王五".getBytes());
		raf.writeInt(99);


		raf.close();
	}
}

七、DataInputStream 与 DataOutputStream
    可以用于操作基本数据类型的数据的流对象。

import java.io.*;

class DataStreamDemo
{
	public static void main(String[] args)throws IOException
	{
		//writeData();
		//readData();

		//writeUTFDemo();

		readUTFDemo();


	/*	转换流中指定编码表
		OutputStreamWriter osw =
 		new OutputStreamWriter(new FileOutputStream("utf.txt"),"utf-8");

		osw.write("你好");

		osw.close();
	*/
	}

	public static void readUTFDemo()throws IOException
	{
		DataInputStream dis = 
		new DataInputStream(new FileInputStream("utfdata.txt"));

		String s = dis.readUTF();
	
		System.out.println(s);
		
		dis.close();
	}

	public static void writeUTFDemo()throws IOException
	{
		DataOutputStream dos =
		new DataOutputStream(new FileOutputStream("utfdata.txt"));

		dos.writeUTF("你好");
		//只能用对应的方法读取
		
		dos.close();
	}

	public static void readData()throws IOException
	{
		DataInputStream dis = 
			new DataInputStream(new FileInputStream("data.txt"));
		//读取顺序要和存储的顺序一样，否则就会出错
		int num = dis.readInt();
		boolean b = dis.readBoolean();
		double d = dis.readDouble();

		System.out.println("num="+num+"b="+b+"d="+d);
	
		dis.close();
	}

	public static void writeData()throws IOException
	{
		DataOutputStream dos =
			 new DataOutputStream(new FileOutputStream("data.txt"));

		dos.writeInt(234);
		dos.writeBoolean(true);
		dos.writeDouble(9987.543);

		dos.close();
	}
}

八、用于操作字节数组的流对象。
    ByteArrayInputStream:在构造的时候需要接收数据源，而且数据源是一个字节数组。
    ByteArrayOutputStream:在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数据，这就是数据目的地。
    因为这两个流对象都操作的数组，并没有使用系统资源。所以，不用进行close关闭。
    在流操作规律讲解时：
    源设备
	键盘 System.in 硬盘 FileStream 内存ArrayStream
    目的设备：
	控制台 System.out 硬盘FileStream 内存ArrayStream
    用流的读写思想来操作数组。

import java.io.*;

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

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

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


		sop(bos.size());

		sop(bos.toString());

		//bos.writeTo(new FileOutputStream("a.txt"));
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

九、字符编码
    1、编码表的由来
	计算机只能识别二进制数据，早起由来是电信号，为了方便应用计算机，让它可以识别各个国家的文字，就将各个国家的     文字用数字来表示，并一一对应，形成一张表，这就是编码表
    2.常见编码表
	ASCLL：美国标准信息交换码。用一个字节的7位可以表示
	ISO8859-1:拉丁码表。欧洲码表。用一个字节的8位表示。
	GB2312:中国的中文编码表。
	GBK：中国的中文编码表升级，融合了更多的中文文字符号。
	Unicode：国际标准码，融合了多种文字。所有文字都用两个字节表示，Java语言使用的是unicode
	UTF-8：最多用三个字节来表示一个字符。

import java.io.*;

class EncodeStream
{
	public static void main(String[] args)throws IOException
	{
		//writeText();

		readText();
	}

	public static void readText()throws IOException
	{
		InputStreamReader isr = 
		new InputStreamReader(new FileInputStream("utf.txt"),"gbk");

		char[] buf = new char[10];
		
		int len = isr.read(buf);

		String str = new String(buf,0,len);

		System.out.println(str);

		isr.close();
	}

	public static void writeText()throws IOException
	{
		OutputStreamWriter osw = 
		new OutputStreamWriter(new FileOutputStream("utf.txt"),"utf-8");

		osw.write("你好");

		osw.close(); 
	}
}

/*

编码：字符串变字节数组

解码：字节数组变字符串

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

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

*/

import java.util.*;

class EncodeDemo
{
	public static void main(String[] args)throws Exception
	{
		String s = "你好";

		byte[] b1 = s.getBytes("gbk");
		
		//如果解码错误
		String s1 = new String(b1,"iso8859-1");

		//对S1进行iso8859-1编码。
		
		byte[] b2 = s1.getBytes("iso8859-1");

		String s2 = new String(b2,"GBK");

		System.out.println(Arrays.toString(b1));

		System.out.println("s1:"+s1);

		
		System.out.println(Arrays.toString(b2));

		System.out.println("s2:"+s2);
	
		
	}
}

练习：

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

1.描述学生对象。
2.定义一个可以操作学生对象的工具类。

思想：
1.通过获取键盘录入一行数据，并将该行中的信息取出封装成学生对象。

2.因为学生对象有很多，那么就需要存储，使用到集合，因为要对学生的总分排序
  所以可以使用TreeSet。

3.将集合的信息写入到一个文件中。

*/

import java.io.*;
import java.util.*;


class Student implements Comparable<Student>
{
	private String name;
	private int ma,cn,en;
	private int sum;

	Student(String name,int ma,int cn,int en)
	{
		this.name = name;
		this.ma = ma;
		this.cn = cn;
		this.en = en;

		sum = ma+cn+en;
	}

	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 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 String toString()
	{
		return "student["+name+","+ma+","+cn+","+en+"]";
	}
}

class StudentInfoTool
{
	public static Set<Student> getStudent()throws IOException
	{
		return getStudent(null);
	}
	//比较器方式
	public static Set<Student> getStudent(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[] info = line.split(",");

			Student stu = new Student(info[0],Integer.parseInt(info[1]),Integer.parseInt(info[2]),Integer.parseInt(info[3]));

			stus.add(stu);
		}

		bufr.close();
		
		return stus;
	}
		
	public static void write2File(Set<Student> stus)throws IOException
	{
		BufferedWriter bufw = new BufferedWriter(new FileWriter("stuinfo.txt"));

		for(Student stu : stus)	
		{
			
			
			bufw.write(stu.toString()+"\t");

			bufw.write(stu.getSum()+"");

			bufw.newLine();
		
			bufw.flush();

		}

		bufw.close();
	}
}


class StudentInfoTest
{
	public static void main(String[] args)throws IOException
	{
		//建立比较器
		Comparator<Student> cmp = Collections.reverseOrder();		

		Set<Student> stus = StudentInfoTool.getStudent(cmp);

		StudentInfoTool.write2File(stus);
	}
}