第八章·Io流

2024-06-23 11:44
文章标签 io 第八章

本文主要是介绍第八章·Io流，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

Io流

文件流

文件与流

文件概念

属于文件的一种，与普通文件载体不同，文件是以硬盘为载体储存在计算机上的信息集合；是指存储在外部介质上的数据集合。可管理（增删改查），储存。

流概念

是指在计算机的输入/输出操作中各部件之间的数据流动，按照数据的传输方式分为

  • 输入流（InputStream）----用来读取数据的
  • 输出流（OutputStream）----用来写出数据的

IO是输出输入流的简写

流分类

  • 根据处理流的类型

    • **字符流：**基本单位（8位byte）的流
    • **字节流：**基本单位（16为Unicode)的流

  • 流向分类（以代码为中心）

    • 输入流(Input)：从硬盘将数据读取到代码中，只读不写
    • 输出流(Output)：从代码中将数据写入硬盘中，只写不读

  • 根据流的角色来分类

    • **节点流：**特定设备需要使用节点流来进行输出操作
    • **过虑流：**对一个已经存在的输入输出流功能进行强化，注意：一般不能单独使用，必须配合节点流来进行使用
常用Io流体系表
分类字节输入流字节输出入字符输入流字符输出流
抽象基类InputStreamOutputStreamReaderWriter
访问文件FileInputStreamFileOutputStreamFileReaderFileWriter
缓冲流BufferedInputStreamBufferedOutputStreamBufferedReaderBufferedWriter
转换流InputStreamReaderOutputStreamWriter
对象流ObjectInputStreamObjectOutputStream

file类

  • file类是Java.io包中唯一代表磁盘文件本身的对象，也就是说，如果希望在程序中操作文件和目录，则都可以通过file类完成
  • file类定义了一些方法操作文件，可进行新建，删除，重命名文件和目录等。但file不能访问文件内容本身，如需访问则需要使用输出/输入流
package 流;import java.io.File;public class 检查文件 {public static void main(String[] args) {File file = new File("src/main/java/流/文件测试包/文件.txt");//获取名字String name = file.getName();System.out.println(name);//获取文件大小(单位是字节)long len = file.length();System.out.println(len+"字节");//是否可读可写boolean cr = file.canRead();boolean cw = file.canWrite();System.out.println("是否可读:"+cr);System.out.println("是否可写:"+cw);//是否隐藏boolean ih = file.isHidden();System.out.println("是否隐藏:"+ih);}
}

语法格式

File 文件名=new File("文件路径");
创建新文档
使用createNewFile（）方法
package 流;import java.io.File;
import java.io.IOException;public class 创建文档 {public static void main(String[] args)throws IOException {File path=new File("src/main/java/流/文件测试包/文件1.txt");if(path.exists()){//exists：判断文件夹当中是否存在某个文档，返回值只能是booleane类型System.out.println("文档已经存在，重新命名");}else {path.createNewFile();//创建文档System.out.println("创建成功");}}
}
删除和判断文件/夹
package 流;
import java.io.File;
public class 判断_删除文件_夹 {public static void main(String[] args)  throws Exception {File path=new File("src/main/java/流/文件测试包/文件2.txt");if(path.exists()){//exists：判断文件夹当中是否存在某个文档System.out.println("文档已经存在，重新命名");}else {path.createNewFile();//createNewFile:创建文档System.out.println("创建成功");}//判断是否是文件：isFile   判断是否是文件夹：isDirectorySystem.out.println("判断是否是文件："+path.isFile());System.out.println("判断是否是文件夹："+path.isDirectory());//删除文件夹File a=new File("src/main/java/流/文件测试包/文件2.txt");System.out.println(a.delete());/*a.delete()* 返回teur表示删除成功* 返回false表示删除失败* */}
}
获取当前文件夹中所有文件
使用list()方法
package 流;import java.io.File;public class k {public static void main(String[] args) {//获取当前目录中的所有子项File dir = new File("src/main/java/流/文件测试包");/*boolean isFile()判断当前File表示的是否为一个文件boolean isDirectory()判断当前File表示的是否为一个目录*/if(dir.isDirectory()){/*File[] listFiles()将当前目录中的所有子项返回。返回的数组中每个File实例表示其中的一个子项*/File[] subs = dir.listFiles();System.out.println("当前目录包含"+subs.length+"个子项");for(int i=0;i<subs.length;i++){File sub = subs[i];System.out.println(sub.getName());}}}
}
获取符号特点条件子项目

重载的listFiles方法:File[] listFiles(FileFilter)

该方法要求传入一个文件过滤器，并仅将满足该过滤器要求的子项返回。

package file;import java.io.File;
import java.io.FileFilter;/*** 有条件的获取一个目录中的子项*/
public class ListFilesDemo2 {public static void main(String[] args) {//获取当前目录下的所有文本文件(文件名是以".txt"结尾的)File dir = new File(".");if(dir.isDirectory()){
//            FileFilter fileFilter = new FileFilter() {
//                public boolean accept(File f) {
//                    return f.getName().endsWith(".txt");
//                }
//            };
//            /*
//                重载的listFiles方法要求传入一个文件过滤器
//                该方法会将File对象表示的目录中所有满足过滤器条件的子项返回
//             */
//            File[] subs = dir.listFiles(fileFilter);File[] subs = dir.listFiles(f->f.getName().endsWith(".txt"));for(File sub : subs){System.out.println(sub.getName());}}}
}
创建目录mkdirs()
package 流;import java.io.File;
import java.io.IOException;public class 创建多级目录 {public static void main(String[] args) throws IOException {// 定义需要创建的文件夹路径String dirPath = "src/main/java/流/文件测试包/创建目录";// 创建文件对象File file = new File(dirPath);// 判断文件是否存在，不存在则创建if (!file.exists()) {// 创建文件file.mkdirs();System.out.println("创建目录成功！");} else {System.out.println("目录已存在！");}}
}
mkdirs()和mkdir()区别
  • mkdirs()
    • 它可以创建多级目录结构，如果父目录不存在，它会自动创建所有必要的父目录
  • mkdir()
    • 它只能创建单个目录，并且只有当父目录已经存在时才能成功创建目录。如果父目录不存在，它将抛出异常
常用方法
  • getParent():获取上级目录
  • getPath():获取相对路径
  • getAbsolutePath:获取绝对路径
  • getName():获取名字
  • lastModified():最近一次修改时间
package 流;import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;public class 常用方法 {public static void main(String[] args) throws IOException {File path=new File("src/main/java/流/文件测试包/文件2.txt");path.createNewFile();System.out.println("上级目录："+path.getParent());System.out.println("该文件的名字为;"+path.getName());long longdate=path.lastModified();//最近修改时间Date date=new Date(longdate);//new Date:获取的是柏林时间SimpleDateFormat pp=new SimpleDateFormat("yyy-mm-dd hh:mm:ss:ss");//时间格式转换 SimpleDateFormat()System.out.println(pp.format(date));//如果文件不存在则输出初始时间File yd=new File("文件测试包/lly.doc");System.out.println("相对路径："+yd.getPath());System.out.println("绝对路径："+yd.getAbsolutePath());}
}
/*
输出：
上级目录：src\main\java\流\文件测试包
该文件的名字为;文件2.txt
2024-24-21 12:24:34:34
相对路径：文件测试包\lly.doc
绝对路径：F:\Java_project\java_maven\文件测试包\lly.doc*/

文件字节流

InputStream是Java所有字节输入流类的父类，OutputStream是Java所有字节输出流类的父类，因此继承它们的子类要重新定义父类中的抽象方法。

OutputStream

是字节输出流，也是一个抽象类，new子类来定义其方法

常用方法

write():向输出流中写入一个字节

close:关闭输出流

flush：可以强制将缓冲区中的数据写入输出流，并清空缓冲区

实现代码

package com.ch012.h003;import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;public class shuchuruliu {public static void out(){//地址File lyy=new File("src/com/ch012/h003/ceshi/测试.txt");try{FileOutputStream ldy=new FileOutputStream(lyy,true);//true为追加操作内容String zb="风声鹤起,问我要有多大，梦里把你吓";//原本准备内容ldy.write(zb.getBytes());//x写入内容ldy.close();//关闭资源System.out.println("成功输入！");}catch (FileNotFoundException e){System.out.println("找不到指定文件");}catch (IOException e){e.printStackTrace();}}public static void main(String[] args) {
out();//调用方法}
}
//输出：
风声鹤起,问我要有多大，梦里把你吓

package 流;import java.io.FileOutputStream;
import java.io.IOException;public class 文件字节流1 {public static void main(String[] args) {try {FileOutputStream a=new FileOutputStream("src/main/java/流/文件测试包/文件3");String a1="1234567890";a.write(a1.getBytes());//把数据写到内存a.flush();//把内存中的数据刷新写到硬盘上a.close();//关闭} catch (IOException e) {e.printStackTrace();}}
}
InputStream

是输入流，也是一个抽象类，主要负责将数据进行读取操作，在进行实列化的时候一定要是实列化其子类，new子类来使用方法

package 流;import java.io.FileInputStream;public class 文件字节流 {public static void main(String[] args) {try {FileInputStream a=new FileInputStream("src/main/java/流/文件测试包/文件3");byte[]b=new byte[10];//设置一个数组接收读取文件的内容a.read(b);System.out.println(new String(b));//打印出读取的内容a.close();} catch (Exception e) {e.printStackTrace();}}
}

常用方法

read():读取数据

close：关闭资源

代码实现

package 流;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
public class 读取文件内容 {public static void main(String[] args) throws IOException {File ye=new File("src/main/java/流/文件测试包/文件2.txt");FileInputStream le = new FileInputStream(ye);byte[]bytes=new byte[1024];/*读取数据*/int len=le.read(bytes);while (len!=-1){System.out.println(new String(bytes,0,len));len=le.read(bytes);}}
}
字节流拷贝文件
package 流;import java.io.*;
public class 字节流复制 {//将文件复制到另一个文件public static void main(String[] args) throws IOException {FileInputStream in=new FileInputStream("src/main/java/流/文件测试包/文件.txt");FileOutputStream out=new FileOutputStream("src/main/java/流/文件测试包/文件2.txt");byte[] b=new byte[100];int len;while((len=in.read(b))!=-1){out.write(b,0,len);}in.close();out.close();}
}
/*注意：使用write方法帮我们去进行写入工作的时候，为了解决部分编码问题（乱码），于是传入三个参数第一个：byte[]存放读取出来的内容第二个：起始位置，因为是进行拷贝工作，所以一般起始位置都是从0开始第三个：编号*/

文件字符流

FileReader

主要负责读取工作

package 流.文件字符流;import java.io.FileReader;
import java.io.IOException;
public class 文件字符流 {public static void main(String[] args) throws IOException {//读取文件数据FileReader fr = new FileReader("src/main/java/流/文件测试包/文件.txt");char[]c=new char[10];int len=0;while ((len=fr.read(c))!=-1){System.out.println(new String(c,0,len));}fr.close();}
}
writer
package 流.文件字符流;import java.io.FileWriter;
import java.io.IOException;public class 文件字符流2 {public static void main(String[] args) throws IOException {FileWriter a=new FileWriter("src/main/java/流/文件测试包/文件.txt");a.write("一滴水的感恩！");a.flush();a.close();}
}
字符流拷贝
package 流.文件字符流;import java.io.*;public class 拷贝 {public static void main(String[] args) throws IOException {FileReader a = new FileReader("src/main/java/流/文件测试包/文件.txt");FileWriter b = new FileWriter("src/main/java/流/文件测试包/文件2.txt");char[]c=new char[100];int len;while ((!((len=a.read(c))!=-1))){//读取数据b.write(c,0,len);//写入数据}a.close();b.close();}
}

缓冲流

缓冲字节流

功能

在流链接中的作用:加快读写效率

通常缓冲是最终链接在低级流上的流

flush的传递

flush()方法是被定义在java.io.Flushable中。而字节输出流的超类java.io.OutputStream实现了该接口，这意味着所有的字节输出流都有flush方法。而除了缓冲流之外的高级流的flush方法作用就是调用它链接的流的flush方法将该动作传递下去。最终传递给缓冲流来清空缓冲区。

BufferedInputStream
package 流.缓冲流;import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
//缓冲字节流读取文件内容
public class 缓冲字节流 {public static void main(String[] args) throws IOException {FileInputStream a=new FileInputStream("src/main/java/流/文件测试包/文件2");BufferedInputStream b=new BufferedInputStream(a);byte[]c=new byte[100];int len;while ((len=b.read(c))!=-1){System.out.println(new String(c,0,len));}a.close();b.close();}
}
BufferedOutputStream
package io;import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;/*** 缓冲输出流的写缓冲问题*/
public class BosFlushDemo {public static void main(String[] args) throws IOException {FileOutputStream fos = new FileOutputStream("bos.txt");BufferedOutputStream bos = new BufferedOutputStream(fos);String line = "super idol的笑容都没你的甜~";byte[] data = line.getBytes(StandardCharsets.UTF_8);bos.write(data);/*void flush()强制将缓冲流的缓冲取(内部维护的字节数组)中已经缓存的字节一次性写出*/
//        bos.flush();System.out.println("写出完毕!");bos.close();//缓冲输出流的close()方法内部会自动调用一次flush()方法确保数据写出}
}

写缓冲问题

由于缓冲输出流会将写出的数据装满内部缓冲区(默认8kb的字节数组)后才会进行一次真实的写出操作。当我们的数据不足时，如果想要及时写出数据，可以调用缓冲流的flush()方法，强制将缓冲区中已经缓存的数据写出一次。

缓冲字节流拷贝
package 流.缓冲流;import java.io.*;public class 缓冲字节流文件复制 {public static void main(String[] args) throws IOException {FileInputStream fis = new FileInputStream("src/main/java/流/文件测试包/b51866052244a2414c0d2cc75f3c3752.png");BufferedInputStream bis = new BufferedInputStream(fis);FileOutputStream fos = new FileOutputStream("src/main/java/流/文件测试包/创建目录/复制的图片.png");BufferedOutputStream bos = new BufferedOutputStream(fos);int len;long start = System.currentTimeMillis();while((len=bis.read())!= -1){bos.write(d);}long end = System.currentTimeMillis();//格林尼治标准时间System.out.println("复制完毕!耗时:"+(end-start)+"ms");bis.close();bos.close();}
}

缓冲字符流

BufferedReader
package 流.缓冲流;import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;public class 缓冲字符输入流 {public static void main(String[] args) throws IOException {FileReader r=new FileReader("src/main/java/流/文件测试包/文件3");BufferedReader  br=new BufferedReader(r);char[]b=new char[100];int len;while ((len=br.read(b))!=-1){System.out.println(new String(b,0,len));}r.close();}
}
BufferedWriter
package 流.缓冲流;import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;public class 缓冲字符输出流 {public static void main(String[] args) throws IOException {FileWriter a=new FileWriter("src/main/java/流/文件测试包/文件2.txt");BufferedWriter b=new BufferedWriter(a);String c="hello world";System.out.println("成功");b.write(c);b.flush();b.close();a.close();}
}
缓冲字符流拷贝
package 流.缓冲流;import java.io.*;public class 缓冲字符流拷贝 {public static void main(String[] args) throws IOException {BufferedReader a=new BufferedReader(new FileReader("src/main/java/流/文件测试包/文件3"));BufferedWriter b=new BufferedWriter(new FileWriter("src/main/java/流/文件测试包/文件2.txt"));char[] c=new char[1024];int len=0;while((len=a.read(c))!=-1) {b.write(c, 0, len);}System.out.println("成功");b.flush();b.close();a.close();}
}

字符转换流

字符流与字节流之间的转换

好处

1，可以进行编码格式的设置

2，可以加快读写速度

3，读写的数据类型为字节类型

InputStreamReader

将字符输入流和字节输入流之间进行转换

package 流.转换流;import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;public class 转换输入流 {public static void main(String[] args) throws IOException {FileInputStream a=new FileInputStream("src/main/java/流/文件测试包/文件4");InputStreamReader  b=new InputStreamReader(a,"UTF-8");char[]c=new char[10];int len;while((len=b.read(c))!=-1){System.out.println(new String(c,0,len));}b.close();a.close();}
}
OutputStreamWrier

将字符流输出流和字节输出流之间进行转换

package 流.转换流;import java.io.*;public class 转换输出流 {public static void main(String[] args) throws IOException {FileOutputStream out = new FileOutputStream("src/main/java/流/文件测试包/文件5");OutputStreamWriter  outWriter = new OutputStreamWriter(out,"utf-8");outWriter.write("转换输出流");System.out.println("成功");outWriter.close();out.close();}
}

字节对象流

直接把某个对象写入到某个文件中，直接读取某个文件中的对象属性

为什么使用序列化操作

1，可以将对象永久的保存到磁盘中

2，可以把对象通过网络上进行传输到另一台机器上

**注：**无论是保存在磁盘中还是传输，都需要将对象转换为字节后才可以进行

使用序列化的前提

  • 必须实现Serilizable接口

创建被序/反序列化的对象

package 流.对象流;
import java.io.Serializable;
public class chuangjian implements Serializable {String name;int age;private transient String id;public chuangjian(String name, int age, String id){this.name=name;this.age=age;this.id=id;}public String getId() {return id;}public void setId(String id) {this.id = id;}public String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age;}
}

实现了序列化接口的类建议显示的定义常量:static final long serialVersionUID = 1L;

序列化操作

将对象的某些属性或方法写入到某个文件中（将对象写入文档）

ObjectOutputStream

主要负责写入工作，实现序列化操作（将某个对象写入到某个文件中）

package 流.对象流;import java.io.*;public class 对象流反序列化 {public static void main(String[] args) throws IOException {chuangjian a=new chuangjian("zhangsan",21,"jd218429");FileOutputStream b=new FileOutputStream("src/main/java/流/文件测试包/文件.txt");ObjectOutputStream b1=new ObjectOutputStream(b);b1.writeObject(a);System.out.println("成功");b1.close();}
}

transient关键字

当一个属性被transient关键字修饰后，该对象在进行序列化时，转换出来的字节中是不包含该属性的。忽略不必要的属性可以达到对象"瘦身"的操作。

对象瘦身可以在对象持久化时减少磁盘开销。在进行传输时可以缩短传输速度。

如果该对象不需要序列化，那么该关键字不发挥其他任何效果

public class chuangjian implements Serializable {String name;int age;private transient String id;

序列化时不包含otherInfo属性，并且反序列化时该属性值为null

Person{name='zhangsan', age=21,id=null}

反序列化操作

将某个文件中的对象读取出来（在文件中读取对象）

ObjectInputStream

主要负责读取工作，实现反系列化操作（将某个文件中的对象读取出来）

package 流.对象流;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;public class 序列化 {public static void main(String[] args) throws IOException, ClassNotFoundException {FileInputStream a=new FileInputStream("src/main/java/流/文件测试包/文件.txt");ObjectInputStream b=new ObjectInputStream(a);chuangjian c= (chuangjian) b.readObject();System.out.println(c);b.close();}
}

这篇关于第八章·Io流的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1087067。

相关文章

Java——IO流（一）-（5/8）：IO流概述、字节流-FileInputStream 每次读取一个字节

Java——IO流（一）-（5/8）：IO流概述、字节流-FileInputStream 每次读取一个字节

IO流概述 介绍 输入输出流，用于读写数据。 I指Input，称为输入流：负责把数据读到内存中去。 O指Output，称为输出流：负责写数据出去。 IO流的应用场景 文件内容的读写永久保存应用数据复制粘贴对话通信等等 怎么学IO流 理清楚IO六点分类和体系循序渐进、深入学习每个IO流的作用和用法 IO流的分类 IO流总体来看就有四大类： 字节输入流：以内存
阅读更多...
【Linux】系统文件IO·文件描述符fd

【Linux】系统文件IO·文件描述符fd

前言  C语言文件接口  C 语言读写文件 1.C语言写入文件 2.C语言读取文件 stdin/stdout/stderr 系统文件IO 文件描述符fd： 文件描述符分配规则： 文件描述符fd： 前言 我们早在C语言中学习关于如何用代码来管理文件，比如文件的输入和文件的输出，一些文件的接口，如何深入学习文件的知识，在Linux下一切皆文件，今天我们探讨Linux的基础I/
阅读更多...
JavaIO流之创建字节输出流的2中方式

JavaIO流之创建字节输出流的2中方式

package fileoutputstream;import java.io.File;import java.io.FileOutputStream;public class FileOutputStreamDemo {public static void main(String[] args) throws Exception {//创建字节输出流对象方式1// FileO
阅读更多...
JavaIO之删除指定目录(递归删除，先删除目录下的文件再删除目录)

JavaIO之删除指定目录(递归删除，先删除目录下的文件再删除目录)

package 输出指定文件绝对路径;import java.io.File;/** 需求：递归删除带内容的目录* * 目录我已经给定：demo* * 分析：* A:封装目录* B:获取该目录下的所有文件或者文件夹的File数组* C:遍历该File数组，得到每一个File对象* D:判断该File对象是否是文件夹* 是：回到B* 否：就删除*
阅读更多...
Portainer.io安装并配置Docker远程访问及CA证书

Portainer.io安装并配置Docker远程访问及CA证书

Portainer.io安装并配置Docker远程访问及CA证书 文章目录 Portainer.io安装并配置Docker远程访问及CA证书一.安装 Portainer.io2.启动容器 二.docker API远程访问并配置CA安全认证1.配置安全(密钥)访问2.补全CA证书信息3.生成server-key.pem4.创建服务端签名请求证书文件5.创建服务端扩展配置文件 extfile.
阅读更多...
【Linux】基础IO_3

【Linux】基础IO_3

文章目录 六、基础I/O3. 软硬链接4. 动静态库 未完待续 六、基础I/O 3. 软硬链接 使用 ln 就可以创建链接，使用 ln -s 可以创建软链接，直接使用 ln 则是硬链接。 我们对硬链接进行测试一下： 根据测试，我们知道了 硬链接就像一个重命名一样，向其中一个文件里面写，另一个也会改变 。但是删除后只会删除一个，这说明 文件的删除本质上是减少硬链接数。硬
阅读更多...
IO-Link PD数据

IO-Link PD数据

目录 一、PD过程数据的特点 二、PD过程数据的功能 三、PD过程数据的使用输出说明 IO-Link是一种数字化、点对点通信协议和接口，广泛应用于工业自动化领域。其中，PD（Process Data）过程数据是IO-Link通信中的一个重要组成部分，它承载着设备在运行过程中产生的实时数据。以下是关于IO-Link中PD过程数据的特点、功能以及使用输出的完整说明： 一、PD过程数据
阅读更多...
Nginx基础. eventfd, 异步IO 与epoll的相互协作

Nginx基础. eventfd, 异步IO 与epoll的相互协作

关于eventfd. 对于eventfd, 这里只是简单的讲它的功能. 看manpage就足够了, 其中的例子也很容易看懂 eventfd函数可以创建一个efd描述符, 该描述符在内核中维护着一个计数器counter. 在调用eventfd时, 可以传入参数指定内核中维护着的计数器的值. 如果这样调用： int efd = eventfd(0, 0);那么计数器值
阅读更多...
第八章 数字信号的频带传输

第八章 数字信号的频带传输

第八章 数字信号的频带传输 第八章 数字信号的频带传输数字调制二进制数字振移键控(2ASK)二进制数字频移键控(2FSK)二进制数字相位键控(2PSK)小结 第八章 数字信号的频带传输 数字调制 目的：将数字基带信号变成适于信道传输的数字频带信号，用载波调制方式进行传输。 载波选取：高频正弦波。 调制信号：数字、离散。 原理：同于模拟，但特殊：高频载波的离散状态携带信
阅读更多...
java基础总结：（1）IO流+简单爬虫

java基础总结：（1）IO流+简单爬虫

文件可认为是相关记录或放在一起的数据的集合 file类常用的方法：    方法名称                                说明 boolean exists()     判断文件或目录是否存在 boolean isFile()  判断是否是文件 boolean isDirectory()判断是否是目录 String getPath() 返回此对象表示的文件的相对路径 S
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2