Java基础：I/O流

原创 于 2021-06-23 21:45:09 发布 · 204 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

File的构造器


1.File file = new File("hello.txt");
2.File file2 = new File(parent路径,child路径);
例如：new File("Z:\\code_file","Idea_2019_3.5");
3.File file3 = new File(file2,"hello.txt");

File类的常用方法

File file = new File("hello.txt");
//getAbsolutePath():获取绝对路径
file.getAbsolutePath();
//getPath();
file.getPaht();
//getName():获取文件名
file.getName();
//getParent():获取父路径
file.getParent();
//length();
file.length();
//lastModified()::最后一次修改时间
file.lastModified();
//renameTo(otherFile):将file文件改名为file1放在file1文件目录下
//此时需要保证file时存在的，file1不存在
boolean b = file.renameTo(file1);





//如下的两个方法适用于文件目录：
//public String[] list() ：获取指定目录下的所有文件或者文件目录的名称数组
//public File[] listFiles() ：获取指定目录下的所有文件或者文件目录的File数组
String[] list = file.list();
for(String s:list){
	System.out.println(s);
}


File[] files = file.listFiles();
for(File f:files){
	System.out.println(f);
}



//isDirectory();判断是否是文件目录
file.isDirectory();
//isFile():判断是否是文件
file.isFile();
//exists()：判断是否存在
file.exists();
//canRead():判断是否可读
file.canRead();
//canWrite():判断是否可写
file.canWrite();
//isHidden():判断是否隐藏
file.isHidden();

    /*
    创建硬盘中对应的文件或文件目录
public boolean createNewFile() ：创建文件。若文件存在，则不创建，返回false
public boolean mkdir() ：创建文件目录。如果此文件目录存在，就不创建了。如果此文件目录的上层目录不存在，也不创建。
public boolean mkdirs() ：创建文件目录。如果此文件目录存在，就不创建了。如果上层文件目录不存在，一并创建

    删除磁盘中的文件或文件目录
public boolean delete()：删除文件或者文件夹
    删除注意事项：Java中的删除不走回收站。

     */

if(!file.exists()){
	file.createNewFile();
	System.out.println("创建成功");
}else{
	file.delete();
	System.out.println("创建成功");
}






        //文件目录的创建
        File file1 = new File("d:\\io\\io1\\io3");

        boolean mkdir = file1.mkdir();
        if(mkdir){
            System.out.println("创建成功1");
        }

        File file2 = new File("d:\\io\\io1\\io4");

        boolean mkdir1 = file2.mkdirs();
        if(mkdir1){
            System.out.println("创建成功2");
        }
        //要想删除成功，io4文件目录下不能有子目录或文件
        File file3 = new File("D:\\io\\io1\\io4");
        file3 = new File("D:\\io\\io1");
        System.out.println(file3.delete());

流的分类

1.操作数据单位：字节流、字符流
2.数据的流向：输入流、输出流
3.流的角色：节点流、处理流


流的体系结构
抽象基类          节点流
InputStream		  FileInputStream (read(byte[] buffer))
OutputStream	  FileOutputStream (write(byte[] buffer, 0,len)
Reader  		  FileReader (read(char[] cbuf))
Writer			  FileWriter(writer(char[] cbuf,0,len);

FileReader:将一个文本文件的内容输出

		//实例化
		File file = new File("test071.txt");
		//创建流
        FileReader fileReader = new FileReader(file);
		//读取文件
        int data;
        while((data = fileReader.read()) != -1){
            System.out.print((char)data);
        }
        //关闭流
        if(fileReader != null){
            fileReader.close();
        }

改进

	    File file = new File("test071.txt");
        FileReader fileReader = new FileReader(file);
        char[] chars = new char[1024];
        int len;
        while((len =fileReader.read(chars))!= -1){
            for (int i = 0; i < len; i++) {
                System.out.print(chars[i]);
            }
        }

        if(fileReader != null){
            fileReader.close();
        }

FileWriter:在一个文件中写入数据，如果文件不存在则创建文件

        //数据的写出
        File file = new File("hello1.txt");
         /*
        如果文件不存在，自动创建文件
        如果存在，覆盖原有文件
         */
//        FileWriter fw = new FileWriter(file,false);
        /*
        如果文件不存在，自动创建文件
        如果存在，不覆盖文件，而在原有文件的基础上追加内容
         */
        FileWriter fw = new FileWriter(file, true);
        fw.write("i have a dream");
        fw.write("\nyou need to have a dream");
        fw.close();

FileReader\FileWriter:复制一个文本文件

        File srcfile = new File("test071.txt");
        File destFile = new File("test110.txt");

        FileReader fileReader = new FileReader(srcfile);
        FileWriter fileWriter = new FileWriter(destFile);

        char[] cbuf = new char[5];
        int len;
        while((len = fileReader.read(cbuf)) != -1){
            fileWriter.write(cbuf,0,len);
        }

        if(fileReader != null){
            fileReader.close();
        }
        if(fileWriter != null){
            fileWriter.close();
        }

使用缓冲流

        //缓冲流（字符型）实现文本文件的复制
        BufferedReader br = new BufferedReader(new FileReader("hello.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("hejljflaj3.txt"));
        
        String data;
        while((data = br.readLine())!= null){
            bw.write(data + '\n');
            //or
            //bw.write(data);
            //bw.newline();
        }

        br.close();
        bw.close();

FileInputStream/FileOutputStream:复制一个非文本文件

        //非文本文件的复制：使用字节流处理
        File srcFile = new File("电脑四合一.jpg");
        File destFile = new File("copy.jpg");

        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(destFile);

        byte[] buffer = new byte[5];
        int len;
        while((len = fis.read(buffer))!= -1){
            fos.write(buffer,0,len);
        }

        fos.close();
        fis.close();

使用缓冲流对非文本文件实现复制

        //缓冲流实现非文本文件的复制
        File srcFile = new File("电脑四合一.jpg");
        File destFile = new File("复制品.jpg");

        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(destFile);

        BufferedInputStream bis = new BufferedInputStream(fis);
        BufferedOutputStream bos = new BufferedOutputStream(fos);

        byte[] buffer = new byte[1024];
        int len;
        while((len = bis.read(buffer)) != -1){
            bos.write(buffer,0,len);
        }

        bis.close();
        bos.close();

FileInputStream/InputStreamReader:改变文件的编码格式

        FileInputStream fis = new FileInputStream("hello.txt");
        InputStreamReader isr = new InputStreamReader(fis,"gbk");
        char[] cbuf = new char[10];
        int len;
        while((len = isr.read(cbuf))!= -1){
            for (int i = 0; i < len; i++) {
                System.out.print(cbuf[i]);
            }
        }
        isr.close();

        //1.造文件、造流
        File file1 = new File("dbcp.txt");
        File file2 = new File("dbcp_gbk.txt");

        FileInputStream fis = new FileInputStream(file1);
        FileOutputStream fos = new FileOutputStream(file2);

        InputStreamReader isr = new InputStreamReader(fis,"utf-8");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");

        //2.读写过程
        char[] cbuf = new char[20];
        int len;
        while((len = isr.read(cbuf)) != -1){
            osw.write(cbuf,0,len);
        }

        //3.关闭资源
        isr.close();
        osw.close();

InputStreamReader/BufferedReader:标准输入、输出流（你输入一个它抄一个）

     BufferedReader br = null;
        try {
            InputStreamReader isr = new InputStreamReader(System.in);
            br = new BufferedReader(isr);

            while (true) {
                System.out.println("请输入字符串：");
                String data = br.readLine();
                if ("e".equalsIgnoreCase(data) || "exit".equalsIgnoreCase(data)) {
                    System.out.println("程序结束");
                    break;
                }

                String upperCase = data.toUpperCase();
                System.out.println(upperCase);

            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }

不太懂的打印流和数据流

       //PrintStream \PrintWriter
        PrintStream ps = null;

        FileOutputStream fos = new FileOutputStream(new File("hello.txt"));
        ps = new PrintStream(fos,true);
        if(ps != null){
            System.setOut(ps);
        }
        for (int i = 0; i < 255; i++) {
            System.out.print((char)i);
            if(i % 50==0){
                System.out.println();
            }
        }

 //1.
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
        //2.
        dos.writeUTF("刘建辰");
        dos.flush();//刷新操作，将内存中的数据写入文件
        dos.writeInt(23);
        dos.flush();
        dos.writeBoolean(true);
        dos.flush();
        //3.
        dos.close();



//1.
        DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
        //2.
        String name = dis.readUTF();
        int age = dis.readInt();
        boolean isMale = dis.readBoolean();

        System.out.println("name = " + name);
        System.out.println("age = " + age);
        System.out.println("isMale = " + isMale);

        //3.
        dis.close();

ObjectOutputStream:序列化（将文本文件弄成看不懂的样子）和ObjectInputStream:反序列化过程（将看不懂的东西读出来）

        //序列化过程
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"));
        oos.writeObject(new String("i love beijing"));
        oos.flush();
        oos.writeObject(new Person("tom",24));
        oos.flush();
        if (oos != null) {
            oos.close();
        }

        //反序列化过程
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"));
        Object obj = ois.readObject();
        String str = (String)obj;
        System.out.println(str);


        int read = ois.read();
        System.out.println(read);
        if (ois != null) {
            ois.close();
        }

序列化的自定义类需要加private static final long serialVersionUID序列号

 //类序列化过程
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"));
        //需要实现Serializable接口
        //同时需要增加private static final long serialVersionUID序列号
        //如果不提供序列号，则在反序列化的时候可能找不到
        oos.writeObject(new Person("tom",24));
        oos.flush();
        if (oos != null) {
            oos.close();
        }


        //反序列化过程
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"));
        Object obj = ois.readObject();
        Person str = (Person)obj;
        System.out.println(str);
        if (ois != null) {
            ois.close();
        }

RandomAccessFile:修改文件的可读、可改属性

  //RandomAccessFile类
        /*
        1.RandomAccessFile直接继承于object类，实现了dataIput和DataOutput接口
        2.RandomAccessFile既可以作为一个输入流，又可以作为一个输出流
         */
        /*
        mode:
        r:只读
        rw:读取和写入
        rwd:读取和写入，同步文件内容的更新
        rws:读取和写入，同步文件内容和元数据的更新
         */
        RandomAccessFile raf1 = new RandomAccessFile(new File("微信图片_20210525115618.jpg"), "r");
        RandomAccessFile raf2 = new RandomAccessFile(new File("三上悠亚3.jpg"), "rw");

        byte[] bytes = new byte[1024];
        int len;
        while((len = raf1.read(bytes)) != -1){
            raf2.write(bytes,0,len);
        }
        if (raf1 != null) {
            raf1.close();
        }
        if (raf2 != null) {
            raf2.close();
        }

RandomAccessFile实现数据的输入

        RandomAccessFile raf1 = new RandomAccessFile("hello.txt", "rw");
        //如果作为输出流，写出到的文件如果不存在，则在执行过程中自动创建
        //如果文件存在，从头覆盖
        raf1.write("xyz".getBytes());

        raf1.close();

 RandomAccessFile raf1 = new RandomAccessFile("hello.txt", "rw");
        //从第三个位置开始覆盖
//        raf1.seek(3);
//        raf1.write("耶耶耶耶耶".getBytes());

        //展现一个插入的效果
        //插入操作
        StringBuffer stringBuffer = new StringBuffer((int) new File("hello.txt").length());
        byte[] bytes = new byte[1024];
        int len;
        while((len = raf1.read(bytes))!=-1){
            stringBuffer.append(new String(bytes,0,len));
        }
                raf1.seek(3);
        raf1.write("耶耶耶耶耶".getBytes());

        //将数据再写入
        raf1.write(stringBuffer.toString().getBytes());

        raf1.close();
Camellia0212
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值