第十章 IO流1

最新推荐文章于 2024-04-12 22:54:04 发布

X.. R H

最新推荐文章于 2024-04-12 22:54:04 发布

阅读量110

点赞数

分类专栏： JavaSE

本文链接：https://blog.csdn.net/weixin_47160763/article/details/107409973

版权

JavaSE 专栏收录该内容

22 篇文章 1 订阅

订阅专栏

IO原理及流的分类

文件流（操作的是文件）
FileInputStream / FileOutputStream / FileReader / FileWriter
缓冲流（操作的是内存）
BufferedInputStream / BufferedOutputStream /
BufferedReader / BufferedWriter
转换流
InputStreamReader / OutputStreamWriter
标准输入/输出流
打印流（了解）（System.out.println）
PrintStream / PrintWriter
数据流（了解）
DataInputStream / DataOutputStream
对象流 ----涉及序列化、反序列化(把一个对象转化成一个数据流)
ObjectInputStream / ObjectOutputStream
随机存取文件流（例如一个TXT文件，可以直接读取第50行的数据，也可以在80行插入数据）
RandomAccessFile

流：通过程序把一个图片放到一个文件夹中，把图片转换成一个数据集（例如二进制），把这些数据一点一点传到文件夹中，这个整体的数据集是一个数据流。

File 类

import java.io.File;

public class Test {
	public static void main(String[] args) {
		File f =new File("D:\\test\\abc\\ss.txt");  //对象f就是ss文件
	//	File f1 =new File("D:\\\\test","abc\\\\ss.txt");//了解 
		// 注意，\在文件路径中分隔符，在java中一个\是转义符，所以写成\\或者/，
	}
}

File 能新建、删除、重命名文件和目录，但 File 不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入/输出流。

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

public class Test {
	public static void main(String[] args) {
		File f =new File("D:\\test\\abc\\ss.txt");  //对象f就是ss文件
		File f2 =new File("D:\\test\\abc");  //目录
	//	File f1 =new File("D:\\\\test","abc\\\\ss.txt");//了解 
		// 注意，\在文件路径中分隔符，在java中一个\是转义符，所以写成\\或者/，
		
		System.out.println(f.getName());//获取文件名
		System.out.println(f2.getName());//获取目录（输出是abc？）
		
		File f3 =new File("/helloworld/src/day12/Test.java");//使用相对路径创建对象
		System.out.println(f.getPath());//获取文件f的路径
		System.out.println(f3.getAbsolutePath()); //获取绝对路径
		System.out.println(f3.getPath());
		
		System.out.println(f.getParent()) ; //获取父亲路径
		
		f.renameTo(new File("D:\\test\\abc\\ssS.txt"));//重命名
		
		File f9 =new File("D:\\test\\abc\\ssS.txt");
		System.out.println(f9.exists());//判断文件夹是否存在
		System.out.println(f9.canWrite()); //判断当前文件是否可写
		System.out.println(f9.canRead());  //判断当前文件是否可读
		
		System.out.println(f9.isFile());//判断当前的file对象是不是文件
		System.out.println(f9.isDirectory());//判断当前的file对象是不是文件夹或者目录
		
		System.out.println(f9.lastModified()); //获取文件最后的修改时间，返回的是一个毫秒数
		System.out.println(f9.length()); //返回文件的长度，单位是字节数
		
		File ff =new File("D:\\test\\abc\\sSss.txt");
		System.out.println(ff.exists());//判断是否存在
//		if(!ff.exists()) {
//			try {
//				ff.createNewFile();//光这句会有异常 捕获一下子
//			} catch (IOException e) {
//				
//				e.printStackTrace();
//			}
//		}
		ff.delete();
		
		File f91 =new File("D:\\test\\abc\\cc");//建一个目录也就是一个文件夹
		
		f91.mkdir();//单层的目录，如果创建多层就得一层一层的mkdir
		
		File f99 =new File("D:\\test\\abc\\a\\c\\v");
		
		f99.mkdirs(); //多层目录
		
		File f11 =new File("D:\\test");
		
		String[] fl =f11.list();//返回当前文件夹的子集的名称，包括目录和文件
		for (String s:fl) {
			System.out.println(s);
		}
		File[] fs=f11.listFiles();
		for(File fff:fs) {
			System.out.println(fff);//返回当前文件夹的子集的file对象，包括目录和文件
		}
		
	}
}

使用递归遍历文件夹

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

public class Test {
	public static void main(String[] args) {
	
		//遍历D盘下的test文件夹，把test文件加下的文件遍历出来，不论层级有多深
		//使用递归的方式实现
		
		File f =new File("D:\\test");
		Test t= new Test();
		t.test(f);
		
	}
	/**
	 * 递归遍历文件
	 * @param file
	 */
	public void test(File file) {
		if(file.isFile()) {
			System.out.println(file.getAbsolutePath()+" 是一个文件");
		}else {
			System.out.println(file.getAbsolutePath()+" 是一个文件夹");
			//如果是文件夹，这个文件夹可能有子文件夹和文件
			File[] fs =file.listFiles();
			if(fs !=null && fs.length>0) {
				for(File ff:fs) {
//					if(file.isFile()) {
//						System.out.println(file.getAbsolutePath()+" 是一个文件");
//					}else {
//						System.out.println(file.getAbsolutePath()+" 是一个文件夹");
//						//如果是文件夹，这个文件夹可能有子文件夹和文件
//						File[] fss =file.listFiles();
					
					test(ff);//递归
					
				}
			}
		}
	}
}

Java IO 原理

iO流用来处理设备之间的数据传输。

Java程序中，对于数据的输入/输出操作以”流(stream)” 的方式进行。

java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。

流的分类
按操作数据单位不同分为：字节流(8 bit)，字符流(16 bit)
按数据流的流向不同分为：输入流，输出流
按流的角色的不同分为：节点流，处理流
在这里插入图片描述

文件字节输入，输出流

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

public class Test2 {
	public static void main(String[] args) {
		Test2.testInput();
		//Test2.testOutput();
		
	}


	public static void testInput() {
		
			FileInputStream in;
			try {
				in = new FileInputStream("D:\\test\\abc\\s.txt");
				
				
				byte[] b =new byte[10]; //设置一个数组接受读取的文件的内容
				int len =0;  //读取数据的长度
				
				//in.read(b);  //in.read有一个返回值读到最后就是-1
				while((len=in.read(b)) != -1) {
					System.out.println(new String(b,0,len));//转换成字符串输出,
				                   //参数1是缓冲数据的数组，参数2是从哪个位置开始转换字符串，参数3总共转换几个字节
				}
							
				in.close();//流关闭
			} catch (Exception e) {
				
				e.printStackTrace();
			}
			
			
		
		}//有异常进行捕获

	
	public static void testOutput() {
		
		try {
			FileOutputStream out =new FileOutputStream("D:\\test\\abc\\s.txt");
			
			String str ="sssssssss啊啊啊";
			out.write(str.getBytes()); //把数据写到内存，write中的参数是比特，要把字符串转化成比特
			out.flush();               //把内存的数据写到硬盘
			out.close();
		} catch (Exception e) {
			
			e.printStackTrace();
		}
		
	
}

练习编写程序将一个文件复制到指定文件夹下

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

public class Test2 {
	public static void main(String[] args) {
		//Test2.testInput();
		//Test2.testOutput();
		Test2.copyFile("D:\\test\\abc\\s.txt", "D:\\test\\abc\\cc\\s.txt");
		
		
	}


	public static void testInput() {
		
			FileInputStream in;
			try {
				in = new FileInputStream("D:\\test\\abc\\s.txt");
				
				
				byte[] b =new byte[10]; //设置一个数组接受读取的文件的内容
				int len =0;  //读取数据的长度
				
				//in.read(b);  //in.read有一个返回值读到最后就是-1
				while((len=in.read(b)) != -1) {
					System.out.println(new String(b,0,len));//转换成字符串输出,
				                   //参数1是缓冲数据的数组，参数2是从哪个位置开始转换字符串，参数3总共转换几个字节
				}
							
				in.close();//流关闭
			} catch (Exception e) {
				
				e.printStackTrace();
			}
			
			
		
		}//有异常进行捕获

	
	public static void testOutput() {
		
		try {
			FileOutputStream out =new FileOutputStream("D:\\test\\abc\\s.txt");
			
			String str ="sssssssss啊啊啊";
			out.write(str.getBytes()); //把数据写到内存，write中的参数是比特，要把字符串转化成比特
			out.flush();               //把内存的数据写到硬盘
			out.close();
		} catch (Exception e) {
			
			e.printStackTrace();
		}
		
	
}
	
	
	
	
	
	public static void copyFile(String inpanth,String outpanth) {
		try {
			FileInputStream in =new FileInputStream(inpanth);//读取文件
			FileOutputStream out =new FileOutputStream(outpanth);//复制到哪
			
			byte[] b =new byte[100];
			int len =0;
			while((len =in.read(b)) != -1) {
				out.write(b, 0, len);//参数1写的缓冲数组，参数2从哪个位置写，参数3写的总长度
			}
			out.flush();//刷到硬盘
			out.close();
			in.close();
			
		} catch (Exception e) {
			
			e.printStackTrace();
		}
	}
		
}

注意文件字节流非常通用，可以操作字符的文档，还可以操作任何的其他类型的文件（图片压缩包等），因为字节流使用的是二进制

文件字符输入，输出流

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Test1 {
	public static void main(String[] args) {
		//Test1.testFileReader("D:\\test\\abc\\s.txt");
		//Test1.testFileWrite("hello", "D:\\test\\abc\\s.txt");
		Test1.copyFile("D:\\test\\abc\\s.txt", "D:\\test\\abc\\cc\\s.txt");
	}
	/**
	 * 文件字符输入流
	 * @param inpanth
	 */
	public static void testFileReader(String inpanth) {
		try {
			FileReader fr =new FileReader(inpanth); //创建文件字符输入流的对象
			char[] c =new char[10];  //创建临时存放数据的字符数组
			
			int len =0;
			while((len=fr.read(c))!=-1) {
				System.out.println(new String(c, 0, len));
			}
			fr.close();
			
			
		} catch (Exception e) {
		
			e.printStackTrace();
		}
		
	}
	/**
	 * 文件字符输出流
	 * @param text输出的内容
	 * @param outpath输出的文件
	 */
	public static void testFileWrite(String text,String outpath) {
		try {
			FileWriter fw =new FileWriter(outpath);
			fw.write(text);//写到内存上
			fw.flush();
			fw.close();
			
		} catch (Exception e) {
			
			e.printStackTrace();
		}
		
	}
	/**
	 * 字符流拷贝文件，只能拷贝文本
	 */
	public static void copyFile(String inpath,String outpath) {
		
		try {
			FileReader fr =new FileReader(inpath);
			FileWriter fw =new FileWriter(outpath);
			
			char c[] =new char[100];
			int len =0;
			while((len=fr.read(c))!=-1) {  //读取数据
				fw.write(c,0,len); //写入数据
				
			}
			fw.flush();
			fw.close();
			fr.close();
		} catch (Exception e) {
			
			e.printStackTrace();
		}
	}
}

注意
定义文件路径时，注意：可以用“/”或者“\”。
在写入一个文件时，如果目录下有同名文件将被覆盖。
在读取文件时，必须保证该文件已存在，否则出异常

X.. R H

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第十章 IO流1

IO原理及流的分类文件流（操作的是文件）FileInputStream / FileOutputStream / FileReader / FileWriter缓冲流（操作的是内存）BufferedInputStream / BufferedOutputStream /BufferedReader / BufferedWriter转换流InputStreamReader / OutputStreamWriter标准输入/输出流打印流（了解）（System.out.print
复制链接

扫一扫