java怎么对一个字段进行排序（java 中 List<T>如何按照T中的一个字段排序）

本文目录

• java 中 List如何按照T中的一个字段排序
• 编写一个java程序对一个字符串数组进行排序
• java的list集合如何根据对象中的某个字段排序
• 如何用java对字符串进行排序
• java8代码实现某字段排序,是不是该字段必须有值
• java list 相同的字段排序
• java中一个List集合，放的都是从不同的表中查出来的数据，请问我怎样可以根据其中的一个字段进行list排序
• JAVA中有哪几种常用的排序方法
• java中怎么对一串字符进行排序！

java 中 List如何按照T中的一个字段排序

可以通过以下工具类进行实现：
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/**
* List按照指定字段排序工具类
*
* @param 《T》
*/
public class ListSortUtil《T》 {
/**
* @param targetList 目标排序List
* @param sortField 排序字段(实体类属性名)
* @param sortMode 排序方式（asc or desc）
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
public void sort(List《T》 targetList, final String sortField, final String sortMode) {

Collections.sort(targetList, new Comparator() {
public int compare(Object obj1, Object obj2) {
int retVal = 0;
try {
//首字母转大写
String newStr=sortField.substring(0, 1).toUpperCase()+sortField.replaceFirst("\\w","");
String methodStr="get"+newStr;

Method method1 = ((T)obj1).getClass().getMethod(methodStr, null);
Method method2 = ((T)obj2).getClass().getMethod(methodStr, null);
if (sortMode != null && "desc".equals(sortMode)) {
retVal = method2.invoke(((T) obj2), null).toString().compareTo(method1.invoke(((T) obj1), null).toString()); // 倒序
} else {
retVal = method1.invoke(((T) obj1), null).toString().compareTo(method2.invoke(((T) obj2), null).toString()); // 正序
}
} catch (Exception e) {
throw new RuntimeException();
}
return retVal;
}
});
}

}
Collections.sort(list.);//升序

编写一个java程序对一个字符串数组进行排序

import java.util.Arrays;
public class StringDateSort {
public static void main(String args) {
String numString="23 10 -8 0 3 7 108";
String sortStr=sortNumberString(numString);
System.out.println("排序的结果是"+sortStr);
}
private static String sortNumberString(String numString) {
//1.将给定的字符串分解成多个数字格式字符串
String numStrings=toStringArray(numString);
//2.将字符串数组转成int数组
int nums=toIntArray(numStrings);
//3.对数组排序
sort(nums);
//4.将int数组转成字符串
return toString(nums);
}
private static String toString(int nums) {
StringBuffer stringBuffer=new StringBuffer();
for (int i = 0; i 《 nums.length; i++) {
if (i!=nums.length-1) {
stringBuffer.append(nums+"《");
}else{
stringBuffer.append(nums);
}
}
return stringBuffer.toString();
}
private static void sort(int nums) {
Arrays.sort(nums);
}
private static int numStrings) {
int;
for (int i = 0; i 《 numStrings.length; i++) {
String s=numStrings;
nums=Integer.parseInt(s);
}
return nums;
}
private static String toStringArray(String numString) {
String numberStr=numString.split(" ");
for (int i = 0; i 《 numberStr.length; i++) {
System.out.println("抽出数字"+numberStr);
}
return numberStr;
}
}

java的list集合如何根据对象中的某个字段排序

下面的代码是根据学生年龄排序学生list 的一个例子：

import java.util.ArrayList;
import java.util.List;
class Student {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
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 String toString() {
return "Perosn ";
}
}
public class App {
 
    public static void main(String args) {
    
    List《Student》 students = new ArrayList《》();
    
    students.add(new Student("abc", 12));
    students.add(new Student("bcd", 20));
    students.add(new Student("cde", 17));
    students.add(new Student("def", 25));
    students.add(new Student("efg", 15));
    
    students.sort((x, y) -》 Integer.compare(x.getAge(), y.getAge()));
    
    for (Student stu : students) {
    System.out.println(stu);
    }
    }
}

运行结果：

如何用java对字符串进行排序

import java.util.*;
public class  CharSort
{
private static Scanner sc=new Scanner(System.in);
private static StringBuffer sb=new StringBuffer();
public static void main(String args) 
{
System.out.println("\n\t\t==========字符串排序!==========\n");
init();
}//初始化!
private static void init()
{
System.out.println("请输入:");
for (; ; )
{
String a=input();
char arr=a.toCharArray();
Arrays.sort(arr);
sb.append(a);
print(arr,sb);
}
}
//扫描!
private static String input()
{
String a=sc.nextLine();
return a;
}
//打印!
private static void print(char arr,StringBuffer sb)
{
System.out.println("\n字符串排序演示:");
for (int i=0;i《arr.length ;i++ )
{
System.out.print(arr);
}
System.out.println("\n=====================\n倒序演示:");
System.out.print(sb.reverse());
}
}

java8代码实现某字段排序,是不是该字段必须有值

java8代码实现某字段排序，是该字段必须有值。当使用collation时，字段locale必须要有值，numericOrdering决定字符串是否按照数值来排序，默认为false。

java list 相同的字段排序

1. 集合类List存放的数据，默认是按照放入顺序排序的。我们也可以对list中某一个元素进行排序。例如;
package test.tool.gui.dbtool.util;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class Test {
public static void main(String args) {
List list = new ArrayList();
2.创建3个学生对象，年龄分别是20、19、21，并将他们依次放入List中
Student s1 = new Student();
s1.setAge(20);
Student s2 = new Student();
s2.setAge(19);
Student s3 = new Student();
s3.setAge(21);
list.add(s1);
list.add(s2);
list.add(s3);
System.out.println("排序前："+list);
Collections.sort(list, new Comparator(){
public int compare(Student o1, Student o2) {
//按照学生的年龄进行升序排列
if(o1.getAge() 》 o2.getAge()){
return 1;
}
if(o1.getAge() == o2.getAge()){
return 0;
}
return -1;
}
});
System.out.println("排序后："+list);
}
}
class Student{
private int age;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return getAge()+"";
}

}

java中一个List集合，放的都是从不同的表中查出来的数据，请问我怎样可以根据其中的一个字段进行list排序

用 Collections.sort（）排序，给你个例子，你参考下

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class $ {
    public static void main(String args) {
        List《Bean》 data = new ArrayList《Bean》();
        data.add(new Bean("aaaaa", 20));
        data.add(new Bean("bbbbb", 10));
        System.out.println("排序前:" + data);
        Collections.sort(data, new Comparator《Bean》() {
            public int compare(Bean o1, Bean o2) {
                return o1.getName().compareTo(o2.getName());
            }
        });
        System.out.println("按name升序:" + data);
        Collections.sort(data, new Comparator《Bean》() {
            public int compare(Bean o1, Bean o2) {
                return o2.getName().compareTo(o1.getName());
            }
        });
        System.out.println("按name降序:" + data);
        Collections.sort(data, new Comparator《Bean》() {
            public int compare(Bean o1, Bean o2) {
                return o1.getAge() - o2.getAge();
            }
        });
        System.out.println("按age升序:" + data);
        Collections.sort(data, new Comparator《Bean》() {
            public int compare(Bean o1, Bean o2) {
                return o2.getAge() - o1.getAge();
            }
        });
        System.out.println("按age降序:" + data);
    }
}
class Bean {
    private String name;
    private int age;
    public Bean(String name, int age) {
        this.name = name;
        this.age = age;
    }
    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;
    }
    public String toString() {
        return "";
    }
}

JAVA中有哪几种常用的排序方法

最主要的是冒泡排序、选择排序、插入排序以及快速排序
1、冒泡排序

冒泡排序是一个比较简单的排序方法。在待排序的数列基本有序的情况下排序速度较快。若要排序的数有n个，则需要n-1轮排序，第j轮排序中，从第一个数开始，相邻两数比较，若不符合所要求的顺序，则交换两者的位置；直到第n+1-j个数为止，第一个数与第二个数比较，第二个数与第三个数比较，......，第n-j个与第n+1-j个比较，共比较n-1次。此时第n+1-j个位置上的数已经按要求排好，所以不参加以后的比较和交换操作。

例如：第一轮排序：第一个数与第二个数进行比较，若不符合要求的顺序，则交换两者的位置，否则继续进行二个数与第三个数比较......。直到完成第n-1个数与第n个数的比较。此时第n个位置上的数已经按要求排好，它不参与以后的比较和交换操作；第二轮排序：第一个数与第二个数进行比较，......直到完成第n-2个数与第n-1个数的比较；......第n-1轮排序：第一个数与第二个数进行比较，若符合所要求的顺序，则结束冒泡法排序；若不符合要求的顺序，则交换两者的位置，然后结束冒泡法排序。

共n-1轮排序处理，第j轮进行n-j次比较和至多n-j次交换。

从以上排序过程可以看出，较大的数像气泡一样向上冒，而较小的数往下沉，故称冒泡法。

public void bubbleSort(int a)

{

int n = a.length;

for(int i=0;i《n-1;i++)

{

for(int j=0;j《n-i-1;j++)

{

if(a)

{

int temp = a;

a;

a = temp;

}

}

}

}

2、选择排序

选择法的原理是先将第一个数与后面的每一个数依次比较,不断将将小的赋给第一个数,从而找出最小的,然后第二个数与后面的每一个数依次比较,从而找出第二小的,然后第三个数与后面的每一个数依次比较,从而找出第三小的.....直到找到最后一个数。

public void sort(int x)

{

int n=x.length;

int k,t;

for(int i=0;i《n-1;i++)

{

k=i;

for(int j=i+1;j=n;j++)

{

if(x)k=j;

if(k!=i)

{

t=x;

x;

x=t;

}

}

}

}
3、插入排序

插入排序的原理是对数组中的第i个元素，认为它前面的i-1个已经排序好，然后将它插入到前面的i-1个元素中。插入排序对少量元素的排序较为有效.

public void sort(int obj)

{

for(int j=1;j《obj.length;j++)

{

int key=obj;

int i=j-1;

while(i》=0&&obj》key)

{

obj;

i--;

}

obj=key;

}

}

4、快速排序

快速排序是对冒泡排序的一种改进。它的基本思想是：通过一次排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按次方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此大道整个数据变成有序序列。

public void quickSort(int obj,int low,int high)

{

int i=low;

int j=high;

int keyValue=obj;

while(i《j)

{

int temp=0;

while(i《j&&obj》=keyValue)

{

j=j-1;

}

temp=obj;

obj;

obj=temp;

while(i《j&&obj《=keyValue)

{

i=i+1;

}

temp=obj;

obj;

obj=temp;

}

obj=keyValue;

if(low《i-1)

{

quickSort(obj,low,i-1);

}

if(high》i+1)

{

quickSort(obj,i+1,high);

}

}

java中怎么对一串字符进行排序！

import java.util.Arrays;
public class StringSort {
public static void main(String args) {
String string = "to good too no string and now";
String sortString = sortChar(string);
System.out.println(sortString);
}
private static String sortChar(String str) {
// 1.将字符串转化成数组
char chs = stringToArray(str);
// 2.对数组进行排序
sort(chs);
// 3.将数组转成字符串
return toString(chs);
}
private static String toString(char chs) {
return new String(chs);
}
// 对字符数组进行升序排序
private static void sort(char chs) {
Arrays.sort(chs);
}
// 将字符串转化成为数组
private static char stringToArray(String string) {
return string.toCharArray();
}
}