第十四章List、Set、数据结构、Collections

一、数据结构

数据结构是计算机存储、组织数据的方式

常见的数据结构类型

1、栈：stack，又叫堆栈，仅允许在顶端进行插入和删除操作，先进后出，栈的入口、出口的都是栈的顶端位置，形象类比子弹压进弹夹。
压栈：就是存元素。把元素存储到栈的顶端位置，栈中已有元素依次向栈底方向移动一个位置。
弹栈：就是取元素。把栈的顶端位置元素取出，栈中已有元素依次向栈顶方向移动一个位置
2、队列：queue，仅允许在表的一端进行插入，而在表的另一端进行删除，先进先出，队列的入口、出口各占一侧
3、数组：Array，有序的元素序列，有索引且长度不变，数组是在内存中开辟一段连续的空间，并在此空间存放元素，查找元素快（通过索引即可快速找到），增删元素慢（因长度不变，故而只能新开辟空间新建数组）
4、链表：linked list，由一系列结点node（链表中每一个元素称为结点）组成，每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域，主要讨论单项列表，多个结点之间，通过地址进行连接，查找元素慢（需要通过节点依次向后查找），增删元素快（只需要修改连接的地址即可）
5、二叉树：binary，每个结点不超过2的有序树，红黑树：趋于平衡的二叉树，查找的子节点最多次数和最少次数不超过2倍，查询增删速度特别快

二、List集合

本章主要讨论Collection接口（单列集合）的两个子类：java.util.List集合、java.util.Set集合
list接口的特点：List接口是一个有序，有索引可以存储重复元素的集合

1、List常用方法(增、删、改、查)

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

2、ArrayList与LinkedList集合

ArrayList集合数据存储的是数组结构，元素增删慢，查找快，日常较多为查找与遍历，故ArrayList为最常用的集合

前期已有讲解ArrayList集合，本节主要探讨LinkedList集合

LinkedList双向链表结构，有序、有索引、元素可重复、的基础上增加了链表的增删块查找慢特点，

LinkedList提供了大量首尾操作的方法：
public void addFirst(E e):将指定元素插入此列表的开头。
public void addLast(E e):将指定元素添加到此列表的结尾。
public E getFirst():返回此列表的第一个元素。
public E getLast():返回此列表的最后一个元素。
public E removeFirst():移除并返回此列表的第一个元素。
public E removeLast():移除并返回此列表的最后一个元素。
public E pop():从此列表所表示的堆栈处弹出一个元素。
public void push(E e):将元素推入此列表所表示的堆栈。

三、Set集合

Set集合特点：无序，无索引，不可存储重复的元素

常用子类：（继承Set特点的基础上）
HashSet：底层采用哈希表结构（非常快）
LinkedHashSet：速度很快，并且能够保证顺序
TreeSet：能够保证元素自然升序排序

1、HashSet集合

步骤：
1、自定义类
2、在类中重写hashCode和equals方法（使用IDEA生成 Alt + Insert）
3、创建对象存入HashSet集合中取
4、遍历集合查看结果
给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式

public class Student {
    private String name;
    private int age;
    构造空参、满参、getter\setter
    重写equals、hashCode 
    //equals是为了方便对比，hashCode是为了避免小概率下的哈希值相同，两者都重写是为了保证自定义下：存入的元素不会出现重复

 public static void main(String[] args) {			 
    HashSet<String> set1 = new HashSet<>(); 存储字符串、多态  
    set1.add("CCC");
    set1.add("AAA");
    set1.add("AAA");
    set1.add("BBB");
    System.out.println("set1 = " + set1);
    Iterator<String> iter = set1.iterator();遍历这个set集合、迭代器
    while (iter.hasNext()) {
		String next = iter.next();
        System.out.println("next = " + next);
    }
    Student stu1 = new Student("蔡徐坤",18);//自定义类型：Student
    Student stu2 = new Student("蔡徐坤",18);
    Student stu3 = new Student("蔡徐坤",20);
    HashSet<Student> stus = new HashSet<>();
    stus.add(stu1);
    stus.add(stu2);
    stus.add(stu3);
    System.out.println("stus = " + stus);}

2、LinkedHashSet及TreeSet的用法

LinkedHashSet：底层结构中含有链表结构，所以可以保证插入顺序

public static void main(String[] args) { 
    LinkedHashSet<String> set1 = new LinkedHashSet<>();
    set1.add("CCC");
    set1.add("AAA");
    set1.add("AAA");
    set1.add("BBB");
    System.out.println("set1 = " + set1);}

TreeSet：底层采用的是二叉查找树，能够将存入的数据，自动升序排序【自然升序排序】（字符对应的编码表的数字大小排序）

public static void main(String[] args) {
    TreeSet<String> set = new TreeSet<>();
    set.add("B");
    set.add("C");
    set.add("A");
    set.add("2");
    set.add("1");
    set.add("3");
    set.add("3");
    System.out.println("set = " + set);}

四、Collections工具类

Arrays：数组的工具类
Collections:集合的工具类

1、常用功能

public static <T> boolean addAll(Collection<T> c, T... elements):往集合中添加一些元素。
public static void shuffle(List<?> list) 打乱顺序:打乱集合顺序。
public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。
public static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则排序。

//public static <T> boolean addAll(Collection<T> c, T... elements):往集合中添加一些元素
ArrayList<String> list1 = new ArrayList<>();
Collections.addAll(list1, "BB", "BB", "BB", "BB", "BB"); 
//2. public static void shuffle(List<?> list) 打乱顺序:打乱集合顺序。
ArrayList<String> list3 = new ArrayList<>();
Collections.addAll(list3, "1", "2", "3", "4", "5");
Collections.shuffle(list3);// 将list3中的元素打乱
//3. public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。
Collections.sort(list3); // 排序

2、Comparator比较器(用于默认类型下的自定义规则比较)

Comparator: 在自定义排序规则的时候使用
需要实现抽象方法【排序规则】：升序就是1【o1】-2【o2】
int compare(E o1, E o2){
return o1-o2; // 升序排序
}

//4. public static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则排序,Comparators是比较器
// int compare(T o1, T o2);比较两个元素的大小，返回整数：负数o1比o2小，0 o1和o2相同，正数o1比o2大
Collections.sort(list1, new Comparator<String>() {
	@Override
    public int compare(String o1, String o2) {
    return o1.length()-o2.length();采用字符串的长度，升序排序
	}});

3、Comparator与Comparable两个接口的区别

Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。

Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。

4、自定义类型集合排序

/*自定义类型的排序
1) Comparator:自定义比较规则
2) Comparable： 使自定义类具备排序比较规则【自然排功能】
    public int compareTo(E o){
        //升序：我【this】-他【o】
        return this.属性-o.属性; //升序
所以最后两者通过重写方法后(前者main方法中重写compare(o1,o2),后者自定义类中重写compareTo(E o))最后都可以实现相同的功能，无论是升序还是倒序
    }*/

public static void main(String[] args) {
        Student stu1 = new Student("AA", 11);
        Student stu2 = new Student("BBB", 10);
        List<Student> stus = new ArrayList<>();
        Collections.addAll(stus, stu1, stu2);
        System.out.println("stus = " + stus);
        Collections.sort(stus);// 年龄排序，自定义类中已重写compareTo(E o)方法
        System.out.println("stus = " + stus);

        //姓名的长度升序排序
        Collections.sort(stus, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getName().length() - o2.getName().length();
            }
        });
        System.out.println("stus = " + stus);}}

public class Student implements Comparable<Student>{
    private String name;
    private int age;
	构造空参、满参、getter\setter
    重写equals、hashCode //equals是因自定义类前期中的比较器存在需要对比故重写

    @Override	//重新定义Comparable下的compareTo，使其拥有特定功能
    public int compareTo(Student o) {
        // this   o
        //年龄升序排序
        return this.age-o.age;
    }
}