双列集合Map

双列集合：map - 地图

Map:双列集合，每个一个集合分为键和值两个部分组成，是一个键值对的关系 - 对应关系（映射关系）
实际使用中利用键找到值。
最常用的Map集合是HashMap：键是唯一且无序！
键 - key
值 - value
* 键值对 - entrySet

用法：
put(key,value):添加元素 - 当key相同的时候，新值会覆盖旧值！
value get(key):获取元素 - 获取key所对应的值

补充：Map是一个接口，是单独一个接口，不属于Collection（属于单列集合）

常用方法：
value get(key)
value put(key,value)
Set keySet() - 返回的是所有的集合
Collection values() - 返回的是所有值的集合

Entry方法

map遍历的方式2：

Set> entrySet() - 方法用于返回某个集合中所有的键值对对象
Entry将键值对的对应关系封装成了一个对象，可以从一个Entry对象中获取每一个键值对的键和值
Map.Entry说明Entry是属于Map的一个内部接口！

Entry的方法：

K getKey() - 获取键
V getValue() - 获取值 ```java import java.util.HashMap; import java.util.Map; import java.util.Set;

public class MapDemo2 { public static void main(String[] args) { //创建对象 HashMap map = new HashMap<>(); //添加元素 map.put(“黑旋风”,”李逵”); map.put(“金毛狮王”,”段景住”); map.put(“母夜叉”,”孙二娘”);

    //获取集合汇总的所有的键值对对象的set集合
    Set<Map.Entry<String,String>> entrySet = map.entrySet();
    //System.out.println(entrySet);
    //迭代集合，获取每一个键值对的对象 - 增强for循环 - 底层是一个迭代器
    for (Map.Entry<String, String> entry : entrySet) {
        //通过键值对的对象获取键
        String key = entry.getKey();
        //通过键值对的对象获取值
        String value = entry.getValue();
        System.out.println(key+":"+value);
    }
}

}


<a name="bfVsf"></a>
# LinkedHashMap
**LinkedHashMap的作用和使用：**

- LinkedHashMap继承自HashMap并实现了Map接口！

**LinkedHashMap作用：**

- 1.链表结构可以保证元素有序
- 2.Hash结构可以保证元素唯一性
- 3.以上约束仅仅对key有效

**注意：底层的链式结构实现怎么存就怎么取 - 不用考虑，使用就行**<br />**实际上LinkedHashMap的底层使用的是Node节点做的是排序处理**<br />**
<a name="iToe0"></a>
# Collections
Collections是一个工具类

- 这个类是一个静态的类，也就是意味着可以直接通过类名.方法来调用 - 不需要实例化
- 这个类中的方法都是静态方法 - 基本上都是集合中服务的

- public static void shuffle(List<?> list):打乱元素的顺序

- 有顺序：每一个元素都是按照添加的时候生成的下标进行排序
- 排序后：不管是第几个放的，只要是到了集合中，就会按照一定的顺序重新排列。

**二分查找法：(**Collections.binarySearch(list,key);**)**

- **在一个集合中，如果找到返回一个值，找不到返回一个负数,不管这个指定元素的下标是多少**
- **二分查找法必须要求集合中的元素排列好顺序。**
- **binarySearch(查找的集合，在集合中查找的内容);返回下标**


<a name="BNNXg"></a>
# 可变参数

**什么是方法签名？**<br />*** main(String[] args) - 方法签名**<br />*** 包含方法名和参数列表**

- 可变参数的优点：使参数列表更加灵活
- 可变参数：参数的数量可变！

注意：

- 1.数据类型...代表可变参数，即可以传入任意个该类型的数据
- 2.可变参数不能放在前面，只能放在后面
- 3.可变参数的方法与数组的方法不能重载，因为可变参数就是一个数组

```java
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;

/**
 * 讲解方法的可变参数
 *
 */
public class ArgsDemo {
    public static void main(String[] args) {
        //利用父类的接口创建对象
        Collection<String> c = new ArrayList<>();

        //添加数据 - 调用方法
        Collections.addAll(c,"黄药师","段誉","虚竹");//jvm会自动将多个参数封装成一个数组
        System.out.println(c);

        System.out.println("--------------------------------");

        //自定义一个方法 - 可以灵活的处理参数列表
        int sum = add(10, 20, 50, 88);
        System.out.println("sum="+sum);

        System.out.println("--------------------------------");

        int[] arr = {10,20,50,88};
        int sum2 = add(arr);
        System.out.println("sum2="+sum2);
    }

    //封装一个灵活参数的方法
    public static int add(int...a){
        //声明变量，记录所有数字的和
        int sum = 0;
        //变量数组 - 参数列表数组
        for (int i = 0; i < a.length; i++) {
            int j = a[i];
            System.out.println("j="+j);
            //没遇到一个数字就累加
            sum += j;
        }
        return sum;
    }

    /**
     * 可变参数其实就是一个数组
     * 这里int[]其实就和int...是一样的，所以jvm判断为两个方法一样，并不是重载
     * public static int add(int[] arr){
     *     return 0;
     * }
     */


}

数组与集合的相互转换

Arrays工具类

Arrays是一个工具类 - 专门服务于数组的 - 是一个静态类
toString()其实就是在Arrays中重写了Object中的方法
**

数组转成集合

Java数组的特点：
1.一旦声明不能修改长度
2.存放的元素只能是当前声明的数据类型

java集合的特点：
1.长度任意改变
2.存放的元素可以是任意类型 - 包装类

数组转成集合的方法：
public static * List asList(T…a):将数组转换成集合
*注意：数组转换成集合后，该集合就不支持添加或删除操作，否则会抛出异常**

集合转成数组：

public T[] toArray(T[] a);
__ public Object[] toArray(); - __集合转换为数组

import java.util.ArrayList;
import java.util.Arrays;

/**
 * 集合转换为数组：
 *  public <T> T[] toArray(T[] a);
 *  public Object[] toArray(); - 集合转换为数组
 *
 *
 *  总结：
 *  1.当数组转为集合的时候要注意：不能进行添加和删除的操作 - 遵循数组的结构规则
 *  2.当集合转为数组的时候要注意：数据类型的强制转型或者泛型的使用
 *  3.数组转为集合 - 从小到大
 *    集合转为数组 - 从大到小
 */
public class ArrayListToArrayDemo {
    public static void main(String[] args) {
        //声明一个集合
        ArrayList<Integer> list = new ArrayList<>();
        list.add(10);
        list.add(1);
        list.add(5);
        list.add(7);
        list.add(3);

        //调用方法 - 将集合转换为Object类型的数组
        Object[] objArr = list.toArray();
        System.out.println(Arrays.toString(objArr));
        //向下转型
        Integer i = (Integer) objArr[0];
        System.out.println(i.intValue());

        System.out.println("-------------------------");

        //调用方法，将集合转换为带类型的数组
        Integer[] intArr = new Integer[6];
        Integer[] returnArr = list.toArray(intArr);

        System.out.println(Arrays.toString(intArr));//[10, 1, 5, 7, 3, null]
        System.out.println(Arrays.toString(returnArr));//[10, 1, 5, 7, 3, null]

        /*如果给定的数组的长度不足以存放下集合中的元素，这个时候系统会再次自动创建
        一个能够存放集合中元素的数组，原来声明好的数组就不用了*/
        Integer[] intArr = new Integer[3];
        Integer[] returnArr = list.toArray(intArr);
        System.out.println(Arrays.toString(intArr));//[null，null，null]

        //帶泛型的
        Integer integer = returnArr[3];
        System.out.println(integer.intValue());//7
    }
}

总结：

1.当数组转为集合的时候要注意：不能进行添加和删除的操作 - 遵循数组的结构规则
2.当集合转为数组的时候要注意：数据类型的强制转型或者泛型的使用
3.数组转为集合 - 从小到大
集合转为数组 - __从大到小

JAVASE

day18