ArrayList, LinkedList, Collections

本篇文章只是本人为方便查找相关方法而记录，下面具体代码并没有真正运行。

数组在开辟时需要指定数组元素的个数，且个数一旦确定，不能随意更改. 链表类似于数组，但是可以动态的增加或减少元素。

需要开辟数组，但是数组维度未知时，可以选择先使用ArrayList，后面再转化为数组。
   // (一)、LinkedList 利用-双向-链表实现，增删方便，查询慢
        // (1) LinkedList的创建：  不带参(空集合) / 带参(由已有集合转化)
        LinkedList<Integer> lis = new LinkedList<>();
        List<Integer> lis2=new LinkedList<>(lis.subList(1,3));
        List<Integer> lis3=new LinkedList<Integer>(new ArrayList<>(Arrays.asList(new Integer[]{1,2,3})));
        // (2) 增加元素
        lis3.add(5);                       // 末尾增加元素
        lis3.add(4,4);     				   // 指定位置增加元素
        lis3.addAll(lis2);                 // 尾部合并
        lis3.addAll(2,lis2);       		   // 从指定元素处合并
        // (3) 删除元素
        lis3.remove(3);             	   // 删除指定位置元素
        lis3.remove(new Integer(5));	   // 删除首次出现的指定对象
        lis3.removeAll(lis2);              // 删除lis2中的数据
        lis3.clear();                      // 清空
        // (4) 更改元素
        lis3.set(1,new Integer(2)); // 更改指定位置元素
        lis3.sort(Integer::compareTo);     // 元素排序
        lis3.toArray();                    // 转化为数组
        lis3.subList(1,3);                 // 子链表
        lis3.retainAll(lis2);              // 仅保留和集合lis2中相同的元素
        // (5) 查询
        lis3.get(1);                        // 指定位置元素值
        lis3.size();                        // 大小
        lis3.isEmpty();                     // 是否为空
        lis3.contains(new Integer(2));// 是否包含指定元素
        lis3.containsAll(lis2);             // 是否包含指定集合
        lis3.indexOf(new Integer(2));		// 某元素第一次出现位置
        lis3.lastIndexOf(new Integer(2));// 某元素最后一次出现位置
        // (6) 三种遍历方式，对于LinkedList 迭代器遍历最优，增强for循环差不了多少
        //          对于ArrayList 普通for循环最优
        for (int i = 0; i < lis3.size(); i++)               // 普通for循环
            System.out.println("lis3.get(i) = " + lis3.get(i));
        for (Integer integer : lis3)                        // 增强for循环 内部也用到了迭代器
            System.out.println("integer = " + integer);
        for(Iterator<Integer> iter=lis3.iterator();iter.hasNext();) // 迭代器遍历
            System.out.println("iter.next() = " + iter.next());

  // (二)、ArrayList  利用数组实现，查询方便，增删慢  一般较多使用ArrayList
        // (1) 三种创建方式： 空列表 / 带参集合 / 初始容量
        List<Integer> al=new ArrayList<Integer>();
        List<Integer> x=new ArrayList<Integer>(al);   // 利用已有列表进行复制，指针不同，元素相同
        List<Integer> al1=new ArrayList<>(Arrays.asList(1,2,3));
        List<Integer> al2=new ArrayList<>(20);
        // ---ArrayList其他方法和LinkedList差不多 这里不再显示---
		// 二维ArrayList的创建
		List<List<Integer>> liss=new ArrayList<List<Integer>>();
		List<int[]> lis2=new ArrayList<>();
		lis2.toArray(new int[0][]);     // 二维链表转换为二维数组  
  // (三)、Collections 集合工具类
        ArrayList<Integer> arr1=new ArrayList<Integer>(Arrays.asList(1,3,2,4));
        ArrayList<Integer> arr2=new ArrayList<>(Arrays.asList(5,2,1,3));
        Collections.reverse(arr1);                      // 集合元素反转
        Collections.shuffle(arr1);                      // 集合元素随机排序
        Collections.fill(arr2,new Integer(0));   		// 替换集合所有元素
        Collections.copy(arr2,arr1);                    // 将arr1中的元素复制到arr2中并覆盖相应元素
        Collections.indexOfSubList(arr1,arr2);          // subList arr2在arr1中第一次出现位置
        Collections.lastIndexOfSubList(arr1,arr2);      // subList arr2在arr1中最后一次出现位置
        Collections.rotate(arr1,2);           			// 向右循环arr1列表元素
        Collections.rotate(arr1,-2);          			// 向左循环arr1列表元素
        Collections.swap(arr1,1,3);              		// 交换列表指定位置元素
        Collections.disjoint(arr1,arr2);                // 两个集合是否有交集
        Collections.replaceAll(arr1,new Integer(1),new Integer(2)); // 替换指定元素
        // 下面的方法可以 在最后自定义Comparator进行比较
        Collections.binarySearch(arr1,new Integer(2));  // 在集合中二分查找指定元素
        Collections.max(arr1);                  		// 返回集合中最大值
        Collections.min(arr1);                  		// 返回集合中最小值
        Collections.sort(arr1);         				// 集合元素排序
        例：
        Comparator<ListNode> cmp=new Comparator<ListNode>() {
         @Override
         public int compare(ListNode o1, ListNode o2) {
             return o1.val-o2.val;
         }
        };
        ListNode l1=new ListNode(1),l2=new ListNode(2),l3=new ListNode(3),l4=new ListNode(4),
                l5=new ListNode(5),l6=new ListNode(6),l7=new ListNode(7),l8=new ListNode(8);
        List<ListNode> lis=new ArrayList<ListNode>(Arrays.asList(l2,l3,l8,l5,l1,l7,l4,l6));
        Collections.sort(lis,cmp);
        for (ListNode li : lis) {
            System.out.printf("  "+li.val);
        }