精华内容
下载资源
问答
  • 一:Set集合去掉List集合中重复元素 public static void main(String[] args) { //利用set集合 去除ArrayList集合中的重复元素 ArrayList list = new ArrayList(); list.add("1"); list.add("1"); list.add("2...
  • 去除Set集合中的重复元素

    千次阅读 2019-01-26 15:44:23
    去除 Set 集合重复元素的方法与 equals(),hashCode()方法有关 class Person{ String name; int age; public String toString(){ return name+"..."+age; } } public class test1{ publi...

               去除 Set 集合的重复元素的方法与 equals(),hashCode()方法有关

    class Person{
        String name;
        int age; 
        public String toString(){
            return name+"..."+age;
        }
    }
    
    public class test1{
        public static void main(String[] args){
            Set<Person> set=new HashSet<Person>();
            set.add(new Person("a",21));
            set.add(new Person("b",65));
            set.add(new Person("c",23));
            set.add(new Person("b",65));
            System.out.println(set);
    }
    

    当你这样输出的时候,有可能会存在相同的元素存在 Set 集合中,是因为你没有重写 equals() ,hashCode()方法

    class Person{
        String name;
        int age;
        public boolean equals(Object o){
            if(o==null)
                return false;
            if(!(o instanceof Person))
                return false;
            Person p=(Person)o;
            return this.name.equals(p.name) && this.age==p.age;
        }
        public int hashCode(){
            return name.hashCode()+age;
        }
    }
    
    public class test1{
        public static void main(String[] args){
            Set<Person> set=new HashSet<Person>();
            set.add(new Person("a",21));
            set.add(new Person("b",65));
            set.add(new Person("c",23));
            set.add(new Person("b",65));
            System.out.println(set);
    }
    
    

     因为你通过 new Person() 写出来的元素都是不同的元素,所以集合会自动认为它是不同的元素。当你重写方法之后相同的元素就会去除

     

     

    展开全文
  • 如何在Set集合中添加重复元素

    千次阅读 2020-03-22 00:16:43
    Set集合元素重复比较    当你把对象加入HashSet时,HashSet会先计算对象的hashcode值来判断对象加入的位置,同时也会与其他已经加入的对象的hashcode值作比较,如果没有相符的hashcode,HashSet会假设对象没有...

    Set集合元素重复比较

       当你把对象加入HashSet时,HashSet会先计算对象的hashcode值来判断对象加入的位置,同时也会与其他已经加入的对象的hashcode值作比较,如果没有相符的hashcode,HashSet会假设对象没有重复出现。但是如果发现有相同hashcode值的对象,这时会调用equals()方法来检查hashcode相等的对象是否真的相同。如果两者相同,HashSet就不会让其加入操作成功。如果不同的话,就会重新散列到其他位置。(摘自《Head
    fist java》第二版)。这样我们就大大减少了equals的次数,相应就大大提高了执行速度。

        如下代码所示:

    /**
     * @author gosaint
     */
    public final class AddDupliacateElementInSet {
        public static void main(String[] args) {
            Set<Integer> set = new HashSet<>();
            set.add(1);
            set.add(1);
            set.add(3);
            set.add(4);
            set.add(5);
            set.add(6);
            set.forEach(s -> System.out.println(s));
        }
    }
    

    打印结果如下;Set集合会自动去重。
    在这里插入图片描述
       但是保不准变态的面试官会让你在Set集合中添加重复元素。让你实现,你该怎么做呢?我在文章开头就写到主要是equals方法和hashcode方法。实现思路是这样:我们让它的equals永远也相等就可以啦。实现和测试如下:

    /**
     * @author gosaint
     */
    public class UnequalWrapper {
    
        private int value;
    
        //...constructor, getter, setter
    
        @Override
        public boolean equals(Object o) {
            return false;
        }
    
        @Override
        public int hashCode() {
            return Objects.hashCode(value);
        }
    
        public static void main(String[] args) {
            UnequalWrapper a = new UnequalWrapper(1);
            UnequalWrapper b = new UnequalWrapper(2);
            UnequalWrapper c = new UnequalWrapper(1);
    
            Set<UnequalWrapper> set = new HashSet<>();
            set.add(a);
            set.add(b);
            set.add(c);
            set.forEach(wrapper -> System.out.println(wrapper.getValue()));
        }
    }
    

    在这里插入图片描述
    最后建议不这么做。

    展开全文
  • java中set集合如何去除重复元素

    万次阅读 2017-07-25 19:12:11
    set集合是可以重复元素集合; 用set集合添加一个学生对象元素时:import java.util.ArrayList; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Set;public class ...

    set集合是可以重复的元素集合;
    用set集合添加一个学生对象元素时:

    import java.util.ArrayList;
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.List;
    import java.util.Set;
    
    public class People {
        String name;
        int ages;
    
        public People(String name, int ages) {
            this.name = name;
            this.ages = ages;
        }
    
        public static void main(String[] args) {
            //创建集合对象
            Set study = new HashSet();
            //List  study=new ArrayList();
            study.add(new People("张三", 45));
            study.add(new People("李四", 37));
            study.add(new People("王五", 54));
            study.add(new People("张三", 45));
            study.add(new People("张三", 25));
            //创建迭代器对象
            Iterator it = study.iterator();
            while (it.hasNext()) {
                People str = (People) it.next();
                System.out.println(str.toSring());
            }
        }
        //重写头String方法,使输出的样式按照自己所定义的格式输出
        public String toSring() {
            return name + " " + ages;
        }
    }

    此时的运行结果:
    这里写图片描述
    如何除去重复的元素信息呢?
    需要重写equals()和hashCode()方法;
    代码如下

    public class People {
        String name;
        int ages;
        public People(String name, int ages) {
            this.name = name;
            this.ages = ages;
        }
        public static void main(String[] args) {
            //创建集合对象
            Set study = new HashSet();
            //List  study=new ArrayList();
            study.add(new People("张三", 45));
            study.add(new People("李四", 37));
            study.add(new People("王五", 54));
            study.add(new People("张三", 45));
            study.add(new People("张三", 25));
            //创建迭代器对象
            Iterator it = study.iterator();
            while (it.hasNext()) {
                People str = (People) it.next();
                System.out.println(str.toSring());
            }
        }
        public String toSring() {
            return name + " " + ages;
        }
        //重写equals()方法:判断姓名和年龄两者是否都相同;
        @Override
        public boolean equals(Object obj) {
            People p = (People) obj;
            return p.name == this.name && p.ages == this.ages;
        }
        //重写hashcode()方法:
        @Override
        public int hashCode() {
            return name.hashCode();
        }
    }

    运行结果:
    这里写图片描述
    通过以上代码,就可以出去set集合中的重复元素!

    希望对大家有所帮助!

    展开全文
  • Set集合重复元素的判断

    千次阅读 2018-06-14 08:44:06
    更重要的是Set集合不能放置重复元素.她是怎么判断的呢?那么,我们首先要让对象具有比较性 一,存储的自定义对象实现接口 Comparable 复写public int compareTo()方法. 返回0表示二者相等. 如...

    Set集合比较特殊,他的方法基本上和Collection接口的方法一致,并且他没有根据索引得到对应值的get(int index)方法. 更重要的是Set集合不能放置重复的元素.她是怎么判断的呢?那么,我们首先要让对象具有比较性
    一,存储的自定义对象实现接口 Comparable
    复写public int compareTo()方法. 返回0表示二者相等. 如果返回大于0的整数(一般写1),则认为该对象大于比较的对象.如果返回小于0的整数(一般是-1),则认为该对象小于比较的对象.

    下面我们定义一个类Person,如果对象的年龄相等,我们就认为这两个对象相等

    public static void main(String[] args) {
            testTreeSet();
        }
    
        private static void testTreeSet() {
            TreeSet<Person> treeSet = new TreeSet<Person>();
            treeSet.add(new Person("Tom", 20));
            treeSet.add(new Person("Jim", 21));
            treeSet.add(new Person("Jim", 20));
    
            Iterator<Person> it = treeSet.iterator();
            while (it.hasNext()) {
                Person p = it.next();
                System.out.println(p.toString());
            }
            System.out.println("size = "+treeSet.size());
        }
    
        static class Person implements Comparable<Person> {
            private String name;
            private int age;
    
            public Person(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 hashCode() {
                System.out.println("hashcode  " + 17 * age);
                return 17 * age;
            }
    
            @Override
            public boolean equals(Object obj) {
                Person p = (Person) obj;
                boolean b = (this.age == p.getAge());
                if (b) {
                    System.out.println("一样      " + this.toString() + "   "
                            + p.toString());
                } else {
                    System.out.println("不一样      " + this.toString() + "   "
                            + p.toString());
                }
                return b;
            }
    
            @Override
            public String toString() {
                return "Person [name=" + name + ", age=" + age + "]";
            }
    
            @Override
            public int compareTo(Person o) {
                if (this.age == o.getAge()) {
                    return 0;
                }
    
                if (this.age > o.getAge()) {
                    return 1;
                }
    
                return -1;
            }
    
        }
      
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83

    运行结果为:
    Person [name=Tom, age=20]
    Person [name=Jim, age=21]
    size = 2

    由此分析,在操作treeSet.add(new Person(“Jim”, 20));的时候认为他是一个相同的对象,那么就无法再放入了

    二,存储的自定义对象实现接口 Comparable

    public static void main(String[] args) {
            testTreeSet();
        }
    
        private static void testTreeSet() {
            TreeSet<Person> treeSet = new TreeSet<Person>(new Comparator<Person>() {
                @Override
                public int compare(Person o1, Person o2) {
                    if (o1.getAge() == o2.getAge()) {
                        return 0;
                    }
    
                    if (o1.getAge() > o2.getAge()) {
                        return 1;
                    }
    
                    return -1;
                }
            });
            treeSet.add(new Person("Tom", 20));
            treeSet.add(new Person("Jim", 21));
            treeSet.add(new Person("Jim", 20));
    
            Iterator<Person> it = treeSet.iterator();
            while (it.hasNext()) {
                Person p = it.next();
                System.out.println(p.toString());
            }
            System.out.println("size = "+treeSet.size());
        }
    
        static class Person  {
            private String name;
            private int age;
    
            public Person(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 String toString() {
                return "Person [name=" + name + ", age=" + age + "]";
            }
        }
    
      
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63

    结果是:
    Person [name=Tom, age=20]
    Person [name=Jim, age=21]
    size = 2
    存入了两个结果.
    treeSet.add(new Person(“Jim”, 20)); Jim的年龄和Tom相同被认为是一样的对象

    展开全文
  • Set集合如何判断重复元素

    千次阅读 2019-04-20 15:06:00
    1.TreeSet子类是利用Comparable接口来实现重复元素的判断,但是Set集合的整体特征就是不允许保存重复元素。 2.HashSet判断元素重复是利用Object类中的方法实现的: -|对象编码:public int hashCode(); -|对象....
  • Set集合不允许存储重复元素原理

    千次阅读 2020-06-22 20:46:38
    Set集合不允许存储重复元素原理 package com.Set; import java.util.HashSet; /* Set集合不允许存储重复元素原理 */ public class Demo02HashSetSaveString { public static void main(String[] args) { //创建...
  • python——集合set不存在重复元素

    千次阅读 2020-12-15 23:42:20
    1、set创建 (1)非空集合两种创建方式 # 第一种创建方式 ...2、set中不存在重复元素 In [1]: set1 = set([1,2,3, 1, 2, 3, 'a', 'b', 'b']) In [2]: set1 Out[2]: {1, 2, 3, 'a', 'b'} 3、set不支持索引
  • java 集合 Set 插入重复元素

    千次阅读 2019-05-04 13:21:35
    java 集合 Set 插入重复元素
  • Java中利用Set判断List集合中是否有重复元素 1、在开发工作中,我们有时需要去判断List集合中是否含有重复的元素 2、我们不需要找出重复的元素,我们只需要返回一个 Boolean 类型就可以了 3、如果使用循环遍历的方式...
  • set中的元素是不能相等重复的,这一点我知道,那么怎样才是(不)重复呢? 是hashcode相等?是地址相同?是元素的equal返回true? 猜测:先判断是不是同一个引用(地址),再判断equal 我自己做了...
  • 【用set集合重复数据,重写equals还是不成功的问题解决思路在文章最后】 需求描述: 因业务需要,通过复杂的代码逻辑从数据库取出数据放入List集合中,涉及多次从访问数据库取出数据放入List集合中,其中会取到...
  • Set集合是如何保证元素重复

    千次阅读 2019-12-14 17:10:06
    这里写自定义目录标题Set集合是如何保证元素不可重复总结 Set集合是如何保证元素不可重复 在使用集合的时候,会经常用到Set集合Set集合的特点如下: 1,元素无序 2,元素不可重复 那么Set集合底层是如何保证元素...
  • 要点:set集合存储元素重复元素前提:存储的元素必须重写hashCode方法和equals方法。 example: //创建HashSet集合对象 HashSet<String> set = new HashSet<>(); String s1 = new String( ...
  • Java中利用Set判断List集合中是否有重复元素

    万次阅读 多人点赞 2018-12-05 20:05:36
    在开发工作中,我们有时需要去判断List集合中是否含有重复的...我们只需要将List集合转化为Set集合,再进行比较就可以实现了: 代码如下: package com.test; import java.util.ArrayList; import java.util.HashSe...
  • 消除集合重复元素

    千次阅读 2018-07-25 10:48:43
    消除集合重复元素,根本考差点即list与set的区别。 简单点说:list 代表有索引编号的集合,可以存放重复的对象,可以在指定的位置插入对象。set存放不重复的对象,只能有一个null元素。 知道两者的区别,就可以...
  • java:Set可以插入重复元素

    千次阅读 2020-10-23 19:12:01
    Set<List<Integer>> res1 = new HashSet<>(); res1.add(new ArrayList<>()); res1.add(new ArrayList<>(Arrays.asList(1))); Set<List<Integer>> ...
  • 用Iterator方法来判断元素是否重复,用equals()判断两个set是否相等, set存取元素是按哈希值排序, 示例代码 package test; import java.util.HashSet; import java.util.Iterator; import java.util....
  •  Console.WriteLine("====这个集合存在重复");  break;  }  }    Console.ReadLine();  }  } }  ISet<string> devicesIDSet = new SortedSet();  Boolean tlag=...
  • python中集合中的元素是否可以重复

    千次阅读 2020-12-04 03:26:13
    集合是一个无序的不重复元素序列,我们可以使用大括号{}或者set()函数来创建一个集合,具体语法为:【parame = {value01,value02,...}】。python中集合中的元素不可以重复。集合定义:集合(set)是一个无序的不重复...
  • * 类描述:set集合针对String 类型和8大基础数据类型 过滤掉重复数据,如果存放的是其他类型对象,则需要重写hashCode方法和equals方法,当equals 比较相等时,则会去比较hashCode值 hashCode的值 如果一致的话,则...
  • 取集合中元素_Python Set集合

    千次阅读 2021-03-06 22:33:24
    Set集合阅读本文需要3分钟2019.09.05集合(set)是一个无序不重复元素的序列。基本功能是进行成员关系测试和删除重复元素。可以使用大括号 { } 或者 set() 函数创建集合,注意:创建一个空集合必须用 set() 而不是 { }...
  • Java获取集合重复元素

    千次阅读 2019-10-15 13:29:32
    我们在下订单的时候,收件人的地址信息可能会有多个,现在的需求是把一些重复的地址信息删除掉。 姓名,电话,省,市,区,详细地址完全相同则认为是同一个收件人。 分析 地址是存在数据库的表里的,所以我们需要先...
  • c++中向set集合中插入元素并遍历

    千次阅读 2019-08-11 18:21:51
    由于set集合容器实现了红黑...2.set集合内没有重复元素 ,只是对重复元素进行忽略处理,(multiset可以插入重复元素) 3.平衡二叉树采用中序遍历算法,于是,遍历时将键值由小到大排序 4.可以把平衡二叉树理解为:...
  • Set<Worker> set = new HashSet(); set.add(new Worker("tom", 18, 2000)); set.add(new Worker("tom", 18, 2000)); set.add(new Worker("jerry", 18, 2000)); for (Worker worker : set) { System....
  • Set集合实现元素重复原理

    千次阅读 2015-10-04 11:39:54
    众所周知,set内容不重复。以hashSet为例,会使用对象的hashCode()与equals()来判断存入的对象是否相同。详解收集过程如下。
  • javaSE Set集合,元素无序不重复

    千次阅读 2018-06-11 22:16:00
    Collection(集合):容器,用于存放对象(引用类型。... 查看Set(集):元素无序,不可重复 (没有索引)。 遍历只能用Iterator迭代器和增强for, 不能使用普通for遍历。ArrayList(数组列表): 查询快,增删慢。 查看LinkedLis...
  • 集合{ }_set_元素不可重复

    千次阅读 2018-11-29 02:12:42
    集和里面的元素是不可重复的 s = {1,2,3,4,5,6,6,3,3,2} print(s,type(s)) s1 = {1} print(s1,type(s1)) 运行: 如何定义一个空集合: s2 = {} #默认情况是dict,称为字典 print(s2,type(s2)) 运行: 定义一个...
  • java中set集合重复验证机制

    千次阅读 2018-09-30 14:47:18
    我们知道,set集合很重要的一个特性,是不允许存储重复元素。那么,这究竟是怎么验证的呢。在之前的资料查询中,有这样一个说法,set集合进行插入的时候,会调用对象的equals方法,判断元素是否相同,若equals...
  • c++中容器set的去除重复元素排序

    千次阅读 2018-08-22 15:28:05
    两者不同在于前者不允许元素重复,而后者允许。 1) 不能直接改变元素值,因为那样会打乱原本正确的顺序,要改变元素值必须先删除旧元素,则插入新元素 2) 不提供直接存取元素的任何操作函数,只能通过迭代器进行...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 266,618
精华内容 106,647
关键字:

set集合如何处理重复元素