java文件File和IO流（一）-- File文件，IO流，缓冲流，字节流，字符流

最新推荐文章于 2024-04-20 19:33:09 发布

2401_83641098

最新推荐文章于 2024-04-20 19:33:09 发布

阅读量595

点赞数 11

分类专栏：程序员文章标签： java windows 开发语言

本文链接：https://blog.csdn.net/2401_83641098/article/details/137998536

版权

程序员专栏收录该内容

508 篇文章 1 订阅

订阅专栏

boolean exists()：判断文件或者文件夹是否存在。
boolean isDirectory()：测试此抽象路径名表示的文件是否是一个目录。
boolean isFile()：测试此抽象路径名表示的文件是否是一个标准文件。
boolean isHidden()：测试此抽象路径名指定的文件是否是一个隐藏文件。
boolean isAbsolute()：测试此抽象路径名是否为绝对路径名。
Public boolean canRead()：判断是否可读
public boolean canWrite()：判断是否可写

File file2 = new File(“F:\cc\vv”);
file2.mkdir();
System.out.println(file2.exists());// 判断文件或者文件夹是否存在。
System.out.println(file2.isDirectory());// 测试此抽象路径名表示的文件是否是一个目录。
System.out.println(file2.isFile());// 测试此抽象路径名表示的文件是否是一个标准文件。
System.out.println(file2.isHidden());// 测试此抽象路径名指定的文件是否是一个隐藏文件。
System.out.println(file2.isAbsolute());// 测试此抽象路径名是否为绝对路径名。
System.out.println(file2.canRead());// 判断是否可读
System.out.println(file2.canWrite());// 判断是否可写


##### **过滤器功能**

String[] a = file2.list(new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
return new File(dir, name).isFile() && name.endsWith(“jpg”);
}
});



#### **5：重命名。**

重命名
File file1 = new File(“e:\c2c.txt”);
File newFile = new File(“e:\c22c.txt”);
System.out.println(file1.renameTo(newFile));

剪切
File newFile = new File(“e:\c2c.txt”);
File file4 = new File(“F:\c2c.txt”);
System.out.println(file4.renameTo(newFile));

// 可以实现移动的效果。剪切+重命名。
boolean renameTo(File dest)：

// 列出指定目录下的当前的文件和文件夹的名称。包含隐藏文件。
String[] list()：
// 如果调用list方法的File 对象中封装的是一个文件，那么list方法返回数组为null。
// 如果封装的对象不存在也会返回null。只有封装的对象存在并且是文件夹时，这个方法才有效。

// 判断File对象指定的文件或某个文件夹是否是一个隐藏文
System.out.println(f1.isHidden());

// 返回File对象指定的分区大小，以字节为单位；如果File对象没有指定分区，则返回 0L。
System.out.println(f1.getTotalSpace()+“---------”);

// 返回File对象表示的文件最后一次被修改的时间，
// 用与时间点（1970年1月1日，00:00:00 GMT）之间的毫秒数表示。
// 如果该文件不存在，或者发生I/O错误，则返回0L
System.out.println(f1.lastModified()+“---------。”);


## **IO****流：**


用于处理设备上数据。


### **IO流原理**


* I/O是Input/Output的缩写，I是指Input（输入）,O是指Output（输出），I/O技术是非常实用的技术，用于处理设备之间的数据传输。如读/写文件，网络通讯等。
* Java程序中，对于数据的输入/输出操作以“流**(stream)**”的方式进行。
* java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。
* 输入**input**：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中。
* 输出**output**：将程序（内存）数据输出到磁盘、光盘等存储设备


### **IO流的分类**


#### **流:**


可以理解数据的流动，就是一个数据流。IO流最终要以对象来体现，对象都存在IO包中。注意：**流的操作只有两种：读和写。**


* 按**操作数据单位**不同分为：**字节流****(8 bit)****，字符流****(16 bit)**
* 按**数据流的流向**不同分为：**输入流，输出流**
* 按**流的角色**的不同分为：**节点流，处理流**


流的体系因为功能不同，但是有共性内容，不断抽取，形成继承体系。该体系一共有四个基类，而且都是抽象类。




|  |  |  |
| --- | --- | --- |
| **(****抽象基类****)** | **字节流** | **字符流** |
| 输入流 | **InputStream** | **Reader** |
| 输出流 | **OutputStream** | **Writer** |


1. Java的IO流共涉及40多个类，实际上非常规则，都是从如下4个抽象基类派生的。


    **字节流的两个顶层父类：****1****，** **InputStream 2****，** **OutputStream.**


**字符流的两个顶层父类：****1****，** **Reader 2****，** **Writer**


2. 在这四个系统中，它们的子类，都有一个共性特点：子类名后缀都是父类名，前缀名都是这个子类的功能名称。


![](https://img-blog.csdnimg.cn/direct/b5f31f0e7cd34bd9b1e218a5cda6fe5c.png)

public static void main(String[] args) throws IOException { //读、写都会发生IO异常
/*
* 1：创建一个字符输出流对象，用于操作文件。该对象一建立，就必须明确数据存储位置，是一个文件。
* 2：对象产生后，会在堆内存中有一个实体，同时也调用了系统底层资源，在指定的位置创建了一个存储数据的文件。
* 3：如果指定位置，出现了同名文件，文件会被覆盖。
/
FileWriter fw = new FileWriter(“demo.txt”); // FileNotFoundException
/ 调用Writer类中的write方法写入字符串。字符串并未直接写入到目的地中，而是写入到了流中，(其实是写入到内存缓冲区中)。怎么把数据弄到文件中？
*/
fw.write(“abcde”);
fw.flush(); // 刷新缓冲区，将缓冲区中的数据刷到目的地文件中。
fw.close(); // 关闭流，其实关闭的就是java调用的系统底层资源。在关闭前，会先刷新该流。
}


#### **InputStream& Reader**

InputStream和Reader 是所有输入流的基类。
InputStream（典型实现：FileInputStream）
In tread()
Int read(byte[] b)
Int read(byte[] b, intoff, intlen)
Reader（典型实现：FileReader）
Int read()
int read(char [] c)
nt read(char [] c, intoff, intlen)


 程序中打开的文件IO 资源不属于内存里的资源，垃圾回收机制无法回收该资源，所以应该显式关闭文件**IO** 资源。


FileInputStream 从文件系统中的某个文件中获得输入字节。FileInputStream 用于读取非文本数据之类的原始字节流。要读取字符流，需要使用FileReader


##### **InputStream**

Int read()
从输入流中读取数据的下一个字节。返回0到255范围内的int字节值。
如果因为已经到达流末尾而没有可用的字节，则返回值-1。

int read(byte[]b)
从此输入流中将最多b.length个字节的数据读入一个byte数组中。
如果因为已经到达流末尾而没有可用的字节，则返回值-1。否则以整数形式返回实际读取的字节数。

int read(byte[]b, int off, int len)
将输入流中最多len个数据字节读入byte数组。尝试读取len个字节，但读取的字节也可能小于该值。
以整数形式返回实际读取的字节数。如果因为流位于文件末尾而没有可用的字节，则返回值-1。

public void close() throws IOException
关闭此输入流并释放与该流关联的所有系统资源。


##### **Reader**

int read()
读取单个字符。作为整数读取的字符，范围在0到65535之间(0x00-0xffff)（2个字节的Unicode码），
如果已到达流的末尾，则返回-1

int read(char[] cbuf)
将字符读入数组。如果已到达流的末尾，则返回-1。否则返回本次读取的字符数。

int read(char[] cbuf, int off, int len)
将字符读入数组的某一部分。存到数组cbuf中，从off处开始存储，最多读len个字符。
如果已到达流的末尾，则返回-1。否则返回本次读取的字符数。

public void close() throws IOException
关闭此输入流并释放与该流关联的所有系统资源。


#### **OutputStream& Writer**


Output Stream 和Writer 也非常相似：

Output Stream 和Writer 也非常相似：
void write(intb/intc);
void write(byte[] b/char[] cbuf);
void write(byte[] b/char[] buff,int off, int len);
void flush();
void close(); 需要先刷新，再关闭此流
因为字符流直接以字符作为操作单位，所以Writer 
可以用字符串来替换字符数组，即以String 对象作为参数

void write(String str);
void write(String str, int  off, int  len);


  FileOutputStream 从文件系统中的某个文件中获得输出字节。FileOutputStream 用于写出非文本数据之类的原始字节流。要写出字符流，需要使用FileWriter


##### **OutputStream**

void write(intb)
将指定的字节写入此输出流。write的常规协定是：向输出流写入一个字节。
要写入的字节是参数b的八个低位。b的24个高位将被忽略。即写入0~255范围的。

Void write(byte[]b)
将b.length个字节从指定的byte数组写入此输出流。write(b)的常规协定是：
应该与调用write(b,0,b.length)的效果完全相同。

void write(byte[]b,int off,int len)
将指定byte数组中从偏移量off开始的len个字节写入此输出流。

public void flush() throws IOException
刷新此输出流并强制写出所有缓冲的输出字节，
调用此方法指示应将这些字节立即写入它们预期的目标。

public void close() throws IOException
关闭此输出流并释放与该流关联的所有系统资源。



##### **Writer**

void write(int c)
写入单个字符。要写入的字符包含在给定整数值的16个低位中，16高位被忽略。
即写入0到65535之间的Unicode码。

void write(char[]cbuf)
写入字符数组。

void write(char[]cbuf, int off ,int len)
写入字符数组的某一部分。从off开始，写入len个字符

void write(String str)
写入字符串。

void write(String str,int off,int len)
写入字符串的某一部分。

void flush()
刷新该流的缓冲，则立即将它们写入预期目标。

public void close() throws IOException
关闭此输出流并释放与该流关联的所有系统资源。



### **IO流中close()和flush()的区别：**

flush()：将缓冲区的数据刷到目的地中后，流可以使用。

close()：将缓冲区的数据刷到目的地中后，流就关闭了，
该方法主要用于结束调用的底层资源。这个动作一定做。


### **IO流缓冲区**


#### **缓冲区是提高效率用的，给谁提高呢？**


    提高效率的，提高流的操作数据的效率。所以创建缓冲区之前必须先有流。


#### **缓冲区的基本思想：**


其实就是定义容器将数据进行临时存储。对于缓冲区对象，其实就是将这个容器进行了封装，并提供了更多高效的操作方法。


### **IO流异常的处理方式：**


io一定要写finally；


### **IO流设计模式：装饰设计模式。**


IO中的使用到了一个装饰设计模式解决：对一组类进行功能的增强。


包装：写一个类(包装类)对被包装对象进行包装；


       \*1、包装类和被包装对象要实现同样的接口；


\*2、包装类要持有一个被包装对象；


\*3、包装类在实现接口时，大部分方法是靠调用被包装对象来实现的，对于需要修改的方法我们自己实现；


### **IO流之流对象：**


        其实很简单，就是读取和写入。但是因为功能的不同，流的体系中提供N多的对象。那么开始时，到底该用哪个对象更为合适呢？这就需要明确流的操作规律。


#### **流的操作规律：**


#### **1，明确源和目的。**


        数据源：就是需要读取，可以使用两个体系：InputStream、Reader；


        数据汇：就是需要写入，可以使用两个体系：OutputStream、Writer；


#### **2，操作的数据是否是纯文本数据？**


        如果是：数据源：Reader


                     数据汇：Writer 


        如果不是：数据源：InputStream


                       数据汇：OutputStream


#### **3，虽然确定了一个体系，但是该体系中有太多的对象，到底用哪个呢？**


        明确操作的数据设备。


                数据源对应的设备：硬盘(File)，内存(数组)，键盘(System.in)


                数据汇对应的设备：硬盘(File)，内存(数组)，控制台(System.out)。


#### **4，需要在基本操作上附加其他功能吗？比如缓冲。**


        如果需要就进行装饰。


### **IO流之字节流**


字节流的处理单位是字节，通常用来处理二进制文件，例如音乐、图片文件


字节流类都继承自InputStream、OutputStream这两个抽象类


处理字节数据的流对象。设备上的数据无论是图片或者dvd，文字，它们都以二进制存储的。二进制的最终都是以一个8位为数据单元进行体现，所以计算机中的最小数据单元就是字节。意味着，字节流可以处理设备上的所有数据，所以字节流一样可以处理字符数据。


#### **InputStream中重用的方法：**


**InputStream****：是表示字节输入流的所有类的超类。**


* **|--- FileInputStream****：**从文件系统中的某个文件中获得输入字节。哪些文件可用取决于主机环境。FileInputStream 用于读取诸如图像数据之类的原始字节流。要读取字符流，请考虑使用 FileReader。
* **|---** **FilterInputStream****：**包含其他一些输入流，它将这些流用作其基本数据源，它可以直接传输数据或提供一些额外的功能。
* **|--- BufferedInputStream****：**该类实现缓冲的输入流。
* **|--- Stream****：**
* **|---** **ObjectInputStream****：**
* **|---** **PipedInputStream****：**
* ```
public class inputStreamYH {
	public static void main(String[] args) {
		FileInputStream inputStream = null;
		try {
			inputStream = new FileInputStream("E:/Beyond - 情人.mp3");
//方式1
//			int validBufferLength = 0;
//			while ((validBufferLength = inputStream.read()) != -1) {
//				System.out.println((char)validBufferLength);
//			}
//方式2			
byte[] bufferArray = new byte[1024];
			int validBufferLength = 0;
			while ((validBufferLength = inputStream.read(bufferArray)) != -1) {
				System.out.println(new String(bufferArray, 0, validBufferLength));
			//设置局部变量缓冲数组bufferArray，read方法会将字节保存到该数组中并
			//返回实际写入bufferArray数组的元素个数，这样减少了循环次数，提高了复制效率
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(inputStream != null){
				try {
					inputStream.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			System.out.println("结束");
		}
	}
}

read() 可以从流中读取单个字节的数据，其中read有多个重载的方法;

close()关闭此输入流并释放与该流关联的所有系统资源

OutputStream中重用的方法：

OutputStream**：此抽象类是表示输出字节流的所有类的超类。**

|— FileOutputStream**：**文件输出流是用于将数据写入 File 或 FileDescriptor 的输出流。
|— FilterOutputStream**：**此类是过滤输出流的所有类的超类。
|— BufferedOutputStream**：**该类实现缓冲的输出流。
|— PrintStream**：**
|— DataOutputStream**：**
|— ObjectOutputStream**：**
|— PipedOutputStream**：**

import java.io.*;
public class fileOutputStream {
	public static void main(String[] args) {
		FileOutputStream outputStream = null;
		try {
			outputStream = new FileOutputStream("for.txt", true);
			byte[] bufferArray = {12,2,3,22,21,82};
			outputStream.write(bufferArray);
outputStream.write("hello".getBytes());//化为2进制
			outputStream.write(bufferArray, 1, 5);
			outputStream.flush();//刷新outputStream缓冲区
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(outputStream != null){
				try {
					outputStream.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			System.out.println("结束");
		}
	}
}

write() 可以向流中写入单个字节的数据，其中write有多个重载的方法;

close()关闭此输出流并释放与此流有关的所有系统资源

这两个抽象类

import java.io.*;
public class inputStream {
	//TODO 字节流
	public static void main(String[] args) {
		FileInputStream inputStream = null;
		FileOutputStream outputStream = null;
		try {
			inputStream = new FileInputStream("E:/戴荃 - 悟空.mp3");//2.	FileOutputStream(String name)
			File outFile = new File("f:\\存在01.mp3"); 
			outFile.createNewFile();
			outputStream = new FileOutputStream(outFile, true);//FileOutputStream(File file) 里面加个true的话一直叠加。
//			int byteData;
//			while ((byteData = inputStream.read()) != -1) {
//逐个读取输入流中的数据
//				outputStream.write(byteData);//向输出流中逐个存入字节
//			}
			byte[] bufferArray = new byte[1024];
			int validBufferLength = 0;
			while ((validBufferLength = inputStream.read(bufferArray)) != -1) {
				//设置局部变量缓冲数组bufferArray，read方法会将字节保存到该数组中并
				//返回实际写入bufferArray数组的元素个数，这样减少了循环次数，提高了复制效率
				outputStream.write(bufferArray, 0, validBufferLength);
			}
			outputStream.flush();//刷新outputStream缓冲区
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(inputStream != null){
				try {
					inputStream.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			
			if(outputStream != null){
				try {
					outputStream.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			System.out.println("结束");
		}
	}
}

IO流之字符流

字符流操作的单位是字符

字符流类都继承自Reader、Writer这两个抽象类，那么为什么要有字符流呢？Reader Writer

因为字符每个国家都不一样，所以涉及到了字符编码问题，那么GBK编码的中文用unicode编码解析是有问题的，所以需要获取中文字节数据的同时+ 指定的编码表才可以解析正确数据。为了方便于文字的解析，所以将字节流和编码表封装成对象，这个对象就是字符流。只要操作字符数据，优先考虑使用字符流体系。

Reader中最重要的方法：

Reader：用于读取字符流的抽象类。子类必须实现的方法只有 read(char[], int, int) 和 close()。
|—BufferedReader**：**从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。
|—LineNumberReader**：**跟踪行号的缓冲字符输入流。此类定义了方法 setLineNumber(int) 和 getLineNumber()，它们可分别用于设置和获取当前行号。
|—InputStreamReader**：**是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。
|—FileReader**：**用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以先在 FileInputStream 上构造一个 InputStreamReader。
|—CharArrayReader**：**
|—StringReader**：**
read() 可以从输入流中读取单个字符的数据，其中read方法有多个重载的方法;
close()关闭此输入流并释放与该流关联的所有系统资源

Writer中最重要的方法：

write()可以向输出流中写入单个字符的数据，其中write方法有多个重载的方法
close()关闭此输出流并释放与此流有关的所有系统资源
Writer**：写入字符流的抽象类。子类必须实现的方法仅有** write(char[], int, int)**、flush() 和 **close()。
|—BufferedWriter**：**将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
|—OutputStreamWriter**：**是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。
|—FileWriter**：**用来写入字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的。要自己指定这些值，可以先在 FileOutputStream 上构造一个 OutputStreamWriter。
|—PrintWriter**：**
|—CharArrayWriter**：**
|—StringWriter**：**


        import java.io.FileNotFoundException;
        import java.io.FileReader;
        import java.io.FileWriter;
        import java.io.IOException;
        public class ReaderZiFuYH {
            public static void main(String[] args) {
                FileReader reader = null;
                FileWriter write = null;
                try {
                    reader=new FileReader("E:/新建文本文档.txt");
                    write=new FileWriter("F:/新建文本文档.txt");
//                  int transition;
//                  while((transition=reader.read())!=-1){
//                      write.write(transition);
//                  }
                    char []character=new char[1024];
                    int transition=0;
                    while((transition=reader.read(character))!=-1){
                        write.write(character,0,transition);
                    }
                    write.flush();//刷新缓冲区
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }finally{
                    try {
                        if(reader!=null){
                            reader.close();
                        }
                        if(write!=null){
                            write.close();
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    System.out.println("jieshu");
                }
            }
        }

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注：Python）

构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！**

[外链图片转存中…(img-krK5c7VH-1713593816110)]

[外链图片转存中…(img-m6pe9QEH-1713593816111)]

[外链图片转存中…(img-bEjG5p7n-1713593816112)]

[外链图片转存中…(img-J2hYtmc6-1713593816113)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！

如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注：Python）

2401_83641098

关注

11
点赞
踩
25

收藏

觉得还不错? 一键收藏
0
评论
java文件File和IO流（一）-- File文件，IO流，缓冲流，字节流，字符流

因为字符每个国家都不一样，所以涉及到了字符编码问题，那么GBK编码的中文用unicode编码解析是有问题的，所以需要获取中文字节数据的同时+ 指定的编码表才可以解析正确数据。// 测试此抽象路径名指定的文件是否是一个隐藏文件。* 2：对象产生后，会在堆内存中有一个实体，同时也调用了系统底层资源，在指定的位置创建了一个存储数据的文件。fw.close();// 关闭流，其实关闭的就是java调用的系统底层资源。// 如果调用list方法的File 对象中封装的是一个文件，那么list方法返回数组为null。
复制链接

扫一扫