本文主要介绍了Java集合框架，包括ArrayList、LinkedList、HashSet和HashMap的使用。在学生选课系统中，利用Set集合管理课程，通过Map接口实现学生与课程的映射。文章讲解了如何判断List和Set中是否存在特定课程，获取List中课程的位置，以及如何通过Collections.sort()对List排序。此外，还探讨了Comparable和Comparator接口在排序中的作用。
目录
10. 应用Collections.sort()实现 List排序
1.Java中的集合框架概述
集合框架集合的概念：是一种工具类，就像是容器，储存任意数量的具有共同属性的对象。
集合的作用：在类的内部，对数据进行组织； 简而快速的搜索查找其中的某一条元素； 有的集合接口，提供了一系列排列有序的元素，并且可以在序列中间快速的插入或者删除有关的元素； 有的集合接口，提供了映射关系，可以通过关键字(key)去快速查找到对应的唯一对象，而这个关键字可以使任意类型。
集合与数组的对比： 数组的长度固定，集合长度可变 数组只能通过下标访问元素。类型固定，而有的集合可以通过任意类型查找所映射的具体对象。
Java集合框架体系结构 Collection Map
List(元素排列有序，可重复：序列)-ArrayList(数组序列)
Queue(有序，可重复，不常用：队列)LinkedList(链表)（也属List）
Set(无序，不可重复：集)HashSet(哈希集)
Map接口:----<key,value>----HashMap(哈希表)
在Map的内部会以<key,value>两个对象，一个映射去存储数据。这个映射是Entry类（键值对）的实例
Entry类是Map类的内部类
ArrayList HashSet HashMap 最为常用
2.学生选课
public class Course {
public String id;
public String name;
public Course(String id, String name) {
this.id = id ;
this.name = name;
}
}
import java.util.Set;
import java.util.HashSet;
public class Student {
public String id;
public String name;
public Set courses;
public Student(String id, String name) {
this.id = id;
this.name = name;
this.courses = new HashSet();
}
}
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() {
//创建一个课程对象，并通过调用add方法，添加到备选课程List中
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语言");
coursesToSelect.add(0, cr2);
Course temp2 = (Course) coursesToSelect.get(0);
System.out.println("添加了课程：" + temp2.id + ":" + temp2.name);
coursesToSelect.add(cr1);
Course temp0 = (Course) coursesToSelect.get(2);
System.out.println("添加了课程：" + temp.id + ":" + temp.name);
//以下方法会抛出数组下标越界异常
// Course cr3 = new Course("3", "test");
// coursesToSelect.add(4, cr3);
Course[] course = {new Course("3", "离散数学"), new Course("4", "汇编语言")};
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", "高等数学"), new Course("6", "大学英语")};
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 void testGet() {
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);
}
}
public void testIterator() {
//通过集合的iterator方法，取得迭代器的实例
Iterator<Course> it = coursesToSelect.iterator();
System.out.println("有如下课程待选(通过迭代器访问)：");
while(it.hasNext()) {
Course cr = it.next();
System.out.println("课程：" + cr.id + ":" + cr.name);
}
}
public void testForEach() {
System.out.println("有如下课程待选(通过for each访问)：");
for (Object obj : coursesToSelect) {
Course cr = (Course) obj;
System.out.println("课程：" + cr.id + ":" + cr.name);
}
}
public void testModify() {
coursesToSelect.set(4, new Course("7", "毛概"));
}
public void testRemove() {
// Course cr = (Course) coursesToSelect.get(4);
System.out.println("即将删除4位置和5位置上的课程！");
Course[] courses = {(Course) coursesToSelect.get(4), (Course) coursesToSelect.get(5)};
coursesToSelect.removeAll(Arrays.asList(courses));
// coursesToSelect.remove(4);
System.out.println("成功删除课程！");
testForEach();
}
public static void main( String[] args) {
ListTest lt = new ListTest();
lt.testAdd();
lt.testForEach();
// lt.testGet();
// lt.testIterator();
// lt.testForEach();
// lt.testModify();
// lt.testForEach();
// lt.testRemove();
}
}
3.泛型
1、规定List定义的容器只能存储某种类型的元素。
不用泛型的话是什么类型的元素都可以插入，因为插入集合是忽略其类型，把它看成为Object类型，取出时需要强行转换对应的类型。
2、如何声明
List<Course> courseToSelect; 在构造方法中(实例化的时候也可以不在构造方法，直接实例就可以)
this.courseToSelect=new ArrayList<Course>(); 3、添加
泛型集合中，不能添加泛型规定的类型以及其子类型以外的对象，否则会报错。
4、遍历
用foreach存储变量是泛型的类型。
for(Course a:courseToSelect),不用Object取出再强转，因为已经规定容器里装的都是Course类型。
总结关于list类型的一下用法：
1.创建对象
List list = new ArrayList();2.向list对象中添加数据
（1）Course crre = new Course("1","数据结构");//一个类的对象
list.add(crre);//将对象添加到list中
（2）Course[] crre = {new Course("",""),new Course("","");//对象的数组
list.addAll(0,Arrays.asList(course));//切记Arrays.asList方法3.获取集合中的元素
（1）Course temp = (Course)list.get(0);//注意强转
（2）Iterator it = list.iterator();
while(it.hasNext()){
Course cr = (Course)it.next();//迭代遍历，使用iterator方法
}
（3）for(Object obj:list){
Course cr = (Course)obj;
}//foreach方法 ，注意Object的使用4.集合中参数的修改
list.set(2,new Course("",""));5.集合中数据的删除
(1)list.remove(位置）;
(2)Course[] crr = {(Course)list.get(位置）(Course)list.get(位置）}；
list.removeAll(Arrays.asList(crr));6.带有泛型的list
List<Course> course = new ArrayList<Course>();//相当于添加进去的元素有了具体类型，不再是Object7.list可以添加子类型的对象
8.list不能直接添加基本类型（int,float等）的对象，如果要添加，需要使用其包装类
4.通过Set集合管理课程
Set接口及其实现类——HashSet
Set是元素无序并且不可以重复的集合，被称为集；
HashSet——哈希集，是Set的一个重要实现类。
1、Set没有像List中set()方法一样就修改，因为List是有序的，可以指定位置，而Set是无序的。
2、查询遍历时，Set不能用get()方法去获取，因为无序没有指定索引ID，但可以使用foreach和iterator来遍历，但是每次遍历出来可能顺序都不一样，还是因为无序造成的。
3、Set中的size(),add(),addAll(),remove(),removeAll()与List类似。
4、Set还可以添加null；
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
public class TestGeneric {
public List<Course> coursesToSelect;
public TestGeneric() {
coursesToSelect = new ArrayList<Course>();
}
public void testAdd() {
// 创建一个课程对象，并通过调用add方法，添加到备选课程List中
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语言");
coursesToSelect.add(0, cr2);
Course temp2 = (Course) coursesToSelect.get(0);
// System.out.println("添加了课程：" + temp2.id + ":" + temp2.name);
// coursesToSelect.add(cr1);
// Course temp0 = (Course) coursesToSelect.get(2);
// System.out.println("添加了课程：" + temp.id + ":" + temp.name);
// 以下方法会抛出数组下标越界异常
// Course cr3 = new Course("3", "test");
// coursesToSelect.add(4, cr3);
Course[] course = { new Course("3", "离散数学"), new Course("4", "汇编语言") };
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", "高等数学"), new Course("6", "大学英语") };
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 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) {
TestGeneric st = new TestGeneric();
st.testAdd();
st.testForEach();
// 创建一个学生对象
Student student = new Student("1", "小明");
System.out.println("欢迎学生：" + student.name + "选课！");
// 创建一个Scanner对象，用来接收从键盘输入的课程ID
Scanner console = new Scanner(System.in);
for (int i = 0; i < 3; i++) {
System.out.println("请输入课程ID");
String courseId = console.next();
for (Course cr : st.coursesToSelect) {
if (cr.id.equals(courseId)) {
student.courses.add(cr);
/**
* Set中，添加某个对象，无论添加多少次， 最终只会保留一个该对象（的引用）， 并且，保留的是第一次添加的那一个
*/
// student.courses.add(null);
student.courses.add(cr);
}
}
}
st.testForEachForSet(student);
}
public void testForEachForSet(Student student) {
// 打印输出，学生所选的课程！
System.out.println("共选择了：" + student.courses.size() + "门课程！");
for (Course cr : student.course) {
System.out.println("选择了课程：" + cr.id + ":" + cr.name);
}
}
}
5.Map和HashMap简介
Map接口
1. Map接口提供了一中映射关系，其中的元素是键值对（key-value）的形式存储的，能够实现根据Key快速查找value。Key-value可以是任何对象，是以Entry类型的对象实例存在的。
2.Key是不可以重复的，Value是可以重复的。Key-value都可以为null，不过只能有一个key是null。
3.map支持泛型，Map<K,V>
4.每个键最多只能映射到一个值
5.Map接口提供了分别返回key值集合、value值集合以及Entry（键值对）集合的方法
6.通过put<K key,V value>,remove<Object key>操作数据
7.HashMap中的Entry对象是无序排列的，HashMap是Map的一个重要实现类，也是最常用的，基于哈希表是实现
HashMap类：
1.HashMap是Map的一个重要实现类，也是最常用的，基于哈希表实现
2.HashMap中的Entry对象是无序排列的
3.Key值和value值都可以为null，但是一个HashMap只能有一个key值为null的映射（key值不可重复）
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;
public class MapTest {
public Map<String, Student> students;
public MapTest() {
this.students = new HashMap<String, Student>();
}
public void testPut() {
// 创建一个Scanner对象，用来获取输入的学生ID和姓名
Scanner console = new Scanner(System.in);
int i = 0;
while (i < 3) {
System.out.println("请输入学生ID：");
String ID = console.next();
// 判断该ID是否被占用
Student st = students.get(ID);
if (st == null) {
// 提示输入学生姓名
System.out.println("请输入学生姓名：");
String name = console.next(
最低0.47元/天 解锁文章
扫一扫
387
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
