java集合详解_result = prime * result+ (int) (temp 入 (temp >>>32-CSDN博客

本文链接：https://blog.csdn.net/weixin_42128977/article/details/105430919

集合的理解

理解：一种容器，用于保存一组元素。

集合和数组的对比

è¿éåå¾çæè¿°

3.java集合的分类：

1.Collection 接口的接口对象的集合（单列集合）
├——-List 接口：元素按进入先后有序保存，可重复
│—————-├ LinkedList 接口实现类，链表，插入删除快，随机访问慢，没有同步，线程不安全，效率高
│—————-├ ArrayList 接口实现类，数组，随机访问快，插入删除慢，没有同步，线程不安全，效率高
│—————-└ Vector 接口实现类数组，同步，线程安全，随机访问快，插入删除慢，效率低
│ ———————-└ Stack 是Vector类的实现类
└——-Set 接口：仅接收一次，不可重复，并做内部排序
├—————-└HashSet 使用hash表（数组，无序,唯一）存储元素，元素唯一性 1.依赖两个方法：hashCode()和equals()
│————————└ LinkedHashSet （FIFO插入有序,唯一）由链表保证元素有序由哈希表保证元素唯一
└ —————-TreeSet 底层实现为二叉树，元素排序：自然排序，比较器排序；元素唯一性：根据比较的返回值是否是0来决定

2.Map 接口键值对的集合（双列集合）
├———Hashtable 接口实现类，同步，线程安全，无序，效率较低，不允许null值，父类是Dictionary
├———HashMap 接口实现类，线程不安全，无序，效率较高，允许null值（key和value都允许），父类是AbstractMap
│—————–├ LinkedHashMap 双向链表和哈希表实现
│—————–└ WeakHashMap
├ ——–TreeMap 红黑树对所有的key进行排序
└———IdentifyHashMap

4.Collection接口继承树

è¿éåå¾çæè¿°

注意:

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

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

Map接口

è¿éåå¾çæè¿°

Collection集合的方法：

public class CDemo {
    public static void main(String[] args) {
        //产生对象c1
        Collection c1=new ArrayList();
         //add 添加元素
        c1.add(1);
        c1.add(2);
        //是否包含2这个元素
        System.out.println(c1.contains(2));
        Collection c2=new ArrayList();
        c2.add("a");
        c2.add("b");
        c2.add(2);
        //将集合c1的元素加入c2中
        c2.addAll(c1);
        System.out.println(c2);
        System.out.println("c2的元素个数："+c2.size());
        //删除和c1中的元素相等的元素
        c2.removeAll(c1);
        System.out.println(c2);
        //遍历集合
        //1.迭代器
        Iterator iterator = c2.iterator();
        while(iterator.hasNext()){
            if(iterator.next()=="a"){
                //删除指向当前的元素
                iterator.remove();
            }
            System.out.println(iterator.next());
        }
        System.out.println("==================================");
        //2 for
        for(Object obj:c2){
            System.out.println(obj);
        }
    }
}

迭代器：

特点：1.使用迭代器过程中，不适合做增删操作，容易报java.util.ConcurrentModificationException。

2.使用迭代器过程中，可以修改属性，但是修改地址，没有效果。

3，如果非要在迭代器中做删除操作，可以使用迭代器本身的remove方法

List特有功能

è¿éåå¾çæè¿°

public class listDemo {
    public static void main(String[] args) {
        List list=new ArrayList();
        list.add(1);
        list.add(2);
        list.add(4);
        list.add(4);
        //在索引2的位置，插入3
        list.add(2,3);
        System.out.println(list);
        System.out.println("-----------------------------");
        //索引位置删
        list.remove(4);
        //删除元素2  如果删除元素是int类型，默认按索引删除，所以要删除指定元素，先装箱
        list.remove(new Integer(2));
        System.out.println(list);
        System.out.println("-----------------------------");
        //修改
        list.set(1,100);
        System.out.println(list);
        System.out.println("-----------------------------");
        //截取集合
        List list1 = list.subList(1, 2);
        System.out.println(list1);


        for(int i=0;i<list.size();i++){
            System.out.print(list.get(i)+"\t");
        }
        System.out.println();
    }
}

ArrayList和vector对比

ArrayList有三个构造方法：

public ArrayList(int initialCapacity)//构造一个具有指定初始容量的空列表。    
public ArrayList()      //默认构造一个初始容量为10的空列表。    
public ArrayList(Collection<? extends E> c)//构造一个包含指定 collection 的元素的列表

jdk8：初始容量是0，第一个添加时，容量为10，每次1.5倍扩容。懒汉式

jdk7：初始容量是10，每次1.5倍扩容。饿汉式

Vector有四个构造方法：每次2倍扩容

public Vector()//使用指定的初始容量和等于0的容量增量构造一个空向量。    
public Vector(int initialCapacity)//构造一个空向量，使其内部数据数组的大小，其标准容量增量为零。    
public Vector(Collection<? extends E> c)//构造一个包含指定 collection 中的元素的向量    
public Vector(int initialCapacity,int capacityIncrement)//使用指定的初始容量和容量增量构造一个空的向量

ArrayList和Vector都是用数组实现的，主要有这么三个区别：
（1）.Vector是多线程安全的，线程安全就是说多线程访问同一代码，不会产生不确定的结果。而ArrayList不是，这个可以从源码中看出，Vector类中的方法很多有synchronized进行修饰，这样就导致了Vector在效率上无法与ArrayList相比；
（2）两个都是采用的线性连续空间存储元素，但是当空间不足的时候，两个类的增加方式是不同。
（3）Vector可以设置增长因子，而ArrayList不可以。
（4）Vector是一种老的动态数组，是线程同步的，效率很低，一般不赞成使用。
适用场景分析：
1.Vector是线程同步的，所以它也是线程安全的，而ArrayList是线程异步的，是不安全的。如果不考虑到线程的安全因素，一般用ArrayList效率比较高。
2.如果集合中的元素的数目大于目前集合数组的长度时，在集合中使用数据量比较大的数据，用Vector有一定的优势。

LinkedList：

优点：LinkedList基于链表的数据结构,地址是任意的，所以在开辟内存空间的时候不需要等一个连续的地址，对于新增和删除操作add和remove，LinedList比较占优势。LinkedList 适用于要头尾操作或插入指定位置的场景
缺点：因为LinkedList要移动指针,所以查询操作性能比较低。

Set接口特点

1.不允许重复，最多一个null。2无序，没有索引。

HashSet

底层：维护了一个HashMap结构，基于哈希表

如何实现去重？

底层通过调用hashcode()和equals()方法实现去重。先调用hashcode(),如果不相等，直接添加；如果相等，则比较equals()，如果不相等，则添加；如果相等，不添加。

　默认初始容量为16，加载因子为0.75：即当元素个数超过容量长度的0.75倍时，进行扩容，扩容增量：原容量的 1 倍

　如 HashSet的容量为16，一次扩容后是容量为32

代码示例：

public class Book {
    private String name;
    private double price;
    private String author;

    /**
     * 1.和属性有关
     * 2.属性一样，哈希值一样
     * @return
     */
    @Override
    public int hashCode() {
       final int prime=31;
       int result=1;
       result=prime*result+((author==null)?0:author.hashCode());
       result=prime*result+((name==null)?0:name.hashCode());
       long temp;
       temp=Double.doubleToLongBits(price);
       result=prime*result+(int)(temp^(temp >>> 32));
       return result;
    }

    @Override
    public boolean equals(Object obj) {
        if(this==obj)
            return true;
        //提高代码健壮性,不是同一个类型就直接返回false,省得向下转型了
        if(this.getClass() != obj.getClass()) {
            return false;
        }
        Book b= (Book) obj;
        return this.name.equals(b.name)&&this.author.equals(b.author)&&this.price==b.price;
    }

    public Book(String name, double price, String author) {
        this.name = name;
        this.price = price;
        this.author = author;
    }
}
-----------------------------------------------------------------------
public class SetDemo {
    public static void main(String[] args) {
        HashSet set=new HashSet();
        set.add(new Book("java",100,"cyd"));
        set.add(new Book("c++",80,"ccc"));
        set.add(new Book("java",100,"cyd"));
        System.out.println(set);
    }
}
-

TreeSet

特点：

1.不允许重复，不允许null。

2.可以实现对里面的元素排序。自然排序（无参构造）和比较器排序（有参构造）

底层维护了一个TreeMap，而TreeMap底层是红黑树结构，可以对元素进行排序。

两种排序

代码：

//比较器
public class MyComparator implements Comparator<Book> {

    /**
     * 比较价格和名字
     * @param s1
     * @param s2
     * @return
     */
    @Override
    public int compare(Book s1,Book s2) {
        // 姓名长度
        int num = s1.getName().length() - s2.getName().length();
        // 姓名内容
        int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
        // 年龄
        int num3 = num2 == 0 ? (int)(s1.getPrice() - s2.getPrice()) : num2;
        return num3;
    }

}

--------------------------------------------------------------------------------------
public class SetDemo {
    public static void main(String[] args) {
        /**以基本数据类型的排序为例
         *    // 自然顺序进行排序
         *         TreeSet<Integer> ts = new TreeSet<Integer>();
         *         ts.add(20);
         *         ts.add(18);
         *         ts.add(23);
         *         ts.add(22);
         *         ts.add(17);
         *         ts.add(24);
         *         ts.add(19);
         *         ts.add(24);
         *         // 遍历
         *         for (Integer i : ts) {
         *             System.out.println(i);
         *         }
         */

         //引用类型
        //自然排序  1实现 Comparable接口  2.重写Comparable接口中的Compareto方法
        TreeSet set=new TreeSet();

        set.add(new Book("java",100.7,"cyd"));
        set.add(new Book("c++",80,"ccc"));
        set.add(new Book("java",100.9,"cyd"));
        System.out.println(set);

        //比较器排序步骤：
        //1.单独创建一个比较类，这里以MyComparator为例，并且要让其继承Comparator接口
        //2.重写Comparator接口中的Compare方法
        TreeSet<Book> ts=new TreeSet<Book>(new MyComparator());
        ts.add(new Book("java",100.7,"cyd"));
        ts.add(new Book("c++",80,"ccc"));
        ts.add(new Book("java",100.9,"cyd"));
        System.out.println(ts);
    }
}
-------------------------------------------------------------------------
public class Book implements Comparable<Book>{
    private String name;
    private double price;
    private String author;

    /**
     * 1.和属性有关
     * 2.属性一样，哈希值一样
     * @return
     */
    @Override
    public int hashCode() {
       final int prime=31;
       int result=1;
       result=prime*result+((author==null)?0:author.hashCode());
       result=prime*result+((name==null)?0:name.hashCode());
       long temp;
       temp=Double.doubleToLongBits(price);
       result=prime*result+(int)(temp^(temp >>> 32));
       return result;
    }

    @Override
    public boolean equals(Object obj) {
        if(this==obj)
            return true;
        //提高代码健壮性,不是同一个类型就直接返回false,省得向下转型了
        if(this.getClass() != obj.getClass()) {
            return false;
        }
        Book b= (Book) obj;
        return this.name.equals(b.name)&&this.author.equals(b.author)&&this.price==b.price;
    }

    public Book(String name, double price, String author) {
        this.name = name;
        this.price = price;
        this.author = author;
    }

    public String getName() {
        return name;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

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

    }
}

LinkedHashSet

LinkedHashSet是Set集合的一个实现，具有set集合不重复的特点，同时具有可预测的迭代顺序，也就是我们插入的顺序。

LinkedHashSet可以得到super一个父类初始化为一个容器为16大小，加载因子为0.75的Map容器。

对于LinkedHashSet而言，它继承与HashSet、又基于LinkedHashMap来实现的。

LinkedHashSet底层使用LinkedHashMap来保存所有元素，它继承与HashSet，其所有的方法操作上又与HashSet相同，因此LinkedHashSet 的实现上非常简单，只提供了四个构造方法，并通过传递一个标识参数，调用父类的构造器，底层构造一个LinkedHashMap来实现，在相关操作上与父类HashSet的操作相同，直接调用父类HashSet的方法即可。

TreeSet, LinkedHashSet and HashSet 的区别

1.介绍

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