java集合（List、Set、Map等类详解）

集合

一、Collection接口

集合（collection）有时又称为容器，简单地说，它是一个对象，能将具有相同性质的多个元素汇聚成一个整体

集合被用于存储、获取、操纵和传输聚合的数据

集合框架（Collections Framework）是用来表现和操纵集合的一个统一的体系结构。所有的集合框架都包含以下内容：

• 接口：是代表集合的抽象数据类型。
• 实现：是集合接口的具体实现。本质上，它们是可重用的数据结构，是一些类。
• 算法：是在实现了集合接口的对象上执行有用的计算的方法，如查找和排序。

二、Iterator接口

Collection接口提供了集合接口的通用操作：

基本操作
int size()	返回集合元素的个数
boolean isEmpty()	判断集合是否包含集合元素
boolean contains(Object o)	判断集合中是否包含指定元素
boolean add(E element)	向集合中添加指定元素
boolean remove(Object o)	从集合中移除指定元素
Iterator iterator()	返回在集合元素上进行迭代的迭代器

批量操作
boolean containAll(Collection<?> c)	集合中是否包含指定的所有集合元素
boolean addAll(Collection<? extendsE> c )	向集合中添加指定集合的所有元素
boolean removeAll(Collection<?> c)	从集合中移除指定集合的包含的元素
void clear()	移除集合中所有元素
boolean retainAll(Collection<?> c)	保留集合中指定的元素

Collection集合元素的遍历方式：

1. for-each结构遍历

 for(Object o:c){
   
	System.out.print(o.toString());
 }

2. 迭代器Iterator遍历

 public interface Iterator<E>{
   
           public boolean hasNext();
           public E next();
           public void remove();
 } 

三种遍历方式实现：

import java.util.ArrayList;
import java.util.Iterator;
public class Bianli {
   
    public static void main(String[] args) {
   
        ArrayList arr = new ArrayList();
        arr.add(10);
        arr.add(1);
        arr.add("123");

        System.out.println("----------遍历----------");
        //遍历
        for (int i = 0; i<arr.size() ; i++) {
   
            System.out.println(arr.get(i));
        }
        
        System.out.println("----------增强for遍历----------");
        //增强for循环
        for(Object o:arr){
   
            System.out.println(o);
        }
        
        System.out.println("----------迭代器遍历----------");
        //迭代器——Iterator
        Iterator iterator = arr.iterator();
        while(iterator.hasNext()){
   
            Object next = iterator.next();
            System.out.println(next);
        }
    }
}

运行结果：

三、List接口以及实现类

List接口是一个有序的集合，可以包含重复元素。

除了从Collection继承来的操作外，List接口还提供了以下按序列进行操作的方法：

按序列操作的方法
E get(int index)	返回集合中指定位置的元素
int indexOf(Object o)	返回指定对象在集合中的索引位置
List subList(int from ,int to)	从集合中截取子集合
E remove(int index)	移除集合中指定位置的元素

Java平台提供了两个通用的List接口实现类

• java.util.ArrayList
• java.util.LinkedList

迭代器：Iterator是接口

作用：用来遍历集合的每一个集合对象都有一个对应的迭代器对象list.iterator()返回的是Iterator实现类的实例。

以ArrayList为例演示List接口的使用方法：

ArrayList类：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;

public class Main {
   
    public static void main(String[] args) {
   
        
        //集合：用来存放相同性质的数据集合
        ArrayList list = new ArrayList();//创建一个ArrayList集合容器

        //ArrayList,元素有序[根据元素存入的顺序存放]，内存空间连续。
        //元素可以重复也可以为null  【add(null)】
        //插入和删除的效率比较低，但是查询效率比较高。

//增
        list.add(10);
        list.add("azhe");
        list.add(new Date());
        list.add(1,1);
        System.out.println(list);//[10, 1, azhe, Tue Jul 27 09:34:47 CST 2021]

// 删
        list.remove(new Integer(10));//删除指定元素    转型
        list.remove("azhe");//删除指定元素
        System.out.println(list);
        list.remove(1);//删除指定下标的元素remove
        // list.clear();//清空

// 改
        list.set(1,"我");//set  将新的元素下标，替换新的元素set
        System.out.println(list);//[1, 我]

// 查
        //get()   获取容器种的指定下标元素
        Object o = list.get(2);  //返回值类型为Object
        System.out.println(o);//azhe

        boolean empty = list.isEmpty();//判断容器是否为空isEmpty()
        System.out.println(empty);//false

        boolean contains = list.contains(1);//查看是否包含指定元素contains
        System.out.println(contains);//true

        int i = list.indexOf(10);//获取指定元素的下标indexOf
        System.out.println(i);//0

        int size = list.size();//获取容器的长度size
        System.out.println(size);//4      存放了四个元素

        //toArray()   转为数组
        Object[] objects = list.toArray();
        System.out.println(Arrays.toString(objects));//[1, 我, 10, azhe, Tue Jul 27 10:06:25 CST 2021]
  
        
//批量操作
        ArrayList arr = new ArrayList();
        arr.add(10);
        arr.add(20);

        ArrayList arr1 = new ArrayList();
        arr1.add(30);
        arr1.add(40);

        arr.addAll(arr1);  //将两个集合中的元素添加到 当前集合中
        System.out.println(arr);//[10, 20, 30, 40]

        arr.removeAll(arr1);    //删除arr1中的元素
        System.out.println(arr);//[10, 20]

        arr.retainAll(arr1);  //删除其中没有的，保留相同的

        arr.contains(arr1);//两个集合中都有的

        ArrayList arr2 = new ArrayList(arr1);//将另一个集合中的元素放入新集合  
    }
}

LinkedList类：

import java.util.LinkedList;
public class LInk_List {
   
    public static void main(String[] args) {
   

        //LinkedList   内存空间不连续，元素有序，元素可以重复，元素可以为null。
        //双向链表 。   删除和插入的效率比较高，查询效率比较低。
        //方法和LinkList一样使用

        LinkedList  list = new LinkedList();
        list.add("asd");//添加
        list.remove(0);//删除
        int size = list.size();//长度
        list.set(0,1);//替换
        Object o = list.get(0);//查找
        int asd = list.indexOf("asd");//查找
        boolean asd1 = list.contains(&