java学习-文件管理与IO流

最新推荐文章于 2023-06-17 22:17:54 发布

纪水一

最新推荐文章于 2023-06-17 22:17:54 发布

阅读量196

点赞数 1

分类专栏： java学习文章标签： java

本文链接：https://blog.csdn.net/weixin_49349476/article/details/130248228

版权

java学习专栏收录该内容

7 篇文章 0 订阅

订阅专栏

（一）文件管理：File类

Java语言使用File类对文件和目录进行操作，File类中常用的方法

1、构造方法

File(String path)：如果path是实际存在的路径，则该File对象表示的是目录；如果path是文件名，则该File对象表示的是文件

File(String path, String name)：path是路径名，name是文件名

File(File dir, String name)：dir是路径对象，name是文件名

注意：File只是实例化一个文件对象，不是创造一个文件，如果该文件不存在，也不会报错

public static void main(String[] args) {

		//1、File(String path)
		File f1= new File("E:\\test\\1.txt");//绝对路径
		File f2= new File("E:/test/2.txt");
		File f3=new File("3.txt"); //相对路径

		//2、File(String path, String name)
		String path1="E:\\test";
		String name1="4.txt";
		File f4=new File(path1,name1);

		//3、File(File dir, String name)
		File f5=new File("E:\\test");
		String name2="5.txt";
		File f6=new File(f5,name2);
	}

2、获取文件

getName( )：获得文件的名称，不包括路径

getPath( )：获得文件的路径

getAbsolutePath( )：获得文件的绝对路径

getParent( )：获得文件的上一级目录名

public static void main(String[] args) {
		
		File f1= new File("E:\\test\\1.txt");
		
		System.out.println("获取文件的名称："+f1.getName());
		System.out.println("获取文件的路径："+f1.getPath());
		System.out.println("获取文件的绝对路径："+f1.getAbsolutePath());
		System.out.println("获取文件的上一级目录名："+f1.getParent());
		
		
	}

3、文件测试

exists( )：测试当前File对象所表示的文件是否存在

canWrite( )：测试当前文件是否可写

canRead( )：测试当前文件是否可读

isFile( )：测试当前文件是否是文件

isDirectory( )：测试当前文件是否是目录

public static void main(String[] args) {
		
		File f1= new File("E:\\test\\1.txt");//文件存在
		File f2= new File("E:\\test\\2.txt");//文件不存在
		File f3=new File("E:\\test");
		
		System.out.println("测试文件1.txt是否存在："+f1.exists());//true
		System.out.println("测试文件2.txt是否存在："+f2.exists());//false 
		
		System.out.println("测试文件1.txt是否可写："+f1.canWrite());//true
		System.out.println("测试文件2.txt是否可写："+f2.canWrite());//false 因为该文件不存在，所以返回false
		
		System.out.println("测试文件1.txt是否可读："+f1.canRead());//true
		System.out.println("测试文件2.txt是否可读："+f2.canRead());//false 因为该文件不存在，所以返回false
		
		System.out.println("测试f1对象是否文件："+f1.isFile());//true
		System.out.println("测试f3对象是否文件："+f3.isFile());//false 
		
		System.out.println("测试是f1对象是否目录："+f1.isDirectory());//false
		System.out.println("测试是f3对象是否目录："+f3.isDirectory());//true
		
	}

4、文件操作

lastModified( )：获得文件最近一次修改的时间

length( )：获得文件的长度，以字节为单位

delete( )：删除当前文件。成功返回 true，否则返回false

renameTo(File dest)：将重新命名当前File对象所表示的文件。成功返回 true，否则返回false

public static void main(String[] args) {
		
		File f1= new File("E:\\test\\1.txt");//文件存在
		File f2= new File("E:\\test\\2.txt");//
		File f3=new File("E:\\test\\new1.txt");
		
		System.out.println("获得文件最近一次修改时间："+f1.lastModified());
		System.out.println("获取文件长度："+f1.length());
		
		System.out.println("删除文件："+f2.delete());
		System.out.println("重名为文件1.txt为new1.txt："+f1.renameTo(f3));//false
		
	}

5、目录操作

mkdir( )：创建当前File对象指定的目录，一次只能创建一级目录

mkdirs():创建当前File对象指定的目录，一次能创建多级目录

list()：返回当前目录下的文件和目录，返回值是字符串数组。

listFiles()：返回当前目录下的文件和目录，返回值是File数组

public static void main(String[] args) {
		
		File f1= new File("E:\\test");
		File f2= new File("E:\\test\\one");
		File f3= new File("E:\\test\\two\\two2_1");//
		System.out.println("在test目录下创建one目录："+f2.mkdir());
		System.out.println("在test目录下创建one目录："+f3.mkdirs());
		System.out.println("-----list()方法遍历文件与目录------");
		String [] name=f1.list();
		for(String na:name) {   //for-each方法遍历数组
			System.out.println(na);
		}
		System.out.println("-----listFiles()方法遍历文件与目录------");
		File [] file=f1.listFiles();
		for(File f:file) {
			System.out.println(f);
		}

	}

（二）IO流

数据输入的数据源有多种形式，如文件、网络和键盘等，键盘是默认的标准输入设备。而数据输出的目的地也有多种形式，如文件、网络和控制台，控制台是默认的标准输出设备。

I/O流根据数据的流向分为输入流和输出流，所有的输入形式都抽象为输入流，即把数据从其他设备上读取到内存中的流；所有的输出形式都抽象为输出流所有的输出形式都抽象为输出流，即把数据从内存中写到其他设备上的流

以字节为单位的流称为字节流，以字符为单位的流称为字符流。Java SE提供4个顶级抽象类，两个字节流抽象类：InputStream和OutputStream；两个字符流抽象类：Reader和Writer。如下

输入流

输出流

字节流

字节输入流

InputStream

字节输出流

OutputStream

字符流

字符输入流

Reader

字符输出流

Writer

1. 字节抽象类：InputStream和OutputStream

a、InputStream抽象类

字节输入流根类是InputStream，这个类有很多的子类

它提供的方法

方法	作用
read()	读取一个字节，返回0到255范围内的int字节值。如果已经到达流末尾，而且没有可用的字节，则返回值-1
read(byte b[] )	读取多个字节，数据放到字节数组b中，返回值为实际读取的字节的数量，如果已经到达流末尾，而且没有可用的字节，则返回值-1
read(byte b[ ], int off, int len)	最多读取len个字节，数据放到以下标off开始字节数组b中，将读取的第一个字节存储在元素b[off]中，下一个存储在b[off+1]中，依次类推。返回值为实际读取的字节的数量，如果已经到达流末尾，而且没有可用的字节，则返回值-1
close()	流操作完毕后必须关闭

b、OutputStream抽象类

OutputStream抽象类的子类和方法如下

方法	作用
write(int b)	将b写入到输出流，b是int类型占有32位，写入过程是写入b 的8个低位，b的24个高位将被忽略
write(byte b[ ])	将b.length个字节从指定字节数组b写入到输出流
write(byte b[ ], int off, int len)	把字节数组b中从下标off开始，长度为len的字节写入到输出流。
flush()	刷空输出流，并输出所有被缓存的字节。由于某些流支持缓存功能，该方法将把缓存中所有内容强制输出到流中
close( )	流操作完毕后必须关闭

2、输入抽象类与输出抽象类

Reader抽象类

方法	作用
read()	读取一个字符，返回值范围在0~65535(0x00~0xffff)之间。如果因为已经到达流末尾，则返回值-1
read(char[] cbuf)	将字符读入到数组cbuf中，返回值为实际读取的字符的数量，如果因为已经到达流末尾，则返回值-1
read(char[] cbuf, int off, int len)	最多读取len个字符，数据放到以下标off开始字符数组cbuf中，将读取的第一个字符存储在元素cbuf[off]中，下一个存储在cbuf[off+1]中，依次类推。返回值为实际读取的字符的数量，如果因为已经到达流末尾，则返回值-1
close()	流操作完毕后必须关闭

Writer抽象类

方法	作用
write(int c)	将整数值为c的字符写入到输出流，c是int类型占有32位，写入过程是写入c的16个低位，c的16个高位将被忽略
write(char[] cbuf)	将字符数组cbuf写入到输出流
write(char[] cbuf, int off, int len)	把字符数组cbuf中从下标off开始，长度为len的字符写入到输出流
write(String str)	将字符串str中的字符写入输出流
write(String str,int off,int len)	将字符串str 中从索引off开始处的len个字符写入输出流
flush()	刷空输出流，并输出所有被缓存的字符。由于某些流支持缓存功能，该方法将把缓存中所有内容强制输出到流中
close( )	流操作完毕后必须关闭

IO流的分类

a字节流

FileInputStream 文件字节输入流，构造方法如下：

方法	作用
FileInputStream(String name)	创建FileInputStream对象，name是文件名。
FileInputStream(File file)	通过File对象创建FileInputStream对象。

FileInputStream类是继承InputStream类，可以使用父类的方法：read（）、read（byte[] b）

read（）:读取一个字符，返回值范围在0~65535(0x00~0xffff)之间。如果因为已经到达流末尾，则返回值-1

public static void main(String[] args) throws IOException {
		FileInputStream fis=new FileInputStream("a.txt");//文件字节输入流，实例化对象
		int len=fis.read();  // 读取一个字节的数据,每一次只读取一个字节
		while(len!=-1) {
			System.out.println((char)len);  //转换为字符类型
			len=fis.read();  //再读取下一个字节
		}
		fis.close();
		
	}

read（byte[] b）:将字符读入到数组cbuf中，返回值为实际读取的字符的数量，如果因为已经到达流末尾，则返回值-1

public static void main(String[] args) throws IOException {
		FileInputStream fis=new FileInputStream("a.txt");//文件字节输入流，实例化对象	
		byte[] arr=new byte[2];
		int len=0;
		while((len=fis.read(arr))!=-1) {  //read(byte[])返回定义的字节数组长度
//			System.out.println(new String(arr));//,会多读字节
			System.out.println(new String(arr,0,len));//正确读取内容
		}
		fis.close();
		
	}
}

FileOutputStream 文件输出流，构造方法

方法	作用
FileOutputStream(String name)	通过指定name文件名创建FileOutputStream对象。
FileOutputStream(String name, boolean append)	通过指定name文件名创建FileOutputStream对象，append参数如果为 true，则将字节写入文件末尾处，而不是写入文件开始处
FileOutputStream(File file)	通过File对象创建FileOutputStream对象
FileOutputStream(File file, boolean append)	通过File对象创建FileOutputStream对象，append参数如果为 true，则将字节写入文件末尾处，而不是写入文件开始处。

public static void main(String[] args) throws IOException{
//      FileOutputStream fos=new FileOutputStream("a.txt");
		FileOutputStream fos=new FileOutputStream(new File("a.txt"));
		//1 warite(int):文件中写入内容,一次性只能写入一个字节的内容
		fos.write(65);//A  
		fos.write(66);//B
		//2 输入换行，
		fos.write("\r".getBytes());
		//3、warite(byte[]) :字节数组，可以用String的getBytes()方法把字符转成byte数组，直接输入
		byte b[]="hello,world!".getBytes();
		fos.write(b);
		fos.write("\r".getBytes());
		//4、warite(byte[],int m,int n):指长度输入，从索引m开始，输入长度为n的字节
		byte b1[]="123456789".getBytes();
		fos.write(b1, 1, 5);

		fos.close();
	}

b、字符流

FileReader文件字符输入流，构造方法

方法	作用
FileReader(String fileName)	创建FileReader对象，fileName是文件名
FileReader(File file)	通过File对象创建FileReader对象

public static void main(String[] args) throws IOException{
		FileReader fr=new FileReader("a.txt");
		int len;
		char c[]=new char[2];
		while((len=fr.read(c))!=-1) {
			System.out.println(new String(c,0,len));
		}
	}

字符输入流，与字节输入流的操作相识

FileWriter 文件字符输出流,构造方法

方法	作用
FileWriter(String fileName)	通过指定fileName文件名创建FileWriter对象
FileWriter(String fileName, boolean append)	通过指定fileName文件名创建FileWriter对象，append参数如果为 true，则将字符写入文件末尾处，而不是写入文件开始处
FileWriter(File file)	通过File对象创建FileWriter对象
FileWriter(File file, boolean append)	通过File对象创建FileWriter对象，append参数如果为 true，则将字符写入文件末尾处，而不是写入文件开始处

public static void main(String[] args) throws IOException{
		
//		FileWriter fw=new FileWriter(new File("a.txt"));
		FileWriter fw=new FileWriter("a.txt");  //创建到本地目录
		fw.write(66);
		fw.write(67);
		fw.write("\r");//换行
		fw.write("hello,java");
		fw.write("\r");
		fw.flush();//把write方法写入的内容，写到文件中，但是还可以继续操作
		fw.write("123456789", 1, 6);
		fw.close();//先刷新缓冲区中的数据，再把流给关闭了
	}

c、缓冲流

BufferedInputStream 字节缓冲输入类，构造方法：

方法	作用
BufferedInputStream(InputStream in)	通过一个底层输入流in对象创建缓冲流对象，缓冲区大小是默认的，默认值8192
BufferedInputStream(InputStream in, int size)	通过一个底层输入流in对象创建缓冲流对象，size指定的缓冲区大小，缓冲区大小应该是2的n次幂，这样可提供缓冲区的利用率

BufferedOutputStream 字节缓冲输出类，构造方法

方法	作用
BufferedOutputStream(OutputStream out)	通过一个底层输出流out 对象创建缓冲流对象，缓冲区大小是默认的，默认值8192
BufferedOutputStream(OutputStream out, int size)	通过一个底层输出流out对象创建缓冲流对象，size指定的缓冲区大小，缓冲区大小应该是2的n次幂

利用字节缓冲流复制文件：

public static void main(String[] args) throws IOException{
		BufferedInputStream bis =new BufferedInputStream(new FileInputStream("D:\\软件\\java\\软件安装包\\jdk-8u202-windows-x64.exe"));
		BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("jdk.exe"));
		byte []b=new byte[1024];
		int len;
		while ((len=bis.read(b))!=-1) {
			bos.write(b, 0, len);
		}
	}

BufferedReader 字符缓冲输入类，构造方法

方法	作用
BufferedReader(Reader in)	通过一个底层输入流in对象创建缓冲流对象，缓冲区大小是默认的，默认值8192
BufferedWriter(Writerout, int size)	通过一个底层输出流out对象创建缓冲流对象，size指定的缓冲区大小，缓冲区大小应该是2的n次幂
readLine() （特有方法）	读取一个文本行，如果因为已经到达流末尾，则返回值null

BufferedWriter 字符输出类，构造方法

方法	作用
BufferedWriter(Writerout)	通过一个底层输出流out 对象创建缓冲流对象，缓冲区大小是默认的，默认值8192
BufferedWriter(Writerout, int size)	通过一个底层输出流out对象创建缓冲流对象，size指定的缓冲区大小，缓冲区大小应该是2的n次幂
newLine()（特有方法）	写入一个换行符

用字节缓冲流复制文件如下

public static void main(String[] args) throws IOException{
		BufferedReader bis =new BufferedReader(new FileReader("D:\\软件\\java\\软件安装包\\jdk-8u202-windows-x64.exe"));
		BufferedWriter bos=new BufferedWriter(new FileWriter("jdk.exe"));
		char []b=new char[1024];
		int len;
		while ((len=bis.read(b))!=-1) {
			bos.write(b, 0, len);
		}
	}

d、转换流

InputStreamReader：字符流转化为字节流，构造方法

方法	作用
InputStreamReader(InputStream in)	将字节流in转换为字符流对象，字符流使用默认字符集
InputStreamReader(InputStream in, String charsetName)	将字节流in转换为字符流对象，charsetName指定字符流的字符集

eclipse默认使用GBK,

public static void main(String[] args) throws IOException {
		InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"));//默认GBK
//		InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"),"UTF-8");
		int len= 0;
		while((len=isr.read())!=-1) {
			System.out.print((char)len);
		}
	}

OutputStreamWriter：字节流转化字符流 构造方法

方法	作用
OutputStreamWriter(OutputStream out)	将字节流out转换为字符流对象，字符流使用默认字符
OutputStreamWriter(OutputStream out,String charsetName)	将字节流out转换为字符流对象，charsetName指定字符流的字符集

public static void main(String[] args) throws IOException {
//		OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("a.txt"));//默认GBk
		OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("a.txt"),"utf-8");
		osw.write("hello,世界");
		osw.flush();
	}

使用转化流对文件进行输入和输出：

public static void main(String[] args) throws IOException {
//		a.txt:使用记事本创建，使用UTF-8格式
		InputStreamReader isr=new InputStreamReader(new FileInputStream("C:\\Users\\24964\\Desktop\\a.txt"),"utf-8");
		OutputStreamWriter  osw=new OutputStreamWriter(new FileOutputStream("b.txt"));
		int len;
		char[]b =new char[2];
		while((len=isr.read(b))!=-1) {
			osw.write(b, 0, len);
		}
		isr.close();
		osw.close();
	}