Java学习笔记13-IO流（续）与容器

最新推荐文章于 2023-04-30 21:38:58 发布

JanuaryFM

最新推荐文章于 2023-04-30 21:38:58 发布

阅读量98

点赞数

分类专栏： java笔记文章标签： java 后端经验分享

本文链接：https://blog.csdn.net/JanuaryFM/article/details/118862994

版权

java笔记专栏收录该内容

32 篇文章 0 订阅

订阅专栏

1.缓冲处理类

缓冲流属于功能流，它的作用是提高读写效率。

（1）字节缓冲流分为：BufferedInputStream 字节输入缓冲流

BufferedOutputStream 字节输出缓冲流

注：当缓冲流无新增功能时，可以使用多态创建对象。

//实例代码-文件的拷贝（使用字节缓冲流加快效率）
 class Class001_Buffered {
    public static void main(String[] args) throws IOException {
        //1.创建流（缓冲流中无新增方法使用多态的形势创建对象）
        InputStream is = new BufferedInputStream(new FileInputStream("D://test.txt"));
        OutputStream os = new BufferedOutputStream(new FileOutputStream("D://heihei.txt"));
        //2.拷贝
        byte[] car = new byte[1024];
        int len = -1;
        while((len=is.read(car))!=-1){
            os.write(car,0,len);
        }
        //3.刷出
        os.flush();
        //4.关闭
        os.close();
        is.close();
    }
}

（2）字符缓冲流分为：BufferedReader 字符输入缓冲流

BufferedWriter 字符输出缓冲流

注：字符缓冲流作为输入输出流的子类存在自己新增的方法，不可以使用多态进行创建对象

//实例代码-字符缓冲流
public class Class002_Buffered {
    public static void main(String[] args) throws IOException {
        //1.创建流
        BufferedReader rd = new BufferedReader(new FileReader("D://test.txt"));
        BufferedWriter rw = new BufferedWriter(new FileWriter("D://b.txt"));
        //2.读写
        String msg = null;
        while((msg = rd.readLine())!=null){
            rw.write(msg);
            rw.newLine();
            //rw.write("\n\r");
        }
        //3.刷出
        rw.flush();
        //4.关闭
        rw.close();
        rd.close();
    }
}

2.数据处理流

基本数据类型流也叫Data流，处理基本类型+String,保留数据的类型。

Data流按照功能来讲是属于功能流，按照操作单元来讲，是字节流。

DataInputStream 数据输入流

DataOutputStream 数据输出流

注：读入与写出的顺序要保持一致

//实例代码-Data流
public class Class001_Data {
    public static void main(String[] args) throws IOException {
        readFromFile("D:/d.txt");
    }

    //读入
    public static void readFromFile(String path) throws IOException {
        //1.创建流
        DataInputStream is = new DataInputStream(new BufferedInputStream(new FileInputStream(path)));
        //2.读入
        int i = is.readInt();
        boolean flag = is.readBoolean();
        char ch = is.readChar();
        String s = is.readUTF();
        //3.处理数据
        System.out.println(i);
        System.out.println(flag);
        System.out.println(ch);
        System.out.println(s);
        //4.关闭
        is.close();
    }
    //写出
    public static void writeToFile(String path) throws IOException {
        //1.创建输出流
        DataOutputStream out = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(path)));
        //2.准备数据
        int i = 1;
        boolean flag = false;
        char ch = 'c';
        String str = "哈哈";
        //3.写出
        out.writeInt(i);
        out.writeBoolean(flag);
        out.writeChar(ch);
        out.writeUTF(str);
        //4.刷出
        out.flush();
        //5.关闭
        out.close();
    }
}

3.Object流（对象流）

作用：读写对象数据，引用数据类型的数据（包含基本数据类型）

ObjectInputStream （反序列化输入流）新增功能：readObject()

ObjectOutputStream (序列化输出流) 新增功能：writeObject

序列化：将对象数据局转为字节流（可存储和可传输）的过程

反序列化：从字节流创建对象的相反的过程称为反序列化

注：要先序列化后反序列化

不能所有的类型都能序列化  java.io.Serializable
不是所有的属性都需要序列化
静态的内容不会序列化
如果父类实现序列化,子类没有实现,可以序列化所有的成员
如果子类实现序列化,父类实现,只能序列化子类成员

//实例代码-对象流
public class Class001_Object {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //writeToFile("D://e.txt");
        readFile("D://e.txt");
    }

    //反序列化
    public static void readFile(String path) throws IOException, ClassNotFoundException {
        //1.输入流
        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(new FileInputStream(path)));

        //2.读入
        User obj1 = (User) in.readObject();
        int[] arr = (int[]) in.readObject();
        //3.处理数据
        System.out.println(obj1);
        System.out.println(Arrays.toString(arr));
        //4.关闭
        in.close();
    }

    //序列化输出
    public static void writeToFile(String path) throws IOException {
        //1.输出流
        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(path)));
        //2.数据
        User user = new User("zhangsan",18,"123");
        int[] arr = {1,2,3,4};
        //3.写出
        out.writeObject(user);
        out.writeObject(arr);
        //4.刷出
        out.flush();
        //5.关闭
        out.close();
        //修饰user对象的成员,静态
        user.username = "lisi";
        user.password = "4321";
    }
}
//创建用户类继承接口Serializable
class User implements Serializable{
    private static final long serialVersionUID = -5204947308809070324L;
    public String username;
    //transient 修饰的字段不会序列化
    public transient int age;
    public static String password;
    //成员的修改: 新增的成员
    public int vip;
    public int id;  //用户编号

    public User() {
    }
    public User(String username, int age, String password) {
        this.username = username;
        this.age = age;
        this.password = password;
    }
    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", age=" + age +
                ", password='" + password + '\'' +
                '}';
    }
}

4.容器

容器的的特点：1.容量跟随内容的多少进行动态的增删

2.存储任意引用类型数据

（1）Collection接口

Collection是一个接口，只是规定了一些方法，即作为一个容器就应该具有这些功能。在Collection 中并没有任何的可以存储数据的地方，因此只是作为一个规范存在

添加 add
删除 remove
记数 size
包含 contains
清空 clear
是否空 isEmpty

//实例代码- Collection接口
public class Class001_Collection {
    public static void main(String[] args) {
        //集合
        Collection col = new ArrayList();
        Collection col2 = new ArrayList();
        //常用方法
        //boolean add(E e) 确保此集合包含指定的元素（可选操作）。
        //boolean addAll(Collection<? extends E> c) 将指定集合中的所有元素添加到此集合中（可选操作）。
        col.add("abc");
        col.add(false);
        col.add(100);
        col2.add("aaa");
        col2.add("bbb");
        System.out.println(col);
        col.addAll(col2);
        System.out.println(col);
        //boolean contains(Object o) 如果此collection包含指定的元素，则返回 true 。
        //boolean containsAll(Collection<?> c) 如果此集合包含指定集合中的所有元素，则返回 true 。
        System.out.println(col.contains(100));
        col2.add("ccc");
        System.out.println(col.containsAll(col2));

        //boolean remove(Object o) 从此集合中移除指定元素的单个实例（如果存在）（可选操作）。
        //boolean removeAll(Collection<?> c) 删除此集合的所有元素，这些元素也包含在指定的集合中（可选操作）。
        System.out.println(col.remove(100));
        System.out.println(col);
        //System.out.println(col.removeAll(col2));
        //System.out.println(col);
        //boolean retainAll(Collection<?> c) 仅保留此集合中包含在指定集合中的元素（可选操作）。
        System.out.println(col.retainAll(col2));
        System.out.println(col);
        System.out.println(col2);

        //Object[] toArray() 返回包含此集合中所有元素的数组。
        System.out.println(Arrays.toString(col.toArray()));
    }
}

（2）迭代器

所有实现了Collection接口的容器类都有一个 iterator 方法用以返回一个实现了Iterator接口的对象。

Iterator对象称作迭代器，用以方便的实现对容器内元素的遍历操作。

Iterator接口定义了如下方法：

boolean hasNext(); //判断是否有元素没有被遍历
Object next(); //返回游标当前位置的元素并将游标移动到下一个位置
void remove(); //删除游标左面的元素，在执行完next之后该 ,操作只能执行一次

//实例代码-元素的遍历
public class Class002_Each {
    public static void main(String[] args) {
        Collection col = new ArrayList();
        col.add("aaa");
        col.add("bbb");
        col.add("ccc");
        col.add("ddd");
        //1.增强for（方法一）
        for(Object s:col){
            System.out.println(s);
        }
        //2.迭代器（方法二）
        //1)获取迭代器对象
        Iterator it = col.iterator();
        //2)判断是否存在下一个数据
        while(it.hasNext()){
            //3)获取下一个数据
            System.out.println(it.next());
        }

    }
}