Collection集合理解使用

最新推荐文章于 2022-08-13 22:24:38 发布

mocas_wang

最新推荐文章于 2022-08-13 22:24:38 发布

阅读量903

点赞数 1

分类专栏： java基础

本文链接： https://blog.csdn.net/mocas_wang/article/details/107573593

版权

java基础专栏收录该内容

22 篇文章 16 订阅

订阅专栏

1 Collection集合

1.1 集合概述

集合：集合是java中提供的一种容器，可以用来存储多个数据。集合和数组既然都是容器，它们有啥区别呢？

数组的长度是固定的。集合的长度是可变的。
数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候，使用集合进行存储。
1. Java 是⼀⻔⾯向对象的语⾔，就免不了处理对象

2. 为了⽅便操作多个对象，那么我们就得把这多个对象存储起来

3. 想要存储多个对象 ( 变量 ), 很容易就能想到⼀个容器

4. 常⽤的容器我们知道有 -->StringBuffffered, 数组 ( 虽然有对象数组，但是数组的⻓度是不可变的！ )

5. 所以， Java 就为我们提供了集合 (Collection)

1.2 数组和集合的区别

数组和集合的区别:

1:⻓度的区别

数组的⻓度固定

集合的⻓度可变

2:元素的数据类型

数组可以存储基本数据类型,也可以存储引⽤类型

集合只能存储引⽤类型(你存储的是简单的int，它会⾃动装箱成Integer

1.3 结构框架

Collection子接口有两个，两个子接口分别对应多个子实现类，多个集合数据结构不同，但是他们有共性内容，将共性内容抽取出来，就可以集合继承体系图；

Collection 层次结构中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的（既可有序，也可以无序）；

Collection：单列集合类的根接口，用于存储一系列符合某种规则的元素，它有两个重要的子接口，分别是java.util.List和java.util.Set。
List的特点是元素有序、元素可重复。Set的特点是元素无序，而且不可重复。List接口的主要实现类有java.util.ArrayList和java.util.LinkedList，
Set接口的主要实现类有java.util.HashSet和java.util.TreeSet。

JDK 不提供此接口的任何直接实现：它提供更具体的子接口，更具体的实现类；

2 Collection的使用

2.1常用功能

java.util.Collection接口

Collection是所有单列集合的父接口，因此在Collection中定义了单列集合（List和Set）通用的一些方法，

这些方法可用于操作所有的单列集合。

1. 添加功能
    boolean add(E e) 
        添加一个元素
    boolean addAll(Collection c)  
        添加一批元素
2. 删除功能
   boolean remove(Object o) 
       删除一个元素
3. 判断功能
   boolean contains(Object o) 
       判断集合是否包含指定的元素
   boolean isEmpty()  
       判断集合是否为空(集合中没有元素)
4. 获取功能
   int size()  
      获取集合的长度
5. 转换功能
   Object[] toArray() 
       把集合转换为数组

public class CollectionDemo {
	
	public static void main(String[] args) {
		
		//创建集合对象
		//Collection c = new Collecton() ; //不能实例化
		Collection c = new ArrayList() ;
		Collection c1 = new ArrayList();
		System.out.println(c);
		
		//添加元素:boolean add(Object e);
		System.out.println("flag:"+c.add("hello"));
		c.add("hello") ;
		c.add("world") ;
		c.add("java") ;
		c1.add("world");
		c1.add("java");
		c1.add("hello");
		System.out.println("c:"+c) ;
		System.out.println("c1:"+c1) ;
		/**
		   add()方法的源码:
		   public boolean add(E e) {
		   
        		ensureCapacityInternal(size + 1);  // Increments modCount!!
        		elementData[size++] = e;
        		return true;   //只要添加就返回true
    	   }
    	   
		*/
		
		//删除功能:c.clear(); 
		System.out.println("remove():"+c.remove("java"));
		System.out.println("c:"+c);
		
		//boolean contains(Object o):集合中是否包含指定的元素
		System.out.println("contains():"+c.contains("android"));
		System.out.println("contains():"+c.contains("hello"));
		
		//获取集合中的元素数:
		System.out.println(c.size());
		
		//boolean isEmpty() :判断集合是否为空
		System.out.println(c.isEmpty());
		
		//交集功能:boolean retainAll(Collection c);
		System.out.println("retainAll:"+c.retainAll(c1));
		System.out.println("c:"+c) ;  //将交集的元素赋给集合c;
		System.out.println("c1:"+c1) ;
		
		//删除一个集合中所有元素:boolean removeAll(Collection c);
		System.out.println("removeAll:"+c1.removeAll(c));
		System.out.println("c:"+c) ;
		System.out.println("c1:"+c1) ;  //删除集合c中的所有元素，并将删除元素后的集合c赋给c1;
 
	}
}

Collection集合的高级功能：
                boolean addAll(Collection c)：添加一个集合中的所有元素；
                boolean removeAll(Collection c)：删除的高级功能；
                        思考：删除一个算是删除还是删除所有算是删除?)；
                boolean containsAll(Collection c)：包含所有元素算是包含，还是包含一个算是包含；
                boolean retainAll(Collection c)：交集功能，A集合对B集合取交集；
                        思考：交集的元素到底是去A集合还是去B集合中，返回值boolean表达什么意思?

import java.util.ArrayList;
import java.util.Collection;
 
public class CollectionDemo {
	
	public static void main(String[] args) {
		
		//创建Collection集合1
		Collection c1 = new ArrayList() ;
		
		//添加元素
		c1.add("abc1") ;
		c1.add("abc2") ;
		c1.add("abc3") ;
		c1.add("abc4") ;
		
		
		//创建第二个集合
		Collection c2 = new ArrayList() ;
		c2.add("abc1") ;
		c2.add("abc2") ;
		c2.add("abc3") ;
		c2.add("abc4") ;
		c2.add("abc5") ;
		c2.add("abc6") ;
		c2.add("abc7") ;
		System.out.println("未发生变化的数据:");
		System.out.println("c1:"+c1);
		System.out.println("c2:"+c2);
		System.out.println("--------------------------------");
		
		//boolean addAll(Collection c)  :添加一个集合中的所有元素
		System.out.println("addAll():"+c1.addAll(c2));   //将c2中的所有元素都添加到c1中
		System.out.println("c1:"+c1);
		System.out.println("c2:"+c2);
		System.out.println("--------------------------------");
		
		//boolean removeAll(Collection c):删除的高级功能(思考:删除一个算是删除还是删除所有算是删除?)
		//结论:删除一个算是删除...
		System.out.println("removeAll():"+c1.removeAll(c2));
		System.out.println("c1:"+c1);    //删除集合c2中的所有元素，并将删除元素后的集合赋给c1;
		System.out.println("c2:"+c2);
		System.out.println("--------------------------------");
		
		//boolean containsAll(Collection c):包含所有元素算是包含,还是包含一个算是包含
		//结论:包含所有算是包含
		System.out.println("containsAll():"+c1.containsAll(c2));
		System.out.println("c1:"+c1);    //c1的所有元素都要在c2中能找到才算包含，并将包含的元素赋给集合c1;
		System.out.println("c2:"+c2);
		System.out.println("--------------------------------");
		
		//boolean retainAll(Collection c):A集合对B集合取交集,交集的元素到底是去A集合还是去B集合中
		//返回值boolean表达什么意思?
		//结论:c1集合对c2集合取交集,交集的元素要存到c1集合中,boolean返回值表达的c1集合的元素是否发生变化,如果发生变化,则返回true,否则,返回false
		System.out.println("retainAll():"+c1.retainAll(c2));
		System.out.println("c1:"+c1);
		System.out.println("c2:"+c2);
	}
}

转换功能：
Object[] toArray()：将集合转换成数组；

public class CollectionDemo2 {
	
	public static void main(String[] args) {
		
		//创建一个集合对象
		Collection c = new ArrayList() ;
		
		//给集合中添加元素
		c.add("hello") ;
		c.add("world") ;
		c.add("java") ;
		c.add("JavaEE") ;
		
		//需要去转换
		//Object[] toArray()
		//将集合转成数组
		Object[] objs = c.toArray() ;
		for(int x =0 ; x < objs.length ; x ++) {
			//System.out.println(objs[x]);
			//需求:输出不同的元素的同时,还需要输出字符串元素的长度
			//System.out.println(objs[x]+"----"+objs[x].length());
			
			/**
			 *上面代码有问题
			 * length():属于String类型的特有功能,可以获取字符串长度,不能再Object类中使用
			 */
			
			String str = (String) objs[x] ;  //相当于:向下转型
			System.out.println(str+"----"+str.length());
		}
	}
}

package org.westos_02;
 
import java.util.ArrayList;
import java.util.Collection;
 
/**
 *需求:存储自定义对象并遍历
 *
 *有5个学生,学生有姓名,年龄,遍历5个学生,输出5个学生对应的信息(集合改进)
 *
 *1)创建一个学生类
 *2)在测试类中,创建集合对象
 *3)创建5个具体学生对象,并且添加集合中
 *4)将集合转换数组
 *5)遍历
 *6)输出
 */
public class CollectionDemo {
	
	public static void main(String[] args) {
		
		//创建一个集合对象
		Collection c = new ArrayList() ;
		
		//创建5个具体学生对象
		Student s1 = new Student("高圆圆", 27) ;
		Student s2 = new Student("杨桃", 28) ;
		Student s3 = new Student("王力宏", 35) ;
		Student s4 = new Student("周星驰", 60) ;
		Student s5 = new Student("成龙", 55) ;
		
		//添加到集合中
		c.add(s1) ;
		c.add(s2) ;
		c.add(s3) ;
		c.add(s4) ;
		c.add(s5) ;
		
		//转换数组
		Object[] objs = c.toArray() ;
		//遍历
		for(int x = 0 ; x < objs.length ;x ++) {
			//System.out.println(objs[x]);
			
			//需求:需要的通过getXXX方法获取学生信息
			
			Student s = (Student) objs[x] ; //向下转型
			System.out.println(s.getName()+"----"+s.getAge());
		}
	}
}

2.2 遍历集合

普通的for循环【必须要有索引，可以修改元素】

ArrayList<String> list=new ArrayList<>();
c.add("Hello");
c.add("Java");
c.add("World");
for(int i=0;ilist.size();i++){
    String s=(String)list.get(i);
    System.out.println(s);
}

Iterator接口

　　JDK专门提供了一个接口java.util.Iterator，遍历集合中的所有元素。

　　Iterator接口也是Java集合中的一员，但它与Collection、Map接口有所不同，

　　Collection接口与Map接口主要用于存储元素，而Iterator主要用于迭代访问（即遍历）Collection中的元素，因此Iterator对象也被称为迭代器。

在ArrayList下找到了iterator实现的身影：它是在ArrayList以内部类的⽅式实现的！并且，

从源码可知：Iterator实际上就是在遍历集合

所以说：我们遍历集合(Collection)的元素都可以使⽤Iterator，⾄于它的具体实现是以内部类的⽅式

实现的！

　　想要遍历Collection集合，那么就要获取该集合迭代器完成迭代操作，获取迭代器的方法：

Iterator iterator()：集合的迭代器方法(获取集合的迭代器)；
集合的专有遍历方式：迭代器遍历；

        Iterator :接口中有以下的方法:：
                boolean hasNext()：如果有元素可以迭代,那么返回true,否则返回false；
                Object next()：返回迭代的下一个元素；

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
 
public class IteratorDemo {
 
	public static void main(String[] args) {
		//创建集合对象
		Collection c = new ArrayList() ;
 
		//添加元素
		c.add("hello");
		c.add("world");
		c.add("java");
		c.add("javaee");
 
		//通过集合获取迭代器
		Iterator it = c.iterator() ;
 
		//使用while循环
		while(it.hasNext()) {
                        //Object obj = it.next() ;  //Object obj = new Objct();
			//需求:打印字符串同时,获取长度
                        //String str = (String) obj ;
			String str = (String)(it.next()) ;
			System.out.println(str+"---"+str.length());
		}
		
	}
}

方法示例

注意:：在进行集合元素取出时，如果集合中已经没有元素了，还继续使用迭代器的next方法，将会发生java.util.NoSuchElementException没有集合元素的错误。

存储自定义对象并遍历（使用专有遍历方式）：

package org.westos_03;
 
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
 
/**
 *存储自定义对象并遍历(使用专有遍历方式) 
 *
 */
class Student {
	
	private String name ;
	private int age ;
	
	public Student() {
		super();
	}
 
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
 
	public String getName() {
		return name;
	}
 
	public void setName(String name) {
		this.name = name;
	}
 
	public int getAge() {
		return age;
	}
 
	public void setAge(int age) {
		this.age = age;
	}
 
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
}
 
public class IteratorDemo2 {
	
	public static void main(String[] args) {
		
		//创建集合对象:
		Collection c = new ArrayList() ;
		
		//创建学生对象
		Student s1 = new Student("张三", 27) ;
		Student s2 = new Student("李四", 29) ;
		Student s3 = new Student("王五", 25) ;
		
		//添加集合中
		c.add(s1) ;
		c.add(s2) ;
		c.add(s3) ;
		
		//获取迭代器
		Iterator it = c.iterator() ;
                //遍历
		while(it.hasNext()) {   //模板代码
                        //System.out.println(((Student) it.next()).getName() + "----" + ((Student) it.next()).getAge());
			Student s = (Student)it.next() ;
			System.out.println(s.getName()+"="+s.getAge());
		}
	}
}

高级for循环【就是迭代器的简化方式】

增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。

　　格式：

for(元素的数据类型  变量 : Collection集合or数组){ 
    //写操作代码
}

　　它用于遍历Collection和数组。通常只进行遍历元素，不要在遍历的过程中对集合元素进行增删操作。

Collection<String> coll=new ArrayList<String>();
coll.add("Hello");
coll.add("Java");
coll.add("World");
//高级for遍历集合
for(Stirng s:coll){
    System.out.println(s);
}

int[] arr={1,2,3,4,5,6};
//高级for遍历数组
for(int a:arr){
    System.out.println(a);
}