精华内容
下载资源
问答
  • set去重

    2019-07-30 10:06:54
    今天我们来学=学习一下set如何实现去重的相关内容。 ES6中新增了set数据结构,类似于数组,其构造函数可以接受一个数组作为参数,我们先来看一下代码: <script> let array = [1, 1, 1, 2, 2, 2, 3, 3, 4];...

    今天我们来学=学习一下set如何实现去重的相关内容。

    • ES6中新增了set数据结构,类似于数组,其构造函数可以接受一个数组作为参数,我们先来看一下代码:
    <script>
        let array = [1, 1, 1, 2, 2, 2, 3, 3, 4];
        let set = new Set(array);
        console.log(set);
    </script>
    

    去重结果如图所示。


    7861972-4912bb892b11c597.png
    去重结果1
    • ES6中Array新增了一个静态方法Array.from,可以把类似数组的对象转换为数组,这样我们可以把代码修改为:
    <script>
        let array = Array.from(new Set([1, 1, 1, 2, 2, 2, 3, 3, 4]));
        console.log(array);
    </script>
    

    去重结果如图所示。


    7861972-dccfc3bbf552b149.png
    去重结果2

    好了,今天的分享就到这里了!
    愿你三冬暖,愿你春不寒;愿你天黑有灯,下雨有伞。


    7861972-c15692bc3ce6fc3a.jpg
    小晴天
    展开全文
  • set 去重

    2019-04-19 09:57:19
    var arr = [2, 4, 1, 1, 4, 4]; var arr1 = […new Set(arr)]; console.log(arr1) // (3) [2,4, 1]

    var arr = [2, 4, 1, 1, 4, 4];

    var arr1 = […new Set(arr)];

    console.log(arr1) // (3) [2,4, 1]

    展开全文
  • java set 去重

    2015-10-20 18:27:30
    java set 去重
  • Set去重原理

    2020-10-04 20:35:56
    在上篇文章《哈希值和可变性Hash value and mutability》最后说到set去重问题,所以这篇主要是通过实践来研究一下set去重背后的故事,当然也是参考了网上一些资料得到了一些启发,感谢那些陌生的喜欢分享的博友们。...

    在上篇文章《哈希值和可变性Hash value and mutability》最后说到set去重问题,所以这篇主要是通过实践来研究一下set去重背后的故事,当然也是参考了网上一些资料得到了一些启发,感谢那些陌生的喜欢分享的博友们。

    set的简单应用
    利用set中元素的唯一性,我们可以对list去重

    list1 = [1,2,3,1,2,3]
    print(set(list1))
    # output: {1, 2, 3}
    

    set去重的原理

    1. set中元素的hash值不一样
    class Person:
        def __init__(self, name, identityId):
            self.name = name
            self.identityId = identityId
            
        def __hash__(self):
            print("%s call hash method"%self.name)
            return hash(id(self))
        
        def __eq__(self, other):
            print("%s call eq method"%self.name)
            if self.__dict__ == other.__dict__:
                return True
            else:
                return False
                    
    p1 = Person('p1', 123456789)
    p2 = Person('p2', 123456789)
    print("p1 id: %s"%hex(id(p1)))
    print("p2 id: %s"%hex(id(p2)))
    list_test = [p1,p2]
    print(set(list_test))
    

    可以看出set调用了元素的hash方法,p1和p2的hash返回不同,就认为是不重复的元素,所以不去重

    #output:
    p1 id: 0x209563fabe0
    p2 id: 0x209563fa910
    p1 call hash method
    p2 call hash method
    {<__main__.Person object at 0x00000209563FABE0>, <__main__.Person object at 0x00000209563FA910>}
    
    1. set中元素的hash返回值是一样的
    class Person:
        def __init__(self, instance, name, identityId):
            self.instance = instance
            self.name = name
            self.identityId = identityId
            
        def __hash__(self):
            print("%s call hash method"%self.instance)
            return hash(self.identityId)
        
        def __eq__(self, other):
            print(f"{self.instance} call eq method: equal to {other.instance}")
            if self.name == other.name:
                return True
            else:
                return False
        
    p1 = Person('p1','kelly', 123456789)
    p2 = Person('p2','xia', 123456789)
    p3 = Person('p3','peter', 111111111)
    p4 = Person('p4','kelly', 123456789)
    p5 = Person('p5','kelly.xia', 123456789)
    print("p1 id: %s"%hex(id(p1)))
    print("p2 id: %s"%hex(id(p2)))
    print("p3 id: %s"%hex(id(p3)))
    print("p4 id: %s"%hex(id(p4)))
    print("p5 id: %s"%hex(id(p5)))
    print(f"p1==p4:{p1==p4}")
    list_test = [p1,p2,p3,p4,p5]
    print(set(list_test))
    

    p1,p2,p3,p4,p5,通过id来看是指向不同的引用的,p1和p2的hash返回值相同,所以再调用p1的eq方法,eq返回是False的,所以认为p1和p2是不重复的。而p1和p4,hash返回值是一样的,再用户p1的eq方法,返回是Ture,所以认为p1和p4是重复的,将除去p4.最后的p5,跟p1,p2的hash返回值都是一样的,所以再分别调用p1和p2的eq方法,因为eq访求返回都为False,所以认为p5分别和p1,p2是不重复的。

    #output:
    p1 id: 0x209564e1fd0
    p2 id: 0x209564e1070
    p3 id: 0x209564e1ac0
    p4 id: 0x209564e1430
    p5 id: 0x209564e1c40
    p1 call eq method: equal to p4
    p1==p4:True
    p1 call hash method
    p2 call hash method
    p1 call eq method: equal to p2
    p3 call hash method
    p4 call hash method
    p1 call eq method: equal to p4
    p5 call hash method
    p1 call eq method: equal to p5
    p2 call eq method: equal to p5
    {<__main__.Person object at 0x00000209564E1070>, <__main__.Person object at 0x00000209564E1FD0>, <__main__.Person object at 0x00000209564E1C40>, <__main__.Person object at 0x00000209564E1AC0>}
    

    结论
    由以上得出结论:set的去重是通过两个函数__hash__和__eq__结合实现的。当两个对象的哈希值不相同时,就认为这两个对象是不同的; 当两个对象的哈希值一样时,调用__eq__方法,当返回值为True时认为这两个对象是重复的,应该去除一个。返回FALSE时,认为这两个对象不是重复的,所以不去重。

    应用
    利用set去重特性,我们扩展思维应用到许多需要去重的场景中去,关键就是override超类Object的__hash__和__eq__方法。

    展开全文
  • set去重原理set去重原理大家都知道,set()自带天然去重,例如自定义一个类测试发现改造去重原理 set去重原理 大家都知道,set()自带天然去重,例如 Set<String> set = new HashSet<String>(); set....

    set去重原理

    大家都知道,set()自带天然去重,例如

    	Set<String> set = new HashSet<String>();
    	
    	set.add("aaa");
    	set.add("bbb");
    	set.add("aaa");
    	set.add("ccc");
    		
    	System.out.println(set);
    
     它的输出结果为:[aaa, ccc, bbb]
    

    可以看到:1.去重了;2.输出无序

    那么,set()是如何去重的呢

    自定义一个类

    为了贴合实际的开发需求,我们常需要自定义数据结构。拿通用示例 Student 来说。

    class Student{
    
        private String name;
        private int age;
        private int sid;
        
        public Student(String name, int age, int sid){
            this.name = name;
            this.age = age;
            this.sid = sid;
        }
    }
    

    现在,我们实例两个 Student 对象,分别是 stu1 和 stu2,其名字 name,年龄 age,学号 sid 相同。现实生活中,可以认为这两个学生是同一人。

    测试

    public static void main(String[] args) {
            Set<Student> set = new HashSet<Student>();
    
            Student stu1 = new Student("jiang", 20, 121);
            Student stu2 = new Student("jiang", 20, 122);
    
            set.add(stu1);
            set.add(stu2);
            System.out.println(stu1 == stu2);
            System.out.println(set);
        }
    

    输出

    false
    [Student@1218025c, Student@548c4f57]
    

    可见,对于new出来的两个对象 stu1 和 stu2 set并没有做去重

    发现

    跟踪add()发现

    /**
         * Adds the specified element to this set if it is not already present.
         * More formally, adds the specified element <tt>e</tt> to this set if
         * this set contains no element <tt>e2</tt> such that
         * <tt>(e==null&nbsp;?&nbsp;e2==null&nbsp;:&nbsp;e.equals(e2))</tt>.
         * If this set already contains the element, the call leaves the set
         * unchanged and returns <tt>false</tt>.
         *
         * @param e element to be added to this set
         * @return <tt>true</tt> if this set did not already contain the specified
         * element
         */
        public boolean add(E e) {
            return map.put(e, PRESENT)==null;
        }
    

    点进去看到

        private transient HashMap<E,Object> map;
     
        // Dummy value to associate with an Object in the backing Map
        private static final Object PRESENT = new Object();
     
        /**
         * Constructs a new, empty set; the backing <tt>HashMap</tt> instance has
         * default initial capacity (16) and load factor (0.75).
         */
        public HashSet() {
            map = new HashMap<>();
        }
    

    1.现在我们看到了,map是HashMap类型,Hash类型是散列的,所以无序。

    2.因为new了一个对象名为PERSENT的Object对象。以传入的e作为key值,PERSENT作为value来存储到map中,如果key值相同,将会覆盖,这就是set为什么能去重的原因(key相同会覆盖)。

    改造

    我们在 Student 类中重写 equals方法 和 hashCode方法

    @Override
        public boolean equals(Object obj) {
    
            Student tmp = (Student)obj;
            if(tmp.getAge() == this.age && tmp.getName() == this.name && tmp.getName() == this.name){
                return true;
            }else{
                return false;
            }
        }
    
        @Override
        public int hashCode() {
            return this.getName().hashCode()+this.age;
        }
    

    然后重新打印输出set

    [Student@606f04f]
    

    我们发现,它只有一个了,完成了去重操作

    这两个方法少些一个都不行

    去重原理

    经过前面一步步推导,我们得到了set()去重的原理

    1. set() 函数中会先调用对象的 hashCode() 方法,获取 hash 结果;
    2. 如果 hash 结果相同,用比较操作符 == (也就是调用函数 equals())判断二者的值是否相等;
    3. 如果都相等,去重;否则,set() 认为二者不同,两个都保留到结果中。
    展开全文
  • es6 中Set去重

    2021-07-08 10:17:57
    es6 中Set去重 const arr = [1, 1, 2, 3, 3, 5, 6] const newArr = [...new Set(arr)] newArr // [1, 2, 3, 5, 6]
  • Set去重原理和内部实现

    千次阅读 2018-10-07 10:15:14
    Set去重的原理非常简单,Set的内部是通过Map来实现的。 我们选取平时常的HashSet来分析 private transient HashMap&lt;E,Object&gt; map; private static final Object PRESENT = new Object(); /** ...
  • 关于使用set去重对象无效的问题

    千次阅读 2019-01-21 20:41:29
    关于使用set去重对象无效的问题 最近使用set去重遇到对于集合为对象的集合,使用set无效的问题解决办法: 假如有一个List users的对象,现在去重集合中重复的user对象,利用set集合特性进行去重 Set&lt;user&...
  • 在做—– leetcode存在...经set去重后,列表会变成乱序,和原列表比较的话,会显示两者不等 所以set去重后不能直接比较 class Solution: def containsDuplicate(self, nums): nums = sorted(nums) nu = n...
  • 这边mysql取两列数据,想进行去重,但是set不接受字段,hash接受但不好去重,这边有考虑先将数据合并进行加密成一窜进行redis set去重,然后再冲redis 队列取出进行解密,这样太复杂,最后发现可以简单将连个数据...
  • Scala set去重与case class

    2018-11-07 11:46:53
    set去重:底层使用了hashMap进行去重,而hashMap判定元素是否相同时调用了hashcode,equals方法。 若在使用过程中使用set来装自定义类型并且想要达到去重的目的需要实现hashcode,equals方法 在使用中发现若用set...
  • 方法一、利用ES6 Set去重(ES6中最常用) function unique (arr) { return Array.from(new Set(arr)) } var arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'...
  • scrapy--set去重数据

    2019-05-28 19:08:53
    scrapy–set去重数据 1、Pipeline 中 from scrapy.exceptions import DropItem class CheckPipeline(object): """check item, and drop the duplicate one""" def __init__(self): self.names_seen = set...
  • Java Set 去重原理解析

    千次阅读 2017-01-31 09:32:06
    在讲原理之前,先看一个简单的示例代码,然后根据这个现象,一步一步地根据源码来看它的原理。 import java.util.HashSet;... * Set去重原理测试 * */ public class JavaSetDemo { public static void mai...
  • Python--day28--set去重

    2018-11-17 16:35:00
    set去重:set依赖对象hash eq 转载于:https://www.cnblogs.com/xudj/p/9974560.html
  • Map不是collection的子接口或者实现类。Map是一个接口 set去重原理(用 Set 存储对象集合并去重,需要重写equals和hashcode) https://blog.csdn.net/zpf336/article/details/42397415 ...
  • java中集合set去重使用

    千次阅读 2016-07-08 16:59:14
    第一种,List , List 用set去重时,无需重写equals方法  List list = new ArrayList(); for (int i = 0 ; i list.add(i); } list.add(3); list.add(5); for (int m = 0 ; m System.out.println("list...
  • 利用ES6 Set去重

    2019-12-02 11:18:40
    首先声明一个aa let aa = "1,2,3,1,2,3" 用逗号分隔以后返回数组 let bb = aa.split(",") 数组传入set去重 dd = Array.from(new Set(bb)) 根据自己需求决定是否toString ...
  • es6 Set去重

    2019-10-22 16:12:58
    var arr = [1,2,3,4,2,3]; var arr1 = new Set(arr); arr = [...arr1] //[1,2,3,4]
  • JS中Set去重

    千次阅读 2019-09-03 15:43:24
    Set类似于数组,但成员均是唯一的,没有重复值。Set本身是一个构造函数,用来生成Set数据结构。 数组去重 const arr=[2,2,3,4,4]; const uniqe=[...new Set(arr)]; //[2,3,4] Array.from方法可以将Set结构转换...
  • //去重最外层岗位信息 Set<BssxGWSearch> set = new TreeSet<BssxGWSearch>(new Comparator<BssxGWSearch>() { public int compare(BssxGWSearch a, BssxGWSearch b) { ...
  • javascript set去重

    2019-03-19 10:35:08
    Array.from(new Set([“1”,“2”,“3”,“5”,“1”]));
  • Set去重实体类

    2018-11-23 20:56:20
    我们知道set是无序且不重复的,但set不能去重我们自己定义的实体类,如果想根据一定的规则去重实体类,比如如果这个实体类中的ID相同就去重,这时候我们就要在这个实体类中重写hashCode和equals方法, /** * ...
  • 这次去测试一下 python 的set去重,速度怎么样? 我们要做的是把文件一次性读取到内存中,然后去重,输出去重的长度。 第一步:对121w 条数据去重,看去重话费的时间  上证据:   第二步:对1210 w 条数据...
  • redis set 去重

    千次阅读 2019-07-25 16:56:31
    但是如果我们把消息去重和计算未读数分开,即redis的set结构只用于判断一条消息是否是新消息,是否需要增加未读数,而把未读数保存在其他的地方,如果tair之类的,那我们是不是就可以定期重启redis了呢?因此我们...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 106,653
精华内容 42,661
关键字:

set去重