Java学习笔记12-常用类与IO流

最新推荐文章于 2023-02-21 20:11:14 发布

JanuaryFM

最新推荐文章于 2023-02-21 20:11:14 发布

阅读量136

点赞数

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

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

版权

java笔记专栏收录该内容

32 篇文章 0 订阅

订阅专栏

本文介绍了Java中的枚举类型，如何定义和使用枚举实例，以及File类的用法。深入探讨了数据源与IO流的概念，包括字节流（如FileInputStream和FileOutputStream）和字符流（如FileReader和FileWriter）的实例演示及文件复制。

摘要由CSDN通过智能技术生成

1.常用类

（1）枚举类型

枚举类型：描述一种事务的所有情况，所有可能，所有实例

1.通过enum关键字定义枚举类型

2.枚举的成员,字段都作为当前枚举类型的实例存在,默认被public static final修饰

3.定义的枚举类型都会隐式的继承自java.lang.Enum 这是所有Java语言枚举类型的公共基类。

4.在枚举类型中构造器默认私有

//实例代码-枚举的使用
public class Class001_Enum {
    public static void main(String[] args) {
        System.out.println(WeekDays.SUN);
        //使用枚举类型的实例
        WeekDays sun = WeekDays.SUN;
        System.out.println(sun.getName());
        //name() 获取枚举类型实例的字段名
        System.out.println(sun.name());
        //获取枚举对象在枚举类的字段列表中的索引值
        System.out.println(sun.ordinal());
        //values() 获取当前枚举类型的所有实例
        WeekDays[] arr = sun.values();
        System.out.println(Arrays.toString(arr));
        sun = WeekDays.MON;
        //switch()中jdk5新增对枚举的支持
        switch (sun){
            case MON:
                System.out.println("星期一");
                break;
            case TUES:
                System.out.println("星期二");
                break;
            case SUN:
                System.out.println("星期天");
                break;
        }
    }
}

//一周的中的天数 周1~周7，确定已知条件使用枚举类型
enum WeekDays{
    //枚举字段|当前枚举类型的实例
    MON,TUES,SUN("星期天");
    // public static final WeekDay MON = new WeekDay();
    //成员变量
    private String name;
    //构造器
    private WeekDays(){}
    private WeekDays(String name){
        this.name = name;
    }
    //成员方法
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

（2）File类

java.io.File类：文件和路径名的抽象表现形式

分隔符：静态常量

java中的路径的分隔符可以使用 \\ 、/、//

//实例代码-File类使用和部分方法
public class Class001_File {
    public static void main(String[] args) throws IOException {
        //File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
        File file1 = new File("D:\\test.txt");
        File file2 = new File("D:\\AAA");
        File file3 = new File("D:/");
        //File(File parent, String child) 从父抽象路径名和子路径名字符串创建新的 File实例。


        File(String parent, String child) 从父路径名字符串和子路径名字符串创建新的 File实例。
        File file5 = new File("D://AAA","BBB");

        File file6 = new File("D://haha.txt");

        System.out.println(file1);
        System.out.println(file2);
        System.out.println(file4);

        System.out.println(file1.equals(file4));
        System.out.println(file2.equals(file5));
        System.out.println(file5);

        //常用方法
        //boolean canWrite() 测试应用程序是否可以修改此抽象路径名表示的文件。
        //boolean exists() 测试此抽象路径名表示的文件或目录是否存在。
        //boolean setReadOnly() 标记此抽象路径名指定的文件或目录，以便仅允许读取操作。
        if(file1.exists()){
            System.out.println("只读状态设置: "+file1.setReadOnly());
            System.out.println("判断文件file1是否可以编写 "+file1.canWrite());
        }

        //boolean createNewFile() 当且仅当具有此名称的文件尚不存在时，以原子方式创建由此抽象路径名命名的新空文件。
        if(!file6.exists()){
            System.out.println(file6.createNewFile());
        }

        //boolean delete() 删除此抽象路径名表示的文件或目录。  空文件夹才可以删除
        System.out.println(file6.delete());
        System.out.println(file2.delete());
    }
}

2.IO流

（1）数据源

数据源：数据源就像水箱，流就像水管中流着的水流，程序就是我们最终的用户。流是一个抽象、动态的概念，是一连串连续动态的数据集合。

（2）IO流的种类

按照流向分：输入流

输出流

（以大脑为中心，以程序为中心，明确数据源和目的地，能够确定输入还是输出）

按照单元分：字节流（万能流，任意内容都转为字节）

字符流（只能传输纯文本内容）

按照功能分：节点流（真实做读入写出的流）

功能流（增强节点流的功能，加强性能）

注：它们之间是相辅相成的

（3）IO流—字节流(万能流)

1.字节输入流，基类是InputStream,文件输入流-FileInputStream。

功能：节点流流向分：输入流操作单元：字节流

功能：读入read()

程序设计流程：1.创建流 2.处理数据 3.关闭流

方法一：单一读取输入流的字节数据

//实例代码-文件字节输入流
public class Class001_IO {
    public static void main(String[] args) throws IOException {
        //FileInputStream(File file) 通过打开与实际文件的连接来创建 FileInputStream ，该文件由文件系统中的 File对象 file命名。
        File src = new File("D://test2.txt"); //数据源
        //创建流
        InputStream is = new FileInputStream(src);
        //读入数据 int read() 从此输入流中读取一个字节的数据。  读到文件末尾返回-1
        int num = is.read();
        //处理数据
        System.out.println((char)num);
        System.out.println((char)(is.read()));
        System.out.println((char)(is.read()));
        System.out.println(is.read());
        //关闭流
        is.close();
    }
}

方法二：利用循环一次读取文件字节数据（注：read（）读到文件末尾返回-1）

//实例代码
public class Class002_IO {
    public static void main(String[] args) throws IOException {
        //创建流
        //FileInputStream (String name) 通过打开与实际文件的连接来创建 FileInputStream ，该文件由文件系统中的路径名 name命名。
        InputStream is = new FileInputStream("D://test2.txt");
        //读入数据
        int num = -1;
        while((num=is.read())!=-1){
            //处理数据
            System.out.println((char)num);
        }
        //关闭流
        is.close();
    }
}

方法三（效率最高）：每次读入一个字节数组的数据,重复循环读入

返回读入到字节数组中数据的个数 ,没有读到返回-1

//实例代码
public class Class003_IO {
    public static void main(String[] args) throws IOException {
        //1.构建流
        InputStream is = new FileInputStream("D://test2.txt");
        //2.准备卡车-->字节数组
        byte[] car = new byte[1024];
        //3.读入
        int len = -1;
        while((len=is.read(car))!=-1){
            //4.处理数据
            System.out.println(new String(car,0,len));;
        }

        //5.关闭
        is.close();
    }

2.字节输出流基类是OutputStream，此抽象类是表示输出字节流的所有类的超类（父类）

文件输出流-FileOutputStream,将数据写到指定文件中。

程序设计流程：1.定义输出流 2.准备数据 3.写出 4.刷出 5.关闭

注：如果设置的目的地文件不存在，系统会自动创建

输出流如果目的地文件存在，内容默认会覆盖原来文件内的内容，可以设置追加（在原文件内容中在其后添加）

//实例代码-字节输出流
public class Class005_IO {
    public static void main(String[] args) throws IOException {
        //1.定义输出流
        //FileOutputStream(String name)
        //FileOutputStream(File file)
        //FileOutputStream(File file, boolean append) 创建文件输出流以写入由指定的 File对象表示的文件。
        //FileOutputStream(String name, boolean append) 创建文件输出流以写入具有指定名称的文件。
        OutputStream os = new FileOutputStream("D://test.txt",true);
        //2.准备数据
        byte[] car = "你好就好,要过的没我好!!!!".getBytes();
        //3.写出
        //write(int b) 将指定的字节写入此文件输出流。
        //void write(byte[] b) 将指定字节数组中的 b.length字节写入此文件输出流。
        //void write(byte[] b, int off, int len) 将从偏移量 off开始的指定字节数组中的 len字节写入此文件输出流。
        os.write(97);
        os.write(car);
        //4.刷出
        os.flush();
        //5.关闭
        os.close();
    }
}

3.字节流结合实现文件拷贝

//实例代码
public class Class006_CopyFile {
    public static void main(String[] args){
        //1.创建流(输入 输出)
        //作用域提升,为了能够在finally中使用
        InputStream is = null;
        OutputStream os = null;
        try {
            is = new FileInputStream("D://test.txt");
            os = new FileOutputStream("D://dest.txt");
            //2.准备小汽车 字节数组
            byte[] car = new byte[1024];
            //3.读入-->写出
            int len = -1; //记录每次读入到字节数组中数据的个数
            while((len=is.read(car))!=-1){
                //读入多少字节数据写出多少字节数据
                os.write(car,0,len);
            }
            //4.刷出
            os.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //5.关闭(后打开的先关闭)
            //预防空指针异常出现
            if(os!=null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(is!=null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

（4）IO流—字符流(只能读写纯文本数据)

1.字符输入流，基类是Reader，文件字符输入流-FileReader

//实例代码-字符输入流
public class Class001_IO {
    public static void main(String[] args) throws IOException {
        //1.创建流
        //FileReader(String fileName)
        //FileReader(File file)
        Reader rd = new FileReader("D://test.txt");
        //2.读入
        //char ch = (char)(rd.read());
        //小汽车
        char[] car = new char[1024];
        //循环读入
        int len = -1;
        while((len = rd.read(car))!=-1){
            //3.处理数据
            System.out.println(new String(car,0,len));
        }
        //4.关闭
        rd.close();
    }
}

2.字符输出流 ，基类是Writer ,文件字符输出流-FileWriter

//实例代码-字符输出流
public class Class002_IO {
    public static void main(String[] args) throws IOException {
        //1.创建流
        //FileWriter(File file)
        //FileWriter(String fileName)
        //FileWriter(File file, boolean append)
        //FileWriter(String fileName, boolean append)
        Writer rt = new FileWriter("D://test.txt",true);
        //2.准备数据
        String msg = "今天也要加油鸭!!!";
        //3.写出
        rt.write(msg);
        //4.刷出
        rt.flush();
        //5.关闭
        rt.close();
    }
}

3.结合应用：字符流实现文件拷贝

//实例代码-字符流实现文件拷贝
public class Class003_IO {
    public static void main(String[] args){
        //1.创建流
        Reader rd = null;
        Writer rt = null;
        try {
            rd= new FileReader("D://test.txt");
            rt = new FileWriter("D://hehe.txt");
            //2.读入,写出
            char[] car = new char[1024];
            int len = -1;
            while((len = rd.read(car))!=-1){
                rt.write(car,0,len);
            }

            //3.刷出
            rt.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭
            if(rt!=null){
                try {
                    rt.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(rd!=null){
                try {
                    rd.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

字节流和字符流的用法几乎完全一致，区别在于它们所操作的数据单元不同，字节流（8 位）、字符流（16 位），字节流主要由 InputStream 和 OutputStream 作为基类，字符流主要由 Reader 和 Writer 作为基类。