• ## List排序

千次阅读 2019-09-02 11:32:10
使用Comparator 来排序一个list list.stream().sorted(Comparator.comparing(Student::getAge)) 把上面的元素逆序 list.stream().sorted(Comparator.comparing(Student::getAge).reversed()) Stream sorted() ...
利用java8特性进行排序
使用Comparator 对String来排序一个list
List<String> collect = list.stream().sorted(Comparator.comparing(String::valueOf)).collect(Collectors.toList());

使用Comparator 对对象来排序一个list
list.stream().sorted(Comparator.comparing(Student::getAge)) .collect(Collectors.toList())


把上面的元素逆序
list.stream().sorted(Comparator.comparing(Student::getAge).reversed()) .collect(Collectors.toList())


Stream sorted() with List
我们排序一组装着Student 类对象的List 集合。 首先我们使用自然序， 接着我们使用Comparator 分别进行升序和降序：
SortList.java

package com.concretepage;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;
public class SortList {
public static void main(String[] args) {
List<Student> list = new ArrayList<Student>();

System.out.println("---Natural Sorting by Name---");
List<Student> slist = list.stream().sorted().collect(Collectors.toList());
slist.forEach(e -> System.out.println("Id:"+ e.getId()+", Name: "+e.getName()+", Age:"+e.getAge()));

System.out.println("---Natural Sorting by Name in reverse order---");
slist = list.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
slist.forEach(e -> System.out.println("Id:"+ e.getId()+", Name: "+e.getName()+", Age:"+e.getAge()));

System.out.println("---Sorting using Comparator by Age---");
slist = list.stream().sorted(Comparator.comparing(Student::getAge)).collect(Collectors.toList());
slist.forEach(e -> System.out.println("Id:"+ e.getId()+", Name: "+e.getName()+", Age:"+e.getAge()));

System.out.println("---Sorting using Comparator by Age with reverse order---");
slist = list.stream().sorted(Comparator.comparing(Student::getAge).reversed()).collect(Collectors.toList());
slist.forEach(e -> System.out.println("Id:"+ e.getId()+", Name: "+e.getName()+", Age:"+e.getAge()));
}
}


Student.java 类
package com.concretepage;
public class Student implements Comparable<Student> {
private int id;
private String name;
private int age;
public Student(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
public int getId() {
return id;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
@Override
public int compareTo(Student ob) {
return name.compareTo(ob.getName());
}
@Override
public boolean equals(final Object obj) {
if (obj == null) {
return false;
}
final Student std = (Student) obj;
if (this == std) {
return true;
} else {
return (this.name.equals(std.name) && (this.age == std.age));
}
}
@Override
public int hashCode() {
int hashno = 7;
hashno = 13 * hashno + (name == null ? 0 : name.hashCode());
return hashno;
}
}


执行结果
—Natural Sorting by Name—
Id:1, Name: Mahesh, Age:12
Id:3, Name: Nilesh, Age:10
Id:2, Name: Suresh, Age:15
—Natural Sorting by Name in reverse order—
Id:2, Name: Suresh, Age:15
Id:3, Name: Nilesh, Age:10
Id:1, Name: Mahesh, Age:12
—Sorting using Comparator by Age—
Id:3, Name: Nilesh, Age:10
Id:1, Name: Mahesh, Age:12
Id:2, Name: Suresh, Age:15
—Sorting using Comparator by Age with reverse order—
Id:2, Name: Suresh, Age:15
Id:1, Name: Mahesh, Age:12
Id:3, Name: Nilesh, Age:10



展开全文
• ## List排序

千次阅读 2008-10-07 16:27:00
在Java语言中，在Collections接口中提供了“sort”方法来用于对List对象进行排序，可能我们在Java语言编程中已经用过无数次了，在这里限于篇幅就不多说了。在Groovy语言中，同样提供了“sort”方法，而且比Java语言...
数组还有一个重要内容就是要排序，排序是任何集合操作所躲不过去的。在Java语言中，在Collections接口中提供了“sort”方法来用于对List对象进行排序，可能我们在Java语言编程中已经用过无数次了，在这里限于篇幅就不多说了。
在Groovy语言中，同样提供了“sort”方法，而且比Java语言的“sort”方法使用起来更加的方便。这就是我们这一个《魔幻数组》系列所要谈到的。
先来看一个简单的例子：

def list1 = [1,5,7,3,9,4]

println list1.sort()

结果为：
[1, 3, 4, 5, 7, 9]
可以看到，Groovy语言的“sort”方法比Java语言的“sort”方法更加简单。上面的例子是对数字的排序，同样，如果数组元素是字符串的话，同样也可以使用“sort”方法来排序。请看下面的例子：

def list2 = ['a','h','c','i']

println list2.sort()

结果为：
["a", "c", "h", "i"]

看过了上面的例子，我们说，是的，我们使用“sort”方法对数组进行排序相当简单。但我们有更高的要求：我们想对list1对象按倒序排序，该怎么办呢？

list1.sort{
a,b ->
b <=> a
}

println list1

可以看到，要进行倒序排序很简单，只要在两个元素进行比较的时候将a比b改为b比a就可以了。
上面的结果为：
[9, 7, 5, 4, 3, 1]

当然了，对于数组的排序，我们还有一个基本的要求是能够对数组元素为GroovyBean对象进行排序。比如我们有如下的一个GroovyBean类：

class Empl
{
String id
String name
}

然后，我们有了如下的数组：

def list3 = [new Empl(id:5,name:'Tom'),new Empl(id:8,name:'Wallace'),
new Empl(id:4,name:'Mike'),new Empl(id:6,name:'Jack')]

现在，我们要对list3的元素按id的顺序排序。该怎么办呢？

list3.sort{
a,b ->
a.id <=> b.id
}

很简单，我们还是使用闭包来对数组元素的排序方法进行定义。下面来测试上面的代码是否按我们的要求来排序了：

list3.each{
println "${it.id}${it.name}"
}

结果为：
4 Mike
5 Tom
6 Jack
8 Wallace

有些特殊的时候，我们希望对某一个已经排序好了的数组进行随机排序，那又该怎么办呢？
比如我们有如下的一个数组：

def list4 = [1,2,3,4,5,6]

我们希望对list4的排序顺序打乱，而且要是随机的。

list4.sort{
Math.random()
}

println list4

结果为：
[3, 1, 2, 4, 5, 6]

当然，既然是随机的，当你第二次运行上面的代码的时候，会得到不同的结果，如下所示：
[3, 1, 6, 4, 2, 5]
展开全文
• ## Python3 list排序函数详解

万次阅读 多人点赞 2018-05-28 18:55:03
Python3 list 排序函数详解 一、列表的sort排序函数 函数原型： list.sort(key=None,reverse=False) 函数功能： 对原列表进行排序，完成排序后，原列表变为有序列表。默认情况（不传入任何参数时）按字典顺序...
Python3 list 排序函数详解

一、           列表的sort排序函数

函数原型：

list.sort(key=None,reverse=False)

函数功能：

对原列表进行排序，完成排序后，原列表变为有序列表。默认情况（不传入任何参数时）按字典顺序排序。

函数参数：

(1)     key: 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中。指定可迭代对象中的一个元素来进行排序指定排序时使用的单个元素或多个元素、lambda表达式；

(2)     reverse：指字排序规则是升序还是降序，默认为升序排序；

二、           排序示例

1.      字符串排序

def list_sort_string():
list=["delphi","Delphi","python","Python","c++","C++","c","C","golang","Golang"]
list.sort() #按字典顺序升序排列
print("升序:",list)

list.sort(reverse=True) #按降序排列
print("降序:",list)

排序结果：

升序: ['C', 'C++', 'Delphi', 'Golang', 'Python', 'c', 'c++', 'delphi', 'golang', 'python']
降序: ['python', 'golang', 'delphi', 'c++', 'c', 'Python', 'Golang', 'Delphi', 'C++', 'C']

2.      数值型排序

def list_sort_number():
list=[30,40,10,50,50.1,80,60,100,90]
list.sort()
print("升序:",list)

list.sort(reverse=True)
print("降序:",list)

排序结果：

升序: [10, 30, 40, 50, 50.1, 60, 80, 90, 100]
降序: [100, 90, 80, 60, 50.1, 50, 40, 30, 10]

3.      根据列表中类对象的属性排序

class element(object):
def __init__(self,id="",name=""):
self.id=id
self.name=name
def __lt__(self, other): # override <操作符
if self.id<other.id:
return True
return False

def __str__(self): # override __str__
return "id={0},name={1}".format(self.id,self.name)

def sort_by_attribute():
list=[element(id="130",name="json"),
element(id="01",name="jack"),element(id="120",name="tom")]
list.sort()
for item in list:
print(item)

由于list.sort()函数在排序时，使用的是小于号对比，所以自定义的数据类型需要override __lt__(小于)函数才能实现排序。

根据element的id属性排序

排序列的结果：

id=01,name=jack
id=120,name=tom
id=130,name=json

4.      根据列表中元素的长度排序

def list_sort_by_length():
list=["delphi","Delphi","python","Python","c++","C++","c","C","golang","Golang"]
list.sort(key=lambda ele:len(ele)) #按元素长度顺序升序排列
print("升序:",list)

list.sort(key=lambda ele:len(ele),reverse=True) #按降序排列
print("降序:",list)

借助于lambda表达式，计算list列表中的元素的长度，根据元素的长度进行排序

排序的结果：

升序: ['c', 'C', 'c++', 'C++', 'delphi', 'Delphi', 'python', 'Python', 'golang', 'Golang']
降序: ['delphi', 'Delphi', 'python', 'Python', 'golang', 'Golang', 'c++', 'C++', 'c', 'C']

5.      根据列表中元素的多个属性进行排序：

def two_d_list_sort():
list=[ ["1","c++","demo"],
["1","c","test"],
["2","java",""],
["4","python","gil"],
["5","swift","apple"]
]
list.sort(key=lambda ele:ele[0])# 根据第1个元素排序
print(list)
list.sort(key=lambda ele:ele[1]) #先根据第2个元素排序
print(list)
list.sort(key=lambda ele:(ele[1],ele[0])) #先根据第2个元素排序，再根据第1个元素排序
print(list)

同样借助于lambda表达式完成，当然也可以定义一个与labmda具有相同意义的函数实现排序。

排序结果：

[['1', 'c++', 'demo'], ['1', 'c', 'test'], ['2', 'java', ''], ['4', 'python', 'gil'], ['5', 'swift', 'apple'], ['8', 'golang', 'google']]
[['1', 'c', 'test'], ['1', 'c++', 'demo'], ['8', 'golang', 'google'], ['2', 'java', ''], ['4', 'python', 'gil'], ['5', 'swift', 'apple']]
[['1', 'c++', 'demo'], ['1', 'c', 'test'], ['8', 'golang', 'google'], ['2', 'java', ''], ['4', 'python', 'gil'], ['5', 'swift', 'apple']]

6.      动态的根据用户指定的索引进行排序

有时候，在写代码之前，并不知道根据二维表的哪几列排序，而是在程序运行的时候根据输入或配置决定的，为了解决这个动态根据多个列或属性排序的问题，借助了eval()函数，eval函数能够把字符串编译成python代码并运行，从而达到动态根据多个列或属性排序的目的。

排序结果：

排序索引: 0 [['1', 'c++', 'demo'], ['1', 'c', 'test'], ['2', 'java', ''], ['4', 'python', 'gil'], ['5', 'swift', 'apple'], ['8', 'golang', 'google']]
排序索引: 1 [['1', 'c', 'test'], ['1', 'c++', 'demo'], ['8', 'golang', 'google'], ['2', 'java', ''], ['4', 'python', 'gil'], ['5', 'swift', 'apple']]
排序索引: 2 [['2', 'java', ''], ['5', 'swift', 'apple'], ['1', 'c++', 'demo'], ['4', 'python', 'gil'], ['8', 'golang', 'google'], ['1', 'c', 'test']]
排序索引: 1,0 [['1', 'c++', 'demo'], ['1', 'c', 'test'], ['8', 'golang', 'google'], ['2', 'java', ''], ['4', 'python', 'gil'], ['5', 'swift', 'apple']]

综上，基本总结了list.sort的使用的大部分场景，如下：

1、默认排序

2、根据类对象的单个属性进行排序，当然也可以扩展为根据类对象的多个属性进行排序

3、根据元素的固有属性进行排序，如：长度、第N个元素等。为了简单，所以借助了lambda表达式，当然也可以使用普通函数代替lambda表达式

4、动态的根据多个列进行排序，同时借助lambda和eval()函数实现

5、另外相比Python2，Python3取消了sort函数中的 cmp方式，只能用key方式。
所以python2用cmp方式写的函数迁移到python3中需要转换。
from functools import cmp_to_key

sort(iterable, key=cmp_to_key(cmp_fun)）

可能还有一些场景没有涉及到，不过我相信，上面的几种情况可以满足90%以上的场景了；如果在使用中有问题欢迎留言交流。

展开全文
• ## list排序,list去重

千次阅读 2017-05-19 18:02:01
list排序,list去重（对象数组或list数组均可）


List去重/排序的通用方法



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 bg
*
* @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) {
}
}
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相同，
* 若有其他相同
*
*/
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 {
}
}
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>();

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();

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) {
}
}

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]


展开全文
• ## java List排序

千次阅读 2018-06-25 19:13:27
对元素是基本数据类型的List排序import java.util.ArrayList; import java.util.Collections; import java.util.List; import org.junit.Test; public class ListSortTest { @Test public void ...
• ## 实体类list排序

千次阅读 2019-08-06 19:03:22
实体类list排序 工具类EntityListSort /** * @program: YeeGuideServer * @description: list对象排序 * @author: jiahao * @create: 2019-08-06 17:05 **/ public class EntityListSort { /** * @param ...
• List 排序(首先年龄排序，如果年龄相同，则按名字排序)
• List排序,这里介绍两种排序： 1.Collections.sort()排序： 假如List集合中放的是Menu对象。 public class Menu{ private int id; private String name; private int seq;//自定义排序字段 //构造函数、...
• ## Java List排序

千次阅读 2012-05-09 13:49:33
java List 排序 ...用Collections.sort方法对list排序有两种方法 第一种是list中的对象实现Comparable接口，如下：  /** * 根据order对User排序 */ public class User implements Comparable
• 1.数组排序及list排序     在JAVA中对数组排序或list元素排序，JAVA提供了Arrays.sort()及Collections.sort()，使用者只要正确调用即可，不需要使用者自己写排序算法的实现。当然如果数据量大，并且要求效率高...
• ## scala list排序

千次阅读 2019-10-11 18:34:16
现在有一个List，需要对其进行排序 val a = List(("a",2),("b",44),("c",20),("a",20)) 1、对int值进行排序 val d = a.sortBy(_._2).reverse println(d.mkString(" - ")) 结果： (b,44) - (a,20) - (c,20) - (a,2)...
• ## Python列表list排序

千次阅读 2018-04-10 19:31:21
list排序共有四种方法。1. list[::-1]list的三个参数是：起点，终点，步长。可以缺省。因此，list[::-1]对应的三个参数依次是：第一个参数是起点；第二个参数是终点；第三个参数为-1，其中负数表示从起点到终点位置...
• 首先声明，排序的方法是通用的，但是这个方法是很有... * 字符串类型list排序 * author byH * data 2021/2/1 * @param list 需要排序的list */ public static void listStringSorted(List<String> list){
• ## java8中list排序

万次阅读 2017-04-06 21:03:33
在项目开发中，很多页面的展示，都是按照一定的顺序排列的。 要想获取一个有序的list，有两种做法： 一、使用sql查出有序的list 这种方式进行排序，是最常用的，取数据...这种方式，对于对象类型的list排序，需要指
• ## Java之List排序出错

千次阅读 2014-03-17 22:53:17
Java之List排序出错 Bound mismatch: The generic method sort(List) of type Collections is not applicable for the arguments (List).  The inferred type Student is not a valid substitute for the ...
• 常见数据类型List直接把需要排序list当做参数调用下列方法即可Collections.sort(list);//升序排列 Collections.sort(list,Collections.reverseOrder());//降序排列对象List举例：Student.java（一个简单的实体类）...
• java中的list排序问题 是一个比较常见的问题，在java8中又添加了stream集合类型，使得这个排序更加的丰富，下面我们一起来看一下一下三种list排序：//传统的list排序 public static void listSort() { List list...
• yii checkBoxList 排序方式 默认是
• ## C# List排序

千次阅读 2009-10-20 18:17:00
发现对一个List排序，其实是有比较简单的方法的，拿出来与大家分享 格式其实挺简单的 List.Sort(delegate(T t1, T t2) { return t1.Name.CompareTo(t2.Name);} ); 就可以按照名称排序了。 实例：listProTechEcon...
• ## Java kotlin List排序

千次阅读 2018-08-23 18:16:20
//List重新排序 list.sortBy { it.id} 在sortBy里面添加排序多种方法。我这里是以list里面的自定义类的id排序
•  list.sort(key=None,reverse=False) 函数功能： 对原列表进行排序，完成排序后，原列表变为有序列表。默认情况（不传入任何参数时）按字典顺序排序。 函数参数： (1) key: 主要是用来进行比较的元素，只有一...
• Kotlin中List，根据对象某个属性值进行升序或者倒序排列 升序： data.sortBy { it.power } data 为List，it.power 代表 data 对象的某个属性。 倒序： data.sortByDescending { it.inWheat } it.inWheat ...
• ## Android Java List排序

千次阅读 2011-11-30 09:17:12
原文章转自网上blog，但是其中代码运行后原来的list排序根本没有改变。 于是打开Comparator文档看了，发现原代码的compare函数实现的返回值有问题！ 修正后运行结果正确了，代码如下： @SuppressWarnings...
• ## list排序方法

千次阅读 2014-05-06 15:22:11
一: 排序list
• ## list排序的问题

千次阅读 2018-09-03 10:02:06
list如何按照自定义排序 方法： 一：list有序列表 输出按照放入先后排序 二：使用Collections.sort()排序 三：创建对象 四： 发现，代码直接报错了： Bound mismatch: The generic method sort...
• ## flutter dart list排序

千次阅读 2020-01-06 12:52:07
• ## std list排序

千次阅读 2016-10-12 08:50:33
c++排序

...