黑马程序员--- 学习笔记(第二十一天)

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


流构造的时候,必须有一个目的


直接操作对象数据的流


对象序列化(持久化)
要被流操作的对象必须实现Serialziable接口,否则会抛
NOSerializableException 没有序列化异常,
同时应该自定义SerivalVersionUID,给类一个固定标识符
public static final ServialVersionUID=78L;


InvaildClassException 无效类异常


静态不能被序列化,只能序列化堆内存的,不能序列化方法区的
,不想成员变量被序列化可以加上transient关键字


建议输出流的文件命名: 类名.Object


接口中没有方法称为标志接口


常用方法:
writeObject(); //写入对象
readObject(); //读取返回Object

/*
人类  对象持久化
*/
import java.io.Serializable;
public class   Person implements Serializable
{
	private static final long  serialVersionUID=1314L;
	private String name;
	transient private int age; //被transient修饰不能序列化
	static String city;	//静态不能序列化
	public void setName(String name){
	   this.name=name;
	}
	public String getName(){
		   return name;
	}
	public void setAge(int age){
		 this.age=age;
	}
	public int getAge(){
		return age;
	}
	public Person(String name, int age,String city){
		this.name=name;
		this.age=age;
		this.city=city;
	}
}

/*
 ObjectInputStream
 ObjectOutputStream

 直接操作对象数据的流

 演示两个特殊方法:
 writeObject();
 readObject();
*/
import java.io.*;
class Demo1 
{
	public static void main(String[] args) throws Exception
	{
		//write();
		read();
	}
	public static void read()throws Exception{
		//从Person.object 中读取对象数据
		ObjectInputStream ois=new ObjectInputStream(new FileInputStream("Person.object"));
		//返回Object需要强转
		Person p=(Person)ois.readObject();
		Person p1=(Person)ois.readObject();

	  //无法读取static数据 所以返回null
	//	System.out.println(p.getName()+""+p.city);
	//被transient修饰的变量 返回0 
		System.out.println(p.getName()+""+p.getAge());

		ois.close();
	}
	public static void write()throws IOException{
		//写入对象数据 到Person.object
		ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("Person.object"));
		oos.writeObject(new Person("张三",15,"张角"));
		oos.writeObject(new Person("李四",50,"捏么"));

		oos.close();
	}
}

管道流:
PipedInputStream
PipedOutputStream
输入和输出可以直接进行连接,涉及到多线程


connect();连接流


集合中涉及到IO的是Properties
IO中涉及到多线程的是PipeInputStream,PipeOutputStream

/*
管道流 

PipeInputStream 
PipeOutputStream

演示 
connect() 连接流

  涉及到多线程
*/
import java.io.*;
class Demo2 
{
	public static void main(String[] args)throws Exception 
	{
		PipedInputStream pis=new PipedInputStream();
		PipedOutputStream pos=new PipedOutputStream();

		pis.connect(pos);

		new Thread(new Read(pis)).start();
		Thread.sleep(6000);
		new Thread(new Write(pos)).start();
	}
}
class Read implements Runnable
{
	private PipedInputStream pis;
	public Read(PipedInputStream pis)throws IOException{
		this.pis=pis;
	}
	public void run(){
		
		 try
		{
			byte []buf=new byte[1024];
			int len=0;
			while((len=pis.read(buf))!=-1){
				System.out.println(new String(buf,0,len));
			}
		}
		catch (IOException e)
		{
			System.out.println(e.getMessage());
		}finally
		{
			try
			{
				if(pis!=null)
				pis.close();	
			}
			catch (IOException e)
			{
				System.out.println(e.getMessage());
			}
		}
	}
}
class Write	implements Runnable
{
	private PipedOutputStream pos;
	public Write(PipedOutputStream pos){
		this.pos=pos;
	}
	public void run(){
		try
		{
			pos.write("我是管道流 我来le ".getBytes());

		}
		catch (IOException e)
		{
			System.out.println(e.getMessage());
		}finally
		{
			try
			{
				if(pos!=null)
				pos.close();	
			}
			catch (IOException e)
			{
				System.out.println(e.getMessage());
			}
		}
		
	}
}

RandomAccessFile类
随机访问文件的读取和写入


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


seek();//设置指针,前后都能跳
skipBytes();//跳过字节,只能往后跳


而且该对象的构造函数要操作的文件不存在会自动创建,如果存在则
不会覆盖,如果模式为r只读,不会创建文件,会去读取一个已存在的文件
如果该文件不存在,则会出现异常.如果模式为rw,文件不存在,会自动
创建,不会覆盖文件


可以实现数据的分段写入

/*
RandomAccessFile 类
getFilePointer();//获取指针
skipBytes();//跳过字节
seek(); 设置指针 

实现多线程分段输出
*/
import java.io.*;
class Demo3 
{
	public static void main(String[] args)throws Exception 
	{
		//读取
		RandomAccessFile raf=new RandomAccessFile("g.mp3","rw");
		//写入
		RandomAccessFile raf1=new RandomAccessFile("gg.mp3","rw");
		//三个线程进行分段写入
		//seek 设置指针位置 实现分段功能
		new Thread(new Thread1(raf,raf1,0)).start();

		new Thread(new Thread1(raf,raf1,2097152)).start();
		
		new Thread(new Thread1(raf,raf1,4194304)).start();
	}
}
//多线程
class Thread1 implements Runnable
{
	private RandomAccessFile raf;
	private RandomAccessFile raf1;
	private int skip;
	public Thread1(RandomAccessFile raf,RandomAccessFile raf1,int skip){
		this.raf=raf;
		this.raf1=raf1;
		this.skip=skip;
	}
	//run方法
	public void run(){
	   try
	   {
		   byte []buf=new byte[1024*1024*2];
		   int len=0;
			len=raf.read(buf);
			raf1.write(buf,0,len);
	   }
	   catch (IOException e)
	   {
		   System.out.println(e.getMessage());
	   }
	   finally
	   {
			try
			{
				if(raf!=null)
					raf.close();
				if(raf1!=null)
					raf1.close();
			}
			catch (IOException e)
		   {
			   System.out.println(e.getMessage());
		   }
	   }
	}
}

DataInputStream与DataOutputStream
可以用来操作基本数据类类型的流对象
//注意, 写入的UTF-8修改版, 正常UTF-8无法读取
writeUTF();
readUTF();

/*
DataInputStream
DataOutputStream
操作基本数据类型的流对象
*/
import java.io.*;
class Demo4 
{
	public static void main(String[] args)throws Exception 
	{	
		//write();
	   //read();
	   
	   DataOutputStream dos=new DataOutputStream(new FileOutputStream("utf.txt"));
	  	 //使用utf-7修改版写输入
		 dos.writeUTF("你好");
		 dos.close();
	   DataInputStream dis=new DataInputStream(new FileInputStream("utf.txt"));
		 /*
		 //不能使用默认GBK的编码读 会乱码
		 byte bu[]=new byte[10];
		 int len=dis.read(bu);
		 sop(new String(bu,0,len));
		 */
		 //只能使用ReadUTF才能读出来
		 sop(dis.readUTF());
		 dis.close();
	}
	public static void read()throws IOException{
		DataInputStream dis=new DataInputStream(new FileInputStream("type.txt"));
		//读的时候要按照写的顺序
		sop(dis.readBoolean());
		sop(dis.readByte());
		//等等
		dis.close();
	}
	public static void write()throws IOException{
				DataOutputStream dos=new DataOutputStream(new FileOutputStream("type.txt"));
//		 void writeBoolean(boolean v) 
//          将一个 boolean 值以 1-byte 值形式写入基础输出流。 
			dos.writeBoolean(true);
//		 void writeByte(int v) 
//          将一个 byte 值以 1-byte 值形式写出到基础输出流中。 
			 dos.writeByte(102);
//		void writeBytes(String s) 
//          将字符串按字节顺序写出到基础输出流中。
			dos.writeBytes("bytes");
//		void writeChar(int v) 
//          将一个 char 值以 2-byte 值形式写入基础输出流中，先写入高字节。 
			dos.writeChar(97);
//		void writeChars(String s) 
//          将字符串按字符顺序写入基础输出流。 
			dos.writeChars("chars");
//		void writeDouble(double v) 
//          使用 Double 类中的 doubleToLongBits 方法将 double 参数转换为一个 long 值，然后将该 long 值以 8-byte 值形式写入基础输出流中，先写入高字节。 
			dos.writeDouble(4454.12);
//		void writeFloat(float v) 
//          使用 Float 类中的 floatToIntBits 方法将 float 参数转换为一个 int 值，然后将该 int 值以 4-byte 值形式写入基础输出流中，先写入高字节。 
			dos.writeFloat(12.14f);
//		void writeInt(int v) 
//          将一个 int 值以 4-byte 值形式写入基础输出流中，先写入高字节。 
			dos.writeInt(12121);
//		void writeLong(long v)  
//   将一个 long 值以 8-byte 值形式写入基础输出流中，先写入高字节。
			dos.writeLong(4444444);
		dos.close();
	}
	public static void sop(Object o){
		System.out.println(o);
	}
}

字节数组流:
ByteArrayInputStream
在构造时需要接受数据源,数据源是一个字节数组
ByteArrayOutputStream
在构造时不用定义数据目的,因为该对象中内部已经封装了可变长度的字节数组


因为这两个对象操作的是数组,没有使用底层资源,所以不用进行close关闭
,不会抛任何IOException,除了writeTo(OutputStream);


toByteArray();//变成字节数组
size();//缓冲区大小
toString();//变成字符串形式
writeTo();//写出到字节输出流


设备:内存就是数组流


用流的读写思想操作数组,,

/*
ByteArrayInputStream
ByteArrayOutputStream

字节数组流

只要不使用WriteTo();
其他方法都不操作底层数据 不会发生异常
*/
import java.io.*;
class Demo5 
{
	public static void main(String[] args)
	{
		String s="不管还有多少明天";
		System.out.println("字节输入读取流\n");
		ByteArrayInputStream bis=new ByteArrayInputStream(s.getBytes());
		byte []bb=new byte[1024];
		int ch=0;
		while((ch=bis.read(bb,0,1024))!=-1){ //读取
			System.out.println(new String(bb,0,ch));
		}
		 System.out.println("\n字节数组写入流");
		ByteArrayOutputStream bos=new ByteArrayOutputStream();
		bos.write(12); //写入字节
		bos.write(5);
		bos.write(56);
		byte []bu=bos.toByteArray();//转成字节数组
		for (byte b : bu )
		{
			System.out.println(b);
		}
		System.out.println(bos.size());//获取缓冲区大小
	}
}

字符数组流:
CharArrayInputStream与CharArrayInputStream


字符串流:
StringReader与StringWriter


字符编码:
常见的编码表:
ASCII:美国标准信息交换码  一个字节7位表示
ISO8859-1:拉丁码表,欧洲码表  一个字节8位表示 最高位1
GB2312中国的中文编码表,两个字节表示 每个字节最高位1
GBK 中国的编码表升级,融合了更多的中文字符等
Unicode:国际标准码表,融合了多种文字,所有文字都有两个字节表示,
java使用的就是Unicode,  char字符
UTF-8:最多用三个字节表示


编码:字符串变成字节数组
str.getBytes();//可以指定编码
解码:字节数组变成字符串
new String();//构造时可以指定编码


例如:
String s="你好";
byte []b=s.getBytes("GBK");


如果指定的编码不存在会报UnsupportedEncodingException 不支持的编码异常


乱码,编一次,解一次


UTF-8标识头,标识一开始读几个字节,最多三个
一个字节:0
两个字节:110 0
三个字节:1110 10 10

/*
字符编码

编码 

解码
*/
import java.io.*;
import java.util.*;
class Demo6 
{
	public static void main(String[] args)throws Exception 
	{  /*
		String s="你好";
		byte []b=s.getBytes();
		byte []b1=s.getBytes("gbk");
		byte []b2=s.getBytes("iso8859-1");
		byte []b3=s.getBytes("utf-8");
		sop(Arrays.toString(b));
		//使用编码会引发UnsupportedEncodingException
				System.out.println("\n b的多种解码格式 \n");
		sop(new String(b));
		sop(new String(b,"gbk"));
		sop(new String(b,"utf-8"));	//no  ???
		sop(new String(b,"iso8859-1"));//no	 ????




	  		System.out.println("\n b1的多种解码格式 \n");
		sop(new String(b1));   
		sop(new String(b1,"gbk"));
		sop(new String(b1,"utf-8"));  //no ???
		sop(new String(b1,"iso8859-1"));//no  ????
	   		System.out.println("\n b2的多种解码格式 \n");
		sop(new String(b2));	//no ??
		sop(new String(b2,"gbk")); //no  ??
		sop(new String(b2,"utf-8"));//no ??
		sop(new String(b2,"iso8859-1"));//no ??
		System.out.println("\n b3的多种解码格式 \n");
		sop(new String(b3));	// no 浣犲ソ 
		sop(new String(b3,"gbk"));// no 浣犲ソ
		sop(new String(b3,"utf-8"));
		sop(new String(b3,"iso8859-1"));//no ??????
		*/
		/*
	
	
	
		默认字符串编码是gbk 使用的是系统默认的
		*/
		/*
		String s="你好";
		byte []b=s.getBytes("gbk");
		String str=new String(b,"utf-8");
		sop(str); // ??? 
		byte bb[]=str.getBytes("utf-8");
		sop(new String(bb,"gbk"));//锟斤拷锟?
		*/
		/*	*/
		 String s="你好";
		byte []b=s.getBytes("utf-8");
		String str=new String(b,"gbk");
		sop(str);	 // 浣犲ソ
		//在编一次,在解一次
		byte bb[]=str.getBytes("gbk");
		sop(new String(bb,"utf-8"));  //你好
		
		/*
		String s="你好";
		byte []b=s.getBytes("iso8859-1");
		String str=new String(b,"utf-8");
		sop(str); // ??
		byte bb[]=str.getBytes("utf-8");
		sop(new String(bb,"iso8859-1"));//??
		*/
	}
	public static void sop(Object o){
		System.out.println(o);
	}
}

/*
练习题
*/

/*
练习

有五个学生,每个学生都有三门成绩

键盘录入
格式:张三,40,50,60
计算他们的总成绩, 按总分高低排序输出到stu.txt
*/
import java.util.*;
import java.io.*;
class Demo7 
{
	public static void main(String[] args)throws Exception 
	{	
	//反转比较器	
	Comparator<Student> cmp=Collections.reverseOrder();
		  //获取集合
		 TreeSet<Student> ts=set(cmp);
		toText(ts);	
	}
	//将数据录入存储到集合 不使用比较器
	public static TreeSet<Student> set()throws Exception{
		return set(null);
	}
	//将数据录入存储到集合 使用比较器
	public static TreeSet<Student> set(Comparator<Student> cmp)throws Exception{
		TreeSet<Student> ts=new TreeSet<Student>();
		if(cmp!=null)
			  ts=new TreeSet<Student>(cmp);
			
		//反转比较器 进行排序 Collection.reverseOrder()
		 BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		 String line=null;
		 while((line=br.readLine())!=null){
			 if("over".equals(line))
				 break;
			 String info[]=line.split(",");
		    ts.add(new Student(info[0],new Integer(info[1]),new Integer(info[2]),new Integer(info[3])));
		 }
		br.close();

		return ts;
	}
	//写到硬盘文件 stud.txt
	public static void toText(TreeSet<Student> ts)throws IOException{
		//写入流
		PrintWriter pw=new PrintWriter(new FileOutputStream("stud.txt"));
		 Iterator<Student> it=ts.iterator();
		 while(it.hasNext()){
		 	Student s=it.next();
			pw.println(s.toString());//目的是流 所以自动刷新
		 }

		 pw.close();
	}
}
//学生类,自身具备成绩比较性
class Student implements Comparable<Student>
{
	private String name;  //姓名
	private int Yuwen;	  //语文
	private int Shuxue;	 //数学
	private int Yingyu;	 //英语
	private int sum;  //总分
	public void setName(String name){
		this.name=name;
	}
	public String getName(){
		return name;
	}
	public void setYuwen(int Yuwen){
		this.Yuwen=Yuwen;
	}
	public int getYuwen(){
		return Yuwen;
	}
	public void setShuxue(int Shuxue){
		 this.Shuxue=Shuxue;
	}
	public int getShuxue(){
	   return Shuxue;
	}
	public void setYingyu(int Yingyu){
		this.Yingyu=Yingyu;
	}
	public int getYingyu(){
		return Yingyu;
	}
	public int getSum(){
		 return Yuwen+Shuxue+Yingyu;
	}
	//构造函数
	public Student(String name, int Yuwen, int Shuxue, int Yingyu){
		this.name=name;
		this.Yuwen=Yuwen;
		this.Shuxue=Shuxue;
		this.Yingyu=Yingyu;
	}
	//复写 ｈａｓｈＣｏｄｅ
	public int hashCode(){
		return (this.getName().hashCode())+(getSum()*13);
	}
	//复写 equals
	public boolean equals(Object obj){
	   if(! (obj instanceof Student))
		   throw new ClassCastException("类型转换异常");

	   Student s=(Student)obj;
	   return (this.getName().equals(s.getName()))&&this.getSum()==s.getSum();
	}
	//复写compareTo
	public int compareTo(Student s){
		int num=new Integer(this.getSum()).compareTo(new Integer(s.getSum()));
		if(num==0)
			return	this.getName().compareTo(s.getName());
			return num;
	}
	//复写
	public String toString(){
		return "Student["+name+" "+Yuwen+" "+Shuxue+" "+Yingyu+" "+getSum()+" ]";
	}
}

/*
lisi,10,20,30
wanwu,50,60,40
zhaoliu,100,50,60
wangwu,45,78,32
woziji,100,100,99
*/

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