`
BorisCao
  • 浏览: 2269 次
  • 性别: Icon_minigender_1
  • 来自: 成都
社区版块
存档分类
最新评论

java list 排序

    博客分类：
  • java
list排序 
阅读更多
//------------排序类型-int、long、double、date、string
/**
*  type
* @author boris
*
*/
public enum SortEntityType {
    INT,LONG,DOUBLE,STRING,DATE
}

//---排序实体类--sortValue 存放非date类型的排序值;dateValue 存放date类型的排序值
import java.util.Date;

/**
* sort entry
* @author boris
*
* @param <T>
*/
public class SortEntity<T> {

private T t ;

private String sortValue;

private Date dateValue;

public T getT() {
return t;
}

public void setT(T t) {
this.t = t;
}

public String getSortValue() {
return sortValue;
}

public void setSortValue(String sortValue) {
this.sortValue = sortValue;
}

public Date getDateValue() {
return dateValue;
}

public void setDateValue(Date dateValue) {
this.dateValue = dateValue;
}


}

//排序工厂类
package com.sort;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
*
* @author boris
*
*/
public class SortEntityFactory {

public static List sortList(List<Map> list, boolean isAsc,String orderByField,SortEntityType sortEntityType){
if(orderByField == null || "".equals(orderByField.trim())){
return list;
}
List<SortEntity> sortEntityList = new ArrayList<SortEntity>();
if(sortEntityType == null){
for(Map map : list){
SortEntity sortEntry = new SortEntity();
String value = "";
Object objValue = map.get(orderByField);
if(objValue != null){
value = objValue.toString();
}
if(objValue instanceof Integer){
sortEntityType = SortEntityType.INT;
}else if(objValue instanceof Long){
sortEntityType = SortEntityType.LONG;
}else if(objValue instanceof Double){
sortEntityType = SortEntityType.DOUBLE;
}else if(objValue instanceof Date){
sortEntityType = SortEntityType.DATE;
Date dateValue = (Date) objValue;
sortEntry.setDateValue(dateValue);
}else if(objValue instanceof String){
sortEntityType = SortEntityType.STRING;
}

sortEntry.setSortValue(value);
sortEntry.setT(map);
sortEntityList.add(sortEntry);
}
}else{
for(Map map : list){
SortEntity sortEntity = new SortEntity();

Object objValue = map.get(orderByField);
String value = "";
if(objValue != null){
value = objValue.toString();
}
switch(sortEntityType){
case DATE:
if(objValue instanceof Date){
Date dateValue = (Date) objValue;
sortEntity.setDateValue(dateValue);
}else{
if(objValue != null){
Date dateValue = SmisUtil.getDate(value);
sortEntity.setDateValue(dateValue);
}
}

break;
default:
}

sortEntity.setSortValue(value);
sortEntity.setT(map);
sortEntityList.add(sortEntity);
}
}
List result = list;
try{
result =  sortList(sortEntityList,isAsc,sortEntityType);
}catch(Exception e){
}
return result;
}

public static List sortList(List<SortEntity> sortEntryList,boolean isAsc,SortEntityType sortEntityType){
switch(sortEntityType){
case INT:
return sortIntList(sortEntryList,isAsc);
case LONG:
return sortLongList(sortEntryList,isAsc);
case DOUBLE:
return sortDoubleList(sortEntryList,isAsc);
case DATE:
return sortDateList(sortEntryList,isAsc);

default  :
return sortStringList(sortEntryList,isAsc);
}

}

private static List sortStringList(List<SortEntity> sortEntityList,boolean isAsc){
List list = new ArrayList();


if( isAsc){
StrComparatorEntryAsc comparAsc=new StrComparatorEntryAsc();
Collections.sort(sortEntityList, comparAsc);
}else {
StrComparatorEntryDesc comparDesc=new StrComparatorEntryDesc();
Collections.sort(sortEntityList, comparDesc);
}

for(SortEntity sortEntry : sortEntityList){
list.add(sortEntry.getT());
}
return list;
}

private static List sortIntList(List<SortEntity> sortEntityList,boolean isAsc){
List list = new ArrayList();

if( isAsc){
IntComparatorEntityAsc comparAsc=new IntComparatorEntityAsc();
Collections.sort(sortEntityList, comparAsc);
}else{
IntComparatorEntityDesc comparDesc=new IntComparatorEntityDesc();
Collections.sort(sortEntityList, comparDesc);
}

for(SortEntity sortEntry : sortEntityList){
list.add(sortEntry.getT());
}
return list;
}
private static List sortLongList(List<SortEntity> sortEntityList,boolean isAsc){
List list = new ArrayList();

if( isAsc){
LongComparatorAsc comparAsc=new LongComparatorAsc();
Collections.sort(sortEntityList, comparAsc);
}else{
LongComparatorDesc comparDesc=new LongComparatorDesc();
Collections.sort(sortEntityList, comparDesc);
}

for(SortEntity sortEntry : sortEntityList){
list.add(sortEntry.getT());
}
return list;
}
private static List sortDoubleList(List<SortEntity> sortEntityList,boolean isAsc){
List list = new ArrayList();

if( isAsc){
DoubleComparatorAsc comparAsc=new DoubleComparatorAsc();
Collections.sort(sortEntityList, comparAsc);
}else{
DoubleComparatorDesc comparDesc=new DoubleComparatorDesc();
Collections.sort(sortEntityList, comparDesc);
}

for(SortEntity sortEntry : sortEntityList){
list.add(sortEntry.getT());
}
return list;
}
private static List sortDateList(List<SortEntity> sortEntityList,boolean isAsc){
List list = new ArrayList();

if( isAsc){
DateComparatorEntryAsc comparAsc=new DateComparatorEntryAsc();
Collections.sort(sortEntityList, comparAsc);
}else{
DateComparatorEntryDesc comparDesc=new DateComparatorEntryDesc();
Collections.sort(sortEntityList, comparDesc);
}

for(SortEntity sortEntry : sortEntityList){
list.add(sortEntry.getT());
}
return list;
}

}
class IntComparatorEntityAsc implements Comparator<SortEntity> {
public int compare(SortEntity sortEntity1, SortEntity sortEntity2) {
String sortValue1 = "";
String sortValue2 = "";
if(sortEntity1 != null && sortEntity1.getSortValue() != null){
sortValue1 = sortEntity1.getSortValue();
}
if(sortEntity2 != null && sortEntity2.getSortValue() != null){
sortValue2 = sortEntity2.getSortValue();
}
int valueInt1 = 0;
int valueInt2 = 0;
try{
valueInt1 = Integer.parseInt(sortValue1);
valueInt2 = Integer.parseInt(sortValue2);
}catch(Exception e){
e.getStackTrace();
}

if(valueInt1 < valueInt2){
return -1;
}else if(valueInt1 == valueInt2){
return 0;
}else{
return 1;
}
}

}

class IntComparatorEntityDesc implements Comparator<SortEntity> {


public int compare(SortEntity sortEntity1, SortEntity sortEntity2) {
String sortValue1 = "";
String sortValue2 = "";
if(sortEntity1 != null && sortEntity1.getSortValue() != null){
sortValue1 = sortEntity1.getSortValue();
}
if(sortEntity2 != null && sortEntity2.getSortValue() != null){
sortValue2 = sortEntity2.getSortValue();
}
int valueInt1 = 0;
int valueInt2 = 0;
try{
valueInt1 = Integer.parseInt(sortValue1);
valueInt2 = Integer.parseInt(sortValue2);
}catch(Exception e){
e.getStackTrace();
}
if(valueInt1 > valueInt2){
return -1;
}else if(valueInt1 == valueInt2){
return 0;
}else{
return 1;
}
}

}
class LongComparatorAsc implements Comparator<SortEntity>{

public int compare(SortEntity sortEntity1, SortEntity sortEntity2) {
long longValue1 = 0L;
long longValue2 = 0L;
try{
if(sortEntity1 != null && sortEntity1.getSortValue() != null){
longValue1 = Long.parseLong(sortEntity1.getSortValue());
}
if(sortEntity2 != null && sortEntity2.getSortValue() != null){
longValue2 = Long.parseLong(sortEntity2.getSortValue());

}
}catch(NumberFormatException e){
e.getStackTrace();
}
int flag = -1;
if(longValue1 > longValue2){
flag = 1;
}else if(longValue1 == longValue2){
flag = 0;
}

return flag;
}
}
class LongComparatorDesc implements Comparator<SortEntity>{

public int compare(SortEntity sortEntity1, SortEntity sortEntity2) {
long longValue1 = 0L;
long longValue2 = 0L;
try{
if(sortEntity1 != null && sortEntity1.getSortValue() != null){
longValue1 = Long.parseLong(sortEntity1.getSortValue());
}
if(sortEntity2 != null && sortEntity2.getSortValue() != null){
longValue2 = Long.parseLong(sortEntity2.getSortValue());

}
}catch(NumberFormatException e){
e.getStackTrace();
}
int flag = -1;
if(longValue1 < longValue2){
flag = 1;
}else if(longValue1 == longValue2){
flag = 0;
}

return flag;
}
}

class DoubleComparatorAsc implements Comparator<SortEntity>{

public int compare(SortEntity sortEntity1, SortEntity sortEntity2) {

double doubleValue1 = 0.0;
double doubleValue2 = 0.0;
try{
if(sortEntity1 != null && sortEntity1.getSortValue() != null){
doubleValue1 = Double.parseDouble(sortEntity1.getSortValue());
}
if(sortEntity2 != null && sortEntity2.getSortValue() != null){
doubleValue2 = Double.parseDouble(sortEntity2.getSortValue());

}
}catch(NumberFormatException e){
e.getStackTrace();
}
int flag = -1;
if(doubleValue1 > doubleValue2){
flag = 1;
}else if(doubleValue1 == doubleValue2){
flag = 0;
}

return flag;
}
}
class DoubleComparatorDesc implements Comparator<SortEntity>{

public int compare(SortEntity sortEntity1, SortEntity sortEntity2) {
double doubleValue1 = 0.0;
double doubleValue2 = 0.0;
try{
if(sortEntity1 != null && sortEntity1.getSortValue() != null){
doubleValue1 = Double.parseDouble(sortEntity1.getSortValue());
}
if(sortEntity2 != null && sortEntity2.getSortValue() != null){
doubleValue2 = Double.parseDouble(sortEntity2.getSortValue());
}
}catch(NumberFormatException e){
e.getStackTrace();
}
int flag = -1;
if(doubleValue1 < doubleValue2){
flag = 1;
}else if(doubleValue1 == doubleValue2){
flag = 0;
}

return flag;
}
}
class DateComparatorEntryAsc implements Comparator<SortEntity> {

public int compare(SortEntity sortEntity1, SortEntity sortEntity2) {
Date dateValue1 = new Date();
Date dateValue2 = new Date();
if(sortEntity1 != null && sortEntity1.getDateValue() != null){
dateValue1 = sortEntity1.getDateValue();
}
if(sortEntity2 != null && sortEntity2.getDateValue() != null){
dateValue2 =  sortEntity2.getDateValue();
}
return dateValue1.compareTo(dateValue2);
}

}

class DateComparatorEntryDesc implements Comparator<SortEntity> {


public int compare(SortEntity sortEntity1, SortEntity sortEntity2) {
Date dateValue1 = new Date();
Date dateValue2 = new Date();
if(sortEntity1 != null && sortEntity1.getDateValue() != null){
dateValue1 = sortEntity1.getDateValue();
}
if(sortEntity2 != null && sortEntity2.getDateValue() != null){
dateValue2 =  sortEntity2.getDateValue();
}
return dateValue2.compareTo(dateValue1);
}

}
class StrComparatorEntryAsc implements Comparator<SortEntity> {


public int compare(SortEntity sortEntity1, SortEntity sortEntity2) {
String sortValue1 = "";
String sortValue2 = "";
if(sortEntity1 != null && sortEntity1.getSortValue() != null){
sortValue1 = sortEntity1.getSortValue();
}
if(sortEntity2 != null && sortEntity2.getSortValue() != null){
sortValue2 = sortEntity2.getSortValue();
}

return sortValue2.compareTo(sortValue1);
}

}

class StrComparatorEntryDesc implements Comparator<SortEntity> {


public int compare(SortEntity sortEntity1, SortEntity sortEntity2) {
String sortValue1 = "";
String sortValue2 = "";
if(sortEntity1 != null && sortEntity1.getSortValue() != null){
sortValue1 = sortEntity1.getSortValue();
}
if(sortEntity2 != null && sortEntity2.getSortValue() != null){
sortValue2 = sortEntity2.getSortValue();
}
return sortValue1.compareTo(sortValue2);
}

}

//--测试类
package com.sort;

import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class Sorttest {

private static Date getDateStr(String dateStr){
SimpleDateFormat dateFormate = new SimpleDateFormat("MM/dd/yyyy");
ParsePosition parsePositon = new ParsePosition(0);
Date date = dateFormate.parse(dateStr, parsePositon);
return date;
}



/**
* @param args
*/
public static void main(String[] args) {
boolean isAsc = true;
String keyStr = "keyStr";
String keyInt = "keyInt";
String keyLong = "keyLong";
String keyDouble = "keyDouble";
String keyDate = "keyDate";
Map map1 = new HashMap();
map1.put(keyStr, "aaa");
map1.put(keyInt, 14);
map1.put(keyLong, 14L);
map1.put(keyDouble, 14.11);
map1.put(keyDate, getDateStr("11/5/2013"));
map1.put(keyDate, "11/5/2013");

Map map2 = new HashMap();
map2.put(keyStr, "abb");
map2.put(keyInt, 5);
map2.put(keyLong, 5L);
map2.put(keyDouble,51.11 );
map2.put(keyDate,getDateStr("5/7/2014"));
map2.put(keyDate,"5/7/2014");

Map map3 = new HashMap();
map3.put(keyStr, "acc");
map3.put(keyInt, 210);
map3.put(keyLong, 210L);
map3.put(keyDouble, 33.11);
map3.put(keyDate,getDateStr("12/08/2013"));
map3.put(keyDate,"12/08/2013");

Map map4 = new HashMap();
map4.put(keyStr, "add");
map4.put(keyInt, 7);
map4.put(keyLong, 7L);
map4.put(keyDouble, 7.1);
map4.put(keyDate,getDateStr("10/11/2012"));
map4.put(keyDate,"10/11/2012");

Map map5 = new HashMap();
map5.put(keyStr, "aee");
map5.put(keyInt, 10);
map5.put(keyLong, 10L);
map5.put(keyDouble, 80.00);
map5.put(keyDate,getDateStr("11/22/2013"));
map5.put(keyDate,"11/22/2013");

List<Map> list = new ArrayList<Map>();
list.add(map1);
list.add(map2);
list.add(map3);
list.add(map4);
list.add(map5);

List<Map> sortList = SortEntityFactory.sortList(list, false ,"ee", null);

for(Map map : sortList){
System.out.println(map);
}

}

}

分享到：
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java List排序工具类

    java List排序工具类 使用示例: new OrderUtils().order(list, "name", OrderUtils.DESC); 相关实例代码: public static void main(String[] args) { List&lt;Person&gt; list = getData(); // 获取无序数据 new ...

    java List 排序 Collections.sort

    总结起来，`Collections.sort()`是Java中对List进行排序的标准工具，它支持自然排序和自定义排序。了解其工作原理和优化技巧，可以帮助我们在编程实践中更高效地处理数据。通过阅读和理解`Collections.sort()`的源码...

    java list排序

    java开发，使用list对其进行排序，，易学简单。。。。。。。。。

    JAVALIST排序.pdf

    JAVALIST排序.pdf

    java List中对象多属性排序及各属性排序设置

    在Java编程中，排序是常见的数据处理操作，特别是在处理集合数据结构时，如List。本文将深入探讨如何在Java的List中对包含多个属性的对象进行排序，并且支持动态设置每个属性的排序方式。这个功能的实现是通过泛型和...

    java List排序demo

    当我们需要对`List`中的元素进行排序时，可以利用Java提供的内置排序机制。本篇将详细介绍如何根据指定字段对`List`中的对象进行排序，以`Student`类为例，假设每个`Student`都有一个`grad`属性表示成绩。 首先，...

    java List 排序之冒泡排序实例代码

    java List 排序之冒泡排序实例代码 Java List 排序之冒泡排序实例代码是 Java 语言中实现 List 排序的一种方法。该方法主要使用冒泡排序算法对 List 集合中的元素进行排序。 1.Collections.sort() 排序 ...

    JAVA LIST排序

    主要为LIST对象中的指定字段排序 首先比较年龄，如果年龄相同，则比较名字

    java 使用Collections类对List的排序操作

    总的来说，`Collections` 类提供的排序功能使得在 Java 中对 `List` 进行操作变得更加便捷，无论是自然排序还是定制排序，都可以轻松实现。同时，随着 Java 8 及更高版本的引入，流API也提供了新的排序方式，开发者...

    java中list排序

    Java 中 List 排序 Java 中 List 排序是指在数据库中查出来的列表中对不同的字段重新排序。一般的做法都是使用排序的字段，重新到数据库中查询。如果不到数据库查询，直接在第一次查出来的 List 中排序，无疑会提高...

    JAVA SortList 通用排序类

    JAVA SortList 通用排序类 从网上搜到一个java 对 List 排序的工具，自己改了下 支持 整数 和 浮点数 比较后排序，浮点数小数部分的有点问题，期待大牛帮忙优化。

    Java集合排序及java集合类详解(Collection、List、Map、Set)

    ### Java集合排序及java集合类详解 #### 集合框架概述 集合是Java编程语言中非常核心且广泛使用的部分，对于深入理解和高效使用Java语言至关重要。本文将围绕Java集合框架进行详细介绍，包括Collection、List、Set...

    java 集合分组与排序

    总结来说，Java集合框架提供了强大的工具来处理分组和排序，包括`List`接口的`sort()`方法和流API的`groupingBy()`和`sorted()`。在实际项目中，可以根据需求选择合适的方法。同时，`ArrayHelp`和`ClassLoadUtil`...

    Java 字母数字字符串 混合排序（绝对超值管用）

    List&lt;String&gt; location=new ArrayList(); 一行代码轻松搞定混合排序问题 Collections.sort(location, new SortUtils(true));

    Java对List多个排序、查询条件的处理

    在Java编程中，对List进行多个排序和查询条件的处理是一项常见的任务，特别是在处理数据集合时。本篇文章将深入探讨如何使用Java实现这些操作，并基于给出的`GroupFilterSortUtils.java`文件，我们可以推断这是一个...

    java中文排序,数字字母汉字排序

    Java集合框架中的`List`接口提供了一个`sort(Comparator&lt;? super E&gt; comparator)`方法，可以接受一个比较器（Comparator）来定义自定义的排序规则。默认情况下，Java使用自然排序，即按照字符串的Unicode值进行排序...

    Java将2个List集合合并到一个List里面并排序工具类

    Java将2个List集合合并到一个List里面并排序工具类 1、Java编程资源，定义了一个名为`ListMerger`的工具类，主要包含一个名为`mergeAndSortLists`的静态方法。此方法用于将两个已经根据时间顺序排列的List合并成一...

    java使用stream对日期排序

    通过以上介绍，我们可以看出Java Stream API提供了灵活且高效的方式来处理日期排序。无论是在简单的日期列表还是复杂的数据结构中，都可以轻松地实现排序功能。实践过程中，可以根据实际需求选择合适的日期类型和...

    list集合树状排序-java

    在Java编程中，"list集合树状排序"是一种常见的需求，特别是在处理前端展示的数据时，如使用jQuery的treetable插件。这个场景通常涉及到数据结构的组织和排序，以便前端能够按照树形结构正确地展示层级关系。下面将...

Magicbox
Global site tag (gtag.js) - Google Analytics