黑马程序员---Java基础--21天(IO流之四)

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

1.IO流(对象序列化).

import java.io.*;




public class Person implements Serializable
{
	private static final long serialVersionUID = 42L;
	
	private String name;
	transient int age;
	static String country = "cn";
	Person(String name, int age,String country) {
		super();
		this.name = name;
		this.country = country;
		this.age = age;
	}
	public String toString()
	{
		return name+":"+age+":"+country;
	}
	
	
}
import java.io.*;
public class ObjectStreamDemo {


	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		writeObj();
	}
	public static void writeObj() throws IOException, IOException
	{
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.txt"));
		oos.writeObject(new Person("lisi0",399,"kr"));
		oos.close();
	}


}

2.IO流(管道流)

import java.io.*;
class Read implements Runnable
{
	private PipedInputStream in;
	
	Read(PipedInputStream in) {
		super();
		this.in = in;
	}


	public void run() {
		// TODO Auto-generated method stub
		
		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) {
			// TODO Auto-generated catch block
			throw new RuntimeException("管道读取失败");
			
		}
		
	}
	
}
class Write implements Runnable
{
	private PipedOutputStream out;
	
	Write(PipedOutputStream out) {
		super();
		this.out = out;
	}


	public void run() {
		// TODO Auto-generated method stub
		
		try {
			System.out.println("开始写入数据,等待6秒后");
			Thread.sleep(6000);
			out.write("piped lai le".getBytes());
			out.close();


		} catch (Exception e) {
			// TODO Auto-generated catch block
			throw new RuntimeException("管道输出流失败");
		}
			}
	
}


public class PipedStreamDemo {


	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		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();
	}


}

3.IO流(RandomAccessFile)

import java.io.*;
/*
 * RandomAccessFile
 * 
 * 该类不算是IO体系中的子类.
 * 而是直接继承自Object.
 * 
 * 但是它是IO包中成员.因为它具备读和写功能.
 * 内部封装了一个数组,而且通过指针对数组的元素进行操作.
 * 可以通过getFilePointer获取指针位置.
 * 同时可以通过seek改变指针的位置.
 * 
 * 其实完成读写的原理就是内部封装了字节输入流和输出流.
 * 
 * 通过构造函数可以看出,该类只能操作文件.
 * 而且操作文件还有模式: 只读r,读写rw等.
 * 
 * 如果模式为只读r,不会创建文件.会去读取一个已存在文件.
 * 如果该文件不存在,会出现异常.
 * 如果模式为rw.操作的文件不存在,会自动创建.如果存在则不会覆盖.
 * */
public class RandomAccessFileDemo {


	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		writeFile();
	}
	public static void readFile()throws IOException
	{
		RandomAccessFile raf = new RandomAccessFile("ran.txt", "r");
		
		//调整对象中的指针.
		//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*0);
		raf.write("周期".getBytes());
		raf.write(103);
		raf.close();
	}
	public static void writeFile()throws IOException
	{
		RandomAccessFile raf = new RandomAccessFile("ran.txt", "rw");
		
		raf.write("李四".getBytes());
		raf.writeInt(97);
		
		raf.write("王五".getBytes());
		raf.writeInt(99);
		
		raf.close();
	}
	


}

4.IO流(操作基本数据类型的流对象DataStream)

/*
DataInputStream与DataOutputStream


可以用于操作基本数据类型的数据的流对象。


*/
import java.io.*;
class DataStreamDemo 
{
	public static void main(String[] args) throws IOException
	{
		//writeData();
		//readData();


		//writeUTFDemo();


//		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("gbk.txt"),"gbk");
//
//		osw.write("你好");
//		osw.close();


//		readUTFDemo();


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


		String s = dis.readUTF();


		System.out.println(s);
		dis.close();
	}






	public static void writeUTFDemo()throws IOException
	{
		DataOutputStream dos = new DataOutputStream(new FileOutputStream("utfdate.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);
		System.out.println("b="+b);
		System.out.println("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(9887.543);


		dos.close();


		ObjectOutputStream oos = null;
		oos.writeObject(new O());


		
	}
}

5.IO流(ByteArrayStream)

/*
用于操作字节数组的流对象。


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("ABCDEFD".getBytes());


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


		int by = 0;


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






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


	//	bos.writeTo(new FileOutputStream("a.txt"));


	}
}

6.IO流(转换流的字符编码)

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();
	}


}

7.字符编码

/*
编码：字符串变成字节数组。




解码：字节数组变成字符串。


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




byte[] -->String: new String(byte[],charsetName);


*/
import java.util.*;
class  EncodeDemo
{
	public static void main(String[] args)throws Exception 
	{
		String s = "哈哈";


		byte[] b1 = s.getBytes("GBK");


		System.out.println(Arrays.toString(b1));
		String s1 = new String(b1,"utf-8");
		System.out.println("s1="+s1);


		//对s1进行iso8859-1编码。
		byte[] b2 = s1.getBytes("utf-8");
		System.out.println(Arrays.toString(b2));


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


		System.out.println("s2="+s2);


		


	}
}

8.字符编码-联通

class EncodeDemo2 
{
	public static void main(String[] args) throws Exception
	{
		String s = "ͨ";


		byte[] by = s.getBytes("gbk");


		for(byte b : by)
		{
			System.out.println(Integer.toBinaryString(b&255));
		}




		System.out.println("Hello World!");
	}
}

9.练习

/*
有五个学生，每个学生有3门课的成绩，
从键盘输入以上数据（包括姓名，三门课成绩），
输入的格式：如：zhagnsan，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> getStudents()throws IOException
	{
		return getStudents(null);
	}


	public static Set<Student> getStudents(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.getStudents(cmp);


		StudentInfoTool.write2File(stus);
	}
}

---------------------- android培训、 java培训、期待与您交流！ ----------------------详细请查看： http://edu.csdn.net/heima