contains原理
List.contains()
-遍历Lsit，对集合中的每个元素进行equals判断，只要有一个元素equals返回true，则contains返回true。
Set.contains()
-遍历Lsit，对集合中的每个元素进行equals以及hashCode判断，只要有一个元素equals以及hashCode返回true，则contains返回true。
测试List.contains() and Set.contains()
-Course类
public class Course {
// 课程编号
private String id;
// 课程名
private String name;
public Course() {
}
public Course(String id, String name) {
this.id = id;
this.name = name;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (!(obj instanceof Course))
return false;
Course other = (Course) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
-Student
import java.util.Set;
public class Student {
// 学生编号
private String id;
// 学生姓名
private String name;
// 课程集合
private Set<Course> courses;
public Student(String id, String name, Set<Course> courses) {
this.id = id;
this.name = name;
this.courses = courses;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Set<Course> getCourses() {
return courses;
}
public void setCourses(Set<Course> courses) {
this.courses = courses;
}
}
-main程序
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
public class SetTest {
private List<Course> listCourses;
private Scanner scanner;
private Student student;
public SetTest() {
}
public SetTest(List<Course> listCourses, Scanner scanner) {
this.listCourses = listCourses;
this.scanner = scanner;
}
// 用于向课程集合中添加被选课程
public void add() {
Course course1 = new Course("1", "数据结构");
listCourses.add(course1);
Course temp = listCourses.get(0);
System.out.println(temp.getId() + "/" + temp.getName());
Course course2 = new Course("2", "C语言");
/*
* 在可以访问的位置中插入数据，之前相应的数据位置往后移动一位 目前可访问的位置为0 若试图访问其他位置则会发生数组下标越界异常
*/
listCourses.add(0, course2);
Course temp2 = listCourses.get(0);
System.out.println(temp2.getId() + "/" + temp2.getName());
// 一次添加多个元素
Course[] courses = { new Course("3", "离散数学"), new Course("4", "汇编语言") };
// asList将数组转换为集合
listCourses.addAll(Arrays.asList(courses));
Course temp3 = listCourses.get(2);
System.out.println(temp3.getId() + "/" + temp3.getName());
Course temp4 = listCourses.get(3);
System.out.println(temp4.getId() + "/" + temp4.getName());
Course[] courses2 = { new Course("5", "高等数学"), new Course("6", "大学英语") };
// 新添加的两门课程从2处插入
listCourses.addAll(2, Arrays.asList(courses2));
Course temp5 = listCourses.get(2);
System.out.println(temp5.getId() + "/" + temp5.getName());
Course temp6 = listCourses.get(3);
System.out.println(temp5.getId() + "/" + temp6.getName());
}
// 通过foreach遍历List
public void foreach() {
System.out.println("调用foreach");
for (Course course : listCourses) {
System.out.println(course.getId() + "/" + course.getName());
}
}
// foreach输出所选课程
public void StudentForeach(Student student) {
// 输出学生所选课程，输出顺序不固定
for (Course course : student.getCourses()) {
System.out.println(course.getId() + "/" + course.getName());
}
}
// 测试List-contains方法
public void contains() {
Course course = listCourses.get(0);
System.out.println("取得课程：" + course.getName());
System.out.println("备选课程中是否包含：" + course.getName() + "," + listCourses.contains(course));
// 创建一个新课程对象
System.out.println("输入课程名");
String name = scanner.next();
Course course2 = new Course();
course2.setName(name);
System.out.println("取得课程：" + course2.getName());
// 根据需求重写Course.equals方法来获得效果
System.out.println("备选课程中是否包含：" + course2.getName() + "," + listCourses.contains(course2));
}
// 创建学生对象并选课
public void createStudentAndSelectCourse() {
// 创建一个学生对象
Set<Course> courses = new HashSet<Course>();
student = new Student("1", "小明", courses);
// 获取键盘输入的课程ID
Scanner scanner = new Scanner(System.in);
for (int i = 0; i < 3; i++) {
System.out.println("请输入课程ID");
String id = scanner.next();
for (Course course : listCourses) {
if (course.getId().equals(id)) {
student.getCourses().add(course);
}
}
}
StudentForeach(student);
}
// 测试Setcontains方法
public void SetContains() {
// 提示输入课程名称
System.out.println("请输入学生已选课程名称");
String name = scanner.next();
Course course2 = new Course();
course2.setName(name);
System.out.println("取得课程：" + course2.getName());
// 根据需求重写Course.equals方法来获得效果
System.out.println("备选课程中是否包含：" + course2.getName() + "," + student.getCourses().contains(course2));
}
public static void main(String[] args) {
List<Course> list = new ArrayList<Course>();
Scanner scanner = new Scanner(System.in);
ListTest listCourses = new ListTest(list);
SetTest setTest = new SetTest(list, scanner);
setTest.add();
setTest.foreach();
// setTest.contains();
setTest.createStudentAndSelectCourse();
setTest.SetContains();
}
}
1/数据结构
2/C语言
3/离散数学
4/汇编语言
5/高等数学
5/大学英语
调用foreach
2/C语言
1/数据结构
5/高等数学
6/大学英语
3/离散数学
4/汇编语言
请输入课程ID
1
请输入课程ID
2
请输入课程ID
3
3/离散数学
2/C语言
1/数据结构
请输入学生已选课程名称
离散数学
取得课程：离散数学
备选课程中是否包含：离散数学,true
获取List中索引位置
-代码跟之前的大同小异，此处只显示略微更改的部分
// 测试List-contains方法
public void contains() {
Course course = listCourses.get(0);
System.out.println("取得课程：" + course.getName());
System.out.println("备选课程中是否包含：" + course.getName() + "," + listCourses.contains(course));
// 创建一个新课程对象
System.out.println("输入课程名");
String name = scanner.next();
Course course2 = new Course();
course2.setName(name);
System.out.println("取得课程：" + course2.getName());
// 根据需求重写Course.equals方法来获得效果
System.out.println("备选课程中是否包含：" + course2.getName() + "," + listCourses.contains(course2));
// 通过indexOf方法来取得元素索引位置
// 如果有多个重复元素，则返回第一次出现时所在索引位置，LastindexOf则是返回最后一次出现的位置
// 若不出现则返回索引位置为-1
if(listCourses.contains(course2)){
System.out.println("课程："+course2.getName()+"索引位置为："+listCourses.indexOf(course2));
}
}
public static void main(String[] args) {
List<Course> list = new ArrayList<Course>();
Scanner scanner = new Scanner(System.in);
ListTest listCourses = new ListTest(list);
SetTest setTest = new SetTest(list, scanner);
setTest.add();
setTest.contains();
setTest.foreach();
// setTest.createStudentAndSelectCourse();
// setTest.SetContains();
}1/数据结构
2/C语言
3/离散数学
4/汇编语言
5/高等数学
5/大学英语
取得课程：C语言
备选课程中是否包含：C语言,true
输入课程名
离散数学
取得课程：离散数学
备选课程中是否包含：离散数学,true
课程：离散数学索引位置为：4
调用foreach
2/C语言
1/数据结构
5/高等数学
6/大学英语
3/离散数学
4/汇编语言
判断Map中是否包含指定的key和value
-对Student中的equals进行重写
import java.util.Set;
public class Student {
// 学生编号
private String id;
// 学生姓名
private String name;
// 课程集合
private Set<Course> courses;
public Student(String id, String name, Set<Course> courses) {
this.id = id;
this.name = name;
this.courses = courses;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (!(obj instanceof Student))
return false;
Student other = (Student) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Set<Course> getCourses() {
return courses;
}
public void setCourses(Set<Course> courses) {
this.courses = courses;
}
}
-主程序
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;
public class MapTest {
// 用了盛装学生类型
private Map<String, Student> students;
private Set<Course> courses;
public MapTest(Map<String, Student> students) {
this.students = students;
}
/*
* 添加学生：输入ID，判断是否有学生对象， 若没有则输入姓名，创建学生对象并添加到students中
*/
public void put() {
Scanner scanner = new Scanner(System.in);
int i = 0;
while (i < 3) {
System.out.println("请输入学生ID");
String id = scanner.next();
// 判断id是否被占用
Student student = students.get(id);
if (student == null) {
System.out.println("请输入学生姓名：");
String name = scanner.next();
Student newStudent = new Student(id, name, courses);
// 向map中添加学生
students.put(id, newStudent);
System.out.println("成功添加" + students.get(id).getName());
i++;
} else {
System.out.println("id被占用");
continue;
}
}
}
// 测试keySet
public void keySet() {
Set<String> key = students.keySet();
System.out.println("容量" + students.size());
for (String id : key) {
Student student = students.get(id);
// 判断是否为空非常必要，不然会出现空指针异常
if (student != null) {
System.out.println(student.getId() + "/" + student.getName());
}
}
}
// 测试删除Map中的映射
public void remove() {
System.out.println("请输入要删除学生的id");
Scanner scanner = new Scanner(System.in);
while (true) {
String id = scanner.next();
Student student = students.get(id);
if (student == null) {
System.out.println("输入的id不存在,请重新输入");
continue;
} else {
students.remove(id);
System.out.println("删除:" + student.getName() + "成功");
break;
}
}
}
// 通过entrySet遍历Map
public void entrySet() {
Set<Entry<String, Student>> entrySet = students.entrySet();
for (Entry<String, Student> entry : entrySet) {
System.out.println("取得键:" + entry.getKey());
System.out.println("对应值:" + entry.getValue().getName());
}
}
// 利用put方法修改Map中已有映射
public void testPut() {
System.out.println("请输入要修改学生的id");
Scanner scanner = new Scanner(System.in);
while (true) {
String id = scanner.next();
Student student = students.get(id);
if (student == null) {
System.out.println("输入的id不存在,请重新输入");
continue;
} else {
System.out.println("对应学生为：" + student.getName());
System.out.println("请输入新的学生名");
String name = scanner.next();
Student newStudent = new Student(id, name, courses);
students.put(id, newStudent);
System.out.println("修改成功");
break;
}
}
}
// 测试在Map中是否包含某个key值或者value值
public void containsKeyOrValue() {
/*
* 在Map中，用containsKey()方法，来判断是否包含某个key值
* 用containsValue()方法，来判断是否包含某个value值 作比较时经常需要对相应类的equals() 和 hasnCode()
* 重写
*/
System.out.println("请输入要查询的学生ID");
Scanner scanner = new Scanner(System.in);
String id = scanner.next();
System.out.println("在学生映射表中是否存在：" + students.containsKey(id));
if (students.containsKey(id)) {
System.out.println("对应的学生为：" + students.get(id).getName());
}
System.out.println("请输入要查询的学生姓名");
String name = scanner.next();
if (students.containsValue(new Student(null, name, courses))) {
System.out.println("包含学生：" + name);
} else {
System.out.println("该学生不存在");
}
}
public static void main(String[] args) {
Map<String, Student> students = new HashMap<String, Student>();
MapTest mapTest = new MapTest(students);
mapTest.put();
mapTest.keySet();
// mapTest.remove();
// mapTest.testPut();
// mapTest.entrySet();
mapTest.containsKeyOrValue();
}
public Map<String, Student> getStudents() {
return students;
}
public void setStudents(Map<String, Student> students) {
this.students = students;
}
}请输入学生ID
1
请输入学生姓名：
lc
成功添加lc
请输入学生ID
2
请输入学生姓名：
shz
成功添加shz
请输入学生ID
3
请输入学生姓名：
cjl
成功添加cjl
容量3
1/lc
2/shz
3/cjl
请输入要查询的学生ID
1
在学生映射表中是否存在：true
对应的学生为：lc
请输入要查询的学生姓名
lc
包含学生：lc
Collection.sort()实现List()排序
-对List排序
-对List排序
-对List排序
字符串排序规则
-先数字后字母即【0-9】、【A-Z】、【a-z】
-从高位到低位即进行比较时，字符串“1000”比“200”小
Comparable and Comparator
-对象想要排序则必须是可以比较的
-Comparable即给对象定义默认的排序规则
-实现该接口表示：这个类的实例可以比较大小，进行自然排序
-定义了默认的比较规则
-其实现类需实现compareTo()方法
-compareTo()方法返回正数表示大，负数表示小，0表示相等
-Comparator临时比较规则
-比较工具的接口，用于定义临时比较规则，而不是默认比较规则
-其实现类需要实现compare()方法
-Comparable and Comparator都是Java集合框架成员
Student改动部分
public class Student implements Comparable<Student>{
//其余代码与之前相同不赘述
@Override
public int compareTo(Student o) {
// 将两个对象id的比较结果作为学生对象id的比较结果返回
return this.id.compareTo(o.id);
}
}StudentComparator
import java.util.Comparator;
public class StudentComparator implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
// 按照名字排序
return o1.getName().compareTo(o2.getName());
}
}CollectionTest
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import java.util.Set;
import org.omg.CORBA.PRIVATE_MEMBER;
/*
* 1.通过Collection.sort()方法，对integer泛型的List进行排序；
* 2.对String泛型的List进行排序；
* 3.对其他类型的List进行排序。
*/
public class CollectionTest {
/*
* 通过Collection.sort()方法，对integer泛型的List进行排序； 插入十个100以内的随机数，调用sort()方法排序。
*/
public void integerSort() {
System.out.println("调用integerSort");
List<Integer> integers = new ArrayList<Integer>();
// 插入10个100以内的不重复随机整数
Random random = new Random();
Integer kInteger;
for (int i = 0; i < 10; i++) {
do {
kInteger = random.nextInt(100);
} while (integers.contains(kInteger));
integers.add(kInteger);
System.out.println("成功添加：" + kInteger);
}
System.out.println("--------排序前----------");
for (Integer integer : integers) {
System.out.println(integer);
}
System.out.println("--------排序后----------");
// 进行排序
Collections.sort(integers);
for (Integer integer : integers) {
System.out.println(integer);
}
}
/*
* 对String进行排序 创建String泛型的List,添加三个乱序的String元素
*/
public void stringSort() {
System.out.println("调用stringSort");
List<String> strings = new ArrayList<String>();
strings.add("abc");
strings.add("ggg");
strings.add("hhd");
System.out.println("--------排序前----------");
for (String string : strings) {
System.out.println(string);
}
System.out.println("--------排序后----------");
/*
* 排序,因为student本身尚未实现comparable接口，所以需要让student实现comparable接口
* 并重写compareTo方法，否则会报错
*/
Collections.sort(strings);
for (String string : strings) {
System.out.println(string);
}
}
// 对Student进行排序
public void studentSort(){
System.out.println("调用studentSort");
Set<Course> courses = new HashSet<Course>();
List<Student> students = new ArrayList<Student>();
students.add(new Student("1", "lc", courses));
students.add(new Student("3", "shz", courses));
students.add(new Student("2", "cjl", courses));
System.out.println("--------排序前----------");
for (Student student : students) {
System.out.println(student.getId()+"/"+student.getName());
}
System.out.println("--------按id排序后----------");
// 排序
Collections.sort(students);
for (Student student : students) {
System.out.println(student.getId()+"/"+student.getName());
}
System.out.println("--------按name排序后----------");
Collections.sort(students, new StudentComparator());
for (Student student : students) {
System.out.println(student.getId()+"/"+student.getName());
}
}
public static void main(String[] args) {
CollectionTest collectionTest = new CollectionTest();
collectionTest.integerSort();
collectionTest.stringSort();
collectionTest.studentSort();
}
}调用integerSort
成功添加：29
成功添加：75
成功添加：60
成功添加：74
成功添加：39
成功添加：57
成功添加：11
成功添加：5
成功添加：0
成功添加：15
——–排序前———-
29
75
60
74
39
57
11
5
0
15
——–排序后———-
0
5
11
15
29
39
57
60
74
75
调用stringSort
——–排序前———-
abc
ggg
hhd
——–排序后———-
abc
ggg
hhd
调用studentSort
——–排序前———-
1/lc
3/shz
2/cjl
——–按id排序后———-
1/lc
2/cjl
3/shz
——–按name排序后———-
2/cjl
1/lc
3/shz
Java集合框架总结
-Collection接口
- List
-ArrayList - Set
-HashSet - Collections工具类
-Comparator接口
-Comparable接口 - Map接口
扫一扫
426
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
