数据结构

数据结构 : 数据用什么样的方式组合在一起。
数据存储的常用结构有：栈、队列、数组、链表

栈

栈：stack,又称堆栈，它是运算受限的线性表，其限制是仅允许在标的一端进行插入和删除操作，不允许在其他任何位置进行添加、查找、删除等操作。

采用该结构的集合，对元素的存取有如下的特点

• 先进后出(FILO)。例如，子弹压进弹夹，先压进去的子弹在下面，后压进去的子弹在上面，当开枪时，先弹出上面的子弹，然后才能弹出下面的子弹。

• 栈的入口、出口的都是栈的顶端位置。

这里两个名词需要注意：

• 压栈：就是存元素。即，把元素存储到栈的顶端位置，栈中已有元素依次向栈底方向移动一个位置。
• 弹栈：就是取元素。即，把栈的顶端位置元素取出，栈中已有元素依次向栈顶方向移动一个位置。

队列

queue,简称队，它同堆栈一样，也是一种运算受限的线性表，其限制是仅允许在表的一端进行插入，而在表的另一端进行删除。
采用该结构的集合，对元素的存取有如下的特点：

• 先进先出(FIFO)。例如，小火车过山洞，车头先进去，车尾后进去；车头先出来，车尾后出来。
• 队列的入口、出口各占一侧。

数组

Array,是有序的元素序列，数组是在内存中开辟一段连续的空间，并在此空间存放元素。
采用该结构的集合，对元素的存取有如下的特点：

• 查找元素快：通过索引，可以快速访问指定位置的元素

• 增删元素慢

  • 指定索引位置增加元素：需要创建一个新数组，将指定新元素存储在指定索引位置，再把原数组元素根据索引，复制到新数组对应索引的位置。
  • 指定索引位置删除元素：需要创建一个新数组，把原数组元素根据索引，复制到新数组对应索引的位置，原数组中指定索引位置元素不复制到新数组中。

链表

linked list,由一系列结点node（链表中每一个元素称为结点）组成，结点可以在运行时i动态生成。
每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。
我们常说的链表结构有单向链表与双向链表，这里说是单向链表。
采用该结构的集合，对元素的存取有如下的特点：

• 多个结点之间，通过地址进行连接。例如，多个人手拉手，每个人使用自己的右手拉住下个人的左手，依次类推，这样多个人就连在一起了。

• 查找元素慢：想查找某个元素，需要通过连接的节点，依次向后查找指定元素

• 增删元素快

List 接口

java.util.List接口继承自Collection接口，是单列集合的一个重要分支，习惯性地会将实现了List接口的对象称为List集合。
在List集合中允许出现重复的元素，所有的元素是以一种线性方式进行存储的，在程序中可以通过索引来访问集合中的指定元素。另外，List集合还有一个特点就是元素有序，即元素的存入顺序和取出顺序一致。

List接口特点：

1. 它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、22、33的顺序完成的）。
2. 它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。
3. 集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。

常用方法

List作为Collection集合的子接口，不但继承了Collection接口中的全部方法，而且还增加了一些根据元素索引来操作集合的特有方法

• public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。
• public E get(int index):返回集合中指定位置的元素。
• public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
• public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。

List的子类

ArrayList集合

java.util.ArrayList集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合。

随意的使用ArrayList完成任何需求是不提倡的。

LinkedList集合

java.util.LinkedList集合数据存储的结构是链表结构。方便元素添加、删除的集合。是一个双向链表结构

import java.util.LinkedList;

/*
    java.util.LinkedList
        有序有索引 元素可重复
        底层数据结构是双向链表
        查询慢 增删快
        方法:
            public void add(E e) :将指定元素添加到列表的结尾
            public void addFirst(E e) :将指定元素插入此列表的开头。
            public void addLast(E e) :将指定元素添加到此列表的结尾, 其实相当于add方法
            public E get(int index) :返回列表的指定元素。
            public E getFirst() :返回此列表的第一个元素。
            public E getLast() :返回此列表的最后一个元素。
            public E remove() :调用removeFirst方法, 移除并返回此列表的第一个元素。
            public E removeFirst() :移除并返回此列表的第一个元素。
            public E removeLast() :移除并返回此列表的最后一个元素。
            public E pop() :从此列表所表示的堆栈处弹出一个元素。
            public void push(E e) :将元素推入此列表所表示的堆栈。
            public boolean isEmpty() ：如果列表不包含元素，则返回true。
            public void clear() :删除列表中所有元素
 */
public class Demo {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<Integer>();
        list.addLast(200);
        list.add(1);
        list.add(2);
        list.addFirst(100);
        System.out.println(list);

        System.out.println(list.get(2));
        System.out.println(list.getFirst());
        System.out.println(list.getLast());

        list.removeFirst();
        list.removeLast();
        System.out.println(list);

        list.clear();
        System.out.println(list);

        // pop和push是栈结构
        LinkedList<Integer> stack = new LinkedList<Integer>();
        // 压栈
        stack.push(1);
        stack.push(2);
        stack.push(3);
        System.out.println(stack);

        // 弹栈, 并返回弹出的内容
        System.out.println(stack.pop());
        System.out.println(stack);
    }
}

Collections类

java.utils.Collections是集合工具类，用来对集合进行操作

shuffle方法

public static void shuffle(List list)
//打乱(List)集合中元素

昨天的练习题中的洗牌需求可以使用该方法进行实现

Collections.shuffle(pokerArrayList);

sort方法

public static <T extends Comparable<? super T>> void sort(List<T> list)
// 对集合中元素进行排序 集合中的元素必须实现自然排序接口 Comparable 并重写compareTo方法
public static <T> void sort(List<T> list, Comparator<? super T> c)
// 通过传入的比较器指定的规则进行排序

public class Demo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("anc");
        list.add("abc");
        list.add("Abc");
        list.add("ABc");
        Collections.sort(list);
        System.out.println(list);

        List<Person> persons = new ArrayList<>();
        persons.add(new Person(23));
        persons.add(new Person(17));
        persons.add(new Person(26));
        Collections.sort(persons);
        System.out.println(persons);
        // 传入Comparator比较器指定规则 完成降序 
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                // o1-o2升序 o2-o1降序
                return o2.compareTo(o1);
            }
        });
        System.out.println(list);

   }
}
class Person implements Comparable<Person> {
    private int age;

    public Person(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public int compareTo(Person other) {
        return this.age - other.age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                '}';
    }
}