基本IO操作--字节流

 1 /**
 2  * 使用文件字节输出流向文件中写出数据
 3  * @author Administrator
 4  *
 5  */
 6 public class TestFOS1 {
 7     public static void main(String[] args) throws IOException {
 8         /*
 9          * 创建一个文件字节输出流用于向fos.dat文件中
10          * 写出字节数据
11          */
12         /*
13          * 添加布尔值参数  true  变成追加型操作
14          * FileOutputStream(File file,boolean append)
15            FileOutputStream(String str,boolean append)
16          */
17         FileOutputStream fos = new FileOutputStream("fos.dat",true);
18         //写一个字符串
19         fos.write("hello world".getBytes("GBK"));
20     
21         //流用完了要记得关闭
22         fos.close();
23         
25     }
26 }

FileOutputStream fos = new FileOutputStream("demo.dat");
fos.write(‘A‘);//这里要注意，char占用2个字节，但这里只写入了1个字节。

FileOutputStream fos = new FileOutputStream("demo.txt");
byte[] data = "HelloWorld".getBytes();
fos.write(data);//会将HelloWorld的所有字节写入文件。 
void write(byte[] d,int offset,int len)

FileOutputStream fos = new FileOutputStream("demo.txt");
byte[] data = "HelloWorld".getBytes();
fos.write(data,5,5);//只会将world这5个字节写入文件。

**
 * 使用文件输入流将数据从文件中读取
 * @author Administrator
 *
 */
class TestFIS{
    public static void main(String[] args) throws IOException {
        /*
         * 使用文件字节输入流读取fos.dat文件
         */
        FileInputStream fis =new FileInputStream("fos.dat");
        
        int d = -1;
        while((d=fis.read())!=-1){
            char c=(char)d;
            System.out.print(c);
        }
    }
}

/**
 * 使用文件的输入流与输出流实现文件复制工作
 */

class TestCopy{
    /*
     * 1.创建文件输入流用于读取原文件
     * 2.创建文件输出流用于向目标文件中写
     * 3.循环从源文件中读取每一个字节
     * 4.将读取到的每一个字节写入目标文件
     * 5.关闭两个流
     */
    public static void main(String[] args) throws IOException {
        FileInputStream fis =new FileInputStream("fos.dat");
        
        FileOutputStream fos = new FileOutputStream("fos1.dat",true);
        int d=-1;
        while((d=fis.read())!=-1){
            //char c= (char)d;
            fos.write(d);
        }
        fis.close();
        fos.close();
        
    }
}

/**
 * 使用文件流的批量读和批量写 复制文件
 */

class TestCopy2{
    public static void main(String[] args) throws IOException {
FileInputStream fis =new FileInputStream("fos.dat");
        
        FileOutputStream fos = new FileOutputStream("fos1.dat",true);
        byte [] b= new byte[10*1024];
        int d=-1;
        while((d=fis.read(b))!=-1){
            
            fos.write(d);
        }
        fis.close();
        fos.close();
    }
}

FileInputStream fis = new FileInputStream("java.zip");
BufferedInputStream bis = new BufferedInputStream(fis);
FileOutputStream fos = new FileOutputStream("copy_java.zip");
BufferedOutputStream bos = new BufferedOutputStream(fos);
int d = -1;
while((d = bis.read())!=-1){
bos.write(d);
}
bis.close();//读写完毕后要关闭流，只需要关闭最外层的流即可
bos.close();

BufferedOutputStream bos
            = new BufferedOutputStream(
                new FileOutputStream("demo.dat")
            );
bos.write(‘a‘);//并没有向磁盘写出，而是写入到了BOS的缓存中
bos.flush();//强制将缓存中的数据一次性写出，这时‘a’才会被写入磁盘
bos.close();//实际上，close()方法在变比缓冲流前也调用了flush()

class TestFlow2{
    public static void main(String[] args) throws IOException {
    FileOutputStream fos =new FileOutputStream("1.txt");
    BufferedOutputStream bos = new BufferedOutputStream(fos);
    String str = "hello";
    bos.write(str.getBytes());
    bos.flush();  //清楚缓存区
    bos.close();
    
    }
}

/**
 * 每一个实例用于描述一个人的信息
 * @author Administrator
 *
 */
// Serializable  实现这个接口就是打标签 无需在重写任何东西
class person implements Serializable{

    private static final long serialVersionUID = 1L;   //版本号
    private String name;
    private int age;
    private int phoneNumber;
    private int sex;
    private List<String> otherInfo;
    private Date birDay;
    
    public person(String name, int age, int phoneNumber, int sex,
            List<String> otherInfo, Date birDay) {
        super();
        this.name = name;
        this.age = age;
        this.phoneNumber = phoneNumber;
        this.sex = sex;
        this.otherInfo = otherInfo;
        this.birDay = birDay;
    }
    
    @Override
    public String toString() {
        return "person [age=" + age + ", birDay=" + birDay + ", name=" + name
                + ", otherInfo=" + otherInfo + ", phoneNumber=" + phoneNumber
                + ", sex=" + sex + "]";
    }
    
    
    
}

/**
 * 使用ObjectOutputStream 将对象写入文件
 * @author Administrator
 *
 */
class TestOOSDemo{

    public static void main(String[] args) throws IOException {
        List<String> otherInfo =new ArrayList<String>();
        otherInfo.add("其他信息1");
        otherInfo.add("其他信息2");
        otherInfo.add("其他信息3");
        person ps =new person("张三",25,1364951,1,otherInfo, null);
        
        System.out.println(ps);
        
        /*
         * 将Person序列化后写入文件中
         * 1、向文件中写数据的流：FileOutputStream
         * 2、将对象序列化的流：ObjectOutputStream
         */
        FileOutputStream fos =new FileOutputStream("ps.obj");
        
        ObjectOutputStream oos =new ObjectOutputStream(fos);
        /*
         * 将对象转为字节 
           将数据写入磁盘的过程称之为：持久化
         */
        oos.writeObject(ps);
        
    }
}

/**
 * 实现数据的反序列化
 * @author Administrator
 *
 */
class TestBisDemo{
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        /*
         * 从文件中读取字节数据后再转换为对象
         * 1.FIS 读取文件
         * 2.OIS 反序列化
         */
        FileInputStream fis = new FileInputStream("ps.obj");
        ObjectInputStream ois =new ObjectInputStream(fis);
        /*
         * 反序列的方法
         * Object readObject();
         */
        person ps =  (person)ois.readObject();
        System.out.println(ps);
        ois.close();
        
    }

public class Emp implements Serializable{
    private static final long serialVersionUID = 1L;
    private String name;
    private transient int age;//该属性在序列化时会被忽略
    private String gender;
    //getter and setter and other
    ...
}