学习Java中IO流

2021/8/5 9:06:20

本文主要是介绍学习Java中IO流,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

目录

 1.File 类

File 类基本功能

2.IO流

IO 的分类

 字节流——输出

字节流 try-catch-finally 捕获异常

 字节流——输入

缓冲流

字符流-编码表

字符流-写出数据

字符流-读取数据

缓冲流

转换流 

对象操作流

Properties

Properties-load、store


 1.File 类

在读取的时候告诉虚拟机要操作的(文件/文件夹)在哪
对(文件/文件夹)本身进行操作。包括创建,删除等。

FIle 类概述和构造方法
File :他是文件和目录路径的抽象表示
        文件和目录可以通过File 封装成对象
        File 封装的对象仅仅是一个路径名。它可以是存在的,也可以是不存在的。

                         方法名

                            说明

                File(String pathname)            通过给定的路径名字符串转换File实例
                File(String parent,String child)        从父和子路径名字符串和创建新的File实例
                File(File parent,String child)      从父路径名和子路径名字符串创建新File实例

File 类基本功能

                         方法名

                            说明

                public boolean creatnNewFile ()                        创建一个新得空得文件
                public boolean mkdir ()                        创建一个单机文件夹
                public boolean mkdirs ()                        创建一个多级文件夹
                public boolean delete ()            删除由此抽象路径表示的文件或空目录
                public boolean isDirectory ()          测试此抽象路径名表示的File是否为目录
                public boolean isFile ()          测试此抽象路径名表示的File是否为文件
                public boolean exists ()           测试此抽象路径名表示的File是否存在
                public String getName ()       返回由此抽象路径名表示的文件或目录的名称
                public String getAbsolutePath ()           返回此抽象路径名的绝对路径名字符串
                public Long lastModified ()      返回上次修改此抽象路径名表示的文件的时间
                public File[] listFiles ()       返回一个文件数组,表示路径中的目录和文件
public class Main {
    public static void main(String[] args) throws IOException {
        File f1 = new File("src/demo2/a.txt");
        File f2 = new File("src/demo2/b.txt");
        //创建文件
        System.out.println(f1.createNewFile());
        System.out.println(f2.createNewFile());
    }
}

执行结果:

小结:
        如果路径文件存在,则返回false,不创建文件
        如果路径文件不存在,则返回true,创建文件(只能创建文件)

public class Main {
    public static void main(String[] args) throws IOException {
        File f1 = new File("src/demo2/aaa/bbb/ccc.txt");
        //创建多级目录
        System.out.println(f1.mkdirs());
    }
}

执行结果:

 小结:
        如果路径存在,则返回false,不创建文件夹
        如果路径不存在,则返回true,创建文件夹(只能创建文件夹)

public class Main {
    public static void main(String[] args) throws IOException {
        File f1 = new File("src/demo2/aaa/bbb/ccc.txt/a.txt");
        //删除文件或者目录
        System.out.println(f1.delete());
    }
}

执行结果: 


小结:
        1.不走回收站的 (删除后无法简单复原)
        2.只能删除存在的 文件和空文件夹

public class Main {
    public static void main(String[] args) throws IOException {
        File f1 = new File("src/demo2/aaa");
        File f2 = new File("src/demo2/aaa/a.txt");
        //判断File是否为目录
        System.out.println(f1.isDirectory());
        //判断File是否为文件
        System.out.println(f2.isFile());
        //判断File是否存在
        System.out.println(f2.exists());
        //获得File绝对路径
        System.out.println(f1.getAbsolutePath());
        //获得文件名或者文件夹名
        System.out.println(f2.getName());
        //获得最后一次修改时间
        Date date = new Date(f2.lastModified());
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年 HH:mm:ss");
        String result = sdf.format(date);
        System.out.println(result);
    }
}

执行结果:

public class Main {
    public static void main(String[] args) throws IOException {
        File f = new File("C:/");
        //返回路径中的所有文件和文件夹
        for (File file : f.listFiles()) {
            System.out.println(file);
        }
    }
}

执行结果:

2.IO流

IO 的概述                (流的体系,流的构造,流的操作步骤)
        I  :in      输入
       O :out    输出

IO 的数据传输,可以看做一种数据的流向,按照流动得方向,需要以“内存”为参照物,进行读写操作
        说明:
                内存(Java 程序) ——>  硬盘(文件)        : 输出(写数据)
                硬盘(文件)——>   内存(Java 程序)        : 输入(读数据)

IO 的分类

 字节流——输出

步骤:
        1.创建字节流对象        (如果不存在就创建,根据构造参数是否清空)
        2.写数据                      
        3.释放资源                   (注意使用完释放资源)

构造方法:
        FileOutputStream(String name,boolean append)
        创建一个向具有指定name的文件种写入数据的输出文件流 

写数据的方法分类

                  方法名

                                    说明

    void write (int b)        将指定的字节写入此文件输出流 一次写一个字节数据
    void write (byte [] b) 

        将b.length字节从指定的字节数组写入此文件输出流

                        一次写一个字节数组数据

   void write (byte[] b, int off, int len)

        将 len字节从指定的字节数组开始,从偏移量off开始

        写入此文件输出流 一次写一个字节数组的部分数据

public class Main {
    public static void main(String[] args) throws IOException {
        //目录不存在就会报错,文件不存在会自动创建
        File f = new File("src/a.txt");
        FileOutputStream fos = new FileOutputStream(f,true);
        int b1 = 95;
        byte[] b2 = {98,99,100};
        fos.write(b1);

        fos.write("\r\n".getBytes());
        fos.write("起飞".getBytes());

        fos.write(b2);

        fos.write(System.lineSeparator().getBytes());

        fos.write(b2,0,2);
        fos.close();
    }
}

执行结果:
  

字节流 try-catch-finally 捕获异常

格式:
        try{
            可能出现异常的代码;    
        } catch (异常类名 变量名){
            异常的处理代码;
        } finally {
            执行所有清除操作;
        }

finally 特点:
        被finally控制的语句一定会执行,除非JVM退出

public class Main {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
            //目录不存在就会报错,文件不存在会自动创建
            File f = new File("src/a.txt");
            fos = new FileOutputStream(f,true);
            byte[] b2 = {98,99,100};
            fos.write(b2);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fos != null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

 字节流——输入

步骤:
        1.创建字节输入流对象        (一定要存在)
        2.读取一个字节
        3.关闭流

构造方法:
        FileInputStream(String name)

public class Main {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("D:/a.txt");
        FileOutputStream fos = new FileOutputStream("D:/b.txt");
        //输出char
        int read1;
        while ((read1 = fis.read()) != -1){
            System.out.print((char)read1);
        }
        //输出String
        byte[] b = new byte[1024];
        int read2;
        while ((read2 = fis.read(b)) != -1){
            System.out.print(new String(b));
        }
        //写入文件
        int read3;
        while ((read3 = fis.read()) != -1){
            fos.write(read3);
        }
        fis.close();
        fos.close();
    }
}

执行结果:

缓冲流

字节缓冲流
        BufferedOutputStream:字节缓冲输出流
        BufferedInputStream:字节缓冲输入流

构造方法        (默认缓冲区大小:8192 byte)
        字节缓冲输出流:BufferedOutputStream(OutputStream out)
        字节缓冲输入流:BufferedInputStream(InputStream in)

为什么构造方法需要的是字节流,而不是具体的文件或者路径呢?
        字节缓冲流仅仅提供缓冲区,而真正的读写数据还得依靠基本的字节流对象经行操作

public class Main {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("src/ASCII.jpg");
        BufferedInputStream bis = new BufferedInputStream(fis);
        FileOutputStream fos = new FileOutputStream("src/cpASCII2.jpg");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        byte[] b = new byte[1024];
        int len;
        while ((len = fis.read(b)) != -1){
            fos.write(b,0,len);
        }
        bis.close();
        bos.close();
    }
}

执行结果:


字节流:
        可以操作(拷贝)所有类型的文件
字节缓冲流:
        可以提高效率
        不能直接操作文件,需要传递字节流

拷贝文件的四种方式:
        字节流一次读写一个字节
        字节流一次读写一个字节数组
        字节缓冲流一次操作一个字节
        字节缓冲流一次操作一个字节数组

字符流-编码表

编码:字符转成编号
解码:把编号转成字符
编码表:字符和编号之间的对应关系表
字符集:字符的集合,字符集会对应一个编码表

常见编码表有哪些?
ASCII:现代英语,美国
GB2312:简体中文,7000字符
gbk:2万多字符,兼容GB2312
gb18030:中文最全的码表,包含少数民族文字
iso-8859-1:欧洲编码 ,拉丁字母
unicode码表:万国码,全世界主要国家语言的文字字符.
    utf-8:变长 英文一个,其他2个,中文3个,最多4个字节
    utf-16:固定长度,2个字节,4个字节
    utf-32:固定4个字节

编码:
        byte[] getBytes():使用平台默认字符集将该String 编码为一系列字节,存在数组种
        byte[] getBytes(String charseName):使用上方指定字符集将该String 编码

解码:
        String(byte[] bytes):通过默认字符集解码 指定字节数组来构造新的String
        String(byte[] bytes,String charsetName):通过指定字符集解码

public class Main {
    public static void main(String[] args) throws IOException {
        byte[] b1 = "我真帅".getBytes();
        System.out.println(Arrays.toString(b1));

        byte[] b2 = "我真帅".getBytes("GBK");
        System.out.println(Arrays.toString(b2));

        String s1 = new String(b1);
        System.out.println(s1);

        String s2 = new String(b2,"GBK");
        System.out.println(s2);

        String s3= new String(b2,"UTF-8");
        System.out.println(s3);
    }
}

执行结果:

字符流-写出数据

步骤:
        创建字符输出流对象
                如果文件不存在,就创建,但要保证父级路径存在。
                如果文件存在,更具参数是否清空。

        写数据
                写出的int 类型的数据,实际上写出的是整数在码表上对应的字母。
                写出字符串数据,是把字符串本身原样写出。

        释放资源

介绍:        (底层:字节流 + 编码表)
        Writer: 用于写入字符流的抽象父类
        FileWriter: 用于写入字符流的常用子类

构造方法

                  方法名

                                    说明

            FileWriter (File file)                根据给定的 File 对象构造一个 FileWriter 对象
FileWriter (File file, boolean append)                根据给定的 File 对象构造一个 FileWriter 对象
        FileWriter (String fileName)                根据给定的文件名构造一个 FileWriter 对象

                FileWriter

  (String fileName, boolean append)

                根据给定的文件名以及指示是否附加写入数据

                        的 boolean 值来构造 FileWriter 对象

成员方法

                  方法名

                                    说明

        void write (int c)                                  写一个字符
        void write (char[] cbuf)                             写入一个字符数组
        void write (char[] cbuf, int off, int len)                          写入字符数组的一部分
        void write (String str)                                写一个字符串
        void write (String str, int off, int len)                          写一个字符串的一部分
public class Main {
    public static void main(String[] args) throws IOException {
        File f = new File("src/a.txt");
        FileWriter fw = new FileWriter(f,true);

        int n1 = 97;
        fw.write(n1);

        char[] n2 = {'\r','a','b','c','d'};
        fw.write(n2);

        fw.write(n2,0,4);

        String s = "\r中国乒乓nb";
        fw.write(s);

        fw.write(s,0,5);
        fw.close();
    }
}

执行结果:

                  方法名

                                    说明

                flush ()                                刷新流,还可以继续写数据
                close ()

                 关闭流,释放资源,但是在关闭之前会先刷新流。

                                一旦关闭,就不能再写数据

字符流-读取数据

构造方法

                  方法名

                                    说明

        FileReader(File file)     在给定从中读取数据的 File 的情况下创建一个新 FileReader
        FileReader(String fileName)   在给定从中读取数据的文件名的情况下创建一个新 FileReader

成员方法

                  方法名

                                    说明

                int read ()                                一次读一个字符数据
                int read (char[] cbuf)                                一次读一个字符数组数据
public class Main {
    public static void main(String[] args) throws IOException {
        File f = new File("src/a.txt");
        FileReader fr = new FileReader(f);

        int len;
        while ((len = fr.read()) != -1){
            System.out.print((char)len);
        }

        char[] chars = new char[1024];
        int len2;
        while ((len2 = fr.read(chars)) != -1){
            System.out.print(new String(chars,0,len2));
        }
        fr.close();
    }
}

执行代码:

缓冲流

        BufferedWriter:将文本写入字符输出流,缓冲字符,以提供单个字符,数组和字符串的高效写入,可以指定缓冲区大小,或者可以接受默认大小。默认值足够大,可用于大多数用途

        BufferedReader:从字符输入流读取文本,缓冲字符,以提供字符,数组和行的高效读取,可以指定缓冲区大小,或者可以使用默认大小。 默认值足够大,可用于大多数用途

构造方法

                  方法名

                                    说明

        BufferedWriter (Writer out)                                创建字符缓冲输出流对象
        BufferedReader (Reader in)                                创建字符缓冲输入流对象

特有成员方法

                  方法名

                                    说明

                void newLine ()                写一行行分隔符,行分隔符字符串由系统属性定义

                  方法名

                                    说明

                String readLine ()

        读一行文字。 结果包含行的内容的字符串,不包括任何

                行终止字符如果流的结尾已经到达,则为null

public class Main {
    public static void main(String[] args) throws IOException {
        File f = new File("src/a.txt");
        BufferedWriter bw = new BufferedWriter(new FileWriter(f));
        bw.write("你女朋友真漂亮");
        bw.newLine();
        bw.write("才怪,你根本就没有女朋友");
        bw.close();

        BufferedReader br = new BufferedReader(new FileReader(f));
        String line;
        while ((line = br.readLine()) != null){
            System.out.println(line);
        }
        br.close();
    }
}

执行结果:

转换流 

        InputStreamReader:是从字节流到字符流的桥梁,父类是Reader 它读取字节,并使用指定的编码将其解码为字符它使用的字符集可以由名称指定,也可以被明确指定,或者可以接受平台的默认字符集

        OutputStreamWriter:是从字符流到字节流的桥梁,父类是Writer 使用指定的编码将写入的字符编码为字节它使用的字符集可以由名称指定,也可以被明确指定,或者可以接受平台的默认字符集

构造方法        (JKD 11 之前才需要)

                          方法名

                          说明

InputStreamReader(InputStream in)使用默认字符编码创建InputStreamReader对象
InputStreamReader(InputStream in,String chatset)使用指定的字符编码创建InputStreamReader对象
OutputStreamWriter(OutputStream out)使用默认字符编码创建OutputStreamWriter对象
OutputStreamWriter(OutputStream out,String charset)使用指定的字符编码创建OutputStreamWriter对象
public class Main {
    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(new FileInputStream("D:/a.txt"),"utf-8");
        char[] chars = new char[1024];
        ArrayList<String> al = new ArrayList<>();
        int len;
        while ((len = isr.read(chars)) != -1){
            al.add(new String(chars));
        }
        isr.close();

        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D:/a.txt"),"gbk");
        for (String s : al) {
            osw.write(s);
        }
        osw.close();
    }
}

对象操作流

对象序列化:
        将对象转成字节序列 (保存在磁盘中,或通过网络传输)
         ObjectOutputStream(OutputStream)
对象反序列化: 
        读取字节序列,返回一个对象(字节序列可以来自于文件,也可以来自于网络)

序列化的步骤
    1.创建 ObjectOutputStream(OutputStream)
    2.创建对象(学生对象)
    3.writeObject(stu);
    4.关闭流

注意:
    1.被序列化的对象所在的类必须实现 Serializable
    2.如果某个成员变量不想被序列化,可以使用 transient 关键字修饰

构造方法以及序列化方法

                          方法名

                          说明

        ObjectOutputStream(OutputStream out)          创建一个写入指定的OutputStream的                          ObjectOutputStream
               void writeObject (Object obj)        将指定的对象写入ObjectOutputStream

                          方法名

                          说明

           ObjectInputStream(InputStream in)            创建从指定的InputStream读取的                                     ObjectInputStream
                        Object readObject ()         从ObjectInputStream读取一个对象
public class Main {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        User user = new User("zhangsan","fawaikuangtu");
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("src/a.txt"));
        oos.writeObject(user);
        oos.close();

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("src/a.txt"));
        User us = (User) ois.readObject();
        System.out.println(us);
    }
}

执行结果:

Properties

概述:
        是一个Map体系的集合类
        Properties可以保存到流中或从流中加载
        属性列表中的每个键及其对应的值都是一个字符串

特有方法

                          方法名

                          说明

        Object setProperty (String key, String value)

        设置集合的键和值,都是String类型,

              底层调用 Hashtable方法 put

        String getProperty (String key)        使用此属性列表中指定的键搜索属性
        Set<String> stringPropertyNames ()

        从该属性列表中返回一个不可修改的

        键集,其中键及其对应的值是字符串

public class Main {
    public static void main(String[] args) {
        Properties prop = new Properties();
        prop.setProperty("小龙女", "杨过");
        System.out.println(prop);

        String value = prop.getProperty("小龙女");
        System.out.println(value);

        Set<String> strings = prop.stringPropertyNames();
        for (String string : strings) {
            String value2 = prop.getProperty(string);
            System.out.println(string + " " + value2);
        }
    }
}

执行结果:

Properties-load、store

和IO流结合的方法

                          方法名

                          说明

        void load (Reader reader)     从输入字符流读取属性列表(键和元素对)
        void store (Writer writer, String comments)将此属性列表(键和元素对)写入此 Properties 表中,以适合使用 load(Reader)方法的格式写入                             输出字符流
public class Main {
    public static void main(String[] args) throws IOException {
        Properties prop = new Properties();
        prop.put("wo","n");
        prop.put("hao","0");
        prop.put("shuai","1");
        FileWriter fw = new FileWriter("src/demo1/prop.properties");
        prop.store(fw,"我是注释");
        fw.close();

        Properties prop2 = new Properties();
        FileReader fr = new FileReader("src/demo1/prop.properties");
        prop2.load(fr);
        fr.close();
        System.out.println(prop2);
    }
}

执行结果:



这篇关于学习Java中IO流的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!


扫一扫关注最新编程教程