Java学习笔记十五（集合）

内容的要求：（面试必考）

层次一：选择合适的集合类去实现数据的保存，调用其内部的相关方法。
层次二：不同的集合类底层的数据结构为何？如何实现数据的操作的：增删改查等。

一、集合的概述：

1、集合和数组都是对数据进行存储操作的的结构，简称Java容器；
（这里的存储主要指的是内存层面的存储；不涉及持久化的存储：.txt、数据库中、.jpg等）
2、数组中存储多个数据的特点：
①数组一旦确定，长度也就确定了；
②数组一旦定义好，其元素类型也就确定了，我们只能操作指定的类型的数据了；像：String[]、int[]等。
3、数组在存储多个数据方面的缺点：
①数组一旦声明完成，其长度就不可修改；
②数组中定义的方法非常有限，像增删改查等操作非常不便；
③获取数组中元素个数的需求，数组中没有定义现成的属性和方法；
④数组中存储数据的特点是有序的、可重复的；对于无序的和不可重复的需求无法满足。

二、集合框架：

|——Collection接口：单列集合，用来存储一个一个的数据；

|——List接口：用来存储有序的可重复的数据；（动态数组）
- |——ArrayList、LinkedList、Vector
|——Set接口：存储无序的不可重复的数据；（高中的集合）
- |——HashSet、LinkedHashSet、TreeSet

|——Map接口：双列集合，用于存储一对一对（k-v）的数据;（高中的函数）

|——HashMap、LinkedHashMap、TreeMap、HashTable、Properties

在这里插入图片描述

三、Collection接口中常用方法的使用：

注意：
向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals().

add(Object obj)，addAll(Collection coll)，size()，isEmpty()，clear()，

 @Test
    public void test1(){
        Collection coll = new ArrayList();

        //add(Object e):将元素e添加到集合coll中,返回的是boolean类型
        coll.add("AA");
        coll.add("BB");
        coll.add(123);//自动装箱
        coll.add(new Date());

        //size():获取添加的元素的个数
        System.out.println(coll.size());//4

        //addAll(Collection coll1):将coll1集合中的元素添加到当前的集合中
        Collection coll1 = new ArrayList();
        coll1.add(456);
        coll1.add("CC");
        coll.addAll(coll1);

        System.out.println(coll.size());//6
        System.out.println(coll);

        //clear():清空集合元素
        coll.clear();

        //isEmpty():判断当前集合是否为空
        System.out.println(coll.isEmpty());

    }

contains(Object obj)，containsAll(Collection coll)
（contains(Object obj):判断当前集合中是否包含obj，我们在判断时会调用obj对象所在类的equals()，比较的是对象中的实体内容。）

@Test
    public void test1(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
//        Person p = new Person("Jerry",20);
//        coll.add(p);
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);
        //1.contains(Object obj):判断当前集合中是否包含obj
        //我们在判断时会调用obj对象所在类的equals()。
        boolean contains = coll.contains(123);
        System.out.println(contains);
        System.out.println(coll.contains(new String("Tom")));
//        System.out.println(coll.contains(p));//true
        System.out.println(coll.contains(new Person("Jerry",20)));//false -->true

        //2.containsAll(Collection coll1):判断形参coll1中的所有元素是否都存在于当前集合中。
        Collection coll1 = Arrays.asList(123,4567);
        System.out.println(coll.containsAll(coll1));
    }

remove(Object obj)，removeAll(Collection coll)，retainsAll(Collectioncoll)，equals(Object obj)，hasCode(),toArray()，iterator()；

public class CollectionTest {


    @Test
    public void test1() {
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
//        Person p = new Person("Jerry",20);
//        coll.add(p);
        coll.add(new Person("Jerry", 20));
        coll.add(new String("Tom"));
        coll.add(false);
        //1.contains(Object obj):判断当前集合中是否包含obj
        //我们在判断时会调用obj对象所在类的equals()。
        boolean contains = coll.contains(123);
        System.out.println(contains);
        System.out.println(coll.contains(new String("Tom")));
//        System.out.println(coll.contains(p));//true
        System.out.println(coll.contains(new Person("Jerry", 20)));//false -->true

        //2.containsAll(Collection coll1):判断形参coll1中的所有元素是否都存在于当前集合中。
        Collection coll1 = Arrays.asList(123, 4567);
        System.out.println(coll.containsAll(coll1));
    }

    @Test
    public void test2() {
        //3.remove(Object obj):从当前集合中移除obj元素。
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry", 20));
        coll.add(new String("Tom"));
        coll.add(false);

        coll.remove(1234);
        System.out.println(coll);

        coll.remove(new Person("Jerry", 20));
        System.out.println(coll);

        //4. removeAll(Collection coll1):差集：从当前集合中移除coll1中所有的元素。
        Collection coll1 = Arrays.asList(123, 456);
        coll.removeAll(coll1);
        System.out.println(coll);


    }

    @Test
    public void test3() {
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry", 20));
        coll.add(new String("Tom"));
        coll.add(false);

        //5.retainAll(Collection coll1):交集：获取当前集合和coll1集合的交集，并返回给当前集合
//        Collection coll1 = Arrays.asList(123,456,789);
//        coll.retainAll(coll1);
//        System.out.println(coll);

        //6.equals(Object obj):要想返回true，需要当前集合和形参集合的元素都相同。
        Collection coll1 = new ArrayList();
        coll1.add(456);
        coll1.add(123);
        coll1.add(new Person("Jerry", 20));
        coll1.add(new String("Tom"));
        coll1.add(false);

        System.out.println(coll.equals(coll1));


    }

    @Test
    public void test4() {
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry", 20));
        coll.add(new String("Tom"));
        coll.add(false);

        //7.hashCode():返回当前对象的哈希值
        System.out.println(coll.hashCode());

        //8.集合 --->数组：toArray()
        Object[] arr = coll.toArray();
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        //拓展：数组 --->集合:调用Arrays类的静态方法asList()
        List<String> list = Arrays.asList(new String[]{"AA", "BB", "CC"});
        System.out.println(list);

        List arr1 = Arrays.asList(new int[]{123, 456});//注意基本数据类型的数组，会被当成是一个元素
        System.out.println(arr1);//[[I@50134894]
        System.out.println(arr1.size());//1

        List arr2 = Arrays.asList(new Integer[]{123, 456});
        System.out.println(arr2.size());//2

        //9.iterator():返回Iterator接口的实例，用于遍历集合元素。放在IteratorTest.java中测试

    }
}

Collection集合与数组间的转换:

扫描二维码关注公众号，回复： 11112898 查看本文章

//集合 --->数组：toArray()
Object[] arr = coll.toArray();
for(int i = 0;i < arr.length;i++){
    System.out.println(arr[i]);
}

//拓展：数组 --->集合:调用Arrays类的静态方法asList(T ... t)
List<String> list = Arrays.asList(new String[]{"AA", "BB", "CC"});
System.out.println(list);

//因为不用自动装箱也可以理解，就不会自动装箱。
//可以理解为看成了一个数组对象，
List arr1 = Arrays.asList(new int[]{123, 456});
//下面会自动装箱
//List arr1 = Arrays.asList({123, 456});//2

System.out.println(arr1.size());//1

List arr2 = Arrays.asList(new Integer[]{123, 456});
System.out.println(arr2.size());//2

注意： 使用Collection集合存储对象，要求对象所属的类满足：
向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals()。

遍历Collection的两种方式：

① 使用迭代器Iterator ② foreach循环（或增强for循环）
（java.utils包下定义的迭代器接口：Iterator）

Iterator说明：
1、Iterator对象称为迭代器(设计模式的一种)，主要用于遍历 Collection 集合中的元素。
2、GOF给迭代器模式的定义为：提供一种方法访问一个容器(container)对象中各个元素，而又不需暴露该对象的内部细节。迭代器模式，就是为容器而生。

如何获取实例： coll.iterator()返回一个迭代器实例；

Iterator iterator = coll.iterator();
//hasNext():判断是否还下一个元素
while(iterator.hasNext()){
    //next():①指针下移 ②将下移以后集合位置上的元素返回
    System.out.println(iterator.next());
}

说明迭代器的执行原理：
在这里插入图片描述
迭代器中remove（）的使用：
注意点：
1、如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法，再调用remove都会报IllegalStateException。
2、内部定义了remove(),可以在遍历的时候，删除集合中的元素。此方法不同于集合直接调用remove()

 @Test
    public void test3(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);

        //删除集合中"Tom"
        Iterator iterator = coll.iterator();
        while (iterator.hasNext()){
//            iterator.remove();
            Object obj = iterator.next();
            if("Tom".equals(obj)){
                iterator.remove();
//                iterator.remove();
            }

        }
        //遍历集合
        iterator = coll.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

jdk5.0新增的foreach循环，用于便利集合、数组：
结构：for(集合元素的类型局部变量 : 集合对象){}；增强for循环中其实依然调用的iterator实现方式。

@Test
    public void test1(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);

        //for(集合元素的类型 局部变量 : 集合对象)
        //内部仍然调用了迭代器。
        for(Object obj : coll){
            System.out.println(obj);
        }
    }

一道关于增强for的练习题：

@Test
    public void test3(){

        String[] arr = new String[]{"MM","MM","MM"};

        //方式一：普通for赋值
        for(int i = 0;i < arr.length;i++){
            arr[i] = "GG";
        }//这种方式输出是GG

        //方式二：增强for循环
        for(String s : arr){
            s = "GG";
        }//这种方式输出是MM，新建了一个对象指向相应的内容，
        //并不改变数组中的元素；

        for(int i = 0;i < arr.length;i++){
            System.out.println(arr[i]);
        }


    }

Collection子接口之List：

1、List接口框架：
|——Collection接口：单列集合，用来存储一个一个的数据；

|——List接口：用来存储有序的可重复的数据；（动态数组）
- |——ArrayList：作为List的主要实现类；线程不安全，效率高；底层使用Object[] elementDate存储（数组）
- |—— LinkedList：对于频繁的插入、删除等操作，使用此类比ArrayList效率高；底层使用双向链表存储；
- |——Vector：作为List接口的古老实现类；线程安全的，效率低；底层使用Object[] elementData存储；

ArrayList源码分析：（JDK7和8有点变化）
JDK7下：
ArrayList list = new ArrayL()；底层创建了一个容量为10的Object[]数组elementDate;
list.add(123);底层相当于elementDate[0] = new Integer(123);…
list.add(11);如果此次添加时底层的elementDate数组容量不足，则需要进行扩容；默认情况下，扩容为原来的1.5倍，并且需要将原来数组中的元素复制到新的数组中。

结论：建议开发中使用带参的构造器ArrayList（int Capacity）;

JDK8下：
ArrayList list = new ArrayList();底层创建的Object[] elementDate是一个{}，并没有创建长度为10的数组；
list.add(123);第一次调用add()时底层才创建了长度为10的数组，并将123添加到elementDate[0]中；后续的操作就和JDK7一样了。

小结： JDK7创建ArrayList对象的底层操作类似单例模式的饿汉式；JDK8中相当于懒汉式；

LinkedList的源码分析：
LinkedList list = new LinkedList();内部声明了Node类型的first和last，默认值是null；
list.add()；将123封装到node中，创建node对象。
其中，Node定义为：体现了LinkedList的双向链表的说法

 private static class Node<E> {
      E item;
      Node<E> next;
      Node<E> prev;

      Node(Node<E> prev, E element, Node<E> next) {
      this.item = element;
      this.next = next;
      this.prev = prev;
      }
  }

Vector的源码分析：
jdk7和jdk8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组。
在扩容方面，默认扩容为原来的数组长度的2倍。
补充： 栈（一种数据结构，先进后出）是Vector的一个子类。

面试题： ArrayList、LinkedList、Vector三者的异同？

同：三个类都是实现了List接口，存储数据的特点相同：存储有序的、可重复的数据
不同：见上

List接口中的常用方法：
void add(int index, Object ele):在index位置插入ele元素
boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
Object get(int index):获取指定index位置的元素
int indexOf(Object obj):返回obj在集合中首次出现的位置
int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
Object remove(int index):移除指定index位置的元素，并返回此元素
Object set(int index, Object ele):设置指定index位置的元素为ele
List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合

总结：常用方法
增：add(Object obj)
删：remove(int index) / remove(Object obj)
改：set(int index, Object ele)
查：get(int index)
插：add(int index, Object ele)
长度：size()
遍历：① Iterator迭代器方式
② 增强for循环
③ 普通的循环

@Test
    public void test3(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");

        //方式一：Iterator迭代器方式
        Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

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

        //方式二：增强for循环
        for(Object obj : list){
            System.out.println(obj);
        }

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

        //方式三：普通for循环
        for(int i = 0;i < list.size();i++){
            System.out.println(list.get(i));
        }



    }


    @Test
    public void test2(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add(new Person("Tom",12));
        list.add(456);
        //int indexOf(Object obj):返回obj在集合中首次出现的位置。如果不存在，返回-1.
        int index = list.indexOf(4567);
        System.out.println(index);

        //int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置。如果不存在，返回-1.
        System.out.println(list.lastIndexOf(456));

        //Object remove(int index):移除指定index位置的元素，并返回此元素
        Object obj = list.remove(0);
        System.out.println(obj);
        System.out.println(list);

        //Object set(int index, Object ele):设置指定index位置的元素为ele
        list.set(1,"CC");
        System.out.println(list);

        //List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的左闭右开区间的子集合
        List subList = list.subList(2, 4);
        System.out.println(subList);
        System.out.println(list);


    }


    @Test
    public void test1(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add(new Person("Tom",12));
        list.add(456);

        System.out.println(list);

        //void add(int index, Object ele):在index位置插入ele元素
        list.add(1,"BB");
        System.out.println(list);

        //boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
        List list1 = Arrays.asList(1, 2, 3);
        list.addAll(list1);
//        list.add(list1);
        System.out.println(list.size());//9

        //Object get(int index):获取指定index位置的元素
        System.out.println(list.get(0));

    }

注意：注意区分List中remove(int index)和remove(Object obj)；

public class ListExer {
    /*
    区分List中remove(int index)和remove(Object obj)
     */
    @Test
    public void testListRemove() {
        List list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        updateList(list);
        System.out.println(list);//
    }

    private void updateList(List list) {
//        list.remove(2);
        list.remove(new Integer(2));
    }

}

Set接口：

1、Set接口的框架：
|——Collection接口：单列集合，用来存储一个一个的数据；

|——Set接口：存储无序的不可重复的数据；（高中的集合）
- |——HashSet：作为Set的主要实现类，线程不安全，效率高，且可以存储null值；
- - |——LinkedHashSet：作为HashSet的子类，对其内部数据进行遍历时，可以按照其添加顺序遍历，实现有序的访问；对于频繁遍历的操作，LinkedHashSet效率高于HashSet。
- |——TreeSet：可以按照添加对象的指定属性进行排序。、

Set接口中没有定义新的方法，使用的都是Collection声明的方法。
存储对象所在类的要求：
HashSet和LinkedHashSet：
向Set接口中添加的元素，其所在的类都要重写equals()和hashCode()方法。重写的equals()和hashCode()方法应尽可能保持一致性：equals()判断相等的对象必须具备相同的散列码（hash值）。
小技巧： 用于equals()比较的属性也应该参与hashCode()的计算。
TreeSet:
1.自然排序中，比较两个对象是否相同的标准为：compareTo()返回0.不再是equals().
2.定制排序中，比较两个对象是否相同的标准为：compare()返回0.不再是equals().
Set的无序性和不可重复性理解：
1、无序性：不等同于随机性；应解释为存储的数据在底层数组中并非按照索引的顺序进行添加，而是根据数据的hash值确定的；
2、不可重复性：保证添加的元素通过equals()判断，不能反悔true；即是相同的元素只能添加一个。

添加元素的过程：（以HashSet为例）
向HashSet中添加元素a时，首先根据元素a所在类的hashCode计算出a的hash值，然后在根据某种算法计算得出HashSet底层数组中的存放位置（即为索引），然后在判断其位置处是否存在元素：
1、若不存在则添加成功；
2、若存在元素b（或以链表形式存在的多个元素），则比较a和b的hash值：

①若hash值不相同，则添加成功；——情况2
②若hash值相同，则调用元素a所在类的equals()方法：
- 1）若equals()返回true，添加失败；
- 2）若equals()返回false，添加成功——情况3

对于添加成功的情况2和情况3而言：元素a 与已经存在指定索引位置上数据以链表的方式存储。
jdk 7 :元素a放到数组中，指向原来的元素。
jdk 8 :原来的元素在数组中，指向元素a
总结：七上八下
HashSet底层：数组+链表的结构（JDK7是，JDK8有变化）

LinkedHashSet的使用：
LinkedHashSet作为HashSet的子类，再添加元素的同时，还维护了两个引用，用于记录此数据前一个数据和后一个数据。
优点： 对于频繁的遍历的操作，LinkedHashSet效率高于HashSet。

@Test
    public void test2(){
        Set set = new LinkedHashSet();
        set.add(456);
        set.add(123);
        set.add(123);
        set.add("AA");
        set.add("CC");
        set.add(new User("Tom",12));
        set.add(new User("Tom",12));
        set.add(129);

        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

关于TreeSet： 可以根据添加元素的某种属性进行排序。
1、向TreeSet中添加的数据要求是相同类的对象。
2、两种排序方式：自然排序（实现Comparable接口)和定制排序（Comparator）。

 @Test
    public void test1(){
        TreeSet set = new TreeSet();

        //失败：不能添加不同类的对象
//        set.add(123);
//        set.add(456);
//        set.add("AA");
//        set.add(new User("Tom",12));

            //举例一：
//        set.add(34);
//        set.add(-34);
//        set.add(43);
//        set.add(11);
//        set.add(8);

        //举例二：
        set.add(new User("Tom",12));
        set.add(new User("Jerry",32));
        set.add(new User("Jim",2));
        set.add(new User("Mike",65));
        set.add(new User("Jack",33));
        set.add(new User("Jack",56));


        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

    }

    @Test
    public void test2(){
        Comparator com = new Comparator() {
            //按照年龄从小到大排列
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof User && o2 instanceof User){
                    User u1 = (User)o1;
                    User u2 = (User)o2;
                    return Integer.compare(u1.getAge(),u2.getAge());
                }else{
                    throw new RuntimeException("输入的数据类型不匹配");
                }
            }
        };

        TreeSet set = new TreeSet(com);
        set.add(new User("Tom",12));
        set.add(new User("Jerry",32));
        set.add(new User("Jim",2));
        set.add(new User("Mike",65));
        set.add(new User("Mary",33));
        set.add(new User("Jack",33));
        set.add(new User("Jack",56));


        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

双列集合框架Map：

常见面试题：
1、HashMap的底层实现原理？
2、HashMap 和 Hashtable的异同？
3、CurrentHashMap 与 Hashtable的异同？（暂时不讲）

一、Map实现类的结构：
|——Map接口：双列集合，用于存储一对一对（k-v）的数据;（高中的函数）

|——HashMap：作为Map的主要实现类；线程不安全，效率高，可以存储null值得key和value。
- |—— LinkedHashMap：可以保证在遍历集合中的元素时，是按照添加的顺序进行遍历。（原因：在原有的HashMap底层结构的基础上，添加了一对指针，指向前一个元素和后一个元素。对于频繁的遍历操作，此类的执行效率高于HashMap）
|——TreeMap：保证按照添加的key-value对进行排序，实现排序遍历（考虑的是key的自然排序和定制排序）。底层使用红黑树。
|——HashTable：古老的Map实现类，线程安全，效率低，不能存储null值的key和value。
- |——Properties：常用来处理配置文件。key和value都是String类型。

补充：
HashMap底层使用：

数组+链表（JDK7）
数组+链表+红黑树（JDK8）

二、Map结构的理解：（以HashMap为例）
Map中的key：无序的，不可重复的，使用Set存储所有的key。——key所在的类要重写equals()和hashCode()方法。
Map中的value：无序的，可重复的。使用Collection存储所有的value——value所在的类要重写equals()方法。
一个键值对：key-value构成一个Entry对象。
Map中的Entry：无序的，不可重复的；使用Set存储所有的Entry。
在这里插入图片描述

三、HashMap的底层实现原理：（JDK7）
HashMap map = new HashMap()；实例化之后底层创建一个长度为16的一维数组Entry[] table。
>>>可能经过多次put之后>>>
map.put(key1，value1)；首先，调用key1所在类的hashCode()方法计算出key1的哈希值，此值经过某种算法（其实是与length-1进行位与&）得到在Entry数组中存放的位置
如果此位置为空，则键值对添加成功。----情况1
如果此位置上的数据不为空，(意味着此位置上存在一个或多个数据(以链表形式存在)),比较key1和已经存在的一个或多个数据的哈希值：

如果key1的哈希值与该位置上所有的元素都不相同，则添加key-value对成功。----情况2
如果key1的哈希值和已经存在的某一个数据(key2-value2)的哈希值相同，继续比较：调用key1所在类的equals(key2)方法，比较：
- 如果equals()返回false:此时key1-value1添加成功。----情况3
- 如果equals()返回true，则用value1替换value2

补充：
1、关于情况2和情况3：此时key1-value1和原来的数据以链表的方式存储。

2、HashMap中的容量一定是2的幂次方，因为它有一个检验的机制：
int capacity =1;
while（capacity < initalcapacity）{
capacity <<= 1;}

3、Map不是到达容量极限在扩容：Map可能并不会到达容量极限，因为它是根据hash值算出来的，同一个索引位置可以以链表或红黑树的方式存储。（要尽可能减少，链表或红黑树的情况。）

在不断的添加过程中会涉及到扩容的问题；当超出临界值（且要存放的位置非空时），扩容。默认扩容为原来的2倍。并将原来的数据复制过来。

JDK8相较于JDK7底层实现方面的不同：
1、new HashMap()；底层没有创建一个长度为16的数组；
2、JDK8底层的数组是Node[]而非Entry[]；
3、首次调用put()方法时，底层创建长度为16的数组；
4、JDK7底层结构只有：数组+链表；JDK8底层是：数组+链表+红黑树。

当形成链表时，七上八下（JDK7时新加的元素替换旧元素在数组中的位置并指向旧元素，JDK8时是旧元素指向新元素）。
当数组某一索引上的元素以链表的形式存在的数据个数>8。并且数组的长度>64时，此时此索引位置上的所有元素改为使用红黑树存储。

关于Map的术语：
DEFAULT_INITIAL_CAPACITY : HashMap的默认容量，16
DEFAULT_LOAD_FACTOR：HashMap的默认加载因子：0.75
threshold：扩容的临界值，=容量*填充因子：16 * 0.75 => 12
TREEIFY_THRESHOLD：Bucket中链表长度大于该默认值，转化为红黑树:8
MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量:64

四、LinkedHashMap的源码分析：
就是在HashMap的基础上加了两个Entry类型的before和after用于指向前一个元素和后一个元素：

static class Entry<K,V> extends HashMap.Node<K,V> {
             Entry<K,V> before, after;//能够记录添加的元素的先后顺序
             Entry(int hash, K key, V value, Node<K,V> next) {
                super(hash, key, value, next);
             }
         }

五、Map中定义的方法：
添加、删除、修改操作：
Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
void putAll(Map m):将m中的所有key-value对存放到当前map中
Object remove(Object key)：移除指定key的key-value对，并返回value
void clear()：清空当前map中的所有数据
元素查询的操作：
Object get(Object key)：获取指定key对应的value
boolean containsKey(Object key)：是否包含指定的key
boolean containsValue(Object value)：是否包含指定的value
int size()：返回map中key-value对的个数
boolean isEmpty()：判断当前map是否为空
boolean equals(Object obj)：判断当前map和参数对象obj是否相等
元视图操作的方法：
Set keySet()：返回所有key构成的Set集合
Collection values()：返回所有value构成的Collection集合
Set entrySet()：返回所有key-value对构成的Set集合

总结：常用方法：

添加：put(Object key,Object value)
删除：remove(Object key)
修改：put(Object key,Object value)
查询：get(Object key)
长度：size()
遍历：keySet() / values() / entrySet()

@Test
    public void test5(){
        Map map = new HashMap();
        map.put("AA",123);
        map.put(45,1234);
        map.put("BB",56);

        //遍历所有的key集：keySet()
        Set set = map.keySet();
            Iterator iterator = set.iterator();
            while(iterator.hasNext()){
                System.out.println(iterator.next());
        }
        System.out.println();
        //遍历所有的value集：values()
        Collection values = map.values();
        for(Object obj : values){
            System.out.println(obj);
        }
        System.out.println();
        //遍历所有的key-value
        //方式一：entrySet()
        Set entrySet = map.entrySet();
        Iterator iterator1 = entrySet.iterator();
        while (iterator1.hasNext()){
            Object obj = iterator1.next();
            //entrySet集合中的元素都是entry
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey() + "---->" + entry.getValue());

        }
        System.out.println();
        //方式二：
        Set keySet = map.keySet();
        Iterator iterator2 = keySet.iterator();
        while(iterator2.hasNext()){
            Object key = iterator2.next();
            Object value = map.get(key);
            System.out.println(key + "=====" + value);

        }

    }


    /*
 元素查询的操作：
 Object get(Object key)：获取指定key对应的value
 boolean containsKey(Object key)：是否包含指定的key
 boolean containsValue(Object value)：是否包含指定的value
 int size()：返回map中key-value对的个数
 boolean isEmpty()：判断当前map是否为空
 boolean equals(Object obj)：判断当前map和参数对象obj是否相等
     */
    @Test
    public void test4(){
        Map map = new HashMap();
        map.put("AA",123);
        map.put(45,123);
        map.put("BB",56);
        // Object get(Object key)
        System.out.println(map.get(45));
        //containsKey(Object key)
        boolean isExist = map.containsKey("BB");
        System.out.println(isExist);

        isExist = map.containsValue(123);
        System.out.println(isExist);

        map.clear();

        System.out.println(map.isEmpty());

    }

    /*
     添加、删除、修改操作：
 Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
 void putAll(Map m):将m中的所有key-value对存放到当前map中
 Object remove(Object key)：移除指定key的key-value对，并返回value
 void clear()：清空当前map中的所有数据
     */
    @Test
    public void test3(){
        Map map = new HashMap();
        //添加
        map.put("AA",123);
        map.put(45,123);
        map.put("BB",56);
        //修改
        map.put("AA",87);

        System.out.println(map);

        Map map1 = new HashMap();
        map1.put("CC",123);
        map1.put("DD",123);

        map.putAll(map1);

        System.out.println(map);

        //remove(Object key)
        Object value = map.remove("CC");
        System.out.println(value);
        System.out.println(map);

        //clear()
        map.clear();//与map = null操作不同
        System.out.println(map.size());
        System.out.println(map);
    }

    @Test
    public void test2(){
        Map map = new HashMap();
        map = new LinkedHashMap();
        map.put(123,"AA");
        map.put(345,"BB");
        map.put(12,"CC");

        System.out.println(map);
    }


    @Test
    public void test1(){
        Map map = new HashMap();
//        map = new Hashtable();
        map.put(null,123);

    }
}

Collections:操作Collection、Map的工具类：

reverse(List)：反转 List 中元素的顺序
shuffle(List)：对 List 集合元素进行随机排序
sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换

Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
Object min(Collection)
Object min(Collection，Comparator)
int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
void copy(List dest,List src)：将src中的内容复制到dest中
boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值
说明：ArrayList和HashMap都是线程不安全的，如果程序要求线程安全，我们可以将ArrayList、HashMap转换为线程的。
使用synchronizedList(List list）和 synchronizedMap(Map map）

 @Test
    public void test2(){
        List list = new ArrayList();
        list.add(123);
        list.add(43);
        list.add(765);
        list.add(-97);
        list.add(0);

        //报异常：IndexOutOfBoundsException("Source does not fit in dest")
//        List dest = new ArrayList();
//        Collections.copy(dest,list);
        //正确的：
        List dest = Arrays.asList(new Object[list.size()]);
        System.out.println(dest.size());//list.size();
        Collections.copy(dest,list);

        System.out.println(dest);


        /*
        Collections 类中提供了多个 synchronizedXxx() 方法，
        该方法可使将指定集合包装成线程同步的集合，从而可以解决
        多线程并发访问集合时的线程安全问题

         */
        //返回的list1即为线程安全的List
        List list1 = Collections.synchronizedList(list);


    }

    @Test
    public void test1(){
        List list = new ArrayList();
        list.add(123);
        list.add(43);
        list.add(765);
        list.add(765);
        list.add(765);
        list.add(-97);
        list.add(0);

        System.out.println(list);

//        Collections.reverse(list);
//        Collections.shuffle(list);
//        Collections.sort(list);
//        Collections.swap(list,1,2);
        int frequency = Collections.frequency(list, 123);

        System.out.println(list);
        System.out.println(frequency);

    }

}

TreeMap的使用：

1、向TreeMap中添加key-value，要求key必须是由同一个类创建的对象因为要按照key进行排序：自然排序、定制排序。

 @Test
    public void test1(){
        TreeMap map = new TreeMap();
        User u1 = new User("Tom",23);
        User u2 = new User("Jerry",32);
        User u3 = new User("Jack",20);
        User u4 = new User("Rose",18);

        map.put(u1,98);
        map.put(u2,89);
        map.put(u3,76);
        map.put(u4,100);

        Set entrySet = map.entrySet();
        Iterator iterator1 = entrySet.iterator();
        while (iterator1.hasNext()){
            Object obj = iterator1.next();
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey() + "---->" + entry.getValue());

        }
    }

    //定制排序
    @Test
    public void test2(){
        TreeMap map = new TreeMap(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof User && o2 instanceof User){
                    User u1 = (User)o1;
                    User u2 = (User)o2;
                    return Integer.compare(u1.getAge(),u2.getAge());
                }
                throw new RuntimeException("输入的类型不匹配！");
            }
        });
        User u1 = new User("Tom",23);
        User u2 = new User("Jerry",32);
        User u3 = new User("Jack",20);
        User u4 = new User("Rose",18);

        map.put(u1,98);
        map.put(u2,89);
        map.put(u3,76);
        map.put(u4,100);

        Set entrySet = map.entrySet();
        Iterator iterator1 = entrySet.iterator();
        while (iterator1.hasNext()){
            Object obj = iterator1.next();
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey() + "---->" + entry.getValue());

        }
    }

Properties:常用来处理配置文件。key和value都是String类型：

public static void main(String[] args)  {
    FileInputStream fis = null;
    try {
        Properties pros = new Properties();

        fis = new FileInputStream("jdbc.properties");
        pros.load(fis);//加载流对应的文件

        String name = pros.getProperty("name");
        String password = pros.getProperty("password");

        System.out.println("name = " + name + ", password = " + password);
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if(fis != null){
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

木偶winner

发布了28 篇原创文章 · 获赞 23 · 访问量 6614

私信关注