精华内容
下载资源
问答
  • Set集合

    万次阅读 2018-04-01 11:08:24
    1 Set集合介绍 Collection接口可以存放重复元素,也可以存放不重复元素。List可以存放重复元素,Set就是不重复的元素。 通过元素的equals方法,来判断是否为重复元素。 Set集合取出元素的方式可以采用:迭代器,...

    1 Set集合介绍

    Collection接口可以存放重复元素,也可以存放不重复元素。List可以存放重复元素,Set就是不重复的元素。
    通过元素的equals方法,来判断是否为重复元素。
    Set集合取出元素的方式可以采用:迭代器,增强 for

    2 HashSet(哈希表)

    此类实现了Set接口,由哈希表(实际是HashMap实例)支持。它不保证set的迭代顺序,特别是它不保证该顺序恒久不变。此类允许使用null元素。

    • 特点:无序集合,存储和取出的顺序不同,没有索引,不存储重复元素。代码的编写和ArrayList完全一致。
      HashSet特点:
    • 底层数据结构:哈希表(链表和数组的结合体);
    • 存储取出都比较快;
    • 线程不安全,运行速度快;

    3 对象的哈希值

    • 如果没有重写父类,每次运行的结果都是不同的整数;
    • 如果子类重写父类的方法,哈希值,自定义;
    • 存储到HashSet的依据;

    4 字符串的哈希值

    String类继承Object,重写了父类的方法hashCode,

    5 哈希表的存储过程

    public static void main(String[] args) {
            HashSet<String> set=new HashSet<String>();
            set.add(new String("abc"));
            set.add(new String("abc"));
            set.add(new String("abc"));
            set.add(new String("bbc"));
            set.add(new String("bbc"));
            System.out.println(set);
    
        }

    这里写图片描述
    - new String("abc"),调用对象的哈希值 new String("abc").hashCode=96354,集合在容器内找,有没有和96354一样的哈希值;
    - new String("abc"),集合在容器内找到了已经有一个对象也是96534,集合会让后来的对象调用方法equals(已经有的对象)。两个对象哈希值一样,equals方法返回是true,集合判定元素已经重复;

    6 LinkedHashSet集合

    • 基于链表的哈希表实现;
    • 继承自HashSet; -
    展开全文
  • set集合

    千次阅读 2012-04-17 20:17:34
    Set不允许包含相同的元素,如果试图把两个相同元素加入同一个集合中,add方法返回false。 Set判断两个对象相同不是使用==运算符,而是根据equals方法。也就是说,只要两个对象用equals方法比较返回true,Set就不 ...

    HashSet是无序的

    TreeSet是可排序的

    LinkedHashSet是排序的


    Set接口
    Set不允许包含相同的元素,如果试图把两个相同元素加入同一个集合中,add方法返回false。
    Set判断两个对象相同不是使用==运算符,而是根据equals方法。也就是说,只要两个对象用equals方法比较返回true,Set就不 会接受这两个对象。
    HashSet
    HashSet有以下特点
     不能保证元素的排列顺序,顺序有可能发生变化
     不是同步的
     集合元素可以是null,但只能放入一个null
    当向HashSet结合中存入一个元素时,HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值,然后根据 hashCode值来决定该对象在HashSet中存储位置。
    简单的说,HashSet集合判断两个元素相等的标准是两个对象通过equals方法比较相等,并且两个对象的hashCode()方法返回值相 等
    注意,如果要把一个对象放入HashSet中,重写该对象对应类的equals方法,也应该重写其hashCode()方法。其规则是如果两个对 象通过equals方法比较返回true时,其hashCode也应该相同。另外,对象中用作equals比较标准的属性,都应该用来计算 hashCode的值。
    LinkedHashSet
    LinkedHashSet
    集合同样是根据元素的hashCode值来决定元素的存储位置,但是它同时使用链表维护元素的次序。这样使得元素看起 来像是以插入顺序保存的,也就是说,当遍历该集合时候,LinkedHashSet将会以元素的添加顺序访问集合的元素。
    LinkedHashSet在迭代访问Set中的全部元素时,性能比HashSet好,但是插入时性能稍微逊色于HashSet。
    TreeSet
    TreeSet是SortedSet接口的唯一实现类,TreeSet可以确保集合元素处于排序状态。TreeSet支持两种排序方式,自然排序 和定制排序,其中自然排序为默认的排序方式。向TreeSet中加入的应该是同一个类的对象。
    TreeSet判断两个对象不相等的方式是两个对象通过equals方法返回false,或者通过CompareTo方法比较没有返回0
    自然排序
    自然排序使用要排序元素的CompareTo(Object obj)方法来比较元素之间大小关系,然后将元素按照升序排列。
    Java提供了一个Comparable接口,该接口里定义了一个compareTo(Object obj)方法,该方法返回一个整数值,实现了该接口的对象就可以比较大小。
    obj1.compareTo(obj2)方法如果返回0,则说明被比较的两个对象相等,如果返回一个正数,则表明obj1大于obj2,如果是 负数,则表明obj1小于obj2。
    如果我们将两个对象的equals方法总是返回true,则这两个对象的compareTo方法返回应该返回0
    定制排序
    自然排序是根据集合元素的大小,以升序排列,如果要定制排序,应该使用Comparator接口,实现 int compare(T o1,T o2)方法

    展开全文
  • java中的Set集合

    万次阅读 多人点赞 2018-11-05 21:40:41
    Set集合类似于一个罐子,程序可以依次把多个对象“丢进”Set集合,而Set集合通常不能记住元素的添加顺序。实际上Set就是Collection只是行为略有不同(Set不允许包含重复元素)。 Set集合不允许包含相同的元素,如果...

    概述
    Set集合类似于一个罐子,程序可以依次把多个对象“丢进”Set集合,而Set集合通常不能记住元素的添加顺序。实际上Set就是Collection只是行为略有不同(Set不允许包含重复元素)。
    Set集合不允许包含相同的元素,如果试图把两个相同元素加入同一个Set集合中,则添加操作失败,add()方法返回false,且新元素不会被加入。

    HashSet类

    HashSet是Set接口的典型实现,大多数时候使用Set集合时就是使用这个实现类。HashSet按Hash算法来存储集合中的元素,因此具有很好的存取和查找性能。底层数据结构是哈希表
    哈希表
    一个元素为链表的数组,综合了数组与链表的优点。

    HashSet具有以下特点:

    • 不能保证元素的排列顺序,顺序可能与添加顺序不同,顺序也可能发生变化;
    • HashSet不是同步的;
    • 集合元素值可以是null;

    内部存储机制

    当向HashSet集合中存入一个元素时,HashSet会调用该对象的hashCode方法来得到该对象的hashCode值,然后根据该hashCode值决定该对象在HashSet中的存储位置。如果有两个元素通过equals方法比较true,但它们的hashCode方法返回的值不相等,HashSet将会把它们存储在不同位置,依然可以添加成功。
    也就是说。HashSet集合判断两个元素的标准是两个对象通过equals方法比较相等,并且两个对象的hashCode方法返回值也相等。

    靠元素重写hashCode方法和equals方法来判断两个元素是否相等,如果相等则覆盖原来的元素,依此来确保元素的唯一性

    实例:
    没有重写hashCode和equals方法

            Student s1 = new Student("小龙女", 23);
            Student s2 = new Student("任盈盈", 24);
            Student s3 = new Student("小龙女", 23);
            Student s4 = new Student("东方不败", 25);
            Student s5 = new Student("伊琳", 29);
            Student s6 = new Student("周芷若", 30);
            HashSet<Student> hashSet = new HashSet<>();
            hashSet.add(s1);
            hashSet.add(s2);
            hashSet.add(s3);
            hashSet.add(s4);
            hashSet.add(s5);
            hashSet.add(s6);
            for (Student student : hashSet) {
                System.out.println(student.getName()+"=="+student.getAge());
            }
        }
    
    
    public class Student {
        private String name;
        private int age;
    
        public Student() {
        }
    
        public Student(String name, int age) {
            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 String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
    

    没有重写这两个方法,运行结果:
    在这里插入图片描述
    可以看到由重复元素出现在集合中。

    在元素类中重写hashCode和equals方法:

    Student.class

          //判断判断两个对象是否相等,对象是否存在,对象的name和age是否相等
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Student student = (Student) o;
            return age == student.age &&
                    Objects.equals(name, student.name);
        }
        
        //返回对象的name和age的hash值
        @Override
        public int hashCode() {
            return Objects.hash(name, age);
        }
    
    

    重写之后不是判断两个对象hashCode是否相等,而是判断对象的name和age是否同时相等,如果同时相等则判断为同一对象,不能重复出现在集合中。
    再次遍历结合,运行结果:

    在这里插入图片描述
    可以看到重复的元素已经被覆盖,保证了集合中元素的唯一性。

    如果需要把某个类的对象保存到HashSet集合中,重写这个类的equals方法和hashCode方法时,应尽量保证两个对象通过equals发那个法比较返回true时,他们的hashCode方法返回值也相等。

    为什么不直接使用数组,而用HashSet呢?
    因为数组的索引是连续的而且数组的长度是固定的,无法自由增加数组的长度。而HashSet就不一样了,HashCode表用每个元素的hashCode值来计算其存储位置,从而可以自由增加HashCode的长度,并根据元素的hashCode值来访问元素。而不用一个个遍历索引去访问,这就是它比数组快的原因。

    图解哈希表存储原理

    在这里插入图片描述

    HashCode中每个存储元素的“槽位”通常称为“桶”,如果多个元素的hashCode值相同,但它们通过equals方法比较返回false,就需要在桶里放多个元素,这样会导致性能下降。

    hash表

    • 容量:hash表中桶的数量;
    • 初始化容量:创建hash表时桶的数量;
    • 尺寸:当前hash表中记录的数量;
    • 负载因子:负载因子等于0表示空的hash表,0.5表示半满的hash表,轻负载的hash表具有冲突少、适宜插入与查询等特点。
    • 负载极限:负载极限是一个0~1之间的数值,决定了hash表的最大填满程度。当hash表的负载因子达到指定负载极限时,hash表会自动成倍地增加容量,并将原有的对象重新分配,放入新的桶中。HashSet、HashMap、Hashtable默认的负载极限是0.75。

    当向HashSet中添加可变对象时,必须十分小心。如果修改HashSet集合中的对象,有可能导致该对象与集合中的其他对象相等,从而导致HashSet无法准确访问该对象。

    LinkedHashSet类

    HashSet还有一个子类LinkedList、LinkedHashSet集合也是根据元素的hashCode值来决定元素的存储位置,但它同时使用链表维护元素的次序,这样使得元素看起来是以插入的顺序保存的,也就是说当遍历集合LinkedHashSet集合里的元素时,集合将会按元素的添加顺序来访问集合里的元素。
    输出集合里的元素时,元素顺序总是与添加顺序一致。但是LinkedHashSet依然是HashSet,因此它不允许集合重复。

    TreeSet类

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

    内部存储机制
    TreeSet内部实现的是红黑树,默认整形排序为从小到大。
    在这里插入图片描述

    与HashSet集合相比,TreeSet还提供了几个额外方法:

    • Comparator comparator():如果TreeSet采用了定制顺序,则该方法返回定制排序所使用的Comparator,如果TreeSet采用自然排序,则返回null;
    • Object first():返回集合中的第一个元素;
    • Object last():返回集合中的最后一个元素;
    • Object lower(Object e):返回指定元素之前的元素。
    • Object higher(Object e):返回指定元素之后的元素。
    • SortedSet subSet(Object fromElement,Object toElement):返回此Set的子集合,含头不含尾;
    • SortedSet headSet(Object toElement):返回此Set的子集,由小于toElement的元素组成;
    • SortedSet tailSet(Object fromElement):返回此Set的子集,由大于fromElement的元素组成;

    用法:

            TreeSet<Integer> nums = new TreeSet<>();
            //向集合中添加元素
            nums.add(5);
            nums.add(2);
            nums.add(15);
            nums.add(-4);
            //输出集合,可以看到元素已经处于排序状态
            System.out.println(nums);//[-4, 2, 5, 15]
    
            System.out.println("集合中的第一个元素:"+nums.first());//集合中的第一个元素:-4
            System.out.println("集合中的最后一个元素:"+nums.last());//集合中的最后一个元素:15
            System.out.println("集合小于4的子集,不包含4:"+nums.headSet(4));//集合小于4的子集,不包含4:[-4, 2]
            System.out.println("集合大于5的子集:"+nums.tailSet(2));//集合大于5的子集:[2, 5, 15]
            System.out.println("集合中大于等于-3,小于4的子集:"+nums.subSet(-3,4));//集合中大于等于-3,小于4的子集:[2]
        }
    

    从上面的运行结果可以看出输出的集合已经按从小到大排好了,但是问题来了,只能从小到大排序吗?如果是字符对象应按该怎样的顺序排序?如果是一个学生对象又按怎样的顺序排序呢?遵循怎样的排序规则呢?
    针对这个问题,TreeSet支持两种排序方法:自然排序和定制排序,在默认情况下,采用的是自然排序。

    自然排序

    TreeSet会调用集合元素的compareTo(Objec obj)方法来比较元素之间的大小关系,然后将集合元素按升序排列,这就是自然排序。

    Java提供了一个Comparable接口,该接口里定义了一个compareTo(Object obj)方法,该方法返回一个整数值,实现该接口的类必须实现该方法,实现了该接口的类必须实现该方法,实现接口的类就可以比较大小了。当调用一个一个对象调用该方法与另一个对象进行比较时,obj1.compareTo(obj2)如果返回0表示两个对象相等;如果返回正整数则表明obj1大于obj2,如果是负整数则相反。

    案例:
    实现存储学生类的集合,排序方式,按年龄大小,如果年龄相等,则按name字符串长度,如果长度相等则比较字符。如果name和age都相等则视为同一对象。

    元素对象Student.class

    package org.westos.demo2;
    
    import java.util.Comparator;
    
    public class Student implements Comparable<Student> {
        private String name;
        private int age;
    
        public Student(String name, int age) {
            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 String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        @Override
        public int compareTo(Student o) {
            //比较age
            int num=this.age-o.age;
            //如果age相等则比较name长度
            int num1=num==0?this.name.length()-o.name.length():num;
            //如果前两者都相等则比较name字符串
            int num2=num1==0?this.name.compareTo(o.name):num1;
            return num2;
        }
    }
    
    

    集合类

    package org.westos.demo2;
    
    import java.util.TreeSet;
    
    public class TreeSetDemo4 {
        public static void main(String[] args) {
            TreeSet<Student> tree = new TreeSet<>();
    
            //向集合中添加元素
            tree.add(new Student("孙悟空",16));
            tree.add(new Student("孙悟空",17));
            tree.add(new Student("孙悟空",16));
            tree.add(new Student("唐僧",16));
            tree.add(new Student("沙悟净",23));
            tree.add(new Student("唐僧",30));
    
            //遍历
            System.out.println(tree);
           /*[Student{name='唐僧', age=16},
           Student{name='孙悟空', age=16},
           Student{name='孙悟空', age=17},
           Student{name='沙悟净', age=23},
           Student{name='唐僧', age=30}]
            */
    
        }
    }
    
    

    从运行结果可以看到满足定义的排序规则。

    当把一个对象添加进集合时,集合调用该对象的CompareTo(Object obj)方法与容器中的其他对象比较大小,然后根据红黑树结构中找到它的存储位置。如果两个对象相等则新对象无法加入到集合中。

    注意问题

    • 大部分类在实现CompareTo(Object o)方法时,都需要将被比较对象obj强制类型转换成相同类型,因为只有相同的两个实例才会比较大小。
    • 加入集合的类都必须实现Comparable接口,否则会引发ClassCastException异常。
    • 向TreeSet集合中添加元素时,只有第一个元素无须实现Comparable接口,后面添加的所有元素都必须实现Comparable接口。当然这也不是一种好做法,当试图从TreeSet中取出元素时,依然会引发ClassCastException异常。
    • 不要修改已经存入集合的实例变量,这将导致它与其他对象的大小顺序发生改变,但TreeSet集合不会再次调整它们的顺序,这点和HashSet一样。

    总结:如果希望TreeSet能正常工作,TreeSet只能添加同一种类型的对象

    对于TreeSet集合而言,它判断两个对象是否相等的唯一标准是:两个对象通过compareTo(Object obj)方法比较是否返回0,如果是0则认为对象相等,否则认为不相等。

    修改上述案例:
    重写equals方法,更改compareTo(Object obj)的返回值总是返回1;

        @Override
        public int compareTo(Student o) {
            return 1;
        }
    
        @Override
        public boolean equals(Object o) {
          return true;
        }
    
    
            TreeSet<Student> tree = new TreeSet<>();
    
            Student s1 = new Student("李明",23);
    
            tree.add(s1);
            //遍历
            System.out.println(tree);//[Student{name='李明', age=23}]
            tree.add(s1);
            System.out.println(tree);//[Student{name='李明', age=23}, Student{name='李明', age=23}]
            
            //更改第一个元素的age
            tree.first().setAge(33);
            System.out.println(tree.last().getAge());//33
    

    虽然equals总是返回true,但是TreeSet总认为添加的两个对象不相等,可以看到修改第一个元素的age,最后一个元素的age也被修改。这是因为集合中存储的只是对象的引用,这两个对象的引用指向同一个对象,所以age变量也被随之改变。

    定制排序

    TreeSet的自然排序是根据集合元素的大小,TreeSet将它们以升序排列。如果需要实现定制排序,例如降序排序,则可通过Comparator接口的帮助。该接口里包含一个int compare(T o1,T o2)方法,用于比较o1和o2的大小。由于Comparator是一个函数式接口,因此还可以使用Lambda表达式来代替Comparator子类对象。

            TreeSet<Integer> nums = new TreeSet<>(new Comparator<Integer>() {
                @Override
                public int compare(Integer o1, Integer o2) {
                    return o1-o2;
                }
            });
            //向集合中添加元素
            nums.add(5);
            nums.add(2);
            nums.add(15);
            nums.add(-4);
            //输出集合,可以看到元素已经处于排序状态
            System.out.println(nums);//[-4, 2, 5, 15]
    

    如果需要更改排序方式,则更改Comparator对象的返回值;

            TreeSet<Integer> nums = new TreeSet<>(new Comparator<Integer>() {
                @Override
                public int compare(Integer o1, Integer o2) {
                    return -(o1-o2);
                }
            });
            //向集合中添加元素
            nums.add(5);
            nums.add(2);
            nums.add(15);
            nums.add(-4);
            //输出集合,可以看到元素已经处于排序状态
            System.out.println(nums);//[15, 5, 2, -4]
    

    使用Lambda表达式来实现:

            TreeSet<Integer> nums = new TreeSet<>((a,b)->-(a-b));
            //向集合中添加元素
            nums.add(5);
            nums.add(2);
            nums.add(15);
            nums.add(-4);
            //输出集合,可以看到元素已经处于排序状态
            System.out.println(nums);//[15, 5, 2, -4]
    

    定制排序的特征和自然排序相同,不能添加相同的对象。

    EnumSet类

    • EnumSet是一个专门为枚举类设计的集合类,EnumSet中的所有元素都必须是指定枚举类型的枚举值,该枚举类型在创建EnumSet时显式或隐式地指定。EnumSet的集合元素也是有序的,EnumSet以枚举值在Enum类内的定义顺序来决定集合元素的顺序。
    • EnumSet在内部以位向量的形式存储,这种存储形式非常紧凑、高效,因此EnumSet对象占用内存很小,而且运行效率很好。
    • EnumSet集合不允许加入null元素。

    EnumSet类没有暴露任何构造器来创建该类的实例,EnumSet类提供了以下类方法来创建EnumSet对象。

    • EnumSet allOf(Class elementType):创建一个包含指定枚举类里所有枚举值的EnumSet集合。
    • EnumSet complementOf(EnumSet s):创建一个其元素类型与指定EnumSet里元素类型相同的EnumSet集合,新的集合里包含原集合不包含的枚举值。
    • EnumSet copyOf(Collection c):使用一个普通集合来创建EnumSet集合;
    • EnumSet copyOf(EnumSet s):复制原集合;
    • EnumSet noneOf(Class elementType):创建一个元素类型为指定枚举类型的空EnumSet;
    • EnumSet of(E first,E...rest):创建一个包含一个或多个枚举值的EnumSet集合。传入的枚举值必须是同一枚举类。
    • EnumSet range(E from,E to):创建一个包含从from到to枚举值范围所有枚举值的EnumSet集合。

    实例:

    package org.westos.demo9;
    
    public enum SeasonEnum {
    
        //在第一行列出4个枚举实例
        Spring,Summer,Fall,Winter;
    }
    
    
    package org.westos.demo9;
    
    import java.util.EnumSet;
    
    public class EnumSetTest {
        public static void main(String[] args) {
            //创建一个EnumSet集合,集合元素是Season枚举类的全部枚举值
            EnumSet<SeasonEnum> es1 = EnumSet.allOf(SeasonEnum.class);
            System.out.println(es1);//[Spring, Summer, Fall, Winter]
    
            //创建一个EnumSet空集合,元素类型为Season类的枚举值
            EnumSet<SeasonEnum> es2 = EnumSet.noneOf(SeasonEnum.class);
            System.out.println(es2);//[]
    
            //手动添加两个元素
            es2.add(SeasonEnum.Spring);
            es2.add(SeasonEnum.Summer);
            System.out.println(es2);//[Spring, Summer]
    
            //以指定枚举值创建EnumSet结合
            EnumSet<SeasonEnum> es3 = EnumSet.of(SeasonEnum.Spring, SeasonEnum.Fall);
            System.out.println(es3);//[Spring, Fall]
    
            EnumSet<SeasonEnum> es4 = EnumSet.range(SeasonEnum.Summer, SeasonEnum.Winter);
            System.out.println(es4);//[Summer, Fall, Winter]
    
            //输出es4中不包含的枚举值
            EnumSet<SeasonEnum> es5 = EnumSet.complementOf(es4);
            System.out.println(es5);//[Spring]
        }
    }
    
    

    复制集合

            Collection c = new HashSet<>();
            c.clear();
            c.add(SeasonEnum.Spring);
            c.add(SeasonEnum.Summer);
    
            //复制集合中的元素来创建EnumSet
            EnumSet enumSet = EnumSet.copyOf(c);
            System.out.println(enumSet);//[Spring, Summer]
    
            c.add("Monday");
            c.add("ThusDay");
            EnumSet enumSet1 = EnumSet.copyOf(c);
            //出现ClassCastException异常,因为后面添加的两个元素不是枚举值
    
    展开全文
  • 遍历Set集合

    千次阅读 2018-11-01 14:59:27
    一般遍历set集合有两种方法: 1.迭代遍历: Set&lt;String&gt; set = new HashSet&lt;String&gt;(); Iterator&lt;String&gt; it = set.iterator(); while (it.hasNext()) { String ...

    目录

     

    前言

    正文

    1. 迭代遍历

    2. for循环遍历


    前言

    实际编程过程中,我们经常会遇到遍历set集合的需求。今天就来讲讲遍历set时有哪些常用方法和注意事项。

    正文

    其实,遍历set集合时,一般有两种方法,接下来分别介绍。今天我们以Java语言为例,其实C++的话也差不多。

    1. 迭代遍历

    Set<String> set = new HashSet<String>();  
    Iterator<String> it = set.iterator();  
    while (it.hasNext()) {  
      String str = it.next();  
      System.out.println(str);  
    }  

    该方法用到了迭代器,略显繁琐。其实,我们还可以考虑使用第二种方法。

    2. for循环遍历

    for (String str : set) {  
      System.out.println(str);  
    }  

    注意:在对set集合成进行遍历的时候不能同时进行修改操作,比如删除,这样会导致崩溃。

    这一点需要我们注意,我踩过坑了。(^_^)
      

    展开全文
  • Set集合之TreeSet集合

    万次阅读 2018-09-07 16:06:15
    TreeSet集合:可以对Set集合中的元素进行排序。是不同步i的。  判断元素唯一性的方式:根据比较方法的返回值来判断。是0(零)就存入集合,不是0就不存。因为Set集合是不能有重复的元素,无序。  既然是无序的...
  • set集合的值具有唯一性;1. sadd key value value ..... :向指定的key中set值。2.smembers key :获取指定key中的值。3. sismember key :判断成员元素是否是集合的成员。是返回1,否返回0;4. scard:获取set集合...
  • Java Set集合详解及Set与List的区别

    万次阅读 2018-06-04 23:46:50
    Java中的Set集合是继承Collection的接口,是一个不包含重复元素的集合。 下图是Set集合的源码。 Set和List都是以接口的形式来进行声明。Set主要包含三种存放数据类型都变量,分别是HashSet,LinkedHashSet,...
  • Java Set集合

    千次阅读 2019-02-02 14:50:42
    Set集合 Set接口是 Collection 的子接口。 Set集合不允许包含相同的元素。 如果添加相同的元素, add()返回返回FALSE, 新元素不会加入。 HashSet, TreeSet, EnumSet 是 Set 集合的三个实现类。 HashSet 的性能好于 ...
  • **List 集合Set 集合 ** List 集合Set 集合的区别 在说如何List集合Set 集合之前我们先回顾一下List 集合Set 集合的区别。 他们之间比较细致的区别有蛮多的,不过比较粗糙地来说List 和Set 之间的区别有...
  • Set集合详解

    千次阅读 2017-04-07 17:50:36
    使用Set集合的主要原因是因为Set集合里面没有重复的元素。 Set集合有三个常见的实现类:HashSet,TreeSet,LinkedHashSet。 简单的说,如果你关注性能,应该使用HashSet; 如果你需要一个有序的Set集合,应该使用...
  • List集合和Set集合的区别

    千次阅读 2019-06-09 22:06:51
    开发工具与关键技术:MyEclipse 10、list集合和Set集合的区别 作者: 撰写时间:2019年06月08日   List集合的详细特点:https://blog.csdn.net/weixin_43741599/article/details/91357999   Set集合类似于一个...
  • 使用Set集合对List集合进行去重

    万次阅读 2018-03-22 23:00:21
    使用Set集合对List集合进行去重前段时间正好遇到这样一个需求:我们的支付系统从对方系统得到存储明细对象的List集合,存储的明细对象对象的明细类简化为如下TradeDetail类,需求是这样的,我要对称List集合进行去重...
  • Set集合与List集合的区别

    万次阅读 2019-06-17 11:00:21
    1:**Set 里面不允许有重复的元素,所谓重复,即不能有两个相等(注意,不是仅仅是相同)的对象,**即假设 Set 集合中有了一个 A 对象,现在我要向 Set 集合再存入一个 B 对象,但 B 对象与 A 对象 equals 相等,则 ...
  • Set集合 去重和比较方法

    万次阅读 多人点赞 2018-05-22 20:43:29
    Set集合特点: 无序(没有下标) 集合中的元素不重复HashSethashset具有去重功能例: 创建一个hashset 保存 f f a a b b d d HashSet&lt;String&gt; set = new HashSet&lt;&gt;(); set.add("f&...
  • redis中Set集合SortSet有序集合的复制

    千次阅读 2016-10-18 16:29:40
    redis中Set集合SortSet有序集合的复制redis集合类型中是没有复制命令的,我所说的复制,是通过redis的其他指令来实现需求
  • set集合中添加两个相同元素,会导致添加操作无效。 map集合中的key不能是重复的,如果重复,那么后面添加的的映射关系会覆盖前面的映射关系,map集合中的key的维护是依靠set集合完成的。 为什么同是set集合,map集合...
  • set集合 函数 迭代器

    2019-06-12 20:19:05
    set集合中的元素与字典中的key的元素有共同的特征: 1.set集合中元素也是唯一的 2.set集合中的元素也是不可变的 创建set集合: set1 = {} set2 = set() 创建一个空的set集合 set2 = {1,2,3} 创建具有元素的set集合...
  • set集合特点

    千次阅读 2018-10-21 11:28:46
    Set集合 存储元素无序,且唯一。   HashSet: 依赖于hashCode()与equals()方法 首先比较哈希值: 若,相同,比较地址值或者equals() 相同,说明元素重复,不添加 不同说明元素不重复,添加到集合中 若,...
  • Set集合遍历

    千次阅读 2018-08-14 14:37:13
    package setDemo; import java.util.HashSet; import java.util.Iterator; import java.util.Set;... * @description Set集合遍历的三种方式  *   */ public class TraverseSet {  public static voi...
  • 文章目录ES6 键值对集合一、Set集合1、什么是Set集合2、Set集合的属性方法3、创建Set集合4、遍历Set集合方法`values()方法``keys()方法``entries()方法``forEach()方法`5、Set集合与Array对比二、WeakSet集合1、...
  • set集合的特点

    千次阅读 2019-05-06 15:20:40
    set集合的特点 A:存入集合的顺序和取出集合的顺序不一致 B:没有索引 C:存入集合的元素没有重复 set接口的实现类常用的有HashSet和TreeSet类。语法格式如下: Set<String> set1 = new HashSet<...
  • Set集合的运用

    2019-04-12 22:22:08
    今天阿里笔试崩了,脑子里忘了Set获取元素的用法了,崩盘了,有时候Set集合的特性真好用,正好现在整理一下Set集合 下面不同的Set有统一的特性,那就是不允许集合里的元素重复 HashSet 存储顺序和添加顺序不同, ...
  • C++set集合

    千次阅读 2016-08-09 20:23:10
    set集合容器: 调用头文件: #include&lt;set&gt; using namespace std; 详细用法(部分): set&lt;int&gt; t ------ 定义一个int类型的容器,(默认)里面元素从小到大 set&lt;int, ...
  • thinkphp5操作set集合

    千次阅读 2019-11-23 15:41:15
    thinkphp5操作set集合 redis 五大类型之一set集合,set和list的区别set没有重复值 基本命令: sadd 将一个元素添加到集合里,返回被添加元素当中原本并不存在于集合的元素数量 srem 从集合里删除一个活多个元素,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 87,825
精华内容 35,130
关键字:

set集合