day21对象流。管道流。RandomAccessFile。DataStream。字节流。常见的编码表。编码解码。联通问题。

/*
对象流。管道流。RandomAccessFile。DataStream。字节流。常见的编码表。编码解码。联通问题。
*/

/*
ObjectOutputStream:直接操作对象的流。
对象本身存在堆内存中，用流的方式将这个对象存到硬盘上。这叫对象的持久化。
Serializable:序列化的对象才能使用。没有方法的接口，称为标记接口。
序列化的原理就是产生了一个uid.这个uid是根据类中不同的成员算出来的。
静态不能被序列化，原理：静态在方法区，序列化在堆里。
当类改动private,要重新写，才能读。因为一个新的class有新的序列号。
非静态的我们不想被序列化，加上关键字transient。
*/
import java.io.*;
class  ObjectStream
{
public static void main(String[] args) throws Exception
{
//writeObj();
readObj();
}
public static void writeObj()throws Exception
{
ObjectOutputStream oos =
new ObjectOutputStream(new FileOutputStream("obj.txt"));
oos.writeObject(new Person("wangwu",49,"kr"));
oos.close();
}
public static void readObj()throws Exception
{
ObjectInputStream ois =
new ObjectInputStream(new FileInputStream("obj.txt"));
Person p = (Person) ois.readObject();//会抛出类没有找到异常。
System.out.println(p);
ois.close();
}
}
import java.io.*;
class Person  implements Serializable//实现是为了序列化
{
//public static final long serialVersionUID = 42L;自己定义uid，改动后也能操作。
String name;
transient int age;//transient修饰后不能被序列化
Static String country ="cn";//static 静态不能被序列化，写不进去。
Person(String name,int age,String country)
{
this.name = name;
this.age = age;
this.country = country;
}
public String toString()
{
return name +":"+ age+":"+country;
}
}

//PipedStream:管道流//用自己的管道，这个流的特点是先写入，再读。
import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

public class PipedStreamDemo {
public static void main(String[] args) throws IOException
{
PipedInputStream pis = new PipedInputStream();
PipedOutputStream pos = new PipedOutputStream();
pos.connect(pis);//二个管道连起来。
Read r = new Read(pis);
Write w = new Write(pos);
new Thread(r).start();
new Thread(w).start();
}
}
class Read implements Runnable
{
private PipedInputStream pis;
Read(PipedInputStream pis)
{
this.pis = pis;
}
public void run()
{
byte[] buf = new byte[1024];
int num = 0;
try {
System.out.println("读取前等待");
num = pis.read(buf);//阻塞式的方法。
System.out.println("读取后。。。");
} catch (IOException e) {
throw new RuntimeException("piped读取失败");
}
System.out.println(new String(buf,0,num));
}
}

class Write implements Runnable
{
private PipedOutputStream pos;
Write(PipedOutputStream pos)
{
this.pos = pos;
}
public void run() {
try {
System.out.println("写入前等待");
Thread.sleep(6000);
pos.write("Piped lai le".getBytes());
} catch (Exception e) {
throw new RuntimeException("piped写入失败");
}
}
}

/*
RandomAccessFile，一个对象里面有读和写二个功能。
该类不是IO体系中子类。而是直接继承自Object

但是它是IO包中成员，因为它具备读和写功能。
内部封装了一个数组，而且通过指针对数组的元素进行操作。
可以通过getFilePointer获取指针位置
同时可以通过seek改变指针的位置。很重要！！！！！
其实完成读写的原理就是内部封装了字节输入流和输出流。

通过构造函数发现该类只能操作文件。还要传入模式。只读r,读写rw等。
而且该对象的构造函数要操作的文件不存在，创建，如果存在，不会覆盖。
*/
import java.io.*;
class RandomAccessFileDemo
{
public static void main(String[] args) throws IOException
{
//ranWrite();
//ranReader();
ranWrite2();
}

public static void ranWrite2()throws IOException//随机向里写。比喻迅雷
{
RandomAccessFile raf = new RandomAccessFile("acc.txt","rw");//rw可以读写。

raf.seek(8*4);//随机读写，还能从指定位置覆盖原来的。
raf.write("一啊".getBytes());
raf.writeInt(99);
raf.seek(8*4);

raf.close();
}

public static void ranReader()throws IOException
{
RandomAccessFile raf = new RandomAccessFile("acc.txt","r");
//raf.write("haha".getBytes());构造函数传入r，就不能写。

raf.seek(8*1);//指针，前后都能指。
//raf.skipBytes(8*1);//跳过，指针不能向回走，只能向下走。

byte[] buf = new byte[4];
raf.read(buf);
String name = new String(buf);
int age = raf.readInt();//一次读32位。

System.out.println("name=" + name);
System.out.println("age=" + age);
raf.close();
}

public static void ranWrite()throws IOException
{
RandomAccessFile raf = new RandomAccessFile("acc.txt","rw");
raf.write("小啊".getBytes());
raf.writeInt(99);//write,写入最低八位，一个字节。//writeInt写入32位。
//write写258，就会出错。
raf.write("二啊".getBytes());
raf.writeInt(90);//写四个字节

raf.close();
}
}
/*
DataStream:可以用于操作基本数据类型的数据的流对象。
DataInputStream和DataOutputStream.
DataOutputStream的构造函数要传入一个OutputStream.
*/

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class DataStreamDemo {

public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
//dataWrite();
//dataRead();
//writeUTF();//好像是修改版的UTF-8
//readUTF();
OutputStreamWriter os = new OutputStreamWriter(
new FileOutputStream("data.txt"),"UTF-8");//writeUTF()，类似转换流写入
os.write("你好");
os.close();
}
public static void readUTF() throws IOException
{
DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
String s = dis.readUTF();
System.out.println(s);
}
public static void writeUTF() throws IOException
{
DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
dos.writeUTF("你好");
dos.close();
}
public static void dataRead() 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);
}
public static void dataWrite() throws IOException
{
DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
dos.writeInt(23);
dos.writeBoolean(true);
dos.writeDouble(889.35);
dos.close();
}
}

/*
直接操作字节数组

ByteArrayInputStream。一建立对象就要有数据源。构造函数要传入字节数组。

ByteArrayOutputStream.在构造时不用定义数据目的，因为该对象内部已经封装了一个
可变长度的数组。这就是数据目的地。
writeTo(OutputStream),特有方法，只有它有异常。

因为这二个流对象都是操作数组，并没有使用系统资源。
不需要关闭。而且关闭后还可以用，不会报IO异常。

在流操作规律讲解时：
源设备：
键盘System.in，硬盘FileStream，内存ArrayStream
目的设备：
控制台System.out，硬盘FileStream，内存ArrayStream

用流的读写思想来操作数组。

类似的类：
CharArrayReader和CharArrayWriter,StringReader和StringWriter
*/
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileOutputStream;

public class ByteArrayStreamDemo {

public static void main(String[] args) {
// 可以改变源，获取数据
ByteArrayInputStream bis = new ByteArrayInputStream("ABCDEFGHIJKLMN".getBytes());

ByteArrayOutputStream bos = new ByteArrayOutputStream();
//bos.writeTo(new FileOutputStream("byte.txt"));//把文件一次性的写出。
int ch = 0;
while((ch=bis.read())!=-1)
{
bos.write(ch);//写入内部封装的数组
}
System.out.println(bos.size());
System.out.println(bos);
}
}

/*
常见的编码表：
ASCII：美国标准信息交换码，用一个字节的七位可以表示。
ISO8859-1：拉丁码表。欧洲码表。用一个字节的八位表示。
GB2312：中国的中文编码表。二个字节代表一个文字，高位都是1。
GBK：中国的中文编码表升级，融合了更多的中文和符号。
Unicode：国际标准码，融合了多种文字。
所有文字都用二个字节来表示，java语言就用它。
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"),"UTF-8");

char buf[] = new char[10]; //这里是字符。
int len = isr.read(buf);

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

System.out.println(str);
}
public static void writeText()throws IOException
{
OutputStreamWriter osw = //默认是GBK编码
new OutputStreamWriter(new FileOutputStream("utf.txt"),"UTF-8");

osw.write("你好");
osw.close();
}
}
/*
编码：字符串变成字节数组
String-->byte[],getBytes()。

解码：字节数组变成字符串。
byte[]-->String,new String()的构造函数。

其他码，使用ISO8859-1解码错误,就再按照ISO8859-1编码回去byte[],
再按照怎么编码，就怎么解码。

假如使用GBK编码，使用UTF-8解码错误，但是再用UTF-8就编码不回去。
因为都用负数代表中文。
*/

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class CodeDemo {

public static void main(String[] args) throws UnsupportedEncodingException {

String s = "你好";
byte[] b1 = s.getBytes("UTF-8");//这里是编码
String s1 = new String(b1,"ISO8859-1");//这里解码错误
System.out.println(s1);
System.out.println("这里是怎么编码的"+Arrays.toString(b1));//这里是怎么编码的。

byte[] b2 = s1.getBytes("ISO8859-1");//再编码回去
System.out.println("错误解码编回来的"+Arrays.toString(b2));
String s2 = new String(b2,"UTF-8");//怎么编码，就怎么解码

System.out.println(s2);
}
}
/*
记事本存"联通",默认使用GBK。再打开怎么就没了呢？就这二个字比较特殊。
联通的后八位：11000001-10101010.刚好符合U8的规律。
怎么解决。在前面加一个不是符合U8的汉字，加英文还是不行的，因为还符合U8。
byte[] b = "联通".getBytes();
for(int x = 0;x<b.length;x++)
{
System.out.println(Integer.toBinaryString((b[x])&255));
}

GBK：二个字节代表一个汉字。
UTF-8：三个字节代表一个汉字。其他的字占几位就用几位存。
标识头信息:一个字节的话。第一个为0
二个字节：第一个为110，第二个字节为10开头
三个字节：字节1用1110开头，字节2用10开头，字节3用10开头。
*/

/*
练习：
定义一个学生类，有属性，名字，数学，语文，英语，总分。
在键盘录入：名字，数学，语文，英语
把这个学生按总分成绩存入一个文件中。
*/
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 stu)
{
int num = new Integer(this.sum).compareTo(new Integer(stu.sum));
if (num == 0)
{
return this.name.compareTo(stu.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("infostu.txt"));
for (Student s:stus )
{
bufw.write(s.toString()+"\t");
bufw.write(s.getSum()+"");
bufw.newLine();
bufw.flush();
}
bufw.close();
}
}
public class StudentDemo2
{
public static void main(String[] args) throws IOException
{
Comparator cmp = Collections.reverseOrder();//反转比较器

Set<Student> stus = StudentInfoTool.getStudents(cmp);
StudentInfoTool.write2File(stus);
}
}