集合大满贯

概念很重要
集合的框架结构图
集合与数组的对比
Collection接口中常用的方法
上机练习
iterator迭代器
List接口的方法
List接口的存储特点
List接口的实现类

ArrayList类
代码实现
LinkedList类
Vector类
Stack类
ArrayList与LinkedList，Vector三种实现类存储的比较

概念很重要

集合：就是一个存储数据的容器下面这段话很重要，多读几遍好不
集合与数组一样，也是一个容器，与数组不同的是，数组长度固定，集合的长度不定，可以无限的向集合中添加元素，而且集合中存储的元素类型只能是引用类型，数组可以存储基本类型和引用类型。
注意：
任何一种数据类型或者对象放进容器中后都会失去原有的类型，变成 Object，用的时候从容器中取出后进行转型成所需的类型就可以了。
《Think in java》中是这样解释的：由于当初编写集合时，那个集合的程序员根本不知道用户到底想把什么类型置入集合。若指示某个集合只允许特定的类型，会妨碍它成为一个“常规用途”的工具，为用户带来麻烦。为解决这个问题，集合实际容纳的是类型为Object的一些对象的句柄。

集合的框架结构图

Collection集合的框架结构图
在这里插入图片描述 Map集合的框架结构图

集合与数组的对比

相同点：都是数据的容器，在一个数组或集合中可以存储多个数据
不同点：元素：数组中的元素只能是相同，集合中的元素是任意的（泛型）
数组中可以存储基本类型和引用类型，集合只能存储引用类型涉及基本类型的拆装箱
长度(元素个数)：
数组是定长的，一旦初始化长度就不可以修改
集合长度可以修改，可以删除元素和添加元素

Collection接口中常用的方法

add(E e)

确保此 collection 包含指定的元素（可选操作）。

addAll(Collection<? extends E> c)

将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。

clear()

移除此 collection 中的所有元素（可选操作）。

contains(Object o)

如果此 collection 包含指定的元素，则返回true。

containsAll(Collection<?> c)

如果此 collection 包含指定 collection 中的所有元素，则返回 true。

equals(Object o)

比较此 collection 与指定对象是否相等。

isEmpty()

如果此 collection 不包含元素，则返回true。

iterator()

返回在此 collection 的元素上进行迭代的迭代器。

remove(Object o)

从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。

removeAll(Collection<?> c)

移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。

retainAll(Collection<?> c)

仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。

size()

返回此 collection 中的元素数。

toArray()

返回包含此 collection 中所有元素的数组。

上机练习

//1创建Collection对象
   	Collection collection=new ArrayList();
   	//2操作
   	//2.1添加
   	collection.add("张三");
   	collection.add("李四");
   	collection.add("王五");
   	System.out.println("集合的元素个数:"+collection.size());
   	//2.2删除
   	//2.2.1删除一个
   	collection.remove("张三");
   	System.out.println("删除之后的数据个数:"+collection.size());
   	//2.2.2清空
   	collection.clear();
   	System.out.println("清空之后:"+collection.size());
   	
   	//3遍历
   	//3.1 使用增强for//注意：集合中存储的是Object类型
   	System.out.println("--------使用增强for遍历----------");
   	for(Object obj:collection){
   		System.out.println(obj);
   	}
   	//3.2使用迭代器
   	System.out.println("-------使用迭代器---------");
   	Iterator it=collection.iterator();
   	while(it.hasNext()){
   		Object obj=it.next();
   		System.out.println(obj);
   	}
   	//4判断（判断依据equals）
   	//4.1判断是否存在
   	boolean b=collection.contains("王五");
   	boolean b2=collection.contains("他老爷");
   	System.out.println(b);
   	System.out.println(b2);
   	//4.2判断是否为空
   	System.out.println(collection.isEmpty());
   	
   	//5其他方法
   	System.out.println("c1.equals(c2):"+c1.equals(c2));
   	System.out.println("c1==c2:"+(c1==c2));

   Collection collection=new ArrayList();
   	//1添加
   	collection.add(111);//111自动装箱 new Integer(111)
   	collection.add("222");

iterator迭代器

hasNext()

判断迭代器是否存在下一个元素可以迭代器

next()

迭代器迭代下一个元素

remove()

从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。

List接口的方法

add(int index, E element)

在列表的指定位置插入指定元素（可选操作）。

addAll(int index, Collection<? extends E> c)

将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。

containsAll(Collection<?> c)

如果列表包含指定 collection 的所有元素，则返回true。

get(int index)

返回列表中指定位置的元素。

indexOf(Object o)

返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。

lastIndexOf(Object o)

返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。

listIterator()

返回此列表元素的列表迭代器（按适当顺序）。

remove(int index)

移除列表中指定位置的元素（可选操作）。

set(int index, E element)

用指定元素替换列表中指定位置的元素（可选操作）。

subList(int fromIndex, int toIndex)

返回列表中指定的 fromIndex（包括）和 toIndex（不包括）之间的部分视图。

List接口的存储特点

相对有序存储，可以存储相同元素（不排重），可以通过下标访问集合元素
List接口中可以使用独有的迭代器ListIterator，具有反向遍历的功能

List接口的实现类

ArrayList类

ArrayList类是List接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括null在内的所有元素。
存储特点：
相对有序存储，可以存储相同元素（不排重），可以通过下标访问集合元素，通过数组实现的集合
存储结构:数组

代码实现

public class ArrayListDemo {
    public static void main(String[] args) {
      //创建一个ArrayList集合
      ArrayList<String> list = new ArrayList<>();//构造方法中的泛型可以省略
      list.add("zhangsan");//向集合中添加元素
      list.add("lisi");
      list.add("wangwu");
      System.out.println(list.isEmpty());//判断list集合是否为空集合
      System.out.println(list.size());//查看集合中元素的个数
      System.out.println(list.get(1));//获取集合中下标为1的元素
      System.out.println(list.set(1,"zhaoliu"));//修改集合中下标为1的元素
      System.out.println(list.contains("wangwu"));//查看"wangwu"是否是集合中的元素
      list.remove("wangwu");//删除集合中"wangwu"元素
      list.remove(1);//删除集合中下标为1的元素
      //for循环遍历集合
      for(int i=0; i<list.size(); i++){
        System.out.println(list.get(i));
      }
      //使用Iterator迭代器遍历
      Iterator<String> it = list.iterator();//获取迭代器
      while(it.hasNext()){
        System.out.println(it.next());
      }
      //使用ListIterator迭代器遍历
      ListIterator<String> lit = list.listIterator();
      while(lit.hasNext()){
        System.out.println(lit.next());
      }
      //反向遍历
      while(lit.hasPrevious()){
        System.out.println(lit.previous());
      }
    }
 }

LinkedList类

LinkedList类是List接口的链接列表实现。实现所有可选的列表操作，并且允许所有元素（包括null）。
存储特点：
相对有序存储，可以存储相同元素（不排重），可以通过下标访问集合元素，通过链表实现的集合
存储结构:双向链表
LinkedList集合适用在对元素插入和删除操作较频繁的时候
ArrayList集合适用在对元素查询、遍历操作较频繁的时候

Vector类

Vector类可以实现可增长的对象数组。与数组一样，
它包含可以使用整数索引进行访问的组件。
但是Vector的大小可以根据需要增大或缩小，
以适应创建 Vector后进行添加或移除项的操作。
特点:同步的:有序的，可以重复
面试：elements()  
Vector<String> vector=new Vector<String>();
vector.add("xxx");
vector.add("yyy");
System.out.println(vector.size());
System.out.println(vector);
//遍历
//for
//foreach
//迭代器
//枚举器
Enumeration<String> enumeration=vector.elements();
	while(enumeration.hasMoreElements()) {
		System.out.println(enumeration.nextElement());
}

Stack类

Stack类表示后进先出（LIFO）的对象栈。是Vector的子类。
//添加元素   入栈
Stack<String> stack=new Stack<String>();
stack.push("xxx");
//出栈
for(int i=0;i<1;i++){
   System.out.println(stack.pop());
}

ArrayList与LinkedList，Vector三种实现类存储的比较

a.功能基本相同
b.底层存储结构：ArrayList是数组，LinkedList是双向链表，Vector是数组
c.Vector是一个古老的集合，从JDK1.0开始就有了，Vector存在一些方法名比较长的方法，xxxElement
d.Vector是线程安全的，效率低，ArrayList是线程不安全的，效率高，推荐使用ArrayList【Collections工具类中有相应的方法可以将ArrayList改为线程安全的】
e.ArrayList查找遍历比较快，LinkedList插入删除比较快

下一篇文章讲解Set Map Collections工具类。¹

不然篇幅太长了 https://blog.csdn.net/l1996729/article/details/106638694 ↩︎