Java基础-IO

最新推荐文章于 2024-09-13 17:30:19 发布
最新推荐文章于 2024-09-13 17:30:19 发布
阅读量72 收藏
点赞数
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014215131/article/details/112788421
版权

1.File类

  • java.io.File类：文件和文件目录路径的抽象表示形式
  • File能新建、删除、重命名文件和目录，但File不能访问文件内容本身。如需要访问，需要输入\输出流
  • File对象可以作为参数传递给流的构造器

File类的方法使用

public class FileTest {

    //创建File类的实例
    //File类中涉及到关于文件或目录的创建、删除、重命名、修改时间、文件大小的方法，并未涉及读写内容的操作
    //File类的对象常会作为参数传递到流的构造器中
    @Test
    public void test1() {
        File file1 = new File("hello.txt");//相对于当前Model路径
        //路径分隔符 windows\\ unix/
        File file2 = new File("C:" + File.separator + "Users" + File.separator + "IdeaProjects\\JavaBasis");//绝对路径
        File file3 = new File("D:/work", "Java");
        File file4 = new File(file3, "hi.txt");

        //File的方法使用
        File file = new File("D:/io/");
        System.out.println(file1.getAbsolutePath());
        System.out.println(file1.getPath());
        System.out.println(file1.getName());
        System.out.println(file1.getParent());
        System.out.println(file1.length());
        System.out.println(file1.lastModified());

        System.out.println(file.isDirectory());
        System.out.println(file.isFile());
        System.out.println(file.exists());
        System.out.println(file.canRead());
        System.out.println(file.canWrite());
        System.out.println(file.isHidden());

        String[] list = file.list();
        for (String s : list) {
            System.out.println(s);
        }

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

    //创建硬盘中对应的文件或目录，删除
    @Test
    public void test2() throws IOException {
        File file = new File("hi.txt");
        if (!file.exists()) {
            file.createNewFile();
            System.out.println("创建成功");
        } else {
            file.delete();
            System.out.println("删除成功");
        }

        File file1 = new File("D:/io/io2");
        boolean mkdir = file1.mkdir();
        if (mkdir) {
            System.out.println("创建成功");
        }
    }
}

2. IO原理及分类

  • Input/Output，用于处理设备间的数据传输，如读写文件，网络通讯
  • Java中，对于数据的输入/输出以“流(stream)”的方式进行
  • java.io包下提供了各种流类和接口，用以获取不同种类的数据，并以标准的方法输入或输出数据
  • 按操作数据单位不同分为：字节流(8bit)，字符流(16bit)
  • 按数据流的流向不同：输入流，输出流
  • 按流的角色不同：节点流，处理流
抽象基类字节流字符流
输入流InputStreamReader
输出流OutputStreamWriter

流
流体系

3. 节点流（文件流）

public class FileReaderWriterTest {

    @Test
    public void testFileReader() {
        FileReader fr = null;
        try {
            File file = new File("hello.txt");
            fr = new FileReader(file);

            //read()返回读入的一个字符，如果达到文件末尾，返回-1
            int len;
            char[] cbuf = new char[5];
            while ((len = fr.read(cbuf)) != -1) {
//                for (int i = 0; i < len; i++) {
//                    System.out.println(cbuf[i]);
//                }
                String str = new String(cbuf, 0, len);
                System.out.print(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //流的关闭
            try {
                if (fr != null) {
                    fr.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @Test
    public void testFileWriter() {
        FileWriter fileWriter = null;
        try {
            File file = new File("hello1.txt");
            fileWriter = new FileWriter(file, true);

            fileWriter.write("hello\n");
            fileWriter.write("world");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileWriter != null) {
                    fileWriter.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

        }


    }

    @Test
    public void testFileCopy() {
        FileReader reader = null;
        FileWriter writer = null;
        try {
            File srcFile = new File("hello.txt");
            File destFile = new File("hello1.txt");

            reader = new FileReader(srcFile);
            writer = new FileWriter(destFile);

            char[] cbuf = new char[5];
            int len;//记录每次读入到cbyf数组中字符的个数
            while ((len = reader.read(cbuf)) != -1) {
                //每次写出len个字符
                writer.write(cbuf, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (writer != null) {
                    writer.close();
                }

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


    }
}


public class FileInputStreamTest {

    @Test
    public void testFileInputStream() {
        FileInputStream inputStream = null;
        try {
            File file = new File("hello.txt");

            inputStream = new FileInputStream(file);

            byte[] buffer = new byte[5];
            int len;//记录每次读取字节的个数
            while ((len = inputStream.read(buffer)) != -1) {
                String s = new String(buffer, 0, len);
                System.out.print(s);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Test
    public void testFileCopy() {
        FileInputStream inputStream = null;
        FileOutputStream outputStream = null;
        try {
            File srcFile = new File("wx.png");
            File destFile = new File("ex.png");

            inputStream = new FileInputStream(srcFile);
            outputStream = new FileOutputStream(destFile);

            byte[] buffer = new byte[5];
            int len;
            while ((len = inputStream.read(buffer)) != -1) {
                outputStream.write(buffer, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (inputStream != null) {
                    inputStream.close();
                }

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

    //指定路径下文件的复制
    public void copyFile(String srcPath, String destPath) {
        FileInputStream inputStream = null;
        FileOutputStream outputStream = null;
        try {
            File srcFile = new File(srcPath);
            File destFile = new File(destPath);

            inputStream = new FileInputStream(srcFile);
            outputStream = new FileOutputStream(destFile);

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

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

4. 缓冲流（处理流的一种）

/*处理流之一缓冲流的使用
 * BufferedInputStream BufferedOutputStream
 * BufferedReader      BufferedWriter
 * 内部提供了一个缓冲区，提高流的读取、写入的速度
 * */
public class BufferedTest {
    @Test
    public void bufferedStreamTest() {
        FileInputStream fis = null;
        FileOutputStream fps = null;
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            File srcFile = new File("ex.png");
            File destFile = new File("wx2.png");
            fis = new FileInputStream(srcFile);
            fps = new FileOutputStream(destFile);
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fps);

            byte[] buffer = new byte[10];
            int len;
            while ((len = bis.read(buffer)) != -1) {
                bos.write(buffer, 0, len);
                //bos.flush();//刷新缓冲区
            }

//            String data;
//            while((data=br.readLine())!=null){
//                bw.write(data);
//                bw.newLine():
//            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (bos != null) {
                    bos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (bis != null) {
                    bis.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            //fps.close();
            //fis.close();
        }


    }
}

5. 转换流

  • 提供了在字节流和字符流之间的转换
  • InputStreamReader:InputStream->Reader
  • OutputStreamWriter:Writer->OutputStream
  • 字节流中的数据都是字符时，转成字符流操作更高效
  • 很多时候实现编码和解码的功能
/*处理流之二：转换流的使用
* 提供字节流与字符流之间的转换
* */
public class InputStreamReaderTest {
    @Test
    public void test1() throws IOException {
        FileInputStream fis = new FileInputStream("hello.txt");
        FileOutputStream fos = new FileOutputStream("h2.txt");
        InputStreamReader isr = new InputStreamReader(fis,"UTF-8");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");

        char[] cbuf = new char[10];
        int len;
        while ((len = isr.read(cbuf)) != -1) {
            osw.write(cbuf,0,len);
        }
        osw.close();
        isr.close();
    }

}

6. 标准输入、输出流

  • System.in和System.out分别代表了系统标准的输入和输出设备
  • System.in的类型是InputStream，System.out的类型是PrintStream
  • 重定向：通过System类的setIn,setOut方法对默认设备进行改变
public class OtherStreamTest {
    //标准输入输出流
    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);

        while (true) {
            System.out.println("输入");
            String data = br.readLine();
            if ("exit".equalsIgnoreCase(data)) {
                System.out.println("程序结束 ");
                break;
            }
            String s = data.toUpperCase();
            System.out.println(s);
        }
        br.close();
    }
}

7. 打印流

  • 将基本数据类型的数据格式转化为字符串输出
  • PrintStream和PrintWriter提供了一系列的print()和println()方法，用于多种数据类型的输出，有自动flush功能

8. 数据流

  • 为了方便操作Java的基本数据类型和String的数据，可以使用数据流
  • DataInputStream和DataOutputStream分别套在InputStream和OutputStream子类的流上
@Test
    public void test1() throws IOException {
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
        dos.writeUTF("gai");
        dos.flush();//刷新操作，将内存中的写入文件
        dos.writeInt(22);
        dos.flush();
        dos.writeBoolean(true);
        dos.flush();
        dos.close();
    }

    @Test
    public void test2() throws IOException {
        DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
        System.out.println(dis.readUTF());
        System.out.println(dis.readInt());
        System.out.println(dis.readBoolean());
        dis.close();
    }

9. 对象流

  • ObjectInputStream和ObjectOutputStream，用于存储和读取基本数据类型数据或对象的处理流，可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来
  • 序列化：ObjectOutputStream保存基本类型数据或对象的机制
  • 反序列化：ObjectInputStream读取基本类型数据或对象的机制
  • 不能序列化static和transient修饰的成员变量

对象序列化机制允许把内存中的Java对象转换成二进制流，从而允许把这种二进制流持久地保存在磁盘中，或通过网络将这种二进制流传输到另一个网络节点
为了让某个类是可序列化地，该类必须实现两个接口之一：Serializable、Externalizable，其内部属性也必须是可序列化的
private static final long serialVersonUID;用来表明类的不同版本间的兼容性

//对象流的使用ObjectInputStream和ObjectOutputStream
public class ObjectStreamTest {

    //序列化过程
    @Test
    public void test1() throws IOException, ClassNotFoundException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.dat"));
        oos.writeObject(new Person("天才",10));
        oos.flush();
        oos.close();

        //反序列化
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.dat"));
        Object o = ois.readObject();
        System.out.println(o);
        ois.close();
    }
}

10. 随机存取文件流

  • RandomAccessFile类声明在java.io包下，直接继承于java.lang.Object类，这个类既可以读也可以写，程序可以直接跳到文件的任意地方来读写文件
public class RandomAccessFileTest {

    @Test
    public void test1() throws IOException {
        RandomAccessFile raf1 = new RandomAccessFile(new File("ex.png"), "r");
        RandomAccessFile raf2 = new RandomAccessFile(new File("ex1.png"), "rw");
        byte[] buffer = new byte[1024];
        int len;
        while ((len = raf1.read(buffer)) != -1) {
            raf2.write(buffer, 0, len);
        }
        raf1.close();
        raf2.close();
    }

    //使用RandomAccessFile实现插入效果
    @Test
    public void test2() throws IOException {
        //如果写到的文件存在，则对原有文件从头覆盖
        RandomAccessFile raf1 = new RandomAccessFile("hello.txt", "rw");
        raf1.seek(3);//文件为3的位置
        StringBuilder builder = new StringBuilder((int) new File("hello.txt").length());
        byte[] buffer = new byte[20];
        int len;
        while ((len = raf1.read(buffer)) != -1) {
            builder.append(new String(buffer,0,len));
        }
        raf1.seek(3);
        raf1.write("xyz".getBytes());
        //将StringBuild写入
        raf1.write(builder.toString().getBytes());
        raf1.close();
    }
}

11. NIO.2中Path、Paths、Files类的使用

  • Java NIO(Non-Blocking IO)是Java1.4后开始引入一套新的IO API，NIO支持面向缓冲区的（IO是面向流的）、基于通道的IO操作
  • Java API提供了两套NIO，一套是针对标准输入输出NIO，一套是网络编程NIO
  • JDK7后，Java对NIO进行了扩展NIO.2，增强了对文件处理喝文件系统特性的支持
  • Path可以看成是File类的升级版本，Files用于操作文件或目录的工具类
盖大大
关注
专栏目录
Java基础---IO流
我是太阳
01-30 2万+
1、File类的使用 常用构造器 路径分隔符 常用方法 2、IO流原理及流的分类 3、节点流(或文件流) 4、缓冲流 5、转换流 6、标准输入、输出流 7、 打印流 8、数据流 9、对象流 10、随机存取文件流 11、Path、Paths、Files类的使用 ...
大学课程讲义-Java基础-IO
08-14
Java 基础 - IO Java 的 IO 流主要包括输入、输出两种 IO 流，每种输入、输出流有可分为字节流和字符流两大类。字节流以字节为单位来处理输入、输出操作，字符流以字符为单位来处理输入、输出操作。 ### IO 概述 ...
【Java基础-3】吃透Java IO：字节流、字符流、缓冲流
热门推荐
云深不知处
09-23 15万+
什么是Java-IO？字符流和字节流的区别与适用场景是什么？缓冲流到底实现了什么？如何高效地读写文件？ 本文用大量的示例图和实例，带你吃透Java IO。
Java基础-IO流
Java硬件工程师的博客
02-07 2227
1.IO流概述 输入输出都是参照内存的，从内存里面出来，叫做输出，进入内存，叫输入。 I : Input O : Output 通过IO可以完成硬盘文件的读和写。 2.IO流概述 有多种分类方式： 一种方式是按照流的方向进行分类： 以内存作为参照物， 往内存中去，叫做输入(Input)。或者叫做读(Read)。 从内存中出来，叫做输出(Output)。或者叫做写(Write)。 另一种方式是按照读取数据方式不同进行分类： 有的流是按照字节的方式读取数据，一次读取1个字节byte，等同于一次读取8个
java基础-IO流【理论篇】
weixin_44050211的博客
09-12 752
IO流是java知识体系中很重要的一部分
Java中commons-IO
2401_84048445的博客
04-30 713
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！commons-io-2.4.jar 就是需要导入到项目中的 jar 包，里面存放的是class文件commons-io-2.4-sources.jar 工具类中原代码docs 是帮助文档我使用的是IDEA，这里讲一下再IDEA 中如何导包，以commons-io jar 包为例三、commons-io 的使用================这个工具类是用来处理文件名（文件路径）的，可以轻松解决不同操作系统文
【Java】工具包（Commons-io）
qq_39921135的博客
07-14 1389
但是在以后我们会用到很多很多别人写好的代码，因此在正式使用的第一步是：在项目中新建一个文件夹：lib，这个文件夹以后去专门存放第三方jar包。中其实就是别人写好的各种各样的类，如果你想要使用这些类中的方法，是不能直接用的，而是需要先将别人的代码导入到我们自己的项目中。这个组织有很多很多项目，现在在世界各地被广泛的使用，这些开源的项目为Java的快速发展提供了不可磨灭的贡献。淘汰了，它也会出现其他的替代品，但是只要基础扎实了，这些替代品学起来也是非常简单的。双击打开，是可以将jar包展开，看见里面的内容。
Java基础——IO
qq_52519008的博客
10-01 2583
流（Stream），是一个抽象的概念，是指一连串的数据（字符或字节），是以先进先出的方式发送信息的通道。当程序需要读取数据的时候，就会开启一个通向数据源的流，这个数据源可以是文件，内存，或是网络连接。类似的，当程序需要写入数据的时候，就会开启一个通向目的地的流。这时候你就可以想象数据好像在这其中“流”动一样。
commons-io工具包的基本使用
热爱编程、热爱生活、热爱探索
08-28 2612
在Java中IO操作很常见，原始的码代码会有很多重复操作，过程很烦锁，这就需要诞生一种新技术来减少这种重复的代码操作，让程序员有更多的时间干正真有意义的事情。于是就诞生了commons-io，它是开源基金组织提供的一组有关IO操作的类库，可以提高IO功能开发的效率，commons-io工具包提供了很多有关io操作的类。有两个主要的类,。commons-io相关（也可以直接在官网下载）温馨提示.........
Java基础-IO流-将学生信息添加入集合并从高到底排序写入文件中
NONAME999的博客
12-16 1328
录入五个学生信息，按总分高低，存储至文本文件中 1、创建学生对象 2、创建集合对象 TreeSet(自然排序，或比较器排序) 3、键盘录入学生信息，存储到集合 4、从集合中获取元素，写入文件 创建学生类 这里偷懒了 没有私有化属性
Java基础--IO流--中文乱码问题
buttterfly的博客
05-19 1605
FileOutputStream向文件输出中文 因为write方法中参数没有String，所以向文件中输出中，得把字符串转换成byte[]数组。 import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; public class FileOutputStreamTest01 { public static void main(String[] args) {
java基础- IO（输入/输出）的使用
06-15
Java中的IO（输入/输出）是一种用于与外部资源（如文件、网络连接、数据库等）进行数据交互的机制。在Java中，主要使用java.io包提供的类和接口来进行IO操作。
Java-Io流，练习
07-06
本练习旨在帮助初学者理解和掌握Java IO流的基础知识。 一、IO流的概念 IO流在Java中分为两大类：输入流（Input Stream）和输出流（Output Stream）。输入流用于从源（如文件、网络连接等）读取数据，而输出流则...
Java IO commons-io-2.5.jar
04-02
`commons-io-2.5.jar` 是Apache Commons项目的一部分，它提供了一系列增强和扩展了Java标准IO库的类和方法。这个库为开发者提供了更高效、更便捷的方式来执行常见的文件、目录和流操作。 一、Java IO 基础 Java IO ...
java-io-guide:Java中的Java IO（输入和输出流）指南
04-29
Java I / O基础 文件处理示例 File示例列表，显示了使用Java I / O创建，读取，写入，修改文件以及获取文件信息的方法。 使用BufferInputStream读取文件 使用DataInputStream读取文件 以字节为单位获取文件大小KB MB...
spring事务详细讲解-深入浅出
小电玩
09-08 519
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1504
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
自动生成不重复的订单id
最新发布
ClaireCheney的博客
09-13 132
【代码】自动生成不重复的订单id。
Java集合：Stack详解
yang_brother的博客
09-10 568
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
Java基础教程：IO流详解
"Java基础知识，特别是关于IO流的整理，涵盖了File类的使用以及字节流和字符流的概念。这份文档包含对不同读取文件方法的示例代码，旨在帮助学习者理解Java中的输入/输出操作。" 在Java中，IO（Input/Output）流是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值