一、File类的使用
-
File类的理解
- File类的一个对象，代表一个文件或一个文件目录(俗称：文件夹)
- File类声明在java.io包下
- File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法，
并未涉及到写入或读取文件内容的操作。如果需要读取或写入文件内容，必须使用IO流来完成 - 后续File类的对象常会作为参数传递到流的构造器中，指明读取或写入的"终点".
-
File的实例化
-
常用构造器
File(String filePath)
File(String parentPath,String childPath)
File(File parentFile,String childPath)@Test public void test1(){ //构造器1 File file1 = new File("hello.txt");//相对于当前module File file2 = new File("G:\\IDEA_code\\workspace_idea1\\JavaSenior\\JavaLearn9\\he.txt");//相对于当前module System.out.println(file1); System.out.println(file2); //构造器2 File file3 = new File("G:\\IDEA_code\\workspace_idea1","JavaSenior"); System.out.println(file3); //构造器3 File file4 = new File(file3,"hi.txt"); System.out.println(file4); } -
路径的分类
相对路径：相较于某个路径下，指明的路径。
绝对路径：包含盘符在内的文件或文件目录的路径
说明：
IDEA中：
如果开发使用JUnit中的单元测试方法测试，相对路径即为当前Module下。
如果使用main()测试，相对路径即为当前的Project下。
Eclipse中：
不管使用单元测试方法还是使用main()测试，相对路径都是当前的Project下。 -
路径分隔符
windows和DOS系统默认使用“\”来表示
UNIX和URL使用“/”来表示
-
-
File类的常用方法
-
File类的获取功能
- public String getAbsolutePath()：获取绝对路径
- public String getPath() ：获取路径
- public String getName() ：获取名称
- public String getParent()：获取上层文件目录路径。若无，返回null
- public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
- public long lastModified() ：获取最后一次的修改时间，毫秒值
- public String[] list() ：获取指定目录下的所有文件或者文件目录的名称数组
- public File[] listFiles() ：获取指定目录下的所有文件或者文件目录的File数组
@Test public void test2(){ File file1 = new File("hello.txt"); File file2 = new File("G:\\io\\hi.txt"); System.out.println(file1.getAbsoluteFile());//G:\IDEA_code\workspace_idea1\JavaSenior\JavaLearn9\hello.txt System.out.println(file1.getPath());//hello.txt System.out.println(file1.getName());//hello.txt System.out.println(file1.getParent());//null System.out.println(file1.length());//6 System.out.println(file1.lastModified());//1607781701874 System.out.println(); System.out.println(file2.getAbsoluteFile());//G:\io\hi.txt System.out.println(file2.getPath());//G:\io\hi.txt System.out.println(file2.getName());//hi.txt System.out.println(file2.getParent());//G:\io System.out.println(file2.length());//0 System.out.println(file2.lastModified());//0 } -
File类的重命名功能
public boolean renameTo(File dest):把文件重命名为指定的文件路径
比如：file1.renameTo(file2)为例：
要想保证返回true，需要file1在硬盘中是存在的，且file2不能在硬盘中存在。
@Test public void test4(){ File file1 = new File("hello.txt"); File file2 = new File("G:\\io\\hi.txt"); boolean rename = file2.renameTo(file1); System.out.println(rename); }- File类的判断功能
1. public boolean isDirectory()：判断是否是文件目录
2. public boolean isFile() ：判断是否是文件
3. public boolean exists() ：判断是否存在
4. public boolean canRead() ：判断是否可读
5. public boolean canWrite() ：判断是否可写
6. public boolean isHidden() ：判断是否隐藏
@Test public void test5(){ File file1 = new File("hello.txt"); System.out.println(file1.isDirectory()); System.out.println(file1.isFile()); System.out.println(file1.exists()); System.out.println(file1.canRead()); System.out.println(file1.canWrite()); System.out.println(file1.isHidden()); }-
File类的创建功能
- public boolean createNewFile() ：创建文件。若文件存在，则不创建，返回false
- public boolean mkdir() ：创建文件目录。如果此文件目录存在，就不创建了。
如果此文件目录的上层目录不存在，也不创建。 - public boolean mkdirs() ：创建文件目录。如果上层文件目录不存在，一并创建
-
File类的删除功能
@Test public void test6() throws IOException { //文件的创建 File file1 = new File("hi.txt"); if(!file1.exists()){//文件不存在 file1.createNewFile(); System.out.println("创建成功"); }else{ file1.delete(); System.out.println("删除成功"); } } @Test public void test7(){ //文件目录的创建 File file1 = new File("g:\\io\\io1"); boolean mkdir = file1.mkdir(); if(mkdir){ System.out.println("创建成功"); } } -
二、I/O流的概述
- 流的分类
- 数据的流向：输入流、输出流
- 操作的数据单位：字节流、字符流
- 流的角色：节点流、处理流
- 流的体系结构
- 重点说明的几个流的结构
| 抽象基类 | 节点流（或文件流） | 缓冲流（处理流的一种） |
|---|---|---|
| InputStream | FileInputStream(read(byte[] buffer) | BufferedInputStream (read(byte[] buffer)) |
| OutputStream | FileOutputStream(write(byte[] buffer,0,len) | BufferedOutputStream(write(byte[] buffer,0,len) / flush() |
| Reader | FileReader (read(char[] cbuf))) | BufferedReader (read(char[] cbuf) / readLine())) |
| Writer | FileWriter (write(char[] cbuf,0,len) | BufferedWriter (write(char[] cbuf,0,len) / flush() |
- 输入标准化过程
- 创建File类的对象，指明读取的数据的来源。（要求此文件一定要存在）
- 创建相应的输入流，将File类的对象作为参数，传入流的构造器中
- 具体的读入过程
创建相应的byte[] 或 char[] - 关闭流资源
说明：程序中出现的异常需要使用try-catch-finally处理
- 标准化输出过程
- 创建File类的对象，指明写出的数据的位置。（不要求此文件一定要存在）
- 创建相应的输出流，将File类的对象作为参数，传入流的构造器中
- 具体的写出过程：
write(char[]/byte[] buffer,0,len) - 关闭流资源
三、节点流（或文件流）
- FlieReader/FileWriter的使用
- FileReader的使用
/* 将JavaLearn9下的hello.txt文件内容读入程序中，并输出到控制台 说明点： 1. read()的理解：返回读入的一个字符。如果到达文件末尾，返回-1 2. 异常的处理：为了保证流资源一定可以执行关闭操作。需要使用try-catch-finally处理 3. 读入的文件一定要存在，否则会报异常 */ @Test public void testFileReader() { FileReader fr = null; try { //1. 实例化File类的对象，指明要操作的文件 File file = new File("hello.txt");//相较于当前Module //2. 提供具体的流 fr = new FileReader(file); //3. 数据的读入 //read():返回读入的一个字符。如果达到文件末尾，返回-1 int data; while ((data=fr.read()) != -1){ System.out.println((char)data); } } catch (IOException e) { e.printStackTrace(); } finally { //4. 流的关闭操作 try { if(fr != null) fr.close(); } catch (IOException e) { e.printStackTrace(); } } } //对read()操作升级：使用read的重载方法 @Test public void tetsFileReader1(){ FileReader fr = null; try { //1. File类的实例化 File file = new File("hello.txt"); //2. FileReader流的实例化 fr = new FileReader(file); //3. 读入的操作 //read(char[] cbuf)：返回每次读入cbuf数组中的字符个数。如果到达文件末尾，返回-1 char[] cbuf = new char[5]; int len; while ((len = fr.read(cbuf))!= -1){ //方式一： //错误的写法 // for (int i = 0; i < cbuf.length; i++) { // System.out.println(cbuf[i]); // } //正确的写法 // for (int i = 0; i < len; i++) { // System.out.println(cbuf[i]); // } //方式二： //错误的写法，对应着方式一的错误的写法 // String str = new String(cbuf); // System.out.println(str); //正确的写法 String str =new String(cbuf,0,len); System.out.println(str); } } catch (IOException e) { e.printStackTrace(); } finally { if(fr!=null) { //4. 资源的关闭 try { fr.close(); } catch (IOException e) { e.printStackTrace(); } } } }- FileWriter的使用
/* 从内存中写出数据到硬盘文件里 说明： 1. 输出操作，对应的File可以不存在。 2. File对应的硬盘中文件如果不存在，在输出的过程中，会自动创建此文件 File对应的硬盘中文件如果存在： 如果流使用的构造器是：FileWriter(file,false) / FileWriter(file):对原有文件的覆盖 如果流使用的构造器是：FileWriter(file,true):不会对原有文件覆盖，而是在原有文件基础上追加内容 */ @Test public void testFileWriter() { FileWriter fw = null; try { //1.提供File类的对象，指明写出到的文件 File file = new File("hello1.txt"); //2.提供FileWriter的对象，用于数据的写出 fw = new FileWriter(file); //3.写出的操作 fw.write("I have a dream!\n"); fw.write("You need to have a dream!"); } catch (IOException e) { e.printStackTrace(); } finally { //4.流资源的关闭 if(fw != null) { try { fw.close(); } catch (IOException e) { e.printStackTrace(); } } } }- 文本文件的复制
@Test public void testFileReaderFileWriter(){ FileReader fr = null; FileWriter fw = null; try { //1.创建File类的对象，指明读入和写出的文件 File srcFile = new File("hello.txt"); File destFile = new File("hello2.txt"); //2.创建输入流和输出流的对象 fr = new FileReader(srcFile); fw = new FileWriter(destFile); //3.数据的读入和写出操作 char[] cbuf = new char[5]; int len; while ((len = fr.read(cbuf)) != -1){ //每次写出len个字符 fw.write(cbuf,0,len); } } catch (IOException e) { e.printStackTrace(); } finally { //4.流资源的关闭 try { if(fw != null) fw.close(); } catch (IOException e) { e.printStackTrace(); } try { if(fr != null) fr.close(); } catch (IOException e) { e.printStackTrace(); } } } - FileInputStream / FileOutputStream的使用：
/**
测试FileInputStream和FileOutputStream的使用
结论：
1. 对于文本文件（.txt,.java,.c,.cpp），使用字符流处理
2. 对于非文本文件（.jpg,.mp3,.mp4,.avi,.doc,.ppt,....），使用字节流处理
* @author zhkey
* @create 2020-12-13
*/
@Test
public void testFileInputOuputStream(){
FileInputStream fis = null;
FileOutputStream fos = null;
try {
//
File srcFile = new File("kobe.jpg");
File destFile = new File("kobe1.jpg");
//
fis = new FileInputStream(srcFile);
fos = new FileOutputStream(destFile);
//复制的过程
byte[] buffer = new byte[5];
int len;
while ((len = fis.read(buffer)) != -1){
fos.write(buffer,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//
if(fis != null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(fos != null){
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
四、缓冲流的使用
- 缓冲流涉及到的类：
BufferedInputStream
BufferedOutputStream
BufferedReader
BufferedWriter - 作用： 提高流的读取、写入的速度
提高读写速度的原因：内部提供了一个缓冲区 - 使用BufferedInputStream和BufferedOutputStream:处理非文本文件
public class BufferTest {
/*
实现非文本文件的复制
*/
@Test
public void BuffereedStreamTest(){
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
//1.造文件
File srcfile = new File("kobe.jpg");
File destfile = new File("kobe2.jpg");
//2.造流
//造节点流
FileInputStream fis = new FileInputStream(srcfile);
FileOutputStream fos = new FileOutputStream(destfile);
//造缓冲流
bis = new BufferedInputStream(fis);
bos = new BufferedOutputStream(fos);
//3.复制的细节：读取、写入
byte[] buffer = new byte[10];
int len;
while ((len = bis.read(buffer))!=-1){
bos.write(buffer,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//4.资源关闭
//要求：先关闭外层的流，再关闭内层的流
if(bis != null){
try {
bis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(bos != null){
try {
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//说明：关闭外层流的同时，内层流也会自动关闭。关于内层流的关闭，可以省略
// fis.close();
// fos.close();
}
- 使用BufferedReader和BufferedWriter：处理文本文件
/*
使用BufferedReader和BufferedWriter实现文本文件的复制
*/
@Test
public void BufferedReaderWriterTest(){
BufferedReader br = null;
BufferedWriter bw = null;
try {
//创建文件相应的流
br = new BufferedReader(new FileReader(new File("dbcp.txt")));
bw = new BufferedWriter(new FileWriter(new File("dbcp1.txt")));
//读写操作
//方式一：使用char[]数组
// char[] cbuf = new char[1024];
// int len;
// while ((len = br.read(cbuf))!=-1){
// bw.write(cbuf,0,len);
// }
//方式二：使用String
String data;
while ((data = br.readLine()) != null){
bw.write(data + "\n");//data中不包含换行符
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//关闭资源
if(br != null){
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(bw != null){
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
五、转换流的使用
- 转换流涉及到的类：属于字符流
InputStreamReader： 将一个字节的输入流转换为字符的输入流
解码：字节、字节数组 —>字符数组、字符串
OutputStreamWriter： 将一个字符的输出流转换为字节的输出流
编码：字符数组、字符串 —> 字节、字节数组 - 作用： 提供字节流与字符流之间的转换
- 代码实现
/*
InputStreamReader的使用，实现字节输入流到字符输入流的转化
*/
@Test
public void test1() {
InputStreamReader isr = null;
try {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("dbcp.txt"));
isr = new InputStreamReader(bis);
//参数2指明了字符集，具体使用哪个字符集，取决于文件保存时使用的字符集
// InputStreamReader isr = new InputStreamReader(bis,"UTF-8");
char[] cbuf = new char[20];
int len;
while ((len = isr.read(cbuf)) != -1) {
String str = new String(cbuf, 0, len);
System.out.print(str);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (isr != null) {
try {
isr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/*
综合使用InputStreamReader和OutputStreamWriter
*/
@Test
public void test2(){
InputStreamReader isr = null;
OutputStreamWriter osw =null;
try {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("dbcp.txt"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("dbcp_gbk.txt"));
isr = new InputStreamReader(bis);
osw = new OutputStreamWriter(bos,"gbk");
//参数2指明了字符集，具体使用哪个字符集，取决于文件保存时使用的字符集
// InputStreamReader isr = new InputStreamReader(bis,"UTF-8");
char[] cbuf = new char[20];
int len;
while ((len = isr.read(cbuf)) != -1) {
osw.write(cbuf,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (isr != null) {
try {
isr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(osw != null) {
try {
osw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
- 编码集：
ASCII：美国标准信息交换码。
-------用一个字节的7位可以表示。
ISO8859-1：拉丁码表。欧洲码表
-------用一个字节的8位表示。
GB2312：中国的中文编码表。最多两个字节编码所有字符
GBK：中国的中文编码表升级，融合了更多的中文文字符号。最多两个字节编码
Unicode：国际标准码，融合了目前人类使用的所有字符。为每个字符分配唯一的字符码。所有的文字都用两个字节来表示。
UTF-8：变长的编码方式，可用1-4个字节来表示一个字符。
六、其他流的使用
-
标准的输入输出流：
System.in： 标准的输入流，默认从键盘输入
System.out： 标准的输出流，默认从控制台输出
修改默认的输入和输出行为：System类的setIn(InputStream is) / setOut(PrintStream ps)方式重新指定输入和输出的流 -
打印流：
PrintStream 和 PrintWriter
说明：
提供了一系列重载的print()和println()方法，用于多种数据类型的输出
System.out返回的是PringStream实例 -
数据流：
DataInputStream 和 DataOutputStream
作用：用于读取或写出基本数据类型的变量或字符串
示例代码
/*
练习：将内存中的字符串、基本数据类型的变量写出到文件中。
注意：处理异常的话，仍然应该使用try-catch-finally.
*/
@Test
public void test3() throws IOException {
//1.
DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
//2.
dos.writeUTF("刘建辰");
dos.flush();//刷新操作，将内存中的数据写入文件
dos.writeInt(23);
dos.flush();
dos.writeBoolean(true);
dos.flush();
//3.
dos.close();
}
/*
将文件中存储的基本数据类型变量和字符串读取到内存中，保存在变量中。
注意点：读取不同类型的数据的顺序要与当初写入文件时，保存的数据的顺序一致！
*/
@Test
public void test4() throws IOException {
//1.
DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
//2.
String name = dis.readUTF();
int age = dis.readInt();
boolean isMale = dis.readBoolean();
System.out.println("name = " + name);
System.out.println("age = " + age);
System.out.println("isMale = " + isMale);
//3.
dis.close();
}
七、对象流的使用
-
对象流：
ObjectInputStream 和 ObjectOutputStream -
作用：
- ObjectOutputStream：内存中的对象----->存储中的文件、通过网络传输出去：序列化过程
- ObjectInputStream：存储中的文件、通过网络接收过来----->内存中的对象：反序列化过程
-
对象的序列化机制：
对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久的保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。当其他程序获取了这种二进制流，就可以恢复成原来的Java对象 -
序列化过程：
@Test
public void testObjectOutputStream(){
ObjectOutputStream oos = null;
try {
//1.
oos = new ObjectOutputStream(new FileOutputStream("object.dat"));
//2.
oos.writeObject(new String("我是一名程序员！"));
oos.flush();//刷新操作
oos.writeObject(new Person("Zhkey",21));
oos.flush();
//3.
} catch (IOException e) {
e.printStackTrace();
} finally {
if(oos != null) {
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
- 反序列化过程：
@Test
public void testObjectInputStream(){
ObjectInputStream ois = null;
try {
ois = new ObjectInputStream(new FileInputStream("object.dat"));
Object obj = ois.readObject();
String str = (String)obj;
Person p = (Person)ois.readObject();
System.out.println(str);
System.out.println(p);
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally {
if(ois != null) {
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
- 实现序列化的是对象所属的类需要满足：
- 需要实现接口：Serializable
- 当前类提供一个全局常量：serialVersionUID
- 除了当前Person类需要实现Serializable接口之外，还必须保证其内部所有属性也必须是可序列化的。（默认情况下，基本数据类型可序列化）
补充：ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量
八、RandomAccessFile的使用
-
随机存取文件流：RandomAccessFile
-
使用说明：
- RandomAccessFile直接继承于java.lang.Object类，实现了DataInput和DataOutput接口
- RandomAccessFile既可以作为一个输入流，又可以作为一个输出流
- 如果RandomAccessFile作为输出流时，写出到的文件如果不存在，则在执行过程中自动创建。
如果写出到的文件存在，则会对原文件内容进行覆盖。（默认情况下，从头覆盖） - 可以通过相关的操作，实现RandomAccessFile“插入”数据的效果。seek(int pos)
-
典型代码1：
@Test
public void test1() {
RandomAccessFile raf1 = null;
RandomAccessFile raf2 = null;
try {
//1.
raf1 = new RandomAccessFile(new File("爱情与友情.jpg"),"r");
raf2 = new RandomAccessFile(new File("爱情与友情1.jpg"),"rw");
//2.
byte[] buffer = new byte[1024];
int len;
while((len = raf1.read(buffer)) != -1){
raf2.write(buffer,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//3.
if(raf1 != null){
try {
raf1.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(raf2 != null){
try {
raf2.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
典型代码2：
/*
使用RandomAccessFile实现数据的插入效果
*/
@Test
public void test3() throws IOException {
RandomAccessFile raf1 = new RandomAccessFile("hello.txt","rw");
raf1.seek(3);//将指针调到角标为3的位置
//保存指针3后面的所数据到StringBuilder中
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)) ;
}
//调回指针，写入“xyz”
raf1.seek(3);
raf1.write("xyz".getBytes());
//将StringBuilder中的数据写入到文件中
raf1.write(builder.toString().getBytes());
raf1.close();
//思考：将StringBuilder替换为ByteArrayOutputStream
}
扫一扫
248
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
