Java周记——IO流补充（第五周）

目录

1.文件夹创建和遍历

2.四个抽象类

3.操作网络流

4.数据流

5.对象流

---

1.文件夹创建和遍历

mkdir()：创建目录

mkdirs()：如果父目录链不存在一同创建

list()：下级名称

listFiles()：下级File

listRoots()：根路径

package cn.j.www;

import java.io.File;

public class testdir {
    public static void main(String[]args){
        File dir=new File("E:/mycode/IObuchong/dir/test");//dir不存在
        //创建目录
        boolean flag=dir.mkdir();
        System.out.println(flag);//false
        boolean flag1=dir.mkdirs();
        System.out.println(flag1);//true,并创建dir/test文件
        //dir文件已存在，再次用mkdir
        File dir1=new File("E:/mycode/IObuchong/dir/test1");
        boolean flag2=dir1.mkdir();
        System.out.println(flag2);//true,并在dir目录下创建test1文件
    }
}

package cn.j.www;

import java.io.File;

public class testlist {
    public static void main(String[]args){
        File dir=new File("E:/mycode/IObuchong");
        //列出下一级名称
        String[]subname=dir.list();
        for(String s:subname){
            System.out.println(s);
        }
        //列出下级对象
        File[]subfile=dir.listFiles();
        for(File f:subfile){
            System.out.println(f.getAbsolutePath());
        }
        //列出所有盘符
        File[]roots=dir.listRoots();
        for(File f1:roots){
            System.out.println(f1.getAbsolutePath());
        }
    }
}

2.四个抽象类

抽象类	说明	常用方法
InputStream	字节输入流的父类，数据单位为字节	int read() void close()
OutputStream	字节输出流的父类，数据单位为字节	void write(int) void flush() void close()
Reader	字符输入流的父类，数据单位为字符	int read() void close()
Writer	字符输出流的父类，数据单位为字符	void write(String) void flush() void close()

3.操作网络流

package cn.j.www;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.MalformedURLException;
import java.net.URL;

public class test {
    public static void main(String[]args) throws IOException {
        BufferedReader isr=new BufferedReader(new InputStreamReader(new URL("http://www.baidu.com").openStream()));
        String s;
        while((s=isr.readLine())!=null){
            System.out.print(s);
        }
    }
}

4.数据流

DataInputStream和DataOutputStream提供了可以存取与机器无关的所有Java基础类型数据(如：int、double、String等)的方法。

DataInputStream和DataOutputStream是处理流，可以对其他节点流或处理流进行包装，增加一些更灵活、更高效的功能。

顺序要与写出的一致

package cn.j.www;

import java.io.*;

public class testdate {
    public static void main(String[]args) throws IOException {
        ByteArrayOutputStream baos=new ByteArrayOutputStream();
        DataOutputStream dos=new DataOutputStream(baos);
        dos.writeUTF("编码");
        dos.writeInt(45);
        dos.writeDouble(45.5);
        dos.writeChar('a');
        dos.writeBoolean(true);
        dos.flush();
        byte[]datas=baos.toByteArray();
        DataInputStream dis=new DataInputStream(new ByteArrayInputStream(datas));
        System.out.println(dis.readUTF());
        System.out.println(dis.readInt());
        System.out.println(dis.readDouble());
        System.out.println(dis.readChar());
        System.out.println(dis.readBoolean());

    }
}

5.对象流

package cn.j.www;

import com.sun.corba.se.impl.orbutil.ObjectWriter;

import java.io.*;
import java.nio.Buffer;
import java.util.Date;

public class testobject {
    public static void main(String[]args) throws IOException, ClassNotFoundException {
        FileOutputStream fo=new FileOutputStream("test.txt");
        ObjectOutputStream oos=new ObjectOutputStream(fo);
        //写入,序列化
        oos.writeObject(45);
        oos.writeObject("你好！");
        oos.writeObject(39.9);
        oos.writeObject(true);
        student s=new student("20212102","张三",20);
        oos.writeObject(s);
        oos.writeObject(new Date());
        fo.close();
        //读出
        FileInputStream fi=new FileInputStream("test.txt");
        ObjectInputStream dis=new ObjectInputStream(fi);
        Object o1=dis.readObject();
        Object o2=dis.readObject();
        Object o3=dis.readObject();
        Object o4=dis.readObject();
        Object o5=dis.readObject();
        Object o6=dis.readObject();
        fi.close();
        //反序列化
        if(o1 instanceof Integer){
            Integer d=(Integer)o1;
            System.out.println(d);
        }
        if(o2 instanceof String){
            String d=(String)o2;
            System.out.println(d);
        }
        if(o3 instanceof Double){
            Double d=(Double)o3;
            System.out.println(d);
        }
        if(o4 instanceof Boolean){
            Boolean d=(Boolean)o4;
            System.out.println(d);
        }
        if(o5 instanceof student){
            student d=(student)o5;
            System.out.println(d.id+","+d.name+","+d.age);
        }
        if(o6 instanceof Date){
            Date d=(Date)o6;
            System.out.println(d);
        }
    }
    public static class student implements Serializable{
        private String id;
        private String name;
        private transient int age;//transient将年龄抹掉，该数据不需要序列化
        public student(String id,String name,int age){
            this.id=id;
            this.name=name;
            this.age=age;
        }
    }
}

把Java对象转换为字节序列的过程称为对象的序列化。把字节序列恢复为Java对象的过程称为对象的反序列化。

1. static属性不参与序列化。

 2. 对象中的某些属性如果不想被序列化，不能使用static，而是使用transient修饰。