文件和流

最新推荐文章于 2023-09-04 17:51:32 发布

Java the world

最新推荐文章于 2023-09-04 17:51:32 发布

阅读量160

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/u013140841/article/details/103360677

版权

Java 专栏收录该内容

34 篇文章 0 订阅

订阅专栏

Java程序可访问的最主要的外部资源之一就是文件。
在Java中用File类来进行文件及目录的操作，常见操作：
文件操作
boolean canWrite();
boolean canRead();
boolean isFile();判断是否是文件
boolean isDirectory();判断是否是目录
long lastModifield();
long length();
boolean delete();

目录操作

boolean mkdir (); 创建一个目录
String list(); 列出目录列表注意类型

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

public class FileNote {

	public static void main(String[] args) {
		File f = new File("D:\\AD\\");//使用 \\ 或/
		
		
		//得到目录  路径名
		String [] fl = f.list();
		for(String s:fl) {
			System.out.println(s);//得到文件名
			System.out.println("D:\\AD\\"+s);//得到文件路径
			
		}
		
		
		//  创建文件
		System.out.println(f.exists());//是否存在
		
		try {
			f.createNewFile();//检查异常，必须要解决的异常
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(f.exists());//恒为true
		//f.delete();
		System.out.println(f.exists());
	}



	File nd = new File("D:\\AD\\123-\\");//使用 \\ 或/
		nd.mkdir();//创建文件夹



}

目录的路径和文件的路径的区别
文件路径由文件名结尾 D:\AD\class1.txt
目录路径由\结尾 D:\AD\

检查型异常（Checked Exception）

个人理解：所谓检查（Checked）是指编译器要检查这类异常，检查的目的一方面是因为该类异常的发生难以避免，另一方面就是让开发者去解决掉这类异常，所以称为必须处理（try …catch）的异常。如果不处理这类异常，集成开发环境中的编译器一般会给出错误提示。

例如：一个读取文件的方法代码逻辑没有错误，但程序运行时可能会因为文件找不到而抛出FileNotFoundException，如果不处理这些异常，程序将来肯定会出错。所以编译器会提示你要去捕获并处理这种可能发生的异常，不处理就不能通过编译。

非检查型异常（Unchecked Exception）

个人理解：所谓非检查（Unchecked）是指编译器不会检查这类异常，不检查的则开发者在代码的编辑编译阶段就不是必须处理，这类异常一般可以避免，因此无需处理（try …catch）。如果不处理这类异常，集成开发环境中的编译器也不会给出错误提示。

例如：你的程序逻辑本身有问题，比如数组越界、访问null对象，这种错误你自己是可以避免的。编译器不会强制你检查这种异常。

文件操作–随机存储文件（了解即可，C语言中用到）

RandomAccessFile类封装了字节流操作，方便实现随机读取文件的某一个部分
此类只能操纵文件，通过文件的路径或File对象构造
可以对文件进行读写操作，实例化时指明读写模式
常用的方法有：
long getFilePointer()
void seek(long pos)
long length();
int read()
boolean readBoolean()
char readChar()
void writeBoolean()
void writeByte(int v)

流的作用

输入端：产生数据
输出端：接收数据
Java程序与外部交互的主要手段就是流！！也是唯一手段

流：代表任何有能力产出数据的数据源对象或者有能力接收数据的接收端对象

在Java中使用为什么输入输出要用“流”这种方式呢？
因为程序输入输出的基本单位是字节，输入就是获取一串字节，输出就是发送一串字节。但是很多情况下，程序不可能接收所有的字节之后再进行处理，而是接收一点处理一点。

全部的输出输入都是通过 byte数组进行

根据流的方向分类

输入流：可以从流中读取信息，但不能写它（读）
输出流：可以向流中写入信息，但不能读它（写）

根据操纵对象的类型分类

字符流：读取单位为字符，因为数据编码的不同，而有了对字符进行高效操作的流对象。本质其实就是基于字节流读取时，去查了指定的码表。读取的字节数由字符编码确定
字节流：读取单位为字节，一般用于文件传输（程序输入输出的基本单位是字节，读取的基本单位也是字节）

只要处理纯文本数据，优先考虑字符流，其他的形式采用字节流。

四种类的架构

全部都是上层接口（不能实例化对象）

字节输入流：InputStream类
字节输出流：OutputStream类
字符输入流：Reader类
字符输出流：Writer类

字节
在这里插入图片描述


System.out.println(s);//out是一个对象
public final static PrintStream out = null;//PrintStream屏幕输出流

在这里插入图片描述
以ByteArrayInputStream为例，是把ByteArray转化为字节输入流

java中‘’InputStream的常用方法

1.** int read()**;从输入流中读取数据的下一个字节。返回的是读取的一个字节的整数
2. int read(byte c[ ]);从输入流中读取一定数量的字节，并将其存储在缓冲区数组 c 中。返回值表示从字节流中读取了多少个字节，如果字节流结束，返回-1
3. int read(byte c[ ], int off, int len)：将输入流中最多 len 个数据字节读入 byte 数组。off表示从第几个开始存
4. void mark(int readlimit);在此输入流中标记当前的位置。
5. void reset();将此流重新定位到最后一次对此输入流调用 mark 方法时的位置。
6. void close();关闭此输入流并释放与该流关联的所有系统资源。

Java中OutputStream的常用方法：

void write(int b);将指定的字节写入此输出流
void write(byte b[ ]);将 b.length 个字节从指定的 byte 数组写入此输出流
void write(byte b[ ], int off, int len);将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流
void flush();刷新此输出流并强制写出所有缓冲的输出字节
boolean markSupported();测试此输入流是否支持mark 和 reset 方法
void close();关闭此输出流并释放与此流有关的所有系统资源

纯文本文件：txt 源代码文件
word不是纯文本文件
Unicode默认不支持中文

缓冲区的大小一般是512 或 1024
读写文件：

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class StreamWrite {

	public static void main(String[] args) {

		String a = "D:\\AD1\\class1.txt";
		String c = "D:\\AD1\\txt45.txt";
		File f = new File(a);
		File df = new File(c);

		try {
			FileInputStream fis = new FileInputStream(f);// 可能出现检查性异常
			FileOutputStream fos = new FileOutputStream(df);// 可能出现检查性异常

			//bug代码，可能会出现-1的ASCII码
//			int r = 0;// 返回的int代表读的字节所对应的整数 ASCII码
//
//			while (r != -1) {
//				r = fis.read();//以字节为单位，效率较低，一次只读一个字节
//				fos.write(r);//应该先判断r的值是不是 -1，然后在写入
//				
//				System.out.println(r);
//			}

			
//			byte[] b = new byte[100];//缓冲区  每次尽量读100个字节（以100个字节为单位）
//			int len = fis.read(b);//返回值代表实际读了多少个字节,小于等于100，如果结束返回-1
//			//fos.write(b);//写入的时候回写入b中的100个字节，如果实际上读了75个字节，则剩下的的25个都是0
//			fos.write(b,0,len);
			
		//bug代码，可能会出现-1的ASCII码   
//			byte[] b = new byte[100];
//			int len = 0;
//			while(len!=-1) {
//				len = fis.read(b);
//				fos.write(b,0,len);//应该在写入之前先判断读取之后len的值
//				if(len<b.length) {
//					break;
//				}
//			}
//			
			
			
			
			
			byte[] b = new byte[100];
			int len = 0;
			System.out.println("File Exception!3");
			while((len = fis.read(b)) != -1) {
				//如果没有内容
				System.out.println("File Exception!4");
				fos.write(b,0,len);
				if(len != 100) {
					break;
				}
			}
			
			fis.close();
			fos.close();
		} catch (IOException e) {
			System.out.println("File IOException!");
		}
	}

}

BufferedReader和BufferedWriter：可以直接读一行字符或写一行字符
read()write() 的开销较高

DataInputStream和DataOutputStream:数据输入/输出流。
允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型，两个类中提供了读取和写入基本数据类型的特定方法。
比如：double readDouble()、void writeDouble()、int readInt()、void writeInt() 等等。

用来实现将字节流转换成字符流
InputStreamReader 将字节输入流转换成字符输入流
OutputStreamReader将字节输出流转换成字符输出流

在网络编程中，通常需要使用InputStreamReader和OutputStreamWriter将字节流转成字符流