JAVA-集合-List

package test;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import java.util.Stack;
import java.util.Vector;

public class Collections {
    public static void main(String[] args) {
        /*List
         *     ArrayList - 顺序表
         *         1.底层是通过数组实现的
         *         2.初始容量为10
         *         3.在扩容的时候，每次在当前容量的基础上，增加一半，基于右移
         *         4.线程不安全
         *         5.插入和删除元素相对复杂，查询简单  --查询易，增删难
         * 
         * */
        List<String> L1= new ArrayList<>();
        L1.add("你好");
        L1.add("中国");
        L1.add("北京");
        System.out.println(L1);
        /*
         * List 
         *     LinkedList    - 链表
         *         1.底层通过节点来存储数据，当添加数据的时候，会定义一个新的节点来存储数据
         *         2.节点之间通过地址的引用的方式相互关联
         *         3.线程不安全
         *         4.增删易，查询难。
         * 
         * */
        List<String> L2=new LinkedList<>();
            L2.add("落花雨");
            L2.add("你飘扬在天际");
            System.out.println(L2);
        /*    Comparator -比较器
         *         1.重写compare 方法，在这个方法中制定比较规则
         *         2.在排序的时候根据compare方法返回值的正负来确定排序顺序
         *             例子：
         *                 根据字符串的首字母进行排序
         *                 根据首字母进行降序排序：首字母相同，则位置不发生变化
         * */
            L1.sort(new Comparator<String>() {
                //比较规则就是写在这个方法里
                //根据compare方法的返回值进行排序
                //如果返回的是一个正数，那么认为o1<o2,从而将o1排到o2的后面
                //如果返回的是一个正数，那么认为o1>o2,从而将o1排到o2的前面
                @Override
                public int compare(String o1, String o2) {
                    // TODO Auto-generated method stub
                    return o2.charAt(0)-o1.charAt(0);
                }
            });
            
        /*    Vector - 向量
         *         1.是java最早的集合
         *         2.底层依然是依靠数组来存储元素
         *         3.底层数组默认初始容量是10
         *         4.如果不指定容量增量，那么每次扩容都是加上当前的长度，从而使数组的大小变为了原来的二倍 --- 三元
         *         5.线程安全
         * */
            List<String> L3 = new Vector<>();
            L3.add("花香依");
            L3.add("把往事情勾起");
            System.out.println(L3);
        /*    Stack - 栈
         *         1.是Vector的子类
         *         2.满足后进先出(LIFO)的原则
         *         3.栈顶元素：最后放入栈中的元素
         *         4.栈底元素：最先放入栈中的元素
         *         5.入栈压栈：将元素放入栈中
         *         6.出栈弹栈：将元素从栈取出
         * */
            Stack<String> L4 = new Stack<>();
                L4.push("我愿意");
                L4.push("将浮萍躺湖心");
                System.out.println(L4.peek());
                System.out.println(L4);
        /*
         *     Queue - 队列
         *         1.遵循先进先出的原则(FIFO)
         *         2.队头元素：最先放入队列中的元素
         *         3.队尾元素：最后放入队列中的元素
         *         4.Deque：双向队列    
         * */
    }
}