Collection
中的集合,元素是孤立存在的(理解为单身),向集合中存储元素采用一个个元素的方式存储。Map
中的集合,元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成,通过键可以找对所对应的值。Collection
中的集合称为单列集合,Map
中的集合称为双列集合。- 需要注意的是,
Map
中的集合不能包含重复的键,值可以重复;每个键只能对应一个值。
Map接口中的常用方法
import java.util.HashMap;
/* `public V put(K key, V value)`: 把指定的键与指定的值添加到Map集合中。
* `public V remove(Object key)`: 把指定的键 所对应的键值对元素 在Map集合中删除,返回被删除元素的值。
* `public V get(Object key)` 根据指定的键,在Map集合中获取对应的值。
* `boolean containsKey(Object key) ` 判断集合中是否包含指定的键。
* `public Set<K> keySet()`: 获取Map集合中所有的键,存储到Set集合中。
* `public Set<Map.Entry<K,V>> entrySet()`: 获取到Map集合中所有的键值对对象的集合(Set集合)。
* */
public class test {
public static void main(String[] args) {
HashMap<String, Integer> map = new HashMap<>();
map.put("赵丽颖",18);
map.put("赵雅芝",60);
map.put("谢娜",20);
map.put("Seven",20);
System.out.println(map);
map.remove("Seven");
System.out.println(map);
Integer xn = map.get("谢娜");
System.out.println(xn);
boolean zyz = map.containsKey("赵雅芝");
System.out.println(zyz);
}
}
Map集合遍历键找值方式
键找值方式:即通过元素中的键,获取键所对应的值
分析步骤:
- 获取Map中所有的键,由于键是唯一的,所以返回一个Set集合存储所有的键。方法提示:
keyset()
- 遍历键的Set集合,得到每一个键。
- 根据键,获取键所对应的值。方法提示:
get(K key)
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
public class test {
public static void main(String[] args) {
HashMap<String, Integer> map = new HashMap<>();
map.put("赵丽颖",18);
map.put("赵雅芝",60);
map.put("谢娜",20);
Set<String> set=map.keySet();
//迭代器方法
Iterator<String> it=set.iterator();
while(it.hasNext()){
String key=it.next();
Integer value = map.get(key);
System.out.println(value);
}
//增强for
for(String key:set){
System.out.println(map.get(key));
}
}
}
Entry键值对对象
键值对方式:即通过集合中每个键值对(Entry)对象,获取键值对(Entry)对象中的键与值。
操作步骤与图解:
- 获取Map集合中,所有的键值对(Entry)对象,以Set集合形式返回。方法提示:
entrySet()
。 - 遍历包含键值对(Entry)对象的Set集合,得到每一个键值对(Entry)对象。
- 通过键值对(Entry)对象,获取Entry对象中的键与值。 方法提示:
getkey() getValue()
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class test {
public static void main(String[] args) {
HashMap<String, Integer> map = new HashMap<>();
map.put("赵丽颖",18);
map.put("赵雅芝",60);
map.put("谢娜",20);
Set<Map.Entry<String, Integer>> entry = map.entrySet();
Iterator<Map.Entry<String,Integer>> it= entry.iterator();
while(it.hasNext()){
Map.Entry<String, Integer> a = it.next();
String key = a.getKey();
Integer value = a.getValue();
System.out.println(key+"..."+value);
}
for(Map.Entry<String,Integer> entry1:map.entrySet()){
Integer value = entry1.getValue();
String key = entry1.getKey();
System.out.println(key+"..."+value);
}
}
}
HashMap存储自定义类型键值
import java.util.Objects;
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age &&
Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(name, 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;
}
}
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class test {
public static void main(String[] args) {
//show01();
show02();
}
private static void show02() {
HashMap<Person,String> map=new HashMap<>();
map.put(new Person("张三",18),"北京");
map.put(new Person("李四",19),"上海");
map.put(new Person("王五",20),"广州");
map.put(new Person("张三",18),"北京");
Set<Map.Entry<Person, String>> set = map.entrySet();
for(Map.Entry<Person,String> entry:set){
Person key=entry.getKey();
String value=entry.getValue();
System.out.println(key+"--->"+value);
}
}
private static void show01() {
HashMap<String,Person> map=new HashMap<>();
map.put("北京",new Person("张三",18));
map.put("上海",new Person("李四",19));
map.put("广州",new Person("王五",20));
map.put("北京",new Person("赵六",18));
Set<String> set = map.keySet();
for(String key:set){
Person value=map.get(key);
System.out.println(key+"--->"+value);
}
}
}
我们知道HashMap保证成对元素唯一,并且查询速度很快,可是成对元素存放进去是没有顺序的,那么我们要保证有序,还要速度快怎么办呢?
在HashMap下面有一个子类LinkedHashMap,它是链表和哈希表组合的一个数据存储结构。
import java.util.HashMap;
import java.util.LinkedHashMap;
public class test {
public static void main(String[] args) {
HashMap<String,String> map=new HashMap<>();
map.put("a","b");
map.put("c","b");
map.put("b","b");
map.put("a","d");
System.out.println(map);//key不允许重复,无序 {a=d, b=b, c=b}
LinkedHashMap lin=new LinkedHashMap();
lin.put("a","b");
lin.put("c","b");
lin.put("b","b");
lin.put("a","d");
System.out.println(lin);//key不允许重复,有序 {a=d, c=b, b=b}
}
}
Hashtable