java第五周总结

之前基于面向对象及逻辑算法实现过动态日历，发现要写很多逻辑判断或者算法，现在基于Calendar实现动态日历，底层已经完成了很多算法及判断，大量的减少了代码量。

public class CalendarDemo {
	public static void main(String[] args) {
		Calendar c = Calendar.getInstance();
		Scanner sc = new Scanner(System.in);
		System.out.println("今年输入那一年");
		int year = sc.nextInt();
		System.out.println("今年输入那一月");
		int month = sc.nextInt() - 1;
		c.set(Calendar.MONTH, month);
		c.set(Calendar.YEAR, year);
		System.out.println("=====================[" + year + "年" + (month + 1) + "月]======================");
		System.out.println("一\t二\t三\t四\t五\t六\t日");
		int i = c.getActualMaximum(Calendar.DAY_OF_MONTH);
		int space = c.get(Calendar.DAY_OF_WEEK) - 1;
		for (int j = 0; j <= space; j++) {
			System.out.print("\t");
		}
		for (int j = 1; j <= i; j++) {
			if ((space + j) % 7 == 0) {
				System.out.println();
			}
			System.out.print(j + "\t");

		}

正则表达式

正则表达式是一组由字母和符号组成的特殊文本, 它可以用来从文本中找出满足你想要的格式的句子

简单案例：

String a = "13567845635";
//判断两个字符串是否完全一致
System.out.println(a.equals("13567845634"));
//判断当前String对象是否匹配给定的正则表达式（ 匹配手机号格式字符串）
System.out.println(a.matches("^1\\d{10}$"));

题目：在歌词里找关键词

public static void main(String[] args) {
		Pattern p = Pattern.compile("月亮");
		Matcher m = p.matcher( "看月亮爬上来 看月亮爬上来 看月亮爬上来 失眠的夜漫漫飘过来 想念的心没什么阻碍好像听说最近你也在失眠 一个人发呆 喜欢你笑得像个小孩 想每天和你粘在一块 听一首老歌就会流泪的女孩 没我可怎么办 我们一起看月亮爬上来 你也在失眠想着你的最爱 我们一起看月亮爬上来 你也在失眠想有美好未来 我们一起看月亮爬上来 你也在失眠谁在为谁等待 我们一起看月亮爬上来 失眠的夜爱的人会不会向你告白 喜欢你笑得像个小孩 想每天和你粘在一块 听一首老歌就会流泪的女孩 没我可怎么办 我们一起看 月亮爬上来 你也在失眠想着你的最爱我们一起看 月亮爬上来 你也在失眠想有美好未来 我们一起看 月亮爬上来 你也在失眠谁在为谁等待 我们一起看 月亮爬上来 失眠的夜爱的人会不会向你告白 ");
		int count = 0;
		while(m.find()) {
			count++;
		}
		System.out.println(count);
	}

基于文件读取完成代码行数的查看

private static ArrayList<File> javaFiles = new ArrayList<File>();

	/**
	 * 	读取指定的目录获取所有的java文件的绝对路径
	 * @param dir
	 * @return
	 */
	public static void readAndStoreJavaFile(File dir) {
		File[] files = dir.listFiles();
		if(Objects.nonNull(files)) {
			for (File f : files) {
				if(f.isDirectory()) {
					readAndStoreJavaFile(f);
				}
				//获取所有的java文件
				if(f.getName().endsWith(".java")) {
					//将java文件加入容器中
					javaFiles.add(f);
				}
			}
		}
	} 
	
	/**
	 * 	读取指定的java文件并返回文件中的代码内容
	 * @param file
	 * @return
	 */
	public static String readJavaFile(File file) {
		StringBuffer sb = new StringBuffer();
		BufferedReader br = null;
		try {
			InputStream is = new FileInputStream(file);
			br = new BufferedReader(new InputStreamReader(is));
			String str = "";
			
			while((str = br.readLine())  != null) {
				sb.append(str).append("\n");
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			try {
				if(br != null)br.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return sb.toString();
	}
	
	//总代码行数
	static final Pattern REGEX_CODE_LINES = Pattern.compile("\\n");
	//空白代码行数
	static final Pattern WHITE_CODE_LINES = Pattern.compile("\\n\\s*\\n");
	public static void main(String[] args) {
		int i = 0;
		int j = 0;
		File dir = new File("C:\\eclipse-workspace");
		readAndStoreJavaFile(dir);
		for (File file : javaFiles) {
			String code = readJavaFile(file);
			Matcher m = REGEX_CODE_LINES.matcher(code);
			Matcher m1 = WHITE_CODE_LINES.matcher(code);
			while(m.find()) {
				i++;
			}
			while(m1.find()) {
				j++;
			}
		}
		System.out.println("总代码数为:"+i);
		System.out.println("空白代码数为:"+j);
	}

运行结果：

正则表达式三种模式

• 贪婪模式：贪婪模式即从匹配到的位置开始一直往后依次搜索，并且会回溯
• 独占模式：一直往后搜索会将后续的所有字符串进行匹配
• 懒惰模式：找到即结束

基于面向对象及正则完成的通讯录

联系人类：

public class Contact {
		/**编号*/
		private int id;
		private String phone;
		private String name;
		private int qq;
		private String mail;
		
		//构造器
		//getter/setter		
		//toString()
		}
		}

联系人管理类

package com.day02;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.omg.CORBA.CODESET_INCOMPATIBLE;

public class ContactManage {
	/** 初始化一个集合 */
	static ArrayList<Contact> list = new ArrayList<Contact>();
	/** 电话正则表达式 */
	String regex = "^1[356789]\\d{9}";

	/**
	 * 添加联系人的方法
	 * @param c
	 * @return
	 * @throws MyException 
	 */
	public boolean addContact(Contact c) {
		return list.add(c);
	}
	
	/** 根据姓名或者手机号查找联系人 */
	public Contact findContact(String str) {
		for (Contact c : list) {
			if (str.matches(regex) || str.equals(c.getName())) {
				return c;
			}
		}
		return null;
	}
	public List<Contact> findAllContact(){
		return list;
	}
	/**
	 *  删除联系人
	 * @param id
	 */
	public boolean delContact(int id) {
		Integer i = Integer.valueOf(getIndex(id));
		return list.remove(i);
	}
	/**
	 * 根据id找到集合中元素索引
	 * @param id
	 * @return
	 */
	public int getIndex(int id) {
		for (int i = 0; i < list.size(); i++) {
			if(id == list.get(i).getId()) {
				return i;
			}
	}
		return -1;
}
}

测试类:

public class Test {

	private Scanner sc = new Scanner(System.in);
	private ContactManage c = new ContactManage();

	public void menu() {
		p("******************欢迎使用通讯录******************");
		p("*\t\t[0]退出\t\t\t\t*");
		p("*\t\t[1]添加联系人\t\t\t*");
		p("*\t\t[2]删除联系人\t\t\t*");
		p("*\t\t[3]根据姓名查询联系人\t\t*");
		p("*\t\t[4]根据电话查询联系人\t\t*");
		p("*\t\t[5]显示全部联系人\t\t\t*");
		p("*************************************************");
		stare();
	}

	private void stare() {
		System.out.println("请输入正确的指令");
		String input = sc.next();
		if (!input.matches("[0-5]")) {
			stare();
		}
		switch (input) {
		case "1":
			addContact();
			break;
		case "2":
			delContact();
			break;
		case "3":
			findContact();
			break;
		case "4":
			findContactByName();
			break;
		case "5":	
			findAllContact();
			break;
		case "0":
			p("谢谢使用，再见");
			System.exit(0);
			break;
		}
	}
	/**
	 * 查询全部联系人
	 */
	private void findAllContact() {
		List<Contact> list = c.findAllContact();
		for (Contact contact : list) {
			p(contact);
		}
		menu();
	}

	/**
	 * 删除联系人
	 */
	private void delContact() {
		p("根据编号删除指定编号的联系人");
		String input = sc.next();
		if (!input.matches("\\d.+")) {
			p("请输入数字");
			delContact();
		} else {
			if (!c.delContact(Integer.parseInt(input))) {
				p("删除成功");
				menu();
			}else {
				p("没有该联系人");
				menu();
			}
			
		}
	}

	
	
	/** 根据姓名查询联系人 */
	private void findContactByName() {
		p("请输入你要查询的关键词");
		String input = sc.next();
		if (!input.matches(".+")) {
			p("信息有误!");
			findContact();
		} else {
			p(c.findContact(input));
			menu();
		}
	}

	/** 根据电话查询联系人 */
	private void findContact() {
		p("请输入你要查询的关键词");
		String input = sc.next();
		if (!input.matches("1\\d{10}")) {
			p("信息有误!");
			findContact();
		} else {
			p(c.findContact(input));
			menu();
		}
	}

	private void addContact() {
		// int id, String phone, String name, int qq, String mail
		p("请输入联系人信息(id/电话/姓名/qq/邮箱/)");
		String input = sc.next();
		if (!input.matches("\\d+/1\\d{10}/.+/\\d{4,11}/[1-9]\\d{5,11}@qq\\.com")) {
			p("请输入正确的联系人信息");
			addContact();
		} else {
			String[] split = input.split("/");
			Contact contact = new Contact(Integer.parseInt(split[0]), split[1], split[2], Integer.parseInt(split[3]),
					split[4]);
			if (c.addContact(contact)) {
				p("添加成功");
				menu();
			} else {
				p("添加失败");
				addContact();
			}
		}
	}

	private void p(Object msg) {
		System.out.println(msg);
	}

	public static void main(String[] args) {
		new Test().menu();
	}

集合

Collection是顶层接口，Set（无序集合）和List(有序集合)都是从Collection实现而来。

List:有序且可以重复
list集合的三种实现类

• ArrayList
• LinkedList
• Vector

ArrayList、LinkedList、Vector的区别

首先，它们都属于List接口的实现，是基于数组及数组拷贝的实现，但Vector属于老式集合（jdk1.0)，并且属于线程安全的实现，容量是通过三木运算进行两倍扩充的。而ArrayList和LinkedList都属于线程不安全的实现，ArrayList也是基于数组及数组拷贝的方式完成的实现，容量是通过位运算完成1.5倍的扩充。ArrayList数据查询较快，修改较慢。LinkedList基于双向链表实现的，数据查询较慢，但修改较快。

List list = new ArrayList();
		list.add("jack");
		list.add("faker");
		list.add("cike");
		list.add("rose");
		list.add("tarloy");
		
		ListIterator it = list.listIterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		//逆向排序
		System.out.println("==================");
		while(it.hasPrevious()) {
			System.out.println(it.previous());
		}

		LinkedList list = new LinkedList();
			list.add("yuxia");
			list.add("rose");
			list.add("jerry");
			list.add("faker");
			list.add("theshy");
			list.add("sindy");
			
			list.addFirst("baby");
			list.addLast("JustBir");
			Collections.sort(list);
			System.out.println(list);
			list.clear();
		
			Iterator it = list.iterator();
			while(it.hasNext()) {
				System.out.println(it.next());
			}

集合排序

Collections中用于实现集合排序的方法有如下两个：

1. sort(List list)
2. sort(List list,Comparator c)

Comparable & Compartor

1. 实现Comparable接口并且重写ComparTo方法
2. 直接使用Collections.sort使用匿名累内部类的形式进行比较
3. 实现Compartor接口重写ComparTo方法，然后将调用

User类

public class User {
		private String name;
		private int id;
		private Date bir;
		private double score;
		
		public User(String name, int id, Date bir, double score) {
			super();
			this.name = name;
			this.id = id;
			this.bir = bir;
			this.score = score;
		}
		public String getName() {
			return name;
		}
		public void setName(String name) {
			this.name = name;
		}
		public int getId() {
			return id;
		}
		public void setId(int id) {
			this.id = id;
		}
		public Date getBir() {
			return bir;
		}
		public void setBir(Date bir) {
			this.bir = bir;
		}
		public double getScore() {
			return score;
		}
		public void setScore(double score) {
			this.score = score;
		}

测试类

public static void main(String[] args) {
		List<User> list = new ArrayList();
		list.add(new User("李四", 1002, new Date(103, 11, 7), 98.2));
		list.add(new User("王五", 1003, new Date(99, 7, 1), 43.1));
		list.add(new User("来福", 1004, new Date(100, 7, 1), 85.3));
		list.add(new User("旺财", 1005, new Date(102, 8, 2), 54.1));
		// 方法一
		Collections.sort(list, new Comparator<User>() {
			@Override
			public int compare(User o1, User o2) {
				// 分数的高低进行排序
				return (int) (o1.getScore() - o2.getScore());
			}
		});
		for (Object object : list) {
			System.out.println(object);
		}
		System.out.println("=============方法二=============");
		// 直接用list对象调
		list.sort(new Comparator<User>() {
			@Override
			public int compare(User o1, User o2) {
				// 对id进行排序
				return o2.getId() - o1.getId();
			}
		});
		for (Object object : list) {
			System.out.println(object);
		}
		// 方法三,自己创建类实现comparator接口
		System.out.println("==============方法三=============");
		MyComparator comparator = new MyComparator();
		Collections.sort(list, comparator);
		for (Object object : list) {
			System.out.println(object);
		}
	}

运行结果

中文排序

导入此jar包

List<String> list = new ArrayList();
			list.add("王老师");
			list.add("徐老师");
			list.add("胡老师");
			list.add("阿老师");
			list.add("波老师");
			list.add("刘老师");
			list.add("吴老师");
		
			Collections.sort(list,new Comparator<String>() {
				@Override
				public int compare(String s1, String s2) {
					String name = "";
					String name1 = "";
					for (int i = 0																																																																																																																													; i < s1.length(); i++) {
						//将字符串的拼音列出来，
						char c = s1.charAt(i);
						String s = PinyinHelper.toHanyuPinyinStringArray(c)[0];
						//用name来接收
						name += s;
					}
					for (int i = 0; i < s2.length(); i++) {
						char c = s2.charAt(i);
						String s = PinyinHelper.toHanyuPinyinStringArray(c)[0];
						name1 += s;
					}
					//将两个字符串转化成拼音后的比较
					return name.compareTo(name1);
				}
			});
			for (Object object : list) {
				System.out.println(object);
			}
		}	

运行结果