Map集合、泛型、Collections

一、Map集合

1.1 Map集合

通过查看Map接口描述，看到Map有多个子类，这里我们主要讲解常用的HashMap集合、LinkedHashMap集合。

HashMap<K,V>

：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。
LinkedHashMap<K,V>

：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

tips：Map接口中的集合都有两个泛型变量<K,V>,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量<K,V>的数据类型可以相同，也可以不同。

1.2 Map接口中的常用方法

Map接口中定义了很多方法，常用的如下：

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集合)。

1.3 Map集合遍历键找值方式

键找值方式：即通过元素中的键，获取键所对应的值

分析步骤：

获取Map中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键。方法提示:
keyset()
遍历键的Set集合，得到每一个键。
根据键，获取键所对应的值。方法提示:
get(K key)

代码演示：

public class MapDemo01 {
    public static void main(String[] args) {
        //创建Map集合对象 
        HashMap<String, String> map = new HashMap<String,String>();
        //添加元素到集合 
        map.put("胡歌", "霍建华");
        map.put("郭德纲", "于谦");
        map.put("薛之谦", "大张伟");

        //获取所有的键  获取键集
        Set<String> keys = map.keySet();
        // 遍历键集 得到 每一个键
        for (String key : keys) {
          	//key  就是键
            //获取对应值
            String value = map.get(key);
            System.out.println(key+"的CP是："+value);
        }  
    }
}

1.4 Entry键值对对象

我们已经知道，
Map
中存放的是两种对象，一种称为

key

(键)，一种称为

value

(值)，它们在在
Map
中是一一对应关系，这一对对象又称做
Map
中的一个
Entry(项)
。
Entry
将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历
Map
集合时，就可以从每一个键值对（
Entry
）对象中获取对应的键与对应的值。

既然Entry表示了一对键和值，那么也同样提供了获取对应键和对应值得方法：

public K getKey()
：获取Entry对象中的键。
public V getValue()
：获取Entry对象中的值。

在Map集合中也提供了获取所有Entry对象的方法：

public Set<Map.Entry<K,V>> entrySet()
: 获取到Map集合中所有的键值对对象的集合(Set集合)。

1.5 Map集合遍历键值对方式

键值对方式：即通过集合中每个键值对(Entry)对象，获取键值对(Entry)对象中的键与值。

操作步骤与图解：

获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。方法提示:
entrySet()
。
遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象。
通过键值对(Entry)对象，获取Entry对象中的键与值。方法提示:
getkey() getValue()

public class MapDemo02 {
    public static void main(String[] args) {
        // 创建Map集合对象 
        HashMap<String, String> map = new HashMap<String,String>();
        // 添加元素到集合 
        map.put("胡歌", "霍建华");
        map.put("郭德纲", "于谦");
        map.put("薛之谦", "大张伟");

        // 获取 所有的 entry对象  entrySet
        Set<Entry<String,String>> entrySet = map.entrySet();

        // 遍历得到每一个entry对象
        for (Entry<String, String> entry : entrySet) {
           	// 解析 
            String key = entry.getKey();
            String value = entry.getValue();  
            System.out.println(key+"的CP是:"+value);
        }
    }
}

二、泛型

2.1 普通集合：

1、存放数据统一使用Object，读取数据返回的也都是Object，频繁涉及对象的向上或者向下的转型，效率显然会有影响

2、存放数据的数据类型不确定，导致使用的时候，出现类型转换格式不匹配的异常，数据不安全

泛型解决普通集合的问题：

1、效率高

2、类型安全的

泛型：

泛型类

、

泛型方法

、

泛型接口

、

泛型集合

语法：

集合<数据类型> 集合名=new 集合<数据类型>()；

支持菱形语法：

集合<数据类型> 集合名=new 集合<>()；

在前面学习集合时，我们都知道集合中是可以存放任意对象的，只要把对象存储集合后，那么这时他们都会被提升成Object类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换。

2.2 泛型通配符

当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。

通配符基本使用

泛型的通配符:

不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。

此时只能接受数据,不能往该集合中存储数据。

举个例子大家理解使用即可：

public static void main(String[] args) {
    Collection<Intger> list1 = new ArrayList<Integer>();
    getElement(list1);
    Collection<String> list2 = new ArrayList<String>();
    getElement(list2);
}
public static void getElement(Collection<?> coll){}
//？代表可以接收任意类型

tips:泛型不存在继承关系 Collection list = new ArrayList();这种是错误的。

通配符高级使用—-受限泛型

之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的

上限

和

下限

。

泛型的上限

：

格式

：
类型名称 <? extends 类 > 对象名称
意义

：
只能接收该类型及其子类

泛型的下限

：

格式

：
类型名称 <? super 类 > 对象名称
意义

：
只能接收该类型及其父类型

比如：现已知Object类，String 类，Number类，Integer类，其中Number是Integer的父类

三、Collections

Arrays：操作数组。排序、查找

Collections：操作集合。排序、查找

常用功能

java.utils.Collections
是集合工具类，用来对集合进行操作。部分方法如下：
public static <T> boolean addAll(Collection<T> c, T... elements)
:往集合中添加一些元素。
public static void shuffle(List<?> list) 打乱顺序
:打乱集合顺序。
public static <T> void sort(List<T> list)
:将集合中元素按照默认规则排序。
public static <T> void sort(List<T> list，Comparator<? super T> )
:将集合中元素按照指定规则排序。
BinarySearch()
必须基于排序。

代码演示：

public class CollectionsDemo {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        //原来写法
        //list.add(12);
        //list.add(14);
        //list.add(15);
        //list.add(1000);
        //采用工具类 完成 往集合中添加元素  
        Collections.addAll(list, 5, 222, 1，2);
        System.out.println(list);
        //排序方法 
        Collections.sort(list);
        System.out.println(list);
    }
}
结果：
[5, 222, 1, 2]
[1, 2, 5, 222]

Comparator比较器

我们还是先研究这个方法

public static <T> void sort(List<T> list)
:将集合中元素按照默认规则排序。

不过这次存储的是字符串类型。

public class CollectionsDemo2 {
    public static void main(String[] args) {
        ArrayList<String>  list = new ArrayList<String>();
        list.add("cba");
        list.add("aba");
        list.add("sba");
        list.add("nba");
        //排序方法
        Collections.sort(list);
        System.out.println(list);
    }
}

结果：

[aba, cba, nba, sba]

简述Comparable和Comparator两个接口的区别。

Comparable

：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。

Comparator

强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。

原文链接：https://blog.csdn.net/weixin_43951534/article/details/88852727