IO初识233

已于 2023-01-15 08:55:19 修改
阅读量502 收藏
点赞数 1
分类专栏： 笔记 文章标签： jvm java 开发语言
于 2023-01-14 21:51:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64054032/article/details/128686667
版权

绝对路径和相对路径

 路径是用来描述一个文件在电脑上的具体位置。

这里的 E:\绘画合集\CCE展会logo 2.0就是绝对路径

目录之间的分隔符可以用\也可以用/来表示

相对路径就是以一个基准路径（工作路径），以基准路径为起点往下走要怎么表示目标路径

例如如果基准路径是E:/绘画合集的话，相对路径就是.\CCE展会logo 2.0

现在新建了一个文件夹

如果基准路径是E:\绘画合集\CCE展会logo 2.0\新建文件夹，而我们要表示CCE展会logo 2.0的相对位置的时候，可以使用..\来返回上级目录，因此相对位置就是

../CCE展会logo 2.0

但是注意，WINDOWS下我们无法去表示此电脑这一级，最多就是E:/ C:/这样的

Java中操作文件

构造方法：

File(File parent,Stringchild)
根据父目录＋孩子文件路径，创建一个新的File实例

File(String pathname)
根据文件路径创建一个新的File实例，路径可以是绝对路径或者相对路径

File(String parent,String child)
根据父目录＋孩子文件路径，创建一个新的File实例，父目录用路径表示方法

方法：(名字，作用，返回类型)

getParent()
返回File对象的父目录文件路径
String

getName()
返回Flle对象的纯文件名称
String

getPath()
返回File对象的文件路径
String

getAbsolutePath()
返回 File对象的绝对路径
String

getCanonicalPath()
返回File对象的修饰过的绝对路径
String

exists()
判断File对象描述的文件是否真实存在
boolean

isDirectory()
判断File对象代表的文件是否是一个目录
boolean

isFile()
判断File对象代表的文件是否是一个普通文件
boolean

createNewFile()
根据File对象，自动创建一个空文件。成功创建后返回true
boolean

delete()
根据File对象，删除该文件。成功删除后返回 true
boolean

deleteOnExit()
根据File对象，标注文件将被删除，删除动作会到JVM运行结束时才会进行
void

list()
返回 File对象代表的目录下的所有文件名
String

listFiles()
返回File 对象代表的目录下的所有文件，以File 对象表示
File[]

mkdir()
创建File对象代表的目录
boolean

mkdirs()
创建 File 对象代表的目录，如果必要，会创建中间目录
boolean

renameTo(File dest)
进行文件改名，也可以视为我们平时的剪切、粘贴操作
boolean

canRead()
判断用户是否对文件有可读权限
boolean

canWrite()
判断用户是否对文件有可写权限
boolean

当我们用绝对路径去获取的时候

package threading;

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

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: admin
 * Date: 2023-01-14
 * Time: 11:56
 */
public class L1140 {
    public static void main(String[] args) throws IOException {

        File f = new File("D:/test.txt");
//        File f = new File("./test.txt");
        System.out.println(f.getParent());
        System.out.println(f.getName());
        System.out.println(f.getPath());
        System.out.println(f.getAbsoluteFile());
        System.out.println(f.getCanonicalPath());
    }
}

用相对路径去获取的时候

package threading;

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

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: admin
 * Date: 2023-01-14
 * Time: 11:56
 */
public class L1140 {
    public static void main(String[] args) throws IOException {

//        File f = new File("D:/test.txt");
        File f = new File("./test.txt");
        System.out.println(f.getParent());
        System.out.println(f.getName());
        System.out.println(f.getPath());
        System.out.println(f.getAbsoluteFile());
        System.out.println(f.getCanonicalPath());
    }
}

 这是因为基准目录的变化而导致的，直接用IDEA运行程序的话，基准目录就是项所在目录

File里包含的那个文件是不一定存在的，我们可以创建出来，如下：

package threading;

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

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: admin
 * Date: 2023-01-14
 * Time: 18:02
 */
public class L1141 {
    public static void main(String[] args) throws IOException {
        File f = new File("./test.txt");
        System.out.println(f.exists());
        //判断是否存在
        System.out.println(f.isDirectory());
        //判定是否是目录
        System.out.println(f.isFile());
        //判断是否是文件

        //把这个文件创建出来
        System.out.println("创建文件后：");
        f.createNewFile();
        
        System.out.println(f.exists());
        System.out.println(f.isDirectory());
        System.out.println(f.isFile());

    }
}

创建目录实例：

package threading;

import java.io.File;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: admin
 * Date: 2023-01-14
 * Time: 18:07
 */
public class L1142 {
    public static void main(String[] args) {
//
//        File f = new File("./testDir");
        File f = new File("./testDir/aaa/bbb");
        f.mkdir();
        //上面这个只能创建单层目录（./testDir）
        f.mkdirs();
        //这个可以创建多层目录
    }
}

重命名操作实例：

package threading;

import java.io.File;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: admin
 * Date: 2023-01-14
 * Time: 18:10
 */
public class L1143 {
    public static void main(String[] args) {
        File srcFile = new File("aaa.txt");
        File destFile = new File("bbb.txt");
        srcFile.renameTo(destFile);
    }
}

 

 查看文件目录实例：

package threading;

import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: admin
 * Date: 2023-01-14
 * Time: 18:15
 */
public class L1144 {
    public static void main(String[] args) {
        File f = new File("./testDir");
        String[] results = f.list();
        //查看当前目录内容
        //使用result来接受结果
        System.out.println(Arrays.toString(results));
    }
}

 上面的文件操作，都是针对文件系统的操作（新增文件，珊瑚文件，新增目录，重命名，列表内容）。并不是对文件内容的操作

针对文件内容的操作，涉及的关键操作就是读文件和写文件。

Java标准库，在流的概念上（一次性写10字节和十次写一字节）这种概念上提供了一组类来完成读写文件的操作，主要分为字节流（以一个字节为基本单位）和字符流（以一个字符为基本单位）

操作二进制文件多使用字节流，操作文本文件多使用字符流。

字节流主要有（InputStream和OutputStream）FileInputStream FileOutputStream

字符流主要有（Read和Write）FileRead FileWrite

InputStream

read()
读取一个字节的数据，读出的结果作为rea的返回值。返回—1代表已经完全读完了
int

read(byte[] b)
最多读取b.length字节的数据到b中，返回实际读到的数量；—1代表以及读完了
int
参数b是存放输出结果的内容了，因此这里的b被称为输出型参数

read(byte[] b,int off,int len)
最多读取len—off字节的数据到b中，放在从 off开始，返回实际读到的数量；—1代表以及读完了
int

close()
关闭字节流
void

InputStream 只是一个抽象类，要使用还需要具体的实现类。关于InputStream的实现类有很多，基本可以认为不同的输入设备都可以对应一个InputStream类，我们现在只关心从文件中读取，所以使用FilelnputStream
因此InputStream无法被实例化

OutputStream

write(byte[] b)
把字节数组的所有内容，都写到文件中

write(int b)
写一个字节

write(byte[] b,int off,int len)
把b字节数组从下标off位置开始写，写len个字节

FilelnputStream

FilelnputStream(File file)
利用File构造文件输入流

FilelnputStream(String name)
利用文件路径构造文件输入流

字节流读文件实例：

先前已经往bbb.txt文件写了Hello World！，现在来进行读取操作

package threading;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: admin
 * Date: 2023-01-14
 * Time: 18:37
 */
public class L1145 {
    public static void main(String[] args) throws IOException {
        InputStream  inputStream = new FileInputStream("./bbb.txt");
        //这个过程相当于打开文件，相当于C中的fopen
        //要想读写文件，就得先打开。
        while (true){
            int b = inputStream.read();
            if(b==-1){
                break;
            }
            System.out.println(b);
        }
        inputStream.close();
    }
}

 我们可以发现读取的结果就是每个字符对应的ASCII码值。

字节流写文件实例：

package threading;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: admin
 * Date: 2023-01-14
 * Time: 20:41
 */
public class L1146 {
    public static void main(String[] args) throws IOException {
        OutputStream outputStream = new FileOutputStream("./bbb.txt");

        outputStream.write(97);
        outputStream.write(98);

        outputStream.close();

    }
}

原来写了Hello World!的文本被修改成了ASCII码为97和98的a和b。

只要outputstream写文件的时候，打开文件成功，就会把原有内容清空。

字符流读文件实例：

package threading;

import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: admin
 * Date: 2023-01-14
 * Time: 20:50
 */
public class L1147 {
    public static void main(String[] args) throws IOException {
        Reader reader = new FileReader("./bbb.txt");
        while (true){
            int ret = reader.read();
            if(ret == -1){
                break;
            }
            char ch = (char)ret;
            System.out.println(ch);
        }

        reader.close();
    }
}

 字符流写文件实例：

package threading;

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: admin
 * Date: 2023-01-14
 * Time: 21:10
 */
public class L1148 {
    public static void main(String[] args) throws IOException {
        Writer writer = new FileWriter("./bbb.txt");
        writer.write("hellp world");
        writer.close();
    }
}

 

tip:针对文本文件使用字符流来继续读取的时候，我们还可以使用Scanner来进行读取，如下：

package threading;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Scanner;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: admin
 * Date: 2023-01-14
 * Time: 21:15
 */
//使用scanner
public class L1149 {
    public static void main(String[] args) throws IOException {
        InputStream inputStream = new FileInputStream("./bbb.txt");

        Scanner scanner = new Scanner(inputStream);
        while (scanner.hasNext()){
            System.out.println(scanner.next());
        }
        inputStream.close();
    }
}

package threading;

import java.io.*;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: admin
 * Date: 2023-01-14
 * Time: 21:18
 */
public class L111491 {
    public static void main(String[] args) throws IOException {
        //针对文本文件，还可以使用printwriter来简化开发

        OutputStream outputStream = new FileOutputStream("./bbb.txt");
        try{
            PrintWriter writer = new PrintWriter(outputStream);

            writer.println("你好");
            writer.printf("a = %d\n", 10);

        }finally {
            outputStream.close();

        }
    }
}

 文件操作的时候一定要记得关闭文件，每次进程打开一个文件都会对应创建一个项在文件描述表里面，关闭文件就可以把表给释放掉，不关闭则表会一直占用位置，最后导致表项被耗尽，打开文件失败，文件资源泄露。

扫描指定目录，并找到名称中包含指定字符的普通文件：

package threading;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.Scanner;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: admin
 * Date: 2023-01-14
 * Time: 21:34
 */
public class L111492 {
    public static void main(String[] args) throws IOException {
        //让用户输入信息
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要扫描的路径");
        String rootDirPath = scanner.next();

        File rootDir = new File(scanner.next());
        if(!rootDir.isDirectory()){
            System.out.println("你输入的目录不存在");
            return;
        }
        System.out.println("请输入要搜索的关键词");
        String toDeletc = scanner.next();

        //遍历目录
        scanDir(rootDir,toDeletc);


    }
    private static void scanDir(File rootDir,String toDelect) throws IOException {
        System.out.println("当前访问：" + rootDir.getCanonicalPath());
        File[] file = rootDir.listFiles();
        if(file == null){
            //说明是空目录
            return;
        }
        //如果不是空目录，递归遍历每个元素找
        for(File f : file){
            if(f.isDirectory()){
                scanDir(f,toDelect);
            }
            else {
                //不是目录，普通文件，判断是否符合要求
                checkdelete(f,toDelect);
            }
        }
    }
    private static void checkdelete(File f , String toDelect) throws IOException {
        if(f.getName().contains(toDelect)){
            System.out.println("该单词" + toDelect + "被" + f.getCanonicalPath() + "包含了,是否要删除（Y/N）");
            Scanner scanner = new Scanner(System.in);
            String choice = scanner.next();
            if(choice.equals("Y")||choice.equals("y")){
                f.delete();
            }
        }
    }
}

复制文件操作

package threading;

import java.io.*;
import java.util.Scanner;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: admin
 * Date: 2023-01-15
 * Time: 8:36
 */
public class L115 {
    public static void main(String[] args) {
        //1.先输入要复制的文件路径，以及吧这个文件复制到哪里去
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入源文件：");
        //srcFile 形如d:/cat.jpg
        File srcfile = new File(scanner.next());
        System.out.println("请输入目标文件");
        //destFile例如d:/cat2.jpg
        File destfile = new File(scanner.next());
        if(!srcfile.isFile()){
            System.out.println("输入的源文件有误");
            return;
        }
        if(!destfile.isFile()){
            System.out.println("输入目标文件有误");
            return;
        }
        //2，打开源文件，按照直接读取内容，依次写到目标文件
        try(InputStream inputStream = new FileInputStream(srcfile);
            OutputStream outputStream = new FileOutputStream(destfile)){
            while (true){
                int ret = inputStream.read();
                if(ret == -1){
                    break;
                }
                outputStream.write(ret);
            }
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

查询文件中是否包含内容

package threading;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Scanner;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: admin
 * Date: 2023-01-15
 * Time: 8:46
 */
public class L1151 {
    public static void main(String[] args) {
        //输入路径和要查询的关键词
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要扫描的路径：");
        File rootDir = new File(scanner.next());
        System.out.println("请输入要查询的词");
        String toFind = scanner.next();

        //2.递归扫描目录

    }
    private static void scanDir(File rootDir,String toFind){
        File[] files = rootDir.listFiles();
        if(files == null){
            return;
        }
        for(File f : files){
            if(f.isDirectory()){
                scanDir(f,toFind);
            }else {

            }
        }
    }
    private static void checkfile(File f,String tofine ) throws IOException {
        //先检查文件名
        if(f.getName().contains(tofine)){
            System.out.println(f.getCanonicalPath() + "文件名中包含" + tofine);
        }
        try(InputStream inputStream = new FileInputStream(f)){
            StringBuilder stringBuilder = new StringBuilder();
            Scanner scanner = new Scanner(inputStream);
            //按行读取
            while(scanner.hasNextLine()){
                stringBuilder.append(scanner.nextLine() + "\n");
            }
            if(stringBuilder.indexOf(tofine) > -1){
                System.out.println(f.getCanonicalPath() + "文件内容包含" +tofine);
            }
        }
        //再检查文件内容
    }
}

思鱼不是死鱼
关注
专栏目录
IO 初识
weixin_44309173的博客
09-11 92
IO 文件读写和网络，套用 Linux 里的一句话，一切接文件。所以，无论是文件还是网络，都需要打开、建立连接、读写、关闭。 IO 文件对象里面的字节数组，字符数组，字符串，想要更快的读写，打印，就要使用缓冲。文件合并 则使用seq，有多种的输出则是打印 流向分类 输入流：InputStream，Reader 输出流：OutputStream，Writer 字符/字节分类 字符流：Reader，Writer 字节流：InputStream，OutputStream InputS...
Java 初识IO流
小钟不想敲代码
01-24 1288
初识IO流
初识IO-Link
weixin_46183720的博客
08-14 5960
关于工业自动化领域的国际化标准协议IO-Link在发展、应用、开发、标准文件、数据帧传输、物理接线等方面的概述，欢迎对该技术领域感兴趣的uu们一起交流一起进步。
JAVA IO初识
chenhy24的博客
02-20 262
看了别个的帖子，自己精简的记一下。以备查看 原帖 http://blog.csdn.net/zxman660/article/details/7875799 首先，在JAVA API中，可以从其中读入一个字符序列的对象称作输入流，而可以从中写入一个字符序列的对象称作输出流。 操作流程 在Java中IO操作也是有相应步骤的，以文件操作为例，主要的操作
Java之IO初识
jy_aicn的专栏
12-25 415
---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ---------------------- IO流：数据传输的中转站 源————>IO流————>目的地 IO流一般都是成对出现，也就是按照流向分为：输入流和输出流 IO流按照操作的对象来分：字节流和字符流 一、字符流 基类：Reader(读)、Writer(写)
IO初识
GD_Tiny的博客
05-30 312
其中分有字节流与字符流 字节流： I：input输入 O：output  输出 字符流： I：read  输入（读） O：write  输出（写） 注：输入指拿出数据，也就是读；输出指传入数据，也就是写； 输入流的类： 字节输入流的祖宗：InputStream 常用子类：FileInputStream、DataInputStream 加强类：Buffere
Java之IO初识1
weixin_44943389的博客
04-03 41
在java中只要“类名”以 Stream 结尾的都是字节流。以“ Reader/Writer ”结尾的都是字符流
初识IO流
2301_79699664的博客
04-16 382
File类只能对文件本身进行进行操作，不能读写文件里面存储的数据。IO流：用于读写文件中的数据（可以读写文件，或者网络中的数据）File:表示系统中的文或者文件夹的路径。获取文件信息（大小，文件名，修改时间）写出数据：程序->文件（output）读取数据：文件->程序（input）IO流：存储和读取数据的解决方案。
初识Java IO
qq_65319973的博客
08-30 85
io流
第二章 初识 IO 函数，初学者的笔记
09-08
笔记
精选_【Cocos Creator 联机实战教程(1)】——初识Socket.io_源码打包
03-09
【Cocos Creator 联机实战教程(1)】——初识Socket.io 是一个针对游戏开发者，特别是使用Cocos Creator的开发者的系列教程。本教程旨在帮助他们掌握如何利用Socket.io实现在Cocos Creator游戏中的实时通信功能，这...
Linux：初识IO流
Zyc_cucumber的博客
08-06 247
文章目录前言一、C语言中的文件接口二、进程终止三、进程等待四、进程程序替换1.进程程序替换原理2.进程替换函数：exec函数簇1.execl2.execlp3.execle4.execv5.execvp6.execve7.总结3.进程程序替换应用场景 前言 下面将介绍一些基础IO流的相关知识，主要涉及c语言的文件接口，文件描述符(重点) 一、C语言中的文件接口 这是对C语言中的常用文件接口进行简单复习，有利于更好的认识io流，也是为接下来的知识做铺垫。 1.fopen函数 参数分析： path表示待要
Java 入门指南：JVM（Java虚拟机）—— Java 类加载器详解
最新发布
Zachyy的博客
09-15 1193
类加载器（Class Loader）是 Java 虚拟机（JVM）的一部分，它的作用是将类的字节码文件（.class 文件）从磁盘或其他来源加载到 JVM 中。类加载器负责查找和加载类的字节码文件，并将其转化为 Class 对象。
【JVM】运行时数据区
qq_45875349的博客
09-15 774
JVM 运行时数据区域也叫内存布局，但需要注意的是它和Java 内存模型((Java Memory Model，简称JMM)完全不同，属于完全不同的两个概念，它由以下5大部分组成：本地方法栈、虚拟机栈、程序计数器、方法区、堆区
【JVM GC核心参数】JVM原理，JAVA 各种垃圾回收器的核心参数，JAVA GC回收器参数配置，核心参数说明
xzb5566的专栏
09-12 998
【JVM GC核心参数】JVM原理，JAVA 各种垃圾回收器的核心参数，JAVA GC回收器参数配置，核心参数说明。
JVM源码解析
QiAn的博客
09-12 853
之前的话，通过Linux或者Windows开发，当需要跨平台时，程序不能运行。java出现后，产生了jvm，针对不同的操作系统，产生了不同的java虚拟机。在Java虚拟机中执行的指令，称为Java字节码指令。下面显示了同一个Java程序，被编译为一组Java字节码的集合之后，可以通过Java虚拟机运行于不同的操作系统上，它以Java虚拟机为中介，实现了跨平台的特性。
镭速如何高效使用SQLite数据库高速传输结构化数据文件传输
镭速的博客
09-12 681
SQLite数据库因其小巧、跨平台和无需配置的特性，在众多关系型数据库中独树一帜。与传统的服务器/客户端架构数据库，例如MySQL不同，SQLite通常被嵌入到应用程序中作为一个库。它不仅支持创建索引，还严格遵循ACID原则，非常适合存储由程序生成的结构化数据。
Java初识：输入输出流详解与文件操作关键
在Java语言中，这些操作主要通过`java.io`包中的各类流类来完成，它们按照数据流向和数据类型进行了细致的划分。 首先，我们了解一下输入流和输出流的基本概念。Java定义了抽象类`InputStream`（字节输入流）和`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值