java中按照对象的某个字段进行中文排序 java对象集合根据字段排序

转载

jkfox 2024-07-10 21:40:02

文章标签 java 开发工具 System 数组 文章分类 Java 后端开发

Java集合对象排序测试

Java API针对集合类型排序提供了两种支持：

java.util.Collections.sort(java.util.List) 
  
java.util.Collections.sort(java.util.List, java.util.Comparator)

第一个方法要求所排序的元素类必须实现java.lang.Comparable接口。
第二个方法要求实现一个java.util.Comparator接口。

java.lang.Comparable接口和java.util.Comparator接口是Java对排序最提供最基本支持。这两个接口不但可以用于集合元素排序，还可以用于数组排序。

如果数组或集合元素是String类型，则可以利用Java API实现的Comparator<String>对象String.CASE_INSENSITIVE_ORDER为容器元素排序。

下面给出两个里测试，涵盖集合和数组的排序，并且还演示了数组和集合的相互转换：

例子一：实现Comparable接口排序

package collsort.comparable; 
    

/** 
* Created by IntelliJ IDEA. 
* User: leizhimin 
* Date: 2008-3-29 22:21:19 
* Company: LavaSoft([url]http://lavasoft.blog.51cto.com[/url]) 
* 要排序的元素对象 
*/ 
    
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 String getName() { 
    
         
    return name; 
    
    } 
    

     
    public 
    void setName(String name) { 
    
         
    this.name = name; 
    
    } 
    


     
    public String toString() { 
    
         
    return 
    "Cat{" + 
    
                 
    "age=" + age + 
    
                 
    ", name='" + name + '\'' + 
    
                '}'; 
    
    } 
    

     
    public 
    int compareTo(Cat o) { 
    
         
    return 
    this.getAge() - o.getAge(); 
    
    } 
    
}

package collsort.comparable; 
   

import java.util.*; 
   

/** 
* Created by IntelliJ IDEA. 
* User: leizhimin 
* Date: 2008-3-29 22:24:12 
* Company: LavaSoft([url]http://lavasoft.blog.51cto.com[/url]) 
* 通过实现Comparable接口实现个性化排序测试 
*/ 
   
public 
   class TestComparable { 
   

     
   public 
   static String outCollection(Collection coll) { 
   
        StringBuffer sb = 
   new StringBuffer(); 
   
         
   for (Object obj : coll) { 
   
            sb.append(obj + 
   "\n"); 
   
        } 
   
        System.out.println(sb.toString()); 
   
         
   return sb.toString(); 
   
    } 
   

     
   public 
   static 
   void main(String args[]) { 
   
        test(); 
   
        test2(); 
   
    } 
   

     
   public 
   static 
   void test() { 
   
        System.out.println( 
   "----------test()---------"); 
   
        System.out.println( 
   "升序排序测试:"); 
   
        List<Cat> listCat = 
   new ArrayList<Cat>(); 
   
        Cat cat1 = 
   new Cat(34, 
   "hehe"); 
   
        Cat cat2 = 
   new Cat(12, 
   "haha"); 
   
//        Person catx = new Person(12, "lavasoft");  
   
        Cat cat3 = 
   new Cat(23, 
   "leizhimin"); 
   
        Cat cat4 = 
   new Cat(13, 
   "lavasoft"); 
   

        listCat.add(cat1); 
   
        listCat.add(cat2); 
   
        listCat.add(cat3); 
   
//        listCat.add(catx);  
   

        System.out.println( 
   "原集合为:"); 
   
        outCollection(listCat); 
   

        System.out.println( 
   "调用Collections.sort(List<T> list)排序："); 
   
        Collections.sort(listCat); 
   
        outCollection(listCat); 
   
         
   
        System.out.println( 
   "逆序排列元素:"); 
   
        Collections.sort(listCat, Collections.reverseOrder()); 
   
        outCollection(listCat); 
   

        System.out.println( 
   "再次逆序排列元素:"); 
   
        Collections.reverse(listCat); 
   
        outCollection(listCat); 
   

        System.out.println( 
   "添加一个元素后输出集合："); 
   
        listCat.add(cat4); 
   
        outCollection(listCat); 
   

        System.out.println( 
   "排列后输出:"); 
   
        Collections.sort(listCat); 
   
        outCollection(listCat); 
   
    } 
   

     
   /** 
     * 针对数组的排序 
     */ 
   
     
   public 
   static 
   void test2(){ 
   
        String[] strArray = 
   new String[] { 
   "z", 
   "a", 
   "C"}; 
   
        System.out.println( 
   "-------------数组转换为列表-------------"); 
   
        List<String> list = Arrays.asList(strArray); 
   
        outCollection(list); 
   

        System.out.println( 
   "-------------列表转换为数组(1)-------------"); 
   
        String[] strArrayNew1 = list.toArray(strArray); 
   
         
   for(String str:strArrayNew1){ 
   
            System.out.println(str); 
   
        } 
   
        System.out.println( 
   "-------------列表转换为数组(2)-------------"); 
   
        String[] strArrayNew2 = (String[]) list.toArray(); 
   
         
   for(String str:strArrayNew2){ 
   
            System.out.println(str); 
   
        } 
   

        System.out.println( 
   "-------------顺序排序列表-------------"); 
   
        Collections.sort(list); 
   
        outCollection(list); 
   

        System.out.println( 
   "-----按String实现的Comparator对象String.CASE_INSENSITIVE_ORDER排序----"); 
   
        Collections.sort(list, String.CASE_INSENSITIVE_ORDER); 
   
        outCollection(list); 
   

        System.out.println( 
   "-------------倒序排序列表-------------"); 
   
        Collections.sort(list, Collections.reverseOrder()); 
   
        outCollection(list); 
   

        System.out.println( 
   "-----按String实现的Comparator对象String.CASE_INSENSITIVE_ORDER排序----"); 
   
        Collections.sort(list, String.CASE_INSENSITIVE_ORDER); 
   
        outCollection(list); 
   

        System.out.println( 
   "-----反转列表元素的顺序------"); 
   
        Collections.reverse(list); 
   
        outCollection(list); 
   
    } 
   
}

运行结果：

----------test()---------
升序排序测试:
原集合为:

Cat{age=34, name='hehe'} 
    
Cat{age=12, name='haha'} 
    
Cat{age=23, name='leizhimin'}

调用Collections.sort(List<T> list)排序：

Cat{age=12, name='haha'} 
    
Cat{age=23, name='leizhimin'} 
    
Cat{age=34, name='hehe'}

逆序排列元素:

Cat{age=34, name='hehe'} 
    
Cat{age=23, name='leizhimin'} 
    
Cat{age=12, name='haha'}

再次逆序排列元素:

Cat{age=12, name='haha'} 
    
Cat{age=23, name='leizhimin'} 
    
Cat{age=34, name='hehe'}

添加一个元素后输出集合：

Cat{age=12, name='haha'} 
    
Cat{age=23, name='leizhimin'} 
    
Cat{age=34, name='hehe'} 
    
Cat{age=13, name='lavasoft'}

排列后输出:

Cat{age=12, name='haha'} 
    
Cat{age=13, name='lavasoft'} 
    
Cat{age=23, name='leizhimin'} 
    
Cat{age=34, name='hehe'}

-------------数组转换为列表-------------
z
a
C

-------------列表转换为数组(1)-------------
z
a
C
-------------列表转换为数组(2)-------------
z
a
C
-------------顺序排序列表-------------
C
a
z

-----按String实现的Comparator对象String.CASE_INSENSITIVE_ORDER排序----
a
C
z

-------------倒序排序列表-------------
z
a
C

-----按String实现的Comparator对象String.CASE_INSENSITIVE_ORDER排序----
a
C
z

-----反转列表元素的顺序------
z
C
a

Process finished with exit code 0

例子一：实现Comparator接口排序

package collsort.compare; 
    

/** 
* Created by IntelliJ IDEA. 
* User: leizhimin 
* Date: 2008-3-29 13:28:29 
* Company: LavaSoft([url]http://lavasoft.blog.51cto.com[/url]) 
* 要排序的元素对象 
*/ 
    
public 
    class Person { 
    
     
    private 
    int age; 
    
     
    private String name; 
    

     
    public Person( 
    int age, String name) { 
    
         
    this.age = age; 
    
         
    this.name = name; 
    
    } 
    

     
    public 
    int getAge() { 
    
         
    return age; 
    
    } 
    

     
    public 
    void setAge( 
    int age) { 
    
         
    this.age = age; 
    
    } 
    

     
    public String getName() { 
    
         
    return name; 
    
    } 
    

     
    public 
    void setName(String name) { 
    
         
    this.name = name; 
    
    } 
    

     
    public String toString() { 
    
         
    return 
    "Person{" + 
    
                 
    "age=" + age + 
    
                 
    ", name='" + name + '\'' + 
    
                '}'; 
    
    } 
    
}

package collsort.compare; 
    

import java.util.Comparator; 
    

/** 
* Created by IntelliJ IDEA. 
* User: leizhimin 
* Date: 2008-3-29 13:29:35 
* Company: LavaSoft([url]http://lavasoft.blog.51cto.com[/url]) 
* Person类的排序接口 
*/ 
    
public 
    class PersonComparator 
    implements Comparator<Person> { 
    
     
    /** 
     * 排序接口算法实现 
     * 
     * @param o1 
     * @param o2 
     * @return 比较结果的大小 
     */ 
    
     
    public 
    int compare(Person o1, Person o2) { 
    
         
    return o1.getAge() - o2.getAge(); 
    
    } 
    
}

package collsort.compare; 
    

import collsort.compare.Person; 
    

import java.util.*; 
    

/** 
* Created by IntelliJ IDEA. 
* User: leizhimin 
* Date: 2008-3-29 13:30:49 
* Company: LavaSoft([url]http://lavasoft.blog.51cto.com[/url]) 
* 通过Comparator接口实现个性化排序测试 
* 结论:Comparator接口是一个为集合对象排序的基本算法,其中的compare方法是比较两个元素对象的比较方式.Java Collection框架利用这个算法实现了不同集合类型对象排序方式的统一.<br> 
* 排序针对的是确切的集合对象,当集合对象的元素发生变化时,集合内的元素不会自动重新排序. 
*/ 
    
public 
    class TestComparator { 
    
     
    public 
    static String outCollection(Collection coll) { 
    
        StringBuffer sb = 
    new StringBuffer(); 
    
         
    for (Object obj : coll) { 
    
            sb.append(obj + 
    "\n"); 
    
        } 
    
        System.out.println(sb.toString()); 
    
         
    return sb.toString(); 
    
    } 
    

     
    public 
    static 
    void main(String args[]) { 
    
        test1(); 
    
    } 
    

     
    public 
    static 
    void test1() { 
    
        System.out.println( 
    "----------test1()---------"); 
    
        System.out.println( 
    "升序排序测试:"); 
    
        List<Person> listPerson = 
    new ArrayList<Person>(); 
    
        Person person1 = 
    new Person(34, 
    "lavasoft"); 
    
        Person person2 = 
    new Person(12, 
    "lavasoft"); 
    
//        Person personx = 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); 
    
//        listPerson.add(personx);  
    

        Comparator<Person> ascComparator = 
    new PersonComparator(); 
    

        System.out.println( 
    "原集合为:"); 
    
        outCollection(listPerson); 
    

        System.out.println( 
    "排序后集合为:"); 
    
         
    //利用Collections类静态工具方法对集合List进行排序  
    
        Collections.sort(listPerson, ascComparator); 
    
        outCollection(listPerson); 
    

        System.out.println( 
    "在继续添加一个Person对象,集合为:"); 
    
        listPerson.add(person4); 
    
        outCollection(listPerson); 
    

        System.out.println( 
    "添加一个对象后,重新排序输出:"); 
    
        Collections.sort(listPerson, ascComparator); 
    
        outCollection(listPerson); 
    

        System.out.println( 
    "\n降序排序测试:"); 
    
         
    //从升序排序对象产生一个反转(降序)的排序对象  
    
        Comparator<Person> descComparator = Collections.reverseOrder(ascComparator); 
    
        System.out.println( 
    "利用反转后的排序接口对象对集合List排序并输出:"); 
    
        Collections.sort(listPerson, descComparator); 
    
        outCollection(listPerson); 
    

        System.out.println( 
    "\n求最大最小元素测试:"); 
    
        Person p_max = Collections.max(listPerson, ascComparator); 
    
        Person p_min = Collections.min(listPerson, ascComparator); 
    
        System.out.println( 
    "最大元素为:" + p_max.toString()); 
    
        System.out.println( 
    "最小元素为:" + p_min.toString()); 
    
    } 
    
}

运行结果：

----------test1()---------
升序排序测试:
原集合为:

Person{age=34, name='lavasoft'} 
    
Person{age=12, name='lavasoft'} 
    
Person{age=23, name='leizhimin'}

排序后集合为:

Person{age=12, name='lavasoft'} 
    
Person{age=23, name='leizhimin'} 
    
Person{age=34, name='lavasoft'}

在继续添加一个Person对象,集合为:

Person{age=12, name='lavasoft'} 
    
Person{age=23, name='leizhimin'} 
    
Person{age=34, name='lavasoft'} 
    
Person{age=13, name='sdg'}

添加一个对象后,重新排序输出:

Person{age=12, name='lavasoft'} 
    
Person{age=13, name='sdg'} 
    
Person{age=23, name='leizhimin'} 
    
Person{age=34, name='lavasoft'}

降序排序测试:
利用反转后的排序接口对象对集合List排序并输出:

Person{age=34, name='lavasoft'} 
    
Person{age=23, name='leizhimin'} 
    
Person{age=13, name='sdg'} 
    
Person{age=12, name='lavasoft'}

求最大最小元素测试:
最大元素为:Person{age=34, name='lavasoft'}
最小元素为:Person{age=12, name='lavasoft'}

Process finished with exit code 0

最后说明一下，Java如何通过所实现接口的方法进行排序是API内部的事情，Java这样处理排序目的就是对容器元素排序有一个统一的方式，以简化编程。

当然也可以自己通过别的算法进行元素排序，在此不做讨论。

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：人脸识别训练pytorch 人脸识别训练图片

下一篇：为什么表中的索引数量建议设置为6个为什么用索引

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯

java中按照对象的某个字段进行中文排序 java对象集合根据字段排序

java中按照对象的某个字段进行中文排序 java对象集合根据字段排序

51CTO博客