java基础-----IO流

IO流

/*
 *  java.io.File
 *    将操作系统中的,文件,目录(文件夹),路径,封装成File对象
 *    提供方法,操作系统中的内容
 *    File与系统无关的类
 *    文件 file
 *    目录 directory
 *    路径 path
 */
public class FileDemo {
	public static void main(String[] args) {
		//File类静态成员变量
		//与系统有关的路径分隔符
		String separator = File.pathSeparator;
		System.out.println(separator);// 是一个分号,目录的分割   Linux :
		
		//与系统有关的默认名称分隔符
		separator = File.separator;
		System.out.println(separator);// 向右 \  目录名称分割  Linux / 
	}
}

File有三种重载形式

例子

/*
 *  File类的构造方法
 *  三种重载形式
 */
public class FileDemo1 {
	public static void main(String[] args) {
		function_2();
	}
	/*
	 *  File(File parent,String child)
	 *  传递路径,传递File类型父路径,字符串子路径
	 *  好处: 父路径是File类型,父路径可以直接调用File类方法
	 */
	public static void function_2(){
		File parent = new File("d:");
		File file = new File(parent,"eclipse");
		System.out.println(file);
	}
	
	/*
	 *  File(String parent,String child)
	 *  传递路径,传递字符串父路径,字符串子路径
	 *  好处: 单独操作父路径和子路径
	 */
	public static void function_1(){
		File file = new File("d:","eclipse");
		System.out.println(file);
	}
	
	/*
	 *  File(String pathname)
	 *  传递路径名: 可以写到文件夹,可以写到一个文件
	 *  c:\\abc   c:\\abc\\Demo.java
	 *  将路径封装File类型对象
	 */
	public static void function(){
		File file = new File("d:\\eclipse");
		System.out.println(file);
	}
}

注意：路径windows下不区分大小写，而Linux下区分大小写

如：

相对和绝对的理解

/*
	 *  File创建文件的功能
	 *  boolean createNewFile()
	 *  创建的文件路径和文件名,在File构造方法中给出
	 *  文件已经存在了,不在创建（createNewFile只能创建文件，不能创建文件夹）
	 */
	public static void function()throws IOException{
		File file = new File("c:\\a.txt");
		boolean b = file.createNewFile();
		System.out.println(b);
	}

==============================================================================
	/*
	 *  File创建文件夹功能
	 *  boolean mkdirs() 创建多层文件夹（mkdir只能创建一个文件夹 ）
	 *  创建的路径也在File构造方法中给出
	 *  文件夹已经存在了,不在创建
	 */
	public static void function_1(){
		File file = new File("c:\\abc");
		boolean b = file.mkdirs();
		System.out.println(b);
	}



==============================================================================
/*
	 *  File类的删除功能
	 *  boolean delete()
	 *  删除的文件或者是文件夹,在File构造方法中给出
	 *  删除成功返回true,删除失败返回false
	 *  删除方法,不走回收站,直接从硬盘中删除
	 *  删除有风险,运行需谨慎
	 */
	public static void function_2(){
		File file = new File("c:\\a.txt");
		boolean b = file.delete();
		System.out.println(b);
	}

例子

/*
 *  File类的获取功能
 */
public class FileDemo3 {
	public static void main(String[] args) {
		function_3();
	}
	/*
	 * File类的获取功能
	 * String getParent() 返回String对象
	 * File getParentFile()返回File对象
	 * 获取父路径
	 */
	public static void function_3(){
		File file = new File("d:\\eclipse\\eclipse.exe");
		File parent = file.getParentFile();
		System.out.println(parent);
	}
	
	/*
	 * File类获取功能
	 * String getAbsolutePath() 返回String对象
	 * File   getAbsoluteFile() 返回File对象
	 * 获取绝对路径
	 * eclipse环境中,写的是一个相对路径,绝对位置工程根目录
	 */
	public static void function_2(){
		File file = new File("src");
		File absolute = file.getAbsoluteFile();
		System.out.println(absolute);
	}
	
	/*
	 * File类获取功能
	 * long length()
	 * 返回路径中表示的文件的字节数
	 */
	public static void function_1(){
		File file = new File("d:\\eclipse\\eclipse.exe");
		long length = file.length();
		System.out.println(length);
	}
	
	/*
	 *  File类的获取功能
	 *  String getName()
	 *  返回路径中表示的文件或者文件夹名
	 *  获取路径中的最后部分的名字
	 */
	public static void function(){
		File file = new File("d:\\eclipse\\eclipse.exe");
		String name = file.getName();
		System.out.println(name);
		
		/*String path = file.getPath();
		System.out.println(path);*/
//		System.out.println(file);
	}
}

/*
 *  File类的判断功能
 */
public class FileDemo4 {
	public static void main(String[] args) {
		function_1();
	}
	/*
	 *  File判断功能
	 *  boolean isDirectory()
	 *  判断File构造方法中封装的路径是不是文件夹
	 *  如果是文件夹,返回true,不是文件返回false
	 *  
	 *  boolean isFile()
	 *  判断File构造方法中封装的路径是不是文件
	 */
	public static void function_1(){
		File file = new File("d:\\eclipse\\eclipse.exe");
		if(file.exists()){
			boolean b = file.isDirectory();
			System.out.println(b);
		}
	}
	
	/*
	 *  File判断功能
	 *  boolean exists()
	 *  判断File构造方法中封装路径是否存在
	 *  存在返回true,不存在返回false
	 */
	public static void function(){
		File file = new File("src");  //注意：当我们括号里面不写路径，写成src，系统会默认指向eclipse当前工作空间的路径
		boolean b = file.exists();
		System.out.println(b);
	}
}

/*
 *  File类获取功能
 *  list
 *  listFiles
 */
public class FileDemo {
	public static void main(String[] args) {
		function_2();
	}
	public static void function_2(){
		//获取系统中的所有根目录
		File[] fileArr = File.listRoots();
		for(File f : fileArr){
			System.out.println(f);
		}
	}
	
	/*
	 *  File类的获取功能
	 *  File[] listFiles()
	 *  获取到,File构造方法中封装的路径中的文件和文件夹名 (遍历一个目录)
	 *  返回的是目录或者文件的全路径
	 */
	public static void function_1(){
		File file = new File("d:\\eclipse");
		File[] fileArr = file.listFiles();
		for(File f : fileArr){
			//String s = f.toString();该方法也可以转成String，因为这个toString()方法。String不一定一定要用下面这个方法，用这个方法也可以。
			System.out.println(f);
		}
	}
	
	/*
	 *  File类的获取功能
	 *  String[] list()
	 *  获取到,File构造方法中封装的路径中的文件和文件夹名 (遍历一个目录)
	 *  返回只有名字
	 */
	public static void function(){
		File file = new File("c:");
		String[] strArr = file.list();
		System.out.println(strArr.length);
		for(String str : strArr){
			System.out.println(str);
		}
	}
}

文件过滤器

/*
 *  File类的获取,文件获取过滤器
 *  遍历目录的时候,可以根据需要,只获取满足条件的文件
 *  遍历目录方法 listFiles()重载形式
 *  listFiles(FileFilter filter)接口类型
 *  传递FileFilter接口的实现类
 *  自定义FileFilter接口实现类,重写抽象方法,
 *  接口实现类对象传递到遍历方法listFiles
 */
public class FileDemo1 {
	public static void main(String[] args) {
		File file = new File("c:\\demo");
		File[] fileArr = file.listFiles(new MyFilter());
		for(File f : fileArr){
			System.out.println(f);
		}
	}
}

/*
 *  自定义过滤器
 *  实现FileFilter接口,重写抽象方法
 */
public class MyFilter implements FileFilter{
	public boolean accept(File pathname)  {
		/*
		 * pathname 接受到的也是文件的全路径
		 * c:\\demo\\1.txt
		 * 对路径进行判断,如果是java文件,返回true,不是java文件,返回false
		 * 文件的后缀结尾是.java
		 */
		//String name = pathname.getName();
		return pathname.getName().endsWith(".java");
		
	}
}

文件过滤器实现原理

递归遍历全目录

/*
 *  对一个目录的下的所有内容,进行完全的遍历
 *  编程技巧,方法的递归调用,自己调用自己
 */
public class FileDemo {
	public static void main(String[] args) {
		File dir = new File("d:\\eclipse");
		getAllDir(dir);
	}
	/*
	 *  定义方法,实现目录的全遍历
	 */
	public static void getAllDir(File dir){
		System.out.println(dir);
		//调用方法listFiles()对目录,dir进行遍历
		File[] fileArr = dir.listFiles();
		for(File f : fileArr){
			//判断变量f表示的路径是不是文件夹
			if(f.isDirectory()){
				//是一个目录,就要去遍历这个目录
				//本方法,getAllDir,就是给个目录去遍历
				//继续调用getAllDir,传递他目录
				getAllDir(f);
			}else{
				System.out.println(f);
			}
		}
	}
}

图解

递归

/*
 *  方法的递归调用
 *    方法自己调用自己
 *  适合于,方法中运算的主体不变,但是运行的时候,参与运行的方法参数会变化
 *  注意:
 *     递归一定要有出口, 必须可以让程序停下
 *     递归次数不能过多
 *     构造方法,禁止递归
 */

斐波那契

输入和输出概念

/*
 *  字节输出流
 *    java.io.OutputStream 所有字节输出流的超类
 *    作用: 从Java程序,写出文件
 *    字节: 这样流每次只操作文件中的1个字节
 *    写任意文件
 *    
 *    方法都是写文入的方法
 *    write(int b) 写入1个字节
 *    write(byte[] b) 写入字节数组
 *    write(byte[] b,int,int)写入字节数组,int 开始写入的索引, int 写几个
 *    close() 方法,关闭流对象,释放与次流相关的资源
 *    
 *    流对象,操作文件的时候, 自己不做,依赖操作系统
 */

FileOutStream

public class aaa {
	public static void main(String[] args) throws IOException {
		FileOutputStream file = new FileOutputStream("c:\\a.txt");
		file.write("hello".getBytes());//一定需要写成这样的格式。因为write方法不能接受String引用对象。
		//这样写进去的数据，一旦再次运行就不见了。解决方法：我们可以写成new FileOutputStream("c:\\a.txt"，true);
		file.close();
	}
}

\r\n是换行

IO流的异常处理

/*
 *   IO流的异常处理
 *   try catch finally
 *   
 *   细节:
 *     1. 保证流对象变量,作用域足够
 *     2. catch里面,怎么处理异常
 *         输出异常的信息,目的看到哪里出现了问题
 *         停下程序,从新尝试
 *     3. 如果流对象建立失败了,需要关闭资源吗
 *         new 对象的时候,失败了,没有占用系统资源
 *         释放资源的时候,对流对象判断null
 *         变量不是null,对象建立成功,需要关闭资源
 */
public class FileOutputStreamDemo3 {
	public static void main(String[] args) {
		//try 外面声明变量,try 里面建立对象
		FileOutputStream fos = null;
		try{
			fos = new FileOutputStream("s:\\a.txt");
			fos.write(100);
		}catch(IOException ex){
			System.out.println(ex);
			throw new RuntimeException("文件写入失败,重试");
		}finally{
			try{
				if(fos!=null)
			      fos.close();
			}catch(IOException ex){
				throw new RuntimeException("关闭资源失败");
			}
		}
	}
}

/*
 *   字节输入流
 *     java.io.InputStream 所有字节输入流的超类
 *   作用: 读取任意文件,每次只读取1个字节
 *   读取的方法  read
 *     int  read() 读取1个字节
 *     int  read(byte[] b) 读取一定量的字节,存储到数组中
 */


========================================================================


/*
 *  FileInputStream读取文件
 *  
 *  构造方法: 为这个流对象绑定数据源
 *  
 *    参数: 
 *      File 类型对象
 *      String 对象
 *   输入流读取文件的步骤
 *     1. 创建字节输入流的子类对象
 *     2. 调用读取方法read读取
 *     3. 关闭资源
 *     
 *     read()方法,
 *       read()执行一次,就会自动读取下一个字节
 *       返回值,返回的是读取到的字节, 读取到结尾返回-1
 */
public class FileInputStreamDemo {
	public static void main(String[] args) throws IOException{
		FileInputStream fis = new FileInputStream("c:\\a.txt");
		//读取一个字节,调用方法read 返回int
		//使用循环方式,读取文件,  循环结束的条件  read()方法返回-1
		int len = 0;//接受read方法的返回值
	
		while( (len = fis.read()) != -1){//-1：是因为当我们从文件中取数据的时候，全部取完再取的时候，就是-1
			System.out.print((char)len);
		}
    	//关闭资源
		fis.close();
	}
}

/*
 *  FileInputStream读取文件
 *   读取方法  int read(byte[] b) 读取字节数组
 *   数组作用: 缓冲的作用, 提高效率
 *   read返回的int,表示什么含义 读取到多少个有效的字节数
 */
public class FileInputStreamDemo1 {
	public static void main(String[] args) throws IOException {
		FileInputStream fis = new FileInputStream("c:\\a.txt");
		//创建字节数组
		byte[] b = new byte[1024];
		
		int len = 0 ;
		while( (len = fis.read(b)) !=-1){
			System.out.print(new String(b,0,len));
		}
		fis.close();
	}
}

文件复制操作

/*
 *  将数据源 c:\\a.txt
 *  复制到 d:\\a.txt  数据目的
 *  字节输入流,绑定数据源
 *  字节输出流,绑定数据目的
 *  
 *  输入,读取1个字节
 *  输出,写1个字节
 */
public class Copy {
	public static void main(String[] args) {
		//定义两个流的对象变量
		FileInputStream fis = null;
		FileOutputStream fos = null;
		try{
			//建立两个流的对象,绑定数据源和数据目的
			fis = new FileInputStream("c:\\t.zip");
			fos = new FileOutputStream("d:\\t.zip");
			//字节输入流,读取1个字节,输出流写1个字节
			int len = 0 ;
			while((len = fis.read())!=-1){
				fos.write(len);
			}
		}catch(IOException ex){
			System.out.println(ex);
			throw new RuntimeException("文件复制失败");
		}finally{
			try{
				if(fos!=null)
					fos.close();
			}catch(IOException ex){
				throw new RuntimeException("释放资源失败");
			}finally{
				try{
					if(fis!=null)
						fis.close();
				}catch(IOException ex){
					throw new RuntimeException("释放资源失败");
				}
			}
		}
	}
}

字符流只能玩文本，不能玩jpg这些

字符输出流

/*
 *   字符输出流
 *     java.io.Writer 所有字符输出流的超类
 *   写文件,写文本文件
 *   
 *   写的方法 write
 *     write(int c) 写1个字符
 *     write(char[] c)写字符数组
 *     write(char[] c,int,int)字符数组一部分,开始索引,写几个
 *     write(String s) 写入字符串
 *     
 *   Writer类的子类对象 FileWriter
 *   
 *   构造方法:  写入的数据目的
 *     File 类型对象
 *     String 文件名
 *     
 *   字符输出流写数据的时候,必须要运行一个功能,刷新功能
 *   flush()
 */
public class WriterDemo {
	public static void main(String[] args) throws IOException{
		FileWriter fw = new FileWriter("c:\\1.txt");
		
		//写1个字符
		fw.write(100);
		fw.flush();
		
		//写1个字符数组
		char[] c = {'a','b','c','d','e'};
		fw.write(c);
		fw.flush();
		
		//写字符数组一部分
		fw.write(c, 2, 2);
		fw.flush();
		
		//写如字符串
		fw.write("hello");
		fw.flush();
		
		fw.close();
	}
}

字符输入流

/*
 *  字符输入流读取文本文件,所有字符输入流的超类（文本文件的概念：用记事本打开，人能看得懂的则是。）
 *    java.io.Reader
 *  专门读取文本文件
 *  
 *  读取的方法 : read()
 *   int read() 读取1个字符
 *   int read(char[] c) 读取字符数组
 *   
 *   Reader类是抽象类,找到子类对象 FileReader
 *   
 *   构造方法: 绑定数据源
 *     参数:
 *        File  类型对象
 *        String文件名
 */
public class ReaderDemo {
	public static void main(String[] args) throws IOException{
		FileReader fr = new FileReader("c:\\1.txt");
		/*int len = 0 ;
		while((len = fr.read())!=-1){
			System.out.print((char)len);
		}*/
		char[] ch = new char[1024];
		int len = 0 ;
		while((len = fr.read(ch))!=-1){
			System.out.print(new String(ch,0,len));
		}
		
		fr.close();
	}
}

对比

public class bbb {
	public static void main(String[] args) throws IOException {
		FileReader filer = new FileReader("D:\\B站\\22.txt");
		FileWriter filew = new FileWriter("D:\\B站\\11.txt");
		
		char[] c = new char[1024]; 
		int len = 0;
		while((len=filer.read(c))!=-1){
			filew.write(new String(c, 0, len));
		}
		
		filew.flush();
		filew.close();
		filer.close();
	}
}

public class aaa {
	public static void main(String[] args) throws IOException {
		FileInputStream in = new FileInputStream("D:\\B站\\22.jpg");
		FileOutputStream out = new FileOutputStream("D:\\B站\\11.jpg");
		int len = 0;
		byte[] b = new byte[1024];
		while((len=in.read())!=-1){
			out.write(b,0,len);
		}
		
		in.close();
		out.close();
	}
}

转换流

可以将编码格式进行转换。

用途：解决乱码问题。

案例

 public class eee {
	public static void main(String[] args) {
		FileInputStream in = null;
		FileOutputStream out = null;
		OutputStreamWriter outw = null;
		InputStreamReader inr = null;
		try{
			
			out = new FileOutputStream("D:\\远程\\11.txt");
			in = new FileInputStream("D:\\远程\\22.txt");
			outw = new OutputStreamWriter(out,"UTF-8");
			inr = new InputStreamReader(in,"UTF-8");
			
			int len = 0;
			char[] c = new char[1024];
			while((len=inr.read(c))!=-1){
				outw.write(c, 0, len);
			}
		}catch(IOException ex){
			System.out.println(ex);
			throw new RuntimeException("文件写入失败,重试");
		}finally{
			try{
				if(outw!=null)
					out.flush();
					outw.close();
			}catch(IOException e){
				throw new RuntimeException("关闭资源失败");
			}finally{
				try{
					if(inr!=null){
						inr.close();
					}
				}catch(IOException ea){
					throw new RuntimeException("关闭资源失败");
				}
			}
		}
	}
}

/*
 *  转换流
 *    java.io.OutputStreamWriter 继承Writer类
 *    就是一个字符输出流，写文本文件
 *    write()字符，字符数组，字符串
 *    
 *    字符通向字节的桥梁，将字符流转字节流
 *    
 *    OutputStreamWriter 使用方式
 *     构造方法：
 *       OutputStreamWriter(OuputStream out)接收所有的字节输出流
 *       但是： 字节输出流：  FileOutputStream
 *       
 *      OutputStreamWriter(OutputStream out, String charsetName)
 *      String charsetName 传递编码表名字 GBK  UTF-8 
 *      
 *      OutputStreamWriter 有个子类，  FileWriter
 */
public class OutputStreamWriterDemo {
	public static void main(String[] args)throws IOException {
//		writeGBK();
		writeUTF();
	}
	/*
	 * 转换流对象OutputStreamWriter写文本
	 * 采用UTF-8编码表写入
	 */
	public static void writeUTF()throws IOException{
		//创建字节输出流，绑定文件
		FileOutputStream fos = new FileOutputStream("c:\\utf.txt");
		//创建转换流对象，构造方法保证字节输出流，并指定编码表是UTF-8
		OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8");
		osw.write("你好");
		osw.close();
	}
	
	/*
	 * 转换流对象 OutputStreamWriter写文本
	 * 文本采用GBK的形式写入
	 */
	public static void writeGBK()throws IOException{
		//创建字节输出流，绑定数据文件
		FileOutputStream fos = new FileOutputStream("c:\\gbk.txt");
		//创建转换流对象，构造方法，绑定字节输出流，使用GBK编码表
		OutputStreamWriter osw = new OutputStreamWriter(fos);
		//转换流写数据
		osw.write("你好");
		
		osw.close();
	}
}

缓冲流：提高IO流的读写速度。

图析


字符输出流缓冲区流（字符输出流有两个：FileWriter, OutputStreamWriter）

/*
 *   字符输出流缓冲区流
 *     java.io.BufferedWriter 继承 Writer
 *     写入方法 write () 单个字符,字符数组,字符串
 *     
 *     构造方法:
 *       BufferedWriter(Writer w)传递任意字符输出流
 *       传递谁,就高效谁
 *         能传递的字符输出流 FileWriter, OutputStreamWriter
 *         
 *    BufferedWriter 具有自己特有的方法
 *      void  newLine() 写换行
 *      
 *       newLine()文本中换行, \r\n也是文本换行
 *       方法具有平台无关性
 *       Windows  \r\n
 *       Linux    \n
 *       
 *       newLine()运行结果,和操作系统是相互关系
 *       JVM: 安装的是Windows版本,newLine()写的就是\r\n
 *            安装的是Linux版本,newLine()写的就是\n
 */

字符输入流缓冲流（字符输入流有两个：FileReader InputStreamReader）

/*
 *  字符输入流缓冲流
 *    java.io.BufferedReader 继承 Reader
 *    读取功能 read() 单个字符,字符数组
 *    构造方法:
 *      BufferedReader(Reader r)
 *      可以任意的字符输入流
 *         FileReader  InputStreamReader
 *         
 *     BufferedReader自己的功能
 *     String readLine() 读取文本行 \r\n
 *     
 *     方法读取到流末尾,返回null
 *     小特点:
 *       获取内容的方法一般都有返回值
 *       int 没有返回的都是负数
 *       引用类型 找不到返回null
 *       boolean 找不到返回false
 *       
 *       String s = null
 *       String s ="null"
 *       
 *       readLine()方法返回行的有效字符,没有\r\n
 */

第3章流的操作规律
IO流中对象很多，解决问题(处理设备上的数据时)到底该用哪个对象呢？　　
把IO流进行了规律的总结(四个明确)：
?明确一：要操作的数据是数据源还是数据目的。
		源：InputStream（所有字节输入流的父类）    Reader（所有字符输入流的父类）
		目的：OutputStream（所有字节输出流的父类） Writer（所有字节输出流的父类）
		【IO流的四大抽象父类】
先根据需求明确要读，还是要写。

?明确二：要操作的数据是字节还是文本呢？
		源：
			字节：InputStream（言简意赅就是指人打开后看不懂的）
			文本：Reader（言简意赅就是指人打开后看的懂的）
		目的：
			字节：OutputStream
			文本：Writer
已经明确到了具体的体系上。

?明确三：明确数据所在的具体设备。
		源设备：
			硬盘：文件  File开头。
			内存：数组，字符串。如：ByteArrayInputStream  ByteArrayOutputStream
			键盘：System.in;
			网络：Socket
		目的设备：
			硬盘：文件  File开头。
			内存：数组，字符串。
			屏幕：System.out
			网络：Socket
完全可以明确具体要使用哪个流对象。

?明确四：是否需要额外功能呢？
		额外功能：
			转换吗？转换流。InputStreamReader OutputStreamWriter
			高效吗？缓冲区对象。BufferedXXX
     InputStream
       FileInputStream
       BufferedInputStream
 
OuputStream 
   FileOutputStream
   BufferedOuputStream


Writer
  OutputStreamWriter(可以改变编码表)
     FileWriter
      BufferedWriter

Reader
  InputStreamReader
     FileReader
 BufferedReader