黑马程序员——IO流（其他流）



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

一、

ObjectInputStream 和 ObjectOutputStream

对象存储在堆内存中，当使用完了就会被当做垃圾回收，对象就不存在了
可以通过流的方式将堆内存对象存储在硬盘上，即使程序结束，
对象也不会消失，想要使用时，直接读取存储对象的文件即可

这种方式被称为对象的序列化

操作对象
 ObjectInputStream与ObjectOutputStream
  被操作的对象需要实现Serializable（标记接口）

ObjectOutputStream 将 Java 对象的基本数据类型和图形写入 OutputStream。
可以使用 ObjectInputStream 读取（重构）对象。

构造方法：ObjectOutputStream(OutputStream out)
          创建写入指定 OutputStream 的 ObjectOutputStream。

方法：writeObject(Object obj) 将指定的对象写入 ObjectOutputStream。
   当要序列化的对象不能实现java.io.Serializable 接口。
   方法抛出NotSerializableException

Serializable：类通过实现 java.io.Serializable 接口以启用其序列化功能。
     未实现此接口的类将无法使其任何状态序列化或反序列化。
     可序列化类的所有子类型本身都是可序列化的。
     序列化接口没有方法或字段，仅用于标识可序列化的语义。

ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化。

//将一个对象写入到一个文件中
 public static void writeObj()throws IOException
 {      //所存储对象的文件一般不存成.txt，这里应该存成 Person.Object
  ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.txt"));

  oos.writeObject(new Person("lisi",39));//调用写对象方法（已建立好的Person类）
  

  oos.close();
 }

 //将写入文件的对象读出来
 public static void readObj()throws Exception
 {
  ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));

  //调用读对象方法，返回值类型是Object，因为对象是Person，返回值类型可以直接写Person
  Person p = (Person)ois.readObject();//需要强制转换成类类型
  //此方法抛出 ClassNotFoundException（类没有找到异常）
  System.out.println(p);
  ois.close();
 }

二、

DataInputStream 和 DataOutputStream

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

DataOutputStream:
 writeUTF(String str)
          以与机器无关方式使用 UTF-8 修改版编码将一个字符串写入基础输出流。
DataInputStream:
 readUTF(DataInput in)
          从流 in 中读取用 UTF-8 修改版格式编码的 Unicode 字符格式的字符串；然后以 String 形式返回此字符串。
    抛出：EOFException - 如果此输入流在读取所有字节之前到达末尾。

public static void writeUTFDemo()throws IOException
 {
  DataOutputStream dos = new DataOutputStream(new FileOutputStream("utfdata.txt"));
  dos.writeUTF("你好");
  dos.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 writeData()throws IOException
 {
  DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));

  //直接操作基本数据类型
  dos.writeInt(234);
  dos.writeBoolean(true);
  dos.writeDouble(9887.543);

  dos.close();
 }
 
 public static void readData()throws IOException
 {
  DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
  
  //读取时要按顺序读取
  int i = dis.readInt();
  boolean b = dis.readBoolean();
  double d = dis.readDouble();

  System.out.println("i="+i);
  System.out.println("b="+b);
  System.out.println("d="+d);

  dis.close();
 }

三、

PrintStream 和 PrintWriter

打印流：
该流提供了打印方法，可以将各种数据类型的数据原样打印

字节打印流：
PrintStream
构造函数可以接收的参数类型：
1，file对象。File
2，字符窜路径。String
3，字节输出流。OutputStream

字符打印流：
PrintWriter
1，file对象。File
2，字符窜路径。String
3，字节输出流。OutputStream
4，字符输出流。writer

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); //写入到文件       
  PrintWriter out = new PrintWriter(System.out,true);//定义一个打印流，输出在控制台上
  String line = null;     //此处用true下面就不用flush刷新，只有println，printf，format刷新缓冲区
  while((line=bufr.readLine())!=null)
  {
   if("over".equals(line))
    break;
   out.println(line.toUpperCase());//打印流的输出方法
   out.flush();
  }
  out.close();
  bufr.close();
 }

四、

PipedInputStream 和 PipedOutputStream

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

通常，数据由某个线程从 PipedInputStream 对象读取，
并由其他线程将其写入到相应的 PipedOutputStream。
不建议对这两个对象尝试使用单个线程，因为这样可能死锁线程。

//管道输入流线程
class Read implements Runnable
{
 private PipedInputStream in;
 Read(PipedInputStream in)
 {
  this.in = in;
 }
 public void run()
 {
  try
  {
   //管道流读数据
   byte[] buf = new byte[1024];
   int len = in.read(buf);
   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
  {
   //管道流写数据
   out.write("piped lai la".getBytes());
   out.close();
  }
  catch (IOException e)
  {
   throw new RuntimeException("写出失败！");
  }
 }
}

五、

ByteArrayInputStream 和 ByteArrayOutputStream

操作字节数组的流对象
 ByteArrayInputStream和ByteArrayOutputStream

ByteArrayInputStream:
 ByteArrayInputStream 包含一个内部缓冲区，该缓冲区包含从流中读取的字节。内部计数器跟踪 read 方法要提供的下一个字节。
 关闭 ByteArrayInputStream 无效。此类中的方法在关闭此流后仍可被调用，而不会产生任何 IOException。
 在构造的时候，需要接受数据源，而且数据源是一个字节数组
ByteArrayOutputStream:
 此类实现了一个输出流，其中的数据被写入一个 byte 数组。缓冲区会随着数据的不断写入而自动增长。可使用 toByteArray() 和 toString() 获取数据。
 关闭 ByteArrayOutputStream 无效。此类中的方法在关闭此流后仍可被调用，而不会产生任何 IOException。
 在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数组，这就是数据的目的地

因为这两个流对象都操作的是数组，并没有使用体统资源，所以，不用进行close关闭

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

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

同理：
操作字符数组：
 CharArrayReader  CharArrayWriter
操作字符串：
 StringReader  StringWriter

public static void main(String[] args)
 {
  //数据源          //此处接受的是字节数组
  ByteArrayInputStream bis = new ByteArrayInputStream("abcdefg".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());
 }

六、

SequenceInputStream

序列流：SequenceInputStream对多个流进行合并

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

就是将多个流对象拼成一个流对象

需求：将三个文件复制到一个文件中
用SequenceInputStream将三个文件合并，再写入另一个文件

public static void main(String[] args) throws IOException
 {
  Vector<FileInputStream> v = new Vector<FileInputStream>();
  //使用集合Vector将三个流对象添加进去
  v.add(new FileInputStream("1.txt"));
  v.add(new FileInputStream("2.txt"));
  v.add(new FileInputStream("3.txt"));
  Enumeration<FileInputStream> en = v.elements();
  //构造函数接受Enumeration，集合中只有Vector使用Enumeration
  SequenceInputStream sis = new SequenceInputStream(en);

  //上面代码既实现了多个流的合并，形成了一个流对象，下面用输出流将其写入文件
  FileOutputStream fos = new FileOutputStream("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();
 }

七、

字符编码

字符编码
 字符流的出现为了方便操作字符
 更重要的是加入了编码转换
 通过子类转换流来完成
  InputStreamReader
  OutputStreamWriter
 在两个对象进行构造的时候可以加入字符集
编码表的由来
 计算机只能识别二进制数据，早期由来是电信号
 为了方便应用计算机让它可以识别各个国家的文字
 就将各个国家的文字用数字来表示，并一一对应，形成一张表
 这就是编码表
常见的编码表
 ASCII：美国标准信息交换码
  用一个字节的7位可以表示
 ISO8859-1：拉丁码表，欧洲码表
  用一个字节的8位表示
 GB2312:中国的中文编码表
 GBK：中国的中文编码表升级，融合更多的中文文字符号
 Unicode：国际标准码，融合了多种文字
  所有文字都用两个字节来表示，java语言使用的就是Unicode
 UTF-8：最多用三个字节来表示一个字符

/*
编码：字符串变成字节数组
 String-->byte[]:str.getBytes(charseName);

解码：字节数组变成字符串
 byte[]-->String:new String(byte[].charseName);

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

  //编码。默认情况下是GBK
  byte[] b = s.getBytes("GBK");//UnsupportedEncodingException抛出异常
  System.out.println(Arrays.toString(b));//打印编码对应的数
  //解码，就是将字符数组变成字符串
  String s1 = new String(b,"GBK");
  System.out.println("s="+s);
 }
 public static void demo_2()throws Exception
 {
  String s = "你好";
  //按照GBK进行编码
  byte[] b1 = s.getBytes("GBK");
  System.out.println(Arrays.toString(b1));
  //按照ISO8859-1解码，解码错误，会出现乱码
  String s1 = new String(b1,"ISO8859-1");
  System.out.println("s1="+s1);
  //出现乱码就要解决：将得到的乱码再进行编码
  byte[] b2 = s1.getBytes("ISO8859-1");
  System.out.println(Arrays.toString(b2));
  //然后再按照GBK解码，就能得到原来的数据
  String s2 = new String(b2,"GBK");
  System.out.println("s2="+s2);

//上诉方法对于出现乱码的解决是通用的，但当解码错误时，是按照UTF-8解的码
//就不能使用一上面的方法，因为GBK和UTF-8都识别中文，所以用上诉方法还是会出现乱码
//Tomcat服务器默认使用的是ISO8859-1编码表
 }
}

/*
新建一个记事本文件，写入'联通'，保存在打开以后发现出现了乱码，
这是因为解码时出现了问题，当存储的时候是按照GBK来存储的，
再次打开时，记事本软件是按照UTF-8来解码的，所以出现了乱码
那么为什么会出现这种现象呢？

UTF-8的码表从最低一个字节表示一个字符到最高三个字节表示一个字符
当它解码时怎么确定这一个字符是几个字节表示的呢？

怎么确定此时是读一个字节、两个字节还是三个字节，来返回这个字符呢？
GBK用两个字节代表一个字符，而UTF-8最高用三个字节来代表一个字符
当解码时，UTF-8有它自己的编码标志，符合这一标志，记事本就自动按照
UTF-8来解得码，那么UTF-8的编码是什么样的呢？

Utf-8的码表其实对它的字节都加了标识头信息，用此信息就能识别
解码时是读一个、两个还是三个字节

'\u0001' 到 '\u007F' 范围内的所有字符都是用单个字节表示的：

         位值
字节 1   0    位 6-0
 

null 字符 '\u0000' 以及从 '\u0080' 到 '\u07FF' 的范围内的字符用两个字节表示：

         位值
字节 1   1 1 0   位 10-6
 
字节 2   1 0     位 5-0
 

'\u0800' 到 '\uFFFF' 范围内的 char 值用三个字节表示：
         位值
字节 1   1 1 1 0   位 15-12
 
字节 2   1 0       位 11-6
 
字节 3   1 0       位 5-0
 
想要解决这个问题很简单，只要“联通”前面还有别的文字就可以了

*/
class  EncodeDemo2
{
 public static void main(String[] args) throws Exception
 {
  String s = "联通";
  byte[] by = s.getBytes("GBK");//编码
  for(byte b : by)
  {
   //打印编码是得到的每个字节的十进制数
   //System.out.println(b);
   //打印结果：-63 -86 -51 -88
   //用二进制打印一下,保留最低八位，&255
   System.out.println(Integer.toBinaryString(b&255));
            /*打印结果：11000001  打印结果显示“联通”所对应的二进制数
                        10101010  正好和UTF-8的编码标识头对应上了，所以
      11001101  在解码的时候，记事本就按照UTF-8码表了
      10101000*/
  }
 }
}