当前位置：网站首页>集合框架Collection与Map的区别和基本使用

集合框架Collection与Map的区别和基本使用

2022-08-09 16:47:00 【编程工人】

Collection接口，包含list、Queue和set子接口（Queue接口不常用）

list是有序的，set是无序的

Collection和Map接口之间的主要区别在于：Collection中存储了一组对象，而Map存储关键字/值对。

在Map对象中，每一个关键字最多有一个关联的值。

Map:不能包括两个相同的键，一个键最多能绑定一个值。null可以作为键，这样的键只有一个；可以有一个或多个键所对应的

以下为测试代码，包括Compara...接口中排序的使用

Course类

package cn.form1;

public class Course {

public String id;

public 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;

}

Student类

package cn.form1;

import java.util.HashSet;

import java.util.Set;

public class Student implements Comparable<Student> {

public String id;

public String name;

public Set<Course> course;

public Student(String id,String name){

this.id = id;

this.name = name;

this.course = new HashSet<Course>();

}

//重写方法会自动添加需适当修改

@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;

}

@Override

public int compareTo(Student o) {

// TODO Auto-generated method stub

return this.id.compareTo(o.id);

}

ListTest类，测试List

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

package cn.form1;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.Scanner;

public class ListTest {

public List<Course> courseToSelect;

private Scanner sc;

public ListTest(){

this.courseToSelect = new ArrayList<Course>();

}

//list添加

public void listAdd(){

Course cr1 = new Course("1", "php课程");

this.courseToSelect.add(cr1);//cr1会以object对象类型加入

Course course = (Course)this.courseToSelect.get(0);//调用list中第一个对象，需要强转类型

System.out.println("加入了课程：" + course.id + " - " + course.name );

Course cr2 = new Course("2", "孟浩");

this.courseToSelect.add(0,cr2);//add方法指定位置插入

Course course2 = (Course)this.courseToSelect.get(0);

System.out.println("加入了课程：" + course2.id + " - " + course2.name);

//注：下标不能越界，否则会报下标溢出异常

Course[] temp1 = { new Course("3", "许清"),new Course("4", "王有财")};

this.courseToSelect.addAll(Arrays.asList(temp1));//addAll 批量添加

Course course3 = (Course)this.courseToSelect.get(2);

System.out.println("加入了课程：" + course3.id + " - " + course3.name);

Course[] temp2 = { new Course("5", "李富贵"),new Course("6", "楚语嫣")};

this.courseToSelect.addAll(2,Arrays.asList(temp2));//addAll 指定位置批量添加

Course course4 = (Course)this.courseToSelect.get(2);

System.out.println("加入了课程：" + course4.id + " - " + course4.name);

this.courseToSelect.add(3,cr1);//cr1会以object对象类型加入

Course course0 = (Course)this.courseToSelect.get(0);//调用list中第一个对象，需要强转类型

System.out.println("加入了课程：" + course0.id + " - " + course0.name );

System.out.println(this.courseToSelect.size());

}

//list打印

public void testGet(){

int size = this.courseToSelect.size();

System.out.println("FOR打印===================：");

for(int i = 0; i < size; i++){

Course cr = (Course)this.courseToSelect.get(i);

System.out.println(cr.id +" : " + cr.name);

}

System.out.println("FOR EACH打印===================：");

for(Course cr1 : this.courseToSelect){

System.out.println(cr1.id +" : " + cr1.name);

}

this.courseToSelect.set(4, new Course("9","呼延老祖"));//修改

System.out.println("FOR EACH打印===================：");

for(Course cr1 : this.courseToSelect){

System.out.println(cr1.id +" : " + cr1.name);

}

this.courseToSelect.remove(4);//所引删

System.out.println("FOR EACH打印===================：");

for(Course cr1 : this.courseToSelect){

System.out.println(cr1.id +" : " + cr1.name);

}

Course[] reall = {(Course)this.courseToSelect.get(4),(Course)this.courseToSelect.get(5)};

this.courseToSelect.removeAll(Arrays.asList(reall));//批量删

System.out.println("FOR EACH打印===================：");

for(Course obj : this.courseToSelect){

System.out.println(obj.id +" : " + obj.name);

}

//set用法 set 不可重复并且无序，，其它方法和list使用相似

public void students(){

Student stu = new Student("1", "陈凡");

System.out.println("欢迎"+stu.name+"选课");

sc = new Scanner(System.in);

for(int i = 0; i < 3; i++){

System.out.println("请输入选择的课程ID号：");

String sid = sc.next();

for(Course cr1 : this.courseToSelect){

if(cr1.id.equals(sid)){ //如果课程ID存在

stu.course.add(cr1);//加入到学生课程集合中

}

System.out.println("共选择了"+stu.course.size()+"个课程");

for(Course cr2 : stu.course){

System.out.println(cr2.id+" - "+cr2.name);

}

Course course = new Course("2", "孟浩");

boolean isnull = stu.course.contains(course);//set.contains方法，需要重写hashCode

System.out.println(isnull);//无序所以无索引

}

//list.contains用法，需要重写equals

public void contains(){

Course course = new Course("1", "php课程");//判断课程集合中是否包含某个课程，，需要先把该课程组装为对像

boolean isnull = this.courseToSelect.contains(course);//list.contains用法，需要重写equals

System.out.println(isnull+" - 索引："+ this.courseToSelect.indexOf(course));

//indexOf 存于集合中对应对象的索引位置

}

public static void main(String[] args) {

ListTest lt = new ListTest();

lt.listAdd();

//lt.testGet();

//lt.students();

lt.contains();

}

TestMap类，测试map

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

package cn.form1;

import java.util.HashMap;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Scanner;

import java.util.Set;

public class TestMap {

public Map<String,Student>students;

private Scanner san;

public TestMap(){

this.students = new HashMap<String,Student>();

}

public void Mapstudent(){

san = new Scanner(System.in);

int i = 0;

while(i < 3){

System.out.println("请输入学生ID号");

String ID = san.next();//添加到map中的 key

Student st = this.students.get(ID);

if(st == null){

System.out.println("请输入学生的姓名：");

String sname = san.next();

Student student = new Student(ID, sname);//添加到map中的value

this.students.put(ID, student);//put添加到map集合中

System.out.println("已添加学生："+ sname);

}else{

System.out.println("该学生已存在");

continue;

}

i++;

}

//entrySet的方式打印map

public void entrySet(){

Set<Entry<String, Student>> entry = this.students.entrySet();

for(Entry<String, Student> entr : entry){

System.out.println("key : " + entr.getKey());

System.out.println("valu： " + entr.getValue().name);

}

//使用 keySet 方式，打印map集合数据

public void keySet(){

System.out.println("---------打印所有学生----------");

Set<String> key = this.students.keySet();

for(String ky : key){

Student st = this.students.get(ky);//get调用map中的key获取value

System.out.println("学生ID:"+ st.id + "--学生姓名:"+st.name);

}

//删除对应key的value

public void reMove(){

san = new Scanner(System.in);

while(true){

System.out.println("请输入要删除的学生ID：");

String ID = san.next();

Student stu = this.students.get(ID);

if(stu == null){

System.out.println("学生ID不存在...");

continue;

}else{

this.students.remove(ID);//删除对应key的对象

System.out.println("成功删除学生："+stu.name);

break;

}

//修改对应key的对象

public void modify(){

san = new Scanner(System.in);

while(true){

System.out.println("请输入要修改的学生ID：");

String ID = san.next();

Student stu = this.students.get(ID);

if(stu == null){

System.out.println("学生ID不存在...");

continue;

}else{

System.out.println("即将要修改的学生是："+stu.name);

System.out.println("输入新的学生名称");

String name = san.next();

Student stu2 = new Student(ID, name);

this.students.put(ID, stu2);//修改

break;

}

//map中containskey 与 containsvalue用法

public void containskey_value(){

String ID = "2";

boolean iskey = this.students.containsKey(ID);

System.out.println("containskey----------判断key是否存在");

if(iskey){ //如果判断 map中 key 存在，输出该key对应对像中学生的姓名

System.out.println("学生姓名："+ this.students.get(ID).name +" - "+ iskey);

}

String Name = "小红";

Student student = new Student(null, Name);

boolean isvalue = this.students.containsValue(student);//判断map.containsValue 需要重写equals方法

System.out.println("containsvalue----------判断value是否存在");

if(isvalue){

System.out.println("学生存在于Map集合中" +" - "+isvalue);

}

public static void main(String[] args) {

TestMap testmap = new TestMap();

testmap.Mapstudent();

testmap.keySet();

testmap.reMove();

testmap.entrySet();

testmap.modify();

testmap.entrySet();

testmap.containskey_value();

}

CollectionTest类，测试排序

package cn.form1;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import java.util.Random;

public class CollectionTest {

//对int的包装类integer排序

//创建一个 10 个随机数的 list 对其进行排序

public void integerSort(){

List<Integer> integerList = new ArrayList<Integer>();

Random random = new Random();//产生随机数的类

Integer k = new Integer(0);//实例化一个int的包装类

for(int i = 0; i < 10; i++){

do{ //保证随机数唯一的方法

k = random.nextInt(100);

}while(integerList.contains(k));//如果k已存在于 integerList 会重新随机

integerList.add(k);//添加到 integerList 中

System.out.println("成功添加整数："+k);

}

System.out.println("---------排序前--------");

for(Integer vo : integerList){

System.out.println(vo);

}

System.out.println("---------排序后--------");

Collections.sort(integerList);//是 Collections 工具类的 sort 排序方法

for(Integer vo : integerList){

System.out.println(vo);

}

//对String的包装类String排序

//创建一个 10 个随机字符串的 list 对其进行排序

public void stringSort(){

List<String> stringList = new ArrayList<String>();

Random random = new Random();

for(int i = 0; i < 10; i++){

String str = this.getRandomString(random.nextInt(10));//随机生成 0-10长度的字符串

System.out.println("成功添加字符串："+ str);

stringList.add(str);

}

System.out.println("---------排序前--------");

for(String str : stringList){

System.out.println(str);

}

System.out.println("---------排序后--------");

Collections.sort(stringList);//是 Collections 工具类的 sort 排序方法

for(String str : stringList){

System.out.println(str);

}

//对学生类 Student 进行排序，需要学生类实现 Comparable 接口中的compareTo方法

public void studentSort(){

List<Student> student = new ArrayList<Student>();

Random random = new Random();

student.add(new Student(random.nextInt(1000)+"", "丹鬼大师"));

student.add(new Student(random.nextInt(1000)+"", "金寒宗老祖"));

student.add(new Student(random.nextInt(1000)+"", "帝宗老祖"));

//注：数值排序要用 int类型，否则 1000 会排在 2的上面

System.out.println("---------默认以ID排序后--------");

Collections.sort(student);

//Collections.sort 排序学生类实现 Comparable 接口中的CompareTo方法

for(Student stu : student){

System.out.println(stu.id+" - "+stu.name);

}

System.out.println("---------临时以name排序后--------");

Collections.sort(student,new StudentComparator());//StudentComparator 为临时排序规则

for(Student stu : student){

System.out.println(stu.id+" - "+stu.name);

}

//随机生成字符串

public String getRandomString(int length) { //length表示生成字符串的长度

String base = "abcdefghijklmnopqrstuvwxyz0123456789";

Random random = new Random();

if (length <= 1) length = 3;

StringBuffer sb = new StringBuffer();//初始化可变字符串

for (int i = 0; i < length; i++) {

int number = random.nextInt(base.length());//得到一个随机位置

sb.append(base.charAt(number));//charAt 获取字符中指定位置的字符

}

return sb.toString();//转为String返回

}

public static void main(String[] args) {

CollectionTest cot = new CollectionTest();

cot.integerSort();

cot.stringSort();

cot.studentSort();

}

StudentComparator类，测试临时排序规则

package cn.form1;

import java.util.Comparator;

//临时排序规则接口

public class StudentComparator implements Comparator<Student> {

@Override

public int compare(Student o1, Student o2) {

// 对 Student 的 name 进行排序

return o1.name.compareTo(o2.name);

}

原网站

版权声明
本文为[编程工人]所创，转载请带上原文链接，感谢
https://blog.csdn.net/zjwlgr/article/details/126242602

当前位置：网站首页>集合框架Collection与Map的区别和基本使用

集合框架Collection与Map的区别和基本使用

边栏推荐

猜你喜欢

随机推荐