File的使用和 IO流使用

雨点打透心脏的1/2处 2021-12-01 15:24 232阅读 0赞

# java IO篇 #

JAVA File

File 类

通过给定的父抽象路径名和子路径名字符串创建一个新的File实例。

> File(File parent,String child);

##### 通过将给定路径名字符串转换成抽象路径名来创建一个新 File 实例。 #####

> File(String pathname);

*  filemethod

public class Demo_method { 
    	
    	public static void main(String[] args) { 
    		//demo1();
    		//demo2();
    		//案例找到.txt 结尾的文件并打印
    		//demo3();
    		//file 类 文件名称过滤器 的使用 例子：找到.txt 结尾的文件并打印
    		File dir=new File("C:\\Users\\11276\\Desktop\\dnf");
    		String[] test=dir.list(new FilenameFilter() { //变成只存在.txt 的数组
    			
    			@Override
    			public boolean accept(File dir, String name) { 
    				// TODO Auto-generated method stub
    				//System.out.println(dir);
    				//System.out.println(name);
    				File file=new File(dir, name);
    				return file.isFile()&& file.getName().endsWith(".txt");
    			}
    		});
    		for (String string : test) { //string 中是条件成立的
    			System.out.println(string);
    		}
    	}
    
    
    	private static void demo3() { 
    		File findFile=new File("C:\\Users\\11276\\Desktop\\dnf");
    		File [] findFileList=findFile.listFiles();
    		for (File file: findFileList) { 
    			if(file.isFile()&&file.getName().endsWith(".txt")) { //获得名字
    				System.out.println(file);
    			}
    		}
    	}
    
    	
    	private static void demo2() { 
    		File file=new File("ccc.txt");
    		/* * System.out.println(file.exists()); * System.out.println(file.getAbsolutePath());//获得绝对路径 */	
    		//getoath();获取构造方法中传入的路径
    		System.out.println(file.getPath());
    		//length
    		System.out.println(file.length());
    		//文件的最后修改时间lastModified
    		Date d=new Date(file.lastModified());
    		System.out.println(d);
    		//public String [] list(); 获取名字
    			File dir=new File("C:\\Users\\11276\\Desktop\\dnf");
    			String [] list=dir.list();
    			for (String string : list) { 
    				System.out.println(string);
    			}
    			//public File[] listFile(); 获取对象File
    			File[] listFile=dir.listFiles();
    			for (File file2 : listFile) { 
    				System.out.println(file2);//可以对其进行操作
    			}
    	}
    
    	private static void demo1() { 
    		/** * isDirectory//判断是否为文件夹 * isFile/判断是否为文件 * exists//是否存在 * canread//是否可读 * canwrite//是否可写 * isgidden//是否是隐藏 * * @param args */
    		// TODO Auto-generated method stub
    		File dir1=new File("ccc.text");
    		System.out.println(dir1.isDirectory());//判断是否为文件夹
    		File dir2=new File("zzz");
    		System.out.println(dir1.isFile());//判断是否为文件
    		System.out.println(dir2.isFile());
    		System.out.println(dir1.exists());//是否存在
    		dir2.setReadable(false);//不可写
    	}
    
    }

*  IO流
    
    IO常用的子类
    
    字节流的抽象父类：计算机存储的是字节的格式
    
     `inputStream:`
    
    > **Fileinput Stream**
    
        public static void main(String[] args) throws IOException { 
        	//读取的方法1 read(); 返回的类型为int ，
            //不是byte ：byte 可能 碰到 byte 的 -1源码
        	//demo1();
        	//读取的方法2,规范
        	FileInputStream fis=new FileInputStream("ccc.txt");
        	int b;
        	while((b=fis.read())!=-1) { //结束符为-1(读到末尾)
        		System.out.println(b);
        	}
        }
        
        private static void demo1() throws FileNotFoundException, IOException { 
        	FileInputStream fis = new FileInputStream("ccc.txt");
        	int read = fis.read();
        	System.out.println(read);
        	fis.close();
        }
    
    > **BuffInputStream**
    
        #### 原理：
    
    \[外链图片转存失败(img-F3I4WCZP-1563628520420)(C:\\Users\\11276\\AppData\\Local\\Temp\\1562654769950.png)\]和小型数组的对比：
    
    \[外链图片转存失败(img-lyIk3oNm-1563628520421)(C:\\Users\\11276\\AppData\\Local\\Temp\\1562654988033.png)\]
    
    
    
    小型处理小型数据会跟快点，因为操作的是一个字节数组，而缓存是操作2个字节数组
    
     `outputStream:`
    
    > **FileoutputStream**
    
        public static void main(String[] args) throws IOException { 
        	//创建字节输出流
        	FileOutputStream fos=new FileOutputStream("yyy.txt",true);
            //续写的append
            */FileOutputStream(String name, boolean append) 
        	创建文件输出流以指定的名称写入文件。 
                /* fos.write(97); //虽然写出的是int数但是会转化为byte fos.write(98); fos.close(); }
    
    > 简单的案例
    > 
    >     /** * 简单的数据拷贝案例 *把图片ccc复制到ddd中 */
    >     方法1：不推荐，因为效率慢
    >     	FileInputStream fis=new FileInputStream("ccc.jpg");
    >     	FileOutputStream fos=new FileOutputStream("ddd.jpg");
    >     	int d;
    >     	while((d=fis.read())!=-1) { //判断是否存在这个图片
    >     		fos.write(d);
    >     	}
    >     方法2：不推荐，因为有可能内存溢出
    >     	available() ：获得文件的字节数
    >     	FileInputStream fis=new FileInputStream("ccc.jpg");
    >     	FileOutputStream fos=new FileOutputStream("bbb.jpg");
    >     	byte[] arr=new byte[fis.available()];
    >     	fos.write(arr);
    
    > ###### 原理： ######
    > 
    > \[外链图片转存失败(img-F5N8ELTZ-1563628520422)(C:\\Users\\11276\\AppData\\Local\\Temp\\1562590903851.png)\]
    
    > 解决方案：`需要一个容器：数组`
    > 
    >     public static void main(String[] args) throws IOException { 
    >     // TODO Auto-generated method stub
    >     FileInputStream fis=new FileInputStream("ccc.txt");
    >     FileOutputStream fos=new FileOutputStream("yyy.txt");
    >     byte[] arr=new byte[1024];//创建字节数组
    >     int len;//返回值类型为int
    >     while((len=fis.read(arr))!=-1) { //如果不加arr,就会返回字节的码表，不是个数
    >     /* * write(byte[] b, int off, int len) 将 len字节从位于偏移量 off的指定字节数组写入此文件输出流。 */
    >     fos.write(arr, 0, len);
    >     }
    >     fis.close();
    >     fos.close();
    >     }
    
    > 读取中文(不推荐使用字符流)
    > 
    >     public static void main(String[] args) throws IOException { 
    >     
    >     		// 读中文 ，字符流不好
    >     		//demo1();
    >     		//取中文
    >     		FileOutputStream fos=new FileOutputStream("ccc.txt");
    >     		fos.write("你好".getBytes());//转化为字节
    >     		fos.write("\r\n".getBytes());
    >     		fos.close();
    >     	}
    >     private static void demo1() throws FileNotFoundException, IOException { 
    >     	FileInputStream fis=new FileInputStream("ccc.txt");	
    >     	byte[] arr=new byte[3];
    >     	int len;
    >     	while((len=fis.read(arr))!=-1) { 
    >     		System.out.println(new String(arr,0,len));
    >     	}
    >     }
    
    1.7的IO流的标准处理异常代码
    
        public static void main(String[] args) throws IOException { 
        		// 1.7 流的异常处理
        			try(
        				//实现的autoclose的方法，所以可以这样用
        				FileInputStream fis=new FileInputStream("ccc.txt");
        				FileOutputStream fos=new FileOutputStream("yyy.txt");
        					){ 
        				int d;
        				while((d=fis.read())!=-1) { 
        					fos.write(d);
        				}
        			}
        		//普通的
        		FileInputStream fis=new FileInputStream("ccc.txt");
        		FileOutputStream fos=new FileOutputStream("yyy.txt");
        		int d;
        		while((d=fis.read())!=-1) { 
        			fos.write(d);
        		}
        		fis.close();
        		fos.close();
        	}
    
    > 小练习
    
    `练习1拷贝文件到项目文件下`
    
        public class Test_1 { 
        	/** * 拷贝文件到项目文件下 * @param args * @throws IOException */
        	public static void main(String[] args) throws IOException { 
        		File file=getFile();//获得File
        		BufferedInputStream bis=new BufferedInputStream(new FileInputStream(file));
        		BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(file.getName()));
        		int b;
        		while((b=bis.read())!=-1){ 
        			bos.write(b);
        		}
        		System.out.println("复制成功");
        		bis.close();
        		bos.close();
        	}
        	/** * 创建键盘录入对象 * 在主方法接受文件 * 读和写文件 */
        	public static File getFile() { 
        		Scanner sc=new Scanner(System.in);
        		System.out.println("输入名称");
        		while(true) { 
        			String line=sc.nextLine();
        			File file=new File(line);//把String 封装成File 类型
        			if(!file.exists()) { 
        				System.out.println("路径不存在");
        			} else if(file.isDirectory()) { 
        				System.out.println("输入的是文件夹的，不正确");
        			} else { 
        				return file;
        			}
        		}
        	}
        }
    
    `练习2录入数据拷贝到文件`
    
        public class Test_2 {
        	public static void main(String[] args) throws IOException {
        		/**
        		 * 练习录入数据拷贝到文件
        		 */
        		//1.创建键盘录入对象
        		Scanner sc=new Scanner(System.in);
        		//2.创建输出流对象
        		BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("ccc.txt"));
        		//进行拷贝文件
        		while(true) {
        			//接收数据
        			String  line=sc.nextLine();
        			if("quit".equals(line)) {
        				break;
        			}else {
        				bos.write(line.getBytes());
        				bos.write("\r\n".getBytes());
        			}	
        		}
        		bos.close();
        	}
        }
    
    字符流的抽象父类： （只能拷贝纯文本）
    
     \*reader 根据码表进行读字符
    
     `Filereader`
    
     \[外链图片转存失败(img-mDJDdP2T-1563628520422)(C:\\Users\\11276\\AppData\\Local\\Temp\\1562765574030.png)\]
    
        public class Demo_FileReader { 
        	/** * 字符流 FileReader * @param args * @throws IOException */
        	public static void main(String[] args) throws IOException { 
        		// TODO Auto-generated method stub
        		FileReader fir=new FileReader("ccc.txt");
        		int x;
        		while((x=fir.read())!=-1) { 
        			System.out.print((char)x);
        		}
        	}
        }
    
     \*writer
    
     `Filewriter`
    
        public class FileWiter { 
        
        	/* * 字符流 */
        
        	public static void main(String[] args) throws IOException { 
        
        		FileWriter fw=new FileWriter("ccc.txt");
        
        fw.write("大家好111");
        	
        	fw.close();
        }
        }
    
    >  字符流的拷贝(不推荐)
    
        public class FileWiter { 
        
        	/* * 字符流 */
        
        	public static void main(String[] args) throws IOException { 
        
        		demo1();
        
        		//字符流的拷贝
        
        		FileReader fr=new FileReader("ccc.txt");
        
        		FileWriter fw=new FileWriter("zzz.txt");
        
        		int c;
        
        		while((c=fr.read())!=-1) { 
        
        			fw.write(c);
        
        		}
        		fr.close();
        		fw.close();//write类中有一个2k的缓冲区，不关闭就不会显示数据
        
        	}
        
        private static void demo1() throws IOException { 
        	FileWriter fw=new FileWriter("ccc.txt");
        	fw.write("大家好111");
        	fw.close();
        	
        	}
        }
    
    > 原因
    > 
    > \[外链图片转存失败(img-yqGlxdok-1563628520423)(C:\\Users\\11276\\AppData\\Local\\Temp\\1562846763258.png)\]

\[外链图片转存失败(img-ecqaZc5Q-1563628520424)(C:\\Users\\11276\\AppData\\Local\\Temp\\1562846986339.png)\]

`字符流的缓冲`

BufferedReader

\[外链图片转存失败(img-2sVEYsqM-1563628520425)(C:\\Users\\11276\\AppData\\Local\\Temp\\1562848773616.png)\]

BufferedWriter

\[外链图片转存失败(img-C9gx9jtw-1563628520425)(C:\\Users\\11276\\AppData\\Local\\Temp\\1562848810762.png)\]

> readLine()和newLine()

readLIne属于Bufferedreader,newLine属于Bufferedwriter

public static void main(String[] args) throws IOException { 
    
    		BufferedReader br=new BufferedReader(new FileReader("ccc.txt"));
    
    		BufferedWriter bw=new BufferedWriter(new FileWriter("yyy.txt"));
    
    		String Line;
    
    		while((Line =br.readLine())!=null) { //包含行的内容的字符串，不包括任何行终止字符，如果已达到流的末尾，则为null 
    
    			bw.write(Line);
    
    			bw.newLine(); //表示\r\n 
    						//可以跨平台使用
    		}
    
    		br.close();
    
    		bw.close();
    
    }

> 小练习 将文本反转

public class Demo_test1 { 
      public static void main(String[] args) throws IOException { 
      	//创建流对象
      	BufferedReader br=new BufferedReader(new FileReader("ccc.txt"));
      
      	//创建集合
      	ArrayList<String> list=new ArrayList<String>();
      	//保存数据
      	String line;
      	while((line=br.readLine())!=null) { 
      		list.add(line);
      		System.out.println(list.size());
      	}
      	br.close();
    BufferedWriter bw=new BufferedWriter(new FileWriter("fz.txt"));
    for(int i=list.size()-1;i>=0;i--) { 
    	System.out.println(i);
    	bw.write(list.get(i));
    	bw.newLine();
    }
    bw.close();
    	}
    }

> BufferedReader 的子类 **LIneNumberinputStream**:
> 
> \[外链图片转存失败(img-myozUppH-1563628520428)(C:\\Users\\11276\\AppData\\Local\\Temp\\1562854353768.png)\]

public static void main(String[] args) throws IOException { 
    		LineNumberReader lnr=new LineNumberReader(new FileReader("yyy.txt"));
    		String line;
    		lnr.setLineNumber(4);//设置行数的开始
    		while((line=lnr.readLine())!=null) { 
    			System.out.println(lnr.getLineNumber()+":"+line);//获得行数的值
    		}
    }

> IO流 （装饰设计模式）

public class Demo_装饰设计模式 { 
    
    /** - 装饰设计模式 的好处是耦合性不强 - 被修饰的类的变化和装饰类的变化无关 - @param args */
      public static void main(String[] args) { 
      	// TODO Auto-generated method stub
      	new wengyanmin(new Student()).code();;
      	
      }
      }
      interface Coder{ 
      public void code();
      }
      class Student implements Coder{ 
      @Override
      public void code() { 
      	// TODO Auto-generated method stub
      	System.out.println("javaee");
      	System.out.println("javaweb");
      }
      }
      class wengyanmin implements Coder{ 
      //1,获取被修饰类的引用
      public Student s;
      //2,构造方法中传入被修饰类的对象
      public  wengyanmin(Student s) { 
      	this.s=s;
      }
      //3,对功能进行升级 
      @Override
      public void code() { 
      	// TODO Auto-generated method stub
      	s.code();
      	System.out.println("android");
       }
    }

> 使用指定的码表读写字符

`InputStreamReaber&OutputStreamWriter`字节通向字符的桥梁

使用例子：

public class Demo_InputStreamReader { 
    
    	public static void main(String[] args) throws IOException, IOException { 
    		//更高效的读和写
    		BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream("ccc.txt"),"utf-8"));
    		BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("fz.txt"),"utf-8"));
    		int b;
    		while((b=br.read())!=-1) { 
    			bw.write(b);
    		}
    		br.close();
    		bw.close();
    	}
    }

原理：

\[外链图片转存失败(img-tg2kMfrc-1563628520429)(C:\\Users\\11276\\AppData\\Local\\Temp\\1562936770796.png)\]

> 练习 ：获取一个文本上的每个字符出现的次数，将结果写在times.txt上

public class Demo_test2 { 
    /** * 获取一个文本上的每个字符出现的次数，将结果写在times.txt上 * @param args * @throws IOException */
    	public static void main(String[] args) throws IOException { 
    		//1创建一个输入流对象
    		BufferedReader br=new BufferedReader(new FileReader("ccc.txt"));
    		//创建一map集合
    		HashMap<Character, Integer> map=new HashMap<>();
    		//读取每一个字符
    		int index;//拿到了每一个字符
    		while((index=br.read())!=-1) { 
    			char c=(char)index;//强制转型
    			map.put(c,! map.containsKey(c)? 1: map.get(c)+1);
    		}
    		br.close();
    		//创建输出流对象
    		BufferedWriter bw=new BufferedWriter(new FileWriter("times.txt"));
    		//遍历集合
    		for (Character string : map.keySet()) { 
    			bw.write(string+"="+map.get(string));//打印
    			bw.newLine();
    		}
    		bw.close();
    	}
    }

\#\#\#\#注意：

要保留一个完整的数字例如10：使用字符流， readLine();方法保留一行的数据

> 练习 试用版软件的体验

public class Demo_test3 { 
    	/** * 试用版软件的体验,一共有10次使用机会 * @param args * @throws IOException */
    	public static void main(String[] args) throws IOException { 
    		//创建输入流对象
    		BufferedReader br=new BufferedReader(new FileReader("config.txt"));
    		//进行数据的转化
    		String lian=br.readLine();
    		int cs=Integer.parseInt(lian);
    		if(cs>0) { 
    			System.out.println("还有使用次数"+cs--);
    			FileWriter fw=new FileWriter("config.txt");
    			fw.write(cs+"");
    			fw.close();//要注意加，因为Filewriter 中有个小型的缓存区
    		}else { 
    			System.out.println("请购买");
    		}
    		br.close();
    	}
    }

> file递归

自己调用自己

缺点：占用内存大

优点： 不用知道循环次数

注意：构造方法不能使用递归， 不一定有返回值，可以有也可以没有v

public class Demo_递归 { 
    /** * 自己调用自己 求阶层！ * @param args */
    	public static void main(String[] args) { 
    		// TODO Auto-generated method stub
    		int re=1;
    		for(int i=1;i<=5;i++){ 
    			re=re*i;
    			System.out.println(re);
    		}
    		System.out.println(fun(5));
    	}
    	public static int fun(int i) { 
    		if(i==1) { 
    			return 1;
    		}else { 
    			int sum=i*fun(i-1);
    			return sum;
    		}	
    	}
    }

`File递归的练习`

public class Demo_test4 { 
    /** * File类练习 * 需求： 从键盘输入接收一个文件夹路径，打印出文件夹下的.java文件 * @param args */
    	public static void main(String[] args) { 
    		// 接收文件夹名称
    		File FileName=getDic();
    		//打印文件夹下的所以.java 文件名
    		printFileName(FileName);
    	}
    	/** * 获取文件夹的方法 getDic(); */
    	public static File getDic() { 
    		Scanner sc=new Scanner(System.in);
    		while(true){ 
    			String line=sc.nextLine();//获取输入的数据
    			//进行判断是否是文件夹
    			File file=new File(line);
    			if(!file.exists()) { 
    				System.out.println("文件夹不存在");
    			}else if(file.isFile()) { 
    				System.out.println("你输入的是文件名，不是文件夹");
    			}else { 
    				return file;
    			}
    		}
    	} 
    	/** * 打印文件夹下的.java文件 * print Filename(File FileNamev) */
    	public static void printFileName(File FileName){ 
    		File [] saveFile=FileName.listFiles();//获取文件夹，存储到数组中
    		for (File file : saveFile) { //过滤器
    			if(file.isFile()&&file.getName().endsWith(".txt")) { 
    				System.out.println(file);
    			}else if(file.isDirectory()) { 
    				printFileName(file);//进行递归，若找到文件夹则进行继续递归 
    			}	
    		}
    	}
    }

> IO**序列流**
> 
> 什么是序列流：可以把多个字节输入流整合成一个，读取这是从第一个开始读，到最后

原理：

\[外链图片转存失败(img-D5OoFTtU-1563628520430)(C:\\Users\\11276\\AppData\\Local\\Temp\\1563112725238.png)\]

代码：

public static void main(String[] args) throws IOException { 
    		demo1();
    		//方式2
    		FileInputStream fis1=new FileInputStream("yyy.txt");
    		FileInputStream fis2=new FileInputStream("ccc.txt");
    		SequenceInputStream sis=new SequenceInputStream(fis1, fis2);//序列流
    		FileOutputStream fos=new FileOutputStream("c.txt");
    		int b;
    		while((b=sis.read())!=-1) { 
    			fos.write(b);
    		}
    		sis.close();
    		fos.close();
    	}
    
    	private static void demo1() throws FileNotFoundException, IOException { 
    		//传统方式
    		FileInputStream fis1=new FileInputStream("yyy.txt");
    		FileOutputStream fos=new FileOutputStream("c.txt");
    		int b;
    		while((b=fis1.read())!=-1) { 
    			fos.write(b);
    		}
    		fis1.close();
    		FileInputStream fis2=new FileInputStream("ccc.txt");
    		int c;
    		while((c=fis2.read())!=-1) { 
    			fos.write(c);
    		}
    		fis2.close();
    		fos.close();
    	}

`多个流的整合`

public class Demo_SequenceInputStream { 
    	/** * SequenceInputStream(InputStream s1,InputStream s2); * * @param args * @throws IOException */
    	public static void main(String[] args) throws IOException { 
    		//demo1();
    		//demo2();
    		//多个序列流整合
    		FileInputStream fis1=new FileInputStream("a.txt");
    		FileInputStream fis2=new FileInputStream("b.txt");
    		FileInputStream fis3=new FileInputStream("c.txt");
    		Vector<FileInputStream> vector=new  Vector<FileInputStream>();
    		vector.add(fis1);
    		vector.add(fis2);
    		vector.add(fis3);
    		Enumeration<FileInputStream> en= vector.elements();//创建枚举，获取枚举的引用
    		SequenceInputStream sis=new SequenceInputStream(en);//传递SequenceInputStream构造
    		
    		FileOutputStream fos=new FileOutputStream("yyy.txt");
    		
    		int b;
    		while((b=sis.read())!=-1){ 
    			fos.write(b);
    		}
    		sis.close();
    		fos.close();
    	}
    
    	private static void demo2() throws FileNotFoundException, IOException { 
    		//序列流
    		FileInputStream fis1=new FileInputStream("yyy.txt");
    		FileInputStream fis2=new FileInputStream("ccc.txt");
    		SequenceInputStream sis=new SequenceInputStream(fis1, fis2);
    		FileOutputStream fos=new FileOutputStream("c.txt");
    		int b;
    		while((b=sis.read())!=-1) { 
    			fos.write(b);
    		}
    		sis.close();
    		fos.close();
    	}
    
    	private static void demo1() throws FileNotFoundException, IOException { 
    		//传统方式
    		FileInputStream fis1=new FileInputStream("yyy.txt");
    		FileOutputStream fos=new FileOutputStream("c.txt");
    		int b;
    		while((b=fis1.read())!=-1) { 
    			fos.write(b);
    		}
    		fis1.close();
    		FileInputStream fis2=new FileInputStream("ccc.txt");
    		int c;
    		while((c=fis2.read())!=-1) { 
    			fos.write(c);
    		}
    		fis2.close();
    		fos.close();
    	}
    }

> IO流 （内存输出流）

什么是内存输出流：

该输出流可以向内存中写输入数据，把内存当成一缓存区，写出之后可以一次性获取所以的数据

使用方法：

toByteArray();

toString();

例子：
    public class Demo_ByteArrayOutputStream { 
    	/** * 内存输出流 * @param args * @throws IOException */
    	public static void main(String[] args) throws IOException { 
    		//不使用ByteArrayOutputStream 读取中文
    		//demo1();
    		//使用ByteArrayOutputStream 读取中文
    		FileInputStream fis=new FileInputStream("c.txt");
    		ByteArrayOutputStream bos=new ByteArrayOutputStream();//使用内存进行存储
    		int b;
    		while((b=fis.read())!=-1) { 
    			bos.write(b);//写到内存当中
    		}
    		byte [] arr=bos.toByteArray();//将缓冲区的数据全部拿出来，赋值给arr数组
    		System.out.println(new String(arr));
    		//System.out.println("toString"+bos);
    		fis.close();
    	}
    
    	private static void demo1() throws FileNotFoundException, IOException { 
    		FileInputStream fis=new FileInputStream("c.txt");
    		byte [] arr=new byte[3];
    		int b;
    		while((b=fis.read(arr))!=-1) { 
    			System.out.println(new String(arr,0,b));
    		}
    	}
    }

内存输出流的练习题

/** * 定义一个文件输入流，调用read(byte [] b)方法， * 将a.txt文件中的内容打印出来 （byte数组大小限制为5） * @author 翁艳敏 * */
    public class Demo_test5 { 
    	public static void main(String[] args) throws IOException { 
    		// 创建文件输入流
    		FileInputStream fis=new FileInputStream("c.txt");
    		//定义一和字节数组
    		byte [] arr=new byte[5];
    		//创建内存输出流
    		ByteArrayOutputStream bos=new ByteArrayOutputStream();
    		//读取数据
    		int d;
    		while((d=fis.read(arr))!=-1) { 
    			bos.write(arr,0,d);
    		}
    		System.out.println(bos);
    		fis.close();
    	}
    }

> 随机访问流 RandomAccessFile() 了解

public class Demo_ReadomAccessFile { 
    /* * 随机读取 * 应用多线程下载 */
    
    	public static void main(String[] args) throws IOException { 
    		//例子:
    		RandomAccessFile raf=new RandomAccessFile("ccc", "rw");
    		//第2个参数为 模式 "r" ,"rw" read ,write
    		//读和写都可以
    		raf.seek(1);//在指定位置设置指针
    		raf.close();
        }
    }

> 对象操作流 ObjecOutputStream

personBean:
    package Bean;
    
    import java.io.Serializable;
    
    public class Person  implements Serializable{ //要实现这个接口
    	private  String name;
    	private  int age;
    	
    	
    
    	public Person() { 
    		super();
    		// TODO Auto-generated constructor stub
    	}
    	
    	public Person(String name, int age) { 
    		super();
    		this.name = name;
    		this.age = age;
    	}
    
    	public String getName() { 
    		return name;
    	}
    
    	public void setName(String name) { 
    		this.name = name;
    	}
    
    	public int getAge() { 
    		return age;
    	}
    
    	public void setAge(int age) { 
    		this.age = age;
    	}
    
    	@Override
    	public String toString() { 
    		return "Person [name=" + name + ", age=" + age + "]";
    	}	
    
    }
    
    public class Demo_ObjectOutputStream { 
    	/** * 序列化操作（写入） * 比如游戏就是退出时进行拿数据写到服务器上一样 * @param args * @throws IOException * @throws FileNotFoundException * @throws ClassNotFoundException */
    	public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException { 
    		/* * Person p1=new Person("weng", 22); Person p2=new Person("yan", 23); //Bean * 要实现Serializable 序列化 ObjectOutputStream oos=new ObjectOutputStream(new * FileOutputStream("c.txt")); oos.writeObject(p1); oos.writeObject(p2); * oos.close(); */
    		//反序列化，就是登陆游戏
    		ObjectInputStream ois=new ObjectInputStream(new FileInputStream("c.txt"));
    		Person p1=(Person) ois.readObject();
    		Person p2=(Person) ois.readObject();
    		System.out.println(p1);
    		System.out.println(p2);
    		ois.close();
    	}
    }

`优化对象操作`

比如，只写了2个对象，但输出了3个对象，就会报错说读取到末尾错误

使用容器

//进行优化
    		//序列化
    		Person p1=new Person("1", 23);
    		Person p2=new Person("2", 21);
    		Person p3=new Person("3", 23);
    		Person p4=new Person("4", 24);
    		//创建容器
    		ArrayList<Person> arr=new ArrayList<Person>();
    		arr.add(p1);
    		arr.add(p2);
    		arr.add(p3);
    		arr.add(p4);
    		ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("c.txt"));
    		oos.writeObject(arr);	
    		//反序列化 
    		ObjectInputStream ois=new ObjectInputStream(new FileInputStream("c.txt"));
    		ArrayList<Person> list= (ArrayList<Person>) ois.readObject();
    		for (Person person : list) { 
    			System.out.println(person);
    		}
    		oos.close();
    		ois.close();
    	}

Bean 实现了Serializable 得 最好加个ID

private static final long serialVersionUID = 1L;//生成Id号在未存档就读档的情况下可以将原因显示出来
    注意要先存档，后读档就不会有问题

> 数据输入流和输出流

DataInputStream &DatOutputStream

用法：

public static void main(String[] args) throws IOException { 
    		// 创建一个数据输出流 和对象流一样
    		//开发用的很少
    		DataOutputStream dos=new DataOutputStream(new FileOutputStream("c.txt"));
    		dos.writeInt(999);
    		dos.close();
    			DataInputStream dataInputStream=new DataInputStream(new FileInputStream("c.txt"));
    			int x= dataInputStream.readInt();
    		System.out.println(x);
    		dataInputStream.close();
    	}

> 打印流 属于字节流
> 
> \[外链图片转存失败(img-DLENGbRi-1563628520431)(C:\\Users\\11276\\AppData\\Local\\Temp\\1563411812353.png)\]

public static void main(String[] args) { 
    		//打印流 printStream
    		System.out.println("aaa");
    		PrintStream ps=System.out;//获取标记输出流
    		ps.println(97);   //转化为String 并打印 toString
    		ps.write(97);	//查找码表
    		Person person=new Person("aaa",23);
    		ps.print(person);//打印引用数据类型 如果是null 就null 反之打印toString
    		ps.close();
    	}
    //自动刷新功能(没用)
    public static void main(String[] args) throws IOException { 
    		//打印流 printStream
    		//demo1();
    		PrintWriter pw=new PrintWriter(new FileOutputStream("c.txt"),true);
    		pw.print(97);
    		pw.println(87);//代有自动刷新功能
    	}

总结下：

对象流（objectStream），打印流(printStream)，数据流(DataStream)

都类似游戏读档，和取档

比如游戏就是退出时进行拿数据（out）写到服务器上一样

登陆就要输入到服务器 (inp)

和字符流，字节流不一样

> 2种键盘录入的方法

BufferedReader br=new BufferedReader(new InputStreamReader(System.in));//可以不用关流，因为 没和键盘产生关联
    		//InputStreamReader 是字节转化为字符的桥梁
    		String lin=br.readLine();
    		System.out.println(lin);
    		br.close();
    		//2
    		Scanner sc=new Scanner(System.in);
    		String line=sc.nextLine();
    		System.out.println(line);

> IO流 （properties） 的使用

使用方法： load store 和properties 的基本用法

public class Demo_Properties { 
    
    	/** * properties 是Hashtable 的子类 * properties 基本使用都是字符串 * @param args * @throws IOException * @throws FileNotFoundException */
    	public static void main(String[] args) throws FileNotFoundException, IOException { 
    		// TODO Auto-generated method stub
    		//demo1();
    		//demo2();
    		//有关properties 的方法 ；load() store()
    		Properties prop=new Properties();
    		System.out.println("读取前"+prop);
    		prop.load(new FileInputStream("config.properties"));
    		//修改参数
    		prop.setProperty("yan", "11111");
    		//修改完要写入到文件中去
    		prop.store(new FileOutputStream("config.properties"),null);//写入的相当于是日志
    		System.out.println(prop);
    		
    	}
    
    	private static void demo2() { 
    		//保存和遍历
    		Properties prop=new Properties();
    		prop.put("1", "1");
    		prop.put("2", "2");
    		//遍历
    		Enumeration<String> en=(Enumeration<String>) prop.propertyNames();
    		while(en.hasMoreElements()) { 
    			String key=en.nextElement();
    			String val=prop.getProperty(key);
    			System.out.println(key+"="+val);
    		}
    	}
    
    	private static void demo1() { 
    		Properties prop=new Properties();
    		prop.put("abc", 1);
    		System.out.println(prop);
    	}
    }

> FIle递归练习综合

1，统计文件，和文件夹的大小

public class Demo_test6 { 
    	/** * 统计文件和文件夹的大小 * * @param args */
    	public static void main(String[] args) { 
    		// TODO Auto-generated method stub
    		File file=getFile();
    		System.out.println(sunFileSize(file));
    	}
    
    	/** * 键盘获取一个文件夹路径 * getFile() * @return */
    	public static File getFile() { 
    		// 1创建键盘录入对象
    		Scanner sc = new Scanner(System.in);
    		System.out.println("输入文件夹路径");
    		while (true) { 
    			String ScName = sc.nextLine();
    			// 封装成File
    			File file = new File(ScName);
    			if (!file.exists()) { // 不是
    				System.out.println("输入的不是文件");
    			} else if (file.isFile()) { 
    				System.out.println("输入的是文件不是文件夹");
    			} else { 
    				return file;
    			}
    		}
    	}
    	/** * 统计文件的大小 * sumFileSize */
    	public static Long sunFileSize(File file){ 
    		//定义一个求和的变量
    		Long sum=0l;
    		//获取到文件和文件夹listfiles();
    		File[] files=file.listFiles();
    		//遍历数组
    		for (File filename : files) { 
    			//进行判断是文件还是文件夹
    			if(filename.isFile()) { 
    				sum=sum+filename.length();
    			}else { 
    				sum=sum+sunFileSize(filename);//递归调用
    			}
    		}
    		return sum;		
    	}	
    }

2，File类递归删除文件夹

public class Demo_test7 {
    /**
     * 删除键盘录入的文件夹
     * 注意：删除不走回收站的,
     * 思路： 先删除文件再删除文件夹
     * 使用递归的方法
     * @param args
     */
    	public static void main(String[] args) {
    		// 获取文件夹
    		File FileName=Demo_test6.getFile();
    		//删除键盘录入的文件夹
    	}
    	public static void deleteFile(File FileName) {
    		//获取文件夹和文件
    		File [] files =FileName.listFiles();
    		for (File deletefile : files) {
    			//是文件就直接删除
    			if(deletefile.isFile()) {
    				deletefile.delete();
    			}else{
    			//是文件夹，递归调用	
    				deleteFile(deletefile);
    			}			
    		}
    		//循环完把空文件夹删除
    		FileName.delete();
    	}
    }

3，模拟拷贝文件

public class Demo_test8 { 
    /** * 模拟拷贝文件 * @param args * @throws IOException */
    	public static void main(String[] args) throws IOException { 
    		// 接收2个文件夹路径，
    		//把其中的一个文件夹中内容拷贝到另外的一个当中
    		File fz=Demo_test6.getFile();
    		File kb=Demo_test6.getFile();
    		//创建方法copy(fz,kb)
    		copy(fz, kb);
    	}
    	/** * 拷贝的方法 * copy(fz,kb) * @throws IOException */
    	public static void copy(File fz,File kb) throws IOException { 
    		//再目标文件中创建原文件夹
    		//File newDir=new File(kb, fz.getName());
    		kb=new File(kb, fz.getName());
    		int sum=1;
    		//把这个路径创建出来（*）
    		//newDir.mkdir();
    		kb.mkdir();
    		//获取源文件保存到File 数组中
    		File [] saveFile =fz.listFiles();//获得原文件中的内容
    		for (File file : saveFile) { 
    			//如果是文件就继续拷贝
    			if(file.isFile()) { 
    			//IO流
    				BufferedInputStream bis=new BufferedInputStream(new FileInputStream(file));
    				BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(new File(kb, file.getName())));
    				int b;
    				while((b=bis.read())!=-1) { 
    					bos.write(b);
    				}
    				bis.close();
    				bos.close();
    			}else { 
    				copy(file, kb);
    			}
    		}
    		System.out.println("复制完成"+sum++);
    	}
    }

4,把文件夹中的所以文件以及文件夹的名字按层级打印

import java.io.File;
    
    /** * 把文件夹中的所以文件以及文件夹的名字按层级打印 * @author 翁艳敏 * */
    public class Demo_test9 { 
    	public static void main(String[] args) { 
    		//接收一个文件夹
    		File dir= Demo_test6.getFile();
    		printFile(dir,0);
    	}
    	/** * 打印文件的层级的方法printFile(File dir) * 返回值： void * 参数：(File dir,int sum) * @param dir */
    	public static void printFile(File dir,int sum) { 
    		//获取所有文件，及文件夹
    		File [] sumFile =dir.listFiles();
    		//遍历
    		for (File file : sumFile) { 
    			for(int i=0;i<=sum;i++) { 
    				System.out.print("\t");
    			}
    			System.out.println(file);
    			if(file.isDirectory()) { 
    				printFile(file,sum+1);//不用sum++ 因为sum++ 会把原来的值也改变掉
    			}
    		}
    	}
    }
     
    output
    输入文件夹路径
    E:\test1
    	E:\test1\one.txt
    	E:\test1\test2
    		E:\test1\test2\1111.txt
    		E:\test1\test2\test22

IO流的学习就告一段落 weng

2019.7.20