集合与数组的对比及集合框架详解-CSDN博客

本文链接：https://blog.csdn.net/myloveprogrmming/article/details/82870972

集合与数组一样，也是一个容器，与数组不同的是，集合的长度不定，可以无限的向集合中添加元素，而且集合中存储的元素类型可以随意。

集合的框架结构介绍

Map集合的框架结构

集合与数组的对比

相同点：

都是数据的容器，在一个数组或集合中可以声明（存储）多个数据

不同点：

元素：数组中的元素只能是相同（相兼容类型）
集合中的元素是任意的（泛型）

数组中可以存储基本类型和引用类型，集合只能存储引用类型

长度(元素个数)：
数组是定长的，一旦初始化长度就不可以修改
集合长度可以修改，可以删除元素和添加元素

第二节 Collection接口

2.1 Collection中常用的方法(Collection中定义是整个集合体系最共性的方法:)

测试：

package a;

import java.util.*;


public class TestA {
	
	static ArrayList<String> arr=new ArrayList<String>();
	static ArrayList<String> x=new ArrayList<String>();
	static void f1()//add
	{
		arr.add("HELLO");
		arr.add("WORLD");
		System.out.println(arr.toString());
	}
	static void f2()//addAll()
	{
		arr.add("HELLO");
		arr.add("WORLD");
		x.add("I LOVE");
		x.add("MY L.I.F.E");
		arr.addAll(x);
		System.out.println(arr.toString());
	}
	static void f3()//clear()
	{
		arr.add("A");
		arr.add("B");
		System.out.println(arr.toString());
		arr.clear();
		System.out.println(arr.toString());
	}
	static void f4()//contains()
	{
		arr.add("ABC");
		arr.add("DEF");
		System.out.println(arr.contains("ABC"));
	}
	static void f5()//containsAll()
	{
		arr.add("ABC");
		arr.add("DEF");
		arr.add("IGH");
		x.add("ABC");
		x.add("IGH");
		System.out.println(arr.containsAll(x));
		System.out.println(x.containsAll(arr));
	}
	static void f6()//equals()
	{
		arr.add("AB");
		arr.add("CD");
		x.add("AB");
		x.add("CD");
		System.out.println(arr.equals(x));
	}
	static void f7()//isEmpty()
	{
		System.out.println(arr.isEmpty());
		arr.add("AA");
		System.out.println(arr.isEmpty());
	}
	static void f8()//iterator()
	{
		arr.add("ABC");
		arr.add("DEF");
		arr.add("GHI");
		Iterator<String> it=arr.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
	static void f9()//remove()
	{
		arr.add("ABC");
		arr.add("ABC");
		arr.add("ABC");
		arr.add("ABC");
		arr.add("DEF");
		arr.add("GHI");
		System.out.println(arr.toString());
		
		arr.remove(0);//通过索引删除
		System.out.println(arr.toString());
		
		arr.remove("ABC");//通过元素删除,如果有重复的，每次只删除一个
		System.out.println(arr.toString());
		
	}
	static void f10()//removeAll
	{
		arr.add("ABC");
		arr.add("ABC");
		arr.add("ABC");
		arr.add("ABC");
		arr.add("DEF");
		arr.add("GHI");

		x.add("ABC");
		x.add("DEF");
		
		System.out.println(arr.toString());
		System.out.println(x.toString());
		
		arr.removeAll(x);//删除arr中所有和x一样的元素
		System.out.println(arr.toString());
		System.out.println(x.toString());
	}
	static void f11()//retain()仅保留arr中和x内相同的元素
	{
		arr.add("ABC");
		arr.add("ABC");
		arr.add("ABC");
		arr.add("ABC");
		arr.add("DEF");
		arr.add("GHI");
		arr.add("666");
		
		x.add("ABC");
		x.add("DEF");
		arr.retainAll(x);
		
		System.out.println(arr.toString());
		System.out.println(x.toString());
	}
	static void f12()//size()返回所含元素个数
	{
		arr.add("ABC");
		arr.add("DEF");
		arr.add("GHI");
		arr.add("666");
		System.out.println(arr.size());
	}
	static void f13()//toArray()转化为Object类型的数组
	{
		arr.add("ABC");
		arr.add("DEF");
		arr.add("GHI");
		arr.add("666");
		Object[] str= arr.toArray();
		for(int i=0;i<=str.length-1;i++)
			System.out.println(str[i].toString());	
	}
	public static void main(String[] args) {
		f13();
	}

}

注意点：
       1在使用迭代器遍历期间，最好不要使用集合的删除方法，删除元素，如果要删除可以使用迭代器自带的remove方法
       2迭代器的add(增),remove(删),set(改)最好不要同时使用
       在用Itrator遍历时用list的remove删除集合中的元素，会报错，因为破坏了集合和迭代器的关系，使得他们不稳定
       但是用迭代器对象的remove就不会出错

注List特有方法：可以操作下标

List l1=new ArrayList();
//如果不指定类型的话，元素的类型为Object

package a;

import java.util.*;

public class TestB//测试List接口中的方法，ArrayList是List的实现类
{
	static List<String> list=new ArrayList<String>();
	static List<String> x=new ArrayList<String>();
	static void f1()//add(索引,值)
	{
		list.add(0,"ABC");
		list.add(0,"DEF");//去了0索引，"ABC"整体后移
		System.out.println(list.toString());
	}
	static void f2()//addAll(索引,集合类对象的引用)
	{
		list.add("AAA");
		list.add("BBB");
		list.add("CCC");
		
		x.add("111");
		x.add("222");
		
		list.addAll(1,x);
		System.out.println(list.toString());
	}
	static void f3()//get(索引)
	{
		list.add("AAA");
		list.add("BBB");
		list.add("CCC");
		System.out.println(list.get(0));
	}
	static void f4()//indexOf() lastIndexOf()
	{
		list.add("AAA");
		list.add("BBB");
		list.add("CCC");
		list.add("AAA");
		System.out.println(list.indexOf("BBB"));
		System.out.println(list.lastIndexOf("AAA"));
		System.out.println(list.indexOf("666"));
	}
	static void f5()//set(索引,要改为的值) 修改
	{
		list.add("AAA");
		list.add("BBB");
		list.add("CCC");
		list.add("AAA");
		list.set(3,"DDD");
		System.out.println(list.toString());
	}
	static void f6()
	{
		list.add("AAA");
		list.add("BBB");
		list.add("CCC");
		list.add("DDD");
		list.add("EEE");
		List<String>s=list.subList(1, 3); //左闭右开
		System.out.println(s.toString());
		System.out.println(list.toString());
	}
	public static void main(String[] args) {
		f6();

	}

}

	//4List特有的迭代器:ListIterator 这种方法了解就可以了
	 public class Demo2 {

	public static void main(String[] args) {

		//4这种方法了解就可以了
		//ListIterator<E> listIterator()
		List l1=new ArrayList<>();
		l1.add("hello");
		l1.add(0,"Hello");
		l1.add("world");
		ListIterator it=l1.listIterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		/*
		 * 输出：
		 *	Hello
			hello
			world
		 */
		
		
		//ListIterator<E> listIterator(int index)
		List list=new ArrayList<>();
		list.add("I");
		list.add(" love");
		list.add(" my");
		list.add(" life");
		ListIterator it1=list.listIterator(2);//从指定索引开始生成迭代器
		while(it1.hasNext()) {
			System.out.println(it1.next());
		}
		/*
		 *输出： 
		 * my
 		 * life
		 */	
	}

}

 
/* 集合：
 * 集合与数组的比较：
 * 数组：可以存储多个相同类型的数据，数据类型可以是简单数据类型也可以是引用类型
 *     缺点：只能存储固定长度的数据，一旦存完了就不能再继续存储
 * 集合：可以存储多个类型相同或不同类型的数据
 * 		缺点：只能存储引用数据类型
 * 		优点：存储空间会随着数据量的变化而变化，可以更加合理的使用内存空间。方法很多，方便我们进行操作
 * 集合的分类：
 * 常用的集合体系：
 * 	>Collection(接口)
 * 		>List(接口)存储的值是有序(元素的存在顺序与添加顺序一致)的，可重复的.List的特殊之处在于可以对索引进行处理
 * 			>ArrayList(实现类)--类：底层的数据结构是数组，是线程不安全的，查找速度快，添加删除速度慢
 * 			>LinkedList(实现类)--类：类：底层的数据结构是链表，是线程不安全的，查找速度慢，添加删除速度快
 * 			>Vector(实现类)--类：底层的数据结构是数组，是线程安全的，查找速度快，添加删除速度慢
 * 		>Set(接口)无序，不可重复
 * 			>HashSet(实现类)
 * 			>TreeSet(实现类)
 * 	>Map(接口)
 * 		>HashMap(实现类)
 * 		>TreeMap(实现类)
 */

public class Demo2 {

	public static void main(String[] args) {

//		LindedList特有的方法：
		LinkedList l1=new LinkedList<>();
//		addFirst()//始终在首位添加
//		addLast()//始终在末尾添加
		l1.add("hello");
		l1.addFirst("world");
		l1.addLast("WORLD");
		System.out.println(l1);
//		getFirst()//从头部获取，当获取的对象不存在时，会发生异常
//		l1.clear();
//		l1.getFirst();报异常
//		getLast()从尾部获取
//		System.out.println(l1.getLast());//异常
//		removeFirst()//删除头删除的对象不存在会发生异常
//		removeLast()删除尾
//
//		从jdk1.6开始出现以下方法(和上面那六个方法相对应，区别在于处理对象不存在时的方式)
		LinkedList l2=new LinkedList<>();
//		offerFirst()//始终在首位添加
		l2.offerFirst("haha");
//		offerLast()//始终在末尾添加
		l2.offerFirst("hehe");
		System.out.println(l2);
//		peekFirst()//获取的对象不存在会返回null
//		peekLast()
//
//		pollFirst()//删除的对象不存在会返回null
//		pollLast()

	}

}

关于Iterator

//Iterator<E> iterator() //获取集合中的对象
//hasnext():盘点当前位置是否有元素，如果有返回true，没有返回false
//当产生迭代器的时候，指针已经指向第一个元素
//next()：将当前值取出并返回，并将指针后移一位
//程序给每个集合都准备了一个属于自己的迭代器对象，所以我们获取迭代器对象的方法是调用集合的一个方法得到迭代器对象

	Iterator it=c1.iterator();
	while(it.hasNext()) {
		String s=(String)it.next();
		System.out.println(s);
	}
	
	//注意点：这个遍历运行完之后，当前it迭代器对象的指针指向最后，要是再对这个迭代器对象进行遍
//历...是不能成功的，除非产生新的迭代器
	//第二种遍历方式
	for(Object str:c1)
	{
		System.out.println(str);
	}
	
	//在使用时，集合中可能有多种类型的元素，要进行容错处理
	c1.add(5);//自动装包为Iteger
	Iterator it1=c1.iterator();
	while(it1.hasNext()) {
		Object s=it1.next();//相当于将String类型的对象赋值给Object类型（向上转型，实际上是子类的类型）
		if(s instanceof String)//所以可以用instanceof方法判断
			System.out.println(s);
		else
			System.out.println((Integer)s);
	}
	
	Iterator it2=c1.iterator();//但其实这样不做类型转换也是可以正常运行的
	while(it2.hasNext()) {
		Object s=it2.next();
			System.out.println(s);
	}

注：

1.List<String> list=new ArrayList<>();//后面<>可以不写东西，但是前面<>必须写

public class TestC {

	public static void main(String[] args) {
		LinkedList<String> link=new LinkedList<String>();
		link.add("AAA");
		link.add("BBB");
		link.add("CCC");
		System.out.println(link.peekFirst());//得到头部元素
		System.out.println(link.toString());
		System.out.println(link.pop());//弹出AAA并返回其值
		System.out.println(link.toString());//[BBB, CCC]LinkedList是先进先出的
	}

输出：
AAA
[AAA, BBB, CCC]
AAA
[BBB, CCC]

public class Demo3 {
/*
 * ArrayList是有序的，可以重复的
 * 要求：使用List存储数据，但是：有序的，不能重复的
 */
	public static void main(String[] args) {
		ArrayList list=new ArrayList<>();
		list.add("java2");//1
		list.add("java2");//2
		list.add("java4");//3
		list.add("java5");//4
		list.add("java6");//5
		
		//创建一个临时的集合，用于存储去重后的元素
		ArrayList list1=new ArrayList<>();
		//遍历List
		Iterator it=list.iterator();
		while(it.hasNext()) {
			String str=(String)it.next();
//当list1中没有str的时候，就天津进去
//如果新的集合中不包含当前的元素，就将当前的元素添加进去
/*
 * 原理：在添加新元素的时候，去调用contains方法，看在新的集合中是否有这个元素，
 * 但在contains内部是去调用集合中元素的equals方法，遍历list集合元素,让list1中的指定元素去和list集合中的元素比较，
 * 当所有的equals方法都返回false,整个conrains的结果就是false,有一次比较返回true，整个conrains的结果就是true
 * 退出循环。
 * 
 */
			if(!list1.contains(str))
				list1.add(str);
			
		}
		System.out.println(list1);


	}

}
输出：[java2, java4, java5, java6]

public class Demo1 {

	public static void main(String[] args) {
	/*
	 * Vector:了解
	 * 遍历的是枚举器
	 */
		//使用Vector存值
		Vector v1=new Vector<>();
		v1.add("hello");
		v1.add("world");
		v1.add("i");
		v1.add("love");
		v1.add("my Life");
		System.out.println(v1);
		
		//遍历--枚举器
		//获取枚举器对象
		Enumeration e1=v1.elements();
		//调用方法遍历
		while(e1.hasMoreElements()) {
			Object o1=(Object)e1.nextElement();
			System.out.println(o1);
		}

	}

}

Stack用作资源池

public class TestD {

	public static void main(String[] args) {
		Stack<Integer> s=new Stack<>();//Stack是Vector的子类，底层是数组，它是线性安全的
		s.add(1);
		s.add(2);
		s.add(3);
		System.out.println(s.toString());
		s.pop();//栈，后进先出（只有它特殊）
		System.out.println(s.toString());
	}

}
输出：
[1, 2, 3]
[1, 2]

import java.util.*;

/*
 * ArrayList是有序的，可以重复的
 * 要求：使用List存储数据，但是：有序的，不能重复的
 * 存储的是Person类的对象，只要姓名和年龄相同就认为是一个人
 */
class Person{
	String name;
	int age;
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	Person()
	{}
	Person(String name,int age)
	{
		this.name=name;
		this.age=age;
	}
	public boolean equals(Object obj) {
		if(!(obj instanceof Person)) {
			throw new ClassCastException("当前对象不是Person类的");
		}
		Person p=(Person)obj;
		return (age==p.age && name.equals(p.name));
	}
	
	
	
}
public class Demo4 {
/*
 * ArrayList是有序的，可以重复的
 * 要求：使用List存储数据，但是：有序的，不能重复的
 * 存储的是Person类型的对象
 */
	public static void main(String[] args) {
		ArrayList list=new ArrayList<>();
		list.add(new Person("小明",22));//1
		list.add(new Person("小萝卜头",22));//2
		list.add(new Person("小明",22));//3
		list.add(new Person("赵彦",23));//4
		list.add(new Person("赵彦",23));//5
		
		System.out.println(list);
		ArrayList list1=new ArrayList<>();//新建一个集合，存储结果
		Iterator it=list.iterator();
		while(it.hasNext()) {
//			Object obj=it.next();
//			if(!(list1.contains(obj)));//调用的是Object类中的equals方法
			Person p=(Person)it.next();	
			if(!(list1.contains(p)))//不包含存值,contains内部会调用equals方法比较，所以只要重写equals方法就行了
				
			list1.add(p);
		}
		System.out.println(list1);
	}

}

集合知识点