集合框架1

目录

一、认识集合

二、Collection接口

三、Iterable接口

四、Queue接口

4.1Queue接口概述

4.2 Deque接口

五、List接口

5.1 使用ArrayList类动态存储数据

5.1.1 ArrayList定义类有两个私有属性

5.1.2 构造方法 

5.1.3 操作数据

 5.2 使用LinkedList类动态存储数据

5.2.1 LinkedList中定义的属性

5.2.2 Node类定义

5.2.3 构造方法

 5.2.4 操作数据

5.3 Vector

5.4 Stack

一、认识集合

Java 中集合体系：

java 中的集合框架主要从三个方面入手： 

二、Collection接口

Collection接口是Java标准库中的一个接口，用于表示一组对象的集合。

public interface Collection<E>
extends Iterable<E>

从类的声明我们可以看到， Collection 接口继承了 Iterable 接口。也就意味着，实现了

Collection 接口的类也间接实现了 Iterable 接口，也就是说它们都能作为 for - each - loo

p 的循环对象。

抽象方法：

 子接口很多，主要研究 List 、 Set 、 Queue 。

Collection接口的实现类包括常见的ArrayList、LinkedList、HashSet、TreeSet、LinkedHashSet。

三、Iterable接口

java.lang.Iterable接口是Java标准库中的一个接口，用于表示可迭代的集合类。实现了Iterable接口的类可以使用Java中的for-each循环语句来遍历其元素，使其具有可迭代的特性。

实现了Iterable接口的类可以通过实现iterator()方法来返回一个迭代器对象，使其可以使用for-each循环语法来遍历集合中的元素。例如，ArrayList、LinkedList、HashSet、TreeSet等集合类都实现了Iterable接口，因此可以直接用for-each循环来遍历他们的元素。

实现了Iterable接口的类应该保证其迭代器的行为是一致的，即多次调用iterator()方法返回的迭代器应该具有相同的遍历顺序和结果。同时，如果集合在迭代过程中发生了结构性变化（如添加、删除元素），应该抛出ConcurrentModificationException异常来通知迭代器和调用者。

四、Queue接口

4.1Queue接口概述

public interface Queue<E>
extends Collection<E>

主要抽象方法 ：

 特殊值（或者 null 或 false ，取决于操作）。

Queue接口的实现类有很多，例如常用的LinkedList、ArrayDeque，Queue接口不允许插入null元素，也不允许包含重复的元素。

4.2 Deque接口

public interface Deque<E>
extends Queue<E>

继承了 Queue ,支持两端(首尾)元素插入和移除的线性集合。

 java.util.Deque接口（双端队列）是Java标准库中的一种集合接口，代表了一种具有队列和栈特性的数据结构，支持在队列的两端进行插入和删除操作。Deque接口继承自Queue接口。

Deque接口的主要特点：

（1）双向操作：Deque接口允许在队列的两端进行插入、 删除、检索操作。

（2）队列特性：Deque接口支持队列的特性，支持FIFI（先进先出）的队列行为。

（3）栈特性：Deque接口支持栈的特性，支持LIFO（后进先出）的队列行为。

（4）实现类：包括ArrayDeque和LinkedList。

常用抽象方法：

五、List接口

5.1 使用ArrayList类动态存储数据

ArrayList集合类对数组进行了封装，实现了长度可变的数组，而且和数组采取相同的存储方式，在内存中分配连续的空间，称ArrayList为动态数组。但不等同于数组，ArrayList集合中可以添加任何类型的数据，添加的数据都将转换成Object类型，在数组中只能添加同一类型的数据。

实现了List接口，底层使用数组保存所有的元素。每个ArrayList都有一个容量，该容量是指用来存储列表元素的数组的大小。

5.1.1 ArrayList定义类有两个私有属性

private transient Object[] elementData;
private int size;

transient关键字：Javaz中的serialization提供了一种持久化对象实例的机制。当持久化对象时，可能有一个特殊的对象数据成员，我们不想用serialization机制来为了在一个特定对象的一个域上关闭serialization，就在这个与前加上关键字transient。

5.1.2 构造方法 

ArrayList提供三种方式的构造器，可以构造一个默认初始容量为10的空列表、构造一个指定初始容量的空列表以及构造一个指定collection的元素的列表。

private static final int DEFAULT_CAPACITY=10;
    private static final Object[] EMPTY_ELEMENTDATA={};
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA={};
 
    public ArrayList(int initialCapacity){
        if (initialCapacity>0){
            this.elementData=new Object()[initialCapacity];
        }else if (initialCapacity==0){
            this.elementData=EMPTY_ELEMENTDATA;
        }else {
            throw new IllegalStateException("Illegal Capacity:"+initialCapacity);
        }
    }
 
    public ArrayList(){
        this.elementData=DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    public ArrayList(Collection<? extends E> c){
        Object[] a=c.toArray();
        if ((size==a.length)!=0){
            if (c.getClass()==ArrayList.class){
                elementData=a;
            }else {
                elementData= Arrays.copyOf(a,size,Object[].class);
            }
        }else {
            elementData=EMPTY_ELEMENTDATA;
        }
    }

5.1.3 操作数据

 5.2 使用LinkedList类动态存储数据

能将LinkedList当作双端队列使用，优点在于插入、删除元素时效率比较高，但是LinkedList类的查找效率低。

5.2.1 LinkedList中定义的属性

transient int size=0;
transient LinkedList.Node<E> first;
transient LinkedList.Node<E> last;

（1）size：双向列表的节点个数

（2）first：双向链表指向头节点的指针

（3）last：双向链表指向尾节点的指针

5.2.2 Node类定义

private static class Node<E>{
    E item;
    LinkedList.Node<E> next;
    LinkedList.Node<E> prev;
 
    Node(E element, LinkedList.Node<E> next, LinkedList.Node<E> prev) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

5.2.3 构造方法

public LinkedList(){
       
   }
   public LinkedList(Collection c){
       this();
       addAll(c);
   }

 5.2.4 操作数据

5.3 Vector

5.4 Stack

public class Stack extends Vector

package collection;
 
import java.util.Stack;
 
public class ArrayListExample {
    public static void main(String[] args) {
        //创建一个Stack对象
        Stack<Integer> stack=new Stack();
 
        //添加元素
        stack.push(1);
        stack.push(2);
        stack.push(3);
 
        //弹出并删除元素
        int pop = stack.pop();
        System.out.println(pop);
        System.out.println(stack);
 
        //弹出但是不删除
        Integer peek = stack.peek();
        System.out.println(peek);//2
 
        //判断是否为空
        boolean empty = stack.isEmpty();
        System.out.println(empty);//false
 
        //获取元素个数
        System.out.println(stack.size());//2
 
        //搜索元素在栈中的位置
        int search = stack.search(1);
        System.out.println(search);
 
    }
}