Java MOOC-互评作业-流与文件

0. 字节流与二进制文件

任务1：使用DataOutputStream与FileOutputStream将Student对象写入二进制文件student.data

我的代码

public class Main {
    public static void main(String[] args)
    {
        String fileName="e://student.data";
        int length=3;
        Student[] students=new Student[length];
        students[0]=new Student(1,"张三",19,65);
        students[1]=new Student(2,"李四",19,75);
        students[2]=new Student(3,"王五",20,85);
        Student stu1=new Student();
        try(DataOutputStream dos=new DataOutputStream(new FileOutputStream(fileName)))
        {
        	for (int i = 0; i < length; i++) {
				dos.writeInt(students[i].getId());
				dos.writeUTF(students[i].getName());
				dos.writeInt(students[i].getAge());
				dos.writeDouble(students[i].getGrade());
			}
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        try(DataInputStream dis=new DataInputStream(new FileInputStream(fileName)))
        {
        	while(true) {
        		int id=dis.readInt();
                String name=dis.readUTF();
                int age=dis.readInt();
                double grade=dis.readDouble();
                Student stu=new Student(id,name,age,grade);
                System.out.println(stu);
        	}
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block  
            e.printStackTrace();
        } catch(EOFException e) {
        	//已经从流中读完
        }catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
}

我的总结

Q1:	二进制文件与文本文件的区别
A1:	这两者只是在编码层次上有差异。文本文件编码基于字符定长，译码容易些；二进制文件编码是变长的，所以它灵活，存储利用率要高些，译码难一些
Q2:	try...catch...finally注意事项
A2:	捕获多个异常时，如有多个catch块并有继承关系的情况下必须先写子类后写父类(即先捕获小异常再捕获大异常)，若写反在编译时就会报错使用。以及执行顺序，先执行try如果未发生异常，继续执行最后执行finally,否者跳过try执行catch最后执行finally.
Q3:	try..with...resouces关闭资源
A3:	在Java7中增强了try语句的功能，它允许在try关键字后紧跟一对圆括号，圆括号可以声明、初始化一个或多个资源，此处的资源指的是那些必须在程序结束时显示关闭的资源，try语句在该语句结束时自动关闭这些资源。这些资源实现类必须实现AutoCloseable或Closeable接口，实现这两个接口就必须实现close()方法。

。

任务2：使用DataInputStream与FileInputStream从student.data中读取学生信息并组装成对象

我的代码

        try(DataInputStream dis=new DataInputStream(new FileInputStream(fileName)))
        {
        	while(true) {
        		int id=dis.readInt();
                String name=dis.readUTF();
                int age=dis.readInt();
                double grade=dis.readDouble();
                Student stu=new Student(id,name,age,grade);
                System.out.println(stu);
        	}
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block  
            e.printStackTrace();
        } catch(EOFException e) {
        	//已经从流中读完
        }catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

1. 字符流与文本文件：使用 PrintWriter(写)，BufferedReader(读)

任务
1.	使用BufferedReader从编码为UTF-8的文本文件中读出学生信息，并组装成对象然后输出。
•	中文乱码问题(FileReader使用系统默认编码方式读取文件，会产生乱码，可使用InputStreamReader解决)
•	String的split方法使用\s+可以使用多个空格作为分隔符。
•	进阶：修改Students.txt文件，在正确的数据行中间增加一些错误行（如，每行只有3个数据，或者应该是数字的地方放入其他字符），修改自己的程序，让起可以处理出错的行（报错但可以继续运                    行）。
2.	编写public static ListreadStudents(String fileName);从fileName指定的文本文件中读取所有学生，并将其放入到一个List中
3.	使用PrintWriter将Student对象写入文本文件，基础代码见后。注意：缓冲区问题。

任务123我的代码

package iostream;

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

public class PrintRead {

	public static void main(String[] args) {
		String fileName = "e:/Students.txt";
		String inFileName = "e:/inStudents.txt";
		System.out.println(PrintRead.readStudents(fileName));
		try (PrintWriter pw = new PrintWriter(inFileName)) {
			pw.print("张三 ");
			pw.print(" 201821123333");
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public static List<Student> readStudents(String fileName) {
		List<Student> studentList = new ArrayList<>();
		try (FileInputStream fis = new FileInputStream(fileName);
				InputStreamReader isr = new InputStreamReader(fis, "UTF-8");
				BufferedReader br = new BufferedReader(isr);) {
			String line = null;
			while ((line = br.readLine()) != null) {
				String[] student = line.split("\s+");// split方法\s+多个空格作为分隔符
				int id = Integer.parseInt(student[0]);
				String name = student[1];
				int age = Integer.parseInt(student[2]);
				double grade = Double.parseDouble(student[3]);
				Student stu = new Student(id, name, age, grade);
				studentList.add(stu);
			}
		} catch (UnsupportedEncodingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return studentList;

	}

}

任务4：使用ObjectInputStream/ObjectOutputStream读写学生对象。

我的代码

try(
		FileOutputStream fos=new FileOutputStream(fileName);
	    ObjectOutputStream oos=new ObjectOutputStream(fos)
	)
	{
	    Student ts=new Student(1,"张三",19,65);
	    oos.writeObject(ts);
	}
	catch (Exception e) {
	    // TODO Auto-generated catch block
	    e.printStackTrace();
	}
	try(
	    FileInputStream fis=new FileInputStream(fileName);
	    ObjectInputStream ois=new ObjectInputStream(fis))
	{
	    Student newStudent =(Student)ois.readObject();
	    System.out.println(newStudent);
	} catch (IOException e) {
	    // TODO Auto-generated catch block
	    e.printStackTrace();
	} catch (ClassNotFoundException e) {
	    // TODO Auto-generated catch block
	    e.printStackTrace();
	}

我的总结

Q1:中文乱码问题
A1:FileReader使用系统默认编码方式读取文件，会产生乱码，可使用InputStreamReader解决,在创建时可以设置编码格式比如GBK,UTF-8
Q2:写入文件后，打开为空白文件
A2:文件写入存在缓冲区，先将数据写入缓冲区，效率高，但是如果没有强制将缓冲区内容写入，或者缓冲区未满，或者正常关闭流，并不会真正写入文件，可以使用writer.flush();writer.close()写入文件

2. 缓冲流(结合使用JUint进行测试)

任务：使用PrintWriter往文件里写入1千万行随机整数，范围在[0，10]。随机数种子设置为100.
然后从文件将每行读取出来转换成整数后相加。然后依次输出“个数 和 平均值（保留5位小数）”。

我的代码

package iostream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Random;
import java.util.Scanner;


public class BufferedScanner {

	/**
	 * @param args
	 * @throws Exception 
	 */
	public static void main(String[] args)  {
		String FILENAME = "e:\test.txt";
		
		//write using PrintWriter
		try (PrintWriter pw = new PrintWriter(FILENAME)){
            Random random=new Random(100);
            for (int i = 0; i < 1000_0000; i++) {
                int r=random.nextInt(11);
                pw.println(r);
            }
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		
		
		System.out.println("write  using PrintWriter done");
		
		
	}

}

class Test {
	String FILENAME = "e:\test.txt";
	
	@org.junit.jupiter.api.Test
	void testBuffered() {
		//read using BufferedReader
		int sum=0;
		int count=0;
		try (BufferedReader br = new BufferedReader(new FileReader(new File(FILENAME)))){
			String str;
			int r;
			while((str=br.readLine())!=null){
				r=Integer.parseInt(str);
				sum+=r;
				count++;
			};
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		System.out.format("%d %d %.5f", count,sum,1.0*sum/count);
		System.out.println("read using BufferedReader done");
	}
	@org.junit.jupiter.api.Test
	void testScanner() {
		//read using Scanner
		int sum=0;
		int count=0;
		int r;
		try (Scanner scanner=new Scanner(new File(FILENAME))){
			String str;
			while(scanner.hasNextLine()){
				str=scanner.nextLine();
				r=Integer.parseInt(str);
				sum+=r;
				count++;
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		System.out.format("%d %d %.5f", count,sum,1.0*sum/count);
		System.out.println("read using Scanner done");
		

	}
}

我的总结

Q1:使用junit对比BufferedReader与Scanner读文件的效率
A1:显而易见用BufferedReader更快，因为BufferedReader采用缓存方式可以有效减少I/O操作次数，进而节省时间
Q2:Scanner的hasNextXXX方法应与相对应的nextXXX方法配合使用，否则容易出错。
Q3:为什么读取出文件后数据量从1000_0000减少的一半变成了500_0000。
A3:因为在while循环中如果采用br.readLine()!=null，文件会指向下一位，如果这时候再在循环直调用readLine,会跳行读取所以减少一半，应该while中写成(str=br.readLine())!=null

3. 字节流之对象流

任务：结合使用ObjectOutputStream、ObjectInputStream与FileInputStream、FileOuputStream实现对Student对象的读写。
编写如下两个方法：
•	public static void writeStudent(List stuList)
•	public static List readStudents(String fileName)

我的代码

public class PrintRead {

	public static void main(String[] args) {
		String fileName = "e:/Students.txt";
		List<Student> stuList=new ArrayList<>();
		stuList.add(new Student(1,"张三",19,65));
		stuList.add(new Student(2,"李四",19,75));
		stuList.add(new Student(3,"王五",20,85));
		PrintRead.writeStudent(stuList);
		System.out.println(PrintRead.readStudents(fileName));
	}

	public static void writeStudent(List<Student> stuList) {
		String fileName = "e:/Students.txt";
		try (FileOutputStream fos = new FileOutputStream(fileName);
				ObjectOutputStream ois = new ObjectOutputStream(fos)) {
			ois.writeObject(stuList);

		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
	}

	public static List<Student> readStudents(String fileName) {
		List<Student> stuList = new ArrayList<>();
		try (FileInputStream fis = new FileInputStream(fileName); ObjectInputStream ois = new ObjectInputStream(fis)) {
			stuList = (List<Student>) ois.readObject();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return stuList;
	}
}

我的总结

Q1:java.io.NotSerializableException: iostream.Student出现异常
A1:要将对象写入文件，必须实现序列化接口，对象---->流数据    序列化流 (ObjectOutputStream)
•	(1)必须序列化之后才可以反序列化
•	(2)自定义类要实现序列化功能,必须实现接口Serializable（标记接口），如果没有实现就会报这个错误NotSerializableException。

5. 文件操作

任务：编写一个程序，可以根据指定目录和文件名，搜索该目录及子目录下的所有文件，如果没有找到指定文件名，则显示无匹配，否则将所有找到的文件名与文件夹名显示出来。
1.	编写public static void findFile(Path dir,String fileName)方法.
以dir指定的路径为根目录，在其目录与子目录下查找所有和filename相同的文件名，一旦找到就马上输出到控制台。

我的代码

public class FindDirectories {
	public static void main(String[] args) {
		// if no arguments provided, start at the parent directory
		String fileName = "test.txt";
		if (args.length == 0)
			args = new String[] { "E:\算法程序设计" };

		try {
			File pathName = new File(args[0]);
			String[] fileNames = pathName.list();

			// enumerate all files in the directory
			for (int i = 0; i < fileNames.length; i++) {
				File f = new File(pathName.getPath(), fileNames[i]);

				if (f.isFile()) {
	                if(f.getName().equals(fileName))
	                {
	                    System.out.println(f.getAbsolutePath());
	                    flag=true;
	                }
				}
				// if the file is again a directory, call the main method recursively
				else if (f.isDirectory()) {
					if (f.getName().equals(fileName))
					{
						System.out.println(f.getCanonicalPath());
						flag=true;
					}
					
					main(new String[] { f.getPath() });//递归
				}
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

我的总结

实现方法主要时通过递归，通过if语句判断当前文件是单个文件或者存在子文件，然后如果存在子文件则递归再次调用，在其子目录下查找所有和filename相同的文件名，一旦找到就马上输出到控制台。

6. 正则表达式

1.	如何判断一个给定的字符串是否是10进制数字格式？尝试编程进行验证。
2.	修改HrefMatch.java
•	尝试匹配网页中的数字字符串
•	尝试匹配网页中的图片字符串

我的代码

public class HrefMatch
{
   public static void main(String[] args)
   {
      try
      {
         // get URL string from command line or use default
        /* String urlString;
         if (args.length > 0) urlString = args[0];
         else urlString = "http://java.sun.com";*/
         String fileName="e:\集美大学-计算机工程学院.htm";
         // open reader for URL
        //InputStreamReader in = new InputStreamReader(new URL(urlString).openStream());
         InputStreamReader in = new InputStreamReader(new FileInputStream(fileName));
         // read contents into string builder
         StringBuilder input = new StringBuilder();
         int ch;
         while ((ch = in.read()) != -1)
            input.append((char) ch);

         String patternString = "[+-]?[0-9]+(\.\d+)?";
         Pattern pattern = Pattern.compile(patternString, Pattern.CASE_INSENSITIVE);
         Matcher matcher = pattern.matcher(input);

         while (matcher.find())
         {
            int start = matcher.start();
            int end = matcher.end();
            String match = input.substring(start, end);
            System.out.println(match);
         }
      }
      catch (IOException e)
      {
         e.printStackTrace();
      }
      catch (PatternSyntaxException e)
      {
         e.printStackTrace();
      }
   }
}