java_String(API),正则,流,集合,map,等各种案例练习题

 

 

day01 

package day01;
/**
 * 1:输出字符串"HelloWorld"的字符串长度
 * 2:输出"HelloWorld"中"o"的位置
 * 3:输出"HelloWorld"中从下标5出开始第一次出现"o"的位置
 * 4:截取"HelloWorld"中的"Hello"并输出
 * 5:截取"HelloWorld"中的"World"并输出
 * 6:将字符串"  Hello   "中两边的空白去除后输出
 * 7:输出"HelloWorld"中第6个字符"W"
 * 8:输出"HelloWorld"是否是以"h"开头和"ld"结尾的。
 * 9:将"HelloWorld"分别转换为全大写和全小写并输出。
 * @author Xiloer
 *
 */
public class Test01 {
	public static void main(String[] args) {
		String str = "HelloWorld";
		String str1 = "  Hello   ";
		test1(str);
		//以下自行调用test2,test3...等方法。
		test2(str);
		test3(str);
		test4(str);
		test5(str);
		test6(str1);
		test7(str);
		test8(str);
		test9(str);
	}
	/**
	 * 以当前方法为例，下面继续编写test2,test3...等方法。
	 * 每个方法中实现类描述中的一个需求。
	 * 当前方法实现:1输出字符串"HelloWorld"的字符串长度
	 * 
	 * test2实现:2:输出"HelloWorld"中"o"的位置
	 * 以此类推。
	 * @param str
	 */
	public static void test1(String str){
		System.out.println("len:"+str.length());
	}
	/**
	 * 输出str中"o"的位置
	 * @param str
	 */
	public static void test2(String str){
		System.out.println("index of 'o':"+str.indexOf('o'));
	}
	/**
	 * 输出"HelloWorld"中从下标5出开始第一次出现"o"的位置
	 */
	public static void test3(String str){
		System.out.println("index of 'o':"+str.indexOf('o',5));
	}
	/**
	 * 截取"HelloWorld"中的"Hello"并输出
	 */
	public static void test4(String str){
		System.out.println("sub:"+str.substring(0, 5));
	}
	/**
	 * 截取"HelloWorld"中的"World"并输出
	 * @param str
	 */
	public static void test5(String str){
		System.out.println("sub:"+str.substring(5));
	}
	/**
	 * 将字符串"  Hello   "中两边的空白去除后输出
	 * @param str
	 */
	public static void test6(String str){
		System.out.println("trim:"+str.trim());
	}
	/**
	 * 输出"HelloWorld"中第6个字符"W"
	 * @param str
	 */
	public static void test7(String str){
		System.out.println("charAt:"+str.charAt(5));
	}
	/**
	 * 输出"HelloWorld"是否是以"h"开头和"ld"结尾的。
	 * @param str
	 */
	public static void test8(String str){
		System.out.println("startsWith:"+str.startsWith("h"));
		System.out.println("endsWith:"+str.endsWith("ld"));
	}
	/**
	 * 将"HelloWorld"分别转换为全大写和全小写并输出。
	 * @param str
	 */
	public static void test9(String str){
		System.out.println("upper:"+str.toUpperCase());
		System.out.println("lower:"+str.toLowerCase());
	}
	
}

package day01;
/**
 * 将"大家好!"修改为:"大家好!我是程序员!"并输出。
 * 然后将"大家好!我是程序员!"修改为:"大家好!我是优秀的程序员!"并输出
 * 然后再修改为:"大家好!我是牛牛的程序员!"并输出
 * 然后在修改为:"我是牛牛的程序员!"并输出
 * @author Xiloer
 *
 */
public class 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());
		
	}
}

package day01;
/**
 * 检查一个字符串是否为回文
 * 回文:正着念与反着念一样，例如:上海自来水来自海上
 * 
 * @author Xiloer
 *
 */
public class Test03 {
	public static void main(String[] args) {
		/*
		 * 编写一个回文字符串，然后调用check方法检查
		 * 该字符串是否为回文，然后输出检查结果。
		 * 若是回文则输出:是回文
		 * 否则输出:不是回文
		 */
		String str = "上海自来水来自海上";
		if(check(str)){
			System.out.println("是回文");
		}else{
			System.out.println("不是回文");
		}
	}
	/**
	 * 判读该方法是否是回文
	 * @param str 需要判断的字符串
	 * @return true表示是回文，false表示不是回文
	 */
	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);
	}
}

package day01;

import java.util.Scanner;

/**
 * 要求用户从控制台输入一个email地址，然后获取该email的用户名(@之前的内容)
 * @author Xiloer
 *
 */
public class Test04 {
	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);
		}
	}
}

package day01;

import java.util.Random;
import java.util.Scanner;

/**
 * 随机生成一个5位的英文字母验证码(大小写混搭)
 * 然后将该验证码输出给用户，然后要求用户输入该验证码，大小写不限制。
 * 然后判定用户输入的验证码是否有效(无论用户输入大小写，只要字母都正确即可)。
 * @author Xiloer
 *
 */
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();
	}
}

package day01;

import java.util.Scanner;

/**
 * 要求用户输入一个计算表达式，可以使用加减乘除。
 * 只处理一次运算的，不要有连续加减乘除的表达式,且不做小数计算。(例:1+2+3)
 * 例如:
 * 1+2
 * 然后经过处理计算结果并输出:1+2=3
 * @author Xiloer
 *
 */
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 

package day02;
/**
 * 定义私有属性:
 * String name;
 * int age;
 * String gender;
 * int salary;
 * 定义全参数(该构造方法的参数用于设置所有属性)构造方法与默认构造方法
 * 重写toString方法，返回字符串格式如:"张三,25,男,5000"
 * 重写equals方法，要求名字相同就认为内容一致。
 * @author Xiloer
 *
 */
public class Person {
	private String name;
	private int age;
	private String gender;
	private int salary;
	
	public Person(String name, int age, String gender, int salary) {
		super();
		this.name = name;
		this.age = age;
		this.gender = gender;
		this.salary = salary;
	}

	public boolean equals(Object obj){
		if(obj==null){
			return false;
		}
		if(obj==this){
			return true;
		}
		if(obj instanceof Person){
			Person p = (Person)obj;
			return p.name.equals(this.name);
		}
		return false;
	}
	
	public String toString(){
		return name+","+age+","+gender+","+salary;
	}
	
}

package day02;

import java.util.Scanner;

/**
 * 要求用户输入一个字符串，然后若该字符串是一个整数，则转换为整数后输出乘以10后的结果
 * 若是小数，则转换为一个小数后输出乘以5后的结果，若不是数字则输出"不是数字"
 * 需要使用正则表达式进行判断。
 * @author Xiloer
 *
 */
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("不是数字");
		}
		
		
	}
}

package day02;
/**
 * 将字符串123,456,789,012根据","拆分，并输出拆分后的每一项
 * @author Xiloer
 *
 */
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]);
		}
		
		String imageName="1.jpg";
		String name=imageName.substring(imageName.lastIndexOf("."));
		imageName=System.currentTimeMillis()+name;
		System.out.println(imageName);
		
	
		
	}
}

package day02;

import java.util.Scanner;

/**
 * 输入一个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})
 * @author Xiloer
 *
 */
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]);
		}
	}
}

package day02;
/**
 * 将字符串"123abc456def789ghi"中的英文部分替换为"#char#"
 * @author Xiloer
 *
 */
public class Test04 {
	public static void main(String[] args) {
		String str = "123abc456def789ghi";
		str = str.replaceAll("[a-zA-Z]+", "#char#");
		System.out.println(str);
	}
	
}


class AAA{
	private static String name;
	
	public static void main(String[] args) {
		name="dd";
		
	}
}

package day02;

import java.util.Scanner;

/**
 * 实现文件重命名。
 * 要求用户输入一个文件名称，例如:abc.jpg
 * 然后对该名字进行重新命名，输出的格式为:系统时间毫秒值.jpg
 * 例如:1465266796279.jpg
 * @author Xiloer
 *
 */
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);
		
		//还有其他方式，请自行思考
	}
}

package day02;

import java.util.Scanner;

/**
 * 测试正则表达式，并尝试编写规则: 电话号码可能有3-4位区号，
 * 7-8位号码:0415-5561111
 * @author Xiloer
 *
 */
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("不是电话号码");
		}
		
	}
}

package day02;

import java.util.Scanner;

/**
 * 输入一个数学计算表达式，如:1+2
 * 然后输出计算后的结果:1+2=3
 * 这里计算表达式只计算一次即可，可以使用加减乘除任意一个,可以进行小数运算。
 * @author Xiloer
 *
 */
public class Test07 {
	public static void main(String[] args) {
		Scanner scan=new Scanner(System.in);
		String regex="[0-9\\.]+[\\+\\-\\*\\/][0-9\\.]+";
		String temp=scan.next();
		if(temp.matches(regex)){
			int index=0,num=0;
			if(temp.indexOf("+")>=0){
				num=0;
				index=temp.indexOf("+");
			}
			if(temp.indexOf("-")>=0){
				num=1;
				index=temp.indexOf("-");
			}
			if(temp.indexOf("*")>=0){
				num=2;
				index=temp.indexOf("*");
			}
			if(temp.indexOf("/")>=0){
				num=3;
				index=temp.indexOf("/");
			}
			
			String temp1=temp.substring(0, index);
			String temp2=temp.substring(index+1,temp.length());
			double leftNum=Double.parseDouble(temp1);
			double rightNum=Double.parseDouble(temp2);
			double sum=0;
			switch(num){
			case 0:
				sum=leftNum+rightNum;
				System.out.println(temp1+"+"+temp2+"=");
				break;
			case 1:
				sum=leftNum-rightNum;
				System.out.println(temp1+"-"+temp2+"=");
				break;
			case 2:
				sum=leftNum*rightNum;
				System.out.println(temp1+"*"+temp2+"=");
				break;
			case 3:
				sum=leftNum/rightNum;
				System.out.println(temp1+"/"+temp2+"=");
				break;
				
				default:
					System.out.println("错误");
					break;
			}
			String str=String.valueOf(sum);
			String regex1="[0]+";
			if(str.substring(str.indexOf(".")+1).matches(regex1)){
				System.out.println((int)sum);
			}else{
				System.out.println(sum);
			}
		}
		else {
			System.out.println("格式错误");
		}
	}
}

package day02;

import java.util.Scanner;

/**
 * 要求用户输入若干员工信息，格式为：
 * name,age,gender,salary;name,age,gender,salary;....
 * 例如:
 * 张三,25,男,5000;李四,26,女,6000;...
 * 然后将每个员工信息解析成Person对象。并存入到一个数组中。
 * 然后循环数组，输出每一个员工信息(输出使用toString返回的字符串)
 * @author Xiloer
 *
 */
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

package day03;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 定义私有属性:
 * String name;
 * int age;
 * String gender;
 * int salary;
 * Date hiredate;//入职时间
 * 
 * 定义构造方法，以及属性get,set方法.
 * 定义toString方法，格式如:
 *    姓名:张三,年龄:25,性别:男,薪资:5000,入职时间:2006-02-15
 * 
 * 定义equals方法，要求只要名字相同，则认为内容一致。
 * @author Xiloer
 *
 */
public class Emp {
	private String name;
	private int age;
	private String gender;
	private int salary;
	private Date hiredate;
	public Emp(String name, int age, String gender, int salary, Date hiredate) {
		super();
		this.name = name;
		this.age = age;
		this.gender = gender;
		this.salary = salary;
		this.hiredate = hiredate;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
	public int getSalary() {
		return salary;
	}
	public void setSalary(int salary) {
		this.salary = salary;
	}
	public Date getHiredate() {
		return hiredate;
	}
	public void setHiredate(Date hiredate) {
		this.hiredate = hiredate;
	}
	public boolean equals(Object obj){
		if(obj==null){
			return false;
		}
		if(obj==this){
			return true;
		}
		if(obj instanceof Emp){
			Emp emp = (Emp)obj;
			return emp.name.equals(this.name);
		}
		return false;
	}
	
	public String toString(){
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		return "姓名:"+name+",年龄:"+age+",性别:"+gender+",薪资:"+salary+",入职时间:"+sdf.format(hiredate);
	}
}

package day03;

import java.util.Date;

/**
 * 使用Date输出当前系统时间，以及3天后这一刻的时间
 * @author Xiloer
 *
 */
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);
	}
}

package day03;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 将当前系统时间以"yyyy-MM-dd HH:mm:ss"格式输出
 * @author Xiloer
 *
 */
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));
	}
}

package day03;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

/**
 * 输入某人生日，格式为"yyyy-MM-dd"，输出到现在为止经过了多少周。
 * @author Xiloer
 *
 */
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+"周");
	}
}

package day03;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Scanner;

/**
 * 输入一个生产日期格式"yyyy-MM-dd",再输入一个数字(保质期的天数)。
 * 然后经过计算输出促销日期，促销日期为:该商品过期日前2周的周三
 * @author Xiloer
 *
 */
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));
		
	}
}

package day03;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Scanner;

/**
 * 实现时间的计算: 要求用户输入身份证号，若格式有误，要求其重新输入。然后根据身份证号码输出20岁生日
 * 所在周的周三的日期。
 * 例如:
 * 出生日期:1992-07-15。
 * 20岁生日:2012-07-15
 * 当周的周三为:2012-07-18
 * 
 * @author Xiloer
 *
 */
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.set(Calendar.MONTH,5);
		
		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()));
	}
}

package day03;

import java.util.ArrayList;
import java.util.Collection;

/**
 * 创建一个集合，存放字符串"one","two"，"three"
 * 然后输出该集合的元素个数。
 * 然后输出该集合是否包含字符串"four"
 * 然后输出集合是否不含有任何元素
 * 然后清空集合
 * 然后输出该集合的元素个数
 * 然后输出集合是否不含有任何元素
 * @author Xiloer
 *
 */
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());
	}
}

package day03;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Scanner;

/**
 * 要求用户首先输入员工数量，然后输入相应员工信息，格式为：
 * name,age,gender,salary,hiredate
 * 例如:
 * 张三,25,男,5000,2006-02-15
 * 每一行为一个员工信息，然后将每个员工信息解析成Emp对象。并存入到一个集合中。
 * 在解析成Emp对象后要先查看当前集合是否包含该员工，若包含则提示该用于已存在，
 * 否则才存入集合。
 * 然后输出集合查看每个员工信息.
 * @author Xiloer
 *
 */
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

package day04;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 定义私有属性:
 * String name;
 * int age;
 * String gender;
 * int salary;
 * Date hiredate;//入职时间
 * 
 * 定义构造方法，以及属性get,set方法.
 * 定义toString方法，格式如:
 *    张三,25,男,5000,2006-02-15
 * 
 * 定义equals方法，要求名字以及年龄相同，则认为内容一致。
 * @author Xiloer
 *
 */
public class Emp {
	private String name;
	private int age;
	private String gender;
	private int salary;
	private Date hiredate;
	public Emp(String name, int age, String gender, int salary, Date hiredate) {
		super();
		this.name = name;
		this.age = age;
		this.gender = gender;
		this.salary = salary;
		this.hiredate = hiredate;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
	public int getSalary() {
		return salary;
	}
	public void setSalary(int salary) {
		this.salary = salary;
	}
	public Date getHiredate() {
		return hiredate;
	}
	public void setHiredate(Date hiredate) {
		this.hiredate = hiredate;
	}
	public boolean equals(Object obj){
		if(obj==null){
			return false;
		}
		if(obj==this){
			return true;
		}
		if(obj instanceof Emp){
			Emp emp = (Emp)obj;
			return emp.name.equals(this.name)&&emp.age==this.age;
		}
		return false;
	}
	
	public String toString(){
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		return name+","+age+","+gender+","+salary+","+sdf.format(hiredate);
	}
}

package day04;

import java.util.ArrayList;
import java.util.Collection;

/**
 * 创建一个集合c1，存放元素"one","two","three"
 * 再创建一个集合c2，存放元素"four","five","six"
 * 然后将c2元素全部存入c1集合
 * 然后在创建集合c3,存放元素"one,five"
 * 然后输出集合c1是否包含集合c3的所有元素
 * 然后将c1集合中的"two"删除后再输出c1集合
 * @author Xiloer
 *
 */
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);
	}
}

package day04;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**
 * 创建一个集合，存放元素"1","$","2","$","3","$","4"
 *   使用迭代器遍历集合，并在过程中删除所有的"$"，
 *   最后再将删除元素后的集合使用新循环遍历，并输出每一个元素。
 * @author Xiloer
 *
 */
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);
		}
	}
}

package day04;

import java.util.LinkedList;
import java.util.List;

/**
 * 创建一个List集合(ArrayList,LinkedList均可)
 * 存放元素"one","two","three","four"。
 * 获取集合第二个元素并输出。
 * 将集合第三个元素设置为"3"
 * 在集合第二个位置上插入元素"2"
 * 删除集合第三个元素。
 * @author Xiloer
 *
 */
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);
		
		
	}
}

package day04;

import java.util.ArrayList;
import java.util.List;

/**
 * 创建一个List集合并添加元素0-9
 * 然后获取子集[3,4,5,6]
 * 然后将子集元素扩大10倍
 * 然后输出原集合。
 * 之后删除集合中的[7,8,9]
 * @author Xiloer
 *
 */
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);
	}
}

package day04;

import java.util.ArrayList;
import java.util.List;

/**
 * 创建一个List集合，并添加元素0-9
 * 将集合转换为一个Integer数组并输出数组每一个元素
 * @author Xiloer
 *
 */
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);
		}
	}
}

package day04;

import java.util.Arrays;
import java.util.List;

/**
 * 创建一个字符串数组:{"one","two","three"}
 * 然后将该数组转换为一个List集合
 * @author Xiloer
 *
 */
public class Test06 {
	public static void main(String[] args) {
		String[] arr = {"one","two","three"};
		List<String> list = Arrays.asList(arr);
		System.out.println(list);
 	}
}

package day04;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

/**
 * 创建一个List集合，并存放10个随机数，然后排序该集合
 * 后输出
 * @author Xiloer
 *
 */
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);
	}
}

package day04;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.Scanner;

/**
 * 通过控制台输入3个日期(yyyy-MM-dd格式)，然后转换为Date对象后存入
 * 集合，然后对该集合排序后输出所有日期。
 * @author Xiloer
 *
 */
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);
	}
}

package day04;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Scanner;

/**
 * 要求用户输入若干员工信息，格式为：
 * name,age,gender,salary,hiredate;name,age,gender,salary,hiredate;....
 * 例如:
 * 张三,25,男,5000,2006-02-15;李四,26,女,6000,2007-12-24;...
 * 然后将每个员工信息解析成Emp对象。并存入到一个集合中。
 * 然后循环集合，输出每一个员工信息(输出使用toString返回的字符串)
 * 然后输出每个员工的转正仪式日期。
 * 转正仪式日期为:入职3个月的当周周五
 * 
 * @author Xiloer
 *
 */
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

package day05;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 定义私有属性:
 * String name;
 * int age;
 * String gender;
 * int salary;
 * Date hiredate;//入职时间
 * 
 * 定义构造方法，以及属性get,set方法.
 * 定义toString方法，格式如:
 *    姓名:张三,年龄:25,性别:男,薪资:5000,入职时间:2006-02-15
 * 
 * 定义equals方法，要求名字以及年龄相同，则认为内容一致。
 * 
 * 实现Comparable接口，并重写抽象方法comparaTo()，比较规则为年龄小的人小。
 * @author Xiloer
 *
 */
public class Emp implements Comparable<Emp>{
	private String name;
	private int age;
	private String gender;
	private int salary;
	private Date hiredate;
	public Emp(String name, int age, String gender, int salary, Date hiredate) {
		super();
		this.name = name;
		this.age = age;
		this.gender = gender;
		this.salary = salary;
		this.hiredate = hiredate;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
	public int getSalary() {
		return salary;
	}
	public void setSalary(int salary) {
		this.salary = salary;
	}
	public Date getHiredate() {
		return hiredate;
	}
	public void setHiredate(Date hiredate) {
		this.hiredate = hiredate;
	}
	public boolean equals(Object obj){
		if(obj==null){
			return false;
		}
		if(obj==this){
			return true;
		}
		if(obj instanceof Emp){
			Emp emp = (Emp)obj;
			return emp.name.equals(this.name)&&emp.age==this.age;
		}
		return false;
	}
	
	public String toString(){
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		return "姓名:"+name+",年龄:"+age+",性别:"+gender+",薪资:"+salary+",入职时间:"+sdf.format(hiredate);
	}
	public int compareTo(Emp e) {
		return this.age - e.age;
	}

}

package day05;

import java.util.LinkedList;
import java.util.Queue;

/**
 * 创建一个队列，存入Integer类型元素1,2,3,4,5
 * 然后遍历队列并输出每个元素
 * @author Xiloer
 *
 */
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());
		}
	}
}

package day05;

import java.util.Deque;
import java.util.LinkedList;

/**
 * 创建一个栈，存入Integer类型元素1,2,3,4,5
 * 然后遍历队列并输出每个元素
 * @author Xiloer
 *
 */
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());
		}
	}
}

package day05;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.Scanner;

/**
 * 要求用户输入若干员工信息，格式为：
 * name,age,gender,salary,hiredate;name,age,gender,salary,hiredate;....
 * 例如:
 * 张三,25,男,5000,2006-02-15;李四,26,女,6000,2007-12-24;...
 * 然后将每个员工信息解析成Emp对象。并存入到一个List集合中。
 * 并对集合排序，然后输出每个员工信息。
 * 
 * 再根据员工的入职时间排序，入职晚的在前，早的在后并
 * 输出每个员工的信息。
 * 
 * @author Xiloer
 *
 */
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;
	}
	
	
	
	
	
	
	
	
}

package day05;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

/**
 *创建一个Map，保存某个学生的成绩:
 *在控制台输入该学生成绩，格式:
 *科目:成绩;科目:成绩;...
 *例如:  
 *语文:99;数学:98;英语:97;物理:96;化学:95
 *然后输出物理的成绩。
 *然后将化学的成绩设置为96
 *然后删除英语这一项。
 *然后遍历该Map分别按照遍历key，Entry，value
 *的形式输出该Map信息。
 * @author Xiloer
 *
 */
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);
		}
	}
}

package day05;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

/**
 * 有下列字符串:
 * 销售:张三;财务:李四;销售:王五;财务:赵六;程序:mike;程序:jerry;美工:jackson;前端:green;前端:nick;程序:钱七;销售:alice
 * 分析上述字符串然后统计每个职位总共多少人?
 * 使用Map保存统计的结果，其中key:职位,value为该职位人数
 * 然后分别输出各职位的名称(keySet),各职位人数(entrySet)
 * @author Xiloer
 *
 */
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(";");
		System.out.println(Arrays.toString(emps));
		System.out.println();
		Map<String,Integer> map = new HashMap<String,Integer>();

		for(String emp : emps){
			String []info = emp.split(":");
			System.out.println(Arrays.toString(info));
			System.out.println();
			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

package day06;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 定义私有属性:
 * String name;
 * int age;
 * String gender;
 * int salary;
 * Date hiredate;//入职时间
 * 
 * 定义构造方法，以及属性get,set方法.
 * 定义toString方法，格式如:
 *    张三,25,男,5000,2006-02-15
 * 
 * 定义equals方法，要求名字相同，则认为内容一致。
 * @author Xiloer
 *
 */
public class Emp {
	private String name;
	private int age;
	private String gender;
	private int salary;
	private Date hiredate;
	public Emp(String name, int age, String gender, int salary, Date hiredate) {
		super();
		this.name = name;
		this.age = age;
		this.gender = gender;
		this.salary = salary;
		this.hiredate = hiredate;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
	public int getSalary() {
		return salary;
	}
	public void setSalary(int salary) {
		this.salary = salary;
	}
	public Date getHiredate() {
		return hiredate;
	}
	public void setHiredate(Date hiredate) {
		this.hiredate = hiredate;
	}
	public boolean equals(Object obj){
		if(obj==null){
			return false;
		}
		if(obj==this){
			return true;
		}
		if(obj instanceof Emp){
			Emp emp = (Emp)obj;
			return emp.name.equals(this.name);
		}
		return false;
	}
	
	public String toString(){
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		return name+","+age+","+gender+","+salary+","+sdf.format(hiredate);
	}
	public int compareTo(Emp e) {
		return this.age - e.age;
	}
}

package day06;

import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 通过File输出当前项目目录下的文件"myfile.txt"的名字，大小，最后修改时间。
 * 最后修改时间格式如:2016-03-23 14:22:16
 * @author Xiloer
 *
 */
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)));
	}
}

package day06;

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

/**
 * 要求用户输入一个文件名并使用File在当前目录下创建出来。
 * 若该文件已经存在，则提示用户该文件已经存在。并创建该文件副本：
 * 例如:用户输入"test.txt".若该文件已存在，提示用户存在后，创建名为：test_副本1.txt 的文件
 * 若该文件也存在了，则创建名为:test_副本2.txt 的文件，以此类推
 * @author Xiloer
 *
 */
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("文件创建完毕!");
	}
}

package day06;

import java.io.File;
import java.util.Scanner;

/**
 * 要求用户输入一个目录名并使用File在当前目录下创建出来。
 * 若该目录已经存在，则提示用户该目录已经存在。并创建副本，原则与第二题一致。
 * @author Xiloer
 *
 */
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("目录创建完毕!");
	}
}

package day06;

import java.io.File;

/**
 * 获取并输出当前目录下的所有文件和目录的名字
 * @author Xiloer
 *
 */
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());
		}
	}
}

package day06;

import java.io.File;
import java.util.Scanner;

/**
 * 要求用户输入一个文件或目录名，并删除当前目录下的该文件或目录。
 * 可自行手动先在当前项目目录中创建一个要删除的文件或目录，若是目录，还可以
 * 在该目录中继续创建若干级目录和文件。
 * @author Xiloer
 *
 */
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();
	}
}

package day06;

import java.io.File;
import java.io.FileFilter;

/**
 * 获取并输出当前目录下所有文件的名字
 * @author Xiloer
 *
 */
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());
		}
	}
}

package day06;

import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.Scanner;

/**
 * 要求用户输入一个文件名，并复制当前目录中该文件，并取名为"原文件名_copy.后缀名"
 * 定义两个方法分别使用单字节形式复制，以及字节数组形式复制
 * @author Xiloer
 *
 */
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();
		
	
	}
}

package day06;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;

/**
 * 创建一个"raf.dat"的文件，并在其中写出一个int的最大值，long的最大值，
 * 然后将其分别读取出来并输出
 * @author Xiloer
 *
 */
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();
	}
}

package day06;

import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.Scanner;

/**
 * 创建一个文件"note.txt",然后通过控制台输入的每一行字符串都按行写入到
 * note.txt中。当输入的字符串为"exit"时退出程序。
 * @author Xiloer
 *
 */
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();
	}
}

package day06;

import java.io.IOException;
import java.io.RandomAccessFile;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

/**
 * 要求用户输入一个员工信息，格式为：
 * name,age,gender,salary,hiredate
 * 例如:
 * 张三,25,男,5000,2006-02-15
 * 然后将输入的员工信息解析成Emp对象。
 * 然后将该Emp对象的toString返回的字符串写入到文件中，该文件的
 * 名字为:name.emp,以上面的例子，那么该文件名为:张三.emp
 * 至少运行5次该程序，输入五个员工信息，并生成5个文件。

 * @author Xiloer
 *
 */
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();
		
		
	}
}

package day06;

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.List;

/**
 * 编写一个程序，将当前目录下所有员工文件进行读取，并解析出所有员工为Emp
 * 对象并存入集合。然后排序该集合，按照员工的年龄排序，年龄大的靠前，年龄小
 * 的靠后。排序完毕后输出结果。
 * @author Xiloer
 *
 */
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;
	}
}

package day06;

import java.io.File;
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

/**
 * 编写一个程序，将当前目录下所有的员工文件进行读取，并解析出所有员工为Emp
 * 对象并存入Map。其中key为该员工的名字，value为该员工的emp对象。
 * 然后，要求用户输入一个员工名字，若该员工存在，则输出该员工的名字，年龄，工资，以及入职20周年的纪念日当周的周六的日期。
 * 即:输入名字"张三"
 * 若该员工存在，则输出如下格式:
 * 张三,25,5000,2006-02-14
 * 入职20周年纪念日派对日期: 2026-02-14  （注:若入职日期为:2006-02-14）
 * 若该员工不存在，则输出:"查无此人"
 * @author Xiloer
 *
 */
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("查无此人");
		}
	}
}

package day06;

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.net.URISyntaxException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;

/**
 * 将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方法。依次类推。
 * @author Xiloer
 *
 */
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

package day07;

import java.io.Serializable;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 定义私有属性:
 * String name;
 * int age;
 * String gender;
 * int salary;
 * Date hiredate;//入职时间
 * 
 * 定义构造方法，以及属性get,set方法.
 * 定义toString方法，格式如:
 *    姓名:张三,年龄:25,性别:男,薪资:5000,入职时间:2006-02-15
 * 
 * 定义equals方法，要求名字，年龄，性别，薪资都相同，则认为内容一致。
 * 实现序列化接口，并定义版本号。
 * @author Xiloer
 *
 */
public class Emp implements Serializable{
	private static final long serialVersionUID = 1L;
	private String name;
	private int age;
	private String gender;
	private int salary;
	private Date hiredate;
	public Emp(String name, int age, String gender, int salary, Date hiredate) {
		super();
		this.name = name;
		this.age = age;
		this.gender = gender;
		this.salary = salary;
		this.hiredate = hiredate;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
	public int getSalary() {
		return salary;
	}
	public void setSalary(int salary) {
		this.salary = salary;
	}
	public Date getHiredate() {
		return hiredate;
	}
	public void setHiredate(Date hiredate) {
		this.hiredate = hiredate;
	}
	public boolean equals(Object obj){
		if(obj==null){
			return false;
		}
		if(obj==this){
			return true;
		}
		if(obj instanceof Emp){
			Emp emp = (Emp)obj;
			return emp.name.equals(this.name)&&emp.age==this.age&&emp.gender.equals(this.gender)&&emp.salary==this.salary;
		}
		return false;
	}
	
	public String toString(){
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		return "姓名:"+name+",年龄:"+age+",性别:"+gender+",薪资:"+salary+",入职时间:"+sdf.format(hiredate);
	}
	
}

package day07;

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

/**
 * 使用文件流复制myfile.txt文件为myfile_cp.txt
 * @author Xiloer
 *
 */
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();
	}
}

package day07;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 使用缓冲流复制myfile.txt文件为myfile_cp2.txt
 * @author Xiloer
 *
 */
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();
	}
}

package day07;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

/**
 * 要求用户控制台输入想输入的员工人数（至少5个），然后依序输入员工信息，每行为
 * 一条员工信息，格式如:张三,25,男,5000,2006-3-18
 * 然后将该对象写入到文件<name>.obj并保存到当前项目根目录中，例如:张三.obj。
 * @author Xiloer
 *
 */
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();
	}
}

package day07;

import java.io.File;
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * 读取当前项目根目录下所有后缀为.obj的文件，将这些Emp对象读取出来
 * 并存入到一个List集合中，然后按照员工工资从多到少的顺序依次输出员工信息
 * @author Xiloer
 *
 */
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;
	}
}






class AAA{
	public static void main(String[] args) {
		for(int i=1;i<=9;i++){
			for(int r=1;r<=i;r++){
				 System.out.print(r*i);
			}
			System.out.println();
		}
	}
}

package day07;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

/**
 * 使用字符流复制当前程序的源文件到当前项目根目录下。
 * @author Xiloer
 *
 */
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();
	}
}

package day07;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Scanner;

/**
 * 记事本功能，首先要求用户输入一个文件名，并将该文件创建出来，
 * 然后通过控制台输入的每一行字符串都按行写入到该文件中，并
 * 使用GBK编码保存。当输入的字符串为"exit"时退出程序。
 * @author Xiloer
 *
 */
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();
		 
	}
	
}

package day07;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Scanner;

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

package day08;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 定义私有属性:
 * String name;
 * int age;
 * String gender;
 * int salary;
 * Date hiredate;//入职时间
 * 
 * 定义构造方法，以及属性get,set方法.
 * 
 * 定义toString方法，格式如:
 *    张三,25,男,5000,2006-02-15
 * 
 * 定义equals方法，要求名字，年龄，性别，薪资都相同，则认为内容一致。
 * @author Xiloer
 *
 */
public class Emp {
	private String name;
	private int age;
	private String gender;
	private int salary;
	private Date hiredate;
	public Emp(String name, int age, String gender, int salary, Date hiredate) {
		super();
		this.name = name;
		this.age = age;
		this.gender = gender;
		this.salary = salary;
		this.hiredate = hiredate;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
	public int getSalary() {
		return salary;
	}
	public void setSalary(int salary) {
		this.salary = salary;
	}
	public Date getHiredate() {
		return hiredate;
	}
	public void setHiredate(Date hiredate) {
		this.hiredate = hiredate;
	}
	public boolean equals(Object obj){
		if(obj==null){
			return false;
		}
		if(obj==this){
			return true;
		}
		if(obj instanceof Emp){
			Emp emp = (Emp)obj;
			return emp.name.equals(this.name)&&emp.age==this.age&&emp.gender.equals(this.gender)&&emp.salary==this.salary;
		}
		return false;
	}
	
	public String toString(){
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		return name+","+age+","+gender+","+salary+","+sdf.format(hiredate);
	}
}

package day08;

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

/**
 * 对myfile.txt文件进行复制操作，要求使用异常捕获
 * 机制对流的异常进行捕获和处理，finally中
 * 要将流关闭
 * @author Xiloer
 *
 */
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();
				}
			}
		}
	}
}

package day08;

import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Scanner;

/**
 * 使用异常捕获完成下述操作
 * 将控制台输入的每一行字符串使用缓冲字符输出流PrintWriter
 * 按行以GBK编码写入到文件note.txt中
 * @author Xiloer
 *
 */
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();			
		}
	}
}

package day08;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * 使用异常捕获机制完成下述读取操作。
 * 使用缓冲流读取note.txt文件，并将每行字符串输出到控制台上
 * @author Xiloer
 *
 */
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();
				}
			}
		}
	}
}

package day08;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

/**
 * 使用异常捕获机制完成下述读取操作
 * 读取emp.txt文件，并将每个员工信息读取出来，以一个Emp实例保存，然后将
 * 这些Emp实例存入到一个Map集合中。其中key为字符串，是该员工名字，而value
 * 是该Emp实例。
 * 存入后，要求用户输入一个员工的名字,如:张三
 * 若该员工存在则输出该员工所有信息(Emp的toString方法返回的字符串)
 * 输入的员工名若是英文，不要求区分大小写。
 * 若输入的员工名字不存在，则显示"查无此人"
 * 
 * @author Xiloer
 *
 */
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;
	}
}

package day08;

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.net.URISyntaxException;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
/**
 * 使用异常捕获机制完成下述读取操作，并在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图
 * @author Xiloer
 *
 */
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");
	}
}

package day08;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.URISyntaxException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

/**
 * 使用异常捕获机制完成下述IO操作
 * 编写程序，要求下面的类实现功能:
 * 添加新员工
 * 要求用户输入一个员工信息，格式如下:
 * jackson,25,男,5000,2008-12-22
 * 用户输入后需要做下述验证:
 * 要求用户名长度在1-20个字符之间且必须是英文
 * 年龄在0-100之间的整数
 * 性别只能是:"男"或"女"
 * 当发现用户输入有不符合规定时，提醒用户
 * 相关内容输入不符合要求，并要求重新输入。
 * 都输入正确后，将该员工添加到emp.txt文件
 * 的最后一行。
 * 
 * @author Xiloer
 *
 */
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

package day09;
/**
 * 使用线程方式一创建两个线程:分别输出1000次，你好和再见
 * @author Xiloer
 *
 */
public class Test01 {
	public static void main(String[] args) {
		Thread t1 = new MyThread1();
		Thread t2 = new MyThread2();
		t1.start();
		t2.start();
		
		//byte d=1+100;
		
	}
}
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("再见");
		}
	}
}

class D{
	protected  void a(){
		
	}
	
}
class E extends D{
	public   void a(){
		
	}
}

package day09;
/**
 * 使用线程方式二创建两个线程:分别输出1000次，你好和再见
 * @author Xiloer
 *
 */
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("再见");
		}
	}
}

package day09;
/**
 * 使用匿名内部类方式创建两个线程:分别输出1000次，你好和再见
 * @author Xiloer
 *
 */
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();
	}
}

package day09;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 创建一个线程，每秒输出一次当前系统时间:yyyy-MM-dd HH:mm:ss
 * @author Xiloer
 *
 */
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

package day10;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

/**
 * 将聊天室客户端今天写的内容独立完成一次，
 * 完成后，修改代码，使聊天室可以实现用户
 * 随意在控制台输入内容并发送给服务端。
 * 
 * 在构造方法中初始化Socket时，服务端的地址与端口通过读取当前包中的config.txt
 * 文件的两行内容得到，并依读取到的值初始化Socket。
 * @author Xiloer
 *
 */
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();
		}
	}
}

package day10;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;
import java.util.Map;

/**
 * 将聊天室服务端今天写的内容独立完成一次，
 * 完成后，修改代码，使得服务端可以一直读取
 * 客户端发送过来的每一条消息并输出到控制台。
 * 
 * 初始化服务端时，读取当前包中server-config.txt文件的第一行，用该端口进行
 * ServerSocket的初始化。
 * @author Xiloer
 *
 */
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

package day11;
/**
 * 将聊天室客户端内容独立完成一次.
 * 下面内容可以选做:
 * 修改代码，使聊天室可以实现用户自定义昵称，
 * 以及私聊功能。
 * 
 * 参考思路:
 * 客户端连接服务端后，要求用户输入一个昵称，
 * 然后将改昵称发送给服务端，服务端那边读取到
 * 客户端发送的第一个字符串认为是昵称。
 * 
 * 私聊功能可以定义格式，例如:
 * @张三:你好
 * 服务端在读取客户端发送过来的昵称时，需要进行
 * 解析，分解出昵称与聊天内容，然后将该聊天内容
 * 单独发送给指定昵称的用户。
 * 服务端的输出流需要使用Map进行维护，而不能再
 * 使用List，Map的key可以是该用户昵称，value
 * 为该用户输出流。
 * 
 * 
 * @author Xiloer
 *
 */
public class Client {

}

package day11;
/**
 * 将聊天室服务端内容独立完成一次
 * 下面内容可以选做:
 * 配合客户端实现支持昵称与私聊功能
 * @author Xiloer
 *
 */
public class Server {

}

day12

package day12;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 定义私有属性:
 * int id;
 * String name;
 * int age;
 * String gender;
 * int salary;
 * Date hiredate;//入职时间
 * 
 * 定义构造方法，以及属性get,set方法.
 * 
 * 定义toString方法，格式如:
 *    id:1,姓名:张三,年龄:25,性别:男,薪资:5000,入职时间:2006-02-15
 * 
 * 定义equals方法，要求id相同，则认为内容一致。
 * @author Xiloer
 *
 */
public class Emp {
	private int id;
	private String name;
	private int age;
	private String gender;
	private int salary;
	private Date hiredate;
	public Emp(int id, String name, int age, String gender, int salary, Date hiredate) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
		this.gender = gender;
		this.salary = salary;
		this.hiredate = hiredate;
	}
	
	public Emp(){}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getGender() {
		return gender;
	}

	public void setGender(String gender) {
		this.gender = gender;
	}

	public int getSalary() {
		return salary;
	}

	public void setSalary(int salary) {
		this.salary = salary;
	}

	public Date getHiredate() {
		return hiredate;
	}

	public void setHiredate(Date hiredate) {
		this.hiredate = hiredate;
	}
	
	@Override
	public String toString() {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		return "id:"+id+",姓名:"+name+",年龄:"+age+",性别:"+gender+",薪资:"+salary+",入职时间:"+sdf.format(hiredate);
	}
}

package day12;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.List;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

/**
 * 解析前需要修改pom.xml文档，加载dom4j的jar包。
 * 将emp.xml文件中的员工信息解析出来并以Emp实例保存到一个集合中然后
 * 按照工资从高到低的顺序输出每个员工信息
 * @author Xiloer
 *
 */
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();
		}
	}
}

package day12;

import java.io.FileOutputStream;
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Collection;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Scanner;

import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;

/**
 * 要求用户控制台输入想输入的员工人数（至少5个），然后依序输入员工信息，每行为
 * 一条员工信息，格式如:1,张三,25,男,5000,2006-3-18
 * 每当输入一个员工后，要检查新输入的员工的id是否已经存在，即：不能在本次输入的
 * 这些员工信息中出现相同id的员工。
 * 然后按照emp.xml的格式，将这些员工写入到myemp.xml文档中。
 * @author Xiloer
 *
 */
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();
	} 
	
}

package day12;

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * 将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图
 * @author Xiloer
 *
 */
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");
	}

}

package day12;

import java.io.FileInputStream;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

/**
 * 解析emplist.xml文档，将所有的员工以Emp对象
 * 存入到一个Map中，key为该员工id。
 * 然后要求用户输入一个id，若该员工存在，则输出
 * 该员工入职30周年纪念日。
 * 纪念日为当周的周一的日期。
 * 若该员工不存在，则输出查无此人
 * @author Xiloer
 *
 */
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();
		}
	}
}

se_day05

package se.day05;

import java.io.File;
import java.io.IOException;

public class FileDemo2 {

	public static void main(String[] args) throws IOException {
		File file=new File("log.txt");{
			file.createNewFile();
			System.out.println("创建完毕");
		}

	}

}