速（尚）学堂第十章IO技术章末作业自写答案

最新推荐文章于 2021-11-28 22:59:27 发布

家有可爱多呢

最新推荐文章于 2021-11-28 22:59:27 发布

阅读量1.2k

点赞数

文章标签： java eclipse 编程语言乱码

本文链接：https://blog.csdn.net/ManPi24/article/details/104573287

版权

速（尚）学堂第十章IO技术章末作业自写答案

第四次在CSDN发文章，正在学JAVA，学习了第十章IO技术后，对章末作业做了解答，全部手工自己写的，选择题也有一些自己的看法，编码题的话，注释不能写太多不然会显得比较杂乱，如果有大家哪里有疑惑的话可以私信我，大神勿喷哦，嘻嘻！

选择题
1.B //在使用Java IO流实现对文本文件的读写过程中，需要处理的是IOException异常，IOException又有很多子类异常，如FileNotFoundException、FileExistsException等，故选择B答案。
2.BD //在Java的IO操作中，使用flush()方法可以实现手动刷新，每一次都可以将缓冲容器的内容刷新出来。在每次关闭I输出的时候，调用close()方法的时候系统内部也会自动调用一次flush()方法，故答案选BD。
3.B //Reader类提供了read()方法，读取单个字符到输入流中，没有提供read(int n)的重载。Writer类提供了write(int n)方法，表示向输出流中写入字节数为n的某单个字符；还提供了write(String s)的重载，表示向输出流中写入字符串s。故选B答案。
4.C //在java中路径分隔符有两种表示：第一种使用反斜杠“\”表示路径分隔符时，需要加上一个转义符号“\”，即用两个反斜杠(\\)才能表示路径分隔符；第二种就是用正斜杠“/”，一个正斜杠就可表示路径分隔符，故语句2有错。FileWriter是OutputStreamWriter的子类，里面并没有提供writerToEnd(String s)的方法，故语句3有错。综上，该程序有两处错误，分别为语句2和语句3，选C。
5.D //在使用IO流（除字节数组流外）时，需要在使用完以后关闭IO流，原则“后进先关，从外到内”，最后关闭流的时候，会有一个异常要处理，要么手动处理，要么直接抛出，否则会有编译错误，故语句4有错，选D答案。

编码题

实现字节数组和任何基本类型和引用类型执行的相互转换
提示：使用ByteArrayInutStream和ByteArrayOutputStream。

package FinalTest;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 * 1. 实现字节数组和任何基本类型和引用类型执行的相互转换 
 * 提示：使用ByteArrayInputStream和ByteArrayOutputStream。
 * 
 * @author 皮
 *
 */
public class FinalTest01 {

	public static void main(String[] args) {
		convertTest1();
		System.out.println();
		convertTest2();
		System.out.println();
		convertTest3();
	}
	public static void convertTest1() {
		
		String str = "黑曼巴";
		byte[] b1 = str.getBytes();//字符串转换为字节数组，为bais获取源数组
		StringBuilder sb = new StringBuilder("[");
		for(byte b:b1) {
			sb.append(b+"，");
		}
		sb.setCharAt(sb.length()-1, ']');
		System.out.println("字符串“黑曼巴”转为字节数组为："+sb);
		ByteArrayInputStream bais = new ByteArrayInputStream(b1);
		
		byte[] flush = new byte[1024];//缓冲容器，暂存数据
		int len=-1;
		try {//字节数组转换为字符串
			while((len=bais.read(flush))!=-1) {
				String msg = new String(flush,0,len,"gbk");//指定字符集，以防乱码
				System.out.println("将字节数组还原为字符串为："+msg);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		
	}
	//自定义类转、字节数组相互转换
	public static void convertTest2() {
		Kobe k = new Kobe("科比布莱恩特", 24);
		
		ByteArrayOutputStream baos = null;
		ObjectOutputStream oos = null;
		
		ByteArrayInputStream bais = null;
		ObjectInputStream ois = null;
		try {
			baos = new ByteArrayOutputStream();
			oos = new ObjectOutputStream(baos);
			oos.writeObject(k);//自定义类写到字节数组
			StringBuilder sb = new StringBuilder("[");
			for(byte b:baos.toByteArray()) {
				sb.append(b+"，");
			}
			sb.setCharAt(sb.length()-1, ']');
			System.out.println("自定义类Kobe转换为字节数组为："+sb);
			bais = new ByteArrayInputStream(baos.toByteArray());
			ois = new ObjectInputStream(bais);
			if(k instanceof Kobe) {
				Kobe kk;
				try {//字节数组读取到程序，即又还原为自定义类
					kk = (Kobe)ois.readObject();
					System.out.println("将字节数组还原成自定义类："+kk.getName()+kk.getNumber());
				} catch (ClassNotFoundException e) {
					e.printStackTrace();
				}
			}
		} catch (IOException e1) {
			e1.printStackTrace();
		}finally {//应该先关闭最外层的包装流，即“后开的先关闭”
			if(ois!=null) {
				try {
					ois.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(bais!=null) {
				try {
					bais.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(oos!=null) {
				try {
					oos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(baos!=null) {
				try {
					baos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

	public static void convertTest3() {
		int i = 24;
		char c = 'k';
		boolean b = true;
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		DataOutputStream dos = new DataOutputStream(baos);
		try {
			dos.writeInt(i);
			dos.writeChar(c);
			dos.writeBoolean(b);
			StringBuilder sb = new StringBuilder("[");
			for(byte bb:baos.toByteArray()) {
				sb.append(bb+"，");
			}
			sb.setCharAt(sb.length()-1, ']');
			System.out.println("这几个基本数据类型转换字节数组为："+sb);
			ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
			DataInputStream dis = new DataInputStream(bais);
			int i1 = dis.readInt();
			char c1 = dis.readChar();
			boolean b1 = dis.readBoolean();
			System.out.println("将字节数组还原为几个数据类型后为："+i1+"，"+c1+"，"+b1);
			
		} catch (IOException e) {
			e.printStackTrace();
		}
		
	}
}
class Kobe implements java.io.Serializable{
	private String name;
	private int number;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getNumber() {
		return number;
	}
	public void setNumber(int number) {
		this.number = number;
	}
	public Kobe() {
	}
	public Kobe(String name, int number) {
		super();
		this.name = name;
		this.number = number;
	}
	
}

运行结果：

2.这道题还是很有意思的，如果想要进步，真的需要自己从头写到尾，因为也是初学者，所以是根据自己的逻辑来写的，功能能实现，但是没有做进一步的完善和处理一些情况，注释也写不了太多，如果有不懂且需要帮助的小伙伴，请私信我吧，我再详细解释一下为啥这样写。

package FinalTest;

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

/**目录我自己改了
 *  2. 复制文件夹"C:\\JAVAfile测试\\JAVA目录2"下面所有文件和子文件夹内容到"C:\\JAVAfile测试"
 *  提示：涉及单个文件复制、目录的创建、递归的使用
 * @author 皮
 *
 */
public class FinalTest02 {
	public static void main(String[] args) {
		copy(new File("C:\\JAVAfile测试\\JAVA目录2"), new File("C:\\JAVAfile测试"));
	}
	//将src目录下的所有文件目录拷贝到dest中，只实现了拷贝已存在目录的功能，还没有进一步完善
	public static void copy(File src, File dest) {
		File firstFile = dest;// 先产生一个文件对象，目标文件夹的位置
		for (File f : src.listFiles()) {// 获取目录的子孙级文件对象
			if (f.isDirectory()) {// 如果下一级是目录，则将该目录用文件对象记录下来
				String dirName = f.getName();
				
				File dirFile = new File(firstFile, dirName);
				if (!(dirFile.exists())) {// 如果该目录在dest中不存在，则创建它
					dirFile.mkdirs();
				}
				copy(f, src.getParentFile());// 递归调用，需思考一下写哪个文件对象做参数
			}
			if (f.isFile()) {// 如果遍历了是文件的话则直接读取他并写出他，即单个文件的复制
				FileInputStream fis = null;
				FileOutputStream fos = null;
				try {
					fis = new FileInputStream(f);// 输出流，源为该文件
					fos = new FileOutputStream(firstFile.getAbsolutePath() + File.separator + f.getName());// 输入流，输入到目标文件夹并且要包含该文件
					byte[] flush = new byte[1024 * 10];
					int len;
					try {
						while ((len = fis.read(flush)) != -1) {
							fos.write(flush, 0, len);
							fos.flush();
						}
					} catch (IOException e) {
						e.printStackTrace();
					}
				} catch (FileNotFoundException e) {
					e.printStackTrace();
				} finally {
					if (fos != null) {
						try {
							fos.close();
						} catch (IOException e) {
							e.printStackTrace();
						}
					}
					if (fis != null) {
						try {
							fis.close();
						} catch (IOException e) {
							e.printStackTrace();
						}
					}
				}

			}
		}
	}
}

运行结果：

3.

package FinalTest;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;

package FinalTest;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;

/**目录自己改了
 * 3. 使用IO包中的类读取“C:\JAVAfile测试”中的FinalTest03.txt文本文件的内容，
 * 每次读取一行内容，
 * 将每行作为一个输入放入ArrayList的泛型集合中
 * 并将集合中的内容使用加强for进行输出显示。
 * @author 皮
 *
 */
public class FinalTest03 {
	public static void main(String[] args) {
		File src = new File("C:/JAVAfile测试/FinalTest03.txt");
		InputStreamReader isr = null;
		BufferedReader r = null;
		try {
			isr = new InputStreamReader(new FileInputStream(src),"gbk");
			r = new BufferedReader(isr);
			List<String> list = new ArrayList<>();
			String data = "";
			try {
				while((data=r.readLine())!=null) {
					list.add(data);//list将读取出的一行添加进去
					System.out.println(data);
				}
				System.out.println();
				System.out.println("以下是对list容器的遍历结果：");
				for(String s:list) {
					System.out.println(s);
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (UnsupportedEncodingException e1) {
			e1.printStackTrace();
		}finally {//应该先关闭最外层的包装流，即“后开的先关闭”
			if(r!=null) {
				try {
					r.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(isr!=null) {
				try {
					isr.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		
	}
}