如何对List集合中的数据进行排列

Posted 2023-05-17

参考技术A 方法一：实现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; 参考技术B [size=large][color=red]要对List排序,你要对List里装的这种类型的类实现排序接口(Comparable).
举个例子:

下面这个例子是对List<MyObject>进行排序.使用Collections.sort(List list);方法,此方法会调用MyObject的compareTo方法.所以在MyObject类定义里要实现compareTo方法.

Java代码
public class ListSort

/**
* main()
* 2010-4-2,下午09:25:57
*/
public static void main(String[] args)
// TODO Auto-generated method stub
List<MyObject> lists = new ArrayList<MyObject>();
MyObject obj1 = new MyObject("d");
MyObject obj2 = new MyObject("a");
lists.add(obj1);
lists.add(obj2);
Collections.sort(lists);
for (MyObject myObject : lists)
System.out.println(myObject.getContent());




class MyObject implements Comparable<MyObject>
private String content;
public MyObject(String _content)
this.content = _content;


public String getContent()
return content;


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


public int compareTo(MyObject obj)
// TODO Auto-generated method stub
if (null == obj) return 1;
else
return this.content.compareTo(obj.content);






下面是Collections.sort方法

Java代码
public static <T extends Comparable<? super T>> void sort(List<T> list)
Object[] a = list.toArray();
Arrays.sort(a);
ListIterator<T> i = list.listIterator();
for (int j=0; j<a.length; j++)
i.next();
i.set((T)a[j]);



实际上我们的MyObject类的方法compareTo是在Arrays.sort()中被调用的...
请看..

Java代码
public static void sort(Object[] a)
Object[] aux = (Object[])a.clone();
mergeSort(aux, a, 0, a.length, 0);


Java代码
private static void mergeSort(Object[] src,
Object[] dest,
int low,
int high,
int off)
int length = high - low;

// Insertion sort on smallest arrays
if (length < INSERTIONSORT_THRESHOLD)
for (int i=low; i<high; i++)
for (int j=i; j>low &&
((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)
swap(dest, j, j-1);
return;


// Recursively sort halves of dest into src
int destLow = low;
int destHigh = high;
low += off;
high += off;
int mid = (low + high) >> 1;
mergeSort(dest, src, low, mid, -off);
mergeSort(dest, src, mid, high, -off);

// If list is already sorted, just copy from src to dest. This is an
// optimization that results in faster sorts for nearly ordered lists.
if (((Comparable)src[mid-1]).compareTo(src[mid]) <= 0)
System.arraycopy(src, low, dest, destLow, length);
return;


// Merge sorted halves (now in src) into dest
for(int i = destLow, p = low, q = mid; i < destHigh; i++)
if (q >= high || p < mid && ((Comparable)src[p]).compareTo(src[q])<=0)
dest[i] = src[p++];
else
dest[i] = src[q++];


[/color][/size]

当然,这是一种实现排序的办法.还有一种是实现Comparator,实现这个接口,然后使用
Collections.sort(List list,Comparator c);这个方法来排序..本回答被提问者采纳

Java List集合

集合的概念

现实生活中：很多事物凑在一起

数学中的集合：具有共同属性的事物的总体

Java中的集合类：是一种工具类，就像是容器，储存任意数量的具有共同属性的对象

集合的作用

- 在类的内部，对数据进行组织

- 简单而快速的搜索大数量的条目

- 有的集合接口提供了一系列排列有序的元素，并且可以在序列之间快速的插入或者删除有关元素

- 有的集合接口提供了映射关系，可以通过关键字（key）去快速查找到对应的唯一对象，而这个关键字可以是任意类型

集合与数组的区别

- 数组的长度是固定不可变的，集合长度可变

- 数组只能通过下标访问元素，类型固定，而有的集合可以通过任意类型查找所映射的具体对象

 

Java 集合类型分为 Collection 和 Map，它们是 Java 集合的根接口，这两个接口又包含了一些子接口或实现类。

 

 

Collection接口、子接口以及实现类

Collection接口

　　- 是List、Set和Queue接口的父接口

　　- 定义了可用于操作List、Set和Queue接口的方法 — 增删改查

List接口及其实现类 — ArrayList

　　- List是元素有序并且可以重复的集合，被称为序列

　　- List可以精确的控制每个元素的插入位置，或删除某个位置元素

　　- ArrayList — 数组序列，是List的一个重要实现类

　　- ArrayList底层是由数组实现的

实现功能 — 模拟学生选课功能

　　选择课程（往集合中添加课程）

　　删除所选的某门课程（删除集合中的元素）

　　查看所选课程

　　修改所选课程

 

//课程类
public class Course {
    public String id;
    public String name;
    public Course(String id,String name) {
        this.id = id;
        this.name = name;
    }
}

新增（第1种add方法）：

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

public class ListTest {
    //用于存放备选课程的List
    public List coursesToSelect;
    public ListTest() {
        this.coursesToSelect = new ArrayList();
    }
    //用于往coursesToSelect中添加备选课程
    public void testAdd() {
        //创建一个课程对象，并通过调用add方法，添加到备选课程List中
        Course cr1 = new Course("1","数据结构");
        coursesToSelect.add(cr1);
        //通过List的get方法把此元素取出来
        //对象存入集合都变成了object类型，取出时需要类型转换
        Course temp = (Course) coursesToSelect.get(0);
        System.out.println("添加了课程："+temp.id+":"+temp.name); 
    }
    public static void main(String[] args) {
        ListTest lt = new ListTest();
        lt.testAdd();
    }
}

运行结果：

新增（第2种add方法：可以指定元素添加位置）：

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

public class ListTest {
    //用于存放备选课程的List
    public List coursesToSelect;
    public ListTest() {
        this.coursesToSelect = new ArrayList();
    }
    //用于往coursesToSelect中添加备选课程
    public void testAdd() {
        Course cr1 = new Course("1","数据结构");
        coursesToSelect.add(cr1);
        Course temp = (Course) coursesToSelect.get(0);
        System.out.println("添加了课程："+temp.id+":"+temp.name);

        Course cr2 = new Course("2","C语言");
        //指定添加位置为首位0 此时序列变为：0：cr2 | 1：cr1
        coursesToSelect.add(0,cr2);
        Course temp2 = (Course) coursesToSelect.get(0);
        System.out.println("添加了课程："+temp2.id+":"+temp2.name);

        //以下调用add方法时，传递的位置参数>序列长度 会抛出数组下标越界异常
        Course cr3 = new Course("3","test");
        coursesToSelect.add(4,cr3);
    }
    public static void main(String[] args) {
        ListTest lt = new ListTest();
        lt.testAdd();
    }
}

运行结果：

除了两个add方法，还有两个addAll方法可以实现往List中添加元素的功能

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

public class ListTest {
    //用于存放备选课程的List
    public List coursesToSelect;
    public ListTest() {
        this.coursesToSelect = new ArrayList();
    }
    //用于往coursesToSelect中添加备选课程
    public void testAdd() {
        Course cr1 = new Course("1","数据结构");
        coursesToSelect.add(cr1);
        Course temp = (Course) coursesToSelect.get(0);
        System.out.println("添加了课程："+temp.id+":"+temp.name);

        Course cr2 = new Course("2","C语言");
        //指定添加位置为首位 此时序列变为：0： 2 C语言 | 1：1 数据结构
        coursesToSelect.add(0,cr2);
        Course temp2 = (Course) coursesToSelect.get(0);
        System.out.println("添加了课程："+temp2.id+":"+temp2.name);

        //以下调用add方法时，传递的位置参数>序列长度 会抛出数组下标越界异常
        //Course cr3 = new Course("3","test");
        //coursesToSelect.add(4,cr3);

        //创建课程数组
        Course[] course = {new Course("3","sql"),new Course("4","MySQL")};
        //第1种addAll方法：通过工具类Arrays里的addAll方法 将course数组转变为list
        coursesToSelect.addAll(Arrays.asList(course));
        Course temp3 = (Course) coursesToSelect.get(2);
        Course temp4 = (Course) coursesToSelect.get(3);
        System.out.println("添加了两门课程："+temp3.id+":"+temp3.name+";"+temp4.id+":"+temp4.name);

        Course[] course2 = {new Course("5","java"),new Course("6","python")};
        //第2种addAll方法：和第2种add方法类似，指定了添加元素位置，这里的添加元素为一个集合
        coursesToSelect.addAll(2, Arrays.asList(course2));
        Course temp5 = (Course) coursesToSelect.get(2);
        Course temp6 = (Course) coursesToSelect.get(3);
        System.out.println("添加了两门课程："+temp5.id+":"+temp5.name+";"+temp6.id+":"+temp6.name);
    }
    public static void main(String[] args) {
        ListTest lt = new ListTest();
        lt.testAdd();
    }
}

运行结果：

 

查询：

- 通过for循环

- 通过迭代器

- 通过for each循环

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

public class ListTest {
    public List coursesToSelect;
    public ListTest() {
        this.coursesToSelect = new ArrayList();
    }
    public void testAdd() {
        Course cr1 = new Course("1","数据结构");
        coursesToSelect.add(cr1);
        Course temp = (Course) coursesToSelect.get(0);
        System.out.println("添加了课程："+temp.id+":"+temp.name);

        Course cr2 = new Course("2","C语言");
        //指定添加位置为首位 此时序列变为：0： 2 C语言 | 1：1 数据结构
        coursesToSelect.add(0,cr2);
        Course temp2 = (Course) coursesToSelect.get(0);
        System.out.println("添加了课程："+temp2.id+":"+temp2.name);
        //此时序列顺序为：0： 2 C语言| 1： 1 数据结构| 2： 1 数据结构
        coursesToSelect.add(cr1);
        Course temp0 = (Course) coursesToSelect.get(2);
        System.out.println("添加了课程："+temp0.id+":"+temp0.name);

        //创建课程数组
        //此时序列顺序为：0： 2 C语言| 1： 1 数据结构| 2： 1 数据结构| 3: 3 sql| 4: 4 MySQL
        Course[] course = {new Course("3","sql"),new Course("4","MySQL")};
        //第1种addAll方法：通过工具类Arrays里的addAll方法 将course数组转变为list
        coursesToSelect.addAll(Arrays.asList(course));
        Course temp3 = (Course) coursesToSelect.get(2);
        Course temp4 = (Course) coursesToSelect.get(3);
        System.out.println("添加了两门课程："+temp3.id+":"+temp3.name+";"+temp4.id+":"+temp4.name);

        Course[] course2 = {new Course("5","java"),new Course("6","python")};
        //第2种addAll方法：和第2种add方法类似，指定了添加元素位置，这里的添加元素为一个集合
        //此时序列顺序为：0： 2 C语言| 1： 1 数据结构| 2： 5 java| 3: 5 python| 4: 1 数据结构| 5：3 sql| 6: 4 MySQL
        coursesToSelect.addAll(2, Arrays.asList(course2));
        Course temp5 = (Course) coursesToSelect.get(2);
        Course temp6 = (Course) coursesToSelect.get(3);
        System.out.println("添加了两门课程："+temp5.id+":"+temp5.name+";"+temp6.id+":"+temp6.name);
    }

    //取得List中的元素的方法
    public void testGet() {
        //为了依次遍历List中的元素，首先需要取得List的长度
        int size = coursesToSelect.size();
        System.out.println("有如下课程待选：");
        for(int i = 0;i < size;i++) {
            Course cr = (Course) coursesToSelect.get(i);
            System.out.println("课程："+cr.id+":"+cr.name);
        }
    }

    //通过迭代器去遍历List
    public void testIterator() { //iterator 迭代器
        //通过集合的iterator方法，取得迭代器的实例
        Iterator it = coursesToSelect.iterator();
        System.out.println("有如下课程待选(通过迭代器访问)：");
        while(it.hasNext()) {
            Course cr = (Course) it.next();
            System.out.println("课程："+cr.id+":"+cr.name);
        }
    }

    //通过for each方法访问集合元素
    public void testForEach() {
        System.out.println("有如下课程待选(通过for each访问)");
        for (Object obj:coursesToSelect) {
            Course cr = (Course) obj;
            System.out.println("课程："+cr.id+":"+cr.name);
        }
    }

    public static void main(String[] args) {
        ListTest lt = new ListTest();
        lt.testAdd();
        lt.testGet();
        lt.testIterator();
        lt.testForEach();
    }
}

 

修改：

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

public class ListTest {
    //用于存放备选课程的List
    public List coursesToSelect;
    public ListTest() {
        this.coursesToSelect = new ArrayList();
    }
    //用于往coursesToSelect中添加备选课程
    public void testAdd() {
        //创建一个课程对象，并通过调用add方法，添加到备选课程List中
        Course cr1 = new Course("1","数据结构");
        coursesToSelect.add(cr1);
        //通过List的get方法把此元素取出来
        //对象存入集合都变成了object类型，取出时需要类型转换
        Course temp = (Course) coursesToSelect.get(0);
        System.out.println("添加了课程："+temp.id+":"+temp.name);

        Course cr2 = new Course("2","C语言");
        //指定添加位置为首位 此时序列变为：0： 2 C语言 | 1：1 数据结构
        coursesToSelect.add(0,cr2);
        Course temp2 = (Course) coursesToSelect.get(0);
        System.out.println("添加了课程："+temp2.id+":"+temp2.name);
        //此时序列顺序为：0： 2 C语言| 1： 1 数据结构| 2： 1 数据结构
        coursesToSelect.add(cr1);
        Course temp0 = (Course) coursesToSelect.get(2);
        System.out.println("添加了课程："+temp0.id+":"+temp0.name);

        //创建课程数组
        //此时序列顺序为：0： 2 C语言| 1： 1 数据结构| 2： 1 数据结构| 3: 3 sql| 4: 4 MySQL
        Course[] course = {new Course("3","sql"),new Course("4","MySQL")};
        //第1种addAll方法：通过工具类Arrays里的addAll方法 将course数组转变为list
        coursesToSelect.addAll(Arrays.asList(course));
        Course temp3 = (Course) coursesToSelect.get(2);
        Course temp4 = (Course) coursesToSelect.get(3);
        System.out.println("添加了两门课程："+temp3.id+":"+temp3.name+";"+temp4.id+":"+temp4.name);

        Course[] course2 = {new Course("5","java"),new Course("6","python")};
        //第2种addAll方法：和第2种add方法类似，指定了添加元素位置，这里的添加元素为一个集合
        //此时序列顺序为：0： 2 C语言| 1： 1 数据结构| 2： 5 java| 3: 6 python| 4: 1 数据结构| 5：3 sql| 6: 4 MySQL
        coursesToSelect.addAll(2, Arrays.asList(course2));
        Course temp5 = (Course) coursesToSelect.get(2);
        Course temp6 = (Course) coursesToSelect.get(3);
        System.out.println("添加了两门课程："+temp5.id+":"+temp5.name+";"+temp6.id+":"+temp6.name);
    }

    //取得List中的元素的方法
    public void testGet() {
        //为了依次遍历List中的元素，首先需要取得List的长度
        int size = coursesToSelect.size();
        System.out.println("有如下课程待选：");
        for(int i = 0;i < size;i++) {
            Course cr = (Course) coursesToSelect.get(i);
            System.out.println("课程："+cr.id+":"+cr.name);
        }
    }

    //通过迭代器去遍历List
    public void testIterator() { //iterator 迭代器
        //通过集合的iterator方法，取得迭代器的实例
        Iterator it = coursesToSelect.iterator();
        System.out.println("有如下课程待选(通过迭代器访问)：");
        while(it.hasNext()) {
            Course cr = (Course) it.next();
            System.out.println("课程："+cr.id+":"+cr.name);
        }
    }

    //通过for each方法访问集合元素
    public void testForEach() {
        System.out.println("有如下课程待选(通过for each访问)");
        for (Object obj:coursesToSelect) {
            Course cr = (Course) obj;
            System.out.println("课程："+cr.id+":"+cr.name);
        }
    }

    //修改List中的元素
    public void testModify() {
        coursesToSelect.set(4,new Course("7","jmeter"));
    }

    public static void main(String[] args) {
        ListTest lt = new ListTest();
        lt.testAdd();
        lt.testGet();
        lt.testIterator();
        lt.testForEach();
        lt.testModify();
        lt.testForEach();
    }
}

运行结果：

 

删除：