必威体育Betway必威体育官网
当前位置：首页 > IT技术

Java集合中List,Set以及Map等集合体系详解(史上最全)

时间:2019-07-29 13:43:16来源:IT技术作者:seo实验室小编阅读:76次「手机版」
　

java list

转载请注明出处:java集合中List,Set以及Map等集合体系详解(史上最全)

概述:

  • List , Set, Map都是接口，前两个继承至collection接口，Map为独立接口
  • Set下有HashSet，LinkedHashSet，treeset
  • List下有ArrayList，vector，LinkedList
  • Map下有Hashtable，LinkedHashMap，HashMap，TreeMap
  • collection接口下还有个queue接口，有priorityQueue类

这里写图片描述

注意:

  • Queue接口与List、Set同一级别，都是继承了collection接口。

    看图你会发现,LinkedList既可以实现Queue接口,也可以实现List接口.只不过呢, LinkedList实现了Queue接口。Queue接口窄化了对LinkedList的方法的访问权限（即在方法中的参数类型如果是Queue时，就完全只能访问Queue接口所定义的方法 了，而不能直接访问 LinkedList的非Queue的方法），以使得只有恰当的方法才可以使用。

  • SortedSet是个接口，它里面的（只有TreeSet这一个实现可用）中的元素一定是有序的。

总结:

connection接口(注意首字母小写):

— List 有序,可重复

  • ArrayList

    优点: 底层数据结构是数组，查询快，增删慢。

    缺点: 线程不安全，效率高

  • Vector

    优点: 底层数据结构是数组，查询快，增删慢。

    缺点: 线程安全，效率低

  • LinkedList

    优点: 底层数据结构是链表，查询慢，增删快。

    缺点: 线程不安全，效率高

—Set 无序,唯一

  • HashSet

    底层数据结构是哈希表。(无序,唯一)

    如何来保证元素唯一性?

    1.依赖两个方法：hashCode()和equals()

  • LinkedHashSet

    底层数据结构是链表和哈希表。(FIFO插入有序,唯一)

    1.由链表保证元素有序

    2.由哈希表保证元素唯一

  • TreeSet

    底层数据结构是红黑树。(唯一，有序)

    1. 如何保证元素排序的呢?

    自然排序

    比较器排序

    2.如何保证元素唯一性的呢?

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

针对collection集合我们到底使用谁呢?(掌握)

唯一吗?

是：Set

排序吗?

是：TreeSet或LinkedHashSet

否：HashSet

如果你知道是Set，但是不知道是哪个Set，就用HashSet。

否：List

要安全吗?

是：Vector

否：ArrayList或者LinkedList

查询多：ArrayList

增删多：LinkedList

如果你知道是List，但是不知道是哪个List，就用ArrayList。

如果你知道是collection集合，但是不知道使用谁，就用ArrayList。

如果你知道用集合，就用ArrayList。

说完了collection,来简单说一下Map.

Map接口:

上图:

这里写图片描述

Map接口有三个比较重要的实现类，分别是HashMap、TreeMap和HashTable。

  • TreeMap是有序的，HashMap和HashTable是无序的。
  • Hashtable的方法是同步的，HashMap的方法不是同步的。这是两者最主要的区别。

这就意味着:

  • Hashtable是线程安全的，HashMap不是线程安全的。
  • HashMap效率较高，Hashtable效率较低。

    如果对同步性或与遗留代码的兼容性没有任何要求，建议使用HashMap。 查看Hashtable的源代码就可以发现，除构造函数外，Hashtable的所有 public 方法声明中都有 synchronized关键字，而HashMap的源码中则没有。

  • Hashtable不允许null值，HashMap允许null值（key和value都允许）
  • 父类不同：Hashtable的父类是Dictionary，HashMap的父类是AbstractMap

重点问题重点分析:

(一).TreeSet, LinkedHashSet and HashSet 的区别

1. 介绍

  • TreeSet, LinkedHashSet and HashSet 在java中都是实现Set的数据结构
  • TreeSet的主要功能用于排序
  • LinkedHashSet的主要功能用于保证FIFO即有序的集合(先进先出)
  • HashSet只是通用的存储数据的集合

2. 相同点

  • Duplicates elements: 因为三者都实现Set interface，所以三者都不包含duplicate elements
  • Thread safety: 三者都不是线程安全的，如果要使用线程安全可以collections.synchronizedSet()

3. 不同点

  • Performance and Speed: HashSet插入数据最快，其次LinkHashSet，最慢的是TreeSet因为内部实现排序
  • ordering: HashSet不保证有序，LinkHashSet保证FIFO即按插入顺序排序，TreeSet安装内部实现排序，也可以自定义排序规则
  • null:HashSet和LinkHashSet允许存在null数据，但是TreeSet中插入null数据时会报NullPointerException

4. 代码比较

  public static void main(String args[]) {
        HashSet<String> hashSet = new HashSet<>();
        LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
        TreeSet<String> treeSet = new TreeSet<>();

        for (String data : Arrays.asList("B", "E", "D", "C", "A")) {
            hashSet.add(data);
            linkedHashSet.add(data);
            treeSet.add(data);
        }

        //不保证有序
        System.out.println("Ordering in HashSet :" + hashSet);

        //FIFO保证安装插入顺序排序
        System.out.println("Order of element in LinkedHashSet :" + linkedHashSet);

        //内部实现排序
        System.out.println("Order of objects in TreeSet :" + treeSet);


    }

运行结果:

Ordering in HashSet :[A, B, C, D, E] (无顺序)

Order of element in LinkedHashSet :[B, E, D, C, A] (FIFO插入有序)

Order of objects in TreeSet :[A, B, C, D, E] (排序)

(二).TreeSet的两种排序方式比较

1.排序的引入(以基本数据类型的排序为例)

由于TreeSet可以实现对元素按照某种规则进行排序，例如下面的例子

public class MyClass {

    public static void main(String[] args) {
        // 创建集合对象
        // 自然顺序进行排序
        TreeSet<integer> ts = new TreeSet<Integer>();

        // 创建元素并添加
        // 20,18,23,22,17,24,19,18,24
        ts.add(20);
        ts.add(18);
        ts.add(23);
        ts.add(22);
        ts.add(17);
        ts.add(24);
        ts.add(19);
        ts.add(18);
        ts.add(24);

        // 遍历
        for (Integer i : ts) {
            System.out.println(i);
        }
    }
}

运行结果:

17

18

19

20

22

23

24

2.如果是引用数据类型呢,比如自定义对象,又该如何排序呢?

测试类:

public class MyClass {
    public static void main(String[] args) {
        TreeSet<Student> ts=new TreeSet<Student>();
        //创建元素对象
        Student s1=new Student("zhangsan",20);
        Student s2=new Student("lis",22);
        Student s3=new Student("wangwu",24);
        Student s4=new Student("chenliu",26);
        Student s5=new Student("zhangsan",22);
        Student s6=new Student("qianqi",24);

        //将元素对象添加到集合对象中
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);

        //遍历
        for(Student s:ts){
            System.out.println(s.getName()+"-----------"+s.getAge());
        }
    }
}

Student.java:

public class Student {
    private String name;
    private int age;

    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

结果报错:

这里写图片描述

原因分析：

由于不知道该安照那一中排序方式排序，所以会报错。

解决方法：

1.自然排序

2.比较器排序

(1).自然排序

自然排序要进行一下操作：

1.Student类中实现 Comparable接口

2.重写Comparable接口中的Compareto方法

compareTo(T o)  比较此对象与指定对象的顺序。
public class Student implements Comparable<Student>{
    private String name;
    private int age;

    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public int compareTo(Student s) {
        //return -1; //-1表示放在红黑树的左边,即逆序输出
        //return 1;  //1表示放在红黑树的右边，即顺序输出
        //return o;  //表示元素相同，仅存放第一个元素
        //主要条件 姓名的长度,如果姓名长度小的就放在左子树，否则放在右子树
        int num=this.name.length()-s.name.length();
        //姓名的长度相同，不代表内容相同,如果按字典顺序此 String 对象位于参数字符串之前，则比较结果为一个负整数。
        //如果按字典顺序此 String 对象位于参数字符串之后，则比较结果为一个正整数。
        //如果这两个字符串相等，则结果为 0
        int num1=num==0?this.name.compareTo(s.name):num;
        //姓名的长度和内容相同，不代表年龄相同，所以还要判断年龄
        int num2=num1==0?this.age-s.age:num1;
        return num2;
    }
}

运行结果:

lis-----------22

qianqi-----------24

wangwu-----------24

chenliu-----------26

zhangsan-----------20

zhangsan-----------22

(2).比较器排序

比较器排序步骤：

1.单独创建一个比较类，这里以MyComparator为例，并且要让其继承Comparator接口

2.重写Comparator接口中的Compare方法

compare(T o1,T o2)      比较用来排序的两个参数。

3.在主类中使用下面的 构造方法

TreeSet(Comparator<? superE> comparator)
          构造一个新的空 TreeSet，它根据指定比较器进行排序。

测试类:

public class MyClass {

    public static void main(String[] args) {
        //创建集合对象
        //TreeSet(Comparator<? super E> comparator) 构造一个新的空 TreeSet，它根据指定比较器进行排序。
        TreeSet<Student> ts=new TreeSet<Student>(new MyComparator());

        //创建元素对象
        Student s1=new Student("zhangsan",20);
        Student s2=new Student("lis",22);
        Student s3=new Student("wangwu",24);
        Student s4=new Student("chenliu",26);
        Student s5=new Student("zhangsan",22);
        Student s6=new Student("qianqi",24);

        //将元素对象添加到集合对象中
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);

        //遍历
        for(Student s:ts){
            System.out.println(s.getName()+"-----------"+s.getAge());
        }
    }
}

Student.java:

public class Student {
    private String name;
    private int age;

    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

}

MyComparator类：

public class MyComparator implements Comparator<Student> {

    @Override
    public int compare(Student s1,Student s2) {
        // 姓名长度
        int num = s1.getName().length() - s2.getName().length();
        // 姓名内容
        int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
        // 年龄
        int num3 = num2 == 0 ? s1.getAge() - s2.getAge() : num2;
        return num3;
    }

}

运行结果:

lis-----------22

qianqi-----------24

wangwu-----------24

chenliu-----------26

zhangsan-----------20

zhangsan-----------22

(三). 性能测试

对象类:

class Dog implements Comparable<Dog> {
    int size;
    public Dog(int s) {
        size = s;
    }
    public String toString() {
        return size + "";
    }
    @Override
    public int compareTo(Dog o) {
       //数值大小比较
        return size - o.size;
    }
}

主类:

public class MyClass {

    public static void main(String[] args) {

        Random r = new Random();
        HashSet<Dog> hashSet = new HashSet<Dog>();
        TreeSet<Dog> treeSet = new TreeSet<Dog>();
        LinkedHashSet<Dog> linkedSet = new LinkedHashSet<Dog>();

        // start time
        long startTime = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
            int x = r.nextint(1000 - 10) + 10;
            hashSet.add(new Dog(x));
        }

        // end time
        long endTime = System.nanoTime();
        long duration = endTime - startTime;
        System.out.println("HashSet: " + duration);

        // start time
        startTime = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
            int x = r.nextInt(1000 - 10) + 10;
            treeSet.add(new Dog(x));
        }
        // end time
        endTime = System.nanoTime();
        duration = endTime - startTime;
        System.out.println("TreeSet: " + duration);

        // start time
        startTime = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
            int x = r.nextInt(1000 - 10) + 10;
            linkedSet.add(new Dog(x));
        }

        // end time
        endTime = System.nanoTime();
        duration = endTime - startTime;
        System.out.println("LinkedHashSet: " + duration);
    }

}

运行结果:

HashSet: 1544313

TreeSet: 2066049

LinkedHashSet: 629826

虽然测试不够准确,但能反映得出，TreeSet要慢得多,因为它是有序的。

嘿嘿

好了,至此完结.小伙伴有问题的话,请留言

参考文章:

HashSet、TreeSet和LinkedHashSet的使用区别

collection集合总结

HashMap、TreeMap和HashTable的区别

相关阅读

Java 扑克牌 - 洗牌

Java 扑克牌 - 洗牌 背景 估计是想打扑克了吧简述 生成一副扑克牌，没有大小王，然后洗牌，将洗牌后的结果输出思路 扑克牌基本情况：一副

八人过河问题详解（Java语言求解）

八人过河问题详解（Java语言求解） 在秋招面试搜狗大数据开发岗位的时候，面试官给出了一个八个人过河的问题，后来自己查了之后发现这个

java爬虫实现

爬虫入门 手写一个Java爬虫本文内容 涞源于  罗刚 老师的 书籍 << 自己动手写网络爬虫一书 >> ;本文将介绍 1: 网络爬虫的是

java注释使用及error occurred during initialization

JAVA注释 java语言注释有三种——单行注释，多行注释以及文档注释。单行注释：只需要将双斜线//放在这一行的最前面即可多行注释：以/*

spring execution 表达式详解

Aspectj切入点语法定义 在使用spring框架配置AOP的时候，不管是通过XML配置文件还是注解的方式都需要定义pointcut"切入点" 例如

赞()
分享到:

猜你喜欢

栏目导航

推荐阅读

热门阅读

seo实验室提供seo优化服务，有网站优化、网站建设、运营推广等需求请联系我们!
Copyright © 2001-2017 .seo实验室 版权所有 网站地图