java学习之路 之 IO流-练习题

package com.atguigu.javae.io;

import java.io.FileReader;
import java.io.IOException;

import org.junit.Test;

public class IOTest {
	
	@Test
	public void testReader() {
		// 1) 声明流对象引用,并赋值为null;
		FileReader fReader = null;
		// 2) try catch finally
		try {
			// 5) 创建流对象, 建立通道
			fReader = new FileReader("一个文本文件"); // 尝试从当前目录下开始找这个文件
			// 6) 通过流对象,处理数据
			int ch = fReader.read();
			while (ch != -1) {
				// 1) 处理已经读到的数据
				System.out.print((char)ch); // 如果包含换行, 也能正确处理
				// 2) 继续读后面的数据, 直到-1为止
				ch = fReader.read();
			}
		} catch (Exception e) {
			// 4) 处理异常
			e.printStackTrace();
		} finally {
			// 3) 关闭流对象
			if (fReader != null) {
				try {
					fReader.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

class FileCopy {
	// 使用文件流完成文件的复制，每一次读取一个字节
	@Test
	public void test() {
		
		FileReader fr = null;
		FileWriter fw = null;
		
		try {
			fr = new FileReader("./src/com/atguigu/javase/io/Filecopy.java");
			fw = new FileWriter("Filecopy.java.bak");
			
			int ch = fr.read();
			while (ch != -1) {
				fw.write(ch);
				ch = fr.read();
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (fr != null) {
				try {
					fr.close();
				} catch (Exception e2) {
				}
			}
			if (fw != null) {
				try {
					fw.close();
				} catch (Exception e2) {
				}
			}
		}
	}
}

class IOTest {
	// 使用问件输入流 读取文件内容，并给没行前加上行号，然后在控制台打印输出，
	public static void main(String[] args) {
		FileReader fr = null;
		
		try {
			fr = new FileReader("./src/com/atguigu/javase/io/IOTest.java");
			char[] buf = new char[100]; 
			int ch = fr.read(buf);
			System.out.println(buf);
			int count = 1;
			System.out.print(count++ + " ");
			while (ch != -1) {
				for (int i = 0; i < ch; i++) {
					System.out.print(buf[i]);
					if (buf[i] == '\n') {
						System.out.print(count++ + " ");
					} 
				}
				ch = fr.read(buf);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (fr != null) {
				try {
					fr.close();
				} catch (Exception e2) {
				}
			}
		}
	}
}

class TestCopy {

	public static void main(String[] args) {
		FileReader fReader = null;
		FileWriter fWriter = null;
		// 使用文件流完成文件的复制，每一次读取100个字节
		try {
			fReader = new FileReader("./src/com/atguigu/javase/io/TestCopy.java");
			fWriter = new FileWriter("TestCopy.java.bak");
			
			char[] buf = new char[100];
			int realCount = fReader.read(buf);
			
			while(realCount != -1) {
				fWriter.write(buf, 0, realCount);
				realCount = fReader.read(buf);
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (fReader != null) {
				try {
					fReader.close();
				} catch (Exception e2) {
				}
			}
			if (fWriter != null) {
				try {
					fWriter.close();
				} catch (Exception e) {
				}
			}
		}
	}
}

class TestFileCopy2 {
	// 使用缓冲流完成文件的复制
	public static void main(String[] args) {
		FileReader fReader = null;
		BufferedReader bReader = null;
		FileWriter fWriter = null;
		BufferedWriter bWriter = null;
		
		try {
			fReader = new FileReader("./src/com/atguigu/javase/io/TestCopy.java");
			bReader = new BufferedReader(fReader);
			fWriter = new FileWriter("TestFileCopy2.java.bak2");
			bWriter = new BufferedWriter(fWriter);
			
			String line = bReader.readLine();
			while (line != null) {
				
				bWriter.write(line);
				bWriter.newLine();
				line = bReader.readLine();
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (bReader != null) {
				try {
					bReader.close();
				} catch (Exception e2) {
				}
			}
			if (bWriter != null) {
				try {
					bWriter.close();
				} catch (Exception e2) {
					// TODO: handle exception
				}
			}
		}
	}
}

package com.atguigu.javase.io;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Set;
import java.util.TreeSet;

import org.junit.Test;

public class Work {
	
	@Test
	public void work6() {
		//把xmlstudy文件中的内容的重复的行去掉, 并对行进行从小到大排序后 写入新文件xmlstudy2中, 验证文件中有没有去掉空行,并且排序
		FileReader fileReader = null;
		BufferedReader bufferedReader = null;
		FileWriter fileWriter = null;
		BufferedWriter bufferedWriter = null;
		try {
			fileReader = new FileReader(new File("xmlstudy"));
			bufferedReader = new BufferedReader(fileReader);
			fileWriter = new FileWriter(new File("xmlstudy2"));
			bufferedWriter = new BufferedWriter(fileWriter);
			
			Set<String> set = new TreeSet<String>();
			String line = null;
			while ((line = bufferedReader.readLine()) != null) {
				set.add(line);
			}
			for (String string : set) {
				bufferedWriter.write(string);
				bufferedWriter.newLine();
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		} finally {
			try {
				bufferedReader.close();
			} catch (Exception e2) {
				// TODO: handle exception
			}
			try {
				bufferedWriter.close();
			} catch (Exception e2) {
				// TODO: handle exception
			}
		}
	}
	
	@Test
	public void work1() {
		// 使用Object输入输出流,写入50个100以内的随机整数, 再读出来打印输出
		FileOutputStream fos = null;
		BufferedOutputStream bos = null;
		ObjectOutputStream oos = null;
		try {
			fos = new FileOutputStream("50个随机数");
			bos = new BufferedOutputStream(fos);
			oos = new ObjectOutputStream(bos);
			for (int i = 0; i < 50; i++) {
				oos.writeInt((int)(Math.random() * 100));
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				oos.close();
			} catch (Exception e2) {
			}
		}
	}
	
	@Test
	public void work2() {
		FileInputStream fis = null;
		BufferedInputStream bis = null;
		ObjectInputStream ois = null;
		try {
			fis = new FileInputStream("50个随机数");
			bis = new BufferedInputStream(fis);
			ois = new ObjectInputStream(bis);
			for (int i = 0; i < 50; i++) {
				System.out.println(ois.readInt());
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				ois.close();
			} catch (Exception e2) {
			}
		}
	}
			
	//扩展 写入随机个100以内的随机整数, 再全部读出来打印输出
	@Test
	public void work3() {
		// 使用Object输入输出流,写入50个100以内的随机整数, 再读出来打印输出
		FileOutputStream fos = null;
		BufferedOutputStream bos = null;
		ObjectOutputStream oos = null;
		try {
			fos = new FileOutputStream("随机个随机数");
			bos = new BufferedOutputStream(fos);
			oos = new ObjectOutputStream(bos);
			int rand = (int)(Math.random() * 50);
			oos.writeInt(rand);
			for (int i = 0; i < rand; i++) {
				oos.writeInt((int)(Math.random() * 100));
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				oos.close();
			} catch (Exception e2) {
			}
		}
	}
	
	@Test
	public void work4() {
		FileInputStream fis = null;
		BufferedInputStream bis = null;
		ObjectInputStream ois = null;
		try {
			fis = new FileInputStream("随机个随机数");
			bis = new BufferedInputStream(fis);
			ois = new ObjectInputStream(bis);
			int count = ois.readInt();
			for (int i = 0; i < count; i++) {
				System.out.println(ois.readInt());
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				ois.close();
			} catch (Exception e2) {
			}
		}
	}
}

package com.atgiugu.javase.io;

import java.io.FileReader;
import java.io.FileWriter;

public class FileCopy {
	
	public static void main(String[] args) {
		// 把FileCopy.java复制成FileCopy.java.bak
		FileReader fReader = null;
		FileWriter fWriter = null;
		try {
			fReader = new FileReader("./src/com/atgiugu/javase/io/FileCopy.java");
			fWriter = new FileWriter("FileCopy.java.bak");
			int ch = fReader.read();
			while (ch != -1) {
				// 1) 处理已经读到的数据
				fWriter.write(ch);
				// 2) 继续读后面的数据,直到-1
				ch = fReader.read();
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (fReader != null) {
				try {
					fReader.close();
				} catch (Exception e2) {
				}
			}
			
			if (fWriter != null) {
				try {
					fWriter.close();
				} catch (Exception e2) {
				}
			}
		}
	}
}	

package com.atgiugu.javase.io;

import java.io.FileReader;
import java.io.FileWriter;

public class TextFileCopy {
	
	public static void main(String[] args) {
		//编写程序TextFileCopy.java，在测试方法中，将TextFileCopy.java复制为TextFileCopy.java.bak文件；
		FileReader fReader = null;
		FileWriter fWriter = null;
		try {
			//fReader = new FileReader("真的爱你.mp3"); 不可以处理二进制文件
			//fWriter = new FileWriter("真的不爱你.mp3");
			fReader = new FileReader("TextFileCopy.java");
			fWriter = new FileWriter("TextFileCopy.java.bak");
			char[] buf = new char[100];
			int realCount = fReader.read(buf);
			while (realCount != -1) {
				// 1) 处理已经读到的数据
				fWriter.write(buf, 0, realCount);
				// 2) 继续读后面的数据
				realCount = fReader.read(buf);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (fReader != null) {
				try {
					fReader.close();
				} catch (Exception e2) {
				}
			}
			if (fWriter != null) {
				try {
					fWriter.close();
				} catch (Exception e2) {
				}
			}
		}
	}
}

package com.atguigu.javase.work;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

import org.junit.Test;

public class HomeWork {
	
	//请把学生名与考试分数录入到Map中，并按分数显示前三名成绩学员的名字。
	@Test
	public void work1() {
		Map<String, Integer> map = new HashMap<String, Integer>();
		map.put("小明", 80);
		map.put("小花", 70);
		map.put("小丽", 60);
		map.put("小强", 100);
		map.put("小伟", 99);
		map.put("小刚1", 100);
		map.put("小刚2", 100);
		map.put("小刚3", 100);
		map.put("小刚4", 100);
		map.put("小刚5", 100);
		
		Set<String> nameSet = map.keySet();
		String[] nameArr = nameSet.toArray(new String[0]);
		for (int i = 0; i < nameArr.length - 1; i++) {
			for (int j = 0; j < nameArr.length - 1 - i; j++) {
				if (map.get(nameArr[j]) > map.get(nameArr[j + 1])) {
					String tmp = nameArr[j];
					nameArr[j] = nameArr[j + 1];
					nameArr[j + 1] = tmp;
				}
			}
		}
		Set<Integer> high3 = new TreeSet<Integer>();
		for (int i = nameArr.length - 1; i >= 0 ; i--) {
			if (high3.size() == 3) {
				break;
			}
			high3.add(map.get(nameArr[i]));
		}
		List<Integer> high3List = new ArrayList<Integer>();
		high3List.addAll(high3);
		int no1count = 0;
		int no2count = 0;
		for (int i = nameArr.length - 1; i >= 0 ; i--) {
			if (map.get(nameArr[i]) == high3List.get(2)) {
				System.out.println(nameArr[i] + " : " + high3List.get(2));
				no1count++; // 最高分个数++
			} else if (map.get(nameArr[i]) == high3List.get(1)) {
				if (no1count >= 3) { // 如果是最高分个数已经大于3 中断第二高分的同学的打印
					break;
				}
				System.out.println(nameArr[i] + " : " + high3List.get(1));
				no2count++; // 第二高分计数
			} else if (map.get(nameArr[i]) == high3List.get(0)) {
				if (no1count + no2count >= 3) {
					break;
				}
				System.out.println(nameArr[i] + " : " + high3List.get(0));
			}
		}
		//System.out.println(nameArr[nameArr.length - 1] + " : " + map.get(nameArr[nameArr.length - 1]));
		//System.out.println(nameArr[nameArr.length - 2] + " : " + map.get(nameArr[nameArr.length - 2]));
		//System.out.println(nameArr[nameArr.length - 3] + " : " + map.get(nameArr[nameArr.length - 3]));
	}
	
	@Test
	public void work2() {
		Map<String, Integer> map = new HashMap<String, Integer>();
		map.put("小明", 80);
		map.put("小花", 70);
		map.put("小丽", 60);
		map.put("小强", 100);
		map.put("小伟", 99); // 99小伟
		map.put("小刚", 100);// 100小刚
		
		List<String> list = new ArrayList<String>();
		Set<String> name = map.keySet();
		for (String n : name) {
			int score = map.get(n);
			list.add((char)score + n);
		}
		Collections.sort(list);
		Collections.reverse(list);
		System.out.println((int)list.get(0).charAt(0) + " : " + list.get(0).substring(1));
		System.out.println((int)list.get(1).charAt(0) + " : " + list.get(1).substring(1));
		System.out.println((int)list.get(2).charAt(0) + " : " + list.get(2).substring(1));
	}
}


package com.guigu.javase.Object;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStreamWriter;
import java.io.RandomAccessFile;
import java.io.Serializable;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

import org.junit.Test;

@SuppressWarnings("serial")
class Student implements Serializable{
	
	private int id;
	private String name;
	private double score;
	
	public Student() {
	}

	public Student(int id, String name, double score) {
		super();
		this.id = id;
		this.name = name;
		this.score = score;
	}

	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", score=" + score
				+ "]";
	}
}

public class IOTest {
	// 使用对象流将，存有3个学生对象的Set集合对象，写如文件“对象序列化文件”
	@Test
	public void test1() {
		FileOutputStream fos = null;
		ObjectOutputStream oos = null;
		
		try {
			fos = new FileOutputStream("对象序列化文件");
			oos = new ObjectOutputStream(fos);
			
			Student s1 = new Student(1, "小明", 90);
			Student s2 = new Student(2, "小红", 89);
			Student s3 = new Student(3, "小丽", 98);
			
			Set<Student> set = new HashSet<Student>();
			set.add(s1);
			set.add(s2);
			set.add(s3);
			
			oos.writeObject(set);
			
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				oos.close();
			} catch (Exception e2) {
			}
		}
	}
	
	// 将上述文件内的对象读取出来并在控制台打印输出
	@Test
	public void test2() {
		FileInputStream fis = null;
		ObjectInputStream ois = null;
		
		try {
			fis = new FileInputStream("对象序列化文件");
			ois = new ObjectInputStream(fis);
			
			@SuppressWarnings("unchecked")
			Set<Student> set = (Set<Student>)ois.readObject(); 
			Iterator<Student> iterator = set.iterator();
			while (iterator.hasNext()) {
				System.out.println(iterator.next());
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		} finally {
			try {
				ois.close();
			} catch (Exception e2) {
				// TODO: handle exception
			}
		}
	}
	
	// 使用转换流将几个字符串以UTF8编码写入“转换流写文件”文件中
	@Test
	public void test3() {
		FileOutputStream fis = null;
		OutputStreamWriter osw = null;
		
		try {
			fis = new FileOutputStream("转换流写文件");
			osw = new OutputStreamWriter(fis,"UTF8");
			
			osw.write("abdcssd\n");
			osw.write("你管我写什么?");
			osw.write(10);
			osw.write("哈哈哈!!");
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		} finally {
			try {
				osw.close();
			} catch (Exception e2) {
			}
		}
	}
	
	// 使用转换流将“转换流写文件”中的字符串按照UTF8格式读出来并在控制台上打印输出
	@Test
	public void test4() {
		FileInputStream fis = null;
		InputStreamReader isr = null;
		
		try {
			fis = new FileInputStream("转换流写文件");
			isr = new InputStreamReader(fis,"UTF8");
			
			int count = isr.read();
			while (count != -1) {
				
				System.out.print((char)count);
				count = isr.read();
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		} finally {
			try {
				isr.close();
			} catch (Exception e2) {
				// TODO: handle exception
			}
		}
	}
	
	获取键盘输入的字符串，并在控制台打印输出，若不是数字则提示
	@Test
	public void test5() {
		InputStreamReader isr = null;
		BufferedReader brReader = null;
		FileWriter fw = null;
		BufferedWriter brWriter = null;
		try {
			isr = new InputStreamReader(System.in); //转换流获取键盘输入的字符串
			brReader = new BufferedReader(isr); // 缓冲流
			fw = new FileWriter("nums.txt");  // 文件输出流
			brWriter = new BufferedWriter(fw); // 缓冲流
			
			for (int i = 0; i < 10;i++) {
				String num = brReader.readLine();
				try {
					Double.parseDouble(num);
					brWriter.write(num);
					brWriter.newLine();
				} catch (NumberFormatException e) {
					System.out.println("输入数字错误!!");
					i--;
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				brReader.close();
			} catch (Exception e2) {
			}
			try {
				brWriter.close();
			} catch (Exception e2) {
			}
		}
	}
	
	// 随机访问文件类练习
	@Test
	public void test6() {
		RandomAccessFile raf = null;
		try {
			raf = new RandomAccessFile("随机访问文件", "rw");
			for (int i = 0; i < 26; i++) {
				raf.write('a' + i);
			}
			raf.seek(0);
			for (int i = 0; i < 10; i++) {
				raf.write('A' + i);
			}
			raf.seek(raf.length() - 10);
			for (int i = 0; i < 10; i++) {
				raf.write('0' + i);
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		} finally {
			try {
				raf.close();
			} catch (Exception e2) {
			}
		}
	}
	
	// File类的练习
	@Test
	public void test7() {
		File file = new File(".");
		File file1 = new File("xxx");
		
		String[] childFileName = file.list();
		for (int i = 0; i < childFileName.length; i++) {
			System.out.println(childFileName[i]);
		}
		
		file1.mkdir();
		File file2 = new File("xxx/file.info");
		FileWriter fWriter = null;
		try {
			fWriter = new FileWriter(file2);
			File[] childFiles = file.listFiles();
			for (int i = 0; i < childFiles.length; i++) {
				fWriter.write(childFiles[i].getName() + ",");;
				fWriter.write(childFiles[i].length() + "\n");;
				System.out.print(childFiles[i].getAbsolutePath());
				System.out.println(childFiles[i].length());
			}
		} catch (Exception e) {
			// TODO: handle exception
		} finally {
			try {
				fWriter.close();
			} catch (Exception e2) {
				// TODO: handle exception
			}
		}
		
	}
}


package com.atguigu.javase.io;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
import java.io.RandomAccessFile;
import java.io.Serializable;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

import org.junit.Test;

class Person implements Serializable {
	
	private static final long serialVersionUID = -402328197027L;

	public static int no = 100; // 静态属性不可以被序列化
	
	private String name;
	private transient int age; // transient是短暂的,瞬时的. 这个属性也不能被序列化
	private String gender;
	//private double weight;
	
	public Person() {
	}

	public Person(String name, int age, String gender) {
		super();
		this.name = name;
		this.age = age;
		this.gender = gender;
	}

	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", gender=" + gender
				+ "]";
	}
	
}

/**
 * 写一个Student类 ,包含属性 id, name, score
 * 序列化一个包含3个对象的数组, 再序列化一个包含4个对象的List集合
 * 再反序列化,打印输出
 */
public class IOTest {
	
	@Test
	public void exer5() {
		// 创建目录xxx
		File file = new File("xxx");
		file.mkdir();
		// 列出当前目录下的所有子文件和子目录, 把文件的文件名和文件长度信息写入文件xxx/file.info中
		File currentDir = new File(".");
		File[] childFiles = currentDir.listFiles();
		FileWriter fileWriter = null;
		try {
			fileWriter = new FileWriter("xxx/file.info");
			for (int i = 0; i < childFiles.length; i++) {
				System.out.println(childFiles[i]);
				fileWriter.write(childFiles[i].getName() + "," + childFiles[i].length());
				fileWriter.write(10);
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		} finally {
			try {
				fileWriter.close();
			} catch (Exception e2) {
				// TODO: handle exception
			}
		}
		
	}
	
	@Test
	public void testFile2() throws IOException {
		File file = new File("abc");
		System.out.println("file.mkdir():" + file.mkdir());
		System.out.println("file.canRead():" + file.canRead());
		System.out.println("file.getAbsolutePath():" + file.getAbsolutePath());
		System.out.println("file.getFreeSpace():" + file.getFreeSpace());
		System.out.println("file.getTotalSpace():" + file.getTotalSpace());
		System.out.println("file.lastModified():" + file.lastModified());
		System.out.println("file.length():" + file.length());
		System.out.println("file.canWrite():" + file.canWrite());
		System.out.println("file.createNewFile():" + file.createNewFile());
		System.out.println("file.exists():" + file.exists());
		System.out.println("file.isDirectory():" + file.isDirectory());
		System.out.println("file.isFile():" + file.isFile());
		// 目录特有的方法
		System.out.println("------------------------");
		String[] childFileNames = file.list();
		for (int i = 0; i < childFileNames.length; i++) {
			System.out.println(childFileNames[i]);
		}
		System.out.println("------------------------");
		// 重点方法
		File[] childFiles = file.listFiles();
		for (int i = 0; i < childFiles.length; i++) {
			System.out.println(childFiles[i].length() + " " + childFiles[i].getAbsolutePath());
		}
		
	}
	@Test
	public void testFile() throws IOException {
		File file = new File("nums.txt");
		System.out.println("file.canRead():" + file.canRead());
		System.out.println("file.getAbsolutePath():" + file.getAbsolutePath());
		System.out.println("file.getFreeSpace():" + file.getFreeSpace());
		System.out.println("file.getTotalSpace():" + file.getTotalSpace());
		System.out.println("file.lastModified():" + file.lastModified());
		System.out.println("file.length():" + file.length());
		System.out.println("file.canWrite():" + file.canWrite());
		System.out.println("file.createNewFile():" + file.createNewFile());
		System.out.println("file.exists():" + file.exists());
		System.out.println("file.isDirectory():" + file.isDirectory());
		System.out.println("file.isFile():" + file.isFile());
		//System.out.println("file.delete():" + file.delete());
	}
	
	
	// 写一个文件, 写入26个小写字母
	@Test
	public void exer3() {
		RandomAccessFile raf = null;
		try {
			raf = new RandomAccessFile("随机文件2", "rw");
			for (int i = 0; i < 26; i++) {
				raf.write('a' + i); // 0x00000061
			}
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		} finally {
			try {
				raf.close();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
	// 再打开这个文件, 把前10个换成大写字母,后10个替换为数字字符
	@Test
	public void exer4() {
		RandomAccessFile raf = null;
		try {
			raf = new RandomAccessFile("随机文件2", "rw");
			//abcdefghijklmn...xyz
			raf.seek(0);
			for (int i = 0; i < 10; i++) {
				raf.write('A' + i);
			}
			raf.seek(raf.length() - 10);
			for (int i = 0; i < 10; i++) {
				raf.write('0' + i);
			}
			//raf.setLength(1024 * 1024 * 1024);
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		} finally {
			try {
				raf.close();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
	@Test
	public void testRandomAccessFile() {
		RandomAccessFile raf = null;
		try {
			raf = new RandomAccessFile("随机访问文件", "rw"); // 以读写方式打开文件, 指针指向0下标处
			char ch = (char)raf.read(); // 读一个字节, 一个字节正好是一个英语字符, 指针要作相应的移动
			System.out.println(ch);
			//raf.readChar();
			System.out.println("pointer:" + raf.getFilePointer());
			
			raf.seek(4);
			byte[] buf = new byte[8192];
			int realCount = raf.read(buf, 0, 4); // 只读4个字节
			String string = new String(buf, 0, realCount);
			System.out.println(string);
			
			raf.seek(20);
			realCount = raf.read(buf, 0, 3); // 只读3个字节
			String string2 = new String(buf, 0, realCount);
			System.out.println(string2);
			
			raf.seek(8);
			raf.writeUTF("XXXX");
			//raf.write('a'); 把一个字符当作字节写入文件

			
			// 打开文件,确认内容
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		} finally {
			try {
				raf.close();
			} catch (Exception e2) {
				// TODO: handle exception
			}
		}
	}
	
	@Test
	public void testSystemOut2() throws FileNotFoundException {
		System.out.println("aaaaa");
		System.err.println("bbbbb"); // System.err对象中的方法是在另外一个线程中运行
	}
	
	@Test
	public void testSystemOut() throws FileNotFoundException {
		//System.setOut(new PrintStream(new FileOutputStream("sysout"))); // 输入输出重定向
		//System.out.println("abcdefg");
		
		System.setErr(new PrintStream(new FileOutputStream("syserr"))); //把错误输出重定向到文件
		System.err.println("xxxxxxxxx");
		try {
			String string = null;
			System.out.println(string.length());
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	// 从键盘获取10组数字, 把这10个数字保存在文件nums.txt中.
	@Test
	public void exer1() {
		// 如果获取到的输入不是数字,则不允许写入文件.
		InputStreamReader isr = null;
		BufferedReader bufferedReader = null;
		FileWriter fileWriter = null;
		BufferedWriter bufWriter = null;
		try {
			isr = new InputStreamReader(System.in);
			bufferedReader = new BufferedReader(isr);
			fileWriter = new FileWriter("nums.txt", true); // 以追加的方式写文件
			bufWriter = new BufferedWriter(fileWriter);
			
			for (int i = 0; i < 10; i++) {
				String str = bufferedReader.readLine();
				try {
					Double.parseDouble(str);
					bufWriter.write(str);
					bufWriter.newLine();
				} catch (NumberFormatException e) {
					System.out.println("输入的数字有误!!");
					i--;
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				bufferedReader.close();
			} catch (Exception e2) {
				// TODO: handle exception
			}
			try {
				bufWriter.close();
			} catch (Exception e2) {
				// TODO: handle exception
			}
		}
	}
	
	// 使用转换流获取键盘输入的字符串并在控制台打印输出
	@Test
	public void testSystemIn() {
		//System.out.println(System.in);
		InputStreamReader isr = null;
		BufferedReader bufReader = null;
		try {
			isr = new InputStreamReader(System.in); // System.in是一个常量对象, 由JVM自动创建, 我们只需要拿来使用即可
			bufReader = new BufferedReader(isr);
			String line = bufReader.readLine();
			while (line != null) {
				// 1)
				System.out.println(line);
				// 2) 
				line = bufReader.readLine(); // ctrl+z会使得返回null
			}
			
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		} finally {
			try {
				bufReader.close();
			} catch (Exception e2) {
				// TODO: handle exception
			}
		}
	}
	
	@Test
	public void testOutputStreamWriter() {
		FileOutputStream fos = null;
		OutputStreamWriter osw = null;
		try {
			fos = new FileOutputStream("使用转换流写文本文件3", true);
			//osw = new OutputStreamWriter(fos); // 以本地编码方式写文本文件
			osw = new OutputStreamWriter(fos, "UTF8"); // 以指定编码方式写文本文件
			osw.write("来一个字符串");
			osw.write(10);
			osw.write("abcdefgh\n");
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		} finally {
			try {
				osw.close();
			} catch (Exception e2) {
				// TODO: handle exception
			}
		}
	}
	// 写一个文本文件,使用UTF8编码方式, 用记事本打开查看内容
	// 再读取文件内容并打印输出
	// 试一下使用ISO8859-1编码方式,写文件并读文件
	@Test
	public void testInputStreamReader() {
		//FileReader fReader = null;
		FileInputStream fis = null;
		InputStreamReader isr = null;
		BufferedReader bufReader = null;
		try {
			//fReader = new FileReader("utf8编码的文本文件.txt"); // 只能使用默认的GBK方式读文本文件
			fis = new FileInputStream("使用转换流写文本文件2");
			//isr = new InputStreamReader(fis); // 默认按照GBK方式把字节流转换为字符流
			isr = new InputStreamReader(fis, "UTF8"); // 以UTF8编码方式把字节流转化为字符流
			bufReader = new BufferedReader(isr);
			String line = bufReader.readLine(); // 直接从流中读一行字符串, line中不包含任何换行
			while (line != null) {
				// 1) 处理数据
				System.out.println(line);
				// 2) 继续读
				line = bufReader.readLine();
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			// 关闭流, 只需要关闭高级流即可
			if (bufReader != null) {
				try {
					bufReader.close();
				} catch (Exception e2) {
				}
			}
		}
	}
	
	// 处理对象, 对象序列化 : 把在GC区中对象的相关数据保存到输出流中.
	// 可以直接序列化类实现了Seriliable接口的对象, 还可以序列化对象数组, 对象集合
	// 序列化和序列化时类的版本要求一致.
	@Test
	public void testSerialize() {
		FileOutputStream fos = null;
		ObjectOutputStream oos = null;
		try {
			fos = new FileOutputStream("对象序列化文件");
			oos = new ObjectOutputStream(fos);
			// 对象序列化
			Person.no = 1000;
			Person obj1 = new Person("张三", 30 , "男");
			Person obj2 = new Person("李四", 40 , "女");
			Person obj3 = new Person("王五", 50 , "男");
			
			Person[] arr = {obj1, obj2, obj3};
			
			/*
			oos.writeObject(obj1);
			oos.writeObject(obj2);
			oos.writeObject(obj3);
			*/
			
			//oos.writeObject(arr);
			
			Set<Person> set = new HashSet<Person>();
			set.add(obj1);
			set.add(obj2);
			set.add(obj3);
			
			oos.writeObject(set);
			
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		} finally {
			try {
				oos.close();
			} catch (Exception e2) {
				// TODO: handle exception
			}
		}
	}
	
	// 对象反序列化 : 把输入流中二进制数据还原成对象的过程
	@Test
	public void testDeSerialize() {
		FileInputStream fis = null;
		ObjectInputStream ois = null;
		try {
			fis = new FileInputStream("对象序列化文件");
			ois = new ObjectInputStream(fis);
			/*
			Person person1 = (Person)ois.readObject();
			System.out.println(person1);
			Person person2 = (Person)ois.readObject();
			System.out.println(person2);
			Person person3 = (Person)ois.readObject();
			System.out.println(person3);
			*/
			
			/*
			Person[] arr = (Person[])ois.readObject();
			for (int i = 0; i < arr.length; i++) {
				System.out.println(arr[i]);
			}
			*/
			Set<Person> set = (Set<Person>)ois.readObject();
			Iterator<Person> iterator= set.iterator();
			while (iterator.hasNext()) {
				Person person = iterator.next();
				System.out.println(person);
			}
			System.out.println(Person.no);
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		} finally {
			try {
				ois.close();
			} catch (Exception e2) {
				// TODO: handle exception
			}
		}
	}
}

package com.atguigu.javase.work;

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;

import org.junit.Test;
// 从键盘读取一个字符串，判断是整数，还是浮点数，或者是字符串，然后在控制台上打印输出
public class HomeWork {
	
	@Test
	public void test3() {
		Scanner scanner = null;
		try {
			scanner = new Scanner(System.in);
			/*
			while (scanner.hasNextLine()) {
				String string = scanner.nextLine();
				System.out.println(string);
			}*/
			// aaa 111 222.3 bbb ccc 999
			while (scanner.hasNext()) {
				if (scanner.hasNextInt()) {
					int num = scanner.nextInt();
					System.out.println("整数:" + num);
				} else if (scanner.hasNextDouble()) {
					double value = scanner.nextDouble();
					System.out.println("浮点数:" + value);
				} else {
					String string = scanner.next();
					System.out.println("普通字符串:" + string);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			scanner.close();
		}
	}
	
	// 从键盘读取字符串并在控制太打印输出
	@Test
	public void test2() throws IOException {
		BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
		String line = bufferedReader.readLine();
		while (line != null) {
			System.out.println(line);
			line = bufferedReader.readLine();
		}
		bufferedReader.close(); // 键盘流一旦关闭,就无法再使用
	}
	
	@Test
	public void work1() {
		String path = "c:/MyWork";
		File file = new File(path);
		deleteFile(file);
	}
	
	// 删除文件夹及其子目录及子文件夹
	public void deleteFile(File file) {
		if (file.isFile()) {
			file.delete();
		} else {
			File[] childFiles = file.listFiles();
			for (int j = 0; j < childFiles.length; j++) {
				deleteFile(childFiles[j]);
			}
			file.delete();
			System.out.println(file + " 目录删除成功!");
		}
	}
}