java集合排序方法（“java set”集合的值可以排序吗）

本文目录

• “java set”集合的值可以排序吗
• java中,如何实现集合的升序和降序排列
• java list集合中抽取每个字符串元素中的数字进行排序
• java 集合中怎么将元素倒序排列
• Java中如何对集合排序
• java的list集合如何根据对象中的某个字段排序
• 请问Java中如何用compareTo方法对集合进行排序啊

“java set”集合的值可以排序吗

Set集合的排序
我们知道,Set集合是无序的,
可以使用TreeSet类,那么TreeSet进行排序的规则是怎样的呢?
1 TreeSet支持两种排序方式,自然排序和定制排序,在默认情况下,TreeSet采用自然排序.
自然排序:
TreeSet会调用集合元素的compareTo(Object obj)方法来比较元素之间的大小关系,然后将集合的元素按升序排列,这种方式就是自然排序.
为什么集合元素有compareTo方法,因为集合元素对象实现了Comparable接口,该方法返回一个整数值,当一个对象调用该方法与另一个对象进行比较,例如:
obj1.compareTo(obj2)如果返回0,表示这两个对象相等,如果该方法返回一个正整数,表示obj1大于obj2如果该方法返回一个负整数,表示obj1小于obj2
所以需要使用TreeSet集合进行自然排序,元素必须实现Comparable接口,但是Java一些常用的类已经实现了该接口,例如:String Character Boolean Date Time
BigDecimal BigInteger等
如:
TreeSet《String》 ts = new TreeSet《String》();
ts.add("b");
ts.add("c");
ts.add("a");
System.out.println(ts);
结果：a b c

java中,如何实现集合的升序和降序排列

单纯的字符串或者数字排列可用Collections.sort(object o)方法，这样方便。
如果是要对对象中的某一进行排序，则可实现Comparator接口，复写其中的Compare方法；然后调用Collections.sort(object 0 , Comparator c)方法;
说的只是思路，具体问题可以查看帮助文档。

java list集合中抽取每个字符串元素中的数字进行排序

1. 分析问题，集合中每一个元素都含有数字，需要得到里面的数字存入一个集合或者数组中
   

2. 循环遍历字符串，根据下标判断每一个字符是否是数字，是的话加入一个空的字符串中，遍历一遍后得到原字符串中的数字字符串，转换成数字存入数组，进行升序排序

3. import java.util.ArrayList;
   import java.util.Arrays;
   public class Test20 {
   public static int getNum(String s) {// 获取字符串中的数字
   String num = "";
   for (int i = 0; i 《 s.length(); i++) {
   if (s.charAt(i) 》= ’0’ && s.charAt(i) 《= ’9’) {// 遍历判断是否为数字
   num += s.charAt(i);
   }
   }
   return Integer.parseInt(num);
   }
   public static void main(String args) {
   ArrayList《String》 list = new ArrayList《String》();// 字符串集合
   list.add("abc123");
   list.add("我是栗子1");
   list.add("我是栗子2");
   list.add("我是栗子3是栗子4");
   list.add("栗子100"); // 例子
   int;// 定义一个数组用来存放数字
   for (int i = 0; i 《 list.size(); i++) {
   array = getNum(list.get(i));// 遍历集合，调用方法获得里面的数字并存入数组
   }
   Arrays.sort(array);// 升序排序
   for (int i : array) {
   System.out.println(i);// 遍历输出
   }
   }
   }

4. 结果：

   1
   2
   34
   100
   123

java 集合中怎么将元素倒序排列

方法一：实现Comparable接口排序package collsort.comparable;
package com.cvicse.sort.comparable;
public class Cat implements Comparable《Cat》 {
private int age;
private String name;
public Cat(int age, String name) {
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
......
public int compareTo(Cat o) {
return this.getAge() - o.getAge();
}
......
}
通过实现Comparable接口实现个性化排序测试。排序测试，Collection.sort(list)升序排列Collections.sort(list, Collections.reverseOrder());降序排列；Collections.reverse(list);反转排序，先输出列表最后一个元素
public class TestComparable {
public static void main(String args) {
test();
test2();
}
public static void test() {
......
List《Cat》 listCat1 = new ArrayList《Cat》();
Cat cat1 = new Cat(34, "hehe");
Cat cat2 = new Cat(12, "haha");
Cat cat3 = new Cat(23, "leizhimin");
Cat cat4 = new Cat(13, "lavasoft");
listCat1.add(cat1);
listCat1.add(cat2);
listCat1.add(cat3);
......
System.out.println("调用Collections.sort(List《T》 list)listCat2升序排序：");
Collections.sort(listCat1);
System.out.println("降序排列元素:");
Collections.sort(listCat1, Collections.reverseOrder());
System.out.println("Collections.reverse 从列表中最后一个元素开始输出:");
Collections.reverse(listCat1);
......
}
/**
* 针对数组的排序
*/
public static void test2() {
String { "z", "a", "C" };
System.out.println("数组转换为列表");
List《String》 list = Arrays.asList(strArray);
System.out.println("顺序排序列表");
Collections.sort(list);
System.out
.println("按String实现的Comparator对象String.CASE_INSENSITIVE_ORDER排序----");
Collections.sort(list, String.CASE_INSENSITIVE_ORDER);
System.out.println("倒序排序列表");
Collections.sort(list, Collections.reverseOrder());
......
}
}
方法二：实现Comparator接口排序
public class Person {
private int age;
private String name;
......
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
......
}
实现了Comparator接口，重写了compare方法
import java.util.Comparator;
public class PersonComparator implements Comparator《Person》 {
public int compare(Person o1, Person o2) {
return o1.getAge() - o2.getAge();
}
}
测试方法
public class TestComparator {
public static void main(String args) {
test1();
}
public static void test1() {
System.out.println("升序排序测试:");
List《Person》 listPerson = new ArrayList《Person》();
Person person1 = new Person(34, "lavasoft");
Person person2 = new Person(12, "lavasoft");
Person person3 = new Person(23, "leizhimin");
Person person4 = new Person(13, "sdg");
listPerson.add(person1);
listPerson.add(person2);
listPerson.add(person3);
Comparator《Person》 ascComparator = new PersonComparator();
System.out.println("排序后集合为:");
// 利用Collections类静态工具方法对集合List进行排序
Collections.sort(listPerson, ascComparator);
System.out.println("\n降序排序测试:");
// 从升序排序对象产生一个反转(降序)的排序对象
Comparator《Person》 descComparator = Collections
.reverseOrder(ascComparator);
System.out.println("利用反转后的排序接口对象对集合List排序并输出:");
Collections.sort(listPerson, descComparator);
outCollection(listPerson);
}
}

Java中如何对集合排序

Java内建的排序（冒泡）：Java集合有两个实现的工具类，Collections和Arrays。Collections针对集合类型。Arrays针对数组。只需要一个为你排序需要的定制的Comparator或Comparable的实现，将其作为参数传给Collections或Arrays的sort方法就行。
可以自己用程序去实现这个排序。用for从原List里面一个一个拿出来比较然后一个新建的List里面去。
楼主看一下参考资料。

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中如何用compareTo方法对集合进行排序啊

import java.util.*;
class Student implements Comparable
{
public String sName;
public Student()
{

}
public Student(String sName)
{
this.sName=sName;
}
public int compareTo(Object o)//重写compareTo方法
{
Student tempStudent=(Student)o;
String temp=tempStudent.sName;
return this.sName.compareTo(temp); //按字符串sName的顺序排列Student
}
public String toString()
{
return this.sName;
}
}
class fggg {
public static void main(String args)
{
TreeSet ts=new TreeSet();//插入Student对象时，会自动调用compareTo方法
ts.add(new Student("DD"));
ts.add(new Student("CC"));
ts.add(new Student("BB"));
System.out.println(ts);
}
}