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