java order()_java8 排序 orderBy

最新推荐文章于 2022-12-30 11:28:55 发布
最新推荐文章于 2022-12-30 11:28:55 发布
阅读量2.1k 收藏
点赞数
文章标签： java order()
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_35545176/article/details/114051323
版权

package com.icil.report.utils;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

import java.util.Collection;

import java.util.Comparator;

import java.util.Date;

import java.util.List;

import java.util.Map;

import java.util.Optional;

import java.util.stream.Collectors;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;/**

* *************************************************************************

* 

 
 
* @param 
 
 
* @ClassName: : ListUtil
 
 
*
 
 
* @Description: :
 
 
*
 
 
* @Creation Date : 13 May 2019 2:48:52 PM
 
 
*
 
 
* @Author : Sea
 
 
*
 
 
*
 
 
* 
 
 
***************************************************************************/@SuppressWarnings("all")public classOrderByUtils{private static Logger LOGGER=LoggerFactory.getLogger(OrderByUtils.class);//#######################################################################################################//order by java 7 && java8//######################################################################################################
 
 
/**
 
 
* @Desc: java8 parallelStream
 
 
* @param colls :需要排序的集合(pojo)
 
 
* @param firstfiledName :先按排序的字段
 
 
* @param secondfiledName ：:再按排序的字段
 
 
* @return*/
 
 
//public static List orderby(Collection colls,String firstfiledName,String secondfiledName){//return colls.parallelStream().sorted(Comparator.comparing(d->getFieldStringValueByName(d,firstfiledName)).thenComparing(d->getFieldStringValueByName(d,secondfiledName))).collect(Collectors.toList());//}
 
 
/**
 
 
* @Desc: java8 parallelStream
 
 
* @param colls
 
 
* @param filedName 排序的字段
 
 
* @param fieldType 排序的字段的类型
 
 
* @return*/
 
 
public static List orderbyPro(Collectioncolls,String filedName,Class fieldType){switch(fieldType.getName()) {case "java.lang.Integer":return colls.parallelStream().sorted(Comparator.comparing(d->(Integer)getFieldValueByName(d,filedName))).collect(Collectors.toList());case "java.lang.Long":return colls.parallelStream().sorted(Comparator.comparing(d->(Long)getFieldValueByName(d,filedName))).collect(Collectors.toList());case "java.lang.Double":return colls.parallelStream().sorted(Comparator.comparing(d->(Double)getFieldValueByName(d,filedName))).collect(Collectors.toList());case "java.util.Date":return colls.parallelStream().sorted(Comparator.comparing(d->(Date)getFieldValueByName(d,filedName))).collect(Collectors.toList());case "java.lang.Float":return colls.parallelStream().sorted(Comparator.comparing(d->(Float)getFieldValueByName(d,filedName))).collect(Collectors.toList());case "java.lang.String":return colls.parallelStream().sorted(Comparator.comparing(d->(String)getFieldStringValueByName(d,filedName))).collect(Collectors.toList());default:return null;
 
 
}
 
 
}/**
 
 
*
 
 
* @param colls
 
 
* @param filedName :pojo 的属性名 如 user -->name
 
 
* @return*/
 
 
public static List orderby(Listcolls, String filedName,Class fieldType){
 
 
getMyComparator(colls,filedName,fieldType);
 
 
colls.sort(getMyComparator(colls,filedName,fieldType));returncolls;
 
 
}/**
 
 
* 通过属性名称对集合分组
 
 
* @Desc:java 8 stream api, list 会过滤掉group by filed 的非空字段
 
 
* @param colls 集合必须为对象 eg: List
 
 
* @param fieldName为集合中对象的属性名称 eg: Employee-->name
 
 
* @return
 
 
* extends Comparable*/
 
 
public static final Map> groupByPro(Collectioncolls ,String fieldName){//filter//List filterlist = colls.parallelStream().filter(r->getFieldValueByName(r,fieldName)!=null).collect(Collectors.toList());
 
 
for(D d : colls) {if(OrderByUtils.getFieldValueByName(d, fieldName)==null){
 
 
OrderByUtils.setFieldValueByName(d, fieldName,"null");
 
 
}
 
 
}//group by
 
 
Map> collect = colls.stream().collect(Collectors.groupingBy(r->getFieldValueByName(r,fieldName)));returncollect;
 
 
}/**
 
 
* 根据属性名称获取属性值
 
 
**/
 
 
public staticObject getFieldValueByName(Object pojo,String fieldName) {try{
 
 
String firstLetter= fieldName.substring(0, 1).toUpperCase();
 
 
String getter= "get" + firstLetter + fieldName.substring(1);
 
 
Method method= pojo.getClass().getMethod(getter, newClass[] {});
 
 
Object value= method.invoke(pojo, newObject[] {});returnvalue;
 
 
}catch(Exception e) {
 
 
LOGGER.error(e.getMessage(),e);return null;
 
 
}
 
 
}/**
 
 
*
 
 
* @param pojo
 
 
* @param fieldName
 
 
* @param value just can be Integer(int) Double(double) Long(ong) Date String*/
 
 
public static voidsetFieldValueByName(Object pojo,String fieldName,Object value) {try{
 
 
String firstLetter= fieldName.substring(0, 1).toUpperCase();
 
 
String seter= "set" + firstLetter + fieldName.substring(1);
 
 
value= Optional.ofNullable(value).orElseGet(()-> new String("null"));
 
 
String simpleName=value.getClass().getSimpleName();
 
 
Class class1;switch(simpleName) {case "Integer":
 
 
class1=Integer.class;break;case "Double":
 
 
class1=Double.class;break;case "Long":
 
 
class1=Long.class;break;case "Date":
 
 
class1=Date.class;break;default:
 
 
class1=String.class;break;
 
 
}
 
 
Method setmethod=pojo.getClass().getMethod(seter, class1);
 
 
setmethod.invoke(pojo,value);
 
 
}catch(Exception e) {
 
 
LOGGER.error(e.getMessage(),e);
 
 
}
 
 
}/**
 
 
* 根据属性名称获取属性值 (获取String型)
 
 
**/
 
 
public staticString getFieldStringValueByName(Object o,String fieldName) {try{
 
 
String firstLetter= fieldName.substring(0, 1).toUpperCase();
 
 
String getter= "get" + firstLetter + fieldName.substring(1);
 
 
Method method= o.getClass().getMethod(getter, newClass[] {});
 
 
String value= (String) method.invoke(o, newObject[] {});returnvalue;
 
 
}catch(Exception e) {
 
 
LOGGER.error(e.getMessage(),e);return null;
 
 
}
 
 
}public static Comparator getMyComparator(Listcolls, String filedName,Class fieldType){
 
 
Comparator comparator = new Comparator() {
 
 
@Overridepublic intcompare(E o1, E o2) {int result=0;switch(fieldType.getName()) {case "java.lang.Integer":
 
 
result= getFieldValueByNameAndType(o1,filedName,Integer.class).compareTo(getFieldValueByNameAndType(o2,filedName,Integer.class));break;case "java.lang.Long":
 
 
result= getFieldValueByNameAndType(o1,filedName,Long.class).compareTo(getFieldValueByNameAndType(o2,filedName,Long.class));break;case "java.lang.Double":
 
 
result= getFieldValueByNameAndType(o1,filedName,Double.class).compareTo(getFieldValueByNameAndType(o2,filedName,Double.class));break;case "java.util.Date":
 
 
result= getFieldValueByNameAndType(o1,filedName,Date.class).compareTo(getFieldValueByNameAndType(o2,filedName,Date.class));break;case "java.lang.Float":
 
 
result= getFieldValueByNameAndType(o1,filedName,Float.class).compareTo(getFieldValueByNameAndType(o2,filedName,Float.class));break;case "java.lang.String":
 
 
result= getFieldValueByNameAndType(o1,filedName,String.class).compareTo(getFieldValueByNameAndType(o2,filedName,String.class));break;default:
 
 
result= 0;break;
 
 
}returnresult;
 
 
}
 
 
};returncomparator;
 
 
}/**
 
 
* @param pojo
 
 
* @param fieldName
 
 
* @param fieldType
 
 
* @return*/
 
 
public static T getFieldValueByNameAndType(Object pojo,String fieldName,ClassfieldType) {try{
 
 
String firstLetter= fieldName.substring(0, 1).toUpperCase();
 
 
String getter= "get" + firstLetter + fieldName.substring(1);
 
 
Method method= pojo.getClass().getMethod(getter, newClass[] {});
 
 
T value= (T) method.invoke(pojo, newObject[] {});returnvalue;
 
 
}catch(Exception e) {
 
 
LOGGER.error(e.getMessage(),e);return null;
 
 
}
 
 
}/**
 
 
* @param 
 
 
* @param pojo
 
 
* @param fieldName
 
 
* @param fieldType
 
 
* @return*/
 
 
public static T getFieldValueByNameAndType(Object pojo,String fieldName) {try{
 
 
String firstLetter= fieldName.substring(0, 1).toUpperCase();
 
 
String getter= "get" + firstLetter + fieldName.substring(1);
 
 
Field field= pojo.getClass().getDeclaredField(fieldName); //获取属性
 
 
Class> type =field.getType();
 
 
Method method=pojo.getClass().getMethod(getter, type);
 
 
T value= (T) method.invoke(pojo, newObject[] {});returnvalue;
 
 
}catch(Exception e) {
 
 
LOGGER.error(e.getMessage(),e);return null;
 
 
}
 
 
}
 
 
}
 


                

        

        




    




    

      

        

            

              
                
                  兔农农
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
Java 8 排序的 10 个姿势，太秀了吧！同事直呼看不懂。。

				
			

			

				

					weixin_70730532的博客
				

				

					06-21
					
					7364
					
				

			

		

		

			
				
今天栈长就分享 Java 8 进行排序的 10 个姿势，原来还有这么多排序技巧，其实就是把 Java 8 中的 Lambda、Stream、方法引用等知识点串起来，栈长的同事直呼还看不懂。。现在有一个 List 集合：jdk8 之前的排序：在 Java 8 出来之前，排序基本上要这么写，可是 Java 8 都出来这么多年了，你还在这么排序那就太 Low 了！对 Java 8 新增的知识点这篇不再详述，本篇就直接上干货，看我怎么用 Java 8 排序！1、Lambda 排序（带参数类型）Java 8 中的 L

			
		

	



                

              
                



	

		

			

				
					
java stream order by_Java Stream 使用详解

				
			

			

				

					weixin_29876591的博客
				

				

					02-19
					
					6341
					
				

			

		

		

			
				
Stream是 Java 8新增加的类，用来补充集合类。Stream代表数据流，流中的数据元素的数量可能是有限的，也可能是无限的。Stream和其它集合类的区别在于：其它集合类主要关注与有限数量的数据的访问和有效管理(增删改)，而Stream并没有提供访问和管理元素的方式，而是通过声明数据源的方式，利用可计算的操作在数据源上执行，当然BaseStream.iterator()和BaseStream...

			
		

	



                


  
              

                


	

		

			

				
					
java8List根据某个属性排序

				
			

			

				

					Bejpse的博客
				

				

					04-03
					
					1839
					
				

			

		

		

			
				
List<PromotionForHomeDto> list = promotionBasicDao.
list(new WherePrams().orderBy("create_time desc"));
list = list.stream().sorted(Comparator.comparing(PromotionForHomeDto::getCreateTime))
                .collect(Collectors.toList());





			
		

	





	

		

			

				
					
java8使用 Comparator.comparing 进行排序

				
			

			

				

					q1353122328的博客
				

				

					12-30
					
					5138
					
				

			

		

		

			
				
java8使用 Comparator.comparing 进行排序

			
		

	



		

			
		



	

		

			

				
					
各种排序方法以及JAVA实现

				
			

			

				

					qq_40971025的博客
				

				

					05-23
					
					128
					
				

			

		

		

			
				
先给出一张表，今天这个博客介绍的就是这10种排序方法，都是从互联网上其他经典讲解中搜刮过来的。

1、插入排序

这个我就是始终和选择排序混淆，现在定义这个插入排序的功能是将无序段中的第一个数不断往前平移，直到在有序段中找到适合它的位置。




public void order(int[] s) {
    for (int i = 1; i < s.length; i++) {
        for (int j = i; j > 0; j--) {
            if(s..

			
		

	





	

		

			

				
					
fengye.rar_Java编程_Java_

				
			

			

				

					08-12
				

			

		

		

			
				
 SELECT *, ROW_NUMBER() OVER (ORDER BY some_column) AS RowNum  FROM YourTable ) SELECT TOP 10 *  FROM PagedResults WHERE RowNum BETWEEN ((5 - 1) * 10 + 1) AND (5 * 10) ```  这里的`some_column`应替换为...

			
		

	





	

		

			

				
					
Java实现按中文首字母排序的具体实例

				
			

			

				

					09-04
				

			

		

		

			
				
同时，如果你的数据存储在数据库中，还可以利用数据库提供的排序功能，比如SQL的`ORDER BY`语句，来实现中文字段的排序。  总的来说，Java通过`Collator`和`Comparator`为我们提供了灵活的字符串排序机制，可以方便...

			
		

	





	

		

			

				
					
Hibernate(HQL).zip_Java编程_Java_

				
			

			

				

					08-11
				

			

		

		

			
				
3. **查询操作**：HQL支持SELECT、FROM、WHERE、GROUP BY、HAVING、ORDER BY等子句，可以进行复杂查询，如分组、排序、聚合函数等。  4. **关联查询**：HQL可以处理一对一、一对多、多对一、多对多的关系，使得关联...

			
		

	





	

		

			

				
					
sql数据库查询_java_java_sqlserver_sql_

				
			

			

				

					10-01
				

			

		

		

			
				
- **ORDER BY**：按指定字段排序结果。  SQL Server作为流行的数据库系统，还有一些特有的功能和优化技巧，例如：  - **索引**：提高查询性能，包括聚集索引（唯一且与表数据存储在一起）和非聚集索引（独立存储）。...

			
		

	





	

		

			

				
					
liuliangtongji_java_

				
			

			

				

					10-03
				

			

		

		

			
				
这可能涉及到SELECT语句，时间字段的WHERE子句，以及可能的GROUP BY和ORDER BY操作。  4. **多线程和并发**：为了连续记录流量信息，系统可能需要处理并发访问。Java的并发API，包括`ExecutorService`、`Thread`、`...

			
		

	





	

		

			

				
					
Java8 sort map by key or value

				
			

			

				

					Shangri-La
				

				

					10-09
					
					3269
					
				

			

		

		

			
				
1. Sort by Key

SortByKeyExample.java
package com.mkyong.test;

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

public class SortByKeyExample {

    public static v

			
		

	





	

		

			

				
					
java 8 Lambda排序

				
			

			

				

					乐于学习、乐于分享、乐于总结
				

				

					09-19
					
					3581
					
				

			

		

		

			
				
package com.ven.java8.lambda;

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;

/**
 * 使用Lambda排序
 * 
 * @author x

			
		

	





	

		

			

				
					
数据的排序：(order by)

				
			

			

				

					写自己的代码，让别人去看吧
				

				

					05-12
					
					6508
					
				

			

		

		

			
				
order by 默认情况下是升序排列



SQL> select * from dept;（deptno默认的是升序排列）


    DEPTNO DNAME          LOC
---------- -------------- -------------
        10 ACCOUNTING     NEW YORK
        20 RESEARCH

			
		

	





	

		

			

				
					
Java 8 Stream Collectors groupingBy 示例

				
			

			

				

					Hatsune_Miku_的博客
				

				

					06-18
					
					6万+
					
				

			

		

		

			
				
展示如何使用Java 8 Stream Collectors进行分组，计数，总和和排序List
分组，计数和排序


1.1分组List并显示其总数。

Java8Example1.java
package com.mkyong.java8;

import java.util.Arrays;
import java.util.List;
import java.util.Map;

			
		

	





	

		

			

				
					
JDK 8 之 Stream sorted() 示例

					
热门推荐

				
			

			

				

					舒哥的blog
				

				

					03-19
					
					14万+
					
				

			

		

		

			
				
原文链接：http://www.concretepage.com/java/jdk-8/java-8-stream-sorted-example 
国外对Java8一系列总结的不错， 翻译过来给大家共享 
这篇文章将会讲解Java 8 Stream sorted()示例， 我们能够以自然序或着用Comparator 接口定义的排序规则来排序一个流。Comparator 能用用lambada表达式来初

			
		

	





	

		

			

				
					
Java8中List的排序

				
			

			

				

					吖脖（博）
				

				

					09-20
					
					7449
					
				

			

		

		

			
				
1、基本类型的List集合的排序    public void testListSort() {
        List<Long> idList = new ArrayList<>();
        idList.add(23L);
        idList.add(22L);
        idList.add(20L);
        idList.add(21L);

			
		

	





	

		

			

				
					
Java8实现Map/List/Set排序

				
			

			

				

					卓立的博客
				

				

					11-03
					
					7349
					
				

			

		

		

			
				
Java8之前如果想对一个集合排序，那么集合元素要么实现了Comparable接口，要么另外定义一个继承于Comparator的比较器并实现compare方法，使用起来是非常麻烦的。在我之前的文章中也介绍了一种Guava的排序实现方案，也是非常简单的，有兴趣的同学可以去了解一下Guava Ordering 。Java8之后可以使用java.util包的Comparator比较器，实现对集合的排序，...

			
		

	





	

		

			

				
					
Java list order by property

					
最新发布

				
			

			

				

					03-31
				

			

		

		

			
				
To sort a list of objects by a specific property, you can use the `Comparator` interface in Java. Here's an example:

Assuming you have a class `Person` with properties `name`, `age`, and `salary`, you can sort a list of `Person` objects by their salary in ascending order like this:

```
List<Person> people = new ArrayList<>();
// add some people to the list...

// sort by salary in ascending order
Collections.sort(people, new Comparator<Person>() {
    @Override
    public int compare(Person p1, Person p2) {
        return Integer.compare(p1.getSalary(), p2.getSalary());
    }
});
```

This code uses the `Collections.sort` method to sort the `people` list. The second argument to `sort` is a `Comparator` object that compares two `Person` objects based on their salary. The `compare` method returns a negative value if `p1`'s salary is less than `p2`'s salary, a positive value if `p1`'s salary is greater than `p2`'s salary, and 0 if their salaries are equal.

You can also sort by other properties by changing the `compare` method to compare the desired properties.

			
		

	



              



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

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值