list排序,list去重

其他 2019-03-04 23:16:34 阅读次数: 0
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/ck3345143/article/details/72550945

List去重/排序的通用方法


 

package com.ck.test.util;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.text.Collator;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;

/**
 * List去重/排序的通用方法
 * 
 * @author CK
 * 
 * @param <T> T对象
 */
public class ListSort<T> {
	/**
	 * 
	 * @param list对象 要排序的集合
	 * @param method 要排序的实体的属性所对应的get方法
	 * @param sort desc 倒序、asc升序、""为原样  
	 */
	public void Sort(List<T> list, final String method, final String sort) {
		// 用内部类实现排序
		Collections.sort(list, new Comparator<T>() {

			public int compare(T a, T b) {
				int ret = 0;
				try {
					// 获取m1的方法名
					Method m1 = a.getClass().getMethod(method, null);
					// 获取m2的方法名
					Method m2 = b.getClass().getMethod(method, null);
					
					if(sort != null && "desc".equals(sort)) {
						ret = m2.invoke(((T)b), null).toString().compareTo(m1.invoke(((T)a),null).toString());
					} else {
						// 正序排序
						ret = m1.invoke(((T)a), null).toString().compareTo(m2.invoke(((T)b), null).toString());
					}
				} catch (NoSuchMethodException ne) {
					System.out.println(ne);
				} catch (IllegalArgumentException e) {
					e.printStackTrace();
				} catch (IllegalAccessException e) {
					e.printStackTrace();
				} catch (InvocationTargetException e) {
					e.printStackTrace();
				}
				return ret;
			}
		});
	}
	
	/**
	 * 重复的选中其一以及其他不重复的对象保留，并进行排序
	 * @param list 要处理的list对象
	 * @param method 排序对象字段的getxxx()方法名，即getxxx
	 * @param sort  desc/DESC 倒序、asc/ASC升序、""为原样  
	 * @return
	 */
	public List<T> sortObjDistinctList(List<T> list, final String method, final String sort) {
		List<T> listWithoutDup = null;
		
		listWithoutDup = distinctListValue(list);
		
		if(sort != null && ("desc".equals(sort) || "DESC".equals(sort) || "ASC".equals(sort) || "asc".equals(sort))) {
			// 排序
			Sort(listWithoutDup, method, sort);
		} else {
			return listWithoutDup;
		}
		
		return listWithoutDup;
	}
	
	/**
	 * 去重，返回重复的数据
	 * @param list
	 * @return
	 */
	public List<T> sortDistinct2Other(List<T> list) {
		// 重复数据
		List<T> list2 = new ArrayList<>();
		
		// 使用hashset去重复，set为重复的集合，可以通过new ArrayList(set)转换成list
		HashSet<T> set = new HashSet<>();
		// 去掉重复的值，只保留其他不重复的对象
		for (T t : list) {
			boolean add = set.add(t);
			if (!add) {
				list2.add(t);
			}
		}
		return list2;
	}
	/**
	 * 除重  去掉重复的值,并保留重复值中一个值及其他不重复的值
	 * @param list 处理list
	 * @return 
	 */
	public List<T> distinctListValue(List<T> list) {
		List<T> listWithoutDup = new ArrayList<T>(new HashSet<T>(list));
		return listWithoutDup;
	}
	/**
	 * 
	 * @param list 处理list
	 * @param sort desc/DESC 倒序、asc/ASC升序、""为原样  
	 * @param flag true-除重；false-不除重
	 * @return
	 */
	public List<T> distinctListASCorDesc(List<T> list, final String sort, boolean flag) {
		
		List<T> listWithoutDup = null;
		if(flag) {
			listWithoutDup = distinctListValue(list);
		} else {
			 listWithoutDup = list;
		}
		
		if(sort != null && ("ASC".equals(sort) || "asc".equals(sort))) {
			// 升序
			Collections.sort(listWithoutDup,Collator.getInstance(java.util.Locale.CHINA));//注意：是根据的汉字的拼音的字母排序的，而不是根据汉字一般的排序方法
		} else if(sort != null && ("desc".equals(sort) || "DESC".equals(sort))) {
			// 降序
			Collections.reverse(listWithoutDup);//不指定排序规则时，也是按照字母的来排序的
		} else {
			return listWithoutDup;
		}
		return listWithoutDup;
	}
}

package com.ck.test.modal;

/**
 * 这里id，name,age相同则Student相同，
 * 若有其他相同
 * @author Administrator
 *
 */
public class Student {
	int id;
    String name;
    int age;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	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() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + id;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (age != other.age)
			return false;
		if (id != other.id)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	public Student(int id, String name, int age) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "(" + id + ", " + name + ", " + age + ")";
//		return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
	}
    
	
}



package com.ck.test;

import java.text.Collator;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;

import org.junit.Assert;
import org.junit.Test;

import com.ck.test.modal.Student;
import com.ck.test.util.ListSort;

/*
 * 对list去重
 * 
 */
public class TestList {

	//去除set中重复数据的方法
	private static Set<Student> removeDuplicate(Set<Student> set) {
	    Map<String, Student> map = new HashMap<String, Student>();
	    Set<Student> tempSet = new HashSet<Student>();
	         for(Student p : set) {
	              if(map.get(p.getName()) == null ) {
	                   map.put(p.getName(), p);                        
	              } else {
	                   tempSet.add(p);
	              }
	          }
	    set.removeAll(tempSet);
	    return set;
	}
	
	public static String outCollection(Collection coll) { 
        StringBuffer sb = new StringBuffer(); 
        for (Object obj : coll) { 
            sb.append(obj + "," ); 
        }
        System.out.println(sb.toString()); 
        return sb.toString(); 
    } 
	
	/*
	 * 对list去重 list with dup:[1, 2, 3, 1] list without dup:[3, 2, 1]
	 */
	@Test
	public void distinctListValue() {
		List<String> listWithDup = new ArrayList<String>();
		listWithDup.add("1");
		listWithDup.add("2");
		listWithDup.add("4");
		listWithDup.add("3");
		listWithDup.add("1");

		List<String> listWithoutDup = new ArrayList<String>(new HashSet<String>(listWithDup));
		System.out.println("list with dup:" + listWithDup);
		System.out.println("list without dup:" + listWithoutDup);
		System.out.println("list去重后(去掉重复的值,并保留重复值中一个值及其他不重复的值/排序) :\n" + (new ListSort<String>()).distinctListValue(listWithDup));
		
		Collections.sort(listWithoutDup);
		 Collections.reverse(listWithoutDup);  //按照age降序 23,22   
		System.out.println(listWithoutDup);
	}
	
	@Test
	public void test2() {
		List<String> list = new ArrayList();
		list.add("王硕");
		list.add("刘媛媛");
		list.add("李明1");
		list.add("李明2");
		list.add("李明");
		list.add("刘迪");
		list.add("刘布2");
		list.add("李明");
		list.add("刘布8");
		list.add("刘布");
		list.add("刘布");
		list.add("3");
		list.add("4");
		list.add("4");
		list.add("2");
		list.add("4");
		list.add("1");
		
		System.out.println((new ListSort<String>()).distinctListValue(list));
		for(int i=0;i<list.size();i++) {
			System.out.print(list.get(i) +",");
		}
		System.out.println("");
		//升序
		Collections.sort(list,Collator.getInstance(java.util.Locale.CHINA));//注意：是根据的汉字的拼音的字母排序的，而不是根据汉字一般的排序方法
		for(int i=0;i<list.size();i++) {
		    System.out.print(list.get(i) +",");
		}
		System.out.println("");

		//降序
		Collections.reverse(list);//不指定排序规则时，也是按照字母的来排序的
		for(int i=0;i<list.size();i++) {
		     System.out.print(list.get(i) +",");
		}
	}

	/**
	 * 取出list中重复的Student对象
	 */
	@Test
	public void ObtainListEquals() {
		// 原始数据
		List<Student> list = new ArrayList<>();
		// 重复数据
		List<Student> list2 = new ArrayList<>();

		// 填充
		for (int i = 0; i < 10; i++) {
			list.add(new Student(i, "_" + i, 18 + i));
			Random random = new Random();
			if (random.nextBoolean()) {
				list.add(new Student(i, "_" + i, 18 + i));
			}
		}

		// 使用hashset去重复，set为重复的集合，可以通过new ArrayList(set)转换成list
		HashSet<Student> set = new HashSet<>();
		
		// 去掉重复的值，只保留其他不重复的对象
		for (Student student : list) {
			boolean add = set.add(student);
			if (!add) {
				list2.add(student);
			}
		}

		List<Student> listWithoutDup = new ArrayList<Student>(new HashSet<Student>(list));
		System.out.println("list初始化:\n" + list);
		System.out.println("list去重后(重复的对象):\n" + list2);
		System.out.println("list去重后(去掉重复的值,并保留重复值中一个值及其他不重复的值):\n" + listWithoutDup);
		
		System.out.println("list去重后(去掉重复的值,并保留重复值中一个值及其他不重复的值/排序) :\n" + (new ListSort<Student>()).sortObjDistinctList(list, "getId", "desc"));
		ListSort<Student> listSort= new ListSort<Student>();  
		// 排序
        listSort.Sort(listWithoutDup, "getId", "");
//        listSort.Sort(listWithoutDup, "getId", "");
        
        System.out.println("list去重后(去掉重复的值,并保留重复值中一个值及其他不重复的值) 排序:\n" + listWithoutDup);
        
		Set<Student> set2 = new HashSet<Student>(list);
		System.out.println("list without dup:" + removeDuplicate(set2));
		// 比较
		Assert.assertEquals(list.size(), list2.size() + set.size());
	}
}



结果：
[刘布2, 刘布8, 刘媛媛, 王硕, 3, 2, 1, 4, 刘布, 李明, 刘迪, 李明1, 李明2]
王硕,刘媛媛,李明1,李明2,李明,刘迪,刘布2,李明,刘布8,刘布,刘布,3,4,4,2,4,1,
1,2,3,4,4,4,李明,李明,李明1,李明2,刘布,刘布,刘布2,刘布8,刘迪,刘媛媛,王硕,
王硕,刘媛媛,刘迪,刘布8,刘布2,刘布,刘布,李明2,李明1,李明,李明,4,4,4,3,2,1,list初始化:
[(0, _0, 18), (1, _1, 19), (1, _1, 19), (2, _2, 20), (3, _3, 21), (4, _4, 22), (4, _4, 22), (5, _5, 23), (5, _5, 23), (6, _6, 24), (6, _6, 24), (7, _7, 25), (7, _7, 25), (8, _8, 26), (9, _9, 27), (9, _9, 27)]
list去重后(重复的对象):
[(1, _1, 19), (4, _4, 22), (5, _5, 23), (6, _6, 24), (7, _7, 25), (9, _9, 27)]
list去重后(去掉重复的值,并保留重复值中一个值及其他不重复的值):
[(9, _9, 27), (3, _3, 21), (2, _2, 20), (8, _8, 26), (0, _0, 18), (5, _5, 23), (7, _7, 25), (1, _1, 19), (6, _6, 24), (4, _4, 22)]
list去重后(去掉重复的值,并保留重复值中一个值及其他不重复的值/排序) :
[(9, _9, 27), (8, _8, 26), (7, _7, 25), (6, _6, 24), (5, _5, 23), (4, _4, 22), (3, _3, 21), (2, _2, 20), (1, _1, 19), (0, _0, 18)]
list去重后(去掉重复的值,并保留重复值中一个值及其他不重复的值) 排序:
[(0, _0, 18), (1, _1, 19), (2, _2, 20), (3, _3, 21), (4, _4, 22), (5, _5, 23), (6, _6, 24), (7, _7, 25), (8, _8, 26), (9, _9, 27)]
list without dup:[(9, _9, 27), (3, _3, 21), (2, _2, 20), (8, _8, 26), (0, _0, 18), (5, _5, 23), (7, _7, 25), (1, _1, 19), (6, _6, 24), (4, _4, 22)]
list with dup:[1, 2, 4, 3, 1]
list without dup:[3, 2, 1, 4]
list去重后(去掉重复的值,并保留重复值中一个值及其他不重复的值/排序) :
[3, 2, 1, 4]
[4, 3, 2, 1]


猜你喜欢

转载自blog.csdn.net/ck3345143/article/details/72550945
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
Java自定义时间格式
同步整形电路
在开发中最最最常用的字符串的属性大集合
Linux 查看端口占用并杀掉
Java基础四：ArrayList
多线程之死锁就是这么简单
mysql 基础命令集
awk 命令详解
Centos6.3编译安装nginx+php步骤
OCR （Optical Character Recognition，光学字符识别）
每日归档
更多
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022