Java基础学习01--I/O字节流

Java的I/O流可以分为：字节流和字符流。本文重点介绍字节流的基本使用。

流的概念：内存与存储设备之间传输数据的通道。

流的分类——按流向：

输入流：将存储设备中的数据读取到内存中。

输出流：将内存中的数据写入到存储设备中。

 

流的分类——按存储单位：

字节流：以字节为单位，可以读写所有数据。

字符流：以字符为单位，只能读写文本数据。

 

流的分类三——按功能：

节点流：具有实际传输数据的读写功能。

过滤流：在节点流的基础之上增强功能。

 

1.FileInputStream与FileOutputStream

package file.demo;

import java.io.FileInputStream;
import java.io.IOException;

//演示FileInputStream的使用
public class filedemo01 {

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

        //0.加载文件路径
        String url = filedemo01.class.getClassLoader().getResource("aaa.txt").getPath();
        System.out.println("文件位置是：" + url);
        //1.创建FileInputStream
        FileInputStream fileInputStream = new FileInputStream(url);

        int available = fileInputStream.available();
        System.out.println("可用字节数为:" + available);

//        //单个字节读取
//        int data = 0;
//        while ((data = fileInputStream.read()) != -1) {
//            System.out.print((char) data);
//        }

        System.out.println("--------------------------");

        //一次读取多个字节
        byte[] bytes = new byte[2];
        int count = 0;
        while ((count = fileInputStream.read(bytes)) != -1) {
            System.out.print(new String(bytes, 0, count));
        }
        fileInputStream.close();
    }
}

package file.demo;

import java.io.FileOutputStream;
import java.io.IOException;

//演示FileOutputStream的使用
public class filedemo02 {
    public static void main(String[] args) throws IOException {

        //0.
        String url = filedemo01.class.getClassLoader().getResource("bbb.txt").getPath();
        System.out.println("文件位置是：" + url);
        //1.创建FileOutputStream对象
        FileOutputStream fileOutputStream = new FileOutputStream(url);

        fileOutputStream.write(97);
        fileOutputStream.write('b');

        fileOutputStream.close();
    }
}

package file.demo;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class filedemo03 {


    public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream = new FileInputStream("/Users/yangasen/Downloads/aaa.txt");

        FileOutputStream fileOutputStream = new FileOutputStream("/Users/yangasen/Downloads/ccc.txt");

        int count = 0;
        byte[] bytes = new byte[1024];
        while ((count = fileInputStream.read(bytes)) != -1) {
            fileOutputStream.write(bytes, 0, count);
        }
        fileInputStream.close();
        fileOutputStream.close();

    }


}

 

2.BufferedInputStream与BufferedOutputStream

缓冲流：提高IO效率，减少访问磁盘次数。数据存储在缓冲区中，flush()将缓冲区内容写入文件。也可以直接close()，会自动调用flush()。

package file.demo;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

//BufferedInputStream
public class buffereddemo01 {
    public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream = new FileInputStream("/Users/yangasen/Downloads/aaa.txt");
        BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
//        int data = 0;
//        while ((data = bufferedInputStream.read()) != -1) {
//            System.out.print((char) data);
//        }
        System.out.println("-----------------");

        byte[] bytes = new byte[1024];
        int count = 0;
        while ((count = bufferedInputStream.read(bytes)) != -1) {
            System.out.println(new String(bytes, 0, count));
        }
        bufferedInputStream.close();
    }
}

package file.demo;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;

public class buffereddemo02 {
    public static void main(String[] args) throws Exception {
        FileOutputStream fileOutputStream = new FileOutputStream("/Users/yangasen/Downloads/ddd.txt");
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);

        for (int i = 0; i < 10; i++) {
            bufferedOutputStream.write('z');
            bufferedOutputStream.flush();
        }
        bufferedOutputStream.close();
    }
}

 

3.ObjectOutputStream与ObjectInputStream

对象流增强了缓冲区功能，

增强了读写八种基本类型和字符串的功能。

增强了读写对象的功能：

readObject() 从流中读取一个对象。

writeObject() 向流中写入一个对象。

package file.demo;

import java.io.Serializable;

/*序列化与反序列化注意事项：
1.序列化类必须实现Serializable接口
2.序列化类中的对象属性也要实现Serializable接口
3.序列化版本号ID必须统一
4.使用transient的属性不会被序列化
5.静态属性不会被序列化
6.序列化多个对象，可以通过ArrayList等集合类
 */
public class Student implements Serializable {

    private static final long serialVersionUID = 100L;

    private String Name;
    private Integer Age;//使用关键字： transient 修饰，就不会被序列化

    public String getName() {
        return Name;
    }

    public Integer getAge() {
        return Age;
    }

    public void setName(String name) {
        Name = name;
    }

    public void setAge(Integer age) {
        Age = age;
    }

    public Student(String name, Integer age) {
        Name = name;
        Age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "Name='" + Name + '\'' +
                ", Age=" + Age +
                '}';
    }
}

package file.demo;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

public class objectdemo01 {
    public static void main(String[] args) throws Exception {
        FileOutputStream fileOutputStream = new FileOutputStream("/Users/yangasen/Downloads/student.bin");
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);

        objectOutputStream.writeObject(new Student("zhangsan", 18));

        objectOutputStream.close();
    }
}

package file.demo;

import java.io.FileInputStream;
import java.io.ObjectInputStream;

public class objectdemo02 {
    public static void main(String[] args) throws Exception {
        FileInputStream fileInputStream = new FileInputStream("/Users/yangasen/Downloads/student.bin");
        ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);

        Student student = (Student) objectInputStream.readObject();
        System.out.println(student);

        objectInputStream.close();

    }
}

注意：

静态属性不能被序列化。

序列化多个对象，可以使用ArrayList。