18 API-集合(Map(Map_HashMap_TreeMap),Collections工具类,集合(C+M)大总结)

来源：互联网发布：电脑360数据恢复大师编辑：程序博客网时间：2024/06/10 01:08

1:Map(掌握)

(1)将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

(2)Map和Collection的区别?

A:Map存储的是键值对形式的元素，键唯一，值可以重复。夫妻对

B:Collection存储的是单独出现的元素，子接口Set元素唯一，子接口List元素可重复。光棍

* 注意：
* Map集合的数据结构值针对键有效，跟值无关
* Collection集合的数据结构是针对元素有效

(3)Map接口功能概述(自己补齐)

A:添加功能

*V put(K key,V value):添加元素。
如果键是第一次存储，就直接存储元素，返回null
如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值

B:删除功能

*void clear():移除所有的键值对元素
V remove(Object key)：根据键删除键值对元素，并把值返回

C:判断功能

* boolean containsKey(Object key)：判断集合是否包含指定的键
* boolean containsValue(Object value):判断集合是否包含指定的值
* boolean isEmpty()：判断集合是否为空

D:获取功能

* Set<Map.Entry<K,V>> entrySet(): 获取键值对对象的集合
* V get(Object key):根据键获取值
* Set<K> keySet():获取集合中所有键的集合
* Collection<V> values():获取集合中所有值的集合

E:长度功能

* int size()：返回集合中的键值对的对数

(4)Map集合的遍历

A:键找值

a:获取所有键的集合

b:遍历键的集合,得到每一个键

c:根据键到集合中去找值

B:键值对对象找键和值

a:获取所有的键值对对象的集合

b:遍历键值对对象的集合，获取每一个键值对对象

c:根据键值对对象去获取键和值

代码体现：

Map<String,String>hm = new HashMap<String,String>();

hm.put("it002","hello");

hm.put("it003","world");

hm.put("it001","java");

//方式1 键找值

Set<String>set = hm.keySet();

for(Stringkey : set) {

Stringvalue = hm.get(key);

System.out.println(key+"---"+value);

}

//方式2 键值对对象找键和值

Set<Map.Entry<String,String>>set2 = hm.entrySet();

for(Map.Entry<String,String>me : set2) {

Stringkey = me.getKey();

Stringvalue = me.getValue();

System.out.println(key+"---"+value);

}

(5)HashMap集合的练习

A:HashMap<String,String>

B:HashMap<Integer,String>

C:HashMap<String,Student>

D:HashMap<Student,String>

(6)TreeMap集合的练习

A:TreeMap<String,String>

B:TreeMap<Student,String>

(6.5) LinkedHashMap

* LinkedHashMap:是Map接口的哈希表和链接列表实现，具有可预知的迭代顺序。
* 由哈希表保证键的唯一性
* 由链表保证键盘的有序(存储和取出的顺序一致)

* 1:Hashtable和HashMap的区别?
* Hashtable:线程安全，效率低。不允许null键和null值
* HashMap:线程不安全，效率高。允许null键和null值
*
* 2:List,Set,Map等接口是否都继承子Map接口?
* List，Set不是继承自Map接口，它们继承自Collection接口
* Map接口本身就是一个顶层接口

(7)案例

A:统计一个字符串中每个字符出现的次数

import java.util.Scanner;import java.util.Set;import java.util.TreeMap;/* * 需求 ："aababcabcdabcde",获取字符串中每一个字母出现的次数要求结果:a(5)b(4)c(3)d(2)e(1) *  * 分析： * A:定义一个字符串(可以改进为键盘录入) * B:定义一个TreeMap集合 * 键:Character * 值：Integer * C:把字符串转换为字符数组 * D:遍历字符数组，得到每一个字符 * E:拿刚才得到的字符作为键到集合中去找值，看返回值 * 是null:说明该键不存在，就把该字符作为键，1作为值存储 * 不是null:说明该键存在，就把值加1，然后重写存储该键和值 * F:定义字符串缓冲区变量 * G:遍历集合，得到键和值，进行按照要求拼接 * H:把字符串缓冲区转换为字符串输出 *  * 录入：linqingxia * 结果：result:a(1)g(1)i(3)l(1)n(2)q(1)x(1) */public class TreeMapDemo {public static void main(String[] args) {// 定义一个字符串(可以改进为键盘录入)Scanner sc = new Scanner(System.in);System.out.println("请输入一个字符串：");String line = sc.nextLine();// 定义一个TreeMap集合TreeMap<Character, Integer> tm = new TreeMap<Character, Integer>();//把字符串转换为字符数组char[] chs = line.toCharArray();//遍历字符数组，得到每一个字符for(char ch : chs){//拿刚才得到的字符作为键到集合中去找值，看返回值Integer i =  tm.get(ch);//是null:说明该键不存在，就把该字符作为键，1作为值存储if(i == null){tm.put(ch, 1);}else {//不是null:说明该键存在，就把值加1，然后重写存储该键和值i++;tm.put(ch,i);}}//定义字符串缓冲区变量StringBuilder sb=  new StringBuilder();//遍历集合，得到键和值，进行按照要求拼接Set<Character> set = tm.keySet();for(Character key : set){Integer value = tm.get(key);sb.append(key).append("(").append(value).append(")");}//把字符串缓冲区转换为字符串输出String result = sb.toString();System.out.println("result:"+result);}}

B:集合的嵌套遍历
a:HashMap嵌套HashMap
b:HashMap嵌套ArrayList
c:ArrayList嵌套HashMap

d:多层嵌套

*面试题
* 1:Hashtable和HashMap的区别?
* Hashtable:线程安全，效率低。不允许null键和null值
* HashMap:线程不安全，效率高。允许null键和null值
*
* 2:List,Set,Map等接口是否都继承子Map接口?
* List，Set不是继承自Map接口，它们继承自Collection接口
* Map接口本身就是一个顶层接口
*/

2:Collections(理解)

(1)是针对集合进行操作的工具类
(2)面试题：Collection和Collections的区别
A:Collection 是单列集合的顶层接口，有两个子接口List和Set
B:Collections 是针对集合进行操作的工具类，可以对集合进行排序和查找等
(3)常见的几个小方法：
A:public static <T> void sort(List<T> list) 排序默认情况下是自然顺序。《如果同时有自然排序和比较器排序，以比较器排序为主》
B:public static <T> int binarySearch(List<?> list,T key) 二分查找
C:public static <T> T max(Collection<?> coll) 最大值
D:public static void reverse(List<?> list) 反转
E:public static void shuffle(List<?> list) 随机置换
(4)案例

A:ArrayList集合存储自定义对象的排序

学生类略

import java.util.ArrayList;import java.util.Collections;import java.util.Comparator;import java.util.List;/* * Collections可以针对ArrayList存储基本包装类的元素排序，存储自定义对象可不可以排序呢? */public class CollectionsDemo {public static void main(String[] args) {// 创建集合对象List<Student> list = new ArrayList<Student>();// 创建学生对象Student s1 = new Student("林青霞", 27);Student s2 = new Student("风清扬", 30);Student s3 = new Student("刘晓曲", 28);Student s4 = new Student("武鑫", 29);Student s5 = new Student("林青霞", 27);// 添加元素对象list.add(s1);list.add(s2);list.add(s3);list.add(s4);list.add(s5);// 排序// 自然排序/* Collections.sort(list);//=====>学生类里implements Comparable<Student> 并且复写@Override【public int compareTo(Student s) {int num = this.age - s.age;int num2 = num == 0 ? this.name.compareTo(s.name) : num;return num2;}】*/// 比较器排序// 如果同时有自然排序和比较器排序，以比较器排序为主Collections.sort(list, new Comparator<Student>() {@Overridepublic int compare(Student s1, Student s2) {int num = s2.getAge() - s1.getAge();int num2 = num == 0 ? s1.getName().compareTo(s2.getName()): num;return num2;}});// 遍历集合for (Student s : list) {System.out.println(s.getName() + "---" + s.getAge());}}}

B:模拟斗地主洗牌和发牌

C:模拟斗地主洗牌和发牌并对牌进行排序

import java.util.ArrayList;import java.util.Collections;import java.util.HashMap;import java.util.TreeSet;/* * 思路： * A:创建一个HashMap集合 * B:创建一个ArrayList集合 * C:创建花色数组和点数数组 * D:从0开始往HashMap里面存储编号，并存储对应的牌 *        同时往ArrayList里面存储编号即可。 *      E:洗牌(洗的是编号) *      F:发牌(发的也是编号，为了保证编号是排序的，就创建TreeSet集合接收) *      G:看牌(遍历TreeSet集合，获取编号，到HashMap集合找对应的牌) */public class PokerDemo {public static void main(String[] args) {// 创建一个HashMap集合HashMap<Integer, String> hm = new HashMap<Integer, String>();// 创建一个ArrayList集合ArrayList<Integer> array = new ArrayList<Integer>();// 创建花色数组和点数数组// 定义一个花色数组String[] colors = { "♠", "♥", "♣", "♦" };// 定义一个点数数组String[] numbers = { "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q","K", "A", "2", };// 从0开始往HashMap里面存储编号，并存储对应的牌,同时往ArrayList里面存储编号即可。int index = 0;for (String number : numbers) {for (String color : colors) {String poker = color.concat(number);hm.put(index, poker);array.add(index);index++;}}hm.put(index, "小王");array.add(index);index++;hm.put(index, "大王");array.add(index);// 洗牌(洗的是编号)Collections.shuffle(array);// 发牌(发的也是编号，为了保证编号是排序的，就创建TreeSet集合接收)TreeSet<Integer> fengQingYang = new TreeSet<Integer>();TreeSet<Integer> linQingXia = new TreeSet<Integer>();TreeSet<Integer> liuYi = new TreeSet<Integer>();TreeSet<Integer> diPai = new TreeSet<Integer>();for (int x = 0; x < array.size(); x++) {if (x >= array.size() - 3) {diPai.add(array.get(x));} else if (x % 3 == 0) {fengQingYang.add(array.get(x));} else if (x % 3 == 1) {linQingXia.add(array.get(x));} else if (x % 3 == 2) {liuYi.add(array.get(x));}}// 看牌(遍历TreeSet集合，获取编号，到HashMap集合找对应的牌)lookPoker("风清扬", fengQingYang, hm);lookPoker("林青霞", linQingXia, hm);lookPoker("刘意", liuYi, hm);lookPoker("底牌", diPai, hm);}// 写看牌的功能public static void lookPoker(String name, TreeSet<Integer> ts,HashMap<Integer, String> hm) {System.out.print(name + "的牌是：");for (Integer key : ts) {String value = hm.get(key);System.out.print(value + " ");}System.out.println();}}

===============================

集合(C+M)大总结

1:集合(自己补齐)

Collection(单列集合)

List(有序,可重复)

ArrayList

底层数据结构是数组,查询快,增删慢

线程不安全,效率高

Vector

底层数据结构是数组,查询快,增删慢

线程安全,效率低

LinkedList

底层数据结构是链表,查询慢,增删快

线程不安全,效率高

Set(无序,唯一)

HashSet

底层数据结构是哈希表。

哈希表依赖两个方法：hashCode()和equals()

执行顺序：

首先判断hashCode()值是否相同

是：继续执行equals(),看其返回值

是true:说明元素重复，不添加

是false:就直接添加到集合

否：就直接添加到集合

最终：

自动生成hashCode()和equals()即可

LinkedHashSet

底层数据结构由链表和哈希表组成。

由链表保证元素有序。

由哈希表保证元素唯一。

TreeSet

底层数据结构是红黑树。(是一种自平衡的二叉树)

如何保证元素唯一性呢?

根据比较的返回值是否是0来决定

如何保证元素的排序呢?

两种方式

自然排序(元素具备比较性)

让元素所属的类实现Comparable接口

比较器排序(集合具备比较性)

让集合接收一个Comparator的实现类对象

Map(双列集合)

A:Map集合的数据结构仅仅针对键有效，与值无关。

B:存储的是键值对形式的元素，键唯一，值可重复。

HashMap

底层数据结构是哈希表。线程不安全，效率高

哈希表依赖两个方法：hashCode()和equals()

执行顺序：

首先判断hashCode()值是否相同

是：继续执行equals(),看其返回值

是true:说明元素重复，不添加

是false:就直接添加到集合

否：就直接添加到集合

最终：

自动生成hashCode()和equals()即可

LinkedHashMap

底层数据结构由链表和哈希表组成。

由链表保证元素有序。

由哈希表保证元素唯一。

Hashtable

底层数据结构是哈希表。线程安全，效率低

哈希表依赖两个方法：hashCode()和equals()

执行顺序：

首先判断hashCode()值是否相同

是：继续执行equals(),看其返回值

是true:说明元素重复，不添加

是false:就直接添加到集合

否：就直接添加到集合

最终：

自动生成hashCode()和equals()即可

TreeMap

底层数据结构是红黑树。(是一种自平衡的二叉树)

如何保证元素唯一性呢?

根据比较的返回值是否是0来决定

如何保证元素的排序呢?

两种方式

自然排序(元素具备比较性)

让元素所属的类实现Comparable接口

比较器排序(集合具备比较性)

让集合接收一个Comparator的实现类对象

2:到底使用那种集合(自己补齐)

看需求。

是否是键值对象形式:

是：Map

键是否需要排序:

是：TreeMap

否：HashMap

不知道，就使用HashMap。

否：Collection

元素是否唯一:

是：Set

元素是否需要排序:

是：TreeSet

否：HashSet

不知道，就使用HashSet

否：List

要安全吗:

是：Vector(其实我们也不用它,后面我们讲解了多线程以后，我在给你回顾用谁)

否：ArrayList或者LinkedList

增删多：LinkedList

查询多：ArrayList

不知道，就使用ArrayList

3:集合的常见方法及遍历方式

Collection:

add()

remove()

contains()

iterator()

size()

遍历：

增强for

迭代器

|--List

get()

遍历：

普通for

|--Set

Map:

put()

remove()

containskey(),containsValue()

keySet()

get()

value()

entrySet()

size()

遍历：

根据键找值

根据键值对对象分别找键和值

4:ArrayList,LinkedList,HashSet,HashMap(掌握)

存储字符串和自定义对象数据并遍历

5:集合的嵌套遍历(理解)

0 0