IO集合框架和File类的使用

于 2022-08-05 20:28:28 发布
阅读量111 收藏
点赞数
分类专栏： Java 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_47945117/article/details/126185076
版权

I/O 框架

流的概念

定义：内存与存储设备之间传输数据的通道

流的分类

1、按方向【重点】

  • 输入流：将<存储设备>中的内容读到<内存>中
  • 输出流：将<内存>中的内容写到<存储设备>中

2、按单位

  • 字节流：以字节为单位，可以读写所有数据
  • 字符流：以字符为单位，只能读写文本数据

3、按功能

  • 节点流：具有实际传输数据的读写功能
  • 过滤流：在节点流的基础之上增强功能

字节流的父类（抽象类）

//InputStream 字节输入流
public int read(){}
public int read(byte[] b){}
public int read(byte[] b, int off, int len){}

// OutputStream 字节输出流
public void write(int n){}
public void write(byte[] b){}
public void write(byte[] b, int off, int len){}

文件字节流

FlieInputStream

public class Demo01 {
    public static void main(String[] args) throws Exception{

        //创建文件字节输入流 FileInputStream(文件的路径)
        FileInputStream fis = new FileInputStream("/Users/duandonghua/Desktop/IO.rtf");
        //读取文件
        int date =0;
        while ((date=fis.read())!=-1){
            System.out.print((char) date);
        }
        System.out.println("");
        System.out.println("==============");

        byte[] buf = new byte[1024];
        int counts = 0;
        while ((counts=fis.read(buf))!=-1){
            System.out.println(new String(buf,0,counts));
        }
        //关闭io
        fis.close();
    }
}

FlieOutputStream

import java.io.FileOutputStream;

public class Demo02 {
    public static void main(String[] args) throws Exception{
        //FlieOutputStream 文件字节输出流
        //创建文件字节输出流
        FileOutputStream fos = new FileOutputStream("/Users/duandonghua/Desktop/IO.rtf");
        //写入文件
        fos.write(97);
        fos.write('a');
        fos.write('b');
        //关闭io
        fos.close();
    }
}

习题

使用文件字节流复制文件

public class Demo04 {
    //使用字节缓冲流写入文件
    public static void main(String[] args) throws Exception{
        //创建字节输出缓冲流
        FileOutputStream fos = new FileOutputStream("/Users/duandonghua/Desktop/fos.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //写入文件
        for (int i = 0; i < 10; i++) {
            bos.write("hello word\r\n".getBytes());
            bos.flush();
        }
        //关闭
        bos.close();

    }
}

字节缓冲流

缓冲流：BufferedInputStream/ BufferedOutputStream

  • 提高IO效率，减少访问磁盘次数
  • 数据存储在缓冲区中，flush是将缓冲区的内容写入文件中，也可以直接close
public class Demo05 {
    public static void main(String[] args) throws Exception{
        //使用字节缓冲流复制文件
        //创建文件字节流和字节缓冲流
        FileInputStream fis = new FileInputStream("/Users/duandonghua/Desktop/jxj.pdf");
        BufferedInputStream bis = new BufferedInputStream(fis);
        FileOutputStream fos = new FileOutputStream("/Users/duandonghua/Desktop/jxj2.pdf");
        BufferedOutputStream bos = new BufferedOutputStream(fos) ;
        //实现复制
        int count =0;
        while ((count=bis.read())!=-1){
            bos.write(count);
            bos.flush();
        }
        //关闭io
        bis.close();
        bos.close();
    }

}

对象流

ObjectOutputStream / ObjectInputStream

  • 增强了缓冲区功能

  • 增强了读写8种基本数据类型和字符串的功能

  • 增强了读写对象的功能

    • readObject() 从流中读取一个对象
    • writeObject(Object obj) 向流中写入一个对象
    public class Demo06 {
    public static void main(String[] args) throws Exception{
        //使用obiectoutputStream 实现学生类的序列化
        //创建对象流
        FileOutputStream fos =new FileOutputStream("/Users/duandonghua/Desktop/stu.bin");
        ObjectOutputStream oos = new ObjectOutputStream(fos);

        //实现序列化
        Student zhanghua =new Student("张三",18);
        Student lisi =new Student("李四",22);
        ArrayList<Student> list =new ArrayList<>();
        list.add(zhanghua);
        list.add(lisi);
        oos.writeObject(list);


        //关闭
        oos.close();
        System.out.println("序列化完毕");
    }
}

    //使用ObjectInputStream实现反序列化 读取重构对象
public class Demo07 {
    public static void main(String[] args) throws Exception{
        //创建对象流
        FileInputStream fis = new FileInputStream("/Users/duandonghua/Desktop/stu.bin");
        ObjectInputStream ois = new ObjectInputStream(fis);

        //读取文件
        //Student a=(Student) ois.readObject();
        //Student b=(Student) ois.readObject();
        ArrayList<Student> list =(ArrayList<Student>) ois.readObject();

        //关闭
        ois.close();
        System.out.println("反序列化完毕");
        //System.out.println(a.toString());
        //System.out.println(b.toString());
        System.out.println(list.toString());
    }
}

序列化

使用流传输对象的过程称为序列化、反序列化

注意点：

  1. 某个类要想序列化必须实现Serializable接口
  2. 序列化类中对象属性要求实现Serializable接口
  3. 序列化版本号ID，保证序列化的类和反序列化的类是同一个类
  4. 使用transient修饰属性，这个属性就不能序列化
  5. 静态属性不能序列化
  6. 序列化多个对象，可以借助集合来实现
//使用ObjectInputStream实现反序列化 读取重构对象
public class Demo07 {
    public static void main(String[] args) throws Exception{
        //创建对象流
        FileInputStream fis = new FileInputStream("/Users/duandonghua/Desktop/stu.bin");
        ObjectInputStream ois = new ObjectInputStream(fis);

        //读取文件
        //Student a=(Student) ois.readObject();
        //Student b=(Student) ois.readObject();
        ArrayList<Student> list =(ArrayList<Student>) ois.readObject();

        //关闭
        ois.close();
        System.out.println("反序列化完毕");
        //System.out.println(a.toString());
        //System.out.println(b.toString());
        System.out.println(list.toString());
    }
}

编码方式

UTF-8：针对Unicode的编码的可变长字符编码

GBK：简体中文，扩充

字符流

字符流的父类（抽象类）

reader 字符输入流

  • public int read(){}
  • public int read(char[] c){}
  • public int read(char[] b, int off, int len){}

Writer 字符输出流

  • public void write(int n){}
  • public void write(String str){}
  • public void write(char[] c){}

文件字符流

FileRead/FileWrite

//使用文件字符流复制文件，只能复制文本文件，其他的都不可以
public class Demo09 {
    public static void main(String[] args) throws Exception {
        //利用文件字符流FlieReader读取文件内容
        //创建文件字符流
        FileReader fr = new FileReader("/Users/duandonghua/Desktop/fos.txt");
        //读取方法1
        //int date = 0;
        //while ((date=fr.read())!=-1){
            //System.out.print((char) date);
        //}
        //读取方法2
        char[] buf =new char[1024];
        int count = 0;
        while ((count=fr.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }

        System.out.println("读取完毕开始写入");
        //利用文件字符流FlieWrite写入文件内容
        //创建文件字符流
        FileWriter fw =new FileWriter("/Users/duandonghua/Desktop/fzfos.txt");
        //写入数据
        int counts = 0;
        while ((counts=fr.read())!=-1){
            fw.write(counts);
            fw.flush();
        }
        //关闭
        fw.close();
        fr.close();
        System.out.println("写入完毕");
    }
}

字符流进行文本文件复制

不能复制图片或二进制文件，使用字节流可以复制任意文件

//利用文件字符流复制文件，只能复制文本文件，其他文件复制不了
public class Demo10 {
    public static void main(String[] args) throws Exception{
        FileReader fr = new FileReader("/Users/duandonghua/Desktop/fos.txt");
        FileWriter fw =new FileWriter("/Users/duandonghua/Desktop/fzfos.txt");
        int counts = 0;
        while ((counts=fr.read())!=-1){
            fw.write(counts);
            fw.flush();
        }
        fr.close();
        fw.close();
    }
}

字符缓冲流

BufferedReader / BufferedWriter

高效读写、支持输入换行符、可一次写一行读一行

/*
使用字符缓冲流高效的复制文件
 */
public class Demo11 {
    public static void main(String[] args) throws Exception {
        //创建文件字符流
        FileReader fr=new FileReader("/Users/duandonghua/Desktop/fos.txt");
        FileWriter fw=new FileWriter("/Users/duandonghua/Desktop/fos2.txt");

        //创建字符缓冲流
        BufferedReader br = new BufferedReader(fr);
        BufferedWriter bw = new BufferedWriter(fw);

        //实现复制功能
        int date = 0;
        while ((date=fr.read())!=-1){
            fw.write(date);
            fw.flush();
        }

        //关闭
        br.close();
        fw.close();
    }
}

打印流

PrintWriter封装了print() / println() 方法

支持写入后换行

支持数据原样打印

public class Demo14 {
    public static void main(String[] args) throws Exception{
        //创建打印流
        PrintWriter pw = new PrintWriter("/Users/duandonghua/Desktop/print.txt");
        //打印
        pw.println(97);
        pw.println(true);
        pw.println(3.14);
        pw.println('a');
        //关闭
        pw.close();
        System.out.println("打印完成");
    }
}

转换流

桥转换流 InputStreamReader / OutputStreamWriter

可将字节流转换为字符流

可设置字符的编码方式

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
//使用OutputStreamWriter写入文件，并且指定编码
public class Demo15 {
    public static void main(String[] args) throws Exception{
        //创建OutputStreamWriter
        FileOutputStream fis =new FileOutputStream("/Users/duandonghua/Desktop/osw.txt");
        OutputStreamWriter isr = new OutputStreamWriter(fis,"gbk");
        //写入
        for (int i = 0; i < 10; i++) {
            isr.write("我是中弱的\n");
            isr.flush();
        }
        //关闭
        isr.close();
        System.out.println("写入完成");
    }
}

File类

概念：代表物理盘符中的一个文件或者文件夹

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

public class Demo01 {
    public static void main(String[] args) throws Exception{
        separator();
        fileope();
    }
    //分隔符
    public static void separator(){
        System.out.println("路径分隔符"+ File.pathSeparator);
        System.out.println("名称分隔符"+File.separator);
    }

    //文件操作
    public static void fileope() throws Exception{
        //创建文件
        File file = new File("/Users/duandonghua/Desktop/file.txt");
        if (!file.exists()){
            boolean b=file.createNewFile();
            System.out.println("文件创建结果"+b);
        }

        //删除文件
        //1.1直接删除
        //System.out.println("删除结果"+file.delete());
        //1.2使用JVM退出时删除
        //file.deleteOnExit();
        //Thread.sleep(5000);

        //获取文件信息
        System.out.println("文件绝对路径："+file.getAbsoluteFile());
        System.out.println("获取路径:"+file.getPath());
        System.out.println("文件名称:"+file.getName());
        System.out.println("父目录:"+file.getParent());
        System.out.println("文件长度:"+file.length());
        System.out.println("文件创建时间:"+new Date(file.lastModified()).toLocaleString());

        //判断
        System.out.println("是否可写"+file.canWrite());
        System.out.println("是否是文件"+file.isFile());
        System.out.println("是否隐藏"+file.isHidden());
    }
}

/**
 * 案例：
 * 1、递归遍历文件夹
 * 2、递归删除文件夹
 */
public class FileCase {
    public static void main(String[] args) throws Exception {
            listDir(new File("F:\\idea\\temp"));
            deleteDir(new File("F:\\idea\\temp\\file"));
        }

        public static void listDir(File dir) {
            File[] files = dir.listFiles();  //把文件夹或者文件存入数组
            System.out.println(dir.getAbsolutePath());
            if (files != null && files.length > 0) {
                for (File file : files) {
                    if (file.isDirectory()) { //如果是文件夹
                        listDir(file); // 递归
                    } else {
                        System.out.println(file.getAbsolutePath());
                    }
                }
            }
        }
    public static void deleteDir(File dir){
        File[] files = dir.listFiles();
        if(files != null && files.length > 0){
            for(File file : files){
                if(file.isDirectory()){
                    deleteDir(file); // 递归
                }else{
                    // 删除文件
                    System.out.println(file.getAbsolutePath() + "删除结果为：" + file.delete());
                }
            }
        }
        System.out.println(dir.getAbsolutePath() + "删除结果为：" + dir.delete());
    }
}

import java.io.File;
import java.io.FileFilter;
import java.util.Date;

public class Demo02 {
    public static void main(String[] args) {

    }

    public static void separator() {
        System.out.println("路径分隔符" + File.pathSeparator);
        System.out.println("名称分隔符" + File.separator);
    }

    //文件操作
    public static void fileope() throws Exception {
        //创建文件夹
        File dir = new File("/Users/duandonghua/Desktop/file");
        if (!dir.exists()) {
            //boolean b=dir.mkdir();  //创建单级目录
            boolean b = dir.mkdirs();    //创建多级目录
            System.out.println("文件夹创建结果" + b);
        }

        //删除文件夹
        //1.1直接删除
        //System.out.println("删除结果"+dir.delete());  //删除必须是空目录
        //1.2使用JVM退出时删除
        //dir.deleteOnExit();
        //Thread.sleep(5000);

        //获取文件夹信息
        System.out.println("文件夹绝对路径：" + dir.getAbsoluteFile());
        System.out.println("获取路径:" + dir.getPath());
        System.out.println("文件夹名称:" + dir.getName());
        System.out.println("父目录:" + dir.getParent());
        System.out.println("文件夹创建时间:" + new Date(dir.lastModified()).toLocaleString());

        //判断
        System.out.println("是否可写" + dir.canWrite());
        System.out.println("是否是文件" + dir.isFile());
        System.out.println("是否隐藏" + dir.isHidden());

        //遍历文件夹
        String[] a=dir.list();
        for (String string:a) {
            System.out.println(string);
        }
        //FileFilter接口的使用
       // dir.listFiles(new FileFilter() {
            //@Override
          //  public boolean accept(File pathname) {
          //      if (pathname.getName().endsWith(".jpg")){
           //     return true;
          //  }
         //       return false;
       // });

    }
}

Properties

1、Properties特点

  1. 属性集合
  2. 存储属性名和属性值
  3. 没有泛型
  4. 和流有关
public class Properties01 {
    public static void main(String[] args) throws Exception{
        //1、创建集合
        Properties properties = new Properties();
        //2、添加数据
        properties.setProperty("username","zhangsan");
        properties.setProperty("age","20");
        System.out.println(properties.toString());
        //3、遍历
        /*
        1、keySet
        2、entrySet
        3、stringpropertyNames
         */
        Set<String> pname = properties.stringPropertyNames();
        for (String s : pname) {
            System.out.println(s+"==="+ properties.getProperty(s));
        }
        //4、和流相关的用法
        // 1、list方法
//        PrintWriter pw = new PrintWriter("F:\\idea\\temp\\aaa.txt");
//        properties.list(pw);
//        pw.close();
        //2、store保存
//        FileOutputStream fos = new FileOutputStream("F:\\idea\\temp\\aaa.properties");
//        properties.store(fos,"注释");
//        fos.close();
        //3、load加载方法
        Properties properties1 = new Properties();
        FileInputStream fis = new FileInputStream("F:\\idea\\temp\\aaa.properties");
        properties1.load(fis);
        fis.close();
        System.out.println(properties1.toString());
    }
}
小白的逆袭之谷
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
map集合以及IO流
06-13
`Map`接口是Java集合框架的一部分，它不直接继承自`Collection`接口，因为其元素不是单一的值，而是键值对（key-value pairs）。常见的`Map`实现有`HashMap`、`TreeMap`、`LinkedHashMap`等。每个`Map`实现都有其...
Java 初识IO流笔记
qq_53600812的博客
08-31 167
Java 初识IO流笔记 内容：1.常见的输入流FileInputStream的三种read方法使用 2.过程中遇到的编码和类型转换问题分析 1.输入流 InputStream的read方法是抽象方法所以InputStream是抽象类，不能直接使用可以： InputStream fis=new FileInputStream("url"); read（） hello.txt中的内容： hello FileInputStream实现read（）方法时返回的是一个int值，如果为-1则说明流已经读完了，
fileinputstream java,使用url的Java fileinputstream
weixin_32287801的博客
02-22 706
How to input in the fileinputstream, a file to url?I enter the url in the Fileinputstream, but the output of the URL is wrong, because the link slashes are turned backwards like - from / to \ and the ...
文件的简单读取，FileInputStream类的简单使用
kikizxc999的博客
12-15 621
文件输入操作： FileInputStream类的使用： 1、定义一个数组、整形数、字符串、存放文本的路径； 2、创建一个FileInputStream类对象，read()方法将读取数据放入数组并返回内容的长度； 3、整形数接收read()返回值，获取长度； 4、字符串对象利用构造方法接收数据。 String str=new String(bt,0,bytes);//内容，起始位置下标
使用字节流FileInputStream读取、FileOutputStream写入、拷贝(先读取后写入)
ThinkPet
07-27 3142
package com.io.test; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; /** * 使用字节流FileInputStream读取、FileOutputStrea...
JAVA基础（FileInputStream）
Cricket_7的博客
05-23 1585
1，FileInputStream介绍 FileInputStream流被称为文件字节输入流，意思指对文件数据以字节的形式进行读取操作如读取图片视频等 2，构造方法 FileInputStream(File file) 通过打开与File类对象代表的实际文件的链接来创建FileInputStream流对象， 若File类对象的所代表的文件不存在;不是文件是目录;或者其他原...
用集合，IO和html实现简易通讯录系统
07-07
- **ArrayList**: 在这个通讯录系统中，最可能使用的集合类是`ArrayList`，它是Java集合框架的一部分，用于动态存储一组对象。`ArrayList`提供了添加、删除、查找和遍历元素的方法，非常适合用来存储和管理联系人...
IO2+泛型+集合.docx
05-14
接着，我们讨论了Java集合框架，它是Java处理对象集合的基石，包括List、Set和Map接口。List接口代表有序的元素集合，可以有重复元素，如ArrayList和LinkedList。Set接口则存储不重复的元素，如HashSet和TreeSet。...
.NET框架类在ASP.NET中的使用
10-11
在ASP.NET中，你可以使用`FileStream`、`StreamReader`和`StreamWriter`来读写文件，或者使用`Directory`和`File`类进行目录和文件的创建、删除等操作。 3. **System.Data.SqlClient**: 这是用于与SQL Server数据库...
Java基础笔记（包括底层原理）
最新发布
04-20
集合框架是Java编程中不可或缺的部分，泛型增加了类型安全，避免了强制类型转换。Collection接口和其子接口List、Set提供了丰富的数据结构。ArrayList和LinkedList是两种常用的List实现，而HashSet、LinkedHashSet和...
IDEA FileInputStream 读取文件路径
今晚看星星的博客
04-25 9727
文章目录1. 读取绝对路径2. 读取相对路径2.1 相对于工程 1. 读取绝对路径 相对路径相对于盘符 InputStream re = new FileInputStream("D:/re.properties"); 2. 读取相对路径 2.1 相对于工程 在工程目录下，读取文件是相对于工程目录 FileInputStream re = new FileInputStream("src/re.properties"); 在工程下的 模块（Module） 时，需要家上 模块名 Input
FileInputStream读取properties系统找不到指定的路径
黎明的专栏
12-22 6507
import java.io.FileInputStream; import java.io.FileOutputStream; import java.util.Properties; public class PropertyEditor {       public static void main(String[] args) throws Exception {
Maven项目中使用FileInputStream()或getResourceAsStream()时默认路径问题
qq_43437122的博客
09-20 4899
前言：很多时候我们需要加载resources目录下properties文件中的配置信息，可是路径的问题总是让人头疼，今天特意总结下。 我的是JavaSenior Maven项目下再创建一个JavaExer项目。 1. 使用FileInputStream读取resources目录下文件 现在我要获取JavaExer项目下resources目录下的jdbc.properties文件，路径应该这样写： FileInputStream fis = new FileInputStream("JavaExer\\sr
JAVA开发10--加载相对路径下配置文件并读取内容
Stephen.G
10-20 1309
描述： java开发，使用 FileInputStream 加载 文件，读取文件内容。 在项目文件夹的同目录下，有一个文件夹 config，此文件夹下有一个配置文件 var2.properties； 文件内容如下： YEAR:2016 MONTH:07 DATA_TYPE:OA_ProjectBudget 代码如下： package com.noahark.da
使用FileInputStream读取文件内容
热门推荐
hello world！
01-18 4万+
废话不多说, 直接上关键代码 package com.zhongjing.file; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; public class FileInputStreamDemo {     /**      * FileInputStr...
java 使用FileInputStream实现文件下载（报java.io.FileNotFoundException 文件名,目录名或卷标语法不正确）
IT界的一只菜鸟
11-22 4144
代码如下： public void downloadFileToUrl(HttpServletRequest request, HttpServletResponse response) { try { String userAgent = request.getHeader("USER-AGENT"); String fileNa...
二、文件输入输出流FileInputStream/FileOutputStream解析与使用
猿小许的博客
08-31 6770
一、阻塞式IO模型     Java IO是Java自带的 API，用于读取和写入数据（输入和输出）。大多数应用程序需要处理一些输入并根据该输入产生一些输出。例如，从文件或通过网络读取数据，然后通过网络写入文件或写回响应。    Java IO API 位于 Java IO 包 ( java.io) 中。如果您查看包中的 Java IO 类，那么java.io大量的选择可能会令人困惑。所有这些课程的目的是什么？对于给定的任务，您应该选择哪一个？你如
FileInputStream读取一个或多个字符
Hern（宋兆恒）
01-10 2407
一次读取一个字符 利用read()方法进行读取，速度慢 //加载一个文件,使用绝对路径定位文件 String path = this.getServletContext().getRealPath("a.txt"); System.out.println(path); //加载文件，二进制流字节码 FileInputStream in...
Java IO：文件读写与File类详解
Java程序通过`java.io.File`类来访问和操作文件及其属性，如路径、权限、创建和修改日期等。 2. File类： `File`类是Java IO包中的核心类，它不仅代表磁盘上的文件，还可以表示目录。`File`类提供了许多方法来创建...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值