java對集合進行排序

A. 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, "leimin");
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[] strArray = new 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, "leimin");
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);
}
}

B. java怎樣對集合按照實體類的欄位排序

importjava.util.Comparator;
importjava.util.TreeSet;

/*
*需求：請按照姓名的長度排序
*
*TreeSet集合保證元素排序和唯一性的原理
*唯一性：是根據比較的返回是否是0來決定。
*排序：
*		A:自然排序(元素具備比較性)
*			讓元素所屬的類實現自然排序介面Comparable
*		B:比較器排序(集合具備比較性)
*			讓集合的構造方法接收一個比較器介面的子類對象Comparator
*/
publicclassTreeSetDemo{
	publicstaticvoidmain(String[]args){
		//創建集合對象
		//TreeSet<Student>ts=newTreeSet<Student>();//自然排序
		//publicTreeSet(Comparatorcomparator)//比較器排序
		//TreeSet<Student>ts=newTreeSet<Student>(newMyComparator());

		//如果一個方法的參數是介面，那麼真正要的是介面的實現類的對象
		//而匿名內部類就可以實現這個東西
		TreeSet<Student>ts=newTreeSet<Student>(newComparator<Student>(){
			@Override
			publicintcompare(Students1,Students2){
				//姓名長度
				intnum=s1.getName().length()-s2.getName().length();
				//姓名內容
				intnum2=num==0?s1.getName().compareTo(s2.getName())
						:num;
				//年齡
				intnum3=num2==0?s1.getAge()-s2.getAge():num2;
				returnnum3;
			}
		});

		//創建元素
		Students1=newStudent("linqingxia",27);
		Students2=newStudent("zhangguorong",29);
		Students3=newStudent("wanglihong",23);
		Students4=newStudent("linqingxia",27);
		Students5=newStudent("liushishi",22);
		Students6=newStudent("wuqilong",40);
		Students7=newStudent("fengqingy",22);
		Students8=newStudent("linqingxia",29);

		//添加元素
		ts.add(s1);
		ts.add(s2);
		ts.add(s3);
		ts.add(s4);
		ts.add(s5);
		ts.add(s6);
		ts.add(s7);
		ts.add(s8);

		//遍歷
		for(Students:ts){
			System.out.println(s.getName()+"---"+s.getAge());
		}
	}
}

C. java 實現ArrayList的sort

在排序中,最重要的是自己實現自己的比較的行數,即是implements Comparator
實現方法 public int compare(Object o1, Object o2) 最為重要..

舉個例子:
package book.arrayset;

import java.util.Comparator;

/**
* 整數比較器，將整數按降序排列
*/
class MyIntComparator implements Comparator{

/**
* o1比o2大，返回-1；o1比o2小，返回1。
*/
public int compare(Object o1, Object o2) {
int i1 = ((Integer)o1).intValue();
int i2 = ((Integer)o2).intValue();
if (i1 < i2){
return 1;
}
if (i1 > i2){
return -1;
}
return 0;
}
}

//上面的為比較的函數實現,下面真正的添加數據,

//通過調用上面的比較函數實現自定義排序的功能

package book.arrayset;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
* 對List中的元素排序
*/
public class SortList {

public static void output(List list){
if (list == null){
return;
}
for (int i=0; i<list.size(); i++){
System.out.print(list.get(i).toString() + " ");
}
System.out.println();
}

public static void main(String[] args) {
List list = new ArrayList();
list.add(new Integer(5));
list.add(new Integer(8));
list.add(new Integer(1));
list.add(new Integer(3));
list.add(new Integer(2));
list.add(new Double(3.1));
System.out.println("list開始狀態");
SortList.output(list);
//Collections.sort方法將用默認比較器排列list的元素
Collections.sort(list);
System.out.println("list被默認比較器排序後的狀態");
SortList.output(list);
//下面將list的元素按降序排列
Collections.sort(list, new MyIntComparator());
System.out.println("list被自定義比較器排序後的狀態");
SortList.output(list);

//因此，對於任意自定義類的對象，當保存在集合類容器中後，如果需要對它們進行排序，
//需要自己提供適應於自定義類的比較器，自定義比較器必須實現Comparator介面。
//然後採用Collections.sort(list, comparator);方法對容器進行排序。
}
}

D. java中兩個list集合如何排序

首先讓你的Article實現Comparable這個介面..

然後根據他的gxrq進行比較..

集合合成的話
list1.addAll(list2)就行了。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;

public class Article implements Comparable<Article> {

public static void main(String[] args) {
List<Article> list1 = new ArrayList<Article>();
List<Article> list2 = new ArrayList<Article>();
Article a1 = new Article();
a1.setGxrq(new Date(100, 5, 5));
Article a2 = new Article();
a2.setGxrq(new Date(100, 3, 5));
list1.add(a1);
list2.add(a2);
list1.addAll(list2);
Collections.sort(list1);
for(Article a : list1) {
System.out.println(a.getGxrq());
}
}

private String title;

private String content;

private Date gxrq;

public int compareTo(Article arg0) {
return this.gxrq.compareTo(arg0.gxrq);
}

public String getContent() {
return content;
}

public void setContent(String content) {
this.content = content;
}

public Date getGxrq() {
return gxrq;
}

public void setGxrq(Date gxrq) {
this.gxrq = gxrq;
}

public String getTitle() {
return title;
}

public void setTitle(String title) {
this.title = title;
}
}

E. JAVA中list集合的排序

根據字元串的含義，進行對象化，比如，Student，有三個屬性，序號，姓名，分數
注意重寫Student的Compareable介面
然後,List<String>變成List<Student> students=new ArrayList<Student>
然後，遍歷list,算出平均分，放入新的SortList<Student>
列印結果

F. java中如何對數組和集合進行排序

java中對集合排序，可以使用Collections.sort來進行排序，可以對中文、字母、數字進行排序，當比較的是對象時候，讓該類實現comparable介面，示例如下：
Collections.sort(dataMap, new Comparator<Map<String, Object>>() { //排序介面實現方法 @Override public int compare(Map<String, Object> lhs, Map<String, Object> rhs) { switch (whichsort) { case System_OpenPosition_Sort_Currency: String d2 = ((String) rhs.get(Instrument)); String d1 = (String) lhs.get(Instrument); if (d2 != null && d1 != null) { int flag = d1.compareTo(d2); if (flag == 0) { Double d3 = ((Double) rhs.get(OpenPrice)); Double d4 = (Double) lhs.get(OpenPrice); if (d3 != null && d4 != null) { int flag2 = d4.compareTo(d3); if (flag2 == 0) { String d5 = ((String) rhs.get(BuySell)); String d6 = (String) lhs.get(BuySell);//文字排序 if (d5 != null && d6 != null) { return d6.compareTo(d5);//返回一個int類型，用來判斷是否大於、小於還是等於 } } return d4.compareTo(d3); } } else { return flag; } // return d1.compareTo(d2); }