第十二次课总结及思考

       本次课上了一个白天，虽然很累。但是相比学到的知识，这些累、这些付出都是值得的。学习安卓、学习安卓所用到的java知识，这些过程都需要我们学习之人要这些困难。好了，废话不多说，下面开始对这次课进行总结，以及谈谈我对其中的一些知识点的思考。

       本次课的内容有很多，主要是上一次课中讲到的java类库的其他两个类Date类和Calendar类、集合和泛型，特别是集合中的Collection接口和它的子接口Set、List、集合中的Map类、异常等知识

     Java类库之Date类

              1、Date类用于表示当前的日期和时间

              2、构造器：

                   (1))ew Date()

                   (2)new Date(long millionseconds)：传入从1970年1月1日算起的毫秒数

              下面通过代码介绍Date的一些常用方法：

import java.util.Date;

public class TestDate {

	public static void main(String[] args) {

		Date date = new Date();
		
		System.out.println("日期时间完整表示：" + date.toString());
		
		System.out.println("日期时间完整表示：" + date.toGMTString());
		System.out.println("日期时间完整表示：" + date.toLocaleString());
		System.out.println("当前毫秒数:" + date.getTime());
		System.out.println("年:" + date.getYear());
		//月份从0开始
		System.out.println("月:" + date.getMonth());
		System.out.println("日子:" + date.getDate());
		System.out.println("时:" + date.getHours());
		System.out.println("分:" + date.getMinutes());
		System.out.println("秒:" + date.getSeconds());
		//星期从0开始（星期日）
		System.out.println("星期:" + date.getDay());
		
	}

}

运行结果：

日期时间完整表示：Mon Jul 18 23:17:46 CST 2016
日期时间完整表示：18 Jul 2016 15:17:46 GMT
日期时间完整表示：2016-7-18 23:17:46
当前毫秒数:1468855066639
年:116
月:6
日子:18
时:23
分:17
秒:46
星期:1

       Java类库之Calendar类

                 1、使用Calendar类的原因：

                       由于Date的大多数方法已经废弃（deprecated），所以一般用Calendar类来表示年月日时分秒

                 2、Calendar是一个抽象类，不能直接实例化，要通过Calendar.getInstance()获取实例

                 3、与Date类的相互转换：

import java.util.Calendar;
import java.util.Date;

public class DateAndCalendar {

	public static void main(String[] args) {

		Calendar c = Calendar.getInstance();
		Date date = c.getTime();
		System.out.println(date);
		
		Date d2 = new Date();
		Calendar c2 = Calendar.getInstance();
		c2.setTime(d2);
		System.out.println(c2.getTime());
	}

}

运行结果：

Mon Jul 18 23:40:51 CST 2016
Mon Jul 18 23:40:51 CST 2016

                4、下面通过一个例子的代码（n年前的今天的日历信息）来介绍Calander的常用方法以及SimpleDateFormat类格式化输出的具有应用：
                     需要说明的一点：Calendar的add(int field,int amount)方法： 将指定日历加上或者减去指定的时间量

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

public class TestCalendar {
	
	private static final String [] DAY_OF_WEEK = {"星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
	private void TestCalendar() {
		
	}

	public static void main(String[] args) {

		System.out.println("----当前日期信息----");
		System.out.println(TestCalendar.getCurrentDateInfo(0));
		
		
		System.out.println("----n年前的今天----");
		System.out.println(TestCalendar.getCurrentDateInfo(-2));
		
	}

	public static String getCurrentDateInfo(int deta){
		String result = "";
		Calendar calendar = Calendar.getInstance();
		//n年前的今天
		calendar.add(Calendar.YEAR, deta);
		//ay、aM、ad、ah、am、as

		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss a");//eg.上午
//		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss am");//eg.上午40
//		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
		
		result += "当前日期：" + simpleDateFormat.format(calendar.getTime()) + "\n";
		result += "当前年份：" + calendar.get(Calendar.YEAR) + "\n";
		//月份从0开始
		result += "当前月份：" + (calendar.get(Calendar.MONTH) + 1) + "\n";
		result += "当前日子：" + calendar.get(Calendar.DAY_OF_MONTH) + "\n";
		result += "时：" + calendar.get(Calendar.HOUR_OF_DAY) + "\n";//24小时制
		//result += "时：" + calendar.get(Calendar.HOUR);//12小时制
		result += "分：" + calendar.get(Calendar.MINUTE) + "\n";
		result += "秒：" + calendar.get(Calendar.SECOND) + "\n";
		result += "上午/下午：" + (calendar.get(Calendar.AM_PM)==0?"AM":"PM") + "\n";
		
		result += DAY_OF_WEEK[calendar.get(Calendar.DAY_OF_WEEK) - 1] + "\n";
		return result;
	}
	
}

运行结果：

----当前日期信息----
当前日期：2016-07-18 11:50:31 下午
当前年份：2016
当前月份：7
当前日子：18
时：23
分：50
秒：31
上午/下午：PM
星期一

----n年前的今天----
当前日期：2014-07-18 11:50:31 下午
当前年份：2014
当前月份：7
当前日子：18
时：23
分：50
秒：31
上午/下午：PM
星期五

            集合和泛型

                      集合

                        1、Java的集合类用于储存数量不等的对象，主要由两个接口派生而出：Collection和Map，Collection和Map是Java集合框架的根接口，这两个接口又包含了一些接口或实现类

                             Collection类接口是List、set、queue接口的父接口。

                          2、Set和List接口是Collection接口派生的两个子接口，Queue是Java提供的队列实现，类似于List。

                          3、Set:无序集合、其元素不可重复，访问集合中的元素可以根据元素的索引来访问；

                               List：有序集合，其元素可重复，访问集合中的元素只能根据元素本身来访问（也是Set集合里元素不允许重复的原因）；

                               Map：具有映射关系的集合（key-value）

                               对于Set、List和Map三种集合，最常用的实现类分别是HashSet、ArrayList和HashMap三个实现类

                                 (1)下面通过代码介绍HashSet的几个常用方法和Iterator的使用：

package jiekouhefanxing_12th;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;

public class TestSet {

	public static void main(String[] args) {

		 
		 HashSet<String> namesHashSet = new HashSet<String>();
//		 namesHashSet.add(new String("zzz")); 
//		 namesHashSet.add(new String("zzz")); 
//		 namesHashSet.add(new String("zzz"));
		 namesHashSet.add("zzz"); 
		 namesHashSet.add("zzz"); 
		 namesHashSet.add("zzz");
		 System.out.println("检查HashSet里面元素是否重复：" + namesHashSet.toString());
		 
		 String str = new String("111");
		 System.out.println("字符串\"111\"的hashCode:"+ str.hashCode());
		 

		HashSet<Object> books = new HashSet<Object>();
		// books.add(new TestB());
		// books.add(new TestB());
		// books.add(new TestC().hashCode());
		// books.add(new TestC().hashCode());
		books.add("java");
		// books.add("java");
		books.add("Ph");
		books.add("obj-c");
		Iterator<Object> iterator = books.iterator();
		System.out.println("Set集合中元素顺序是不保证的");
		System.out.println("利用Iterator遍历集合元素：");
		while (iterator.hasNext()) {
			System.out.println(iterator.next());

		}
		System.out.println("利用foreach遍历集合元素:");
		for (Object object : books) {
			System.out.println(object);
		}
		// System.out.println(books.toString());
	}

}

运行结果：

检查HashSet里面元素是否重复：[zzz]
字符串"111"的hashCode:48657
Set集合中元素顺序是不保证的
利用Iterator遍历集合元素：
java
obj-c
Ph
利用foreach遍历集合元素:
java
obj-c
Ph

                                 

                                  注意：如何判断Set中的两个元素是否一致？

                                             用集合元素的equals()方法和验证其HashCode是否都相等

                                 (2)下面通过代码介绍ArrayList的的几个常用方法：

                                     

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class TestArrayList {

	public static void main(String[] args) {

		ArrayList<Integer> list = new ArrayList<Integer>();
		//增加元素
		for (int i = 0; i < 5; i++) {
			list.add(i);
		}
		//打印集合中的元素
		System.out.println(list.toString());
		//得到集合的元素个数
		System.out.println("得到集合的元素个数： " + list.size());
		//在指定下标增加新的元素
		list.add(2, 100);
		System.out.println(list.toString());
		//删除指定下标的元素
		list.remove(3);
		System.out.println(list.toString());
		// sort，默认升序ASC、DESC（降序）
		//升序排列
		Collections.sort(list);
		System.out.println(list.toString());
		// 降序排列
		Comparator<Integer> reverseOrder = Collections.reverseOrder();
		Collections.sort(list, reverseOrder);
		System.out.println(list.toString());

	}

}

运行结果：

[0, 1, 2, 3, 4]
得到集合的元素个数： 5
[0, 1, 100, 2, 3, 4]
[0, 1, 100, 3, 4]
[0, 1, 3, 4, 100]
[100, 4, 3, 1, 0]

                                     (3)下面通过代码介绍HashMap的几个常用方法：

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

public class MapTest {

	public static void main(String[] args) {

		Map<String, Object> dataMap = new HashMap<String, Object>();
		dataMap.put("name", "张三");
		dataMap.put("name", "李四");
		dataMap.put("gender", "male");
		System.out.println(dataMap.toString());// 同一key:后者覆盖了前者
		System.out.println(dataMap.get("gender"));

		System.out.println();
		Set<String> keys = dataMap.keySet();
		for (String k : keys) {
			String value = dataMap.get(k).toString();
			System.out.println(value);
		}
	}

}

运行结果：

{name=李四, gender=male}
male

李四
male

              一个实用的例子：用Map集合，找出给定的字符串数组中各个元素及其出现的总次数

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

public class MapAndStrArr {

	public static void main(String[] args) {

		String[] strArr = { "a", "b", "a", "b", "c", "a", "b", "c", "b", };

		 System.out.println(parseStrArr(strArr).toString());
	}
	public static Map<String, Integer> parseStrArr(String[] strArr) {
		Map<String, Integer> data = new HashMap<String, Integer>();

		for (String arr : strArr) {
			data.put(arr, data.get(arr) == null ? 1 : data.get(arr) + 1);

		}

		return data;
	}
}

运行结果：

{b=4, c=2, a=3}

                             (4)比较List和Map的效率：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

public class CompareListAndMap {

	public static void main(String[] args) {

		int count = 10000000;
		long startTime = System.currentTimeMillis();

		Map<Integer, Integer> data = new HashMap<Integer, Integer>();
		for (int i = 0; i < count; i++) {
			data.put(i, i);

		}

		long endTime = System.currentTimeMillis();
		System.out.println("map.put()耗时 ：" + (endTime - startTime));

		long startTime3 = System.currentTimeMillis();

		for (int i = 0; i < count; i++) {
			data.get(i);
		}
		long endTime3 = System.currentTimeMillis();
		System.out.println("map.get()耗时 ：" + (endTime3 - startTime3));

		ArrayList<Integer> list = new ArrayList<Integer>();
		long startTime2 = System.currentTimeMillis();

		for (int i = 0; i < count; i++) {
			list.add(i);
		}

		long endTime2 = System.currentTimeMillis();
		System.out.println("list.add()耗时 ：" + (endTime2 - startTime2));

		long startTime4 = System.currentTimeMillis();

		for (int i = 0; i < count; i++) {
			list.get(i);
		}
		long endTime4 = System.currentTimeMillis();
		System.out.println("list.get()耗时 ：" + (endTime4 - startTime4));
	}

}

运行结果：

map.put()耗时 ：1215
map.get()耗时 ：174
list.add()耗时 ：287
list.get()耗时 ：6

       可见，对于Map和List而言，List的相关方法的运行效率要优于Map

      泛型

1、不用泛型时，IDE编译时不检查类型带来的风险
2、使用泛型，可以在IDE编译时提醒错误，如

              异常

                             1、异常是一个事件，它发生在程序运行期间，干扰了正常的指令流程
                             2、Java异常都是对象，是Throwable子类的实例

                             3、try-catch语句：

try {  
    // 可能会发生异常的程序代码  
} catch (Type1 id1){  
    // 捕获并处置try抛出的异常类型Type1  
}  
catch (Type2 id2){  
     //捕获并处置try抛出的异常类型Type2  
}finally{//无论是否捕获或处理异常，finally块里的语句都会被执行}

                             4、异常处理机制为：抛出异常，捕捉异常
                                 throw：抛出异常（当前方法没有能力处理这个异常，需要往外抛）


                             5、异常跟踪堆栈信息

package exception_13th;

public class StackInfo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		firstMethod();
	}

	private static void firstMethod() {
		// TODO Auto-generated method stub
		secondMethod();
	}

	private static void secondMethod() {
		// TODO Auto-generated method stub
		thirdMethod();
	}

	private static void thirdMethod() {
		// TODO Auto-generated method stub
		throw new SelfException("自定义异常信息");
	}

}

运行结果：

Exception in thread "main" exception_13th.SelfException: 自定义异常信息
	at exception_13th.StackInfo.thirdMethod(StackInfo.java:23)
	at exception_13th.StackInfo.secondMethod(StackInfo.java:18)
	at exception_13th.StackInfo.firstMethod(StackInfo.java:13)
	at exception_13th.StackInfo.main(StackInfo.java:8)

                              5、当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。在以下4种特殊情况下，finally块不会被执行：
                                  1）在finally语句块中发生了异常。
                                  2）在前面的代码中用了System.exit()退出程序。
                                  3）程序所在的线程死亡。
                                  4）关闭CPU。

        一些使用工具类（double类型的精确运算、输出n年前的今天日历信息、计算字数、分析URL）

                  链接