List集合排序

最新推荐文章于 2023-10-23 10:37:40 发布
最新推荐文章于 2023-10-23 10:37:40 发布
阅读量752 收藏 1
点赞数 1
文章标签： java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44191359/article/details/106476692
版权
  • Collections.sort(集合)排序
	/*直接按值的大小排序*/
	public static void main(String[] args) {
		List<Integer> nums = new ArrayList<Integer>();
		nums.add(100);
		nums.add(8);
		nums.add(6);
		nums.add(10);
		System.out.println("排序前："+nums);
		Collections.sort(nums);
		System.out.println("排序后："+nums);
	}

输出为：
排序前：[100, 8, 6, 10]
排序后：[6, 8, 10, 100]

  • List<Map<String, Object>>某个key值的大小排序
	public static void main(String[] args) {
		List<Map<String, Object>> arrayList2 = new ArrayList<Map<String, Object>>();
		Map<String, Object> map1 = new HashMap<String, Object>();
		Map<String, Object> map2 = new HashMap<String, Object>();
		Map<String, Object> map3 = new HashMap<String, Object>();
		map1.put("aa", -1.1);
		map2.put("aa", 2.2);
		map3.put("aa", -3.2);
		map1.put("bb", -10);
		map2.put("bb", 2);
		map3.put("bb", -6.6);
		arrayList2.add(map1);
		arrayList2.add(map2);
		arrayList2.add(map3);
		sortTableDataByKeyName(arrayList2,"bb");
		for(int a = 0 ; a<arrayList2.size();a++) {
			System.out.println("aa:"+arrayList2.get(a).get("aa")+" bb:"+arrayList2.get(a).get("bb"));
		}
	}
	public static void sortTableDataByKeyName(List<Map<String,Object>> marketUnitList,final String KeyName){
		Collections.sort(marketUnitList,new Comparator<Map<String,Object>>(){
			@Override
			public int compare(Map<String, Object> o1,Map<String, Object> o2) {
				if(!"".equals(o1.get(KeyName)) && "".equals(o2.get(KeyName))){
					return 0;
				}else if("".equals(o1.get(KeyName)) && !"".equals(o2.get(KeyName))){
					return 0;
				}else if("".equals(o1.get(KeyName)) && "".equals(o2.get(KeyName))){
					return 0;
				}else{
					BigDecimal o1B = new BigDecimal(o1.get(KeyName).toString());
					BigDecimal o2B = new BigDecimal(o2.get(KeyName).toString());
					
					Double o1I = o1B.doubleValue();
					Double o2I = o2B.doubleValue();
					return o2I.compareTo(o1I);
				}
			}
		});
	}

输出为：
aa:2.2 bb:2
aa:-3.2 bb:-6.6
aa:-1.1 bb:-10

  • List<Map<String, Object>>中某个key值的绝对值排序
	public static void main(String[] args) {
			List<Map<String, Object>> arrayList1 = new ArrayList<Map<String, Object>>();
			List<Map<String, Object>> arrayList2 = new ArrayList<Map<String, Object>>();
			Map<String, Object> map1 = new HashMap<String, Object>();
			Map<String, Object> map2 = new HashMap<String, Object>();
			Map<String, Object> map3 = new HashMap<String, Object>();
			map1.put("aa", -1.1);
			map2.put("aa", 2.2);
			map3.put("aa", -3.342);
			map1.put("bb", -10.909);
			map2.put("bb", 9.22);
			map3.put("bb", -60.6789);
			arrayList1.add(map1);
			arrayList1.add(map2);
			arrayList1.add(map3);
			for(int a= 0 ; a<arrayList1.size();a++) {
				Map<String, Object> map = new HashMap<String, Object>();
				map.put("aa", arrayList1.get(a).get("aa"));
					if(arrayList1.get(a).get("bb")==null){
						map.put("bb",arrayList1.get(a).get("bb"));
					}else {
						map.put("bb", Double.valueOf(arrayList1.get(a).get("bb").toString()));
					}
				arrayList2.add(map);
			}
			
			sortTableDataByKeyName(arrayList1,"bb");
			for(int a = 0 ; a<arrayList1.size();a++) {
				System.out.println("aa:"+arrayList1.get(a).get("aa")+" bb:"+arrayList1.get(a).get("bb"));
			}
		}
		public static void sortTableDataByKeyName(List<Map<String,Object>> marketUnitList,final String KeyName){
			Collections.sort(marketUnitList,new Comparator<Map<String,Object>>(){
				@Override
				public int compare(Map<String, Object> o1,Map<String, Object> o2) {
					if(o1.get(KeyName)==null||o2.get(KeyName)==null) {
						return -1;
					}
						if(!"".equals(o1.get(KeyName)) && "".equals(o2.get(KeyName))){
							return 0;
						}else if("".equals(o1.get(KeyName)) && !"".equals(o2.get(KeyName))){
							return 0;
						}else if("".equals(o1.get(KeyName)) && "".equals(o2.get(KeyName))){
							return 0;
						}else{
							BigDecimal o1B = new BigDecimal(o1.get(KeyName).toString());
							BigDecimal o2B = new BigDecimal(o2.get(KeyName).toString());
							Double o1I = Math.abs(o1B.doubleValue());
							Double o2I = Math.abs(o2B.doubleValue());
							return o2I.compareTo(o1I);
						}
					}
			});
		}

输出为：
aa:-3.342 bb:-60.6789
aa:-1.1 bb:-10.909
aa:2.2 bb:9.22

  • 单属性list，自定义顺序排序
public static void main(String[] args) {
		List<String> list = Arrays.asList("北京","上海","广州","北京","广州");
		List<String> sortRule = Arrays.asList("北京","上海","广州");
		System.out.println("原始数据："+list);
		System.out.println("排序规则："+sortRule);
		Collections.sort(list,new Comparator<String>() {
			@Override
			public int compare(String o1, String o2) {
				int a1 = sortRule.indexOf(o1);
				int a2 = sortRule.indexOf(o2);
				return a1-a2;
			}
		});
		System.out.println("正序排列："+list);
		Collections.sort(list,new Comparator<String>(){
			@Override
			public int compare(String o1, String o2) {
				int a1 = sortRule.indexOf(o1);
				int a2 = sortRule.indexOf(o2);
				return a2 - a1 ;
			}
		});
		System.out.println("倒序排列："+list);
	}

输出为：
原始数据：[北京, 上海, 广州, 北京, 广州]
排序规则：[北京, 上海, 广州]
正序排列：[北京, 北京, 上海, 广州, 广州]
倒序排列：[广州, 广州, 上海, 北京, 北京]

  • 对象自定义多属性的顺序排序
public static void main(String[] args) {
		List<Stu> stu = new ArrayList<>();
		stu.add(new Stu("二逗",60,173,"浙大","北京"));
		stu.add(new Stu("小豆",65,176,"郑大","郑州"));
		stu.add(new Stu("二逗",63,174,"武大","上海"));
		stu.add(new Stu("大豆",66,183,"北大","郑州"));
		stu.add(new Stu("小豆",56,178,"交大","上海"));
		stu.add(new Stu("小豆",58,175,"交大","上海"));
		System.out.println("原始数据：");
		for (Stu s : stu) {
			System.out.println(s.getName()+" "+s.getWeight()+" "+s.getHeight()+" "+s.getSchool()+" "+s.getAddress());
		}
		System.out.println("先按照（大豆 二逗 小豆）排序，当名称相同时按照（北京 上海 郑州）排序，当名称和地区都相同时按照身高降序排序：");
		List<String> nameOrder = Arrays.asList("大豆","二逗","小豆");
		List<String> addressOrder = Arrays.asList("北京","上海","郑州");
		Collections.sort(stu,new Comparator<Stu>() {
			@Override
			public int compare(Stu stu1, Stu stu2) {
				if(stu1.getName().equals(stu2.getName())) {
					if(stu1.getAddress().equals(stu2.getAddress())){
						return stu2.getHeight()-stu2.getHeight();
					}else {
						int a1 = addressOrder.indexOf(stu1.getAddress());
						int a2 = addressOrder.indexOf(stu2.getAddress());
						return a1 - a2;
					}
				}else {
					int a1 = nameOrder.indexOf(stu1.getName());
					int a2 = nameOrder.indexOf(stu2.getName());
					return a1 - a2;
				}
			}
		});
		for (Stu s : stu) {
			System.out.println(s.getName()+" "+s.getWeight()+" "+s.getHeight()+" "+s.getSchool()+" "+s.getAddress());
		}
	}

输出为：
原始数据：
二逗 60 173 浙大 北京
小豆 65 176 郑大 郑州
二逗 63 174 武大 上海
大豆 66 183北大 郑州
小豆 56 178 交大 上海
小豆 58 175 交大 上海
先按照（大豆 二逗 小豆）排序，当名称相同时按照（北京 上海 郑州）排序，当名称和地区都相同时按照身高降序排序：
大豆 66 183 北大 郑州
二逗 60 173 浙大 北京
二逗 63 174 武大 上海
小豆 56 178 交大 上海
小豆 58 175 交大 上海
小豆 65 176 郑大 郑州

二逗哇
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java中进行集合排序
10-13
java中按找对象的某个属性进行升序降序的排序
选择排序 介绍与java实现
Rosen's
09-27 105
排序是程序编码避不开的一个话题。 一组无规则有序数据，排序的方式有很多中，其中最笨的方法就是穷举，也就是全排列排序。n个数字的有n！种不同的排列方法，如果50个无规则数据进行全排列进行排序，及时一台高性能计算机，每秒计算1万亿 （ 10^12 ） 次，也需要超过 10^20 年。 那么选择排序又能快多少呢？ 选择排序需要依次从剩余无规则数据组合中取出最大（小）的数值，放置到新的队列中的即为有序的数列了。计算次数要比全排列排序少得多。 50个数字排序，50^2 = 2500 ，对于一台高性能计算机而言，
collections集合操作排序,Java8 stream集合操作
路漫漫其修远兮，吾将上下而求索！
04-04 5034
/** * */ package com.wen; import java.math.BigDecimal; /** * @author wencun * @date 2018年2月22日 上午9:49:37 * @version 1.0 * @since JDK 1.8 */ public class Staff { private String name; ...
Stream的排序
weixin_30345055的博客
07-27 770
1、list<Integer>的正序 List<Integer> list = new ArrayList<>();list.add(50);list.add(45);list.add(25);list.add(98);list.add(32);List<Integer> collect = list.stream().sorted().col...
BigDecimal的最大值，最小值，中位数，排序操作
weixin_43588364的博客
05-01 9915
BigDecimal的最大值，最小值，中位数，排序操作 由于使用double数组对数据进行操作会引起精度损失，所以使用BigDecimal 进行计算 package com.test.annotation.test.test; import java.math.BigDecimal; import java.util.ArrayList; import java.util.Collection...
java8-List的常用方法
小小小猿
04-27 3115
一、填充字段处理 需求描述：在插入数据的时候自动填充createTime和updateTime为当前插入数据的时间，在数据更新的时候修改updateTime为修改数据的时间。不需要人为的手动赋值。 创建数据库表， CREATE TABLE `user` ( `id` bigint(20) NOT NULL COMMENT '主键ID', `name` varchar(30) DEFAULT NULL COMMENT '姓名', `age` int(11) DEFAULT NULL COMMEN...
list集合根据某一字段数值排序
黑·白·灰
08-26 1669
//设置一个类，实现Comparator接口 public class SortArrayListUtil implements Comparator{     //改写compare方法     public int compare(Object o1, Object o2) {         CustInvestmentBean c1 = (CustInvestmentBean)
对List中根据对象的某一属性进行排序
xiao_chainiao的博客
09-09 625
// 如果标位类型为利率利差，申购标位升序 Collections.sort(instructionsRateSpread, new Comparator<VQtwPmBondInstruction>() { @Override public int compare(VQtwPmBondInstruction o1, VQtwPmBondInstruction o2) { if(new BigDec.
List按照指定字段排序工具类
再试下的博客
07-13 345
<pre style="font-family: 宋体; font-size: 13.5pt; background-color: rgb(255, 255, 255);"><pre name="code" class="java">import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.math.BigDecimal; import
Java之List系列--排序的方法
IT利刃出鞘的博客
05-19 3225
本文用示例介绍Java的ArrayList排序的方法。
List集合排序222222
01-24
导入jar 包 调用 String[] arr1 = new String[1]; ... 参数1 排序的集合 参数2 排序的字段(与定义字段一致) 可多个 参数3 排序方式(asc desc) 暂时只支持String 和int的排序 可能有些BUG 敬请谅解
Java8 用Lambda表达式给List集合排序的实现
08-25
主要介绍了Java8 用Lambda表达式给List集合排序的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java List集合排序实现方法解析
08-25
主要介绍了Java List集合排序实现方法解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java list集合排序按某一属性排序操作
08-24
主要介绍了java list集合排序按某一属性排序操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Java使用Collections工具类对List集合进行排序
08-25
主要介绍了Java使用Collections工具类对List集合进行排序,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java List集合排序
cdc的博客
03-16 489
使用Collections.sort进行排序 import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; public class SetSortTools { public static List<BluetoothDevice> getListBluetoothDevice(){ List<Blueto
List集合中的相邻元素是否满足升序排列
最新发布
SUMMERENT的博客
10-23 269
1. 使用IntStream.range()方法创建一个从0到list.size()-1的整数范围，表示需要比较的相邻元素的下标。4. 在lambda表达式中，使用list.get()方法获取相邻元素的值，并使用compareTo()方法进行比较。//如果所有相邻元素都满足升序排列（不包括等值），则返回true，否则返回false。// 如果所有相邻元素都满足降序排列（不包括等值），则返回true，否则返回false。5. 如果所有相邻元素都满足升序排列，则返回true，否则返回false。
List集合排序及去重
qq_41306129的博客
04-24 3895
Comparable 简介 Comparable 是排序接口。 若一个类实现了Comparable接口，就意味着“该类支持排序”。此外，“实现Comparable接口的类的对象”可以用作“有序映射(如TreeMap)”中的键或“有序集合(TreeSet)”中的元素，而不需要指定比较器。 接口中通过x.compareTo(y)来比较x和y的大小。若返回负数，意味着x比y小；返回零，意味着x等于y；返回正数，意味着x大于y。 Comparator 简介 Comparator 是比较器接口。我们若需要控制某个类
list内对象按照指定字段排序
lw305080的博客
10-29 1039
Java list 对象按照指定字段排序
list集合排序
05-29
可以使用Python中的`sorted()`函数对列表进行排序，也可以使用列表自带的`sort()`方法。 例如，对一个包含整数的列表进行从小到大排序： ``` python my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5] # 使用sorted()函数进行排序 sorted_list = sorted(my_list) print(sorted_list) # 使用sort()方法进行排序 my_list.sort() print(my_list) ``` 输出： ``` [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9] [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9] ``` 如果要进行从大到小的排序，可以使用`reverse=True`参数： ``` python my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5] # 使用sorted()函数进行排序 sorted_list = sorted(my_list, reverse=True) print(sorted_list) # 使用sort()方法进行排序 my_list.sort(reverse=True) print(my_list) ``` 输出： ``` [9, 6, 5, 5, 5, 4, 3, 3, 2, 1, 1] [9, 6, 5, 5, 5, 4, 3, 3, 2, 1, 1] ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值