java基础回顾--3、集合

一、集合概览

二、基础信息

双向链表：每个结点还存放着指向前驱结点的引用

散列表：在Java中，散列表(hash table)用链表数组实现。每个列表被称为桶，要想查找表中对象的位置，就要先计算它的散列码（hash code），然后与桶的总数取余，所得到的结果就是保存这个元素的桶的索引。

1、ArrayList

     非线程安全，通过数组实现

     查询数据快（原因：直接用数组下标获得）

     插入及删除数据慢（原因：插入或删除数据时，插入或删除点后的数组会整体移动）

2、LinkedList

      非线程安全，通过双向链表实现

      查询数据慢（原因：二分法逐渐查找）

      插入及删除数据快（原因：插入或删除数据时，通过节点插入）

3、Vector

     线程安全，通过数组实现，与ArrayList类似

4、CopyOnWriteArrayList

      线程安全，没太用过，不做描述

 

5、HashSet

     基于散列表实现，查询速度快

6、TreeSet

      基于红黑树实现，自动对元素排序（自然排序与定制排序）

7、LinkedHashSet

      基于散列表实现，保持元素插入的顺序

 

8、HashMap

      基于散列表实现，查询速度快

9、TreeMap

      基于红黑树的实现 自动对键值对排序（自然排序与定制排序）

10、LinkedHashMap

        基于散列表及链表实现，保持元素插入的顺序

11、ConcurrentHashMap

       基于散列表实现，线程安全

 

三、遍历

迭代器遍历 List / Set：

        Iterator<String> iterator = collection.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

迭代器遍历 Map:

        for (Map.Entry<String, String> entry : map.entrySet()) {
            System.out.println(entry.getKey() + " = " + entry.getValue());
        }

四、排序

1、List 中对象排序--方案1（对象实现 Comparable 接口，list 中有 null 时会异常）

public class DogPet extends Pet implements Comparable<DogPet>{

    public DogPet(String kind, Double price) {
        super(kind, price);
    }

    @Override
    public int compareTo(DogPet o) {
        if (this == o) {
            return 0;
        }
        if (Objects.isNull(this.getPrice())) {
            return -1;
        }
        if (Objects.isNull(o.getPrice())) {
            return 1;
        }
        if (Objects.equals(this.getPrice(), o.getPrice())) {
            return 0;
        }
        return this.getPrice() > o.getPrice() ? 1 : -1;
    }
}

    /**
     * 对象排序--list中的对象 实现Comparable接口
     *
     * <p>list不能有null,否则排序报错
     */
    @Test
    public void sort1() {
        List<DogPet> dogPetList = new ArrayList<>();
        dogPetList.add(new DogPet("金毛", 180.0));
        dogPetList.add(new DogPet("松狮", 2.0));
        dogPetList.add(new DogPet("柯基", null));
        dogPetList.add(new DogPet("藏獒", 10000.0));
        System.out.println("排序前:" + dogPetList);

        Collections.sort(dogPetList);

        System.out.println("排序后:" + dogPetList);
    }

2、List 中对象排序--方案2（ lambda 表示，实时 new 匿名内部类 Comparator）

    /**
     * 对象排序--list.sort--可用
     *
     * <p>list中可以有null
     */
    @Test
    public void sort2() {
        System.out.println("排序前:" + catPetList);

        catPetList.sort((o1, o2) -> {
            if (o1 == o2) {
                return 0;
            }
            if (Objects.isNull(o1) || Objects.isNull(o1.getPrice())) {
                return -1;
            }
            if (Objects.isNull(o2) || Objects.isNull(o2.getPrice())) {
                return 1;
            }
            if (Objects.equals(o1.getPrice(), o2.getPrice())) {
                return 0;
            }
            return o1.getPrice() > o2.getPrice() ? 1 : -1;
        });

        System.out.println("排序后:" + catPetList);
    }

3、List 中对象排序--方案3 (对象中增加静态内部类实现 Comparator 接口 )

public class CatPet extends Pet {


    public CatPet(String kind, Double price) {
        super(kind, price);
    }

    /**
     * 价格比较规则
     *
     * @author tony
     */
    static class PriceComparator implements Comparator<CatPet> {

        @Override
        public int compare(CatPet o1, CatPet o2) {
            if (o1 == o2) {
                return 0;
            }
            if (Objects.isNull(o1) || Objects.isNull(o1.getPrice())) {
                return -1;
            }
            if (Objects.isNull(o2) || Objects.isNull(o2.getPrice())) {
                return 1;
            }
            if (Objects.equals(o1.getPrice(), o2.getPrice())) {
                return 0;
            }
            return o1.getPrice() > o2.getPrice() ? 1 : -1;
        }
    }
}

    /**
     * 对象排序--list.sort--可用
     *
     * <p>提取出专用的comparator
     */
    @Test
    public void sort3() {
        System.out.println("排序前:" + catPetList);

        catPetList.sort(new CatPet.PriceComparator());

        System.out.println("排序后:" + catPetList);
    }

五 、删除对象

1、List 删除匹配的对象--方案1（ jdk1.8才可用）：

list.removeIf("龙母"::equals);

2、List 删除匹配的对象--方案2

        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            if ("龙母".equals(iterator.next())) {
                iterator.remove();
            }
        }

六、疑问点

1、ArrayList LinkedList能否互相转换？

      能 必须用构造方法

      LinkedList<People> linkedList = new LinkedList<>();

      ArrayList<People> peopleList = new ArrayList<>(linkedList);

       ArrayList 转 LinkedList 较慢

       LinkedList 转 ArrayList 挺快

2、既需要获取 又需要频繁删除呢？

如果是一个集合，需要遍历整个集合删除符合条件的对象，建议直接使用 iterator 或 removeIf方法

直接用 ArrayList 就可以了