java集合对字符串或对象去重

偏执的太偏执、 2023-10-18 13:59 117阅读 0赞

**由于开发中遇到了集合中筛选重复字符串或对象的操作，下面记录几种常用的方法，以备后续查询使用，直接上代码，**

/**
    	 * list去掉重复元素
    	 * 
    	 * @param datas
    	 * @return
    	 */
    	public static List<String> getNoDuplicate1(List<String> datas) {
    		List<String> res = new ArrayList<String>();
    		for (String single : datas) {
    			if (res.contains(single)) {
    				continue;
    			}
    			res.add(single);
    		}
    		return res;
    	}
    
    	/**
    	 * 利用set进行去重
    	 * 
    	 * @param datas
    	 * @return
    	 */
    	public static List<String> getNoDuplicate2(List<String> datas) {
    		Set<String> targets = new HashSet<String>();
    		List<String> res = new ArrayList<String>();
    		for (String single : datas) {
    			if (targets.add(single)) {
    				res.add(single);
    			}
    			continue;
    		}
    		return res;
    	}
    
    	/**
    	 * set和list转换去重
    	 * 
    	 * @param datas
    	 * @return
    	 */
    	public static List<String> getNoDuplicate3(List<String> datas) {
    		Set<String> sets = new HashSet<String>();
    		List<String> res = new ArrayList<String>();
    		sets.addAll(datas);
    		res.addAll(sets);
    		return res;
    	}
    
    	/**
    	 * java8去重
    	 * 
    	 * @param datas
    	 * @return
    	 */
    	public static List<Object> getNoDuplicate4(List<String> datas) {
    		List<Object> res = datas.stream().distinct().collect(Collectors.toList());
    		return res;
    	}
    
    	/**
    	 * 对象去重
    	 * @param users
    	 * @return
    	 */
    	public static ArrayList<User> removeDuplicateUser(List<User> users) {
    		Set<User> personSet = new TreeSet<User>(new Comparator<User>() {
    			public int compare(User o1, User o2) {
    				return o1.getUserName().compareTo(o2.getUserName());
    			}
    		});
    		personSet.addAll(users);
    		return new ArrayList<User>(personSet);
    	}
    	
    	/**
         * 双重for循环对对象去重
         * @param users
         * @return
         */
        public static List<User> removeDuplicateRecr(List<User> users) {
            List<User> res = users;
            for (int i = 0; i < users.size()-1; i++) {
                for (int j = users.size()-1; j > i; j--) {
                    if (users.get(j).getId() == users.get(i).getId()) {
                        users.remove(j);
                    }
                }
            }
            return res;
        }
        
    	/**
         * 利用set不能重复的特性进行去重操作
         * @param datas
         * @return
         */
        public static List<User> removeDupObjElementBySet(List<User> datas) {
            Set<String> targets = new HashSet<String>();
            List<User> res = new ArrayList<User>();
            for (Usersingle : datas) {
                if (targets.add(single.getId())) {  //如果可以加进去，说明没有重复
                    targets.add(single.getId());
                    res.add(single);
                }
                continue;
            }
            return res;
        }
    
    	/**
         * 利用对象的hashCode码不相同进行去重
         * @param datas
         * @return
         */
        public static List<User> removeDupObjElementByHash(List<User> datas) {
            Set<Integer> targets = new HashSet<Integer>();
            List<User> res = new ArrayList<User>();
            for (Usersingle : datas) {
                if (targets.add(single.hashCode())) {  //如果可以加进去，说明没有重复
                    targets.add(single.hashCode());
                    res.add(single);
                }
                continue;
            }
            return res;
        }
    
    	/**
    	 * 对象去重,java8写法
    	 * @param persons
    	 * @return
    	 */
    	public static List<User> removeDupliByName(List<User> persons) {
            Set<User> personSet = new TreeSet<User>((o1, o2) -> o1.getUserName().compareTo(o2.getUserName()));
            personSet.addAll(persons);
            return new ArrayList<User>(personSet);
        }
    
    	
    	/**
    	 * 对象去重
    	 * @param persons
    	 * @return
    	 */
    	public static List<User> removeDupliByName2(List<User> persons) {
    		List<User> personList = new ArrayList<>();
    		persons.stream().forEach(p -> {
    			if (!personList.contains(p)) {
                    personList.add(p);
                }
    		});
    		System.out.println(personList);
    		return personList;
        }
    	
    	/**
         * 利用反射并通过获取属性和属性值的md5进行去重
         * @param datas
         * @return
         */
        public static List<MdManageTree> removeDupElementByMd5(List<MdManageTree> datas){
            Set<String> tems = new HashSet<>();
            List<MdManageTree> resList = new ArrayList<>();
            for(MdManageTree single : datas){
                String elePropertyNameAndValue = reflectObject(single);
                if(tems.add(strToMd5(elePropertyNameAndValue))){    //如果可以加进去，说明没有重复
                    tems.add(strToMd5(elePropertyNameAndValue));
                    resList.add(single);
                }
                continue;
            }
            return resList;
        }
    
        /**
         * 获取字符串md5
         * @param str
         * @return
         */
        public static String strToMd5(String str)  {
            MessageDigest md5 = null;
            try {
                md5 = MessageDigest.getInstance("MD5");
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
                logger.error("获取MD5对象失败");
            }
            try {
                md5.update((str).getBytes("UTF-8"));
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
                logger.error("MD5转换字节数组失败");
            }
            byte b[] = md5.digest();
            int i;
            StringBuffer buf = new StringBuffer("");
            for(int offset=0; offset<b.length; offset++){
                i = b[offset];
                if(i<0){
                    i+=256;
                }
                if(i<16){
                    buf.append("0");
                }
                buf.append(Integer.toHexString(i));
            }
            return buf.toString();
        }
    
        /**
         * java反射获取对象的属性值不为空的字符串拼接值
         * @param obj
         * @return
         * @throws Exception
         */
        public static String reflectObject(Object obj) {
            Field[] field = obj.getClass().getDeclaredFields();
            String result = "" ;
            try{
                for (int j = 0; j < field.length; j++) {
                    String name = field[j].getName();
                    name = name.substring(0, 1).toUpperCase() + name.substring(1);
                    Method m = obj.getClass().getMethod("get" + name);
                    String value = (String) m.invoke(obj);
                    if (value != null) {
                        result += name + value;
                    } else {
                        continue;
                    }
                }
            }catch (Exception e){
                e.printStackTrace();
            }
            return result.trim();
        }
    	
    	public static void main(String[] args) {
    		List<String> nodes = new ArrayList<String>();
    		nodes.add("zhangsan");
    		nodes.add("lisi");
    		nodes.add("wangwu");
    		nodes.add("zhaoliu");
    		nodes.add("lisi");
    		
    		List<User> res = new ArrayList<User>();
    		User user1 = new User();
    		user1.setUserId(1);
    		user1.setUserName("zhangsan");
    		user1.setPassWord("456");
    		res.add(user1);
    		
    		User user2 = new User();
    		user2.setUserId(2);
    		user2.setUserName("lisi");
    		user2.setPassWord("345");
    		res.add(user2);
    		
    		User user3 = new User();
    		user3.setUserId(3);
    		user3.setUserName("wangwu");
    		user3.setPassWord("778");
    		res.add(user3);
    		
    		User user4 = new User();
    		user4.setUserId(1);
    		user4.setUserName("zhangsan");
    		user4.setPassWord("456");
    		res.add(user4);
    		
    		
    		//System.out.println(getNoDuplicate1(nodes));
    		//System.out.println(getNoDuplicate2(nodes));
    		//System.out.println(getNoDuplicate3(nodes));
    		//System.out.println(getNoDuplicate4(nodes));
    		
    		//System.out.println(removeDuplicateUser(res));
    		System.out.println(removeDupliByName2(res));
    		
    	}

user对象为:

private long userId;
    	private String userName;
    	private String passWord;
    	
    	
    	public long getUserId() {
    		return userId;
    	}
    	public void setUserId(long userId) {
    		this.userId = userId;
    	}
    	public String getUserName() {
    		return userName;
    	}
    	public void setUserName(String userName) {
    		this.userName = userName;
    	}
    	public String getPassWord() {
    		return passWord;
    	}
    	public void setPassWord(String passWord) {
    		this.passWord = passWord;
    	}
    	
    	@Override
    	public boolean equals(Object o) {
    		if(this == o)return true;
    		if (o == null || getClass() != o.getClass()) return false;
    		User user = (User) o;
    		return Objects.equals(userName, user.getUserName()) && Objects.equals(passWord, user.getPassWord());
    				
    						
    	}
    	@Override
    	public String toString() {
    		return "User [userId=" + userId + ", userName=" + userName + ", passWord=" + passWord + "]";
    	}

实际使用中，equals方法可以根据自己需要重新定义；

可以作为工具类直接使用，已经经过测试了，可放心使用。