day09集合

集合框架

为什么要使用集合框架?

1、数组的长度是固定
2、数组无法同时存储多个不同的数据类型
集合简单理解就是一个长度可以改变，可以保持任惩数据类型的动态数组。
集合本身是数据结构的基本概念之一，我们这里说的集合是Java语言对这种数据结构的具体实现。
Java中的集合不是由一个类来完成的，而是由一组接口和类构成了一个框架体系。大致可分为3层，最上层是一组接口,继而是接口的实现类。

集合接口

Collection:集合框架最基础的接口，最顶层的接口。

List: Collection的子接口，存储有序、不唯一（元素可重复）的对象，最常用的接口。

Set: Collection的子接口，存储无序、唯一（元素不可重复)的对象。

Map:独立于Collection的另外一个接口，最顶层的接口，存储一组键值对象，提供键到值的映射。

lterator:输出集合元素的接口,一般适用于无序集合，从前往后输出。

Listlterator: Iterator子接口,可以双向输出集合中的元素。

Enumeration:传统的输出接口,已经被Iterator取代。

SortedSet: Set的子接口,可以对集合中的元素进行排序。

SortedMap: Map的子接口，可以对集合中的元素进行排序。

Queue:队列接口。

Map.Entry: Map的内部接口，描述Map中存储的一组键值对元素。

1、Collection接口

Collection:集合框架最基础的父接口，最顶层的接口，可以存储一组无序，不唯一的对象，一般不直接使用该接口，也不能被实例化，只是用来提供规范。

public interface Collection<E> extends Iterable<E> {
   
    // Query Operations

Collection是Iterable接口的子接口。

int size() 获取集合长度
boolean isEmpty() 判断集合是否为空
boolean contains(Object o) 判断集合中是否存在某个对象
lterator iterator() 实例化lterator接口，遍历集合
Object[]toArray() 将集合转换为一个Object数组
T[]toArray(T[]a) 将集合转换为一个指定数据类型的数组
boolean add(E e) 向集合中添加元索
boolean remove(Object o) 从集合中删除元索
boolean containsAll(Collection c) 判断集合中是否存在另一个集合的所有元素
boolean addAll(Collection ) 向集合中添加某个集合的所有元索
boolean removeAll(Collection c) 从集合中删除某个集合的所有元素
void clear() 清除集合中的所有元素
boolean equals(Collection c) 判断两个集合是否相等
int hashCode() 返回集合的哈希值

2、Collection子接口

List:存放有序、不唯一的元素

Set:存放无序、唯一的元素

Queue:队列接口

List接口

public interface List<E> extends Collection<E> {
   
    // Query Operations

List常用的扩展方法

T get(int index) 通过下标返回集合中对应位置的元素
T set(int index,T element) 在集合中的指定位置存入对象
int indexOf(Object o) 从前向后查找某个对象在集合中的位置
int lastIndexOf(Object o) 从后向前查找某个对象在集合中的位置
Listlterator listlterator() 实例化 Listlterator接口，用来遍历List集合
List subList(int fromindex,int tolndex) 通过下标截取 List集合

List接口的实现类

1、ArrayList：是开发中使用频率最高的List实现类，实现了长度可变的数组，在内存中分配连续空间，所以读取快,增删慢。非线程安全，效率高

2、Vector：线程安全，效率低，实现线程安全直接通过synchronize修饰方法来完成。

3、Stack：Vector的子类，实现了栈的数据结构（后进先出）

• push：入栈方法
• peek：取出栈顶元素，将栈顶复制一份取出，取完之后栈内数据不变。
• pop：取出栈顶元素，直接取出栈顶元素，取完之后栈内的数据减一。

4、LikedList：实现了先进先出的队列，采用链表的形式存储。

ArrayList和LinkedList的区别：

内存中存储的形式不同：ArrayList采用的是数组的方式，LinkedList采用的是链表的形式。

数组在内存中的存储空间是连续的，读取快，增删慢。

因为数组在内存中是连续的，所以取数据可以通过寻址公式很快求出目标元素的内存地址，因为内存是连续的，所以新增或者删除元素，必然需要移动数据，而且数组长度越长，需要移动的元素越多，操作就越慢。

链表在内存中存储空间是不连续的：读取慢，增删快。链表在内存中是不连续的，没有固定的公式可以用，要读取只能从第一位开始一直遍历到目标元素，数据规模越大，操作越慢。

增删快，因为只需要重新设置目标元素前后两个节点的后置指针即可，与数据规模无关。

ArrayList：

package com.southwind.demo;


import java.util.ArrayList;
import java.util.Iterator;

public class Test {
   
    public static void main(String[] args) {
   
        ArrayList list = new ArrayList();
        list.add("Hello");
        list.add("world");
        list.add("JavaSE");
        list.add("JavaME");
        list.add("JavaEE");
        System.out.println("list:"+list);
        System.out.println("list长度:"+list.size());
        System.out.println("list是否包含Java:"+list.contains("Java"));
        for (int i = 0; i < list.size(); i++) {
   
            System.out.println(list.get(i));
        }
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
   
            System.out.println(iterator.next());
        }
        list.remove("Hello");
        list.remove(0);
        System.out.println("************");
        System.out.println(list);
        list.add(1,"Spring");
        System.out.println(list);
        list.add(1,"Spring Boot");
        System.out.println(list);
        list.set(1,"Spring Cloud");
        System.out.println(list);
        System.out.println("*************");
        System.out.println("Spring");
        System.out.println(list.indexOf("Spring"));
        System.out.println(list.subList(1,3));//左闭右开,取1,2不取3

    }
}

Vector：

package com.southwind.demo;

import java.util.Vector;

public class Test2 {
   
    public static void main(String[] args) {
   
        Vector vector = new Vector();//创建vector对象
        Boolean flag = vector.add("Java");
        vector.addElement("Hello");
        vector.add("World");
//        vector.add(1,"OK");
//        vector.set(1,"OK");
        System.out.println(vector);
        System.out.println(vector.get(1));
    }
}

package com.southwind.demo2;

import java.util.ArrayList;
import java.util.Vector;
import java.util.concurrent.TimeUnit;

public class Test {
   
    public static void main(String[] args) {
   
//        ArrayList list = new ArrayList();
        Vector list = new Vector();
        for (int i = 0; i < 10; i++) {
   
//            list.add(String.valueOf(i));
//            System.out.println(list);
            final int temp = i;
            new Thread(()->{
   
                try {
   
                    TimeUnit.MILLISECONDS.sleep(100);
                } catch (InterruptedException e) {
   
                    e.printStackTrace();
                }
                list.add(String.valueOf(temp));
                System.out.println(list);
            }).start();
        }
    }
}

Stack：

package com.southwind.demo2;

import java.util.Stack;

public class Test2 {
   
    public static void main(String[] args) {
   
        Stack stack = new Stack();
        //入栈
        stack.push("Hello");
        stack.push("JavaSE");
        stack.push("JavaME");
        stack.push("JavaEE");
        System.out.println