黑马程序员_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 P
4000
erson("李连杰",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: 集合的工具类