数据结构

• 1.栈结构：

先进后出，入栈123，出栈321

• 2.队列：

先进先出，存储123，取出123

• 3.数组：

查询快，数组的地址值是连续的，我们可以通过数组的首地址找到数组通过数组索引可以快速查找某一个元素
增删慢，数组的长度是固定的，想要增加/删除一个元素，必须创建一个新数组，把原数组的数值复制过来
在堆内存当中频繁创建数组，复制数组的元素，销毁数组，效率低下

• 4.链表结构：

查询慢，链表中地址不是连续的，都必须从头开始查。
增删快，链表结构增删一个元素，对链表整体结构不影响，所以增删快
单向链表，链表中只有一条链子，不能保证元素的顺序（存储跟取出的顺序可能不一致）
双向链表，链表中有两条链子，有一条专门用来记录顺序，是一个有序列的集合

• 5.红黑树：

二叉树：分支不能超过两个
排序树：在二叉树的基础上，元素有大小排序，左子树小，右子树大
平衡树：左孩子等于右孩子
不平衡树：左孩子不等于右孩子

红黑树：

特点，趋近于平衡树，查询的速度非常快，查询叶子节点最大次数和最小次数不能超过两倍
约束，节点可以是红黑色的。根节点是黑色的。叶子节点（空节点）是黑色的。每个红色的节点的子节点都是黑色的。任何一个节点到其每个叶子节点的所有路径上黑色节点数相同

List集合

public static void main(String[] args) {
    //List集合是有序的，有索引的，可以储存重复元素
    List<String> list = new ArrayList<>();
    list.add("a");//顺序添加元素
    list.add("b");
    list.add("c");
    list.add("d");
    list.add("a");
    System.out.println(list);//[a, b, c, d, a]
    list.add(3,"java");//指定位置添加元素
    System.out.println(list);//[a, b, c, java, d, a]
    String s = list.remove(1);//删除指定索引位置元素，并返回删除元素
    System.out.println(s);//b
    System.out.println(list);//[a, c, java, d, a]
    String s1 = list.set(2, "love");//替换指定索引位置元素，并返回替换元素
    System.out.println(s1);//java
    System.out.println(list);//[a, c, love, d, a]
    //三种集合遍历
    for (int i = 0; i < list.size(); i++) {//for循环遍历
        System.out.println(list.get(i));//取出指定索引位置元素
    }
    Iterator<String> iterator = list.iterator();
    while (iterator.hasNext()) {//迭代器遍历
        Object next =  iterator.next();
        System.out.println(next);
    }
    for (String s2 : list) {//增强for循环遍历
        System.out.println(s2);
    }
}

public static void main(String[] args) {
    //LinkedList查询慢，增删快，链式结构
    LinkedList<String> list = new LinkedList<>();
    list.add("a");//添加元素
    list.add("b");
    list.add("c");
    System.out.println(list);//[a, b, c]
    list.addLast("com");//给最后结尾添加元素，等效add
    System.out.println(list);//[a, b, c, com]
    list.addFirst("www");//给开头添加元素，等效push
    System.out.println(list);//[www, a, b, c, com]
    System.out.println("=====[华丽的分割线]=====");
    String remove = list.remove(0);
    System.out.println(remove);//www
    System.out.println(list);//[a, b, c, com]
    String s = list.removeFirst();//移除第一个元素,等效与pop
    System.out.println(s);//返回删除元素a
    System.out.println(list);//[b, c, com]
    String s1 = list.removeLast();//删除最后一个元素
    System.out.println(s1);//返回删除元素com
    System.out.println(list);//[b, c]
    if(!list.isEmpty()){
        String first = list.getFirst();
        System.out.println(first);//b
        String last = list.getLast();
        System.out.println(last);//c
    }
}

Ste集合

public static void main(String[] args) {
    //不允许储存重复元素，没有索引，无序，底层是一个哈希表结构（查询速度非常快）
    Set<Integer> set = new HashSet<>();
    set.add(1);
    set.add(2);
    set.add(3);
    set.add(1);
    System.out.println(set);//[1, 2, 3]
    Iterator<Integer> iterator = set.iterator();
    while (iterator.hasNext()) {
        Integer next = iterator.next();
        System.out.println(next);
    }
    for (Integer integer : set) {
        System.out.println(integer);
    }
}

public static void main(String[] args) {
    //有序，不允许重复
    //底层哈希表+链表：多了一条链表记录元素储存顺序，保证元素有序
    LinkedHashSet<String> lh = new LinkedHashSet<>();
    lh.add("www");
    lh.add("java");
    lh.add("a");
    lh.add("com");
    System.out.println(lh);//[www, java, a, com]
}

//hashCode()获取哈希地址值

Collctions

public static void main(String[] args) {
    ArrayList<String> list = new ArrayList();
    Collections.addAll(list,"a","b","c","d");//添加元素
    System.out.println(list);//[a, b, c, d]
    Collections.shuffle(list);//打乱元素顺序
    System.out.println(list);//[a, c, d, b]
}

public static void main(String[] args) {
    ArrayList<Integer> list = new ArrayList<>();
    list.add(1);
    list.add(3);
    list.add(2);
    list.add(4);
    System.out.println(list);//[1, 3, 2, 4]
    Collections.sort(list, new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o1-o2;//升序       o2-o1降序
        }
    });
    System.out.println(list);//[1, 2, 3, 4]
}