java集合arraylist排序（如何实现对ArrayList排序 sort）

本文目录

• 如何实现对ArrayList排序 sort
• java arraylist 按照对象的属性排序
• 怎样用Java Sort Arraylist
• java ArrayList排序底层是怎么实现的
• java 怎么将List里面数据排序
• java如何对ArrayList中对象按照该对象某属性排序
• Java中怎样对ArrayList集合中的指定列排序
• java ArrayList 降序排序问题
• java如何对Arraylist数组进行排序（用comparable）
• Java中的ArrayList怎么进行冒泡排序

如何实现对ArrayList排序 sort

package com.collection;
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) {
Student zlj = new Student("丁晓宇", 21);
Student dxy = new Student("赵四", 22);
Student cjc = new Student("张三", 11);
Student lgc = new Student("刘武", 19);
List《Student》 studentList = new ArrayList《Student》();
studentList.add(zlj);
studentList.add(dxy);
studentList.add(cjc);
studentList.add(lgc);
System.out.println("按年龄升序：");
Collections.sort(studentList, new SortByAge());
for (Student student : studentList) {
System.out.println(student.getName() + " / " + student.getAge());
}
System.out.println();
System.out.println("按姓名排序：");
Collections.sort(studentList, new SortByName());
for (Student student : studentList) {
System.out.println(student.getName() + " / " + student.getAge());
}
}
}
class SortByAge implements Comparator {
public int compare(Object o1, Object o2) {
Student s1 = (Student) o1;
Student s2 = (Student) o2;
return s1.getAge().compareTo(s2.getAge());
// if (s1.getAge() 》 s2.getAge())
// return 1;
// return -1;
}
}
class SortByName implements Comparator {
public int compare(Object o1, Object o2) {
Student s1 = (Student) o1;
Student s2 = (Student) o2;
return s1.getName().compareTo(s2.getName());
}
}
输出结果：
按年龄升序：
张三 / 11
刘武 / 19
丁晓宇 / 21
赵四 / 22
按姓名排序：
丁晓宇 / 21
刘武 / 19
张三 / 11
赵四 / 22

java arraylist 按照对象的属性排序

List中的元素是对象的话，若要按该List中元素的某个属性进行排序，那么应该重写里面元素的hashCode和equals方法，然后再排序。比如该问题要重写course的hashCode和equals方法

怎样用Java Sort Arraylist

在排序中,最重要的是自己实现自己的比较的行数,即是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);方法对容器进行排序。
}
}

java ArrayList排序底层是怎么实现的

list是一个集合，可以存入很多种对象类型。如果你存入的都是自定义类，怎么能排序呢。如果你用泛型存入字符串或是数字等，排序就是按照int
string这些类型进行排序，排序方法也有很多种比较法
冒泡法等。如果你想了解排序可以网上看一下各种排序的算法，自己体会下优缺点。

java 怎么将List里面数据排序

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class ArrayListOrder {
public static void main(String args) {
List《List《Integer》》 list = new ArrayList《List《Integer》》();
List《Integer》 arrayList1 = new ArrayList《Integer》();
arrayList1.add(2);
arrayList1.add(5);
arrayList1.add(6);
list.add(arrayList1);
List《Integer》 arrayList2 = new ArrayList《Integer》();
arrayList2.add(2);
arrayList2.add(4);
arrayList2.add(6);
list.add(arrayList2);
List《Integer》 arrayList3 = new ArrayList《Integer》();
arrayList3.add(2);
arrayList3.add(6);
arrayList3.add(6);
list.add(arrayList3);
List《Integer》 arrayList4 = new ArrayList《Integer》();
arrayList4.add(2);
arrayList4.add(1);
arrayList4.add(6);
list.add(arrayList4);
for (List《Integer》 tmpList : list) {
System.out.print(tmpList.get(1)+"   ");
}
System.out.println("");
//排序
Collections.sort(list,new Comparator《List《Integer》》(){
public int compare(List《Integer》 list1, List《Integer》 list2) {
//比较每个ArrayList的第二个元素
if(list1.get(1)==list2.get(1)){
return 0;
}else if(list1.get(1)》list2.get(1)){
return 1;
}else{
return -1;
}
}
});
for (List《Integer》 tmpList : list) {
System.out.print(tmpList.get(1)+"   ");
}
}
}

java如何对ArrayList中对象按照该对象某属性排序

这只是一个做过的例子，我最近很忙，只能提示你一下，相信你能弄出来的，
方法：重写方法
equals,就是在你定义的类里面加上下面的方法，但内容肯定不同啦。下面是一个例子你看一下就ok了。。。呵呵记得给分啦
。一定记住要重写equals方法，还有类要是想接口
compareable一个并不能少。今天晚了明天我吧完整的我的程序给你吧

Java中怎样对ArrayList集合中的指定列排序

ArrayList
就是一个可以改变大小的一维数组.当然
你可以往ArrayList里放ArrayList或者其它的容器什么的那就用标准的排序方法就行了
用容量类就用Collections.sort
数组就用Arrays.sort
还有什么不清楚直接m我
百度知道最近抽风了
不能回答追问

java ArrayList 降序排序问题

public static void main(String args) {

ArrayList《Integer》 arr=new ArrayList《》();
arr.add(89);
arr.add(78);
arr.add(56);
arr.add(92);
arr.add(76);

//升序排列；
Collections.sort(arr);

//逆序输出
Collections.reverse(arr);
for(int i=0;i《arr.size();i++){
//这就是你要的效果
System.out.println("0"+i+" "+arr.get(i));
}

}

java如何对Arraylist数组进行排序（用comparable）

看代码：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
public class Demo {
public static void main(String args) throws Exception {
Pair pairs = {
new Pair(0, 1),
new Pair(2, 9),
new Pair(7, 0),
new Pair(8, 8),
new Pair(8, 6),
new Pair(9, 2),
new Pair(1, 5),
new Pair(8, 2),
new Pair(9, 15),
new Pair(9, 5)
};
ArrayList《Pair》 pairList = new ArrayList《》(Arrays.asList(pairs));
System.out.println("排序前：");
System.out.println(Arrays.toString(pairs));
Arrays.sort(pairs); // 对数组排序
System.out.println("排序后：");
System.out.println(Arrays.toString(pairs));
System.out.println("排序前：");
System.out.println(pairList);
Collections.sort(pairList); // 对 ArrayList 排序
System.out.println("排序后：");
System.out.println(pairList);
}
}
// 继承 Comparable 接口排序该类是 “可排序的”
// 《》 里面的是排序时与当前实例进行比较的实例的类型
// 一般都和当前实例是同一个类型，比如这里就是 Pair 的实例 和 Pair 的实例比较
class Pair implements Comparable《Pair》 {
public int left;
public int right;
public Pair(int left, int right) {
this.left = left;
this.right = right;
}
@Override
public String toString() {
return "";
}
// 排序规则，先按 left 排序，再按 right 排序
@Override
public int compareTo(Pair that) {
if (this.left 》 that.left) {
return 1;
} else if (this.left 《 that.left) {
return -1;
} else if (this.right 》 that.right) {
return 1;
} else if (this.right 《 that.right) {
return -1;
}
return 0;
}
}

可以发现先按 left 排序，如果 left 相等，则按 right 排序

Java中的ArrayList怎么进行冒泡排序

java中的ArrayList进行冒泡排序，主要是循环遍历取出数据，然后进行比较排序，如下代码：

package com.qiu.lin.he;
import java.util.ArrayList;
public class Ceshi {
public static void main(String args) {
ArrayList《Integer》 list = new ArrayList《Integer》();
list.add(76);
list.add(4);
list.add(786);
list.add(43);
list.add(21);
list.add(432);
list.add(10);
for (int i = 0; i 《 list.size() - 1; i++) {
for (int j = 1; j 《 list.size() - i; j++) {
Integer a;
if (list.get(j - 1).compareTo(list.get(j)) 》 0) { // 比较两个整数的大小
a = list.get(j - 1);
list.set((j - 1), list.get(j));
list.set(j, a);//交换数据
}
}
}
for (Integer s : list) {
System.out.println(s.intValue());//输出arraylist的数据
}
}
}

运行结果如下：