简单了解数据结构，List、Set、可变参数、Collections基本用法

一、数据结构

数据存储的常用结构有：栈、队列、数组、链表和红黑树。

1.1 栈

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

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

• 先进后出（即，存进去的元素，要在后它后面的元素依次取出后，才能取出该元素）。
• 栈的入口、出口的都是栈的顶端位置。

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

1.2 队列

队列：queue,简称队，它同堆栈一样，也是一种运算受限的线性表，其限制是仅允许在表的一端进行插入，而在表的另一端进行删除。

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

• 先进先出（即，存进去的元素，要在后它前面的元素依次取出后，才能取出该元素）。
• 队列的入口、出口各占一侧。

1.3 数组

数组:Array,是有序的元素序列，数组是在内存中开辟一段连续的空间，并在此空间存放元素。

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

• 查找元素快：通过索引，可以快速访问指定位置的元素
• 增删元素慢（都需要创建新数组，将原数组中的元素复制到新数组中）

1.4 链表

链表:linked list,由一系列结点node（链表中每一个元素称为结点）组成，结点可以在运行时i动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。（链表结构有单向链表与双向链表，这里介绍的是单向链表）

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

• 多个结点之间，通过地址进行连接。
• 查找元素慢：想查找某个元素，需要通过连接的节点，依次向后查找指定元素
• 增删元素快：只需修改连接下个元素的地址即可。
  

1.5 红黑树

二叉树：binary tree ,是每个结点不超过2的有序树（tree），顶上的叫根结点，两边被称作“左子树”和“右子树”。

红黑树也是二叉树的一种，（平衡二叉查找树）
红黑树的约束:

1. 节点可以是红色的或者黑色的
2. 根节点是黑色的
3. 叶子节点(特指空节点)是黑色的
4. 每个红色节点的子节点都是黑色的
5. 任何一个节点到其每一个叶子节点的所有路径上黑色节点数相同
   红黑树的特点:
   速度特别快,趋近平衡树,查找叶子元素最少和最多次数不多于二倍

二、List接口

2.1 List接口

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

2.2 List接口常用方法

继承了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) :用指定元素替换集合中指定位置的元素,返回值的更新前的元素。

public static void main(String[] args) {
// 创建List集合对象        
     List<String> list = new ArrayList<String>();  
     // 往 尾部添加 指定元素    
     list.add("图图");    
     list.add("小美");  
     // add(int index,String s) 往指定位置添加    
     list.add(1,"没头脑");        
     // String remove(int index) 删除指定位置元素  返回被删除元素    
     // 删除索引位置为1的元素     
     System.out.println(list.remove(1));    
     System.out.println(list);    
     // 在指定位置 进行 元素替代（改）     
     list.set(0, "三毛");    ;  
     // String get(int index)  获取指定位置元素    
     // 跟size() 方法一起用  来 遍历的     
     for(int i = 0;i<list.size();i++){    
     System.out.println(list.get(i));        
     }

2.3 List的子类

（1）ArrayList集合：
java.util.ArrayList 集合数据存储的结构是数组结构。元素增删慢，查找快
（2）LinkedList集合
java.util.LinkedList 集合数据存储的结构是链表结构（双向链表）。方便元素添加、删除的集合。

LinkedList是List的子类，List中的方法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() :从此列表所表示的堆栈处弹出一个元素。（相当于removeFirst方法）
• public void push(E e) :将元素推入此列表所表示的堆栈。（相当于addFirst方法）
• public boolean isEmpty() ：如果列表不包含元素，则返回true。

三、Set接口

java.util.Set 接口和 java.util.List 接口一样，同样继承自 Collection 接口，并没有对 Collection 接口进行功能上的扩充，只是比 Collection 接口更加严格了。与 List 接口不同的是， Set 接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。

3.1 HashSet集合

java.util.HashSet 是 Set 接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的(即存取顺序不一致)。HashSet 是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能。保证元素唯一性的方式依赖于： hashCode 与 equals 方法。

 HashSet<String>  set = new HashSet<String>();
        //添加元素
        set.add(new String("cba"));
        set.add("abc");
        set.add("bac");
        set.add("cba"); 
        //遍历
        for (String name : set) {
            System.out.println(name);
        }//“cba”重复，不再储存

3.2 HashSet集合存储数据的结构（哈希表）

哈希表是由数组+链表+红黑树（JDK1.8增加了红黑树部分）实现的

3.3 HashSet存储自定义类型元素

给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯一

public class Student {
    private String name;
    private int age;
    //此处省略构造和get、set方法
    public boolean equals(Object o) {
        if (this == o)
            return true;
        if (o == null || getClass() != o.getClass())
            return false;
        Student student = (Student) o;
        return age == student.age &&
               Objects.equals(name, student.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

 public static void main(String[] args) {
        //创建集合对象   该集合中存储 Student类型对象
        HashSet<Student> stuSet = new HashSet<Student>();
        //存储
        Student stu = new Student("于谦", 43);
        stuSet.add(stu);
        stuSet.add(new Student("于谦", 43));
        stuSet.add(new Student("郭麒麟", 23));
        stuSet.add(stu);
        for (Student stu2 : stuSet) {
            System.out.println(stu2);
        }
    }
    执行结果：
Student [name=郭德纲, age=44]
Student [name=于谦, age=43]
Student [name=郭麒麟, age=23]

3.4 LinkedHashSet

在HashSet下面有一个子类 java.util.LinkedHashSet ，它是链表和哈希表组合的一个数据存储结构。可使放进去的元素有序。
使用如下：

public static void main(String[] args) {    
Set<String> set = new LinkedHashSet<String>();        
set.add("bbb");        
set.add("aaa");        
set.add("abc");        
set.add("bbc");        
        Iterator<String> it = set.iterator();
while (it.hasNext()) {        
System.out.println(it.next());            
}        
}    
}
结果：
  bbb
  aaa
  abc
  bbc

四、可变参数

如果我们定义一个方法需要接受多个参数，并且多个参数类型一致，我们可以对其简化成如下格式：
修饰符 返回值类型 方法名(参数类型… 形参名){ }（底层是数组）
其实等价于：
修饰符 返回值类型 方法名(参数类型[] 形参名){ }

//演示
public static void main(String[] args) {
        int[] arr = { 1, 4, 62, 431, 2 };//可写任意多个数字
        int sum = getSum(arr);
        System.out.println(sum);
        int sum2 = getSum(6, 7, 2, 12);//可写任意多个数字
        System.out.println(sum2);
    }
    //可变参数写法
    public static int getSum(int... arr) {
        int sum = 0;
        for (int a : arr) {
            sum += a;
        }
        return sum;
    }

五、Collections

java.utils.Collections 是集合工具类，用来对集合进行操作。部分方法如下：

5.1 常用方法：

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

 public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        //采用工具类 完成 往集合中添加元素 
        Collections.addAll(list, 5, 222, 1，2);
        System.out.println(list);//[5, 222, 1, 2]
        //排序方法（默认升序排序）
        Collections.sort(list);
        System.out.println(list);//[1, 2, 5, 222]
    }

5.2 Comparator比较器

如果不想要默认的升序排序，这个时候我们可以使用
public static void sort(List list，Comparator<? super T> ) 方法灵活的完成，这个里面就涉及到了Comparator这个接口，位于位于java.util包下，排序是comparator能实现的功能之一,该接口代表一个比较器。比较的方法就是：

• public int compare(String o1, String o2) ：比较其两个参数的顺序。

两个对象比较的结果有三种：大于，等于，小于。
如果要按照升序排序， 则o1 小于o2，返回（负数），相等返回0，01大于02返回（正数） 如果要按照降序排序 则o1 小于o2，返回（正数），相等返回0，01大于02返回（负数）

public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("cba");
        list.add("aba");
        list.add("sba");
        list.add("nba");
        //排序方法  按照第一个单词的降序
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.charAt(0) ‐ o1.charAt(0);
            }
        });
        System.out.println(list);//结果：[sba, nba, cba, aba]
    }

Comparable和Comparator两个接口的区别：

Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。

public class Student {
    private String name;
    private int age;
    //（因代码长度原因）此处省去了构造和get、set方法
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>();
        list.add(new Student("a啦啦啦",18));
        list.add(new Student("b啦啦啦",19));
        list.add(new Student("c啦啦啦",20));
        Collections.sort(list, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o2.getName().charAt(0) - o1.getName().charAt(0);
            }
        });
        System.out.println(list);//按名字降序排序
    }