java SE常用的API和一些常用Test

Day01(回文，验证码)

Test01:

1:输出字符串"HelloWorld"的字符串长度 str.length();

 2:输出"HelloWorld"中"o"的位置 str.indexOf('o')

 3:输出"HelloWorld"中从下标5出开始第一次出现"o"的位置 str.indexOf('o',5)

 4:截取"HelloWorld"中的"Hello"并输出 str.substring(0, 5)

 5:截取"HelloWorld"中的"World"并输出 str.substring(5)

 6:将字符串"  Hello   "中两边的空白去除后输出str.trim()

 7:输出"HelloWorld"中第6个字符"W" str.charAt(5)

 8:输出"HelloWorld"是否是以"h"开头和"ld"结尾的。str.startsWith("h")和str.endsWith("ld")

 9:将"HelloWorld"分别转换为全大写和全小写并输出。str.toUpperCase()和str.toLowerCase()

Test02:

将"大家好!"修改为:"大家好!我是程序员!"并输出。

然后将"大家好!我是程序员!"修改为:"大家好!我是优秀的程序员!"并输出

  然后再修改为:"大家好!我是牛牛的程序员!"并输出

然后在修改为:"我是牛牛的程序员!"并输出

public static void main(String[] args) {
    StringBuilder builder = new StringBuilder("大家好!");
    builder.append("我是程序员!");
    System.out.println(builder.toString());
    builder.insert(6,"优秀的");
    System.out.println(builder.toString());
    builder.replace(6, 8, "牛牛");
    System.out.println(builder.toString());
    builder.delete(0, 4);
    System.out.println(builder.toString());

}

 

Test03: 检查一个字符串是否为回文

回文:正着念与反着念一样，例如:上海自来水来自海上

 

public class Test03 {
    public static void main(String[] args) {
        String str = "上海自来水来自海上";
        if(check(str)){
            System.out.println("是回文");
        }else{
            System.out.println("不是回文");
        }
    }
    public static boolean check(String str){
        //charAt实现
        for(int i=0;i<str.length()/2;i++){
            if(str.charAt(i)!=str.charAt(str.length()-1-i)){
                return false;
            }
        }
        return true;

//StringBuilder实现
// String str1 = new StringBuilder(str).reverse().toString();
// return str.equals(str1);
    }
}

Test04: 要求用户从控制台输入一个email地址，然后获取该email的用户名(@之前的内容)

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    System.out.println("请输入一个email地址");
    String email = scanner.nextLine();
    if(email.indexOf("@")<1){
        System.out.println("缺少@或没有用户名");
    }else{
        String username = email.substring(0, email.indexOf("@"));
        System.out.println("用户名:"+username);
    }
}

Test05: 随机生成一个5位的英文字母验证码(大小写混搭)

       然后将该验证码输出给用户，然后要求用户输入该验证码，大小写不限制。

       然后判定用户输入的验证码是否有效(无论用户输入大小写，只要字母都正确即可)。

 

public class Test05 {
    public static void main(String[] args) {
        String str = random();
        System.out.println("验证码为:"+str);
        System.out.println("请输入上述验证码:");
        Scanner scanner = new Scanner(System.in);
        String input = scanner.nextLine();
        if(str.toUpperCase().equals(input.toUpperCase())){
            System.out.println("输入正确");
        }else{
            System.out.println("输入错误");
        }

    }
    /    **
     * 生成验证码
     * @return
     */
    public static String random(){
        Random random = new Random();
        StringBuilder builder = new StringBuilder();
        for(int i=0;i<5;i++){
            if(random.nextInt(2)==1){
                builder.append((char)('a'+random.nextInt(27)));
            }else{
                builder.append((char)('A'+random.nextInt(27)));
            }
        }
            return builder.toString();
        }
    }

 

Test06：要求用户输入一个计算表达式，可以使用加减乘除。

  只处理一次运算的，不要有连续加减乘除的表达式,且不做小数计算。(例:1+2+3)

例如:

  1+2

  然后经过处理计算结果并输出:1+2=3

public class Test06 {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入一个算式:");
		//这里可以验证用户输入的是否为多次运算，已提醒用户违例
		
		String line = scanner.nextLine();
		//符号所在的位置
		int index = -1;
		//判断是否为加法
		if((index=line.indexOf("+"))>0){
			int number1 = parseInt(line.substring(0, index));
			int number2 = parseInt(line.substring(index+1));
			System.out.println(line+"="+(number1+number2));
		}else if((index=line.indexOf("-"))>0){
			int number1 = parseInt(line.substring(0, index));
			int number2 = parseInt(line.substring(index+1));
			System.out.println(line+"="+(number1-number2));
		}else if((index=line.indexOf("*"))>0){
			int number1 = parseInt(line.substring(0, index));
			int number2 = parseInt(line.substring(index+1));
			System.out.println(line+"="+(number1*number2));
		}else if((index=line.indexOf("/"))>0){
			int number1 = parseInt(line.substring(0, index));
			int number2 = parseInt(line.substring(index+1));
			if(number2==0){
				System.out.println("除数不能为0");
				return;
			}
			System.out.println(line+"="+(number1/number2));
		}
	}
	/**
	 * 将指定的字符串转换为数字
	 * @param str
	 * @return
	 */
	public static int parseInt(String str){
		//最后要生成的数字
		int num = 0;
		//临时变量，用于计算对应位数的数字
		int flag = 0;
		for(int i=0;i<str.length();i++){
			flag = (str.charAt(i)-48);
			/*
			 * 这里是将对应的数字计算为对应的位，例如百位数字就要用该数字乘以10的2次方
			 * 得到
			 * 可以用Math的相关方法处理(自行查看API文档)
			 */
			for(int n=0;n<str.length()-1-i;n++){
				flag*=10;
			}
			num+=flag;
		}
		return num;
	}
}

 

Day02(正则表达式)

Test01：要求用户输入一个字符串，然后若该字符串是一个整数，则转换为整数后输出乘以10后的结果

 * 若是小数，则转换为一个小数后输出乘以5后的结果，若不是数字则输出"不是数字"

 * 需要使用正则表达式进行判断。

public class Test01 {
	public static void main(String[] args) {
		//整数的正则表达式
		String intReg = "\\d+";
		//小数的正则表达式
		String douReg = "\\d+\\.\\d+";
		
		System.out.println("请输入一个数字:");
		Scanner scanner = new Scanner(System.in);
		String line = scanner.nextLine();
		//判断是否为整数
		if(line.matches(intReg)){
			int num = Integer.parseInt(line);
			System.out.println("整数:"+num+"*10="+(num*10));
		//判断是否为小数	
		}else if(line.matches(douReg)){
			double num = Double.parseDouble(line);
			System.out.println("小数:"+num+"*5="+(num*5));
		}else{
			System.out.println("不是数字");
		}
	}
}

 

Test02：将字符串123,456,789,012根据","拆分，并输出拆分后的每一项

 

public class Test02 {
	public static void main(String[] args) {
		String str = "123,456,789,012";
		String[] arr = str.split(",");
		for(int i =0;i<arr.length;i++){
			System.out.println(arr[i]);
		}
	}
}

 

 

Test03：输入一个IP地址，然后将4段数字分别输出

 *

 * IP的正则表达式参考

 * ((2([0-4][0-9]|5[0-5])|[01]?[0-9]{1,2})\\.){3}(2([0-4][0-9]|5[0-5])|[01]?[0-9]{1,2})

public class Test03 {
	public static void main(String[] args) {
		System.out.println("请输入一个IP地址");
		Scanner scanner = new Scanner(System.in);
		String ip = scanner.nextLine();
		//可以验证IP地址的格式是否合法
		String[] arr = ip.split("\\.");
		for(int i=0;i<arr.length;i++){
			System.out.println(arr[i]);
		}
	}
}

 

Test04:将字符串"123abc456def789ghi"中的英文部分替换为"#char#"

public class Test04 {
	public static void main(String[] args) {
		String str = "123abc456def789ghi";
		str = str.replaceAll("[a-zA-Z]+", "#char#");
		System.out.println(str);
	}
}

Test05: 实现文件重命名。

 * 要求用户输入一个文件名称，例如:abc.jpg

 * 然后对该名字进行重新命名，输出的格式为:系统时间毫秒值.jpg

 * 例如:1465266796279.jpg

 

public class Test05 {
	public static void main(String[] args) {
		System.out.println("请输入一个文件名");
		Scanner scanner = new Scanner(System.in);
		String fileName = scanner.nextLine();
		//方式一:按照"."拆分
//		String[] arr = fileName.split("\\.");
//		fileName = System.currentTimeMillis()+"."+arr[1];
//		System.out.println(fileName);
		
		//方式二:或者将文件名做替换
		fileName = fileName.replaceAll("\\w+\\.", System.currentTimeMillis()+".");
		System.out.println(fileName);
		
	}
}

 

Test06: 测试正则表达式，并尝试编写规则: 电话号码可能有3-4位区号，

 * 7-8位号码:0415-5561111

public class Test06 {
	public static void main(String[] args) {
		String regex = "\\d{3,4}-\\d{7,8}";
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入一个电话号码:");
		String phoneNumber = scanner.nextLine();
		if(phoneNumber.matches(regex)){
			System.out.println("是电话号码");
		}else{
			System.out.println("不是电话号码");
		}
		
	}
}

 

Test07:和上个test06差不多。

Test08：要求用户输入若干员工信息，格式为：

 * name,age,gender,salary;name,age,gender,salary;....

 * 例如:

 * 张三,25,男,5000;李四,26,女,6000;...

 * 然后将每个员工信息解析成Person对象。并存入到一个数组中。

 * 然后循环数组，输出每一个员工信息(输出使用toString返回的字符串)

 

public class Test08 {
	public static void main(String[] args) {
		System.out.println("请输入员工信息:");
		Scanner scanner = new Scanner(System.in);
		String info = scanner.nextLine();
		//首先根据";"拆分出每个员工信息
		String[] infoArr = info.split(";");
		//根据拆分出的员工信息个数创建对应长度的数组
		Person[] personArr = new Person[infoArr.length];
		/*
		 * 遍历员工信息的数组，将每个员工信息解析为一个Person对象
		 * 并存入到personArr数组中
		 */
		for(int i=0;i<personArr.length;i++){
			String personInfo = infoArr[i];
			//按照","拆分一个员工的各项信息
			String data[] = personInfo.split(",");
			String name = data[0];
			int age = Integer.parseInt(data[1]);
			String gender = data[2];
			int salary = Integer.parseInt(data[3]);
			Person p = new Person(name, age, gender, salary);
			personArr[i]=p;
		}
		System.out.println("解析完毕");
		for(int i=0;i<personArr.length;i++){
			System.out.println(personArr[i]);
		}
		
	}
}

 

Day03(时间)

Test01：使用Date输出当前系统时间，以及3天后这一刻的时间

public class Test01 {
	public static void main(String[] args) {
		Date date = new Date();
		System.out.println("当前日期:"+date);
		
		date.setTime(date.getTime()+1000*60*60*24*3);
		System.out.println("3天后:"+date);
	}
}

 

 

Test02：将当前系统时间以"yyyy-MM-dd HH:mm:ss"格式输出

public class Test02 {
	public static void main(String[] args) {
		Date now = new Date();
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		System.out.println(sdf.format(now));
	}
}

Test03：输入某人生日，格式为"yyyy-MM-dd"，输出到现在为止经过了多少周

public class Test03 {
	public static void main(String[] args) throws ParseException {
		System.out.println("请输入生日:");
		Scanner scanner = new Scanner(System.in);
		String birthStr = scanner.nextLine();
		//将输入的字符串转换为Date
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		Date birth = sdf.parse(birthStr);
		//当前系统时间
		Date now = new Date();
		//计算相差的时间
		long time = now.getTime()-birth.getTime();
		//换算为周
		time/=1000*60*60*24*7;
		System.out.println("经过了"+time+"周");
	}
}

Test04：输入一个生产日期格式"yyyy-MM-dd",再输入一个数字(保质期的天数)。

        然后经过计算输出促销日期，促销日期为:该商品过期日前2周的周三

 

public class Test04 {
	public static void main(String[] args) throws ParseException {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入一个生产日期:");
		String dateStr = scanner.nextLine();

		System.out.println("请输入一个保质期天数:");
		int days = Integer.parseInt(scanner.nextLine());
		
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		//将生产日期转换为Date
		Date date = sdf.parse(dateStr);
		
		//创建Calendar计算时间
		Calendar calendar = Calendar.getInstance();
		//表示生产日期
		calendar.setTime(date);
		//计算过期日
		calendar.add(Calendar.DAY_OF_YEAR, days);
		//计算过日期两周前
		calendar.add(Calendar.DAY_OF_YEAR, -14);
		//设置为当周周三
		calendar.set(Calendar.DAY_OF_WEEK, Calendar.WEDNESDAY);
		//转换为Date
		date = calendar.getTime();
		//输出促销日期
		System.out.println("促销日期:"+sdf.format(date));
		
	}
}

Test05：实现时间的计算: 要求用户输入身份证号，若格式有误，要求其重新输入。然后根据身份证号码输出20岁生日

 * 所在周的周三的日期。

 * 例如：出生日期:1992-07-15。20岁生日:2012-07-15

 * 当周的周三为:2012-07-18

public class Test05 {
	public static void main(String[] args) throws ParseException {
		String regex = "\\d{15}(\\d{2}[0-9xX])?";
		Scanner scanner = new Scanner(System.in);
		//身份证号的字符串
		String id = "";
		while(true){
			System.out.println("请输入身份证号:");
			id = scanner.nextLine();
			if(!id.matches(regex)){
				System.out.println("请输入正确的身份证号.");
			}else{
				break; 
			}
		}
		//截取生日的部分
		String birthStr = id.substring(6, 14);
		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
		Date birth = sdf.parse(birthStr);
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(birth);
		calendar.add(Calendar.YEAR, 20);
		calendar.set(Calendar.DAY_OF_WEEK, Calendar.WEDNESDAY);
		//将计算后的日期按格式输出
		SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
		System.out.println("日期为:"+sdf1.format(calendar.getTime()));
	}
}

Test06：创建一个集合，存放字符串"one","two"，"three"

 * 然后输出该集合的元素个数。

 * 然后输出该集合是否包含字符串"four"

 * 然后输出集合是否不含有任何元素

 * 然后清空集合

 * 然后输出该集合的元素个数

 * 然后输出集合是否不含有任何元素

public class Test06 {
	public static void main(String[] args) {
		Collection c = new ArrayList();
		c.add("one");
		c.add("two");
		c.add("three");
		System.out.println("元素数量:"+c.size());
		System.out.println("是否包含four:"+c.contains("four"));
		System.out.println("是否是空集:"+c.isEmpty());
		c.clear();
		System.out.println("集合已清空");
		System.out.println("元素数量:"+c.size());
		System.out.println("是否是空集:"+c.isEmpty());
	}
}

 

Test07：要求用户首先输入员工数量，然后输入相应员工信息，格式为：

 * name,age,gender,salary,hiredate

 * 例如:

 * 张三,25,男,5000,2006-02-15

 * 每一行为一个员工信息，然后将每个员工信息解析成Emp对象。并存入到一个集合中。

 * 在解析成Emp对象后要先查看当前集合是否包含该员工，若包含则提示该用于已存在，

 * 否则才存入集合。

 * 然后输出集合查看每个员工信息.

 

public class Test07 {
	public static void main(String[] args) throws ParseException {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入员工数量:");
		int num = Integer.parseInt(scanner.nextLine());
		//创建一个集合用于保存所有解析出来的员工信息
		Collection emps = new ArrayList();
		//开始解析工作
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		for(int i=1;i<=num;){
			System.out.println("请输入第"+i+"个员工信息");
			String info = scanner.nextLine();
			String[] data = info.split(",");
			String name = data[0];
			int age = Integer.parseInt(data[1]);
			String gender = data[2];
			int salary = Integer.parseInt(data[3]);
			Date hiredate = sdf.parse(data[4]);
			Emp emp = new Emp(name,age,gender,salary,hiredate);
			if(emps.contains(emp)){
				System.out.println("该员工已经存在!");
				continue;
			}
			emps.add(emp);
			i++;
		}
		System.out.println(emps);
	}
}

Day04(集合，数组)

Test01：创建一个集合c1，存放元素"one","two","three"

 * 再创建一个集合c2，存放元素"four","five","six"

 * 然后将c2元素全部存入c1集合

 * 然后在创建集合c3,存放元素"one,five"

 * 然后输出集合c1是否包含集合c3的所有元素

 * 然后将c1集合中的"two"删除后再输出c1集合

public class Test01 {
	public static void main(String[] args) {
		Collection<String> c1 = new ArrayList<String>();
		c1.add("one");c1.add("two");c1.add("three");
		System.out.println("c1:"+c1);
		Collection<String> c2 = new ArrayList<String>();
		c2.add("four");c2.add("five");c2.add("six");
		System.out.println("c2:"+c2);
		//c2元素存入c1
		c1.addAll(c2);
		System.out.println("已将c2元素全部存入c1");
		System.out.println("c1:"+c1);
		
		Collection<String> c3 = new ArrayList<String>();
		c3.add("one");c3.add("five");
		System.out.println("c1是否包含c3所有元素:"+c1.containsAll(c3));
		
		//删除c1中的two
		c1.remove("two");
		System.out.println("删除了c1集合中的元素two");
		System.out.println(c1);
	}
}

Test02：创建一个集合，存放元素"1","$","2","$","3","$","4"

 *   使用迭代器遍历集合，并在过程中删除所有的"$"，

 *   最后再将删除元素后的集合使用新循环遍历，并输出每一个元素。

public class Test02 {
	public static void main(String[] args) {
		Collection<String> c = new ArrayList<String>();
		c.add("1");c.add("$");c.add("2");c.add("$");c.add("3");c.add("$");c.add("4");
		Iterator<String> it = c.iterator();
		while(it.hasNext()){
			String str = it.next();
			if("$".equals(str)){
				it.remove();
			}
		}
		for(String str : c){
			System.out.println(str);
		}
	}
}

Test03：创建一个List集合(ArrayList,LinkedList均可)

 * 存放元素"one","two","three","four"。

 * 获取集合第二个元素并输出。

 * 将集合第三个元素设置为"3"

 * 在集合第二个位置上插入元素"2"

 * 删除集合第三个元素。

public class Test03 {
	public static void main(String[] args) {
		List<String> list = new LinkedList<String>();
		list.add("one");list.add("two");list.add("three");list.add("four");
		System.out.println("list:"+list);
		String e = list.get(1);
		System.out.println("第二个元素:"+e);
		//设置集合第三个元素
		list.set(2, "3");
		System.out.println("list:"+list);
		//将元素"2"设置到第二个位置上
		list.add(1,"2");
		System.out.println("list:"+list);
		
		
	}
}

Test04：创建一个List集合并添加元素0-9

 * 然后获取子集[3,4,5,6]

 * 然后将子集元素扩大10倍

 * 然后输出原集合。

 * 之后删除集合中的[7,8,9]

public class Test04 {
	public static void main(String[] args) {
		List<Integer> list = new ArrayList<Integer>();
		for(int i=0;i<10;i++){
			list.add(i);
		}
		System.out.println("list:"+list);
		//获取子集
		List<Integer> subList = list.subList(3, 7);
		for(int i=0;i<subList.size();i++){
			subList.set(i, subList.get(i)*10);
		}
		System.out.println("list:"+list);
		//删除7-9
		list.subList(7, 10).clear();
		System.out.println("list:"+list);
	}
}

Test05：创建一个List集合，并添加元素0-9

 * 将集合转换为一个Integer数组并输出数组每一个元素

 

public class Test05 {
	public static void main(String[] args) {
		List<Integer> list = new ArrayList<Integer>();
		for(int i=0;i<10;i++){
			list.add(i);
		}
		Integer[] array = list.toArray(new Integer[list.size()]);
		for(int num : array){
			System.out.println(num);
		}
	}
}

 

Test06：创建一个字符串数组:{"one","two","three"}

 * 然后将该数组转换为一个List集合

public class Test06 {
	public static void main(String[] args) {
		String[] arr = {"one","two","three"};
		List<String> list = Arrays.asList(arr);
		System.out.println(list);
 	}
}

Test07：创建一个List集合，并存放10个随机数，然后排序该集合后输出

 

public class Test07 {
	public static void main(String[] args) {
		Random random = new Random();
		List<Integer> list = new ArrayList<Integer>();
		for(int i=0;i<10;i++){
			list.add(random.nextInt(100));
		}
		System.out.println("list:"+list);
		Collections.sort(list);
		System.out.println("list:"+list);
	}
}

Test08：通过控制台输入3个日期(yyyy-MM-dd格式)，然后转换为Date对象后存入集合，然后对该集合排序后输出所有日期。

public class Test08 {
	public static void main(String[] args) throws ParseException {
		Scanner scanner = new Scanner(System.in);
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		List<Date> list = new ArrayList<Date>();
		for(int i=1;i<=3;i++){
			System.out.println("请输入第"+i+"个日期:");
			String line = scanner.nextLine();
			Date date = sdf.parse(line);
			list.add(date);
		}
		System.out.println(list);
		Collections.sort(list);
		System.out.println(list);
	}
}

 

Test09：要求用户输入若干员工信息，格式为：

 * name,age,gender,salary,hiredate;name,age,gender,salary,hiredate;....

 * 例如:

 * 张三,25,男,5000,2006-02-15;李四,26,女,6000,2007-12-24;...

 * 然后将每个员工信息解析成Emp对象。并存入到一个集合中。

 * 然后循环集合，输出每一个员工信息(输出使用toString返回的字符串)

 * 然后输出每个员工的转正仪式日期。

 * 转正仪式日期为:入职3个月的当周周五

 

public class Test09 {
	public static void main(String[] args) throws ParseException {
		List<Emp> list = new ArrayList<Emp>();
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入员工信息:");
		String info = scanner.nextLine();
		String[] empArr = info.split(";");
		for(String data:empArr){
			String[] empInfo = data.split(",");
			String name = empInfo[0];
			int age = Integer.parseInt(empInfo[1]);
			String gender = empInfo[2];
			int salary = Integer.parseInt(empInfo[3]);
			Date hiredate = sdf.parse(empInfo[4]);
			Emp e = new Emp(name, age, gender, salary, hiredate);
			list.add(e);
		}
		//输出员工信息
		for(Emp e : list){
			System.out.println(e);
		}
		//输出转正仪式日期
		for(Emp e : list){
			Calendar calendar = Calendar.getInstance();
			calendar.setTime(e.getHiredate());
			//入职3个月后的日期
			calendar.add(Calendar.MONTH, 3);
			//设置为当周的周五
			calendar.set(Calendar.DAY_OF_WEEK, Calendar.FRIDAY);
			System.out.println(e.getName()+"的转正仪式日期:"+sdf.format(calendar.getTime()));
		}
	}
}

 

Day05(队列，栈，Map)

Test01：创建一个队列，存入Integer类型元素1,2,3,4,5

 然后遍历队列并输出每个元素

 

public class Test01 {
	public static void main(String[] args) {
		Queue<Integer> queue = new LinkedList<Integer>();
		queue.offer(1);queue.offer(2);queue.offer(3);queue.offer(4);queue.offer(5);
		
		while(queue.size()>0){
			System.out.println(queue.poll());
		}
	}
}

Test02：创建一个栈，存入Integer类型元素1,2,3,4,5，然后遍历队列并输出每个元素

public class Test02 {
	public static void main(String[] args) {
		Deque<Integer> stack = new LinkedList<Integer>();
		stack.push(1);stack.push(2);stack.push(3);stack.push(4);stack.push(5);
		
		while(stack.size()>0){
			System.out.println(stack.pop());
		}
	}
}

Test03：要求用户输入若干员工信息，格式为：

 * name,age,gender,salary,hiredate;name,age,gender,salary,hiredate;....

 * 例如:

 * 张三,25,男,5000,2006-02-15;李四,26,女,6000,2007-12-24;...

 * 然后将每个员工信息解析成Emp对象。并存入到一个List集合中。

 * 并对集合排序，然后输出每个员工信息。

 *

 * 再根据员工的入职时间排序，入职晚的在前，早的在后并

 * 输出每个员工的信息。

public class Test03 {
	public static void main(String[] args) throws ParseException {
		//获取所有员工信息
		List<Emp> list = getEmp();
		//排序集合
		Collections.sort(list);
		for(Emp e : list){
			System.out.println(e);
		}

		//按照入职时间排序
		System.out.println("按照入职时间从晚到早排序:");
		Comparator<Emp> com = new Comparator<Emp>(){
			public int compare(Emp e1, Emp e2) {
				System.out.println(e1.getHiredate().getTime()-e2.getHiredate().getTime());
				long time = e2.getHiredate().getTime()-e1.getHiredate().getTime();
				return time>0?1:-1;
			}			
		};
		Collections.sort(list,com);
		for(Emp e : list){
			System.out.println(e);
		}
	}
	/**
	 * 该方法的作用是获取所有用户输入的员工信息并解析为若干Emp实例存入
	 * 一个集合，然后将该集合返回
	 * @return
	 * @throws ParseException
	 */
	public static List<Emp> getEmp() throws ParseException{
		List<Emp> list = new ArrayList<Emp>();
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入员工信息:");
		String info = scanner.nextLine();
		String[] empArr = info.split(";");
		for(String data:empArr){
			String[] empInfo = data.split(",");
			String name = empInfo[0];
			int age = Integer.parseInt(empInfo[1]);
			String gender = empInfo[2];
			int salary = Integer.parseInt(empInfo[3]);
			Date hiredate = sdf.parse(empInfo[4]);
			Emp e = new Emp(name, age, gender, salary, hiredate);
			list.add(e);
		}
		return list;
	}
}

 

Test04：创建一个Map，保存某个学生的成绩:

 *在控制台输入该学生成绩，格式:科目:成绩;科目:成绩;...

 *例如:  语文:99;数学:98;英语:97;物理:96;化学:95

 *然后输出物理的成绩。

 *然后将化学的成绩设置为96

 *然后删除英语这一项。

 *然后遍历该Map分别按照遍历key，Entry，value的形式输出该Map信息。

 

public class Test04 {
	public static void main(String[] args) {
		Map<String,Integer> map
			= new HashMap<String,Integer>();
		map.put("语文", 99);map.put("数学", 98);map.put("英语", 97);
		map.put("物理", 96);map.put("化学", 95);
		//获取物理的成绩
		Integer num = map.get("物理");
		System.out.println("物理:"+num);
		
		//设置化学成绩
		map.put("化学",96);
		
		//删除英语
		map.remove("英语");
		
		//遍历key
		Set<String> keySet = map.keySet();
		for(String key : keySet){
			System.out.println("key:"+key);
		}
		
		//遍历Entry
		Set<Entry<String,Integer>> entrySet = map.entrySet();
		for(Entry<String,Integer> e : entrySet){
			System.out.println(e.getKey()+":"+e.getValue());
		}
		
		//遍历values
		Collection<Integer> values = map.values();
		for(Integer value : values){
			System.out.println("value:"+value);
		}
	}
}

Test05：有下列字符串:

 * 销售:张三;财务:李四;销售:王五;财务:赵六;程序:mike;程序:jerry;美工:jackson;前端:green;前端:nick;程序:钱七;销售:alice

 * 分析上述字符串然后统计每个职位总共多少人?

 * 使用Map保存统计的结果，其中key:职位,value为该职位人数

 * 然后分别输出各职位的名称(keySet),各职位人数(entrySet)

 

public class Test05 {
	public static void main(String[] args) {
		/*
		 * 按照";"拆分字符串得到每一个员工信息
		 * 再按照:拆分出每个员工的职位与姓名
		 * 然后用员工职位作为key存入Map，若该职位作为key已经存在，则对value+1
		 * 否则放入Map时value从1开始
		 */
		String str = "销售:张三;财务:李四;销售:王五;财务:赵六;程序:mike;程序:jerry;美工:jackson;前端:green;前端:nick;程序:钱七;销售:alice";
		String[] emps = str.split(";");
		Map<String,Integer> map = new HashMap<String,Integer>();
		for(String emp : emps){
			String []info = emp.split(":");
			if(map.containsKey(info[0])){
				//该职位已经统计过
				map.put(info[0], map.get(info[0])+1);
			}else{
				map.put(info[0], 1);
			}
		}
		
		//遍历所有职位
		Set<String> keySet = map.keySet();
		for(String key : keySet){
			System.out.println("job:"+key);
		}
		
		//遍历人数
		Set<Entry<String,Integer>> entrySet = map.entrySet();
		for(Entry<String,Integer> e : entrySet){
			System.out.println(e.getKey()+":"+e.getValue());
		}
	}
}

 

Day06(文件，高级流，低级流，缓冲流)

Test01：通过File输出当前项目目录下的文件"myfile.txt"的名字，大小，最后修改时间。

 * 最后修改时间格式如:2016-03-23 14:22:16

public class Test01 {
	public static void main(String[] args) {
		File file = new File("myfile.txt");
		String name = file.getName();
		System.out.println("名字:"+name);
		
		long length = file.length();
		System.out.println("大小:"+length+"字节");
		
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		long lastModified = file.lastModified();
		System.out.println("最后修改时间:"+sdf.format(new Date(lastModified)));
	}
}

 

Test02：要求用户输入一个文件名并使用File在当前目录下创建出来。

若该文件已经存在，则提示用户该文件已经存在。并创建该文件副本：

例如:用户输入"test.txt".若该文件已存在，提示用户存在后，创建名为：test_副本1.txt 的文件

若该文件也存在了，则创建名为:test_副本2.txt 的文件，以此类推

public class Test02 {
	public static void main(String[] args) throws IOException {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入要创建的文件的名字:");
		String fileName = scanner.nextLine();
		File file = new File(fileName);
		if(!file.exists()){
			file.createNewFile();
		}else{
			int index = 1;
			//文件名
			String name = fileName.substring(0, fileName.indexOf("."));
			//后缀
			String postfix = fileName.substring(fileName.indexOf(".")+1);
			while(true){
				//修改文件名，添加"副本<编号>"内容
				fileName = name+"_副本"+index+"."+postfix;
				//打桩查看生成的新文件名
				System.out.println(fileName);
				//创建File表示该文件
				file = new File(fileName);
				//若不存在就创建，并停止循环，否则继续判断
				if(!file.exists()){
					file.createNewFile();
					break;
				}
				index++;
			}
		}
		
		System.out.println("文件创建完毕!");
	}
}

 

Test03：要求用户输入一个目录名并使用File在当前目录下创建出来。

 * 若该目录已经存在，则提示用户该目录已经存在。并创建副本，原则与第二题一致。

 

public class Test03 {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入要创建的目录的名字:");
		String dirName = scanner.nextLine();
		File dir = new File(dirName);
		if(!dir.exists()){
			dir.mkdir();
		}else{
			int index = 1;
			while(true){
				//修改目录名，添加"副本<编号>"内容
				String name = dirName+"_副本"+index;
				//打桩查看生成的新目录名
				System.out.println(name);
				//创建File表示该目录
				dir = new File(name);
				//若不存在就创建，并停止循环，否则继续判断
				if(!dir.exists()){
					dir.mkdir();
					break;
				}
				index++;
			}
		}
		
		System.out.println("目录创建完毕!");
	}
}

Test04：获取并输出当前目录下的所有文件和目录的名字

public class Test04 {
	public static void main(String[] args) {
		File dir = new File(".");
		File[] subs = dir.listFiles();
		for(File sub : subs){
			if(sub.isFile()){
				System.out.print("文件");
			}else{
				System.out.println("目录:");
			}
			System.out.println(sub.getName());
		}
	}
}

 

Test05：要求用户输入一个文件或目录名，并删除当前目录下的该文件或目录。

 * 可自行手动先在当前项目目录中创建一个要删除的文件或目录，若是目录，还可以

 * 在该目录中继续创建若干级目录和文件。

public class Test05 {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入一个要删除的文件或目录名:");
		String name = scanner.nextLine();
		File file = new File(name);
		if(!file.exists()){
			System.out.println("该文件或目录不存在!");
			return;
		}
		deleteFile(file);
		System.out.println("删除完毕!");
	}
	public static void deleteFile(File file){
		//如果是目录，需要先删除当前目录下的所有子项
		if(file.isDirectory()){
			for(File sub : file.listFiles()){
				//递归删除
				deleteFile(sub);
			}
		}
		file.delete();
	}
}

Test06：获取并输出当前目录下所有文件的名字

public class Test06 {
	public static void main(String[] args) {
		File dir = new File(".");
		File []subs = dir.listFiles(new FileFilter(){
			public boolean accept(File file) {
				return file.isFile();
			}
			
		});
		for(File sub : subs){
			System.out.println("文件:"+sub.getName());
		}
	}
}

Test07：要求用户输入一个文件名，并复制当前目录中该文件，并取名为"原文件名_copy.后缀名"

 * 定义两个方法分别使用单字节形式复制，以及字节数组形式复制

 

public class Test07 {
	public static void main(String[] args) throws IOException {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入一个要复制的文件名:");
		String name = scanner.nextLine();
		Test07 t = new Test07();
//		t.copy1(name);
		t.copy2(name);
	}
	/**
	 * 使用单字节方式复制
	 * @param name 要复制的文件名
	 * @throws IOException 
	 */
	public void copy1(String name) throws IOException{
		RandomAccessFile src = new RandomAccessFile(name,"r");
		String names[] = name.split("\\.");
		RandomAccessFile desc = new RandomAccessFile(names[0]+"_copy."+names[1],"rw");
		int d = -1;
		while((d = src.read())!=-1){
			desc.write(d);
		}
		System.out.println("复制完毕!");
		src.close();
		desc.close();
	}
	/**
	 * 使用字节数组形式复制
	 * @param name 要复制的文件名
	 * @throws IOException 
	 */
	public void copy2(String name) throws IOException{
		RandomAccessFile src = new RandomAccessFile(name,"r");
		String names[] = name.split("\\.");
		RandomAccessFile desc = new RandomAccessFile(names[0]+"_copy."+names[1],"rw");
		int len = -1;
		byte[] buf = new byte[1024*10];
		while((len = src.read(buf))!=-1){
			desc.write(buf,0,len);
		}
		System.out.println("复制完毕!");
		src.close();
		desc.close();
	}
}

 

Test08：创建一个"raf.dat"的文件，并在其中写出一个int的最大值，long的最大值，

 * 然后将其分别读取出来并输出

public class Test08 {
	public static void main(String[] args) throws IOException {
		RandomAccessFile raf = new RandomAccessFile("raf.dat","rw");
		raf.writeInt(Integer.MAX_VALUE);
		raf.writeLong(Long.MAX_VALUE);
		raf.seek(0);
		int i = raf.readInt();
		long l = raf.readLong();
		System.out.println("int:"+i);
		System.out.println("long:"+l);
		raf.close();
	}
}

Test09：创建一个文件"note.txt",然后通过控制台输入的每一行字符串都按行写入到

 * note.txt中。当输入的字符串为"exit"时退出程序

public class Test09 {
	public static void main(String[] args) throws IOException {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入内容,exit为退出");
		RandomAccessFile raf = new RandomAccessFile("note.txt","rw");
		while(true){
			String line = scanner.nextLine();
			if("exit".equals(line)){
				break;
			}
			raf.write(line.getBytes());
		}
		System.out.println("再见!");
		raf.close();
	}
}

Test10：要求用户输入一个员工信息，格式为：

 * name,age,gender,salary,hiredate

 * 例如:

 * 张三,25,男,5000,2006-02-15

 * 然后将输入的员工信息解析成Emp对象。

 * 然后将该Emp对象的toString返回的字符串写入到文件中，该文件的

 * 名字为:name.emp,以上面的例子，那么该文件名为:张三.emp

 * 至少运行5次该程序，输入五个员工信息，并生成5个文件

 

public class Test10 {
	public static void main(String[] args) throws ParseException,IOException {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入员工信息:");
		String line = scanner.nextLine();
		String[] infos = line.split(",");
		String name = infos[0];
		int age = Integer.parseInt(infos[1]);
		String gender = infos[2];
		int salary = Integer.parseInt(infos[3]);
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		Date hiredate = sdf.parse(infos[4]);
		Emp emp = new Emp(name,age,gender,salary,hiredate);
		
		RandomAccessFile raf = new RandomAccessFile(emp.getName()+".emp","rw");
		raf.write(emp.toString().getBytes());
		System.out.println("写出完毕!");
		raf.close();
		
		
	}
}

Test11：编写一个程序，将当前目录下所有员工文件进行读取，并解析出所有员工为Emp

 * 对象并存入集合。然后排序该集合，按照员工的年龄排序，年龄大的靠前，年龄小

 * 的靠后。排序完毕后输出结果。

 

public class Test11 {
	public static void main(String[] args) throws IOException, ParseException {
		Test11 t = new Test11();
		//当前目录
		File dir = new File(".");
		//将所有员工读取出来
		List<Emp> list = t.loadEmp(dir);
		//排序集合
		Collections.sort(list,new Comparator<Emp>(){
			public int compare(Emp e1, Emp e2) {
				return e1.getAge()-e2.getAge();
			}
			
		});
		for(Emp e : list){
			System.out.println(e);
		}
	}
	/**
	 * 从给定目录中读取所有.emp文件并解析为若干Emp对象，然后以
	 * 一个List集合形式返回
	 * @param dir
	 * @return
	 * @throws IOException 
	 * @throws ParseException 
	 */
	public List<Emp> loadEmp(File dir) throws IOException, ParseException{
		List<Emp> list = new ArrayList<Emp>();
		File[] emps = dir.listFiles(new FileFilter(){
			public boolean accept(File file) {
				return file.getName().endsWith(".emp");
			}			
		});
		for(File file:emps){
			list.add(parseEmp(file));
		}
		return list;
	}
	/**
	 * 从指定文件中解析出Emp对象
	 * @param file
	 * @return
	 * @throws ParseException 
	 */
	public Emp parseEmp(File file)throws IOException, ParseException{
		RandomAccessFile raf = new RandomAccessFile(file,"r");
		//文件多大就创建多大的数组
		byte[] buf = new byte[(int)file.length()];
		//将文件数据全部读取出来并转换为字符串
		int len=raf.read(buf);
		String info = new String(buf,0,len);
		//解析字符串并转换为Emp对象
		String[] infos = info.split(",");
		String name = infos[0];
		int age = Integer.parseInt(infos[1]);
		String gender = infos[2];
		int salary = Integer.parseInt(infos[3]);
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		Date hiredate = sdf.parse(infos[4]);
		Emp emp = new Emp(name,age,gender,salary,hiredate);
		//打桩
		System.out.println("读取emp:"+emp);
		return emp;
	}
}

 

Test12：编写一个程序，将当前目录下所有的员工文件进行读取，并解析出所有员工为Emp

 * 对象并存入Map。其中key为该员工的名字，value为该员工的emp对象。

 * 然后，要求用户输入一个员工名字，若该员工存在，则输出该员工的名字，年龄，工资，以及入职20周年的纪念日当周的周六的日期。

 * 即:输入名字"张三"

 * 若该员工存在，则输出如下格式:

 * 张三,25,5000,2006-02-14

 * 入职20周年纪念日派对日期: 2026-02-14  （注:若入职日期为:2006-02-14）

 * 若该员工不存在，则输出:"查无此人"

 

public class Test12 {
	public static void main(String[] args) throws IOException, ParseException {
		Test11 t = new Test11();
		File dir = new File(".");
		//复用Test11读取员工的方法
		List<Emp> list = t.loadEmp(dir);
		System.out.println(list);
		Map<String,Emp> map = new HashMap<String,Emp>();
		//将所有员工存入Map
		for(Emp e : list){
			map.put(e.getName(), e);
		}
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入一个员工名字:");
		String name = scanner.nextLine();
		//查看是否有次员工
		if(map.containsKey(name)){
			Emp e = map.get(name);
			//计算入职20周年纪念日派对日期
			Calendar calendar = Calendar.getInstance();
			calendar.setTime(e.getHiredate());
			//入职20周年
			calendar.add(Calendar.YEAR, 20);
			//设置为当周周六
			calendar.set(Calendar.DAY_OF_WEEK, Calendar.SATURDAY);
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			System.out.println(e);
			System.out.println("入职20周年纪念日派对日期:"+sdf.format(calendar.getTime()));
			
		}else{
			System.out.println("查无此人");
		}
	}
}

Test13：将emp.dat文件中所有员工解析出来，并创建为若干Emp实例存入一个

 * 集合，然后输出该集合中每个员工信息。

 * 该文件800字节，每80个字节为一个员工的信息。

 * 其中:

 *  name为字符串，长度为32个字节，编码为:UTF-8

 *   age为int,长度为4个字节

 *  gender为字符串，长度为10个字节，编码为:UTF-8

 *  salary为int,长度为4个字节

 *  hiredate为字符串，格式"yyyy-MM-dd"，长度为30个字节，编码为:UTF-8

 * 格式可参考当前包中emp.jpg图

 * 提示:

 * 使用RandomAccessFile读取字符串时，例如name,可以先读取32个字节，再按照UTF-8

 * 转换为字符串，读取age时可以直接使用readInt方法。依次类推。

 

public class Test13 {
	public static void main(String[] args) throws URISyntaxException, IOException, ParseException {
		//使用类加载器加载当前包中的emp.dat文件
		File file = new File(Test13.class.getClassLoader().getResource("day06/emp.dat").toURI());
		RandomAccessFile raf = new RandomAccessFile(file,"r");
		List<Emp> list = new ArrayList<Emp>();
		//用于将读取的入职时间解析为Date
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		//解析10个员工信息
		for(int i=0;i<10;i++){
			//读取员工名字
			String name = readString(raf, 32).trim();
			int age = raf.readInt();
			String gender = readString(raf,10).trim();
			int salary = raf.readInt();
			String hiredate = readString(raf, 30).trim();
			Emp e = new Emp(name,age,gender,salary,sdf.parse(hiredate));
			list.add(e);
		}
		System.out.println("解析完毕!");
		for(Emp e : list){
			System.out.println(e);
		}
	}
	/**
	 * 从当前RandomAccessFile当前位置读取指定长度的字节并以UTF-8编码
	 * 转换为字符串后返回
	 * @param raf
	 * @param len
	 * @return
	 * @throws IOException 
	 */
	public static String readString(RandomAccessFile raf,int len) throws IOException{
		byte[] data = new byte[len];
		raf.read(data);
		return new String(data,"UTF-8");
	}
}

 

Day07(文件流，缓冲流，字符流)

 

Test01：使用文件流复制myfile.txt文件为myfile_cp.txt

 

public class Test01 {
	public static void main(String[] args) throws IOException {
		FileInputStream src = new FileInputStream("myfile.txt");
		FileOutputStream desc = new FileOutputStream("myfile_cp.txt");
		int len = -1;
		byte[] data = new byte[1024*10];
		while((len = src.read(data))!=-1){
			desc.write(data,0,len);
		}
		src.close();
		desc.close();
	}
}

 

Test02: 使用缓冲流复制myfile.txt文件为myfile_cp2.txt

 

public class Test02 {
	public static void main(String[] args) throws IOException {
		FileInputStream fis = new FileInputStream("myfile.txt");
		BufferedInputStream src = new BufferedInputStream(fis);
		
		FileOutputStream fos = new FileOutputStream("myfile_cp2.txt");
		BufferedOutputStream desc = new BufferedOutputStream(fos);
		int d = -1;
		while((d = src.read())!=-1){
			desc.write(d);
		}
		src.close();
		desc.close();
	}
}

 

Test03: 要求用户控制台输入想输入的员工人数（至少5个），然后依序输入员工信息，每行为一条员工信息，格式如:张三,25,男,5000,2006-3-18

 * 然后将该对象写入到文件<name>.obj并保存到当前项目根目录中，例如:张三.obj。

public class Test03 {
	public static void main(String[] args) throws ParseException, IOException {
		Test03 t = new Test03();
		int sum = t.getInputSum();
		System.out.println("您要输入"+sum+"个员工信息。");
		for(int i=1;i<=sum;i++){
			System.out.println("请输入第"+i+"个员工信息:");
			Emp emp = t.getEmp();
			t.saveEmp(emp);		
		}
		System.out.println("操作完毕!");
	}
	/**
	 * 要求用户输入要输入的人数并返回该值
	 * @return
	 */
	public int getInputSum(){
		Scanner scanner = new Scanner(System.in);
		int sum = 0;
		while(true){
			System.out.println("请输入要输入的员工人数(至少5个):");
			sum = Integer.parseInt(scanner.nextLine());
			if(sum>=5){
				return sum;
			}
		}
	}
	/**
	 * 获取用户输入的一个员工信息
	 * @return
	 * @throws ParseException 
	 */
	public Emp getEmp() throws ParseException{
		Scanner scanner = new Scanner(System.in);
		String line = scanner.nextLine();
		String[] infos = line.split(",");
		String name = infos[0];
		int age = Integer.parseInt(infos[1]);
		String gender = infos[2];
		int salary = Integer.parseInt(infos[3]);
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		Date hiredate = sdf.parse(infos[4]);
		Emp emp = new Emp(name,age,gender,salary,hiredate);
		return emp;
	}
	/**
	 * 将给定的Emp对象序列化到指定文件,文件名格式<name>.obj
	 * @param emp
	 * @throws IOException 
	 */
	public void saveEmp(Emp emp) throws IOException{
		FileOutputStream fos = new FileOutputStream(emp.getName()+".obj");
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		oos.writeObject(emp);
		//打桩
		System.out.println("序列化<"+emp.getName()+">完毕");
		oos.close();
	}
}

 

Test04: 读取当前项目根目录下所有后缀为.obj的文件，将这些Emp对象读取出来

 * 并存入到一个List集合中，然后按照员工工资从多到少的顺序依次输出员工信息

 

public class Test04 {
	public static void main(String[] args) throws ClassNotFoundException, IOException {
		Test04 t = new Test04();
		File dir = new File(".");
		List<Emp> list = t.loadEmps(dir);
		//排序集合
		Collections.sort(list,new Comparator<Emp>(){
			/**
			 * 从早到晚排序
			 */
			public int compare(Emp e1, Emp e2) {				
				return e2.getSalary()-e1.getSalary();
			}			
		});
		//输出员工信息
		for(Emp e : list){
			System.out.println(e);
		}
	}
	/**
	 * 从指定目录中读取所有.obj结尾的文件，并反序列化所有员工信息
	 * 然后以一个List集合返回
	 * @param dir
	 * @return
	 * @throws IOException 
	 * @throws ClassNotFoundException 
	 */
	public List<Emp> loadEmps(File dir) throws ClassNotFoundException, IOException{
		List<Emp> list = new ArrayList<Emp>();
		//获取所有.obj文件
		File[] emps = dir.listFiles(new FileFilter(){
			public boolean accept(File file) {
				return file.getName().endsWith(".obj");
			}
			
		});
		//将每个obj文件反序列化为Emp对象后存入List集合
		for(File empFile : emps){
			Emp emp = loadEmp(empFile);
			list.add(emp);
		}
		return list;
	}
	/**
	 * 从指定文件中反序列化Emp并返回
	 * @param file
	 * @return
	 * @throws IOException
	 * @throws ClassNotFoundException
	 */
	public Emp loadEmp(File file) throws IOException, ClassNotFoundException{
		FileInputStream fis = new FileInputStream(file);
		ObjectInputStream ois = new ObjectInputStream(fis);
		Emp e = (Emp)ois.readObject();
		ois.close();
		return e;
	}
}

Test05: 使用字符流复制当前程序的源文件到当前项目根目录下

public class Test05 {
	public static void main(String[] args) throws IOException {
		FileInputStream fis = new FileInputStream(
				"src"+File.separator+
				"main"+File.separator+
				"java"+File.separator+
				"day07"+File.separator+
				"Test05.java");
		InputStreamReader isr = new InputStreamReader(fis);
		
		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("Test05.java"));
		
		int d = -1;
		while((d = isr.read())!=-1){
			osw.write(d);
		}
		System.out.println("复制完毕");
		isr.close();
		osw.close();
	}
}

Test06: 记事本功能，首先要求用户输入一个文件名，并将该文件创建出来，

 * 然后通过控制台输入的每一行字符串都按行写入到该文件中，并

 * 使用GBK编码保存。当输入的字符串为"exit"时退出程序。

public class Test06 {
	public static void main(String[] args) throws IOException{
		 Scanner scanner = new Scanner(System.in);
		 System.out.println("请输入文件名:");
		 String fileName = scanner.nextLine();
		 PrintWriter pw = new PrintWriter(
			new OutputStreamWriter(
				new FileOutputStream(fileName),"GBK"	
			)	 
		 );
		 System.out.println("请输入内容，输入exit则退出程序");
		 while(true){
			 String line = scanner.nextLine();
			 if("exit".equals(line)){
				 break;
			 }
			 pw.println(line);
		 }
		 System.out.println("再见!");
		 pw.close();
		 
	}
}

 

Test07: 要求用户输入一个文件，该文件应当是Test07程序生成的文件，然后将该文件中所有字符读取出来，并以UTF-8编码写入到另一个文件中，实现文件转码工作，该文件取名格式:原文件名_utf-8.txt

public class Test07 {
	public static void main(String[] args) throws IOException {
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入要转码的文件名:");
		String fileName = scanner.nextLine();
		File file = new File(fileName);
		if(!file.exists()){
			System.out.println(file+"不存在!");
		}else{
			changeCharSet(file,"GBK","UTF-8");

		}
	}
	/**
	 * 将指定文件转码
	 * @param file 要转码的文件
	 * @param srcCSN 文件现编码
	 * @param desCSN 要转换的编码
	 * @throws IOException 
	 */
	public static void changeCharSet(File file,String srcCSN,String desCSN) throws IOException{
		String fileName = file.getName();
		String name = fileName.substring(0, fileName.indexOf("."));
		String postfix = fileName.substring(fileName.indexOf(".")+1);
		BufferedReader br = new BufferedReader(
			new InputStreamReader(
				new FileInputStream(file),srcCSN	
			)	
		);
		PrintWriter pw = new PrintWriter(
			new OutputStreamWriter(
				new FileOutputStream(name+"_"+desCSN+"."+postfix),desCSN	
			)	
		);
		String line = null;
		while((line = br.readLine())!=null){
			pw.println(line);
		}
		System.out.println("转码完毕!");
		br.close();
		pw.close();
	}
}

 

Day08(文件操作的异常处理)

Test01：对myfile.txt文件进行复制操作，要求使用异常捕获机制对流的异常进行捕获和处理，finally中要将流关闭(先关输入流，再关输出流)

public class Test01 {
	public static void main(String[] args) {
		FileInputStream fis = null;
		FileOutputStream fos = null;
		try {
			fis = new FileInputStream("myfile.txt");
			fos = new FileOutputStream("myfile_cp.txt");
			int len = -1;
			byte[] data = new byte[1024*10];
			while((len=fis.read(data))!=-1){
				fos.write(data,0,len);
			}
			System.out.println("复制完毕!");
		} catch (Exception e) {
			e.printStackTrace();
		} finally{
			if(fis != null){
				try {
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(fos != null){
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

Test02：使用异常捕获完成下述操作：

 * 将控制台输入的每一行字符串使用缓冲字符输出流PrintWriter

 * 按行以GBK编码写入到文件note.txt中

public class Test02 {
	public static void main(String[] args) {
		PrintWriter pw = null;
		try {
			Scanner scanner = new Scanner(System.in);
			pw = new PrintWriter(
				new OutputStreamWriter(
					new FileOutputStream("note.txt"),"GBK"
				)	
			);
			System.out.println("请输入内容,若输入exit则程序退出:");
			String line = null;
			while(true){
				line = scanner.nextLine();
				if("exit".equals(line)){
					break;
				}
				pw.println(line);
			}
			System.out.println("再见!");
		} catch (Exception e) {
			e.printStackTrace();
		} finally{
			pw.close();			
		}
	}
}

 

Test03：使用异常捕获机制完成下述读取操作。

 * 使用缓冲流读取note.txt文件，并将每行字符串输出到控制台上

public class Test03 {
	public static void main(String[] args) {
		BufferedReader br = null;
		try {
			br = new BufferedReader(
				new InputStreamReader(
					new FileInputStream("note.txt"),"GBK"	
				)	
			);
			String line = null;
			while((line = br.readLine())!=null){
				System.out.println(line);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally{
			if(br != null){
				try {
					br.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

 

Test04：使用异常捕获机制完成下述读取操作

 * 读取emp.txt文件，并将每个员工信息读取出来，以一个Emp实例保存，然后将

 * 这些Emp实例存入到一个Map集合中。其中key为字符串，是该员工名字，而value

 * 是该Emp实例。

 * 存入后，要求用户输入一个员工的名字,如:张三

 * 若该员工存在则输出该员工所有信息(Emp的toString方法返回的字符串)

 * 输入的员工名若是英文，不要求区分大小写。

 * 若输入的员工名字不存在，则显示"查无此人"

 

public class Test04 {
	public static void main(String[] args) {
		BufferedReader br = null;
		try {
			Map<String,Emp> map = new HashMap<String,Emp>();
			br = new BufferedReader(
				new InputStreamReader(
					Test04.class.getClassLoader().getResourceAsStream("day08/emp.txt")
				)	
			);
			String line = null;
			//读取文件每一行并解析为一个Emp对象存入Map集合
			while((line = br.readLine())!=null){
				Emp emp = parseEmp(line);
				map.put(emp.getName().toLowerCase(), emp);
			}
			
			Scanner scanner = new Scanner(System.in);
			System.out.println("请输入员工姓名:");
			String name = scanner.nextLine().toLowerCase();
			if(map.containsKey(name)){
				Emp e = map.get(name);
				System.out.println(e);
			}else{
				System.out.println("查无此人");
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally{
			if(br != null){
				try {
					br.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
	/**
	 * 将一行字符串解析为一个Emp对象
	 * @param info
	 * @return
	 * @throws ParseException 
	 */
	public static Emp parseEmp(String info) throws ParseException{
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		String[] infos = info.split(",");
		String name = infos[0];
		int age = Integer.parseInt(infos[1]);
		String gender = infos[2];
		int salary = Integer.parseInt(infos[3]);
		Date hiredate = sdf.parse(infos[4]);
		Emp emp = new Emp(name, age, gender, salary, hiredate);
		return emp;
	}
}

 

Test05：使用异常捕获机制完成下述读取操作，并在finally中有关闭RandomAccessFile操作。

 * 将emp.dat文件中所有员工解析出来，并创建为若干Emp实例存入一个

 * 集合，然后按照员工入职从晚到早的顺序依次输出员工信息。

 *

 * 该文件560字节，每56个字节为一个员工的信息。

 * 其中:

 *  name为字符串，长度为32个字节，编码为:UTF-8

 *   age为short,长度为2个字节

 *  gender为字符串，长度为10个字节，编码为:UTF-8

 *  salary为int,长度为4个字节

 *  hiredate为long，长度为8个字节

 * 格式可参考当前包中emp.jpg图

public class Test05 {
	public static void main(String[] args) throws URISyntaxException, IOException, ParseException {
		//使用类加载器加载当前包中的emp.dat文件
		File file = new File(Test05.class.getClassLoader().getResource("day08/emp.dat").toURI());
		RandomAccessFile raf = new RandomAccessFile(file,"r");
		List<Emp> list = new ArrayList<Emp>();
		//解析10个员工信息
		for(int i=0;i<10;i++){
			//读取员工名字
			String name = readString(raf, 32).trim();
			short age = raf.readShort();
			String gender = readString(raf,10).trim();
			int salary = raf.readInt();
			long hiredate = raf.readLong();
			Emp e = new Emp(name,age,gender,salary,new Date(hiredate));
			list.add(e);
		}
		System.out.println("解析完毕!");
		//排序集合
		Collections.sort(list,new Comparator<Emp>(){
			public int compare(Emp e1, Emp e2) {				
				return e2.getHiredate().getTime()-e1.getHiredate().getTime()>0?1:-1;
			}
			
		});
		for(Emp e : list){
			System.out.println(e);
		}
	}
	/**
	 * 从当前RandomAccessFile当前位置读取指定长度的字节并以UTF-8编码
	 * 转换为字符串后返回
	 * @param raf
	 * @param len
	 * @return
	 * @throws IOException 
	 */
	public static String readString(RandomAccessFile raf,int len) throws IOException{
		byte[] data = new byte[len];
		raf.read(data);
		return new String(data,"UTF-8");
	}
}

 

Test06：使用异常捕获机制完成下述IO操作

 * 编写程序，要求下面的类实现功能:

 * 添加新员工

 * 要求用户输入一个员工信息，格式如下:

 * jackson,25,男,5000,2008-12-22

 * 用户输入后需要做下述验证:

 * 要求用户名长度在1-20个字符之间且必须是英文

 * 年龄在0-100之间的整数

 * 性别只能是:"男"或"女"

 * 当发现用户输入有不符合规定时，提醒用户

 * 相关内容输入不符合要求，并要求重新输入。

 * 都输入正确后，将该员工添加到emp.txt文件

 * 的最后一行。

 

public class Test06 {
	public static void main(String[] args) {
		try{
		Scanner scanner = new Scanner(System.in);
		while(true){
			System.out.println("请输入员工信息:");
			String info = scanner.nextLine();
			String[] infos = info.split(",");
			if(!checkName(infos[0])){
				System.out.println("名字只能是1-20位的英文");
				continue;
			}
			if(!checkGender(infos[2])){
				System.out.println("性别只能是:<男/女>");
				continue;
			}
			String name = infos[0];
			int age = Integer.parseInt(infos[1]);
			String gender = infos[2];
			int salary = Integer.parseInt(infos[3]);
			Date hiredate = parseDate(infos[4]);
			Emp e = new Emp(name, age, gender, salary, hiredate);
			saveEmp(e);
			System.out.println("保存完毕!");
			break;
		}
		}catch(Exception e){
			e.printStackTrace();
		}
	}
	public static void saveEmp(Emp e)throws IOException, URISyntaxException{
		PrintWriter pw = null;
		try{
			File file = new File("src/main/java/day08/emp.txt");
			System.out.println(file.getAbsolutePath());
			pw = new PrintWriter(
				new OutputStreamWriter(
					new FileOutputStream(file,true)	
				)	
			);
			pw.println(e);
		}finally{
			if(pw!=null){
				pw.close();
			}
		}
	}
	
	public static Date parseDate(String line) throws ParseException{
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		return sdf.parse(line);
	}
	
	public static boolean checkGender(String gender){
		String genderRegex = "[男女]";
		return gender.matches(genderRegex);
	
	}
	
	public static boolean checkName(String name){
		String nameRegex = "[a-zA-Z]{1,20}";
		return name.matches(nameRegex);
	}
}

 

Day09(线程，多线程)

 

Test01：使用线程方式一创建两个线程:分别输出1000次，你好和再见

public class Test01 {
	public static void main(String[] args) {
		Thread t1 = new MyThread1();
		Thread t2 = new MyThread2();
		t1.start();
		t2.start();
	}
}
class MyThread1 extends Thread{
	public void run(){
		for(int i=0;i<1000;i++){
			System.out.println("你好");
		}
	}
}
class MyThread2 extends Thread{
	public void run(){
		for(int i=0;i<1000;i++){
			System.out.println("再见");
		}
	}
}

Test02：使用线程方式二创建两个线程:分别输出1000次，你好和再见

public class Test02 {
	public static void main(String[] args) {
		Runnable r1 = new MyRunnable1();
		Runnable r2 = new MyRunnable2();
		Thread t1 = new Thread(r1);
		Thread t2 = new Thread(r2);
		t1.start();
		t2.start();
	}
}
class MyRunnable1 implements Runnable{
	public void run(){
		for(int i=0;i<1000;i++){
			System.out.println("你好");
		}
	}
}
class MyRunnable2 implements Runnable{
	public void run(){
		for(int i=0;i<1000;i++){
			System.out.println("再见");
		}
	}
}

 

Test03：使用匿名内部类方式创建两个线程:分别输出1000次，你好和再见

public class Test03 {
	public static void main(String[] args) {
		Thread t1 = new Thread(){
			public void run(){
				for(int i=0;i<1000;i++){
					System.out.println("你好");
				}
			}
		};
		
		Runnable r = new Runnable(){
			public void run(){
				for(int i=0;i<1000;i++){
					System.out.println("再见");
				}
			}
		};
		Thread t2 = new Thread(r);
		t1.start();
		t2.start();
	}
}

 

Test04：创建一个线程，每秒输出一次当前系统时间:yyyy-MM-dd HH:mm:ss

public class Test04 {
	public static void main(String[] args) {
		Thread t = new Thread(){
			public void run(){
				SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
				while(true){
					System.out.println(sdf.format(new Date()));
					try {
						Thread.sleep(1000);
					} catch (Exception e) {
						e.printStackTrace();
					}
				}				
			}
		};
		t.start();
	}
}

Day10：

两个配置文件：

config.txt内容：serverHost=localhost   /n  serverPort=8088

server-config.txt内容：serverPort=8088

将聊天室客户端今天写的内容独立完成一次，

 * 完成后，修改代码，使聊天室可以实现用户

 * 随意在控制台输入内容并发送给服务端。

 * 在构造方法中初始化Socket时，服务端的地址与端口通过读取当前包中的config.txt

 * 文件的两行内容得到，并依读取到的值初始化Socket。

Client：

 

public class Client {
	private Socket socket;
	
	public Client() throws Exception{
		try {
			//读取配置文件
			Map<String,String> config = loadConfig();
			String host = config.get("serverHost");
			int port = Integer.parseInt(config.get("serverPort"));
			socket = new Socket(host,port);
		} catch (Exception e) {
			throw e;
		}
	}
	/**
	 * 加载config.txt文件，读取每一行字符串，然后按照"="拆分，将等号左面的
	 * 内容作为key，等号右面的内容作为value存入Map然后返回。
	 * @return
	 * @throws Exception
	 */
	private Map<String,String> loadConfig() throws Exception{
		BufferedReader br = null;
		try {
			Map<String,String> map = new HashMap<String,String>();
			br = new BufferedReader(
				new InputStreamReader(
					Client.class.getClassLoader().getResourceAsStream("day10/config.txt")	
				)	
			);
			String line = null;
			while((line = br.readLine())!=null){
				String []info = line.split("=");
				map.put(info[0], info[1]);
			}
			return map;
		} catch (Exception e) {
			throw e;
		} finally{
			if(br != null){
				br.close();
			}
		}
	}
	
	public void start(){
		try {
			Scanner scanner = new Scanner(System.in);
			OutputStream out = socket.getOutputStream();
			OutputStreamWriter osw = new OutputStreamWriter(out,"UTF-8");
			PrintWriter pw = new PrintWriter(osw,true);
			
			String line = null;
			while(true){
				line = scanner.nextLine();
				pw.println(line);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		try {
			Client client = new Client();
			client.start();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

 

将聊天室服务端今天写的内容独立完成一次，

 * 完成后，修改代码，使得服务端可以一直读取

 * 客户端发送过来的每一条消息并输出到控制台。

 *

 * 初始化服务端时，读取当前包中server-config.txt文件的第一行，用该端口进行

 * ServerSocket的初始化。

Server：

public class Server {
	private ServerSocket server;
	
	public Server() throws Exception{
		try {
			//读取配置文件
			Map<String,String> config = loadConfig();
			int port = Integer.parseInt(config.get("serverPort"));
			server = new ServerSocket(port);
		} catch (Exception e) {
			throw e;
		}
	}
	/**
	 * 加载server-config.txt文件，读取每一行字符串，然后按照"="拆分，将等号左面的
	 * 内容作为key，等号右面的内容作为value存入Map然后返回。
	 * @return
	 * @throws Exception
	 */
	private Map<String,String> loadConfig() throws Exception{
		BufferedReader br = null;
		try {
			Map<String,String> map = new HashMap<String,String>();
			br = new BufferedReader(
				new InputStreamReader(
					Client.class.getClassLoader().getResourceAsStream("day10/server-config.txt")	
				)	
			);
			String line = null;
			while((line = br.readLine())!=null){
				String []info = line.split("=");
				map.put(info[0], info[1]);
			}
			return map;
		} catch (Exception e) {
			throw e;
		} finally{
			if(br != null){
				br.close();
			}
		}
	}
	public void start(){
		try {
			System.out.println("等待客户端连接...");
			Socket socket = server.accept(); 
			System.out.println("一个客户端连接了...");
			
			InputStream in = socket.getInputStream();
			InputStreamReader isr = new InputStreamReader(in,"UTF-8");
			BufferedReader br = new BufferedReader(isr);
			String line = null;
			while((line = br.readLine())!=null){
				System.out.println("客户端说:"+line);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		try {
			Server server = new Server();
			server.start();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

 

Day11(dom4j,SAX)

 

Test01: 解析前需要修改pom.xml文档，加载dom4j的jar包。

 * 将emp.xml文件中的员工信息解析出来并以Emp实例保存到一个集合中然后

 * 按照工资从高到低的顺序输出每个员工信息

public class Test01 {
	public static void main(String[] args) {
		try {
			SAXReader reader = new SAXReader();
			Document doc = reader.read(Test01.class.getClassLoader().getResourceAsStream("day12/emp.xml"));
			Element root = doc.getRootElement();
			List<Element> list = root.elements();
			List<Emp> emps = new ArrayList<Emp>();
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			for(Element empEle : list){
				int id = Integer.parseInt(empEle.attribute("id").getValue());
				String name = empEle.elementText("name");
				int age = Integer.parseInt(empEle.elementText("age"));
				String gender = empEle.elementText("gender");
				int salary = Integer.parseInt(empEle.elementText("salary"));
				Date hiredate = sdf.parse(empEle.elementText("hiredate"));
				Emp e = new Emp(id, name, age, gender, salary, hiredate);
				emps.add(e);
			}
			System.out.println(emps);
			//按照工资倒序排列
			Collections.sort(emps,new Comparator<Emp>(){
				public int compare(Emp o1, Emp o2) {
					return o2.getSalary()-o1.getSalary();
				}
			});
			System.out.println(emps);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

 

Test02: 要求用户控制台输入想输入的员工人数（至少5个），然后依序输入员工信息，每行为

 * 一条员工信息，格式如:1,张三,25,男,5000,2006-3-18

 * 每当输入一个员工后，要检查新输入的员工的id是否已经存在，即：不能在本次输入的

 * 这些员工信息中出现相同id的员工。

 * 然后按照emp.xml的格式，将这些员工写入到myemp.xml文档中。

public class Test02 {
	public static void main(String[] args) {
		try {
			Collection<Emp> emps = getEmp(5);
			writeXml(emps,"myemp.xml");
		} catch (ParseException e) {
			e.printStackTrace();
		}
	}
	public static void writeXml(Collection<Emp> emps,String fileName){
		XMLWriter writer = null;
		try {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			Document doc = DocumentHelper.createDocument();
			Element root = doc.addElement("list");
			for(Emp emp : emps){
				Element empEle = root.addElement("emp");
				empEle.addAttribute("id", String.valueOf(emp.getId()));
				empEle.addElement("name").addText(emp.getName());
				empEle.addElement("age").addText(String.valueOf(emp.getAge()));
				empEle.addElement("gender").addText(emp.getGender());
				empEle.addElement("salary").addText(String.valueOf(emp.getSalary()));
				empEle.addElement("hiredate").addText(sdf.format(emp.getHiredate()));
			}
			writer = new XMLWriter(new FileOutputStream(fileName),OutputFormat.createPrettyPrint());
			writer.write(doc);
			System.out.println("写出完毕");
		} catch (Exception e) {
			e.printStackTrace();
		} finally{
			if(writer != null){
				 try {
					writer.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
	/**
	 * 该方法用来获取用户输入的若干员工信息，并存入到一个集合后返回
	 * @param num 要输入的员工数量
	 * @return
	 * @throws ParseException 
	 */
	public static Collection<Emp> getEmp(int num) throws ParseException{
		Map<Integer,Emp> emps = new LinkedHashMap<Integer,Emp>();
		if(num<1){
			System.out.println("人数至少为1！");
			return null;
		}
		Scanner scanner = new Scanner(System.in);
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		int i = 1;
		while(true){
			System.out.println("请输入第"+i+"个员工信息:");
			String line = scanner.nextLine();
			String data[] = line.split(",");
			if(data.length!=6){
				System.out.println("员工信息有误！");
				continue;
			}
			
			int id = Integer.parseInt(data[0]);
			if(emps.containsKey(id)){
				System.out.println("id:"+id+"已经存在！");
				continue;
			}
			String name = data[1];
			int age = Integer.parseInt(data[2]);
			String gender = data[3];
			int salary = Integer.parseInt(data[4]);
			Date hiredate = sdf.parse(data[5]);
			Emp emp = new Emp(id, name, age, gender, salary, hiredate);
			emps.put(id, emp);
			if(++i>num){
				break;
			}
		}
		return emps.values();
	} 
	
}

 

Test03: 将emp.dat文件中所有员工解析出来，并创建为若干Emp实例存入一个

 * 集合，id从1开始，自动为每个员工分配。之后按照emp.xml的格式将

 * 这些员工写入到emplist.xml文档中

 * 该文件800字节，每80个字节为一个员工的信息。

 * 其中:

 *  name为字符串，长度为32个字节，编码为:UTF-8

 *   age为int,长度为4个字节

 *  gender为字符串，长度为10个字节，编码为:UTF-8

 *  salary为int,长度为4个字节

 *  hiredate为字符串，长度为30个字节，编码为:UTF-8  内容格式:yyyy-MM-dd(由于长度30，后面可能会存在空白，注意去除)

 * 格式可参考当前包中emp.jpg图

public class Test03 {
	public static void main(String[] args) {
		try{
			List<Emp> list = getEmp();
			Test02.writeXml(list,"emplist.xml");
		}catch(Exception e){
			e.printStackTrace();
		}
	}
	/**
	 * 读取所有员工信息
	 * @return
	 * @throws Exception 
	 */
	public static List<Emp> getEmp() throws Exception{
		List<Emp> list = new ArrayList<Emp>();
		RandomAccessFile raf = null;
		try {
			File file = new File(Test03.class.getClassLoader().getResource("day12/emp.dat").toURI());
			raf = new RandomAccessFile(file,"r");	
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			//解析10个员工信息
			for(int i=1;i<=10;i++){
				//读取员工名字
				String name = readString(raf, 32).trim();
				int age = raf.readInt();
				String gender = readString(raf,10).trim();
				int salary = raf.readInt();
				String hiredate = readString(raf,30).trim();
				Emp e = new Emp(i,name,age,gender,salary,sdf.parse(hiredate));
				list.add(e);
			}
		} catch (Exception e) {
			throw e;
		} finally{
			if(raf!=null){
				try {
					raf.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		return list;
	}
	/**
	 * 从当前RandomAccessFile当前位置读取指定长度的字节并以UTF-8编码
	 * 转换为字符串后返回
	 * @param raf
	 * @param len
	 * @return
	 * @throws IOException 
	 */
	public static String readString(RandomAccessFile raf,int len) throws IOException{
		byte[] data = new byte[len];
		raf.read(data);
		return new String(data,"UTF-8");
	}

}

Test04: 

 * 解析emplist.xml文档，将所有的员工以Emp对象

 * 存入到一个Map中，key为该员工id。

 * 然后要求用户输入一个id，若该员工存在，则输出

 * 该员工入职30周年纪念日。

 * 纪念日为当周的周一的日期。

 * 若该员工不存在，则输出查无此人

public class Test04 {
	public static void main(String[] args) {
		try {
			SAXReader reader = new SAXReader();
			Document doc = reader.read(new FileInputStream("emplist.xml"));
			Element root = doc.getRootElement();
			List<Element> list = root.elements();
			Map<Integer,Emp> emps = new HashMap<Integer,Emp>();
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			for(Element empEle : list){
				int id = Integer.parseInt(empEle.attribute("id").getValue());
				String name = empEle.elementText("name");
				int age = Integer.parseInt(empEle.elementText("age"));
				String gender = empEle.elementText("gender");
				int salary = Integer.parseInt(empEle.elementText("salary"));
				Date hiredate = sdf.parse(empEle.elementText("hiredate"));
				Emp e = new Emp(id, name, age, gender, salary, hiredate);
				emps.put(id,e);
			}

			Scanner scanner = new Scanner(System.in);
			System.out.println("请输入员工id:");
			int id = Integer.parseInt(scanner.nextLine());
			if(emps.containsKey(id)){
				Emp emp = emps.get(id);
				Calendar calendar = Calendar.getInstance();
				calendar.setTime(emp.getHiredate());
				calendar.add(Calendar.YEAR, 30);
				calendar.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
				System.out.println(emp.getName()+"的入职时间为："+sdf.format(emp.getHiredate())+",30周年纪念日为:"+sdf.format(calendar.getTime()));
			}else{
				System.out.println("查无此人！");
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}