集合(三)------双列集合

所谓双列集合就是存在映射关系并且是成对存在的。

双列集合体系:

-------------| Map  如果是实现了Map接口的集合类,具备的特点: 存储的数据都是以键值对的形式存在的,键不可重复,值可以重复。
----------------| HashMap  底层也是基于哈希表实现 的。
----------------| TreeMap   TreeMap也是基于红黑树(二叉树)数据结构实现 的, 特点:会对元素的键进行排序存储。
----------------| Hashtable 和hashMap实现原理一样,但是是线程安全的,执行效率低。出现于JDK1.0。

Map接口常用方法:

增加:

put(K key, V value) 将指定的值与此映射中的指定键关联(可选操作)。

void putAll(Map<? extends K,? extends V> m) 从指定映射中将所有映射关系复制到此映射中(可选操作)。

删除:

remove(Object key)  如果存在一个键的映射关系,则将其从此映射中移除(可选操作)。

void clear()  从此映射中移除所有映射关系(可选操作)。

查看:

int size() 返回此映射中的键-值映射关系数。

V get(Object key)  返回指定键所映射的值;如果此映射不包含该键的映射关系,则返回 null

判断:

boolean isEmpty() 如果此映射未包含键-值映射关系,则返回 true

boolen containsKey(Object key) 如果此映射包含指定键的映射关系,则返回 true

boolen  containsValue(Object value) 如果此映射将一个或多个键映射到指定值,则返回 true

迭代

Set<K>keySet()  返回此映射中包含的键的 Set 视图。

Collection<V> values()  返回此映射中包含的值的 Collection 视图。

Set<Map.Entry<K,V>> entrySet()  返回此映射中包含的映射关系的 Set 视图。

Map.entr<K,V>中的方法

K getKey() 返回与此项对应的键。

V getValue() 返回与此项对应的值。

V setValue(V value) 用指定的值替换与此项对应的值(可选操作)。返回与此项对应的旧值

代码示例:

 1 public class DemoMap {
 2     public static void main(String[] args) {
 3         Map<String,String> map = new HashMap<String, String>();
 4         //添加
 5         map.put("a", "张三");
 6         map.put("b", "李四");
 7         map.put("c", "王五");
 8         System.out.println(map);
 9         map.put("a", "赵六");
10         System.out.println(map);
11
12         Map<String, String> map2 = new HashMap<String,String>();
13         map2.put("d", "李磊");
14         map2.put("e", "韩梅梅");
15         map.putAll(map2);
16         System.out.println(map);
17
18         //查看
19         System.out.println("size:" + map.size());
20         System.out.println("value:" + map.get("a"));
21         //迭代
22         Set<String> set = map.keySet();
23         System.out.println("map中的key:"+set);
24         Collection<String> collection = map.values();
25         System.out.println("map中的value:"+collection);
26         Set<Map.Entry<String, String>> entrySet = map.entrySet();
27         Iterator<Map.Entry<String, String>> iterator = entrySet.iterator();
28         while(iterator.hasNext()){
29             Map.Entry<String, String> entry = iterator.next();
30 //            entry.setValue("哈哈哈");
31             System.out.println("key:"+entry.getKey() + " value:"+entry.getValue());
32         }
33
34         //判断
35         System.out.println("是否为空:"+map.isEmpty());
36         System.out.println("key是否a:"+map.containsKey("a"));
37         System.out.println("value是否为空:"+map.containsValue("李磊"));
38         //删除
39         map.remove("e");
40         System.out.println(map);
41         map.clear();
42         System.out.println(map);
43     }
44 }

HashMap

HashMap的存储原理:
    往HashMap添加元素的时候,首先会调用键的hashCode方法得到元素 的哈希码值,然后经过运算就可以算出该元素在哈希表中的存储位置。
    情况1: 如果算出的位置目前没有任何元素存储,那么该元素可以直接添加到哈希表中。
    情况2:如果算出 的位置目前已经存在其他的元素,那么还会调用该元素的equals方法与这个位置上的元素进行比较,如果equals方法返回的是false,那么该元素允许被存储,如果equals方法返回的是true,那么该元素被视为重复元素,替换掉原来的旧值。

代码示例:

 1 class Person{
 2     int id;
 3     String name;
 4     public Person(int id, String name) {
 5         this.id = id;
 6         this.name = name;
 7     }
 8     @Override
 9     public int hashCode() {
10         return this.id;
11     }
12     @Override
13     public boolean equals(Object obj) {
14         Person person = (Person)obj;
15         return this.id == person.id;
16     }
17     @Override
18     public String toString() {
19         return "{id :"+ this.id + "  名字:"+ this.name+"}";
20     }
21 }
22
23 public class DemoMap {
24     public static void main(String[] args) {
25         HashMap<Person, String> map = new HashMap<Person,String>();
26         map.put(new Person(110, "张三"), "110");
27         map.put(new Person(210, "李四"), "210");
28         map.put(new Person(310, "王五"), "310");
29         System.out.println(map);
30         map.put(new Person(310, "赵六"), "410");
31         System.out.println(map);
32     }
33 }

TreeMap

TreeMap 要注意的事项:

  1.  往TreeMap添加元素的时候,如果元素的键具备自然顺序,那么就会按照键的自然顺序特性进行排序存储。
    2.  往TreeMap添加元素的时候,如果元素的键不具备自然顺序特性, 那么键所属的类必须要实现Comparable接口,把键的比较规则定义在CompareTo方法上。
    3. 往TreeMap添加元素的时候,如果元素的键不具备自然顺序特性,而且键所属的类也没有实现Comparable接口,那么就必须在创建TreeMap对象的时候传入比较器。

代码示例:

实现Comparable接口

 1 class Person implements Comparable<Person>{
 2     int id;
 3     String name;
 4     public Person(int id, String name) {
 5         this.id = id;
 6         this.name = name;
 7     }
 8     @Override
 9     public int hashCode() {
10         return this.id;
11     }
12     @Override
13     public boolean equals(Object obj) {
14         Person person = (Person)obj;
15         return this.id == person.id;
16     }
17     @Override
18     public String toString() {
19         return "{id :"+ this.id + "  名字:"+ this.name+"}";
20     }
21
22     @Override
23     public int compareTo(Person o) {
24         return this.id-o.id;
25     }
26 }
27
28 public class DemoMap {
29     public static void main(String[] args) {
30         TreeMap<Person, String> treeMap = new TreeMap<Person, String>();
31         treeMap.put(new Person(110, "张三"), "110");
32         treeMap.put(new Person(310, "王五"), "310");
33         treeMap.put(new Person(210, "李四"), "210");
34         System.out.println(treeMap);
35     }
36 }

自定义比较器

 1 import java.util.Comparator;
 2 import java.util.TreeMap;
 3
 4
 5 class Person{
 6     int id;
 7     String name;
 8     public Person(int id, String name) {
 9         this.id = id;
10         this.name = name;
11     }
12     @Override
13     public int hashCode() {
14         return this.id;
15     }
16     @Override
17     public boolean equals(Object obj) {
18         Person person = (Person)obj;
19         return this.id == person.id;
20     }
21     @Override
22     public String toString() {
23         return "{id :"+ this.id + "  名字:"+ this.name+"}";
24     }
25
26 }
27
28 class MapComparator implements Comparator<Person>{
29
30     @Override
31     public int compare(Person o1, Person o2) {
32         return o1.id - o2.id;
33     }
34 }
35
36 public class DemoMap {
37     public static void main(String[] args) {
38         TreeMap<Person, String> treeMap = new TreeMap<Person, String>(new MapComparator());
39         treeMap.put(new Person(110, "张三"), "110");
40         treeMap.put(new Person(310, "王五"), "310");
41         treeMap.put(new Person(210, "李四"), "210");
42         System.out.println(treeMap);
43     }
44 }

HashTable

和hashMap实现原理一样,但是是线程安全的,执行效率低。出现于JDK1.0。

时间: 2024-10-01 07:22:58

集合(三)------双列集合的相关文章

获取单列集合,双列集合,数组的Stream流对象以及简单操作

获取流对象 获取单列集合,双列集合,数组的流对象 单列集合获取流对象: 1.java.util.Collection接口中加入了default方法stream()获取流对象,因此其所有实现类均可通过此方式获取流. public class StreamTest01 { List<String> list = new ArrayList<>(); Stream<String> stream1 = list.stream(); Set<String> set =

Collection单列集合 Map双列集合

Map集合:该集合存储键值对,一对一对往里存.而且要保证键的唯一性. 1.添加 put(K key, V value) putAll(Map<? extends K,? extends V> m) 2.删除 clear() remove(Object key) 3.判断 containsKey(Object key) containsValue(Object value) isEmpty() 4.获取 get(Object key) :获取值 size() values() entrySet(

JAVA双列集合HashMap

HashMap 双列集合HashMap是属于java集合框架3大类接口的Map类,   Map接口储存一组成对的键-值对象,提供key(键)到value(值)的映射.Map中的key不要求有序,不允许重复.value同样不要求有序,但允许重复. Iterator接口是负责定义访问和遍历元素的接口 1. 使用Iterator迭代器缺点: 1. ListIterator有add()方法,可以向List中添加对象,而Iterator不能 2. ListIterator和Iterator都有hasNex

双列集合Map及实现该接口的类的常用方法

为什么要学双列集合? 因为单列集合无法处理映射关系,会有成对出现的数据 Map接口  如果是实现了Map接口的集合类,具备的特点: 存储的数据都是以键值对的形式存在的,键不可重复,值可以重复 Map接口的方法:   添加:    put(K key, V value)     putAll(Map<? extends K,? extends V> m)    删除    remove(Object key)     clear()   获取:    get(Object key)     si

java018.双列集合Map

day18双列集合MapMap接口和Collection接口的区别: * Map是双列的,Collection是单列的 * Map的键唯一,Collection的子体系Set是唯一的,List体系可以存储重复值 * Map集合的数据结构值针对键有效,跟值无关;Collection集合的数据结构是针对元素有效 * a:添加功能  * V put(K key,V value):添加元素.   * 如果键是第一次存储,就直接存储元素,返回null   * 如果键不是第一次存在,就用值把以前的值替换掉,

Map集合(双列集合)

Map集合(双列集合)Map集合是键值对集合. 它的元素是由两个值组成的,元素的格式是:key=value. Map集合形式:{key1=value1 , key2=value2 , key3=value3 , .. } * Map集合系列: Map<K,V>(接口) / HashMap<K,V>(实现类) / LinkedHashMap<K,V>注意:Map集合只支持引用数据类型的元素存储. Map集合特点: 键是无序不重复的. 重复的键,后面加入的会直接覆盖前面.

双列集合框架:Map(个人理解)

双列集合框架:Map1.常用实现类结构|----Map:双列数据,存储key-value对的数据 ---类似于高中的函数:y = f(x)* |----HashMap:作为Map的主要实现类:线程不安全的,效率高:存储null的key和value* |----LinkedHashMap:保证在遍历map元素时,可以照添加的顺序实现遍历.* 原因:在原的HashMap底层结构基础上,添加了一对指针,指向前一个和后一个元素.* 对于频繁的遍历操作,此类执行效率高于HashMap.* |----Tre

集合面试题之双列集合Map

一.了解Map集合吗?Map集合都有哪些实现 HashMap .HashTable.    LinkedHashMap .TreeMap.   ConcurrentHashMap HashMap底层数据结构是哈希表,所以其特点是元素无序且唯一(自定义对象需要重写hashCode和equals方法保证他的唯一性) Hashtable它和HashMap类很相似,但是它支持同步,Hashtable在哈希表中存储键/值对,当使用一个哈希表,要指定用作键的对象,以及要链接到该键的值. 然后,该键经过哈希处

双列集合之hashtable

一.hashtable和ArrayList的性能比较 hashtable比ArrayList取值更快.原因是前者是根据键直接取值,但是ArrayList是循环整个集合,找到需要的元素. 二.hashtable的用法 1 static void Main(string[] args) 2 { 3 Hashtable hs = new Hashtable(); 4 hs.Add("zs","张三"); 5 hs.Add("ls", "李四&