集合Collection-List

collection单列集合，每个元素只包含一个值，Map代表双列集合，每个元素包含两个值（键值对）

Collection：

代表单列集合，每个元素（数据）只包含一个值；

java 复制代码

package d1_collection;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;

public class CollectionTest1 {
    public static void main(String[] args) {
        // 简单确认collection集合的特点
        ArrayList<String> list = new ArrayList<>();
        //有序 可重复 有索引
        list.add("java1");
        list.add("java2");
        list.add("java3");
        list.add("java3");
        System.out.println(list);//[java1, java2, java3, java3]
        System.out.println(list.get(1));//java2

        HashSet<String> set = new HashSet<>();
        // 无序，不重复 无索引（不能get得到元素）
        set.add("java1");
        set.add("java2");
        set.add("java3");
        set.add("java3");
        System.out.println(set);// [java3, java2, java1]
    }
}

Collection的常用方法：

java 复制代码

package d1_collection;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

public class CollectionTestAPI {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<>();
        // 1、public boolean add(E e)：添加成功返回true
        c.add("java1");
        c.add("java1");
        c.add("java2");
        c.add("java2");
        c.add("java3");
        System.out.println(c);//[java1, java1, java2, java2, java3]

        // 2、public void clear()：清空集合的元素
//        c.clear();
//        System.out.println(c);//true

        // 3、 public boolean isEmpty()： 判断集合时候为空
        System.out.println(c.isEmpty()); //false

        // 4、public int size() 获取集合的大小
        System.out.println(c.size());//5

        //5 、public boolean contains(Object obj)：判断集合中是否包含某个元素
        System.out.println(c.contains("java1"));//true
        System.out.println(c.contains("Java1"));//false

        // 6、 public boolean remove(E e)：删除某个元素：如果有多个重复元素默认删除前边第一个
        System.out.println(c.remove("java1")); //true
        System.out.println(c);//[java1, java2, java2, java3]

        // 7、 public Object[] toArray() 把集合转换成数组
        Object[] arr = c.toArray();
        System.out.println(Arrays.toString(arr)); //[java1, java2, java2, java3]

        String[] arr2 = c.toArray(new String[c.size()]);
        System.out.println(Arrays.toString(arr2)); //[java1, java2, java2, java3]
        
        System.out.println("===============================");
        //把一个集合的全部数据倒入到领一个集合中去
        Collection<String> c1 = new ArrayList<>();
        c1.add("java1");
        c1.add("java2");

        Collection<String> c2 = new ArrayList<>();
        c2.add("java3");
        c2.add("java4");
        c1.addAll(c2);
        System.out.println(c1); // [java1, java2, java3, java4]
        System.out.println(c2); // [java3, java4]

    }
}

Collection的遍历方式

迭代器

用来遍历集合的专用方式（数组没有迭代器），在java中迭代器的代表是Iterator。

Collection集合获取迭代器的方法：

java 复制代码

Iterator<E> iterator()  // 返回集合中的迭代器对象，该迭代器对象默认指向当前集合的第一个元素

Iterator迭代器中的常用方法：

java 复制代码

boolean hasNext() //询问当前位置是否有元素存在，存在返回true，不存在返回false；
E next() //获取当前位置的元素，并同时将迭代器对象指向下一个元素处

java 复制代码

package d2_collection_traverse;

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

public class CollectionDemo01 {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<>();
        c.add("赵敏");
        c.add("小昭");
        c.add("素素");
        c.add("灭绝");
        System.out.println(c);//[赵敏, 小昭, 素素, 灭绝]

        // 使用迭代器遍历集合
        // 1、从集合对象中获取迭代器对象
        Iterator<String> it = c.iterator();
//        System.out.println(it.next()); //赵敏
//        System.out.println(it.next()); //小昭
//        System.out.println(it.next()); //素素
//        System.out.println(it.next()); //灭绝
//        System.out.println(it.next()); //出现异常

        // 2、我们应该使用循环结合迭代器遍历集合
        while(it.hasNext()){
            String ele = it.next();//取数据  迭代器并移到下一个索引
            System.out.println(ele);
        }
        //赵敏
        //小昭
        //素素
        //灭绝
    }
}

增强for循环遍历：

java 复制代码

package d2_collection_traverse;

import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo02 {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<>();
        c.add("赵敏");
        c.add("小昭");
        c.add("素素");
        c.add("灭绝");
        System.out.println(c);//[赵敏, 小昭, 素素, 灭绝]

        // 使用增强for循环遍历集合或者数组
        for(String ele : c){
            System.out.println(ele);
        }

        String[] names = {"迪丽热巴","古力娜扎", "嘻哈"};
        for (String name : names) {
            System.out.println(name);
        }
    }
}

Lambda表达式：

java 复制代码

package d2_collection_traverse;

import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Consumer;

public class CollectionDemo03 {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<>();
        c.add("赵敏");
        c.add("小昭");
        c.add("素素");
        c.add("灭绝");
        System.out.println(c);//[赵敏, 小昭, 素素, 灭绝]

        //default void forEach(Consumer<? super T> action):
        // 结合Lambda表达式遍历集合
        c.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
                //赵敏
                //小昭
                //素素
                //灭绝
            }
        });

        c.forEach((String s) -> {
                System.out.println(s);
        });

        c.forEach(s ->  {
                System.out.println(s);
        });
        
        c.forEach(s -> System.out.println(s));

        c.forEach(System.out::println);
    }
}

List集合

List系列集合特点：有序、可重复、有索引

ArrayList：有序、可重复、有索引

LinkedList：有序、可重复、有索引

java 复制代码

package d3_collection_list;

import java.util.ArrayList;
import java.util.List;

public class ListTest1 {
    public static void main(String[] args) {
        // 1、创建一个ArrayList集合对象（有序、可重复、有索引）
        List<String> list = new ArrayList<>();
        list.add("java1");
        list.add("蜘蛛精");
        list.add("至尊宝");
        list.add("至尊宝");
        list.add("牛夫人");
        System.out.println(list);
        //[java1, 蜘蛛精, 至尊宝, 至尊宝, 牛夫人]

        // public void add(int index,E element)
        // 在此集合中的指定位置插入指定的元素
        list.add(3,"紫霞仙子");
        System.out.println(list);
        // [java1, 蜘蛛精, 至尊宝, 紫霞仙子, 至尊宝, 牛夫人]

        // public E remove(int index)
        // 删除指定索引处的元素，返回被删除的元素
        list.remove(2);
        System.out.println(list);
        // [java1, 蜘蛛精, 紫霞仙子, 至尊宝, 牛夫人]

        // public E set(int index,E element)
        // 修改指定索引处的元素，返回被修改的元素
        list.set(0,"大圣娶亲");
        System.out.println(list);
        // [大圣娶亲, 蜘蛛精, 紫霞仙子, 至尊宝, 牛夫人]

        // public E get(int index)
        // 返回指定索引处的元素
        System.out.println(list.get(0)); //大圣娶亲
    }
}

List遍历方式

for循环（因为List集合有索引）
迭代器
增强for循环
Lambda表达式

java 复制代码

package d3_collection_list;

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

public class ListTest2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("java1");
        list.add("蜘蛛精");
        list.add("至尊宝");
        list.add("至尊宝");
        list.add("牛夫人");
        System.out.println(list);

        // 1、for循环
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            System.out.println(s);
        }

        //2、迭代器
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }

        // 3、增强for循环（foreach遍历）
        for (String s : list) {
            System.out.println(s);
        }

        // 4、jdk 1.8开始之后的Lamdba表达式
        list.forEach(s -> {
            System.out.println(s);
        });



    }
}

ArrayList集合的底层原理

基于数组实现的。

数组的特点：查询快、增删慢

查询速度快(注意:是根据索引查询数据快):查询数据通过地址值和索引定位，查询任意数据耗时相同。
删除效率低:可能需要把后面很多的数据进行前移。
添加效率极低:可能需要把后面很多的数据后移，再添加元素;或者也可能需要进行数组的扩容。

ArrayList集合的底层原理

利用无参构造器创建的集合，会在底层创建一个默认长度为0的数组
添加第一个元素时，底层会创建一个新的长度为10的数组
存满时，会扩容1.5倍
如果一次添加多个元素，1.5倍还放不下，则新创建数组的长度以实际为准

ArrayList集合适合的应用场景

1、ArrayList适合:根据索引查询数据比如根据随机索引取数据(高效)!或者数据量不是很大时!
2、ArrayList不适合:数据量大的同时又要频繁的进行增删操作!

LinkedList集合的底层原理

基于双向链表实现的

LinkedList应用场景：

设计一个队列

设计栈

java 复制代码

package d3_collection_list;

import java.util.LinkedList;

public class ListTest3 {
    public static void main(String[] args) {
        //LinkedList创建一个队列
        LinkedList<String> queue = new LinkedList<>();
        //入队
        queue.addLast("第一号人");
        queue.addLast("第二号人");
        queue.addLast("3");
        queue.addLast("4");
        System.out.println(queue);

        //出队
        queue.removeFirst();
        queue.removeFirst();
        queue.removeFirst();
        System.out.println(queue);
        System.out.println("==============================");

        //LinkedList设计栈（在首部增删元素）
        //数据进入栈模型的过程称为：压、进栈（push）
        //数据离开栈模型的过程称为：弹、出栈（pop）
        LinkedList<String> stack = new LinkedList<>();

        //压栈 push
        stack.addFirst("1");
        stack.addFirst("2");
        stack.addFirst("3");
        stack.addFirst("4");
        stack.addFirst("5");
        System.out.println(stack);
        stack.push("5");
        System.out.println(stack);

        //出栈 pop
        stack.pop();
        stack.pop();
        System.out.println(stack);
        System.out.println(stack.removeFirst());
        System.out.println(stack.removeFirst());
        System.out.println(stack);
    }
}