20210322Java集合

最新推荐文章于 2024-09-03 20:17:53 发布
最新推荐文章于 2024-09-03 20:17:53 发布
阅读量123 收藏
点赞数
分类专栏： Java基本语法 文章标签： java 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43320037/article/details/115093485
版权

Java集合

编辑时间：2021/03/22

读完本节：大概花费50分钟，共5261词

文章目录

1.Java集合框架概述

  1. 集合、数组都是对多个数据进行存储和操作的结构，简称Java容器。此时的存储主要指内存层面的存储，不涉及持久化的存储。

  2. 数组在存储多个数据方面的特点

    1. 数组初始化以后，长度就确定了
    2. 数组声明的类型，就决定了进行元素初始化时的类型

  3. 数组在存储数据方面的弊端

    1. 数组在初始化之后，长度就不可变了，不便于扩展
    2. 数组中提供的属性和方法少，不便进行添加、删除插入等操作，且效率不高。同时无法直接获取存储元素的个数
    3. 数组存储的数据是有序的、可重复的。对于无需、不可重复的需求不能满足

  4. Java集合类可以用于村拿出数量不等的多个对象，还可以用于保存具有映射关系的关联数组

  5. 集合框架

    image-20210322100114249

    image-20210322100205597

    Java集合可以分为Collection和Map两种体系

    1. Collection接口：单列数据，定义了存取一组对象的方法的集合
      1. List：元素有序，可重复的集合
      2. Set：元素无序，不可重复的集合
    2. Map接口：双列数据，保存具有映射关系“key-value对”的集合
2.Colllection接口中方法的使用

  1. Collection中常用的方法：

    1. add(Object obj)：向集合中添加元素
    2. addAll(Collection coll)：向集合中添加传入集合的所有元素
    3. int size()：获取有效元素的个数
    4. boolean isEmpty()：判断是否为空集合
    5. void clear()：清空集合中所有的元素
    6. boolean contain(Object obj)：是否包含某个元素；内部通过元素的equals方法来判断是否是同一个对象
    7. boolean containAll(Collection c)：两个集合挨个比较，是否包含传入集合的元素；内部通过元素的equals方法来比较
    8. boolean remove(Object obj)：删除指定元素；通过元素的equals方法判断是否存在待删元素，只会删除第一个找到的元素
    9. boolean removeAll(Collection coll)：取当前集合的差集；同样是通过equals方法判断是否存在待删元素
    10. boolean retainAll(Collection coll)：求两个集合的交集，把交集的结果存在当前集合中，不会影响coll中的元素
    11. boolean equals(Object obj)：判断集合是否相同
    12. Object[] toArray()：将集合转换为对象数组
    13. hashCode()：获取集合对象的哈希值
    14. iterator()：返回迭代器对象，用于遍历集合
  2. import org.junit.Test;

import java.util.*;

/**
 * @Author: xuehai.XUE
 * @MailBox: xuehai.xue@qq.com
 * @Date: 2021/3/22 10:34
 * @Description:
 */
public class CollectionMethodTest {
    @Test
    public void test3(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add("AA");
        coll.add(new String("biggy"));
        coll.add(false);

        //hashCode()：返回当前对象的hash值
        System.out.println(coll.hashCode());

        //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.size());//1
        List arr2 = Arrays.asList(new Integer[]{123,456});
        System.out.println(arr2.size());//2
    }

    @Test
    public void Test2(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add("AA");
        coll.add(new String("biggy"));
        coll.add(false);
        coll.add(new Person("biggy", 22));

        //remove(Object obj)：从当前集合中移除obj元素
        coll.remove(1234);
        System.out.println(coll);

        //如果不在obj相应的类中重写equals方法则无法移除
        coll.remove(new Person("biggy", 22));
        System.out.println(coll);

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

        //equals(Object obj)：判断两个集合是否相同，想要返回true需要当前集合和形参集合的元素都相同
        Collection coll2 = new ArrayList();
        coll2.add("AA");
        coll2.add(new String("biggy"));
        coll2.add(false);
        coll2.add(new Person("biggy", 22));

        System.out.println(coll1.equals(coll2));
    }

    @Test
    public void Test1(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add("AA");
        coll.add(new String("biggy"));
        coll.add(false);
        coll.add(new Person("biggy", 22));

        //contain(Object obj)：判断当前集合中是否包含obj
        boolean contains = coll.contains(123);
        System.out.println(contains);//true
        System.out.println(coll.contains(new Person("biggy",22)));//false
        //false的原因是没有在Person类中重写equals方法，
        //直接使用了根父类Object中的equals方法，实际上就是使用了“==”对地址值进行判断
        //可以通过重写Object类中的equals方法，实现false到true的转变
        //因此，向Collection接口的实现类的对象中添加数据obj时，要求obj所在的类重写equals()方法

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

    @Test
    public void test1(){
        //使用ArrayList实现类的方法展示Collection中的抽象方法
        Collection coll = new ArrayList();

        //add(object e)：将元素e添加到集合coll中
        coll.add("AA");
        coll.add("BB");
        //自动装箱
        coll.add(123);
        coll.add(new Date());
        //调用默认的toString()方法将集合输出
        System.out.println(coll);

        //size()：获取集合中有效元素的个数
        System.out.println(coll.size());

        //addAll(Collection coll)：将给形参给定的集合元素添加至当前集合
        Collection coll1 = new ArrayList();
        coll1.add(456);
        coll1.add("CC");
        coll.addAll(coll1);
        System.out.println(coll);
        System.out.println(coll.size());

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

        //clear()：清空当前集合中的元素
        coll.clear();
        System.out.println(coll);
        System.out.println(coll.isEmpty());
    }
}
3.Iterator接口迭代器

  1. 使用Iterator接口遍历集合元素

    1. Iterator对象称为迭代器（设计模式的一种），主要用于遍历Collection集合中的元素。

    2. GOF给迭代器模式的定义为：提供一种方法访问一个容器(container)对象中各个元素，而又不暴露该对象的内部细节。迭代器模式就是为容器而生。

    3. Collection接口继承了java.lang.Iterator接口，该接口有一个Iterator()方法，那么所有实现了Collection接口的集合类都有一个Iterator()方法，用以返回一个实现了Iterator接口的对象

    4. Iterator仅用于遍历集合，Iterator本身并不提供承装对象的能力。如果需要创建Iterator对象，则必须有一个被迭代的集合

    5. 集合对象每次调用iterator()方法都会得到一个全新的迭代器对象，默认游标都会在集合的第一个元素之前。

      import org.junit.Test;

import java.util.*;

/**
 * @Author: xuehai.XUE
 * @MailBox: xuehai.xue@qq.com
 * @Date: 2021/3/22 10:34
 * @Description:
 */
public class CollectionMethodTest {

    @Test
    /** 集合元素的遍历操作，使用迭代器Iterator接口 */
    public void iteratorTest(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add("AA");
        coll.add(new String("biggy"));
        coll.add(false);

        Iterator iterator = coll.iterator();

//        //方式1：
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        //报异常：NoSuchElementException
//        System.out.println(iterator.next());

//        //方式2：不推荐
//        for (int i = 0; i < coll.size(); i++) {
//            System.out.println(iterator.next());
//        }

        //方式3：推荐方式
        //hasNext()：判断是否还有下一个元素
        while (iterator.hasNext()){
            //next()：1.指针下移；2.将下移以后集合位置上的元素返回
            System.out.println(iterator.next());
        }

        //错误方式一
//        Iterator iterator1 = coll.iterator();
//        while((iterator1.next()) != null){
//            System.out.println(iterator1.next());
//        }
        //错误方式二
//        while(coll.iterator().hasNext()){
//            System.out.println(coll.iterator().next());
//        }

    }
}

  2. Iterator接口的remove()方法

    1. 在迭代器内部定义了remove()方法，可以在遍历的时候，删除集合中的元素。此方法不同于集合直接调用remove()

    2. 如果还未调用next()或在上一次调用next()方法之后已经调用了remove()方法，再次调用remove()都会报illegalStateException

      import org.junit.Test;

import java.util.*;

/**
 * @Author: xuehai.XUE
 * @MailBox: xuehai.xue@qq.com
 * @Date: 2021/3/22 10:34
 * @Description:
 */
public class CollectionMethodTest {

    @Test
    public void iteratorTest1(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add("AA");
        coll.add(new String("biggy"));
        coll.add(false);

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

        //遍历集合
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}
4.使用foreach（增强for循环遍历集合元素）

  1. JDK1.5提供了foreach循环迭代访问Collection和数组

  2. 遍历操作不需要获取Collection或数组的长度，无需使用索引访问元素

  3. 遍历集合的底层调用Iterator完成操作

  4. foreach还可以用来遍历数组

    for(要遍历的元素类型 遍历后自定义元素名称 : 要遍历的结构名称){

    ​ //输出语句

    }

  5. 在循环过程中，对数组元素进行赋值，foreach中的循环变量相当于一个临时变量，系统会把数组元素依次赋给这个临时变量，而这个临时变量并不是数组元素，它只是保存了数组元素的值。因此如果希望改变数组元素的值，则不能使用foreach循环。

    import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;

/**
 * @Author: xuehai.XUE
 * @MailBox: xuehai.xue@qq.com
 * @Date: 2021/3/22 15:04
 * @Description:
 */
public class ForTest {
    @Test
    public void test1(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add("AA");
        coll.add(new String("biggy"));
        coll.add(false);

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

    @Test
    public void test2(){
        int[] arr = new int[]{1,2,3,4,5,6};
        //for(数组元素的类型 局部变量 : 数组对象)
        for (int i : arr){
            System.out.println(i);
        }
    }

    @Test
    public void test3(){
        String[] arr = new String[]{"AA","AA","BB"};

        //方式一：普通for循环
        for (int i = 0; i < arr.length; i++) {
            arr[i] = "BB";
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        //方式二：增强for循环
        for(String s : arr){
            //
            s = "CC";
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}
5.Collection的子接口：List接口
  1. 鉴于Java中数组用来存储数据的局限性，通常使用List代替数组
  2. List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引
  3. List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据需要存取容器中的元素
  4. JDK API中List接口的实现类常用的有：ArrayList、LinkedList、Vector
6.ArrayList、LinkedList、Vector三者的区别
  1. 相同点：三个类都实现了List接口，存储数据的特点相同均是可以存储有序的、可重复的数据
  2. 不同点：
    1. ArrayList：作为List接口的主要实现类；ArrayList的线程是不安全的，但是效率高；底层使用Object[] elementData数组存储
    2. Vector：作为Link接口的古老实现类；线程是安全的，但是效率低；底层使用Object[] elementData数组存储
    3. LinkedList：对于频繁的插入、删除操作，使用LinkdedList效率比ArrayList高；底层采用双向链表存储
7.ArrayList扩容源码分析

  1. JDK1.7环境下

    ArrayList list = new ArrayList();//底层创建了长度是10的Object[]数组elementData
list.add(123);//elementData[0] = new Integer(123);
//.....
list.add(11);//如果此次添加导致底层element数组容量不够，则扩容；
//默认情况下，扩容为原来容量的1.5倍（原本长度 + （原本长度）右移一位），同时需要将原有数组中的数据赋值到新的数组中

    JDK1.8环境下

    ArrayList list = new ArrayList();//底层Object elementData初始化为{}，并没有立刻创建长度为10的数组
list.add(123);//第一次调用add()时，底层才创建了长度为10的数组，此时将123自动装箱放入elementData中
//.....
list.add(11);//如果此次添加导致底层element数组容量不够，则扩容；
//默认情况下，扩容为原来容量的1.5倍（原本长度 + （原本长度）右移一位），同时需要将原有数组中的数据赋值到新的数组中

  2. 源码

    image-20210322154937040

    image-20210322155049822

    image-20210322155227721

    image-20210322155446581

    image-20210322155501019

    image-20210322155654242

    image-20210322155726719

    image-20210322160023814

  3. 小结：

    1. 建议在开发中使用带参数的构造器：ArrayList list = new ArrayList(int capacity);
    2. JDK1.7中的ArrayList对象的创建类似于饿汉式单例模式，而JDK1.8中的ArrayList对象的创建类似于懒汉式单例模式，延迟了数组的创建，节省了内存
8.LinkedList源码分析
  1. LinkedList list = new LinkedList();//执行时，内部声明了Node类型的first和last属性。默认值为null
list.add(123);//将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;
        }
    }

  2. 添加元素的源码

    image-20210322161024322

    image-20210322161044643

9.Vector的源码分析

  1. 源码

    image-20210322161633331

    image-20210322161658046

    image-20210322161858837

    image-20210322161936538

    image-20210322162009643

  2. 分析：JDK1.7和JDK1.8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组，在自动扩容机制上，默认为原来数组长度的2倍。

10.具体实现List接口的方法

  1. List除了从Collection集合继承的方法外，List集合里添加了一些根据索引来操作集合元素的方法。

    1. void add(int index, Object ele)：在index位置插入ele元素
    2. boolean addAll(int index, Collection eles)：从index位置开始将eles中的所有元素添加进来
    3. Object get(int index)：获取指定index位置的元素
    4. int indexOf(Object obj)：返回obj在集合中首次出现的位置，若未找到返回-1
    5. int lastIndexOf(Object obj)：返回obj当前集合中的末次出现的位置，若未找到返回-1
    6. Object remove(int index)：移除指定index位置上的元素，并返回此元素
    7. Object set(int index, Object ele)：设置指定index位置上的元素为ele
    8. List subList(int fromIndex, int toIndex)：返回从fromIndex到toIndex位置的子集合

  2. 常用方法小结：

    增：add(Object obj) List实现的Collection接口中定义的方法

    删：remove(int index) / remove(Object value) 前一个是List中重载的方法，后一个是List实现Collection接口中定义的方法，二者之间构成重载

    改：set(int index, Object ele)

    查：get(int index)

    插：add(int index,Object ele) List中对List实现的add方法进行重载，实现插入元素

    长度：size()

    遍历：①Iterator迭代器方式；②foreach循环（增强for循环）；③普通循环

  3. 对具体实现List接口中的两个remove进行辨析

    import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author: xuehai.XUE
 * @MailBox: xuehai.xue@qq.com
 * @Date: 2021/3/22 16:43
 * @Description: 对List中的两个构成重载的remove进行辨析
 */
public class ListMethodTest {

    @Test
    public void testListRemove1(){
        List list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        updateList1(list);
        System.out.println(list);
    }

    private void updateList1(List list) {
        //此处的remove是remove(Object value)，是ArrayList中重载的方法
        list.remove(new Integer(2));
    }

    @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) {
        //此处的remove是remove(int index)，是ArrayList中实现List接口中的方法
        list.remove(2);
    }
}
11.Collection的子接口：Set接口
  1. Set接口是Collection的子接口，Set接口没有提供额外的方法
  2. Set集合不允许包含相同的元素，如果把两个相同的元素加入到Set集合中，则添加操作失败
  3. Set判断两个对象是否相同不是使用”==“运算符，而是根据equals()方法
  4. Set有三个实现类：HashSet、LinkedHashSet、TreeSet
  5. Set接口的实现类所具有的特点，无序性、不可重复性
    1. 无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加。而是根据数据计算出来的散列值（哈希值）决定的。
    2. 不可重复性：保证添加的元素按照equals()判断时，不能返回ture。即相同的元素只能添加一个
12.Set实现类之HashSet

  1. HashSet是Set接口的典型实现，大多数时候使用Set集合时，都会使用这个实现类。

  2. HashSet按Hash算法来储存集合中的元素，因此具有很好的存取、查找、删除性能

  3. HashSet具有的特点：

    1. 不能保证元素的排列顺序
    2. HashSet不是线程安全的
    3. 集合元素可以是null

  4. HashSet集合判断两个元素相等的标准：两个对象通过hashCode()方法比较相等，且两个对象的equals()方法返回值也相等

  5. 对于存放在Set容器中的对象，对应的类一定要重写equals()和hashCode(Object obj)方法，以实现对象的相等规则。即”相等的对象必须具有相等的散列码“

  6. 重写hashCode()方法的基本原则：

    1. 在程序运行时，同一个对象多次调用hashCode()方法应该返回相同的值
    2. 当两个对象的equals()方法比较返回true时，这两个对象的hashCode()方法的返回值也相等
    3. 对象中作用equals()方法比较的Field，都应该用来计算hashCode值。
    4. 重写的hashCode()和equals()尽可能保持一致性：相等的对象必须具有相等的散列码。

  7. IDE重写的hashCode()为什么有31这个数字

    1. 选择系数的时候要选择尽量大的系数。因为如果计算出来的hash地址值越大，”冲突“就越少，查找效率也会提高
    2. 31只占用5bit，相乘造成的数据溢出的概率较小
    3. 31可以 由i * 31 == (i << 5) - 1来表示，现在很多虚拟机里面都有相关的优化，提高算法的效率
    4. 31是一个素数，素数的特点是只能被1和自己整除，而且一个数乘以素数得到的新数只能由素数、被乘数和1整除，减少冲突。减少冲突能减少使用链地址法，提高查找效率

  8. 添加元素的过程：以HashSet为例说明：

    image-20210322184305329

    对于情况2和情况3而言：元素a与已经存在指定索引位置上数据以链表的方式存储（链地址法）；JDK1.7中将元素a放置在数组中，并且指向原来的数组；JDK1.8中原来的元素放置在数组中，该元素指向元素a

  9. HashSet扩容机制：HashSet底层也是数组，初始容量为16，当使用率超过0.75，（16 * 0.75 = 12）就会扩大容量为原来的两倍

13.Set实现类之LinkedHashSet
  1. LinkedHashSet是HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据的前一个数据和后一个数据
  2. LinkedHashSet根据元素的hashCode值来决定元素的存储位置，但他同时使用双向链表维护元素的次序，这使得元素看起来是以插入的顺序保存的。
  3. **LinkHashSet插入性能略低于HashSet，**但在迭代访问Set里的全部元素时有很好的性能
  4. LinkHashSet不允许集合元素重复
14.Set实现类之TreeSet

  1. TreeSet是SortedSet接口的实现类，TreeSet可以确保集合元素处于排序状态

  2. 向TreeSet中添加数据，要求是相同类的对象

  3. TreeSet底层使用红黑树结构存储数据，红黑树具有的特点是：有序、查询速度比List快

  4. 新增的方法如下：

    1. Comparator comparator()
    2. Object first()
    3. Object last()
    4. Object lower(Object ele)
    5. Object higer(Object ele)
    6. SortedSet subSet(formElement, toElement)
    7. SortedSet headSet(toElement)
    8. SortedSet tailSet(fromElement)

  5. TreeSet的两种排序方法：自然排序和定制排序。默认情况下，TreeSet采用自然排序

    1. 自然排序中，比较两个对象是否相同的标准为：compareTo()返回0，不再是equals()
    2. 定制排序中，比较两个对象是否相同的标准为：compare()返回0，不再是equals()

  6. 使用两种不同的方式完成TreeSet集合的元素添加操作

    import org.junit.Test;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

/**
 * @Author: xuehai.XUE
 * @MailBox: xuehai.xue@qq.com
 * @Date: 2021/3/22 19:03
 * @Description:
 */
public class TreeSetTest {

    /** 采用定制排序（实现Comparator接口） */
    @Test
    public void test2(){
        Comparator com = new Comparator() {
            /** 按照id从小到大排列 */
            @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.getId(),u2.getId());
               }else{
                   throw new RuntimeException("输入的数据类型不匹配");
               }
            }
        };

        TreeSet set = new TreeSet(com);
        set.add(new User("Genji", 22));
        set.add(new User("Hana", 18));
        set.add(new User("Zenyatta", 20));
        set.add(new User("Maccree", 25));
        set.add(new User("Ashe", 23));

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

    /** 采用自然排序（实现Comparable接口） */
    @Test
    public void test1(){
        TreeSet set = new TreeSet();

        set.add(new User("Genji", 22));
        set.add(new User("Hana", 18));
        set.add(new User("Zenyatta", 20));
        set.add(new User("Maccree", 18));
        set.add(new User("Ashe", 18));

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

    }
}

    User类

    import java.util.Objects;

/**
 * @Author: xuehai.XUE
 * @MailBox: xuehai.xue@qq.com
 * @Date: 2021/3/22 19:05
 * @Description:
 */
public class User implements Comparable{
    private String name;
    private int id;

    public User() {

    }

    public User(String name, int id) {
        this.name = name;
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }


    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", id=" + id +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof User)) return false;
        User user = (User) o;
        return getId() == user.getId() &&
                Objects.equals(getName(), user.getName());
    }

    @Override
    public int hashCode() {
        return Objects.hash(getName(), getId());
    }

    /** 输入的性名按照从大到小的顺序排列 */
    @Override
    public int compareTo(Object o){
        if(o instanceof User){
            User user = (User)o;
            return -this.name.compareTo(user.name);
        }else{
            throw new RuntimeException("输入的类型不匹配");
        }
    }
}

image-20210303180846928

STAY ANGER!!!
-Biggy-
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java集合汇总篇
12-13 18万+
一. 集合框架 Java 集合框架一些列的接口和类来实现很多常见的数据结构和算法，例如 LinkedList 就是集合框架提供的实现了双向链表的数据结构，关于这一篇文章建议大家收藏，我会不断地完善和扩充它的内容，例如最下面的系列文章我以后也会对它进行不断的更新 集合框架的接口 集合框架提供了很多接口，这些接口都包含了特定的方法来实现对集合上的特定操作 ) 我们将要学习这些接口以及子接口和它们的各种实现类，在开始之前我们先简单学习一下这些广泛运用的接口，可以看到整个集合框架，总共有三个顶级接口Collecti
20200730Java集合练习
buruore的博客
07-30 375
一、选择 1.下列不属于Collection子接口的是 C A. List B. Map C. Queue D. Set 2.已知ArrayList的对象是list，以下哪个方法是判断ArrayList中是否包含"dodoke" A A. list.contains(“dodoke”); B. list.add(“dodoke”); C. list.remove(“dodoke”); D. list.remove(“dodoke”); 3.下列哪个方法可以获取列表指定位置处的元素 D A. add(E e)
Java集合的排序
qq_41159942的博客
07-13 2664
1. Java中集合的排序方法 当需要进行排序的数据存放在实现了集合Collection接口的类Map，set，list等这些中时，可以使用Collection实现的sort方法对数据进行排序，sort方法主要有以下两种： public static <T extends Comparable<? super T>> void sort(List list) public static void sort(List list, Comparator<? super T&gt
java集合（超详细）
热门推荐
zdl66的博客
08-12 5万+
所有的集合类和集合接口都在java.util包下。 在内存中申请一块空间用来存储数据，在Java中集合就是替换掉定长的数组的一种引用数据类型。
2020-11-3 集合
PythonJIANGTANG的博客
11-27 443
集合是有一组无序排列且不重复的元素组成 集合使用大括号表示，元素类型可以是数字类型、字符串、元组，但不可以是列表、字典 使用大括号创建的集合属于可变集合，即可以添加或删除元素。此外，还存在一种不可变集合，即不允许添加或删除元素。 集合的一个重要用途是将一些数据结构中的重复元素去除。 同其他数据类型类似，集合也有一系列常用的操作，例如添加元素、删除元素等。 #集合中添加元素可以使用add()和update()函数 set1,set2 = {1,2,3},{3,4,5,6} set1.add(4) prin.
java集合java集合java集合java集合java集合
08-02
java集合
Java集合
06-13
Java的集合类是一种特别有用的工具类，它可以用于存储数量不等的多个对象，并可以实现常用数据结构，如栈，队列等，除此之外，Java集合还可用于保存具有映射关系的关联数组。 Java的集合大致上可分为：Set,List和...
Java基础篇：Java集合.pdf
04-24
该文档主要详细总结了Java集合的相关知识，包括Collection和Map接口、Collection接口的子接口List和Set接口以及具体的实现类、存储原理等；Map接口的子接口HashMap、LinkedHashMap、TreeMap、Properties等
java集合思维导图
08-07
Java集合框架是Java编程语言中的一个核心部分，它为数据存储和管理提供了高效且灵活的解决方案。本思维导图及总结旨在深入理解并掌握Java集合的相关概念和使用方法。 首先，我们来了解一下Java集合框架的基本构成。...
JAVA集合框架专题
08-19
JAVA集合框架专题 JAVA集合框架是JAVA编程语言中的一种常用的数据结构，用于存储和操作对象信息。下面是JAVA集合框架的主要知识点： 一、集合框架概述 JAVA集合框架是一种容器，用于存储对象信息。所有集合类都...
浅析synchronized锁升级的原理与实现 1
水w的博客
09-01 1190
浅析synchronized锁升级的原理与实现
在Java Web开发中，如何保障应用的安全性？请列举常见的安全策略和措施。请解释Spring框架中的事务管理，包括声明式事务和编程式事务。
最新发布
weixin_53180424的博客
09-03 675
在实际开发中，声明式事务管理因其非侵入性和易维护性而更受欢迎。它允许开发者将注意力集中在业务逻辑上，而不是事务管理的细节上。然而，在某些特殊场景下，编程式事务管理可能提供更灵活的控制力。因此，在选择事务管理方式时，应根据实际需求和场景来决定。
计算机毕业设计选题推荐-任务管理系统-项目任务分配系统-Java/Python项目实战
IT研究室的博客
09-03 565
随着信息化技术的迅猛发展，各类企业和组织越来越依赖于高效的任务管理系统以保证其日常运营的顺利进行。根据IDC（国际数据公司）发布的报告显示，全球企业在数字化转型上的投入已达数千亿美元，其中相当一部分资金用于提升企业内部的管理效率。任务管理系统作为企业信息化的重要组成部分，能有效帮助企业分配、监控和反馈任务，从而提高工作效率。然而，尽管市场上已有多种任务管理系统，它们在功能、用户体验和适用性上存在显著差异。
操作系统原子操作
zzt_is_me的博客
08-28 8680
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
MapStruct-Java实体转换利器
m0_63622279的博客
09-02 400
MapStruct 是一个用于生成映射器接口的代码生成库，主要用于简化 Java 对象之间的转换过程。在处理不同模型之间数据转换时，MapStruct 可以自动生成实现类减少手工转换逻辑的工作量。使用场景：各种模型之间的转换。BODTOVOPOJO引入mapstruct的pom依赖定义mapper接口（注意，这里不是MyBatis的Mapper哦），使用@Mapper注解标记，并在接口中声明映射方法。编写映射方法，（从xxxO转换为yyyO,模型之间的转换）在业务层中使用Mapper。
JavaWeb（基于SpringBoot开发）全总结（1）
2302_81420820的博客
09-02 841
再到spring boot中去设置，当我们遇到报错不要紧，我们直接再复制我们在DG上面写的sql语句，到idea那个数据库那里再运行一次，2.由于使用不同开发工具开发出来的略有不同，导致不能够互通，所以国际规定，使用maven创建的项目为统一标准结构，也就是下图所示的结构。还有我们写的案例里面的mapper层写的sql语句的新增，删除，等等操作，都是基于mybatis来实现的。例如：传入的是路径参数，json格式的参数等等，根据不同的参数我们使用不同的注解。
输入三个正整数，找出不大不小的值
laocooon的博客
08-30 1683
/ 找出最大值，找出最小值，然后不是最大值也不是最小值的。// 2、输入三个正整数，找出不大不小的值。
SpringBoot日常：扩展接口之CommandLineRunner和ApplicationRunner
qq_32590535的博客
08-28 545
日常开发中我们可能经常会遇到这样的场景，像启动容器完成后需要去执行一些业务逻辑，SpringBoot给我们提供了两个接口来帮助我们实现这种需求，两个启动加载接口分别是CommandLineRunner和ApplicationRunner。本文简单介绍如何使用该扩展点实现业务。
Java并发编程 进程与线程
m0_56369671的博客
08-28 1385
操作系统中有一个组件叫做任务调度器，将 cpu 的时间片（windows下时间片最小约为 15 毫秒）分给不同的程序使用，只是由于 cpu 在线程间（时间片很短）的切换非常快，人类感觉是 同时运行的。但如果是四核 cpu，各个核心分别使用线程 1 执行计算 1，线程 2 执行计算 2，线程 3 执行计算 3，那么 3 个线程是并行的，花费时间只取决于最长的那个线程运行的时间，即 11ms 最后加上汇总时间只会花费 12ms 注：需要在多核 cpu 才能提高效率，单核仍然时是轮流执行。
Java集合框架详解
"Java集合是Java编程中非常重要的部分，涵盖了数据存储和管理的主要机制。这份教程涵盖了Java集合框架的基本概念、接口和类，包括List、Set和Map接口的实现。" 在Java中，集合框架是处理对象组的核心工具，它提供了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值