Java笔记杨枝11.26

其他IO流

数据流：
DataOutputStream（写）和DataInputStream（读）

DataInputStream dis = new DataInputStream（
                  new FileInputStream("dos.txt"));

        //读数据
        byte b = dis.readByte() ;
        int i = dis.readInt() ;
        short s = dis.readShort() ; 
        long l = dis.readLong() ;
        char ch = dis.readChar() ;
        boolean flag = dis.readBoolean() ;
        float f = dis.readFloat() ;
        double d = dis.readDouble() ;

DataOutputStream dos = new DataOutputStream(new FileOutputStream(
                "dos.txt"));

        //写数据
        dos.writeByte(100) ;
        dos.writeInt(1000) ;
        dos.writeShort(120) ;
        dos.writeLong(1000000L);
        dos.writeChar('A') ;
        dos.writeBoolean(true) ;
        dos.writeFloat(12.34F) ; 
        dos.writeDouble(12.56) ;

二 内存操作流
针对内存的数据进行操作的,程序一结束,这些内存中的数据就消失掉了!

package prac;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

public class Prac04 {
 public static void main(String[] args) throws IOException {
     ByteArrayOutputStream baos = new ByteArrayOutputStream() ;
            baos.write(("love").getBytes()) ;


     byte[] buffer = baos.toByteArray() ;

     ByteArrayInputStream bais = new ByteArrayInputStream(buffer) ;

     int by = 0 ;
        while((by=bais.read())!=-1){
            System.out.print((char)by);
        }
}
}

三 打印流:
字节打印流:PrintStream
字符打印流:PrintWriter
特点：
1）复制文件时，只能操作目的源，只能输出数据。
2）可直接对文本文件操作

PrintWriter:有自动刷新功能:
public PrintWriter(Writer out,boolean autoFlush)
第二个参数指定为true,则启动自动刷新
PrintWriter pw = new PrintWriter(new FileWriter(“pw.txt”),true) ;
加入自动刷新功能并且在写数据的时候,使用println():换行
所以复制文件可以使用PrintWriter进行输出数据

public class CopyFileDemo {

    public static void main(String[] args) throws IOException {
//      1)封装数据源
        BufferedReader br = new BufferedReader(new FileReader("DataStreamDemo.java")) ;

        ////2)封装目的地
        //创建字符打印流对象,并且启动自动刷新功能
        PrintWriter pw = new PrintWriter(new FileWriter("Copy.java"), true) ;

        //读写操作
        String line = null ;
        while((line=br.readLine())!=null){
            //写数据
            pw.println(line) ;
        }

        //关闭资源
        pw.close() ;
        br.close() ;
    }
}

四 使用IO流进行录入数据

package prac;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Prac05 {
    public static void main(String[] args) throws IOException {
         BufferedReader br=  new BufferedReader(new InputStreamReader(System.in));

         System.out.println("请输入一个整数：");
        String a=br.readLine();

        int b=Integer.parseInt(a);
        System.out.println("您输入的整数是："+b);
    }
}

五 随机访问流RandomAccessFile
不是实际意义上的流,因为它继承自Object类
常用的构造方法:
public RandomAccessFile(String name, String mode)
参数一:指定该文件的路径
参数二:指定的一种模式:常用的模式:”rw”,这种模式是可以读也可以写

RandomAccessFile raf = new RandomAccessFile("raf.txt", "rw") ;

        //读数据

        byte b = raf.readByte() ;
        System.out.println(b);
        System.out.println("getFilePointer:"+raf.getFilePointer());

        char ch = raf.readChar() ;
        System.out.println(ch);

        String  str  = raf.readUTF() ;
        System.out.println(str);

        //关闭资源
        raf.close() ;

    RandomAccessFile raf = new RandomAccessFile("raf.txt", "rw") ;

        //写数据
        raf.writeByte(100) ;
        raf.writeChar('a') ;
        raf.writeUTF("中国") ;

        //关闭资源
        raf.close() ;

六 合并流SequenceInputStream（读数据）
在复制文件的时候,只能操作数据源,不能操作目的地

    SequenceInputStream sis = new SequenceInputStream(new FileInputStream("a.txt"),new 
            FileInputStream("b.txt"));

    BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("c.txt"));

    byte[] b=new byte[1024];
    int len=0;
    while((len=sis.read(b))!=-1){
        bos.write(b, 0, len);
    }

    sis.close() ;
    bos.close() ;
}
}

合并流另一种构造方式：复制多个文件

Vector<InputStream> v = new Vector<InputStream>() ;

        //封装者三个java文件
InputStream s1 = new FileInputStream("a.txt") ;
InputStream s2 = new FileInputStream("b.txt") ;
InputStream s3 = new FileInputStream("c.txt") ;

        //添加到集合中
        v.add(s1) ;
        v.add(s2) ;
        v.add(s3) ;

        //调用特有功能:
        //public Enumeration<E> elements()
    Enumeration<InputStream> en = v.elements() ;
        //创建合并刘对象
    SequenceInputStream sis = new SequenceInputStream(en) ;
        //封装目的地
    BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream("c.txt"));

        //一次读取一个字节数组
        byte[] bys = new byte[1024] ;
        int len = 0 ;
        while((len=sis.read(bys))!=-1){
            //写数据
            bos.write(bys, 0, len) ;
            bos.flush() ;
        }

        //释放资源
        bos.close() ;
        sis.close() ;

七 序列化和反序列化流

package prac;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Prac08 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
    //反序列化
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d.txt"));
    //使用反序列化:将流数据--->对象
    Object obj = ois.readObject() ;
    ois.close() ;
    System.out.println(obj);


    //序列化
    Person p = new Person("小明", 18) ;
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("d.txt"));
    oos.writeObject(p) ;
    oos.close() ;

}
}
//如果启用序列化功能,那么必须实现一个接口:Serializable
class Person  implements Serializable{
    //序列化和反序列化生产的版本Id不一致的时候,会出现异常,所以使用生产随机ID或者固定ID解决
    private static final long serialVersionUID = 1L;

    private String name;
    //transient:不用被序列化的时候用它修饰
    private transient int age;


    public Person() {
        super();

    }

    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }


}

八 属性集合类
Properties:可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串

package prac;

import java.util.Properties;
import java.util.Set;

public class Prac09 {
      public static void main(String[] args) {
        Properties prop=new Properties();

        prop.setProperty("a", "b");
        //遍历属性列表:public Set<String> stringPropertyNames()
        Set<String> keySet = prop.stringPropertyNames() ;

        for(String key:keySet){
            String value=prop.getProperty(key);
            System.out.println(key+"......."+value);
        }

    }
}

Properties 可保存在流中或从流中加载。

package prac;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;

public class Prac10 {
public static void main(String[] args) throws IOException {
        // 将文件中的数据加载到属性集合中:public void load(Reader reader)
        Properties prop = new Properties();
        FileReader file = new FileReader("d.txt");
        prop.load(file);
        file.close();
        System.out.println(prop);

        // 将属性集合中的数据保存到文件中:public void store(Writer writer,String comments)
        Properties prop1 = new Properties();

        // 给属性集合中添加数据
        prop1.setProperty("张三", "30");
        prop1.setProperty("李四", "40");
        prop1.setProperty("王五", "50");

        // 将属性列表中的数据保存到文件中
        FileWriter fw = new FileWriter("d.txt");
        prop1.store(fw, "names content");

        fw.close();
}
}