第八章 List、Set、数据结构、Collections

1. 常见的数据结构：

   1. 栈：先进后出，分为压栈和弹栈
   2. 队列：属于线性表的一种，先进先出
   3. 数组：有序元素序列
      1. 查询元素快，通过索引访问指定位置的元素
      2. 增删元素慢，因为增删元素时需要创建一个新的数组，先存元素索引，在存储元素的值
   4. 链表：数据域存储数据，指针域存储下一个结点的地址
      1. 查询元素慢
      2. 增删元素快

2. List接口常用方法：数组结构特点

   1. 常用语法：

      import java.util.ArrayList;
      import java.util.Iterator;
      import java.util.LinkedList;
      import java.util.List;
      /*
      java.util.List接口 extends Collection接口
      List接口的特点:
      1.有序的集合,存储元素和取出元素的顺序是一致的(存储123 取出123)
      2.有索引,包含了一些带索引的方法
      3.允许存储重复的元素

       List接口中带索引的方法(特有)
           - public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。
           - public E get(int index):返回集合中指定位置的元素。
           - public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
           - public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
       注意:
           操作索引的时候,一定要防止索引越界异常
           IndexOutOfBoundsException:索引越界异常,集合会报
           ArrayIndexOutOfBoundsException:数组索引越界异常
           StringIndexOutOfBoundsException:字符串索引越界异常

      */
      public class Demo1List {

       public static void main(String[] args) {

      // ListMethod1();

           LinkedDemo1();
      
       }
      
       private static void ListMethod1(){
           List<String> list1 = new ArrayList<String>();
           list1.add("123");
           list1.add("测试内容");
           System.out.println("第一次添加测试："+ list1);
      
           list1.add(1,"添加元素");
           System.out.println("添加的内容："+list1);
      
           System.out.println("删除索引位置为2的元素："+list1.remove(2));
      
           list1.set(0,"修改元素");
           System.out.println("指定位置修改元素："+list1);
      
           // 遍历列表集合
           for (int i = 0; i <list1.size() ; i++) {
               System.out.println("遍历的结果："+list1.get(i));
      
           }
      
       }

3. LinkedList：

   1. 集合数据存储的结构是链表结构。方便元素添加、删除的集合

      /*
          java.util.LinkedList集合 implements List接口
          LinkedList集合的特点:
              1.底层是一个链表结构:查询慢,增删快
              2.里边包含了大量操作首尾元素的方法
              注意:使用LinkedList集合特有的方法,不能使用多态
      
              - public void addFirst(E e):将指定元素插入此列表的开头。
              - public void addLast(E e):将指定元素添加到此列表的结尾。
              - public void push(E e):将元素推入此列表所表示的堆栈。
      
              - public E getFirst():返回此列表的第一个元素。
              - public E getLast():返回此列表的最后一个元素。
      
              - public E removeFirst():移除并返回此列表的第一个元素。
              - public E removeLast():移除并返回此列表的最后一个元素。
              - public E pop():从此列表所表示的堆栈处弹出一个元素。
      
              - public boolean isEmpty()：如果列表不包含元素，则返回true。
      
       */
      public class LinkedListDemo {
      public static void main(String[] args) {
          LinkedList<String> link = new LinkedList<String>();
              //添加元素
              link.addFirst("abc1");
              link.addFirst("abc2");
              link.addFirst("abc3");
              System.out.println(link);
              // 获取元素
              System.out.println(link.getFirst());
              System.out.println(link.getLast());
              // 删除元素
              System.out.println(link.removeFirst());
              System.out.println(link.removeLast());
              while (!link.isEmpty()) { //判断集合是否为空
              System.out.println(link.pop()); //弹出集合中的栈顶元素
              }
              System.out.println(link);
          }
      }

      1. Set集合

         1. 存储的数据是不可重复且无需的；

         2. 底层实现是hashMap；

         3. 保证元素唯一性方法依赖于hashCode and equals方法；

         4. 给HashSet中存放自定义元素是，需要重写hashCode 和equals方法；

            import java.security.PublicKey;
            import java.util.HashSet;
            import java.util.LinkedHashSet;

            /*
            java.util.Set接口 extends Collection接口
            Set接口的特点:
            1.不允许存储重复的元素
            2.没有索引,没有带索引的方法,也不能使用普通的for循环遍历
            java.util.HashSet集合 implements Set接口
            HashSet特点:
            1.不允许存储重复的元素
            2.没有索引,没有带索引的方法,也不能使用普通的for循环遍历
            3.是一个无序的集合,存储元素和取出元素的顺序有可能不一致
            4.底层是一个哈希表结构(查询的速度非常的快)
            */
            public class Demo1Set {
            public static void main(String[] args) {
            HashSetDemo();
            LinkedHashSetTest();

             }
            
             private static void HashSetDemo(){
                 HashSet<String> settest1 = new HashSet<String>();
            
                 settest1.add("abc");
                 settest1.add("abc");
                 settest1.add("123");
                 settest1.add("456");
                 System.out.println(settest1);  // 无序不重复
                 for (String s : settest1) {
                     System.out.println(s);
                 }
            
             }
            
             private static void LinkedHashSetTest(){
                 LinkedHashSet<String> linked = new LinkedHashSet<String>();
                 linked.add("123");
                 linked.add("123");
                 linked.add("789");
                 linked.add("456");
                 System.out.println("LinkedHashSetTest内容测试："+linked); // 有序不重复
                 for (String i:linked){
                     System.out.println("遍历后的结果："+ i);
                 }
            
             }

            }

         HashSet:

         存储自定义类型元素:哈希表底层采用数组+链表实现

         LinkedHashSet:

         链表和哈希表组合的一个数据存储结构

         1. 可变参数:

            1. 参数类型一致，且需要接受多个参数

            2. 底层实现是一个数组

               /*
                   1.可变参数:是JDK1.5之后出现的新特性
                   使用前提:
                       当方法的参数列表数据类型已经确定,但是参数的个数不确定,就可以使用可变参数.
                   使用格式:定义方法时使用
                       修饰符 返回值类型 方法名(数据类型...变量名){}
                   可变参数的原理:
                       可变参数底层就是一个数组,根据传递参数个数不同,会创建不同长度的数组,来存储这些参数
                       传递的参数个数,可以是0个(不传递),1,2...多个
               
                   2. 可变参数的注意事项
                       1.一个方法的参数列表,只能有一个可变参数
                       2.如果方法的参数有多个,那么可变参数必须写在参数列表的末尾
                */
               
                   /*public static void method(String b,double c,int d,int...a){
                   }*/
               
               public class Demo1ChangeArgs {
                   public static void main(String[] args) {
               
               //        int a = addTest(1,3,4,5,6);
               //        int b = sumTest(10,20,30,40,50);
               //        System.out.println("可变参数sum结果："+ b);
                       method("abc",5.5,10,1,2,3,4);
                   }
               
                   public static int addTest(int...arrTest){
                       System.out.println(arrTest);  // 地址值
                       System.out.println(arrTest.length);  // 长度
                       return 0;
               
                   }
               
                   public static int sumTest(int...arrTest){
                       int sum = 0;
                       for (int i : arrTest) {
                           sum+=i;
               
                       }
                       return sum;
                   }
               
                   public static void method(Object...obj){
                       System.out.println(obj);
               
                   }
               }

         2. Collections

            import java.util.ArrayList;
            import java.util.Collection;
            import java.util.Collections;
            import java.util.Comparator;
            /*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 class CollectionDemo {
                public static void main(String[] args) {
            
                    Demo1();
                    comparetorDemo1();
            
                }
            
                public static void Demo1(){
                    ArrayList<Integer> list1 = new ArrayList<Integer>();
                    Collections.addAll(list1, 1,2,4,8,5);
                    System.out.println("集合工具类之添加元素："+list1);
            
                    Collections.sort(list1);
                    System.out.println("排序后的结果："+ list1);
                }
            
                public static void comparetorDemo1(){
            
                    ArrayList<String> list1 = new ArrayList<String>();
                    Collections.addAll(list1, "abc", "cba", "bac");
            
                    Collections.sort(list1, new Comparator<String>() {
                        @Override
                        public int compare(String o1, String o2) {
            //                return o2.charAt(0) - o1.charAt(0); // 降序操作
                            return o1.charAt(0) - o2.charAt(0);  // 升序操作
            
                        }
                    });
                    System.out.println("升序操作："+ list1);
            
                }
            }

         3. Comparator比较器