Java学习笔记（8）——集合

小灰灰 2023-10-18 14:29 124阅读 0赞

### 集合 ###

*  概念：能够存储任意数量的具有相同属性对象的工具类。
 *  作用：

1.  在类的内部对数据进行组织；
2.  可以简单快速的搜索大量的数据
3.  有的集合接口提供了一系列排列有序的元素，可以供用户快速的插入或删除某个元素；
4.  有的集合接口提供了映射关系，可以通过关键字（key）快速查找到对应的唯一对象，而且关键字的类型可以是任意的。

*  集合与数组的区别：

1.  数组的长度是固定的，定义了之后就无法更改；集合的长度是可变的，可随着数据量不断扩增；
2.  数组只能通过下标来确定元素，而集合可以通过任意类型查找对应的元素。

*  Java集合框架

Collection  
<根接口>  
只存储对象

Map  
<根接口>  
以< key, value >两个对象  
组成一个映射来存储一个数据

List  
序列  
有序可重复

Queue  
队列  
有序可重复

Set  
集  
无序不可重复

ArrayList

LinkedList

HashSet

HashMap

#### Collection接口 ####

*  Collection接口是List、Queue、Set接口的父接口；并且定义了可操作List、Queue、Set的增删改查的方法。
 *  Collection方法：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM0NzY1OQ_size_16_color_FFFFFF_t_70]

##### List #####

*  List的元素有序排列，且可以重复，被称为序列；
 *  List可以精确的控制每个元素的插入或删除的位置；
 *  ArrayList——数组序列，是List的一个重要的实现类；
 *  ArrayList底层是由数组实现的。

1.  ArrayList添加元素：

private List cCourse = new ArrayList();
    	@Override
    	public void addCourse() {
        
    		// TODO Auto-generated method stub
     		Course c = new Course("1", "book1");
     		Course c1 = new Course("2", "book2");
     		Course[] course = {
        
    			new Course("3", "book3"),
    			new Course("4", "book4")
    		}
     		//添加一个对象到cCourse
     		cCourse.add(c)
     		//添加一个对象到cCourse的指定位置，如果index大于当前集合的长度，就会产生数组越界异常
    		cCourse.add(0, c1);
    		//还可以使用addAll(Collection c)方法，添加一个集合到另一个数组序列
    		//在这里可以调用Arrays中的方法asList()将数组转换成集合
    		cCourse.addAll(Arrays.asList(course));
    		//也可以为其指定插入的对象
    		cCourse.addAll(1, Arrays.asList(course));
    
    		//将第一个对象取出，取出的d对象类型会被设置为Object类，所以需要强制类型转换成原本的类型
    		Course temp = (Course) cCourse.get(0);
    		
    		System.out.println("course:" + temp.getCourseId() + "," + temp.getCourseName());
    	}

1.  ArrayList遍历元素

//利用for循环遍历集合中的元素
    public void printCourse(){
        
    	for(int i = 0;i < cCourse.size();i++){
        
    		Course temp = (Course)cCourse.get(i);
    		System.out.println(temp.getCourseId() + "," + temp.getCourseName());
    	}
    }
    
    //利用迭代器的方法遍历数组中的元素
    public void printIterator(){
        
    	Iterator it = cCourse.iterator();
    	for(it.hasNext()){
        
    		Course temp = (Course)it.next();
    		System.out.println(temp.getCourseId() + "," + temp.getCourseName());
    	}
    }
    
    //利用foreach方法遍历数组
    public void printForeach(){
        
    	for(Object o : cCourse){
        
    		Course temp = (Course)o;
    		System.out.println(temp.getCourseId() + "," + temp.getCourseName());
    	}
    }

1.  ArrayList修改元素

//修改数组序列中的某个元素
    public void Modify(){
        
    	cCourse.set(1, new Course("2", "book2"));
    }

1.  ArrayList删除元素

//删除某一指定的元素
    public void removeByObj(){
        
    	cCourse temp = (cCourse)cCourse.get(0);
    	cCourse.remove(temp);
    }
    
    //删除某一指定位置的元素
    public void removeByIndex(){
        
    	cCourse.remove(0);
    }
    
    //删除某一数组中的元素
    public void removeByArray(){
        
    	Course[] courses = {
        
    		(Course)cCourse.get(0),
    		(Course)cCourse.get(1)
    	};
    
    	cCourse.removeAll(Arrays.asList(courses));
    }

##### 泛型 #####

*  集合中的元素，可以是任意类型的元素，如果把一个类型放入集合，他会自动忽略他的类型，按Object类型处理；
 *  泛型则是规定了某个集合只能放入指定类型或其子类型，会在编译时检查存入的类型是否符合，并且在取出时也按该指定类型取出，不需要再进行类型转换；
 *  泛型不能指定基本类型，但是可以指定基本类型的包装类。

例：

//加入泛型后的用迭代方法输出集合的方法
    	public void printIterator(List<Course> choiceCourse) {
        
    		Iterator<Course> it = choiceCourse.iterator();
    		while(it.hasNext()) {
        
    			Course temp = it.next();
    			System.out.println(temp.getCourseId() + "," + temp.getCourseName());
    		}
    	}

public void testBasicType(){
        
    	List<Integer> i = new ArrayList<Integer>();
    	//为i集合添加元素1时，会自动将基本类型转换为包装类（装箱），所以在编辑时不会报错
    	i.add(1);
    	System.out.println(i.get(0));
    }

##### Set #####

*  Set中的元素都是无序且不可重复的；
 *  HashSet——Set的重要实现对象，并且在其方法中不存在修改元素的方法；
 *  Set中的方法与ArrayList的方法相似，但是Set中没有get()方法，因为Set集是无序的，只能用迭代的方法的去输出元素。并且无论添加多少次相同的元素，最终只会保存第一个加入的元素，且数量不会增加；
 *  Set集可以添加空元素。

#### Map接口 ####

*  Map提供了一种映射关系，其中的元素都是以键值对(value,key)形式存储的，能够实现通过key快速查找value；
 *  Map中的键值对以Entry类型的对象实例存在；
 *  key值不可以重复，value值可以重复；
 *  每个键最多只可映射到一个值；
 *  Map接口提供了返回key值集合，value值集合和Entry集合的方法；
 *  Map支持泛型（Map<K, V>）。
 *  Map的方法：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM0NzY1OQ_size_16_color_FFFFFF_t_70 1]
 *  HashMap：是Map的重要实现类，基于哈希表实现。在HashMap中Entry对象是无序排列的，且key值和value值都是可以为null，但是只能有一个key值为null的映射。

1.  HashMap添加元素

public Map<String, Students> stu = new HashMap<String, Students>();
    
    public void addStu(){
        
    	Scanner scanner = new Scanner(System.in);
    		
    		int i = 0;
    		//循环输入3名学生的信息，并放入Map集合中
    		while(i < 3) {
        
    			System.out.println("enter student's ID:");
    			String stuId = scanner.next();
    
    			//判断输入的序号在集合中是否存在，若不存在输入学生姓名
    			if(stu.get(stuId) == null) {
        
    				System.out.println("enter student's name:");
    				String stuName = scanner.next();
    				
    				//调用put(key,value)将学生对象放入集合中
    				stu.put(stuId, new Students(stuId, stuName));
    				
    				System.out.println("student " + stu.get(stuId).getStuName() + " has been added.");
    				i++;
    			}else {
        
    				System.out.println("This Id has been occupy, please enter other Id");
    				continue;
    			}
    		}
    }

1.  HashMap元素遍历

//通过获取key值来遍历元素
    	@Override
    	public void print() {
        
    		// TODO Auto-generated method stub
    		// 调用keySet()方法，将Map中的key存入一个Set集合中
    		Set<String> keySet = stu.keySet();
    		
    		for (String str : keySet) {
        
    			Students s = stu.get(str);
    			System.out.println(s.getStuId() + "," + s.getStuName());
    		}
    	}
    
    	//通过获取键值对(Entry)来遍历元素
    	@Override
    	public void printEntry() {
        
    		// TODO Auto-generated method stub
    		// 调用entry()方法来创建一个Set集合存放键值，泛型规定为Entry类型，其中Entry也要用键值规范
    		Set<Entry<String, Students>> entrySet = stu.entrySet();
    		
    		System.out.println("Print the students after remove student");
    		for (Entry<String, Students> entry : entrySet) {
        
    			System.out.println(entry.getKey() + "," + entry.getValue().getStuName());
    		}	
    	}

1.  HashMap删除某一元素

@Override
    	public void remove() {
        
    		// TODO Auto-generated method stub
    		System.out.println("please enter Id which do you want to remove.");
    		Scanner scanner = new Scanner(System.in);
    		String stuId = scanner.next();
    		
    		while(true) {
        
    			if(stu.get(stuId) == null) {
        
    				System.out.println("This Id is invail, please enter other Id.");
    				continue;
    			}
    			
    			stu.remove(stuId);
    			break;
    		}
    	}

1.  HashMap修改元素

@Override
    	public void modify() {
        
    		// TODO Auto-generated method stub
    		Scanner scanner = new Scanner(System.in);
    		
    		while(true) {
        
    			System.out.println("please enter the Id which you want to modify");
    			
    			String stuId = scanner.next();
    			if(stu.get(stuId) == null) {
        
    				System.out.println("This Id is invail, please enter other Id");
    				continue;
    			}
    			
    			System.out.println("enter the name modified:");
    			String stuName = scanner.next();
    			
    			//HashMap修改元素也是用put()来修改，第一个值是现有的key
    			stu.put(stuId, new Students(stuId, stuName));
    			break;
    		}
    	}

#### 判断某一对象是否在当前集合中： ####

1.  判断某一对象是否存在List集合中

public void isContain(List<Course> choiceCourse) {
        
    		Course c = new Course();
    		Scanner scanner = new Scanner(System.in);
    		
    		System.out.println("enter the course name :");
    		String stuName = scanner.next();
    		c.setCourseName(stuName);
    		
    		//调用contains(Object o)方法，来判断输入元素是否存在于当前集合中
    		System.out.println(choiceCourse.contains(c));
    	}

contains(Object o)判断的方法基于equals()方法，调用集合中的每一个元素的equals()方法判断是否与该对象相等。在调用源代码中的equals()方法判断的是指向对象的地址是否相等，所以如果新建一个对象，则两个对象一定不等，故需要重写equals()方法，判断元素中的值是否相等。

1.  判断某一对象是否存在Set集合中

@Override
    	public void isStuCourse(Students s) {
        
    		// TODO Auto-generated method stub
    		System.out.println("please enter course name:");
    		Scanner scanner = new Scanner(System.in);
    		String stu_c = scanner.next();
    		
    		Course c = new Course();
    		c.setCourseName(stu_c);
    		
    		System.out.println(s.getCourse().contains(c));
    	}

Set集合中判断对象是否存在，是需要校验他们的HashCode若HashCode相同，则调用equals()方法判断是否相同，所以需要在Course类中重写hashCode方法和equals()方法。

1.  判断某一元素在List集合中的索引位置

public void isContain(List<Course> choiceCourse) {
        
    		Course c = new Course();
    		Scanner scanner = new Scanner(System.in);
    		
    		System.out.println("enter the course name :");
    		String stuName = scanner.next();
    		c.setCourseName(stuName);
    		
    		System.out.println(choiceCourse.contains(c));
    		
    		if(choiceCourse.contains(c))
    			System.out.println(choiceCourse.indexOf(c));
    	}

indexOf(Object o)方法主要调用的是equals()方法，判断集合中是否含有要查找的对象，若是存在，则输出它的索引位置。若List集合中含有多个元素则只输出第一元素所在的索引位置。lastIndexOf()方法类似只输出最后一个元素的索引位置。若没有查找到要查找的对象则输出-1。

1.  判断Map集合中是否存在对应的key值和value值

@Override
    	public void isStuKey() {
        
    		// TODO Auto-generated method stub
    		System.out.println("please enter stu Id:");
    		Scanner scanner = new Scanner(System.in);
    		String stuId = scanner.next();
    		
    		if(stu.containsKey(stuId))
    			System.out.println("student " + stu.get(stuId).getStuName() + " is contain.");
    		else
    			System.out.println("student " + stuId + " isn't contain.");
    		
    		System.out.println("please enter stu name:");
    		String stuName = scanner.next();
    		if(stu.containsValue(new Students(null, stuName)))
    			System.out.println("student " + stuName + " is contain.");
    		else
    			System.out.println("student " + stuName + " isn't contain.");
    	}

调用`containsKey(Object key)`方法可以直接判断Map中是否有对应的元素。但在调用`containsValue(Object value)`方法时需要重写hashCode()方法和equals()方法，与contain()方法原理类似。

#### 对集合中的元素进行排序 ####

1.  对Integer/String类型进行排序  
    Collections工具类是Java集合框架中操作集合元素的工具类，调用`sort(List<T> List)`方法对集合中的元素进行排序。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM0NzY1OQ_size_16_color_FFFFFF_t_70_pic_center]

//对Integer类型进行排序
    	public void sortInt() {
        
    		List<Integer> intList = new ArrayList<Integer>();
    		Random r = new Random();
    		Integer k;
    		
    		for (int i = 0; i < 10; i++) {
        
    			do {
        
    				k = r.nextInt(100);
    			} while (intList.contains(k));
    			
    			intList.add(k);
    			System.out.println("add number " + k + " success.");
    		}
    		
    		System.out.println("---------------------------------------------");
    		System.out.println("---------print number before sort----------");
    		
    		for (Integer integer : intList) {
        
    			System.out.println(">>>>>>>>>>number:" + integer);
    		}
    		
    		Collections.sort(intList);
    		System.out.println("----------print number after sort-----------");
    		for (Integer integer : intList) {
        
    			System.out.println(">>>>>>>>>>>number" + integer);
    		}
    	}

//对字符串类型进行排序
    	public void sortString() {
        
    		List<String> strList = new ArrayList<String>();
    		strList.add("China");
    		strList.add("English");
    		strList.add("Canada");
    		
    		System.out.println("----------print string before sort------------");
    		for (String string : strList) {
        
    			System.out.println(">>>>>>>>str:" + string);
    		}
    		
    		System.out.println("----------print string after sort--------------");
    		Collections.sort(strList);
    		for (String string : strList) {
        
    			System.out.println(">>>>>>>>str:" + string);
    		}
    	}

1.  对某一类型进行比较

*  Comparable接口  
    实现该接口表示：这个类的实例可以比较大小，可以进行自然排序；  
    定义了默认的排序规则；  
    其实现类需要实现compareTo()方法；  
    compareTo()方法返回值为正则表示大，返回值为负表示小，返回0表示相等。
 *  Comparator接口——比较工具接口  
    用于定义临时的比较规则，而不是默认的规则；  
    其实现类需要实现compare()方法；  
    Comparator和Comparable接口都是Java集合框架的成员。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM0NzY1OQ_size_16_color_FFFFFF_t_70_pic_center 1]  
    例：

public void sortCourse() {
        
    		// TODO Auto-generated method stub
    		System.out.println("-----------print course after sort--------------");
    		// 需要对Course类继承Comparable<T>接口，并实现compareTo()方法
    		// 调用Collections的sort(List<T> list)方法，对对象进行默认方法的排序
    		Collections.sort(cCourse);
    		printIterator();
    		
    		System.out.println("-----------print course after sort by name--------------");
    		// 需要创建一个类作为比较，继承Comparator<T>接口，并实现compare()方法
    		// 调用Collections的sort(List<T> list, Comparator<? super T> c)方法，对对象进行临时排序
    		Collections.sort(cCourse, new HandleCourse());
    		printIterator();
    	}

Course类继承Comparable接口

@Override
    	public int compareTo(Course c) {
        
    		// TODO Auto-generated method stub
    		return this.courseId.compareTo(c.courseId);
    	}

handlCourse类继承Comparator接口

@Override
    	public int compare(Course arg0, Course arg1) {
        
    		// TODO Auto-generated method stub
    		return arg0.getCourseName().compareTo(arg1.getCourseName());
    	}

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM0NzY1OQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20190215154934263.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM0NzY1OQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM0NzY1OQ_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20190219111157838.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM0NzY1OQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM0NzY1OQ_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20190304164325165.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM0NzY1OQ==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM0NzY1OQ_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20190304164208425.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM0NzY1OQ==,size_16,color_FFFFFF,t_70#pic_center