java--File类与IO流详解

最新推荐文章于 2022-01-24 23:02:51 发布
最新推荐文章于 2022-01-24 23:02:51 发布
阅读量192 收藏 2
点赞数
分类专栏： java 文章标签： java 流处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lzq00277/article/details/117568012
版权

本文目录：

一、File类（实例化、基本方法、创建与删除）

package test;

import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.Date;

class Test {
    public static void main(String[] args) throws IOException {
        System.out.println("********File实例化********");
        // File(String path)
        File file1 = new File("D:"+File.separator+"work"+File.separator+"test");  // 绝对路径
        System.out.println(file1.getPath());

        // File(String parentPath,String childPath)
        File file2 = new File("DTest"+File.separator+"file","javaTest"); // 相对路径
        System.out.println(file2.getPath());

        // File(File file,String childPath)
        File file3 = new File(file1,"javaTest.iml");
        System.out.println(file2.getPath());


        System.out.println("********File实例方法********");
        // 获取路径
        System.out.println("getAbsolutePath:\t\t"+file2.getAbsolutePath());
        System.out.println("getPath:\t\t"+file2.getPath());
        System.out.println("getName:\t\t"+file2.getName());
        System.out.println("getParent:\t\t"+file2.getParent());
        System.out.println("length:\t\t\t"+file2.length());
        System.out.println("lastModified:\t"+new Date(file2.lastModified()));
        
        // 下一层文件集合（String)
        String[] list = file1.list();
        System.out.println("list:\t\t"+Arrays.asList(list));
        // 下一层文件集合（File)
        File[] files = file1.listFiles();
        for (File file : files) {
            System.out.print("listFiles:\t\t\t"+file.getName()+"  ");
        }
        System.out.println();

        // 文件重命名，file4存在，file5不能存在，返回布尔
        File file4 = new File(file1,"file1.txt");

        // 判断
        System.out.println("********判断********");
        System.out.println(file4.isDirectory());
        System.out.println(file4.isFile());
        System.out.println(file4.exists());
        System.out.println(file4.canRead());
        System.out.println(file4.canWrite());
        System.out.println(file4.isHidden());

        System.out.println("********File类创建与删除文件或目录********");
        File fileCreate = new File("createdFile.txt");
        System.out.println(fileCreate.createNewFile());
        System.out.println(fileCreate.delete());

        File fileCreatePath = new File("directory");
        System.out.println(fileCreatePath.mkdir());  // 单层目录
        File fileCreatePath1 = new File("directory1"+File.separator+"createdFiles");
        System.out.println(fileCreatePath1.mkdirs());// 多层目录
    }
}
// 输出：
********File实例化********
D:\work\test
DTest\file\javaTest
DTest\file\javaTest
********File实例方法********
getAbsolutePath:		D:\1file\JavaLearning\basicLearning\DTest\file\javaTest
getPath:		DTest\file\javaTest
getName:		javaTest
getParent:		DTest\file
length:			0
lastModified:	Thu Jan 01 08:00:00 CST 1970
list:		[directory1, directory2, directory3, file1.txt, file2.txt, file3.txt]
listFiles:			directory1  listFiles:			directory2  listFiles:			directory3  listFiles:			file1.txt  listFiles:			file2.txt  listFiles:			file3.txt  
********判断********
false
true
true
true
true
false
********File类创建与删除文件或目录********
true
true
false
false

二、IO流

1.IO流体系，基本分类

IO流体系

2.FileReader基本使用

package IOTest;

import org.junit.Test;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class IOTest {
    @Test
    public void FileReader() {
        // 实例化流
        FileReader fr = null;

        // 为了保证流资源一定可以执行关闭操作,需要使用try-catch-finally处理
        try {
            // 提供File对象，确认文件存在且有内容
            File file = new File("D:"+File.separator+"work"+File.separator+"test"+File.separator+"file1.txt");
            System.out.println(file.getAbsolutePath()+"    "+file.exists()+"    "+file.length());

            fr = new FileReader(file);

            // 读入数据,方式1
            /*int data = fr.read(); // read方法只读一个字符
            while (data != -1){
                System.out.print((char)data);
                data = fr.read();
            }*/

            // 读入数据,方式2
            /*int data;
            while ((data = fr.read()) != -1){ // read方法只读一个字符
                System.out.print((char)data);
            }*/

            // 读入数据,方式3,常用
            char [] data = new char[6]; // 声明数组作为read的参数，用于存放每次读入的数据
            int len ; // 每次读入数据的字符个数
            while ((len= fr.read(data)) != -1){
                // for (int i = 0; i < len; i++) {System.out.print(data[i]);}
                // 或者
                System.out.print(new String(data, 0, len));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                // 防止fr在实例化之前报异常进入finally报错，加判断后关闭
                if(fr != null)
                    fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
// 输出
D:\work\test\file1.txt    true    232
I don’t know what your dream is . 
I don’t care how disappointing it might have been, 
as you’ve been working toward that dream.
That dream that you are holding in your mind is possible. 

鹅鹅鹅，曲项向天歌

如果中文出现乱码，请将文件调整为utf8编码：
在这里插入图片描述

3.FileWriter基本使用

package IOTest;


import org.junit.Test;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class IOTest {
    @Test
    public void FileWriter() {
        // File实例化可以放在try外面，因为文件可以不存在
        File file = new File("D:"+File.separator+"work"+File.separator+"test"+File.separator+"file4.txt");
        FileWriter fw = null;
        try {
            // 文件不存在时，new时自动创建
            fw = new FileWriter(file); // 默认覆盖写,实例化时清空文件内容,并改变文件的修改时间与访问时间
            // fw = new FileWriter(file,true); // 追加写，,实例化不改变文件的修改时间与访问时间

            fw.write("I have an apple\n");
            fw.write("I have a pen\n");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

4.FileWriter与FileReader实现文件复制

package IOTest;

import org.junit.Test;

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class IOTest {
    @Test
    public void FileCopy() {
        FileReader fr = null;
        FileWriter fw = null;
        File toFile = new File("d:\\work\\test\\file5.txt");
        try {
            File fromFile = new File("d:\\work\\test\\file1.txt");

            fr = new FileReader(fromFile);
            fw = new FileWriter(toFile);

            char[] data = new char[6];
            int len ;
            while ((len = fr.read(data)) != -1){
                fw.write(data, 0, len); // 与fr.read()相同的写法
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if(fr != null)
                    fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fw != null)
                    fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

5.FileInputStream与FileOutputStream实现视频复制

package IOTest;

import org.junit.Test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class IOTest {
    @Test
    public void FileInputStream() {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        File toFile = new File("d:\\work\\test\\testVideoCopy.avi");
        try {
            File fromFile = new File("d:\\work\\test\\testVideo.avi");
            fis = new FileInputStream(fromFile);

            fos = new FileOutputStream(toFile);

            byte[] bytes = new byte[1024];
            int len;
            while ((len = fis.read(bytes)) != -1){
                fos.write(bytes, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fis != null)
                    fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fos != null)
                    fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

6.使用缓冲流FBufferedInputStream与BufferedOutputStream提高效率（生产常用）

package IOTest;

import org.junit.Test;

import java.io.*;

public class IOTest {
    @Test
    public void FileInputStream() {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        File toFile = new File("d:\\work\\test\\testVideoCopy1.avi");
        try {
            File fromFile = new File("d:\\work\\test\\testVideo.avi");
            fis = new FileInputStream(fromFile);
            bis = new BufferedInputStream(fis);
            fos = new FileOutputStream(toFile);
            bos = new BufferedOutputStream(fos);
            byte[] bytes = new byte[1024];
            int len;
            while ((len = bis.read(bytes)) != -1){
                bos.write(bytes, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fis != null)
                    fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fos != null)
                    fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

7.使用缓冲流bufferedReader 与bufferedWriter 提高文本读写效率（生产常用）

package IOTest;

import org.junit.Test;

import java.io.*;

public class IOTest {
    @Test
    public void FileInputStream() {

        BufferedReader bufferedReader = null;
        BufferedWriter bufferedWriter = null;
        File toFile = new File("d:\\work\\test\\file1-copy.txt");
        try {

            File fromFile = new File("d:\\work\\test\\file1.txt");

            FileReader fileReader = new FileReader(fromFile);
            FileWriter fileWriter = new FileWriter(toFile);

            bufferedReader = new BufferedReader(fileReader);
            bufferedWriter = new BufferedWriter(fileWriter);

            // 原始方法
            /*char[] chars = new char[10];
            int len ;
            while ((len= bufferedReader.read(chars)) != -1 ){
                bufferedWriter.write(chars,0,len);
            }*/

            // 每次读一行
            String str;
            while((str = bufferedReader.readLine()) != null){
                bufferedWriter.write(str);
                bufferedWriter.newLine(); // 换行,相当于bufferedWriter.write("\n");
            }

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

8.使用转换流InputStreamReader与OutputStreamWriter转换文本编码

package IOTest;

import org.junit.Test;

import java.io.*;

public class IOTest {
    @Test
    public void FileInputStream1() {
 //   转换流：属于字符流
 //   InputStreamReader：将一个字节的输入流转换为字符的输入流
 //   OutputStreamWriter：将一个字符的输出流转换为字节的输出流
        FileInputStream fis = null;
        FileOutputStream fos = null;
        InputStreamReader isr = null;
        OutputStreamWriter osw = null;
        File toFile = new File("file1-copy1.txt");
        try {
            File fromFile = new File("d:\\work\\test\\file1.txt");
            fis = new FileInputStream(fromFile);
            isr = new InputStreamReader(fis,"utf-8");
            fos = new FileOutputStream(toFile);
            osw = new OutputStreamWriter(fos,"gbk");
            char[] chars = new char[10];
            int len;
            while ((len = isr.read(chars)) != -1){
                System.out.println(len+"==="+new String(chars,0,len));
                osw.write(chars, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (isr != null)
                    isr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (osw != null)
                    osw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

9.使用标准输入流System.in

package IOTest;

import org.junit.Test;

import java.io.*;

public class IOTest {
    public static void main(String[] args) {
        BufferedReader br = null;
        try {
            //InputStream in = System.in;
            InputStreamReader isr = new InputStreamReader(System.in);
            br = new BufferedReader(isr);

                while (true){
                System.out.println("please input:");
                String s = br.readLine();
                if (s.equals("exit")){
                    break;
                }
                String upperCase = s.toUpperCase();
                System.out.println(upperCase);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (br != null)
                    br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

10.打印流PrintStream的使用

package IOTest;

import org.junit.Test;

import java.io.*;

public class IOTest {
    @Test
    public void test2() {
        PrintStream ps = null;
        try {
            FileOutputStream fos = new FileOutputStream(new File("D:\\work\\file1.txt"));
            // 创建打印输出流,设置为自动刷新模式(写入换行符或字节 '\n' 时都会刷新输出缓冲区)
            ps = new PrintStream(fos, true);
            if (ps != null) {// 把标准输出流(控制台输出)改成文件
                System.setOut(ps);
            }


            for (int i = 0; i <= 255; i++) { // 输出ASCII字符
                System.out.print((char) i);
                if (i % 50 == 0) { // 每50个数据一行
                    System.out.println(); // 换行
                }
            }


        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (ps != null) {
                ps.close();
            }
        }

    }
}

11.数据流DataOutputStream的使用

package IOTest;

import org.junit.Test;

import java.io.*;

public class IOTest {
    @Test
    public void test3() throws IOException {
        //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();
    }
}

12.对象流的序列化与反序列化

package IOTest;

import org.junit.Test;

import java.io.*;

public class IOTest {
    @Test
    public void ObjectStreamTest()  {
    // 序列化：ObjectOutputStream
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream("objects.obj"));
            oos.writeObject(new GoodWorker("yunWeiXiaoCai",22));
            oos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (oos != null)
                    oos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

		// 反序列化：ObjectInputStream 
        System.out.println("****反序列化过程****");
        GoodWorker goodWorker = null;
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream("objects.obj"));
            Object obj = ois.readObject();
            goodWorker = (GoodWorker)obj;
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                if (ois != null)
                    ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        System.out.println(goodWorker.getName());
    }
}


/* 1.需要实现接口：Serializable
 * 2.当前类提供一个全局常量：serialVersionUID
 * 3.除了当前Person类需要实现Serializable接口之外，还必须保证其内部所有属性也必须是可序列化的。（默认情况下，基本数据类型可序列化）
 * 4.ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量*/
class GoodWorker implements Serializable{
    private String name;
    private int age;

    public GoodWorker(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }
}
运维小菜
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java--IO流：File
本人随手记录，内容只是个人看懂程度，对内容有任何疑问请勿打扰
01-15 154
File类 I：iuput(输入流) O：output(输入流) 此文写的类都在io包下 File类的使用 1，File类的一个对象，代表一个文件或一个文件目录（文件夹） 2，File类声明在java.io包下 3，常用构造器 了解一些知识 相对路径：相较于某个路径下指明的路径 绝对路径：包含盘符在内的文件或文件目录的路径（完整的写完） 路径分隔符和系统有关： –》windows和DOS系统默认使...
JavaFile和IO流
Zp_support的博客
07-23 134
JavaSE之File和IO流
File类与I/O流
迷路的小绅士之家
03-13 175
1、IO流概述及分类 IO流用来处理设备之间的数据传输 Java对数据的操作是通过流的方式 Java用于操作流的类都在IO包中 流按流向分为两种：输入流，输出流 2、FileWriter类使用 FileWriter向文件中写数据操作步骤:    a:使用FileWriter流关联文件    b:利用FileWriter的写方法写数据    c:利用FileWriter的刷新方法将数据从内存刷到...
File类和IO流
热门推荐
七叔的博客
05-31 1万+
不从恶人的计谋，不站罪人的道路，不坐亵慢人的座位，惟喜爱耶和华的律法，昼夜思想，这人便为有福！他要像一棵树栽在溪水旁，按时候结果子，叶子也不枯干。凡他所做的尽都顺利。
File类与IO流
qq_59378215的博客
08-28 165
一、java.io.File类 1、File类：文件和目录路径名的抽象表示形式。 （1）无论是表示文件还是目录（文件夹）都是用File类的对象 （2）无论是表示文件还是目录，都是通过指定“路径名”来表示 例如：表示D盘的D:\to_student\尚硅谷_210728Java_柴林燕_JavaSE\ppt\尚硅谷_柴林燕_JDK8的安装及配置.pdf文件 表示D盘的D:\to_student\尚硅谷_210728Java_柴林燕_JavaSE\ppt文件夹 2、File类的API （1）获取文...
Java基础IO流之File类的使用
04-22
Java基础IO流之File类的使用 File类是Java中的一个基础类，用于处理文件和目录操作...File类是一个基础的IO流类，用于处理文件和目录操作。通过使用File类，可以轻松地进行文件和目录的创建、删除、获取、判断等操作。
详解java IO流之缓冲流的使用
08-31
Java IO流中的缓冲流是提高I/O操作性能的重要工具，它们并不直接进行读写操作，而是作为其他流的包装，通过内存缓冲区来优化数据传输。缓冲流分为字节缓冲流和字符缓冲流，每种又有输入和输出两种类型。 1. 字节...
java IO 字节流详解及实例代码
08-31
Java IO 字节流详解及实例代码 Java IO 字节流是 Java 编程语言中最基本的输入/输出机制。它提供了各种输入/输出流，以满足不同的输入/输出需求。在本文中，我们将详细介绍 Java IO 字节流的概念、分类、实例代码和...
commons-io-1.4.jar.zip_io流jar
最新发布
09-23
《Java IO流详解与commons-io-1.4.jar库的应用》 在Java编程语言中，IO（Input/Output）流是一组用于数据传输的类，它们允许程序读取和写入数据，无论是从磁盘、网络还是其他输入输出设备。Java的IO流系统是一个...
Java中File类中常用方法详解
08-27
Java中File类中常用方法详解 Java中的File类是java.io包下的一个类，用于描述和创建一个文件或文件夹对象。File类提供了许多常用的方法，用于对文件或文件夹进行操作。本文将对File类中常用的方法进行详细介绍。 ...
Java基础知识——File类与IO流
weixin_46025531的博客
01-24 545
文章目录一、File类1、File类的静态成员变量2、File类的构造方法3、File类的常用方法4、过滤器二、IO概述1、字节输出流 一、File类 1、File类的静态成员变量 static String pathSeparator：与系统有关的路径分隔符，为了方便，它被表示成一个字符串。window：分号 linux：冒号 static String separator：与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串。windows：反斜杠\ linux：正斜杠/.
Java中的File类和IO流
Jack
08-19 1万+
概述： 1.File：翻译是文件，用于表达java中的路径名。 2.路径：用于表示文件或者文件夹在当前系统中的位置 3.路径的分类： 绝对路径 相对路径 4.绝对路径：没有任何的歧义，也没有任何的前提条件 Windows，从盘符开始的路径，例如"D:/a/b/c/d/a.txt" ...
Java 常用IO流操作详解
weixin_40705360的博客
10-25 369
Java 常用IO流操作详解 1.基本概念 IO：Java对数据的操作是通过流的方式，IO流用来处理设备之间的数据传输，上传文件和下载文件，Java用于操作流的对象都在IO包中。 2.IO流的分类 图示：（主要IO流）    3.字节流 （1）.字节流基类 1）.InputStream InputStream：字节输入流基类，抽象类是表示字节输入流的所有...
File类和IO流的学习方法及总结-----黑马程序员
u011836617的专栏
08-31 725
---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ----------------------             I：就是input(输入)，O：就是output(输出)，所谓IO流就是输入输出流。 IO流：JAVA中的IO流就是为了实现文件和数据的输入输出。 要想使用IO流就得精通JAVA的文件类File类
IO流技术：开篇概述、File对象构建与相关方法的使用
Rocky_monkey的博客
05-16 291
本篇包含开篇知识储备，API使用规则、如何构建File对象、以及相关方法的使用。会通过Java编码分析。 一、开篇 IO概述： 即输入输出流，流动的即是数据，以二进制的形式呈现，即字节流。人对字符更敏感，我们也可操作字符流。字符流底层还是字节流，自动搜索了我们的码表。 推荐组件： CommonsIO 数据源： 就是存储数据的地方，例如网站、服务器、数据库。我们操作的是存储数据的文件。 其他： Ja...
java--NIO详解--Buffer、channel与网络编程
lzq00277的博客
06-13 1196
目录一、buffer--缓冲区的基本使用1.核心与基础用法2.实现字符集转换二、Channel的基本使用三、socketChannel网络编程--阻塞式四、socketChannel网络编程--非阻塞式1.Client客户端类2.Server服务端 一、buffer–缓冲区的基本使用 1.核心与基础用法 初始化缓冲区：XXXBuffer.allocate(int capacity) 数据加入缓冲区：buffer.put(byte[] data) 切换为读模式：byteBuffer.flip() 读取缓冲区

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

运维小菜

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值