黑马程序员_java基础之集合(map及其子类)

------- android培训、java培训、期待与您交流！ ----------

1.Map<K,V>

map集合中存储的元素是成对出现的元素， 这种成对出现的元素，我们称之为 键值对元素(夫妻对)

 Map可以通过 键 找到对应的值 

  Map集合不能包含重复的键

  每个键 只能对应一个 值
 Map集合 与 Collection的区别
Collection: 单列集合
  存储的元素是单个存储的(光棍)
数据结构针对当前元素有效
  Map: 双列集合
 存储的元素是成对存储的(夫妻)
 数据结构只针对元素中的键有效，与值没有关系

2.Map集合的方法

添加功能：
V put(K key, V value) 把指定的键与值 添加到集合中
删除功能：
void clear() 清空集合中的元素
V remove(Object key) 把指定的键对应的元素，在集合中删除，返回当前键所对应的值
判断功能：

  boolean containsKey(Object key) 判断当前集合中 是否包含指定的键
  boolean containsValue(Object value) 判断当前集合中 是否包含指定的值
  boolean isEmpty() 判断当前集合 是否为空集合
 获取功能：
 V get(Object key) 在集合中，通过指定的键 获取到对应的值
  Set<K> keySet()获取当前集合中 所有的键，返回一个Set集合
 Collection<V> values() 获取当前集合中 所有的值， 返回一个Collection集合
  Set<Map.Entry<K,V>> entrySet() 获取当前集合中 所有的键值对元素 的集合
  长度功能：
int size() 获取集合中 键值对元素的个数

3.HashMap集合

3.1特点：

底层： 哈希表结构
      存储null键和null值
    线程不同步--不安全--效率高

  Map集合中，数据结构只针对键，与值无关
  如何保证HashMap集合中键的唯一？
重写 hashCode() 与 equals()

3.2map 集合的遍历方式有2种

方式1： 通过键找值的方式
a: 获取当前Map集合中所有的键

  b: 遍历键的集合，获取到每一个键
c: 通过当前的键，获取到对应的值

方式2： 通过键值对元素对象， 找键 找值的方式

a: 获取当前Map集合中所有的键值对元素对象
b: 遍历键值对元素的集合，获取到每一个键值对元素
c: 通过当前的键值对元素对象，获取对应的键，获取对应的值

package cn.HashMapTest;

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

public class HashMapDemo {
	public static void main(String[] args) {
		HashMap<Stydent, String> hm = new HashMap<Stydent,String>();
		Stydent s1 = new Stydent("小红",28);
		Stydent s2 = new Stydent("大红",28);
		Stydent s3 = new Stydent("小里",28);
		
		hm.put(s1, "id001");
		hm.put(s2, "id002");
		hm.put(s3, "id003");
		
		Set<Stydent> keys = hm.keySet();
		for (Stydent ss : keys) {
			String vlaue = hm.get(ss);
			System.out.println(ss+"--"+vlaue);
		}
		Set<Entry<Stydent, String>> sets = hm.entrySet();
		for (Entry<Stydent, String> entry : sets) {
			Stydent s = entry.getKey();
			String ss = entry.getValue();
			
			System.out.println(s+"=="+ss);
		}
	}

}
package cn.HashMapTest;

public class Stydent {
	private String name;
	private int age;
	public Stydent() {
		super();
	}
	public Stydent(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	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 int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Stydent other = (Stydent) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	
	public String toString() {
		return "Stydent [name=" + name + ", age=" + age + "]";
	}
	
}

4.LinkedHashMap

底层： 才有哈希表结构 + 链表结构
     通过哈希表结构 保证了键的唯一
             通过链表结构保证了有序

package cn.HashMapTest;

import java.util.LinkedHashMap;
import java.util.Set;
import java.util.Map.Entry;

public class LinkedHashMapTest {
	public static void main(String[] args) {
		LinkedHashMap<String,String> lhm = new LinkedHashMap<String,String>();
		lhm.put("2345", "dsff");
		lhm.put("345", "dsf");
		lhm.put("45", "dff");
		
		Set<String> sets = lhm.keySet();
		for(String key : sets){
			String s = lhm.get(key);
			System.out.println(s+"--------"+key);
		}
		
		Set<Entry<String, String>> entry = lhm.entrySet();
		for (Entry<String, String> entry2 : entry) {
			String s = entry2.getKey();
			String ss = entry2.getValue();
			System.out.println(s+"-------"+ss);
		}
	}
}

5.TreeMap

底层： 二叉树结构(红黑树)
  如何保证键的唯一与排序？？
  两种方式
  方式1: 自然排序 Comparable 接口，实现 compareTo(Object o)方法
方式2: 比较器 Comparator 接口， 实现compare(Object o1, Object o2)方法

package cn.bean_06_TreeMap;

import java.util.Comparator;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

import cn.itcast_03_HashMap.Person;
public class TreeMapDemo2 {
	public static void main(String[] args) {
		//创建集合对象
		TreeMap<Person, String> tm = new TreeMap<Person, String>(new Comparator<Person>() {
			
			public int compare(Person o1, Person o2) {
				//年龄比较
				int num = o1.getAge() - o2.getAge();
				//名字比较
				int result = (num==0)? (o1.getName().compareTo(o2.getName())): num;
				return result;
			}
		});
		//添加元素到集合
		Person p1 = new Person("李孝利",28);
		Person p2 = new Person("李小龙",38);
		Person p3 = new Person("成龙",58);
		Person p4 = new Person("李连杰",48);
		
		tm.put(p1, "韩国女明星");
		tm.put(p2, "中国男明星");
		tm.put(p3, "中国男明星");
		tm.put(p4, "中国男明星");
		
		//遍历
		//键值对 找键 找值
		Set<Entry<Person, String>> entrySet = tm.entrySet();
		for (Entry<Person, String> entry : entrySet) {
			Person key = entry.getKey();
			String value = entry.getValue();
			System.out.println(key.getName()+"--"+key.getAge()+"--"+value);
		}
		
	}
}
package cn.bean_06_TreeMap;

public class Person {
	private String name;
	private int age;
	public Person() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	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;
	}
	
}

6.HashMap和Hashtable的区别

HashMap:
jdk1.2后产生的集合 线程不同步--不安全--效率高
存储null键 存储 null值

Hashtable:
jdk1.0 线程同步--安全--效率低
不能存储null键 和 不能存储null值

7.List,Set,Map等接口是否都继承子Map接口

不是， List集合接口  继承Collection集合接口
Set集合接口  继承 Collection集合接口

8.Collection与 Collections的区别

  Collection: 单列集合的顶层接口
  Map: 双列集合的顶层接口
Collections: 集合的工具类