数组集合

数组
===============================
        * 存放一组数据的容器
        * 数组每个位置都有一个下标（索引值）
        * 数组长度在创建时指定，一旦创建出来，长度不可改变
       
数组的创建和访问
===============================
        创建：
                        * int[] arr = new int[3];
                                        _______________                                 ___________________
                                        |_0_|__0__|_0_|<--------|数组内存首地址|arr
                       
                        * int[] arr = {5,12,8,2}
                       
                                        ____________________
                                        |_5_|__12__|_8_|_2_|

                        * int[] arr = new int[]{5,12,8,2}
                       
                                        ____________________
                                        |_5_|__12__|_8_|_2_|

        访问：
                        * 存：
                                        arr[0] = 3;
                                        arr[2] = 45;
                        * 取： 
                                        arr[0]
                                        arr[2]
                        * 数组的长度属性：
                                        arr.length
                                       

数组的相关操作方法
========================================
        1. 复制数组

                        System.arraycopy(
                                原数组,
                                原数组起始位置,
                                目标数组,
                                目标数组起始位置,
                                数据个数
                        )
       
        2. 数组工具类
       
                        java.util.Arrays
                                |- toString(arr)                -       将数组中的元素，连接为字符串
                                |- copyOf(arr, len)     - 将数组复制为指定长度的新数组
                                |-
                                |-
                                |-
                                |-
                                |-
                               

二维数组
========================================
        * 数组的数组
       
        创建二维数组：
                        * int[][] arr = new int[3][3];
                        * int[][] arr = new int[3][];
                        * int[][] arr = {{2,3}, {4,5,6}};

数组练习
========================================
        1. 复制数组
                       
                        public static int[] copy(int[] arr) {
                               
                        }
                       
        2. 将原数组，复制为指定长度的新数组
                        main:
                                        int[] arr = {2,3,4};
                                        copy(arr, 5)
       
       
       
                        public static int[] copy(int[] arr, int len) {
                                       
                        }
       
        3. 求数组中的最大值
                       
                        public static int max(int[] arr) {
                                // 10000000 00000000 00000000 00000000
                                int m = 0x80000000;
                        }
                       
        4. 交换位置
                 将数组中两个指定位置的值进行交换
                
                        public static void swap(int[] arr, int i, int j) {
                        }
                       
        5. 数组倒置
                 数组中的数据反向排列
                
        6. 向数组中指定位置插入一个值
                       
                        public static int[] insert(
                                                                                        int[] arr, int i, int value) {

                        }
                       
       
        7. 指定整数范围，将范围内的数字生成数组
                        main:
                                        int[] arr = createArray(6, 10);
                                       
                       
       
                        // [min, max)
                        public static int[] createArray(int min, int max) {
                        }
       
        8. 将指定数组中的数据打乱顺序
       
                        int r = (int) (Math.random()*arr.length)
       
                        public static void shuffle(int[] arr) {
                        }
       
        9. 从数组中移除一个数据
       
                        // 将 arr 中 i 位置的值移除掉
                        // 并返回新数组
                        public static int[] remove(int[] arr, int i) {
                        }
       
        10. 插入排序
        11. 选择排序
        12. 冒泡排序(重点)
       
        13. 二分法
       
                        快速查找算法
       

集合工具集
=======================================
        java.util.ArrayList
        java.util.LinkedList
       
        java.util.HashMap
        java.util.TreeMap
       
        java.util.HashSet
        java.util.TreeSet
       
        java.util.Iterator
       
java.util.ArrayList
=======================================
        * 内部存储结构：数组
       
        构造方法
        -------------------------------------
                ArrayList list1 = new ArrayList();      // 初始容量10
                ArrayList list2 = new ArrayList(5);     // 指定初始容量
               
        方法
        -------------------------------------
                add(Object obj)                      - 添加
                get(int index)                       - 获得指定位置的对象
                size()                               - 获得存入的数据量
               
                remove(int index)                    - 移除指定位置数据，并返回被移除的数据
                remove(Object obj)                   - 移除第一个找到的相等数据，返回布尔值表示是否移除
                clear()                              - 清空
                contains(Object o)                   - 判断是否包含与指定数据相等的数据
                indexOf(Object o)                    - 获得指定数据所在的位置
                set(int index, Object o)             - 替换，返回被替换的数据
                toArray()                            - 转为 Object[] 数组
                iterator()                           - 获得新的迭代器对象

       
java.util.LinkedList
=======================================
        * 与 ArrayList 用法相同
        * 内部用双向链表结构存储数据
       
        * 存取两端数据效率高

        方法
        -------------------------------------
                * ArrayList 中相同的方法
               
                addFirst(Object o)
                addLast(Object o)
               
                getFirst()
                getLast()
               
                removeFirst()
                removeLast()
               
               
                FIFO - First In First Out 队列
                ------------------------------------
                offer(Object o)                 - addLast()
                peek()                          - getFirst()
                poll()                          - removeFirst()
               
                LIFO - Last In First Out 栈
                ------------------------------------
                push()                          - addFirst()
                pop()                           - removeFirst()

        LinkedList 遍历
        --------------------------------------
                Iterator it = list.iterator();
                while(it.hasNext()) {
                        Object o = it.next();
                        ...
                }
               
java.util.HashMap
===========================================
        * 哈希表结构，存储键-值对数据
        * 快速查找数据
        * 乱序
       
        * 键必须重写 hashCode() 和 equals() 方法
        * hashCode() 和 equals() 必须使用相同的属性来运算或判断
       
        * hashCode() 方法的实现应保证：
                        *) equals() 相等的对象，必须具有相同的哈希值
                        *) 具有相同哈希值的对象，equals() 不保证相等（应尽量相等）
       
       
       
        存数据步骤：
        -----------------------------------------
                1) 获得键的哈希值
                2) 通过哈希值运算得到一个索引位置
                3) 创建一个 Entry 实例，封装键和值两个数据
                4) 将 Entry 实例放入 2 计算出的位置
                                4.1) 如果此位置已经存在数据
                                                4.1.1) equals 比较相等，覆盖
                                                4.2.2) equals 比较不相等，链表挂在一起
       
        获取数据步骤：
        -----------------------------------------
                1) 获得键的哈希值
                2) 通过哈希值运算得到一个索引位置
                3) 如果只有一个对象，equals 比较
                                3.1) 相等，取出
                                3.2) 不等，不取
                4) 如果存在多个对象，依次执行 equals 比较，直到找到相等的为止
       
                       
        方法
        -----------------------------------------
                push(Object key,  Object val)
                get(Object key)

                remove(Object key)
                clear()
               
                containsKey(Object key)
                containsValue(Object val)

                size()
               
                遍历
                ---------------------------------------
                                keySet()                - 返回一个包含所有键的 Set
                                entrySet()      - 返回一个包含所有 Entry 的 Set
                                       

java.util.TreeMap
=====================================
        * 存放键-值对数据
        * 二叉树存储结构
        * 快速查找算法
        * 从小到大
       
        * 键可以实现 Comparable 接口，实现其 compareTo() 方法
        * 也可在 TreeMap 中外接比较器 Comparator，对数据比大小
       
        构造方法
        -----------------------------------
                TreeMap map1 = new TreeMap();
                TreeMap map2 = new TreeMap(外接的比较器);

java.util.HashSet
=====================================
        * 内部使用 HashMap 实现
        * 不重复, 乱序
       
        方法
        --------------------------------------
                add(Object o)
                remove(Object o)
                clear()
                contains(Object o)
                size()
               
                iterator()
               
       
java.util.TreeSet
=====================================
        * 内部使用 TreeMap 实现
        * 方法与 HashSet 相同
        * 不重复，从小到大
       
        构造方法
        --------------------------------------
                TreeSet set1 = new TreeSet();
                TreeSet set2 = new TreeSet(外接的比较器);

java.util.Collection 接口
=====================================
        add(Object o)
        remove(Object o)
        clear()
        size()
        contains(Object o)
        iterator()
       
        addAll(Collection c)

java.util.List 接口
=====================================
        get(int index)
        remove(int index)
        set(int index, Object o)
        indexOf(Object o)

java.util.Set 接口
=====================================
        * HashSet、 TreeSet 的父接口
       
java.util.Map 接口
=====================================
        * HashMap 和 TreeMap 的父接口

java.util.Queue 接口，FIFO
=====================================
        offer()         - 尾部加入
        peek()          - 访问头部
        poll()          - 移除头部
       
        * 子类： LinkedList
       
java.util.Deque 接口，Double End Queue，LIFO
=====================================
        push()          - 压栈
        pop()                   - 弹栈
       
        * 子类： LinkedList

java.util.Collections
=====================================
        addAll(Collection c, ......)
        sort(List list)
        sort(List list, Comparator c)
        binarySearch(List list, Object o)
        shuffle(List list)
        reverse(List list)
        fill(List list, Object o)
        max(Collection c)
        min(Collection c)
       
集合、数组相互转换
=====================================
        * 数组转集合：
       
                        List list = Arrays.asList(array)
                       
        * 集合转数组：
                       
                        String[] arr =
                                list.toArray(new String[list.size()]);
       
                        String[] arr =
                                list.toArray(new String[0]);