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

    2020-06-18 00:54:49
    Java Set集合去重 在开发中经常使用到Set集合去重,那么去重的原理是怎样实现的呢?在此文章记录一下去重原理!!! 下面是set集合类图 下面我们来跟踪一下执行过程; 1、首先我们实例化一个Set对象; Set<8大...

    Java Set集合去重

    在开发中经常使用到Set集合去重,那么去重的原理是怎样实现的呢?在此文章记录一下去重原理!!!

    下面是set集合类图
    在这里插入图片描述
    下面我们来跟踪一下执行过程;
    1、首先我们实例化一个Set对象;

        Set<8大基本类型> set = new HashSet<8大基本类型>();
        set.add(8大基本类型);
    

    2、add操作会调用HashMap中的add方法;

    public boolean add(E e) {
    	return map.put(e, PRESENT)==null;
    	}
    

    3、HashMap中的add方法依赖了HashMap的put方法;

    public V put(K key, V value) {
            if (key == null)
                return putForNullKey(value);
            int hash = hash(key.hashCode());
            int i = indexFor(hash, table.length);
            for (Entry<K,V> e = table[i]; e != null; e = e.next) {//每添加一个,则循环判断是否与map中的元素相等
                Object k;
                // 先判断hashcode是否一致,然后再判断值是否相等
                if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                    V oldValue = e.value;
                    e.value = value;
                    e.recordAccess(this);
                    return oldValue;
                }
            }
     
            modCount++;
            addEntry(hash, key, value, i);
            return null;
        }
    

    但是上述方法只对基本数据类型有效,下面是应用到复杂对象的讲解。
    下面就是重写对象User的实现,重写equals和hashCode方法;

    测试类

    public class User {
        //id
        protected Integer id;
        //username
        protected String username;
    
        //构造方法
        public User(int id,String username){
            this.id = id;
            this.username = username;
        }
    
        /**
         * 如果对象是USER,先比较hashcode,一致的场合在比价每个属性的值
         */
        @Override
        public boolean equals(Object obj) {
            if(obj == null)
                return false;
            if(this == obj)
                return true;
            if(obj instanceof User){
                User user = (User) obj;
                //if(user.id == this.id) return true; //只比较id
                //比较id和username 一致时才返回true,之后再去比较hashCode
                if(user.id == this.id && user.username.equals(this.username)){
                    return true;
                }
            }
            return false;
        }
    
        /**
         *
         * 重写hashCode方法,返回的hashCode不一样 才认为是不一样的对象;
         */
        @Override
        public int hashCode() {
            //return id.hashCode();  只比较id,id不一样就添加进集合;
            return id.hashCode() * username.hashCode();
        }
    }
    

    实现类

    import java.util.HashSet;
    import java.util.Set;
    
    public class test {
        public static void main(String[] args){
            User user1 = new User(1,"xiaoqiang");
            User user2 = new User(2,"xiaoqiang");
            User user3 = new User(1,"xiaoqiang");
            User user4 = new User(1,"xiaoqiang");
    
            Set<User> set = new HashSet<User>();
            set.add(user1);
            set.add(user2);
            set.add(user3);
            set.add(user4);
            for(User u : set){
                System.out.println("id:" + u.id +" username:"+ u.username);
            }
        }
    }
    

    输出

    id:2 username:xiaoqiang
    id:1 username:xiaoqiang
    

    展开全文
  • Set集合去重以及比较

    千次阅读 2019-04-20 12:50:51
    因此利用set集合去重是比较方便的,不需要自己再编写算法比对 HashSet HashSet具有去重功能 简单的基本类型:不需要做任何修改,直接放进hashset 例如:创建一个hashset保存 f f a a b b d d HashSet<String> ...

    Set集合:无序,元素不重复

    因此利用set集合去重是比较方便的,不需要自己再编写算法比对

    HashSet

    HashSet具有去重功能

    简单的基本类型:不需要做任何修改,直接放进hashset
    例如:创建一个hashset保存 f f a a b b d d

    HashSet<String> set = new HashSet<>();
    set.add("f"); 
    set.add("f");
    set.add("a");
    set.add("a");
    set.add("b");
    set.add("b");
    set.add("d");
    set.add("d");
    // 增强for循环
    for (String string : set) {
    	System.out.println(string);
    }
    

    打印结果:a b d f
    去重且无序(不是按照顺序打印)

    对象比对:需要重写equals和hashcode方法
    实现原理,先利用HashCode码比对,hashCode码相同再调用equals方法,查看是否同一个对象,是则无法存入

    下面重写这两个方法用以比对,注意:name作为主键存在

    @Override
        public boolean equals(Object obj) {
            if (obj instanceof Person1) {
                Person1 person= (Person1 )obj;
                return (this.getName().equals(person.getName()));
            }
            return super.equals(obj);
        }
    
        @Override
        public int hashCode() {
            return this.getName().hashCode();
        }
    
    public static void main(String[] args) {
    HashSet<Person1> hashSet = new HashSet<>();
    hashSet.add(new Person1("吕布", 25));
    hashSet.add(new Person1("吕布", 25));
    hashSet.add(new Person1("关羽", 26));
    hashSet.add(new Person1("关羽", 26));
    hashSet.add(new Person1("赵云", 23));
    hashSet.add(new Person1("赵云", 23));
    for (Person1 person1 : hashSet) {
    	System.out.println(person1);
        }
    }
    

    补充:
    LinkedHashSet 有序的HashSet(按照存入集合的顺序打印)
    还可以配合ArrayList使用
    TreeSet用来排序,需要重写Comparable接口

    本资料属于本人整理总结,参考:https://blog.csdn.net/lijock/article/details/80410202

    展开全文
  • 关于Set集合去重

    千次阅读 2019-06-07 19:16:36
    上次说了List集合的去重,这次来说说Set集合去重 public static void main(String[] args) { HashSet hs=new HashSet<>(); hs.add("a"); hs.add("b"); hs.add("c"); hs.add("a"); hs.add("a"); ...

    上次说了List集合的去重,这次来说说Set集合的去重

    public static void main(String[] args) {
    		HashSet hs=new HashSet<>();
    		hs.add("a");
    		hs.add("b");
    		hs.add("c");
    		hs.add("a");
    		hs.add("a");
    		for (Object obj : hs) {
    			System.out.println(obj);
    		}
    	}
    

    在这里插入图片描述
    从中可以看出HashSet中是有去重功能的,那我们来试试自定义对象,看看能不能去重。

    package com.liang.set;
    
    import java.util.HashSet;
    public class SetRemo {
    	public static void main(String[] args) {
    		HashSet hs=new HashSet<>();
    		hs.add(new Student("a","12"));
    		hs.add(new Student("b", "12"));
    		hs.add(new Student("c", "13"));
    		hs.add(new Student("c","12"));
    		hs.add(new Student("a","12"));
    		for (Object obj : hs) {
    			if(obj instanceof Student) {
    				Student stu=(Student)obj;
    				System.out.println(stu.getName()+stu.getAge());
    			}
    		}
    	}
    }
    class Student{
    	private String name;
    	private String age;
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public String getAge() {
    		return age;
    	}
    	public void setAge(String age) {
    		this.age = age;
    	}
    	public Student(String name, String age) {
    
    		this.name = name;
    		this.age = age;
    	}
    	public Student() {
    	
    	}
    	
    }
    
    

    结果如下
    在这里插入图片描述
    HashSet元素是自定义对象时,它的去重功能失效了,那怎么才能实现去重呢?
    下面让我们来看看代码该怎么写

    package com.liang.set;
    
    import java.util.HashSet;
    
    
    
    
    public class SetRemo {
    
    	public static void main(String[] args) {
    		HashSet hs=new HashSet<>();
    		hs.add(new Student("a","12"));
    		hs.add(new Student("b", "12"));
    		hs.add(new Student("c", "13"));
    		hs.add(new Student("c","12"));
    		hs.add(new Student("a","12"));
    		
    		
    		for (Object obj : hs) {
    			if(obj instanceof Student) {
    				Student stu=(Student)obj;
    				System.out.println(stu.getName()+stu.getAge());
    			}
    		}
    		
    	}
    }
    class Student{
    	private String name;
    	private String age;
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public String getAge() {
    		return age;
    	}
    	public void setAge(String age) {
    		this.age = age;
    	}
    	public Student(String name, String age) {
    
    		this.name = name;
    		this.age = age;
    	}
    	public Student() {
    	
    	}
    	@Override
    	public int hashCode() {
    		// TODO Auto-generated method stub
    		return this.getName().hashCode()+this.getAge().hashCode();
    	}
    	@Override
    	public boolean equals(Object obj) {
    			if(obj instanceof Student) {
    				Student s=(Student)obj;
    				return this.getName().equals(s.getName()) && this.getAge().equals(s.getAge());
    			}
    		return false;
    	}
    }
    
    

    运行结果如下
    在这里插入图片描述
    去重完成了!
    这是为什么呢?原因是HashSet去重时自动调用hashCode()方法,这个方法会返回一个哈希值,只有当这个哈希值相等时才会调用equals()方法进行去重.

    展开全文
  • 原文地址:Java Set集合去重机制 关于java里面的集合,大家经常利用到Set集合没有重复数据的特性,来进行数据的去重,那么去重的原理是怎么样的呢?最近面试了几个人,其间有聊到集合的东西,所以就顺便问了一下这...

    原文作者:不知道取啥昵称

    原文地址:Java Set集合去重机制

    关于java里面的集合,大家经常利用到Set集合没有重复数据的特性,来进行数据的去重,那么去重的原理是怎么样的呢?最近面试了几个人,其间有聊到集合的东西,所以就顺便问了一下这个问题,但是都是只知道这么用,而没有去看看底层代码的去重原理(而恰恰有可能这些基础原理会被用来设计其他一些场景实现),所以在此文章记录一下,希望能帮助到一些人。下面是Set集合的类图:

    下面我们来跟踪一下执行的过程:

    1. 首先我们实例化一个set对象

    Set<8大基本类型> set = new HashSet<8大基本类型>();
    set.add(8大基本类型);

    2.add操作会调用HashSet中的add方法,实现如下:

    public boolean add(E e) {
    	return map.put(e, PRESENT)==null;
    }

    3.HashSet中的add方法依赖了HashMap的put方法,实现如下:

    public V put(K key, V value) {
            if (key == null)
                return putForNullKey(value);
            int hash = hash(key.hashCode());
            int i = indexFor(hash, table.length);
            for (Entry<K,V> e = table[i]; e != null; e = e.next) {//每添加一个,则循环判断是否与map中的元素相等
                Object k;
                // 先判断hashcode是否一致,然后再判断值是否相等
                if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                    V oldValue = e.value;
                    e.value = value;
                    e.recordAccess(this);
                    return oldValue;
                }
            }
     
            modCount++;
            addEntry(hash, key, value, i);
            return null;
        }

    很明显上述操作对8种基本类型的数据+String型是有用的,但是如果想把去重的方式应用到复杂的对象呢,上述方式就还欠缺了一点了,知道了执行顺序和原理了的话,就知道该如何去实现了!下面就是重写对象User的实现,重写equals和hashCode方法!

    测试类:

    package com.test.set;
     
    import java.util.HashSet;
    import java.util.Set;
     
    public class UniqueSet {
     
        /**
         * 
         * @param args
         */
        public static void main(String[] args) {
     
            User user1 = new User(1, "a");
            User user2 = new User(2, "b");
            User user3 = new User(3, "c");
            User user4 = new User(2, "b");
     
            Set<User> userSet = new HashSet<User>();
            userSet.add(user1);
            userSet.add(user2);
            userSet.add(user3);
            userSet.add(user4);
            // 输入结果 id=1 username=a  id=2 username=b  id=3 username=c  
            for (User u : userSet) {
                System.out.println("id=" + u.id + " " + "username=" + u.username);
            }
        }
    }

    实现类:

    package com.test.set;
     
    /**
     * 类描述:set集合针对String 类型和8大基础数据类型  过滤掉重复数据,
     * 如果存放的是其他类型对象,则需要重写hashCode方法和equals方法,
     * 当hashcode相等时(先执行hashCode方法),则会去执行equals方法,比较每个属性的值
     * 如果一致的话,则不会存进set,否则加入set集合 
     * 
     */
    public class User {
     
        // id
        protected Integer id;
        // 名称
        protected String  username;
     
        //构造方法
        public User(Integer id, String username) {
            this.id = id;
            this.username = username;
        }
     
        /** 
         * 如果对象类型是User,先比较hashcode,一致的场合再比较每个属性的值
         */
        @Override
        public boolean equals(Object obj) {
            if (obj == null)
                return false;
            if (this == obj)
                return true;
            if (obj instanceof User) {
                User user = (User) obj;
                // if(user.id = this.id) return true; // 只比较id  
                // 比较每个属性的值 一致时才返回true 
                if (user.id == this.id && user.username.equals(this.username))
                    return true;
            }
            return false;
        }
     
        /** 
         * 重写hashcode 方法,返回的hashCode不一样才再去比较每个属性的值
         */
        @Override
        public int hashCode() {
            // return id.hashCode();
            return id.hashCode() * username.hashCode();
        }
    }

     

    展开全文
  • 利用Set集合去重

    2021-09-27 15:12:56
    //在类里面实现Comparable接口,来解决TreeSet里面的元素是类的对象的情况 /* 在聊天软件中,发送方发送消息时,遇到网络超时后就会自动重发, 因此,接收方可能会收到重复的消息,在显示给用户看的时候,需要首先...
  • 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&...
  • Java Set集合去重机制

    万次阅读 2016-03-21 15:38:50
    关于java里面的集合,大家经常利用到Set集合没有重复数据的特性,来进行数据的去重,那么去重的原理是怎么样的呢?
  • 1.set集合去重机制 ps:set集合在内部执行时,首先会先对对象执行hash算法,存储到内存空间, (但在同一次运行过程中两个值相等的对象hash值一样)所以如果两个对象值相等,这时会做出第二步操作, 判断这两个对象的值...
  • 对两个表查出来的数据合并去重,使用List,Map,Set集合去重 表一中查出来的数据 a b c 1 1 1 2 4 2 表二中查出来的数据 a b c 2 2 2 2 4 2 表一表二合并的结果数据 a b c 1 1 1 ...
  • 转载:...Set:一般用来去重,但是我同时也想保留顺序 所以做了如下测试: public class Test { public static void main(String[] args) { List<Integer> a = new ArrayList<&g...
  • Set集合对象去重

    2021-04-12 17:09:31
    Set集合对象去重 只有实现,没有原理。通过重写类的hashCode()跟equals()方法来实现,当前者返回的hashCode相同并且equals()方法返回true时,则判断为重复 一般hashCode()方法返回的是主键id.hashCode(),或者多个...
  • 对象集合去重的实现总结 前言 使用Set集合的去重机制,结合lombok注解实现基本数据类型集合,对象集合的去重 一、引入lombok 在pom.xml文件中,加入以下依赖: <!--lombok注解--> <dependency> &...
  • 综述 equal和hasCode ...重写equal和hasCode,用HashSet集合进行对象去重 自我理解 equal和hasCode equal和hasCode都是Object中的方法,所有的类都有这这两种方法。 先看代码,在讲解 user实
  • 关于使用set去重对象无效的问题

    千次阅读 2019-01-21 20:41:29
    关于使用set去重对象无效的问题 最近使用set去重遇到对于集合为对象的集合,使用set无效的问题解决办法: 假如有一个List users的对象,现在去重集合中重复的user对象,利用set集合特性进行去重 Set&lt;user&...
  • Java Set对象去重

    万次阅读 多人点赞 2018-05-23 16:41:19
    我们可以知道Set集合是没有重复数据的特性,那么对于元素为对象 的情况是否也同样奏效?可以看一下。举一个例子:SetTest.java:class VO { private String name; private String addr; public VO(String name, ...
  • set集合中存放对象类型,对于各个字段值都相同的对象,并没有做去重操作。 new HashSet()操作实际上是new HashMap<>(),底层是以HashMap来实现的。在HashMap.add方法中,判断插入的key是否存在,要判断两点...
  • set 对象去重

    2019-10-25 17:17:25
    set集合 set<string> 是不会重复得,关于Set<obj> 对象塞进去得话会重复。 原因:实例化 HashSet对象实际是 new HashMap<>。HashMap插入值时判断key存在,要判断两点(1.hash...
  • 使用Set集合对List集合进行去重

    万次阅读 2018-03-22 23:00:21
    使用Set集合对List集合进行去重前段时间正好遇到这样一个需求:我们的支付系统从对方系统得到存储明细对象的List集合,存储的明细对象对象的明细类简化为如下TradeDetail类,需求是这样的,我要对称List集合进行去重...
  • 集合去重 对象代码 public class People { private String name; ...
  • 昨天遇到对象去重问题,想当然用Set存储对象,debug的时候发现个数还是没变,所有的都存进来了,百度了一会发现Set是需要重写equals和hashcode的。 @Override public boolean equals(Object obj) { if(this==obj){...
  • String 去重 /** * notes:使用HashSet实现List去重 * @param list * @return */ public static List repeatListWayTwo... //初始化HashSet对象,并把list对象元素赋值给HashSet对象 HashSet set = new HashSet(lis...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 30,918
精华内容 12,367
关键字:

set集合去重对象