Unit 11 Java集合

1 Java集合框架概述

一、集合框架的概述

​ 1.集合、数组都是对多个数据进行存储的结构，简称 Java 容器。
​ 说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化层面的存储（.txt,.jpg,.avi,数据库种）

​ 2.1 数组在存储多个数据方面的特点：

• ​ 一旦初始化以后，长度就确定了。
• ​ 数组一旦定义好，其元素的类型也就确定了，只能操作指定类型的数据了。
  比如：String[ ] arr;int[ ] arr1;

​ 2.2 数组在存储多个数据方面的缺点：

• ​ 一旦初始化以后，其长度就不可修改。
• ​ 数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。
• ​ 获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用。
• ​ 数组存储的数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。

二、集合框架

|-----Collection 接口：单列集合，用来存储一个一个的对象
|----List 接口：存储有序的、可重复的数据。—> “动态”数组
|----ArrayList、LinkedList、Vector
|----Set 接口：存储无序的、不可重复的数据。—> 高中讲的“集合”
|----HashSet、LinkedHashSet、TreeSet
|-----Map 接口：双列集合，用来存储一对（key-value）一对的数据—> 高中函数：y = f(x)
|----HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

	@Test
	public void test1(){
		Collection coll = new ArrayList();

		//add(Objecte)：将元素e添加到集合coll中
		coll.add("AA");
		coll.add("BB");
		coll.add(123);//自动装箱
		coll.add(new Date());

		//size()：获取添加的元素的个数
		System.out.println(coll.size());

		//addAll(Collectioncoll1)：将coll1集合中的元素添加到当前的集合中
		Collection coll1 = new ArrayList();
		coll.add(456);
		coll.add("CC");
		coll.add(coll1);

		System.out.println(coll);
		System.out.println(coll.size());

		//clear()：清空集合元素
		coll.clear();

		//isEmpty()：判断当前集合是否为空
		System.out.println(coll.isEmpty());
	}

	//集合--->数组：toArray()
	Object[] arr = coll.toArray();
	for(int i =0;i < arr.length;i++){
		System.out.println(arr[i]);
	}
	//拓展：数组--->集合：调用Arrays类的静态方法asList(T...t)
	List<String> list = Arrays.asList(new String[]{"AA,BB,CC"});
	System.out.println(list);
	
	List arr1 = Arrays.asList(new int[]{123,456});
	System.out.println(arr1.size());//1
	
	List arr2 = Arrays.asList(new Integer[]{123,456});
	System.out.println(arr2.size());//2

2 Collection接口方法

1.contains(Object obj)：判断当前集合中是否包含 obj

2.containsAll(Collection coll1):判断形参 coll1 中的所有元素是否都存在于当前集合中

3.remove(Object obj):

4.removeAlll(Collection coll1):差集从当前集合中移除 coll1 中所有的元素

3 Iterator迭代器接口

集合元素的遍历操作。使用 Iterator 接口

1.内部的方法：hasNext( ) 和 next( )

2.集合对象每次调用 iterator( ) 方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。

	//方式三：推荐
	Iterator iterator = coll.iterator();
		//hasNext():判断是否还有下一个元素
	while(iterator.hasNext()){
		//next():①指针下移②将下移以后集合位置上的元素返回
		System.out.println(iterator.next());
	}
	
	//错误方式一：
	Iterator iterator = coll.iterator();
	while((iterator.next()) != null){
		System.out.println(iterator.next());
	}
	
	//错误方式二：
	集合对象每次调用iterator()方法都得到一个全新的迭代器对象，
	默认游标都在集合的第一个元素之前。
	while(coll.iterator().hasNext()){
		System.out.println(coll.iterator().next());
	}

	//for(集合中元素的类型 局部变量：集合对象)
	//内部调用的仍是迭代器
	for(Object obj : coll){
		System.out.println(obj);
	}

	@Test
	public void test2(){
		int[] arr = new int[]{1,2,3,4,5,6};
		//for(数组元素的类型局部变量：数组对象)
		for(int I : arr){
			System.out.println(i);
		}
	}

4 Collection子接口一：List(List是重点)

1. list接口框架

​ |-----Collection 接口：单列集合，用来存储一个一个的对象
​ |----List接口：存储有序的、可重复的数据。—> “动态”数组
​ |----ArrayList：作为List接口的主要实现类；线程不安全的，效率高；底层使用 Object[ ]存储
​ |----LinkedList：对于频繁的插入和删除操作，使用此类效率比 ArrayList 高；底层使用双向链表存储
​ |----Vector：作为 List 接口的古老实现类；线程安全的，效率低；底层使用 Object[ ]存储

2. ArrayList的源码分析：jdk7的情况下：

​ 2.1 jdk7情况下

ArrayList list = new ArrayList();//底层创建了长度是10的 Object[]数组 elementDate
list.add(123);//elementData[0] = new Integer(123);
...
list.add(11);//如果此次的添加导致底层 elementData 数组容量不够，则扩容。
//默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数组复制到新的数组中。

结论：建议开发中使用带参的构造器：ArrayLis list = new ArrayList(int capacity)

​ 2.2 jdk8中的变化

ArrayList list = new ArrayList();//底层Object[] elementData初始化为{},并没有创建长度为10的数组
list.add(123);//第一次调用add()时，底层才创建了长度为10的数组，并将数据123添加到elementData
...

后续的添加与扩容操作与 jdk7 无异。

​ 2.3小结：jdk7中的 ArrayList 的创建类似于单例的饿汉式，而 jdk8 中的 ArrayList 的对象的创建类似于

单例的懒汉式，延迟了数组的创建，节省内存。

3. LinkList 的源码分析：

LinkedList list = new LinkedList();//内部声明了Node类型的first和last属性，默认值为null
list.add(123);//将123封装到Node中，创建了Node对象。

//其中，Node定义为：体现了LinkedList的双向链表的说法

private static class Node<E>{
	E item;
	Node<E> next;
	Node<E> prev;

	Node(Node<E> pre, Eelement, Node<E> next){
		this.item = item;
		this.next = next;
		this.prev = prev;
	}
}

4. Vector 的源码分析：jdk7 和 jdk8 中通过 Vector( ) 构造器创建对象时，底层都创建了长度为10的数组，在扩容方面，默认扩容为原来的数组长度的2倍。

5. List 常用方法
   增：add(Object obj)
   删：remove(int index)（注意删除的是索引）
   remove(Object obj)（删除的是元素，new Integer(元素值)）
   改：set(int index, Object ele)
   查：get(int index)
   插：add(int index,Object ele)
   长度：size( )
   遍历：①Iterator迭代器方式
   ②增强for循环
   ③普通的循环

//方式一：Iterator迭代器方式
Iterator iterator = list.iterator();
while(iterator.hasNext()){
	System.out.println(iterator.next());
}

//方式二：增强for循环
for(数据类型 变量 ： 集合){
    sout(变量);
}
for(Object obj : list){
	System.out.println(obj);
}

//方式三：普通的for循环
for(int i=0;i<list.size();i++){
	System.out.println(list.get());
}

5 Collection子接口二：Set(Set不是重点)

Set接口的框架：
|-----Collection 接口：单列集合，用来存储一个一个的对象
|----Set 接口：存储无序的、不可重复的数据。—> 高中讲的“集合”
|----HashSet:作为 Set 接口的主要实现类；线程不安全的；可以存储null值
|----LinkedHashSet：作为 HashSet 子类，遍历其内部数据时，可以按照添加的顺序遍历
|----TreeSet：可以按照添加对象的指定属性进行排序。

1.Set 接口中没有额外定义新的方法，使用的都是 Colllection 中声明过的方法。

2.要求：向 Set 中添加的数据，其所在的类一定要重写 hashCode( ) 和 equals( )

重写的小技巧：要求：重写的 hashCode( ) 和 equals( ) 尽可能保持一致性：相等的对象必须具有相等的散列码（需要时直接 alt+shift+s 自动重写即可）

一、Set：存储无序的、不可重复的数据

​ 以 HashSet 为例说明：

1.无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是按照数据的哈希值确定的。

2.不可重复性：保证添加的元素按照 equals( ) 判断时，不能返回 true，即：相同的元素只能添加一个。

二、添加元素的过程：以 HashSet 为例：

我们向 HashSet 中添加元素 a，首先调用元素 a 所在类的 hashCode( ) 方法，计算元素 a 的哈希值，

此哈希值接着通过某种算法计算出在 HashSet 底层数组中的存放位置（即为：索引位置），判断数组

此位置上是否已经有元素：

​ 如果此位置上没有其他元素，则元素 a 添加成功。—> 情况1
​ 如果此位置上有其他元素 b（或以链表形式存在的多个元素），则比较元素 a 与元素 b 的 hash 值：
​ 如果 hash 值不同，则元素 a 添加成功。—> 情况2
​ 如果 hash 值相同，进而需要调用元素 a 所在类的 equals( ) 方法：
​ equals( ) 返回 true，元素 a 添加失败
​ equals( ) 返回 false，则元素 a 添加成功。—> 情况3

对于添加成功的情况2和情况3而言：元素 a 已经存在指定索引位置上数据以链表方式存储，

​ jdk7：元素 a 放到数组中，指向原来的元素。
​ jdk8：原来的元素在数组中，指向元素 a

​ 总结：七上八下

​ HashSet底层：数组+链表的结构。

LinkedHashSet( )的使用
	LinkedHashSet()作为HashSet()的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据
	优点：对于频繁的遍历操作，LinkedHashSet效率高于HashSet
	@Test
	public void test2(){
		Set set = new LinkedHashSet();
		set.add(456); 
		set.add(123);
		set.add("AA");
		set.add("CC");
		set.add(newUser("Tom",12));
		set.add(newUser("Tom",12));
		set.add(129);
	
		//迭代器遍历
		Iterator iterator = set.iterator();
		while(iterator.hasNext()){
			System.out.println(iterator.next());
		}
	}
	/**
	Userequals()....
	456
	123
	AA
	CC
	User{name='Tom',age=12}
	129

1.向TreeSet中添加的数据，要求是相同类的对象。

2.两种排序方式：自然排序和定制排序

3.自然排序中，比较两个对象是否相同的标准为;compareTo( ) 返回0，不再是 equals( )

4.定制排序中，比较两个对象是否相同的标准为;compareTo( ) 返回0，不再是 equals( )。

	@Test
	public void test1(){
		TreeSet set = new TreeSet();
		//失败：不能添加不同类的对象
		//set.add(123);
		//set.add(456);
		//set.add("AA");
		//set.add(newUser("Tom",12));

		//举例一：
		//set.add(34);
		//set.add(-34);
		//set.add(43);
		//set.add(11);
		//set.add(8);

		//举例二：
		set.add(new User("Tom",12));
		set.add(new User("Jerry",32));
		set.add(new User("Jim",2));
		set.add(new User("Mike",65));
		set.add(new User("Jack",45));
		set.add(new User("Jack",56));

		Iterator iterator = set.iterator();
		while(iterator.hasNext()){
			System.out.println(iterator.next());
		}
		/**
		User{name='Tom',age=12}
		User{name='Mike',age=65}
		User{name='Jim',age=2}
		User{name='Jerry',age=32}
		User{name='Jack',age=45}
		User{name='Jack',age=56}
		*/
	}
	
	@Test
	public void test2(){
		Comparator com = new Comparator(){
	//按照年龄从小到大排列
			@Override
			public int compare(Object o1,Object o2){
				if(o1 instanceof User && o2 instanceof User){
					User u1 = (User)o1;
					User u2 = (User)o2;
					return Integer.compare(u1.getAge(),u2.getAge());
				}else{
					throw new RuntimeException("输入的数据类型不匹配");
				}
			}
		};
	
		TreeSet set = new TreeSet(com);
		set.add(new User("Tom",12));
		set.add(new User("Jerry",32));
		set.add(new User("Jim",2));
		set.add(new User("Mike",65));
		set.add(new User("Jack",45));
		set.add(new User("Jack",56));
	
		Iterator iterator = set.iterator();
		while(iterator.hasNext()){
			System.out.println(iterator.next());
		}
		/**
		User{name='Jim',age=2}
		User{name='Tom',age=12}
		User{name='Jerry',age=32}
		User{name='Jack',age=45}
		User{name='Jack',age=56}
		User{name='Mike',age=65}
		*/
	}

6 Map接口

一、Map的实现类的结构

​ |----Map:双列数据，存储 key-value 对的数据—类似于高中的函数：y = f(x)
​ |----HashMap:作为 Map 的主要实现类；线程不安全的，效率高；存储 null 的 key 和 value
​ |----LinkedHashMap:保证在遍历 Map 元素时，可以按照添加的顺序实现遍历。
​ 原因：在原有的 HashMap 底层结构基础上，添加了一对指针，指向前一个和后一个元素。
​ 对于频繁的遍历操作，此类执行效率高于 HashMap。
​ |----TreeMap: 保证按照添加的 key-value 对进行排序，实现排序遍历。此时考虑 key 的自然排序或定制排序。
​ 底层使用红黑树
​ |----Hashtable:作为古老的实现类；线程安全的，效率低；不能存储 null 的 key 和 value
​ |----Properties:常用来处理配置文件。key 和 value 都是 String 类型

HashMap 的底层：数组+链表（jdk7 及之前）

​ 数组+链表+红黑树（jdk8）

面试题：

1.HashMap 的底层实现原理

2.HashMap 和 Hashtable 的异同

3.CurrentHashMap 与 Hashtable 的异同（暂时不讲）

二、Map结构的理解：

（key，value）–（x，y）类似函数

Map 中的 key：无序的、不可重复的，使用Set存储所有的 key—>key 所在的类要重写 equals( ) 和hashCode( )(以 HashMap 为例)。

Map中的 value：无序的、可重复的，使用 Collection 存储所有的 value—>value 所在的类要重写 equals( )。

一个键值对：key-value 构成了一个 Entry 对象。

Map 中的 entry：无序的、不可重复的，使用 Set 存储所有的 entry。

三、HashMap的底层实现原理？以jdk7为例说明：

HashMap map = new HashMap();

在实例化以后，底层创建了长度是16的一维数组 Entry[ ] table.

…可能已经执行过多次 put…

map.put(key1,value1);

首先，调用 key1 所在类的 hashCode( ) 计算 key1 哈希值，此哈希值经过某种算法以后，得到在 Entry 数组中的存放位置。

>如果此位置上数据为空，此时的 key1-value1 添加成功。 —>情况一

>如果此位置上的数据不为空，（意味着此位置上存在一个或多个数据（以链表形式存在）），比较 key1 和已经存在的

​ 一个或多个数据的哈希值：
​ >如果 key1 的哈希值与已经存在的数据的哈希值都不相同，此时 key1-value 添加成功。—>情况二
​ >如果 key1 的哈希值和已经存在的某一个数据（key2-value2）的哈希值相同，继续比较：调用 key1 所在类的 equals( ) 方法，比较：
​ >如果 equals( ) 返回 false：此时 key1-value1 添加成功。—>情况三
​ >如果 equals( ) 返回 true：使用 value1 替换 value2.

补充：关于情况二和情况三：此时 key1-value1 和原来的数据以链表的方式存储。

在不断地添加过程中，会涉及到扩容问题，当超出临界值（且要存放的位置非空时）默认的扩容方式：扩容为原来的2倍，并将原来的数据复制过来。

​ jdk8 相较于 jdk7 在底层实现方面的不同：

​ 1.new HashMap( ):底层没有创建一个长度为16的数组
​ 2.jdk8 底层的数组是：Node[ ] ,而非 Entry[ ]
​ 3.首次调用 put( ) 方法时，底层创建长度为16的数组
​ 4.jdk7 底层结构只有：数组+链表。jdk8 中底层结构：数组+链表+红黑树。
​ 当数组中的某一个索引位置上的元素以链表形式存在的数据个数>8且当前数组的长度>64时，此时此索引位置上的所有的数据改为使用红黑树存储。

四、LinkedHashMap的底层实现原理（了解）

源码中：

static class Entry<K,V> extends HashMap.Node<K,V>{
	Entry<K,V> before,after;//能够记录添加的元素的先后顺序
	Entry(int hash,K key,V value,Node<K,V> next){
		super(hash,key,value,next);
	}
}

五、Map接口中定义的方法：

	添加：put(Object key,Object value)
	删除：remove(Object key)
	修改：put(Object key,Object value)
	查询：get(Object key)
	长度：size()
	遍历：keySet() / values() / entrySet()
	
	public void test3(){
		HashMap map = new HashMap();
		//添加
		map.put("AA",123);
		map.put(45,123);
		map.put("BB",56);
		//修改
		map.put("AA",87);
		System.out.println(map);

		HashMap map1 = new HashMap();
		map1.put("CC",123);
		map1.put("DD",123);

		map.putAll(map1);
		System.out.println(map);

		//remove(Objectkey)
		Object value = map.remove("CC");
		System.out.println(value);
		System.out.println(map);

		//clear()
		map.clear();//与map = null操作不同
		System.out.println(map.size());
	}

	public void test4(){
		HashMap map = new HashMap();
		map.put("AA",123);
		map.put(45,123);
		map.put("BB",56);
		//Object get(Object key)
		System.out.println(map.get(45));
		//contains Key(Object key)
		boolean isExist = map.containsKey("BB");
		System.out.println(isExist);

		isExist = map.containsValue(123);
		System.out.println(isExist);

		map.clear();
		System.out.println(map.isEmpty());
	}
	
	public void test5(){
		HashMap map = new HashMap();
		map.put("AA",123);
		map.put(45,123);
		map.put("BB",56);

		//遍历所有的key集：keySet()
		Set set = map.keySet();
		Iterator iterator = set.iterator();
		while(iterator.hasNext()){
			System.out.println(iterator.next());
		}
		System.out.println();

		//遍历所有的value集：values()
		Collection values = map.values();
		for(Object obj : values){
			System.out.println(obj);
		}
		System.out.println();

		//遍历所有的key-value：entrySet()
		//方式一：
		Set entrySet = map.entrySet();
		Iterator iterator1 = entrySet.iterator();
		while(iterator1.hasNext()){
			Object obj = iterator1.next();
			Map.Entry entry = (Map.Entry)obj;
			System.out.println(entry.getKey() + "---->" + entry.getValue());
		}
		System.out.println();

		//方式二：
		Setkey Set = map.keySet();
		Iterator iterator2 = keySet.iterator();
		while(iterator2.hasNext()){
			Object key = iterator2.next();
			Object value = map.get(key);
			System.out.println(key+"---->"+value);
		}
	}

六、

	public class PropertiesTest{
		//Properties:常用来处理配置文件。key和value都是String类型
		public static void main(String[] args) throws Exception{
			Properties pros = new Properties();
			FileInputStream fis = new FileInputStream("jdbc.properties");
			
			pros.load(fis);//加载流对应的文件
			String name = pros.getProperty("name");
			String password = pros.getProperty("password");

			System.out.println("name = " + name + ", password = " + password);
		}
	}

7 Collections工具类