1.文件操作
文件------把数据持久化到磁盘的载体
文件的组成：
- 文件的基本属性【文件名称，文件类型，文件创建时间，文件大小…】
- 文件中的数据
文件操作，java为我们提供了一个专门操作文件的java类---java.io.File类
2.File类
定义：public class File
2.1 File类静态成员变量
使用时需要导包java.io.File
（1）static String pathSeparator 与系统相关的路径分隔符字符，为方便起见，表示为字符串。
（2）static char pathSeparatorChar 与系统相关的路径分隔符。
（3）static String separator 与系统相关的默认名称分隔符字符，以方便的方式表示为字符串。
（4）static char separatorChar 与系统相关的默认名称分隔符。
例：
import java.io.File;
public class FileTset1 {
public static void main(String[] args) {
// static String pathSeparator 与系统相关的路径分隔符字符，为方便起见，表示为字符串。
System.out.println("String pathSeparator==" + File.pathSeparator);// ;
// static char pathSeparatorChar 与系统相关的路径分隔符。
System.out.println("char pathSeparatorChar ==" + File.pathSeparatorChar);// ;
// static String separator 与系统相关的默认名称 - 分隔符字符，以方便的方式表示为字符串。
System.out.println("String separator==" + File.separator);// \
// static char separatorChar 与系统相关的默认名称分隔符。
System.out.println("char separatorChar==" + File.separatorChar);// \
}
}路径分隔符的作用：
让我们在编写文件路径的时候使用，因为有可能当我们写文件路径时存在\t，系统识别成转义字符。
不受操作系统对路径分隔符的限制，Windows系统\，Linux系统/
//System.out.println("F:\test\mytest.txt");报错
System.out.println("F:"+File.separator+"test"+File.separator+"mytest.txt");
2.2 File类构造方法
File(String pathname) 通过给定的文件路径字符串创建新的 File实例。
File(String parent, String child) 通过给定的文件位置字符串和给定的文件名称字符串创建新的 File实例。
File(File parent, String child) 通过给定的文件位置File对象和给定的文件名称字符串创建新的 File实例。
注意：文件File的对象创建后，并没有生成实际的文件或者文件夹，实际的东西需要通过实例方法取创建。
2.3 File类实例方法
boolean exists() 判断路径名表示的文件或目录是否存在。
boolean createNewFile() 创建新文件
boolean mkdirs() 创建新的文件夹
boolean delete() 删除文件/文件夹（删除文件夹的时候要将该文件夹下的文件和子文件夹全部删除）
boolean canRead() 判断文件是否可读
boolean canWrite() 判断文件是否可写
boolean isHidden() 判断文件是否为隐藏文件。
boolean isFile() 判断文件对象是否为普通文件。
boolean isDirectory() 判断文件对象是否为目录。
String getPath() 得到文件对象的路径名字符串。
String getName() 得到文件对象所表示的文件或目录的名称。
String getParent() 得到文件对象所表示的路径的父目录路径
long length() 得到文件对象所表示的文件的长度。
long lastModified() 得到文件对象所表示的文件上次修改的时间。
String[] list() 得到文件对象代表的文件夹中的所有文件和文件夹名称返回一个字符串数组
File[] listFiles() 得到文件对象代表的文件夹中的所有文件和文件夹的文件对象，返回一个文件对象数组
注意：最后两个的区别，一个是得到名称，一个是不仅得到名称，还有类型，时间，大小等。文件夹没有大小。
例：
import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;
public class FileTset3 {
public static void main(String[] args) throws Exception{
String pathname = "E:" + File.separator + "test" + File.separator + "mytest.txt";
File file = new File(pathname);
// boolean exists() 判断路径名表示的文件或目录是否存在
System.out.println("exists=="+file.exists());//false
// boolean createNewFile() 创建新文件
file.createNewFile();
System.out.println("createNewFile=="+file.exists());//true
// boolean mkdirs() 创建新的文件夹
String dirpathname = "E:" + File.separator + "test1" ;
File dir = new File(dirpathname);
System.out.println("mkdirs=="+dir.mkdirs());//true
// boolean delete() 删除文件/文件夹删除文件夹的时候要将该文件夹下的文件和子文件夹全部删除
System.out.println("delete=="+dir.delete());//true
//System.out.println("delete=="+file.delete());
// boolean canRead() 判断文件是否可读
System.out.println("canRead=="+file.canRead());//true
// boolean canWrite() 判断文件是否可写
System.out.println("canRead=="+file.canWrite());//true
// boolean isHidden() 判断文件是否为隐藏文件。
System.out.println("isHidden=="+file.isHidden());//false
// boolean isFile() 判断文件对象是否为普通文件。
System.out.println("isFile=="+file.isFile());//true
// boolean isDirectory() 判断文件对象是否为目录(文件夹的意思）
System.out.println("isDirectory=="+file.isDirectory());//false
// String getPath() 得到文件对象的路径名字符串。
System.out.println("getPath=="+file.getPath());//E:\test\mytest.txt
// String getName() 得到文件对象所表示的文件或目录的名称。
System.out.println("getName=="+file.getName());//mytest.txt
// String getParent() 得到文件对象所表示的路径的父目录路径
System.out.println("getParent=="+file.getParent());//E:\test
// long length() 得到文件对象所表示的文件的长度。
System.out.println("length=="+file.length()+"kb");//0,里面还没写东西
// long lastModified() 得到文件对象所表示的文件上次修改的时间。
System.out.println("lastModified=="+file.lastModified());//1637132831651看不懂，因此需要格式化时间
Date date=new Date(file.lastModified());
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd E");
sdf.format(date);
System.out.println(sdf.format(date));//2021-11-17 星期三
// String[] list() 得到文件对象代表的文件夹中的所有文件和文件夹名称返回一个字符串数组
String dirpathname1="E:"+File.separator+"java资料";
File dir1=new File(dirpathname1);
String dirnames[]=dir1.list();
for(String name:dirnames){
System.out.println(name);
}
/*07_《Java基础案例教材（第2版）》
Java全能学习面试手册
前端视频*/
// File[] listFiles() 得到文件对象代表的文件夹中的所有文件和文件夹的文件对象，返回一个文件对象数组
String dirpathname2="E:"+File.separator+"java资料";
File dir2=new File(dirpathname2);
File dirnames2[]=dir2.listFiles();
for(File file2:dirnames2){
Date date2=new Date(file2.lastModified());
SimpleDateFormat sdf2=new SimpleDateFormat("yyyy-MM-dd E");
String filetype="";
if(file2.isDirectory()){
filetype="文件夹";
}else{
filetype="不是文件夹";
}
System.out.println(file2.getName()+"\t"+sdf2.format(date2)+"\t"+filetype);
}
/*07_《Java基础案例教材（第2版）》 2021-11-08 星期一 文件夹
Java全能学习面试手册 2021-11-08 星期一 文件夹
前端视频 2021-11-08 星期一 文件夹*/
}
}2.4 作业练习
得到指定文件夹中的指定类型的文件C:\Windows 文件夹中的可以执行文件“.exe”
例：
import java.io.File;
public class FileTset4 {
public static void main(String[] args) throws Exception{
String pathname="C:"+File.separator+"Windows";
File file=new File(pathname);
String[] listnames = file.list();
for(String names:listnames){
if(names.endsWith(".exe")){
System.out.println(names);
}
}
}
}3.输入输出流
3.1定义
输入输出流------读写文件
输入------从文件中获取数据到自己的程序中接收处理【读】
输出------将自己的程序中处理好的数据保存到文件中【写】
流------数据的移动轨迹
3.1 流的分类
按照数据的移动轨迹将流分为输入流和输出流。
按照每一次读/写数据量的大小将流分为：字节流和字符流。
详细划分：字节输入流、字节输出 流、字符输入流、字符输出流。
字节流：每一次可以读写一个字节的数据量，一个字节就是8位2进制，可以处理任何类型的文件【文本，图片，视频…】。
字符流：每一次可以读写一个字符的数据量，一个字符就是16位2进制，只能处理文本类型的数据。但是处理文本数据速度比字节流快，也就是说字符流是专门处理文本的。
3.2 字节输出流
字节输出流-----OutputStream-----抽象类-----不能new-----靠子类
3.2.1 FileOutputStream类
（1）构造方法：
FileOutputStream(File file) 通过File对象创建一个不可追加的字节输出流。
FileOutputStream(File file, boolean append) 通过File对象创建一个是否追加的字节输出流。追加的意思不覆盖之前的，加的数据在前一次数据后面。
FileOutputStream(String name) 通过String 对象创建一个不可追加的字节输出流。
FileOutputStream(String name, boolean append)通过String对象创建一个是否追加的字节输出流。
注意：此类会自动创建文件，没有写createNewFile()方法，一样会有文件产生。
例：
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
public class FileOutputStreamTest {
public static void main(String[] args) throws Exception{
// FileOutputStream(File file) 通过File对象创建一个不可追加的字节输出流
String pathname1="E:"+File.separator+"test"+File.separator+"mytest.txt";
File file1=new File(pathname1);
FileOutputStream outputstream1=new FileOutputStream(file1);//创建FileOutputStream对象
OutputStream outputstream11=new FileOutputStream(file1);//或者上转型对象
// FileOutputStream(File file, boolean append) 通过File对象创建一个是否追加的字节输出流
String pathname2="E:"+File.separator+"test"+File.separator+"mytest.txt";
File file2=new File(pathname2);
FileOutputStream outputstream2=new FileOutputStream(file2,true);//创建FileOutputStream对象
OutputStream outputstream22=new FileOutputStream(file2,true);//或者上转型对象
// FileOutputStream(String name) 通过String对象创建一个不可追加的字节输出流
String pathname3="E:"+File.separator+"test"+File.separator+"mytest.txt";
FileOutputStream outputstream3=new FileOutputStream(pathname3);//创建FileOutputStream对象
OutputStream outputstream33=new FileOutputStream(pathname3);//或者上转型对象
// FileOutputStream(String name,boolean append)通过String对象创建一个是否追加的字节输出流
String pathname4="E:"+File.separator+"test"+File.separator+"mytest.txt";
FileOutputStream outputstream4=new FileOutputStream(pathname4,true);//创建FileOutputStream对象
OutputStream outputstream44=new FileOutputStream(pathname4,true);//或者上转型对象
}
}（2）实例方法：
void write(byte[] b) 将 b.length个字节从指定的字节数组写入此文件输出流。
void write(byte[] b, int off, int len) 将 len字节从位于偏移量 off的指定字节数组写入此文件输出流。
void write(int b) 将指定的字节写入此文件输出流。
void close() 关闭此文件输出流并释放与此流相关联的任何系统资源。
例：
import java.io.File;
import java.io.FileOutputStream;
public class FileOutputStreamTest2 {
public static void main(String[] args) throws Exception {
// 创建FileOutputStream对象
String pathname1 = "E:" + File.separator + "test" + File.separator + "mytest.txt";
File file1 = new File(pathname1);
FileOutputStream outputstream1 = new FileOutputStream(file1, true);// 可追加
/*
* // void write(byte[] b) 将 b.length个字节从指定的字节数组写入此文件输出流。 String
* info="hello,你好呀";//字符串，准备放进txt文件中 byte[] bytes =
* info.getBytes();//字符串转字节数组 outputstream1.write(bytes);
* outputstream1.close();//关闭输出流
*/
/*
* //void write(byte[] b, int off, int len) 将
* len字节从位于偏移量off的指定字节数组写入此文件输出流 String info="hello,world"; byte[] bytes
* = info.getBytes(); outputstream1.write(bytes);
* outputstream1.close();//关闭输出流
*/
// void write(int b) 将指定的字节写入此文件输出流
String info = "hello,world";
byte[] bytes = info.getBytes();
for (byte by : bytes) {
outputstream1.write(by);
}
outputstream1.close();
// void close() 关闭此文件输出流并释放与此流相关联的任何系统资源
}
}3.2.2 DataOutputStream类
特点：可以直接写出基本数据类型的数据和String，且不需要转换成字节数组。
（1）构造方法：
DataOutputStream(OutputStream out) 创建一个新的数据输出流，以将数据写入指定的底层输出流。
（2）实例方法：
void writeBoolean(boolean v) 将 boolean写入底层输出流作为1字节值。
void writeByte(int v) 将 byte作为1字节值写入底层输出流。
void writeChar(int v) 将 char写入底层输出流作为2字节值，高字节优先。
void writeDouble(double v) 双参数传递给转换long使用 doubleToLongBits方法在类 Double ，然后写入该 long值基础输出流作为8字节的数量，高字节。
void writeFloat(float v) 浮子参数的转换 int使用 floatToIntBits方法在类 Float ，然后写入 该 int值基础输出流作为一个4字节的数量，高字节。
void writeInt(int v) 将底层输出流写入 int作为四字节，高位字节。
void writeLong(long v) 将 long写入底层输出流，为8字节，高字节为首。
void writeShort(int v) 将 short写入底层输出流作为两个字节，高字节优先。
void writeUTF(String str) 使用 modified UTF-8编码以机器无关的方式将字符串写入基础输出流
void flush() 刷新此数据输出流。
void close() 关闭此输出流并释放与此流相关联的任何系统资源。
例：
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
public class DataOutputStreamTest {
public static void main(String[] args) throws Exception{
//DataOutputStream(OutputStream out) 创建一个新的数据输出流，以将数据写入指定的底层输出流。
String pathname="E:"+File.separator+"test"+File.separator+"mytest.txt";
File file=new File(pathname);
OutputStream opstream=new FileOutputStream(file,true);//底层流
DataOutputStream output=new DataOutputStream(opstream);//高级流
/*
void writeBoolean(boolean v) 将 boolean写入底层输出流作为1字节值。
void writeByte(int v) 将 byte作为1字节值写入底层输出流。
void writeChar(int v) 将 char写入底层输出流作为2字节值，高字节优先。
void writeDouble(double v) 双参数传递给转换 long使用 doubleToLongBits方法在类 Double ， 然后写入该 long值基础输出流作为8字节的数量，高字节。
void writeFloat(float v) 浮子参数的转换 int使用 floatToIntBits方法在类 Float ，然后写入 该 int值基础输出流作为一个4字节的数量，高字节。
void writeInt(int v) 将底层输出流写入 int作为四字节，高位字节。
void writeLong(long v) 将 long写入底层输出流，为8字节，高字节为首。
void writeShort(int v) 将 short写入底层输出流作为两个字节，高字节优先。
void writeUTF(String str) 使用 modified UTF-8编码以机器无关的方式将字符串写入基础输出流
void flush() 刷新此数据输出流。
void close() 关闭此输出流并释放与此流相关联的任何系统资源。
*/
int a=2021;
double b=20.0;
float f=90.9f;
char c='D';
boolean l=true;
String name="zhangsan";
output.writeInt(a);
output.writeBoolean(true);
output.writeChar(c);
output.writeFloat(f);
output.writeDouble(b);
output.writeUTF(name);
output.close();
opstream.close();
//优点:可以直接写出基本数据类型的数据和String，且不需要转换成字节数组
//缺点:保存到文件中的数据是乱码
}
}优点:可以直接写出基本数据类型的数据和String，且不需要转换成字节数组
缺点:保存到文件中的数据是乱码，因此需要继续使用DataInputStream类，读回来再保存到文件中
3.3 字节输入流
字节输入流-----InputStream-----抽象类-----不能new-----靠子类
3.3.1 FileInputStream类
（1）构造方法：
FileInputStream(File file) 通过File对象创建一个字节输入流
FileInputStream(String name) 通过String对象创建一个字节输入流
例：
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class FileInputStreamTest {
public static void main(String[] args) throws Exception {
//FileInputStream(File file) 通过File对象创建一个字节输入流
String pathname1 = "E:" + File.separator + "test" + File.separator + "mytest.txt";
File file1 = new File(pathname1);
FileInputStream input1=new FileInputStream(file1);
InputStream input11=new FileInputStream(file1);//也可以上转型
//FileInputStream(String name) 通过String对象创建一个字节输入流
FileInputStream input2=new FileInputStream(pathname1);
InputStream input22=new FileInputStream(pathname1);//也可以上转型
}
}（2）实例方法：
int read() 从该输入流读取一个字节的数据。返回值：读取到的具体字节数据的int型，如果到达文件末尾返回-1。
int read(byte[] b) 从该输入流读取最多 b.length个字节的数据为字节数组。返回值:读取的总字节数，如果到达文件末尾返回-1。（读取全部的这个好一点）
void close() 关闭此文件输入流并释放与流相关联的任何系统资源。
例：
import java.io.File;
import java.io.FileInputStream;
public class FileInputStreamTest2 {
public static void main(String[] args) throws Exception {
//FileInputStream(File file) 通过File对象创建一个字节输入流
String pathname1 = "E:" + File.separator + "test" + File.separator + "mytest.txt";
File file1 = new File(pathname1);
FileInputStream input1=new FileInputStream(file1);
//目前mytest.txt中的内容是aahhhello,world
//int read() 从该输入流读取一个字节的数据。返回值：读取到的具体字节数据的int型，如果到达文件末尾返回-1。
int read1=input1.read();
System.out.println(read1);//97,97不是我要的，我要的是a
//把读来的数放到字节数组中，在把字节数组转换成String输出
byte bytearray[]=new byte[(int)file1.length()];
bytearray[0]=(byte)read1;
String str=new String(bytearray);
System.out.println(str);
//现在输出所有的，因为一次只能读一个字节，因此遍历就可以解决了
byte bytearray1[]=new byte[(int)file1.length()];
int index=0;
int i=0;
while((i=input1.read())!=-1){
bytearray1[index]=(byte)i;
index++;
}
String str1=new String(bytearray1,0,index);
System.out.println(str1);
input1.close();
//输出了ahhhello,world，因为前面读过第一个了，就从第2个开始，因为是流，用过就回不去了，只能往下走
//int read(byte[] b) 从该输入流读取最多 b.length个字节的数据为字节数组。返回值:读取的总字节数，如果到达文件末尾返回-1。
//这个方法就个很快
String pathname2 = "E:" + File.separator + "test" + File.separator + "mytest.txt";
File file2 = new File(pathname2);
FileInputStream input2=new FileInputStream(file2);
byte bytearray2[]=new byte[(int)file2.length()];
int len=input2.read(bytearray2);
String info=new String(bytearray2,0,len);
System.out.println(info);//aahhhello,world
//void close() 关闭此文件输入流并释放与流相关联的任何系统资源。
input2.close();
}
}3.3.2 DataInputStream类
（1）构造方法：
DataInputStream(InputStream in)创建使用指定的底层InputStream的DataInputStream输入流。
（2）实例方法：
boolean readBoolean()
byte readByte()
char readChar()
double readDouble()
float readFloat()
int readInt()
long readLong()
short readShort()
String readUTF()
void close()
例：
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
public class DataInputStreamTest {
public static void main(String[] args) throws Exception{
String pathname="E:"+File.separator+"test"+File.separator+"mytest.txt";
File file=new File(pathname);
InputStream instream=new FileInputStream(file);//底层流
DataInputStream intput=new DataInputStream(instream);//高级流
int a=intput.readInt();
boolean b=intput.readBoolean();
char c=intput.readChar();
float d=intput.readFloat();
double e=intput.readDouble();
String f=intput.readUTF();
intput.close();
instream.close();
System.out.println(a+"\t"+b+"\t"+c+"\t"+d+"\t"+e+"\t"+f);//2021 true D 90.9 20.0
}
}3.4 复制功能/剪贴功能练习
例：
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class CopyTxtTest {
public static void main(String[] args) throws Exception{
/**
* 将E盘目录下的test文件夹里的mytest.txt复制到E盘目录下
*
*/
//先输入流
String inpathname="E:"+File.separator+"test"+File.separator+"mytest.txt";
File filein=new File(inpathname);
FileInputStream input=new FileInputStream(filein);
byte bytearray1[]=new byte[(int)filein.length()];
int len=input.read(bytearray1);
//如果是剪切，只需要删除mytest.txt就好
//filein.delete();
//输出流
String outpathname="E:"+File.separator+"mytest.txt";
File fileout=new File(outpathname);
FileOutputStream output=new FileOutputStream(fileout);
for (byte by : bytearray1) {
output.write(by);
}
output.close();
input.close();
}
}例2：
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class CopyPictureTest {
public static void main(String[] args) throws Exception{
/**
* 将E盘目录下的photo.jpg复制到E盘目录下mytest文件夹里
*
*/
//输入流
String inpathname="E:"+File.separator+"photo.jpg";
File filein=new File(inpathname);
FileInputStream input=new FileInputStream(filein);
byte bytearray1[]=new byte[(int)filein.length()];
int len=input.read(bytearray1);
// String info=new String(bytearray1,0,len);
// System.out.println(info);
//
//如果是剪切，只需要filein.delete();删除
//输出流
String outpathname="E:"+File.separator+"test"+File.separator+"photo.jpg";
File fileout=new File(outpathname);
FileOutputStream output=new FileOutputStream(fileout);
output.write(bytearray1);
output.close();
input.close();
}
}
455
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
