java学习笔记12

io流

File提供的功能都是操作文件外部的能力,没有办法操作文件内部的内容

IO流:
流: 一连串流动的数据,以先入先出的方式进行流动,管道 以程序为中心
程序与 网络|文件|服务器|数组…

分类:
按照流向:

• 输入流
• 输出流

操作单元分:

• 字节流 :万能流:任何内容都可以转为字节,可以传输文本,图片…
• 字符流 :只能操作 纯文本数据

按照功能:

• 节点流 : 包裹源头,实现基本功能
• 功能流 : 对节点流增强性能,提高效率
• 分类之间是相辅相成的

字节输入流 :
InputStream 此抽象类是表示字节输入流的所有类的超类。
FileInputStream 从文件系统中的某个文件中获得输入字节。

字节输出流 : OutputStream

	public static void main(String[] args) throws IOException {
		//FileInputStream(String name)   字符串
		//FileInputStream(File file) 	File对象
		//FileInputStream is=new FileInputStream("D:/test.txt");
		InputStream is=new FileInputStream(new File("D:/test.txt"));//多态
		System.out.println(is);//打印结果
		
		//读入数据 一个字节一个字节读入
		/*int num=is.read();
		System.out.println((char)num);
		num=is.read();
		System.out.println((char)num);
		System.out.println((char)(is.read()));*/
		//使用循环,循环读入  可以简化代码,重复代码只写一次,但是还是一个字节一个字节读入
		/*int num=-1;
		while((num=is.read())!=-1){
			System.out.println((char)num);
		}*/
		//int read(byte[] b)   一个字节数组一个字节数组的读入
		//返回值: 返回读入到字节数组中数据的个数,没有读到返回-1
		byte[] car=new byte[1];
		//int len=is.read(car); 
		int len=-1;
		while((len=is.read(car))!=-1){
			System.out.println(new String(car,0,len));
		}
		
		/*
		 * 问:  一个字节数组不一定能把数据全部读完,可以使用循环重复读取
		 * 		编写过程中,出现的异常都抛出,要求不抛出来捕获解决
		 */
		
		
		//关闭
		is.close();
	}

字节输出流

流向: 输出流 操作单元:字节流 功能: 节点流

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

• public class FileOutputStream extends OutputStream文件输出流是用于将数据写入 File 的输出流。

  如果把文件中的数据先读入到程序中,在写出到另一个文件中,—>文件的拷贝

public static void main(String[] args) {
		//FileOutputStream(String name)
		//FileOutputStream(String name,boolean append)  true追加,false不追加(默认)内容拼接
		//FileOutputStream(File file,boolean append) 
		OutputStream os=null;//方便运行完关闭
		try {
			//1.选择流
			os=new FileOutputStream("D:/hehe.txt",true); //文件不存在,系统会自动帮我们创建,但是文件夹不会
			//2.准备数据
			String str="今天晚上要吃螃蟹..."; 
			byte[] car=str.getBytes();
			//3.写出 void write(byte[] b)  
			os.write(car);
			//4.刷出
			os.flush();
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally{
			//5.关闭
			try {//预防空指针异常
				if(os!=null){
					os.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

文件拷贝:

• 数据从文件中读入到程序中,写出到文件中
• 文件—>-----程序----->-------文件中

public static void main(String[] args) {
		//1.选择流
		InputStream is=null;
		OutputStream os=null;
		
		try{
			is = new FileInputStream("D:/hehe.txt");
			os = new FileOutputStream("E:hehe.txt"); 
			//2.读入.写出
			byte[] car=new byte[1024];
			int len=-1;
			while((len=is.read(car))!=-1){
				os.write(car,0,len);
			}
			//3.刷出
			os.flush();
		}catch(FileNotFoundException e){
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			//4.关闭
			//后打开的先关闭
			try {
				if(os!=null){
					os.close();
				}
				if(is!=null){
					is.close();
				}
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

io: 上传下载,写入写出…
File 类 文件和目录路径名的抽象表示形式。
能够定义真实存在的路径|文件,不在的也可以定义,所以抽象表现形式

public static void main(String[] args) throws IOException {
		//File(String pathname) 
		File file =new File("D:/test.txt");  //转义字符从\开始  所以在表示路径字符串中使用\\或者/表示
		System.out.println(file);
		
		//File(String parent, String child) 
		File file1 =new File("D:/AAA/haha.txt");  
		File file2 =new File("D:/AAA/","haha.txt");  
		System.out.println(file1);
		System.out.println(file2);
		File file3 =new File("D:/");  
		File file4 =new File(file3,"test.txt");  
		System.out.println(file3);
		System.out.println(file4);
		
		// boolean canWrite() 测试应用程序是否可以修改此抽象路径名表示的文件。 
		System.out.println("canWrite()"+file.canWrite());
		//setReadOnly()
		System.out.println("setReadOnly()"+file.setReadOnly());
		System.out.println("canWrite()"+file.canWrite());
		
		/*
		 * boolean mkdir() 
		          创建此抽象路径名指定的目录。 
		   boolean mkdirs() 
		          创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。 
		 */
		/*
		 * String getParent() 返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。 
 		   File getParentFile()  
		 */
		System.out.println("mkdir()"+file1.getParentFile().mkdir());
		//boolean createNewFile()  
		System.out.println("createNewFile()"+file1.createNewFile());
		// boolean delete() 删除此抽象路径名表示的文件或目录。 
		System.out.println("delete()"+file1.delete());
		// boolean exists() 测试此抽象路径名表示的文件或目录是否存在。 
		System.out.println("exists()"+file1.exists());
		/*
		 * File getAbsoluteFile() 
		          返回此抽象路径名的绝对路径名形式。 
		   String getAbsolutePath() 
		          返回此抽象路径名的绝对路径名字符串。 
		 */
		System.out.println("getAbsolutePath()"+file1.getAbsolutePath());
		
		//long getFreeSpace()  返回此抽象路径名指定的分区中未分配的字节数。 
		System.out.println("getFreeSpace()"+file3.getFreeSpace());
		
		// String getName()  返回由此抽象路径名表示的文件或目录的名称。 
		System.out.println("getName()"+file1.getName());
		/*
		 *  boolean isAbsolute()  测试此抽象路径名是否为绝对路径名。 
		 	boolean isDirectory()    测试此抽象路径名表示的文件是否是一个目录。 
		 	boolean isFile() 	
		 */
		System.out.println("isAbsolute()"+file1.isAbsolute());
		file1.createNewFile();
		System.out.println("isFile()"+file1.isFile()); //找路径下真实文件判断
		//long lastModified()  
		System.out.println("lastModified()"+new SimpleDateFormat().format(new Date(file.lastModified())));
	
		//File[] listFiles()  
		// String[] list() 
		System.out.println(Arrays.toString(new File("D:/code").listFiles()));
		
		/*
		 *  boolean renameTo(File dest)   重新命名 
		 *  	不能做跨盘符的文件重新命名
		 */
		File src=new File("D:/AAA");
		System.out.println("renameTo()"+src.renameTo(new File("D:/BBB")));
	}

文件拷贝封装类

//静态方法
	public static void copyFile(String src,String dest){
		copyFile(new File(src),new File(dest));
	}
	//重载方法,代码功能型更强,更灵活,更完善
	public static void copyFile(File src,File dest){
		//1.选择流  先声明:关闭资源的时候,变量is,os作用域的问题
		InputStream is=null;
		OutputStream os=null;
		//处理相同|功能的代码,可能会出现异常的放在一个try中
		try{
			is = new FileInputStream(src);
			os = new FileOutputStream(dest); 
			//2.读入.写出
			byte[] car=new byte[1024]; //一般为1024整数倍,1024进制的
			int len=-1;//len中的数据是读取到字节数组中数据的个数,作用用来控制循环结束
			while((len=is.read(car))!=-1){
				os.write(car,0,len); //写出到文件中的内容就是读取进行的内容
			}
			//3.刷出
			os.flush();
		}catch(FileNotFoundException e){
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			//4.关闭
			//后打开的先关闭
			try {
				if(os!=null){
					os.close();
				}
				if(is!=null){
					is.close();
				}
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

拷贝文件夹

public static void main(String[] args) {
		String src="D:/BBB";
		String dest="E:/";
		copyDir(src,dest);
	}
	
	public static void copyDir(String src,String dest){
		File srcFile=new File(src);  //D:/BBB
		File destFile=new File(dest,srcFile.getName());//E:/BBB
		copyDetails(srcFile,destFile);
		System.out.println(srcFile);
		System.out.println(destFile);
	}
	//实现拷贝细节的方法
	public static void copyDetails(File src,File dest){
		if(src.isFile()){
			if(!dest.getParentFile().exists()){
				//如果目的地路径不存在,需要创建
				dest.getParentFile().mkdirs();
			}
			CopyUtils.copyFile(src, dest);//***前面封装的文件拷贝静态方法
		}else{
			//如果是文件夹,先创建文件夹
			dest.mkdirs();
			//遍历原文件夹中的内容,如果是文件拷贝,如果是文件夹,创建,遍历...
			File[] files=src.listFiles();
			for(File srcFile:files){
				System.out.println(srcFile);
				copyDetails(srcFile,new File(dest,srcFile.getName()));
			}
		}
	}

• 字符流: 只能操作纯文本…
• 节点流:
• 字符输入流: Reader 读取字符流的抽象类。
• FileReader 用来读取字符文件的便捷类。
• 字符输出流: Writer 写入字符流的抽象类
• FileWriter用来写入字符文件的便捷类。

public static void main(String[] args) {
		//FileReader(String fileName) 
		Reader rd=null;
		try {
			//1.选择流
			rd=new FileReader("D:/hehe.txt");
			//2.读入
			//int read() 读取单个字符。 
			/*System.out.println((char)rd.read());
			System.out.println((char)rd.read());
			System.out.println((char)rd.read());
			System.out.println((char)rd.read());*/
			int len=-1;  //存储读到的数据  如果为-1,证明已达到末尾
			/*while(-1!=(len=rd.read())){
				System.out.println((char)len);
			}*/  
			
			// int read(char[] cbuf)  将字符读入数组。
			char[] car=new char[1024];
			while((len=rd.read(car))!=-1){
				System.out.println(new String(car,0,len));
			}
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally{
			if(rd!=null){
				try {
					rd.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}

	}

字符输出流: Writer 写入字符流的抽象类
FileWriter用来写入字符文件的便捷类。

public static void main(String[] args) {
		//FileWriter(File file)    //默认不追加
		//FileWriter(File file, boolean append)true追加false不追加  
		//FileWriter(String file)  
		//FileWriter(String file, boolean append)true追加false不追加  
		Writer rt=null;
		try {
			//1.选择流 
			rt=new FileWriter("D:/houhou.txt",true);
			//2.写出
			/*
			 *   void write(char[] cbuf) 
				          写入字符数组。 
				 abstract  void write(char[] cbuf, int off, int len) 
				          写入字符数组的某一部分。 
				 void write(int c) 
				          写入单个字符。 
				 void write(String str) 
				          写入字符串。 
				 void write(String str, int off, int len) 
				          写入字符串的某一部分。 
			 */
			rt.write(97);
			rt.write("\r\n");  //换行
			rt.write("你真好看!!!!");
			rt.write("\r\n");
			rt.write("你真好看!!!!",2,2);
			rt.write("\r\n");
			char[] ch={'上','海','尚','学','堂'};
			rt.write(ch);
			rt.write("\r\n");
			rt.write(ch,2,3);
			//3.刷出
			rt.flush();
			
		} catch (IOException e) {
			e.printStackTrace();
		} finally{
			//4.关闭
			if(null!=rt){
				try {
					rt.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}

	}

功能流(节点流):

缓冲流: 增强功能,提高性能,加快读写效率…

字节流：

• BufferedInputStream 字节输入流缓冲流
• BufferedOutputStream 字节输出流缓冲流
• 没有新增方法,可以发生多态使用

字符流:

• BufferedReader 字符输入流缓冲流
• BufferedWriter 字符输出流缓冲流

public static void main(String[] args) throws IOException {
		//1.选择流
		//BufferedInputStream(InputStream in) 
		InputStream is=new BufferedInputStream(new FileInputStream("D:/hehe.txt"));
		OutputStream os=new BufferedOutputStream(new FileOutputStream("E:/hengheng.txt") );
		//2.读写
		byte[] car=new byte[1024];
		int len=-1;
		while((len=is.read(car))!=-1){
			os.write(car,0,len);
		}
		//3.刷出
		os.flush();
		//4.关闭
		os.close();
		is.close();
	}

字符流:

BufferedReader 字符输入流缓冲流

• 新增方法:String readLine() 读取一个文本行。
• BufferedWriter 字符输出流缓冲流
• 新增方法:void newLine() 写入一个行分隔符。

public static void main(String[] args) throws IOException {
		//1.选择流  导包快捷键: ctrl+shift+o
		BufferedReader br=new BufferedReader(new FileReader("D:/hehe.txt"));
		BufferedWriter bw=new BufferedWriter(new FileWriter("D:/ccc.txt"));
		//2.读写
		String msg=null;
		while((msg=br.readLine())!=null){
			bw.write(msg);
			bw.newLine();
		}
		//3.刷出
		bw.flush();
		//4.关闭
		bw.close();
		br.close();
	}