java学习笔记（二十九）java中的i/o流

1.LineNumberReader：可以获取行号的i/o流

  public int getLineNumber():获取行号
  public void setLineNumber(int lineNumber):设置起始行号
  String readLine()：读取一行

练习：读取文件，每次读取一行打印并且加上行号

public class LineNumberReaderDemo {
    public static void main(String[] args) throws IOException {
        //创建LineNumberReader对象
        //public LineNumberReader(Reader in)
        LineNumberReader lnr = new LineNumberReader(new FileReader("a.txt"));

        //默认起始行号从0开始
        //设置其实行号为从10开始
        lnr.setLineNumber(10);

        //一次读取一行
        String line;
        while ((line = lnr.readLine())!=null) {
            //打印每一行的行号和内容
        System.out.println(lnr.getLineNumber()+":"+line);
        }
        //关流
        lnr.close();
    }
}
/*结果：   11:hello
          12:world
          13:java*/

2.操作基本数据类型的流
DataInputStream:读数据
DataOutputStream:写数据
练习：给流中写基本类型的数据，并且读取

public class DataOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        //写数据
        //write();
        read();
    }
    private static void read() throws IOException {
        //DataInputStream:读数据
        //创建对象：public DataInputStream(InputStream in)
        DataInputStream dis = new DataInputStream(new FileInputStream("dos.txt"));
        //读数据了,按什么顺序写入就必须按照什么顺序读出来
        System.out.println(dis.readByte());
        System.out.println(dis.readShort());
        System.out.println(dis.readInt());
        System.out.println(dis.readLong());
        System.out.println(dis.readChar());
        System.out.println(dis.readFloat());
        System.out.println(dis.readDouble());
        System.out.println(dis.readBoolean());

        //关流
        dis.close();
    }
    private static void write() throws IOException {
        //public DataOutputStream(OutputStream out)
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("dos.txt"));
        //给流关联的文件中写入基本类型的数据
        dos.writeByte(20);
        dos.writeShort(200);
        dos.writeInt(2000);
        dos.writeLong(20000L);
        dos.writeChar(97);
        dos.writeFloat(12.34F);
        dos.writeDouble(23.34);
        dos.writeBoolean(true); 
        //关流
        dos.close();
    }
}

注意：按什么顺序写的就要按什么顺序读，不然会出现错误

3.内存操作流：解决临时数据存储的问题。
操作字节数组
ByteArrayInputStream
ByteArrayOutputStream

 byte[] toByteArray() 将之前写入内存的流转换成字节数组

public class ByteArrayOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        //给内存中写数据public ByteArrayOutputStream()
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        //给内存中调用方法写数据
        baos.write("hello".getBytes());
        //将写入内存中的数据读取出来
        byte[] buf = baos.toByteArray();//调用这个方法，将之前写入内存中的数据存储到字节数组中
        ByteArrayInputStream bais = new ByteArrayInputStream(buf);//将刚才存储到字节数组中的内容关联上bais
        //只有这样之后，我们才可以直接从bais中读取我们想要的内容
        //一次读取一个字节
        int by;
        while ((by=bais.read())!=-1) {
            System.out.print((char)by);
        }
        //关流
        bais.close();
        baos.close();
    }
}
结果：/*hello*/

1. 打印流：
   字节打印流 PrintStream
   字符打印流 PrintWriter

   特点：

   A:只能操作目的地，不能操作数据源
   B:可以操作任意类型的数据
   C:如果启动了自动刷新，能够自动刷新
   D:可以操作文件的流
       注意：什么流可以直接操作文件？
       看流对象的API,如果其构造方法同时有File和String类型的参数，就可以直接操作文件。
   

public class PrintWriterDemo2 {
    public static void main(String[] args) throws IOException {
        //创建打印流并开启自动刷新
        PrintWriter pw = new PrintWriter(new FileWriter("d.txt"), true);
        //调用print,println,format实现自动刷新
        pw.print("hello");
        pw.print("word");
        pw.println("java");
        pw.println(true);
        pw.close();

    }

}
/*结果：hellowordjava
true*/

5.标准输入输出流
System类下有这样的两个成员变量：

标准输入流：
public static final InputStream in
练习：用IO流实现键盘录入，一次读取一行数据
分析：
InputStream is = System.in;
BufferedReader是字符缓冲流，是对字符流进行高效操作的
所以，参数必须是字符类型
而我们现在有的是字节类型的流
请问：怎么办呢?转换流

public class SystemInDemo2 {
    public static void main(String[] args) throws IOException {
        InputStream in = System.in;
        InputStreamReader isp = new InputStreamReader(in);
        BufferedReader br = new BufferedReader(isp);
        System.out.println("请输入你的名字");
        String name = br.readLine();
        System.out.println("请输入你的年龄");
        String age = br.readLine();
        System.out.println(name+" "+age);
        //关流
        br.close();
        in.close();
        isp.close();
    }

}

6.合并流：SequenceInputStream类可以将多个输入流串流在一起，合并为一个输入流，因此，该流也被称为合并流。
构造：

   SequenceInputStream(InputStream s1, InputStream s2) ：将s1和s2合并成一个输入流，先读取s1后读取s2

练习：把DataStreamDemo.java和ByteArrayStreamDemo.java写到一个文件Copy.java

public class SequenceInputStreamDemo {
    public static void main(String[] args) throws IOException {
        //创建一个合并流，关联两个输入流
        SequenceInputStream sis = new SequenceInputStream(new FileInputStream("c.java"), new FileInputStream("LineNumberReaderDemo.java"));
        //创建一个字节输出流
        FileOutputStream fos = new FileOutputStream("copy.java");
        //读和写
        byte[] by=new byte[1024];
        int len;
        while ((len=sis.read(by))!=-1) {
            fos.write(by, 0, len);
        }
        //关流
        fos.close();
        sis.close();
    }

}

1. 对象的序列化和反序列化
   序列化流：把对象按照流一样的方式写到文件或者在网络中传输。
   反序列化流：把文件或者网络中的流对象数据还原对象。

   ObjectOutputStream：序列化流

      writeObject(Object obj) 将指定的对象写入 
   

   ObjectInputStream：反序列化流

      Object readObject() 从 ObjectInputStream 读取对象。 
   

   注意：如果一个类不是实现Serializable接口无法把实例化，会报异常java.io.NotSerializableException
   类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。

   如何实现序列化?
   让对象所属类的实现序列化接口。

2. Properties（本质是一个map集合）
   9.1 Properties:Properties 类表示了一个持久的属性集。属性列表中每个键及其对应值都是一个字符串。
   特点：Properties 可保存在流中或从流中加载
   9.2Properties的特有功能：

   A:添加元素
       public Object setProperty(String key,String value)
   B:获取元素
       public String getProperty(String key)
       public Set<String> stringPropertyNames()
   

   练习：使用它的特有功能添加元素并遍历

public class ProPertiesDemo1 {
    public static void main(String[] args) {
        //创建集合
        Properties popr = new Properties();
        //添加元素
        popr.setProperty("zhangsan", "17");
        popr.setProperty("lisi", "23");
        popr.setProperty("wangwu", "25");
        //获取建的集合
        Set<String> spn = popr.stringPropertyNames();
        //遍历集合
        for (String string : spn) {
            System.out.println(string+" "+popr.getProperty(string));    
        }
    }
}
/*结果：
zhangsan 17
lisi 23
wangwu 25*/

9.3
可以和IO流进行结合使用：
把文件中的数据加载到集合中。注意：文件中的数据必须是键值对象形式的（例如：张杰=谢娜）

    public void load(InputStream inStream)
    public void load(Reader reader)

练习：创建一个键值对文件，将文件中的键值对加载到集合中，输出集合

public class PropertiesDemo3 {
    public static void main(String[] args) throws IOException {
        //创建集合
        Properties prop = new Properties();

        //将文件中的键值对，加载到集合中
        prop.load(new FileReader("prop.txt"));

        //遍历集合
        Set<String> keys = prop.stringPropertyNames();
        for (String key : keys) {
            System.out.println(key+":"+prop.getProperty(key));
        }   
    }
}
/*结果：
liming:60
liudehua:40
guodegang:50*/

把集合中的数据存储到文本文件中，并且是按照键值对形式存储的。

    public void store(OutputStream out,String comments)
    public void store(Writer writer,String comments)

练习：将创建的键值对集合加载到文件中

public class PropertiesDemo4 {
    public static void main(String[] args) throws IOException {
        //创建集合
        Properties prop = new Properties();

        //给集合中存储数据
        prop.setProperty("liudehua", "50");
        prop.setProperty("liming", "60");
        prop.setProperty("zhangxueyou", "40");

        //将集合中的元素，存储到文本文件中
        prop.store(new FileWriter("prop2.txt"), "name=age");
    }
}
/*结果：prop2.txt
#name=age
#Thu May 18 11:35:01 CST 2017
liming=60
zhangxueyou=40
liudehua=50*/