Day20_IO第二天

1、IO体系总图





2、IO体系——字节流



记忆路线：输入输出流前面加File和Buffered，这样就全记住了

3、表达式解释

表达式：由变量和常量通过运算符连接起来的式子，单个的常量和变量也是表达式

4、标准代码JDK1.6之前（掌握）

1、通过标准输入输出流,一个字节一个字节拷贝文件
  1. 	/**
  2. 	 * 将source拷贝到dest中 source:源文件 dest：目标文件
  3. 	 */
  4. 	public static void copy1(String source, String dest)  {
  5. 		// 输入流
  6. 		FileInputStream fis = null;
  7. 		// 输出流
  8. 		FileOutputStream fos = null;
  9. 		try {
  10. 			fis = new FileInputStream(source);
  11. 			fos = new FileOutputStream(dest);
  12. 			// 读取到的数据
  13. 			int data;
  15. 			while ((data = fis.read()) != -1) {
  16. 				fos.write(data);
  17. 			}
  18. 		} catch (Exception e) {
  19. 			e.printStackTrace();
  20. 		} finally{
  21. 			if(fis != null){
  22. 				try {
  23. 					fis.close();
  24. 				} catch (IOException e) {
  25. 					e.printStackTrace();
  26. 				}
  27. 			}
  28. 			
  29. 			if(fos != null){
  30. 				try {
  31. 					fos.close();
  32. 				} catch (IOException e) {
  33. 					e.printStackTrace();
  34. 				}
  35. 			}
  36. 		}
  37. 	}

2、通过标准输入输出流,采用小数组的方式拷贝文件

  1. 	public static void copy2(String source, String dest)  {
  2. 		// 输入流
  3. 		FileInputStream fis = null;
  4. 		// 输出流
  5. 		FileOutputStream fos = null;
  6. 		
  7. 		
  8. 		try {
  9. 			fis = new FileInputStream(source);
  10. 			fos = new FileOutputStream(dest);
  11. 			
  12. 			//bys里存的是读取到的数据
  13. 			byte[] bys= new byte[1024];
  14. 			
  15. 			//读取了几个数据
  16. 			int len;
  17. 			
  18. 			while((len=fis.read(bys))  != -1){
  19. 				fos.write(bys, 0, len);
  20. 			}
  21. 		} catch (Exception e) {
  22. 			e.printStackTrace();
  23. 		}finally{
  24. 			if(fis != null){
  25. 				try {
  26. 					fis.close();
  27. 				} catch (IOException e) {
  28. 					e.printStackTrace();
  29. 				}
  30. 			}
  31. 			
  32. 			if(fos != null){
  33. 				try {
  34. 					fos.close();
  35. 				} catch (IOException e) {
  36. 					e.printStackTrace();
  37. 				}
  38. 			}
  39. 		}
  40. 	}


3、通过高效流和字节数组的方式拷贝文件（这个必须掌握）
  1. 	public void copy3(String source, String dest) throws Exception {
  2. 		BufferedInputStream bis = null;
  3. 		BufferedOutputStream bos = null;
  4. 		try {
  5. 			bis = new BufferedInputStream(new FileInputStream(source));
  6. 			bos = new BufferedOutputStream(new FileOutputStream(dest));
  7. 			
  8. 			byte[] bys = new byte[1024*20];
  9. 			int len;
  10. 			
  11. 			while((len=bis.read(bys)) != -1){
  12. 				bos.write(bys, 0, len);
  13. 			}
  14. 		} catch (Exception e) {
  15. 			// TODO Auto-generated catch block
  16. 			e.printStackTrace();
  17. 		}finally{
  18. 			if(bis != null){
  19. 				try {
  20. 					bis.close();
  21. 				} catch (IOException e) {
  22. 					e.printStackTrace();
  23. 				}
  24. 			}
  25. 			
  26. 			if(bos != null){
  27. 				try {
  28. 					bos.close();
  29. 				} catch (IOException e) {
  30. 					e.printStackTrace();
  31. 				}
  32. 			}
  33. 		}
  34. 		
  35. 	}


5、标准代码JDK1.7（掌握）


  1. import java.io.BufferedInputStream;
  2. import java.io.BufferedOutputStream;
  3. import java.io.FileInputStream;
  4. import java.io.FileOutputStream;
  7. public class CopyDemo {
  8. 	public static void main(String[] args) {
  9. 		/*
  10. 			格式:
  11. 				try(
  12. 					//声明输入输出流
  13. 				){
  14. 					//拷贝文件
  15. 				}catch(Exception e){
  16. 					//异常处理
  17. 				}
  18. 		 */
  19. 		try(
  20. 				BufferedInputStream bis = new BufferedInputStream(new FileInputStream(".project"));
  21. 				BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("a.txt"));
  22. 		){
  23. 			//存储读取到的数据
  24. 			byte[] data = new byte[1024*8];
  25. 			//存储读取到的数据的长度
  26. 			int len = -1;
  27. 			
  28. 			//通过read方法将数据读取到data数组中，读取了几个数据呢？读取了len个数据
  29. 			while((len=bis.read(data)) !=-1){
  30. 				bos.write(data,0,len);
  31. 			}
  32. 		}catch(Exception e){
  33. 			e.printStackTrace();
  34. 		}
  35. 	}
  36. }


5、案例(掌握)

1、将写出的字节异或上一个数,这个数就是密钥,解密的时候再次异或就可以了
2、在控制台录入文件的路径,将文件拷贝到当前项目下
3、将键盘录入的数据拷贝到当前项目下的text.txt文件中,键盘录入数据当遇到quit时就退出


6、案例代码(掌握)

1、将写出的字节异或上一个数,这个数就是密钥,解密的时候再次异或就可以了
  1. package com.heima.test;
  3. import java.io.BufferedInputStream;
  4. import java.io.BufferedOutputStream;
  5. import java.io.FileInputStream;
  6. import java.io.FileNotFoundException;
  7. import java.io.FileOutputStream;
  8. import java.io.IOException;
  10. public class Test1 {
  12. 	/**
  13. 	 * @param args
  14. 	 * @throws IOException 
  15. 	 * 将写出的字节异或上一个数,这个数就是密钥,解密的时候再次异或就可以了
  16. 	 */
  17. 	public static void main(String[] args) throws IOException {
  18. 		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("copy.jpg"));
  19. 		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy2.jpg"));
  20. 		
  21. 		int b;
  22. 		while((b = bis.read()) != -1) {
  23. 			bos.write(b ^ 123);
  24. 		}
  25. 		
  26. 		bis.close();
  27. 		bos.close();
  28. 	}
  30. }

2、在控制台录入文件的路径,将文件拷贝到当前项目下
  1. package com.heima.test;
  3. import java.io.BufferedInputStream;
  4. import java.io.BufferedOutputStream;
  5. import java.io.File;
  6. import java.io.FileInputStream;
  7. import java.io.FileNotFoundException;
  8. import java.io.FileOutputStream;
  9. import java.io.IOException;
  10. import java.util.Scanner;
  12. public class Test2 {
  14. 	/**
  15. 	 * 在控制台录入文件的路径,将文件拷贝到当前项目下
  16. 	 * 
  17. 	 * 分析:
  18. 	 * 
  19. 	 * 1,定义方法对键盘录入的路径进行判断,如果是文件就返回
  20. 	 * 2,在主方法中接收该文件
  21. 	 * 3,读和写该文件
  22. 	 * @throws IOException 
  23. 	 */
  24. 	public static void main(String[] args) throws IOException {
  25. 		File file = getFile();					//获取文件
  26. 		BufferedInputStream  bis = new BufferedInputStream(new FileInputStream(file));
  27. 		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file.getName()));
  28. 		
  29. 		int b;
  30. 		while((b = bis.read()) != -1) {
  31. 			bos.write(b);
  32. 		}
  33. 		
  34. 		bis.close();
  35. 		bos.close();
  36. 	}
  38. 	/*
  39. 	 * 定义一个方法获取键盘录入的文件路径,并封装成File对象返回
  40. 	 * 1,返回值类型File
  41. 	 * 2,参数列表无
  42. 	 */
  43. 	public static File getFile() {
  44. 		Scanner sc = new Scanner(System.in);				//创建键盘录入对象
  45. 		System.out.println("请输入一个文件的路径:");
  46. 		while(true) {
  47. 			String line = sc.nextLine();					//接收键盘录入的路径
  48. 			File file = new File(line);						//封装成File对象,并对其进行判断
  49. 			if(!file.exists()) {
  50. 				System.out.println("您录入的文件路径不存在,请重新录入:");
  51. 			}else if(file.isDirectory()) {
  52. 				System.out.println("您录入的是文件夹路径,请重新录入:");
  53. 			}else {
  54. 				return file;
  55. 			}
  56. 		}
  57. 	}
  58. }
3、将键盘录入的数据拷贝到当前项目下的text.txt文件中,键盘录入数据当遇到quit时就退出
  1. package com.heima.test;
  3. import java.io.FileNotFoundException;
  4. import java.io.FileOutputStream;
  5. import java.io.IOException;
  6. import java.util.Scanner;
  8. public class Test3 {
  10. 	/**
  11. 	 * 将键盘录入的数据拷贝到当前项目下的text.txt文件中,键盘录入数据当遇到quit时就退出
  12. 	 * 
  13. 	 * 分析:
  14. 	 * 1,创建键盘录入对象
  15. 	 * 2,创建输出流对象,关联text.txt文件
  16. 	 * 3,定义无限循环
  17. 	 * 4,遇到quit退出循环
  18. 	 * 5,如果不quit,就将内容写出
  19. 	 * 6,关闭流
  20. 	 * @throws IOException 
  21. 	 */
  22. 	public static void main(String[] args) throws IOException {
  23. 		//1,创建键盘录入对象
  24. 		Scanner sc = new Scanner(System.in);
  25. 		//2,创建输出流对象,关联text.txt文件
  26. 		FileOutputStream fos = new FileOutputStream("text.txt");
  27. 		System.out.println("请输入数据:");
  28. 		//3,定义无限循环
  29. 		while(true) {
  30. 			String line = sc.nextLine();					//将键盘录入的数据存储在line中
  31. 			//4,遇到quit退出循环
  32. 			if("quit".equals(line)) {
  33. 				break;
  34. 			}
  35. 			//5,如果不quit,就将内容写出
  36. 			fos.write(line.getBytes());						//字符串写出必须转换成字节数组
  37. 			fos.write("\r\n".getBytes());
  38. 		}
  39. 		//6,关闭流
  40. 		fos.close();
  41. 	}

  44. }
方式2
  1. public class Demo2 {
  2. 	public static void main(String[] args)throws Exception {
  3. 		Scanner sc = new Scanner(System.in);
  4. 		String line;
  5. 		FileOutputStream fos = new FileOutputStream("record.txt");
  6. 		
  7. 		//如果输入的不是quite就将用户输入的信息写入到文本文件里面
  8. 		while(!(line=sc.nextLine()) .equals("quite")){
  9. 			fos.write(line.getBytes());
  10. 			//System.getProperty("line.separator")获取换行符
  11. 			fos.write(System.getProperty("line.separator").getBytes());
  12. 		}
  13. 		fos.close();
  14. 	}
  15. }

7、今天必须掌握的内容，面试题，笔试题。

1、说说字节流体系
2、说说以下代码怎么念
int data;
 
while ((data = fis.read()) != -1) {
fos.write(data);
}

3、说说以下段代码怎么念
byte[] data = new byte[1024*8];
int len = -1;
while((len=bis.read(data)) !=-1){
    bos.write(data,0,len);
}

3、flush和close区别 
flush用来刷新缓冲区的,刷新后可以再次写出,即flush后流仍然可以使用
close用来关闭流释放资源的的,如果是带缓冲区的流对象的close()方法,不但会关闭流,还会再关闭流之前刷新缓冲区,关闭后不能再写出,即不能再使用该流
4、说说字节流文件拷贝：定义小数组和不定义小数组的原理
5、高效字节流结合小数组拷贝文件的两种标准代码(JDK1.7以前和JDK1.7以后)
6、练习：从控制台录入数据将数据写入到a.txt中,直到输入quite程序停止。当程序下次启动时可以继续向a.txt中追加数据

7、有五个学生，每个学生有3门课（语文、数学、英语）的成绩，写一个程序接收从键盘输入学生的信息，输入格式为：name,30,30,30（姓名，三门课成绩），然后把输入的学生信息按总分从高到低的顺序写入到一个名称"stu.txt"文件中


























posted on 2016-12-23 09:54  虫虫爬啊爬  阅读(235)  评论(0)  编辑  收藏  举报

导航