集合框架

1.日期时间类

Date类

类Date表示特定的瞬间，精确到毫秒。其表示时间日期数据的对象，现在这个类大部分的方法已经过时，由Calendar和DateFormat类代替。

DateFormat类

DateFormat是日期/时间格式化子类的抽象类，它可以完成Date对象和字符串之间的转成，但是由于这个类是抽象类，不能直接去创建对象。

public class DateFormat {

	public static void main(String[] args) {
		//获取到DateFormat对象
		DateFormat format = DateFormat.getInstance();
		
		//将日期对象转成字符串
		Date d = new Date();
		String s = format.format(d);
		System.out.println(s);
	}
}

SimpleDateFormat类

SimpleDateFormat和DateFormat功能一致，都是完成Date对象和字符串之间的转换。它是DateFormat的子类，在创建SimpleDateFormat对象的时候，可以写入指定日期和字符串之间转换的书写格式。

SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");

2.List接口

Collection接口是集合体系中的顶层(跟)接口。它定义的方法是所有集合最共性的操作规则，其提供了直接的子接口：
List：List接口下的集合容器都拥有下标(有序)，它可以存储重复元素
Set：Set接口下的集合容器，不能存放重复的元素，且无序。

List的特有迭代器

List接口中提供的ListIterator迭代器，它可以对List集合从前往后遍历，也可以从后往前遍历，同时ListIterator接口中还提供的对集合增、删、改、查的方法。

public class ListIteratorDemo {

	public static void main(String[] args) {

		//定义List集合对象
		List<String> list = new ArrayList<String>();
		
		list.add("aaa");
		list.add("abc");
		list.add("dwda");
		list.add("dawdad");
		list.add("rewrq");
		
		System.out.println("使用ListIterator正向遍历集合");
		ListIterator<String> li = list.listIterator();
		while(li.hasNext()) {
			System.out.println(li.next());
		}
		
		System.out.println("使用ListIterator逆向遍历集合");
		while(li.hasPrevious()) {
			System.out.println(li.previous());
		}
	}

}

List集合的所有遍历方式

public class ListDemo {

	public static void main(String[] args) {
	
		//定义List集合对象
		List<String> list = new ArrayList<String>();
		
		//添加元素
		list.add("aeqwe");
		list.add("123");
		list.add("rerq");
		list.add("gfdfg");
		
		//使用Iterator遍历
		System.out.println("使用Iterator进行遍历");
		for(Iterator<String> it = list.iterator() ; it.hasNext() ;) {
			System.out.println(it.next());
		}
		
		//使用ListIterator遍历
		System.out.println("使用ListIterator进行遍历");
		for(ListIterator<String> li = list.listIterator() ; li.hasNext() ;) {
			System.out.println(li.next());
		}
		
		//使用普遍的for循环提供下标遍历
		System.out.println("for循环遍历");
		for(int i = 0 ; i < list.size() ; i++) {
			System.out.println(list.get(i));
		}
		/*
		 * 使用foreach遍历
		 * 		格式：
		 * 		for(容器中元素的类型  变量名 ： 容器名 ){
		 * 			变量名中保存的就是从容器中提出的元素
		 * 		}
		 */
		System.out.println("foreach遍历");
		for(String str : list) {
			System.out.println(str);
		}
	}

}

ArrayList与LinkedList

ArrayList类：它是List接口的实现，可以存放重复元素，也能够使用List接口中的所有特有方法。它增删效率相对较低，查询效率较快。它不保证数据的安全。
LinkedList：它是List接口的直接实现类，实现了Collection和List接口中的所有方法。集合底层使用链表结构，其中链表结构可以完成数据结构中的部分结构的实现：1.队列(先进先出) 2.堆栈(先进后出)。它增删效率快，查询效率慢，也不保证数据的安全。

3.Set集合

Set接口是Collection接口下的一个子接口。它和List接口相同，都是Collection的子接口。
区别：
List：有下标、可以重复、拥有特有的ListIterator迭代器
Set：没有下标、不能包含重复元素，没有特有迭代器，只能使用Iterator进行遍历。

HashSet集合与LinkedHashSet集合

HashSet类实现Set接口，由哈希表支持。它不保证set的迭代顺序；特别是它不保证改顺序恒久不变。
LinkedHashSet是HashSet集合的子类，它也属于Set接口下的集合容器，同样能保证对象的唯一。它与HashSet的区别是：LinkedHashSet可以保证存放的元素的存取顺序一致。

public class HashSet {

	public static void main(String[] args) {

		//创建集合元素
		HashSet<String> set = new HashSet<String>();
		
		//添加元素
		set.add("eqweq");
		set.add("4324");
		set.add("hhtr");
		set.add("dvsdv");
		set.add("524fes");
		
		//遍历HashSet集合
		for(Iterator<String> it = set.iterator(); it.hasNext();) {
			System.out.println(it.next());
		}
	}

}

HashSet保存自定义对象

public class HashSet {

	public static void main(String[] args) {

		//创建集合对象
		HashSet<Object> set = new HashSet<Object>();
		
		//创建自定义对象
		set.add(new Person("小明",21));
		set.add(new Person("小花",22));
		set.add(new Person("小黄",25));
		set.add(new Person("小维",27));
		
		//遍历
		for(Iterator<Object> it = set.iterator() ; it.hasNext();) {
			System.out.println(it.next());
		}
	}

}

TreeSet集合

TreeSet集合是Set接口的间接实现类。TreeSet集合它也不能存放重复的元素。它的底层使用的数据结构中二叉树(红黑树)结构。这种数据结构可以对保证在其中的数据进行排序。

public class TreeSet {

	public static void main(String[] args) {
		
		//创建TreeSet对象
		TreeSet<String> tset = new TreeSet<String>();
		
		//添加元素
		tset.add("ddd");
		tset.add("aaa");
		tset.add("bbb");
		tset.add("AAA");
		
		//遍历
		for(Iterator<String> it = tset.iterator(); it.hasNext();) {
			System.out.println(it.next());
		}
	}

}

4.Map集合

Map集合中保存的是一组数据。数据之间存在着一定的对应关系。它将键映射到值的对象。一个映射不能包含重复的值；每个键最多只能映射到一个值。Map集合中的key是唯一的。每个key都有一个value值和其一一对应。

HashMap、TreeMap与Hashtable

HashMap：HashMap是Map接口的实现类，它的底层使用的哈希表。哈希表作用在HashMap集合的key上。当使用自定义对象作为HashMap集合的key值使，这个自定义对象所属的类需要复写Object类中的hashCode和equals方法。
TreeMap：TreeMap的底层是二叉树结构。二叉树作用在集合的key上。TreeMap集合可以对保存其中的元素进行排序。
Hashtable：它属于Map集合，底层是哈希表，和HashMap功能一致。他是安全的。

Map集合遍历

public class HashMapDemo {

	public static void main(String[] args) {
		
		//创建集合对象
		HashMap<Object,String> map = new HashMap<Object,String>();
		
		map.put(new Person("张三",22), "上海");
		map.put(new Person("李四",24), "广州");
		map.put(new Person("王五",21), "深圳");
		map.put(new Person("小花",20), "北京");
		
		//获取所有的key组成的set集合
		Set<Object> set = map.keySet();
		
		//遍历
		for(Iterator<Object> it = set.iterator(); it.hasNext();) {
			Object key = it.next();
			//获取value值
			Object value = map.get(key);
			System.out.println(key + "..." + value);
		}
	}

}

Map遍历练习实例

需求：统计字符串中每个字符的次数

public class MapTest {

	public static void main(String[] args) {
		
		String s = "dafafaf使用从字符串中取出的字符作为Map的key值，次数作为Map的value值";
		
		//需要定义一个集合
		Map map = new HashMap();
		
		//遍历字符串
		for(int i = 0; i<s.length();i++) {
			//取出字符
			char ch = s.charAt(i);
			if(map.containsKey(ch)) {
				//判断成立说明当前从字符串中取出的字符，已经出现过
				Integer value = (Integer)map.get(ch);
				//给value+1，再保存到Map中
				value = value + 1;
				map.put(ch, value);
			}else {
				//判断不成立，说明当前的字符是第一次出现
				map.put(ch, 1);
			}
		}
		
		//遍历Map集合，取出每个字符的次数
		Set set = map.keySet();
		for(Iterator<String> it = set.iterator(); it.hasNext();) {
			Object key = it.next();
			Object value = map.get(key);
			System.out.println("'" + key + "'"+"出现的次数是" + value);
		}
	}

}