//数组

    public static void main(String[] args)  {

        //1. 数组排序和查找

        {

            int[] intA = {5, 4, 2, 3, 1};

            String[] StrA = {"ab", "cd", "ef"};

            Arrays.sort(intA);

            for(int a : intA){

                System.out.println("1  :"+a);

            }

            //采用的是二分法查找，所以必须要先排序

            int i = Arrays.binarySearch(intA, 3);

            System.out.println("1  :索引是从0开始，索引为"+i);

        }

        //2.  获取数组长度

        {

            int[] intA = {5, 4, 2, 3, 1};

            int[][] intB = new int[5][4];

            System.out.println("2  :"+intA.length);

            System.out.println("2  :"+intB.length+", "+intB[0].length);

        }

        //3. 数组反转（也可以仍为是集合的反转）

        {

            ArrayList<String> al = new ArrayList<String>();

            al.add("a");

            al.add("b");

            al.add("c");

            al.add("d");

            //采用集合的静态工具Collections进行反转

            Collections.reverse(al);

            Iterator it = al.iterator();

            while(it.hasNext()){

                System.out.println("3  :"+it.next());

            }

        }

        //4. 找到数组的最大值和最小值

        {

            Integer[] intA = {5, 4, 2, 3, 1};

            //数组转换成集合里的数组List

            //注意：这里的ArrayList并非java.util.ArrayList，而是Arrays类的静态内部类！

            Integer intB = Collections.max(Arrays.asList(intA));

            Integer intC = Collections.min(Arrays.asList(intA));

            System.out.println("4  :"+intB+", "+intC);

        }

        //5. 数组合并

        {

            Integer[] intA = {5, 4, 2, 3, 1};

            Integer[] intB = {8, 9, 7, 6};

            //现将数组intA转换为内部集合，然后在放入ArrayList中

            ArrayList al = new ArrayList(Arrays.asList(intA));

            al.addAll(Arrays.asList(intB));

            //第一种输出方式

            Iterator it = al.iterator();

            while(it.hasNext()){

                System.out.println("5  :"+it.next());

            }

            //第二种输出方式

            System.out.println("5  :"+al);

        }

        //6. 填充数组元素

        {

            int[] intA = new int[3];

            Arrays.fill(intA, 1);

            for(int a : intA)

                System.out.println("6  :"+a);

            System.out.println("6  --------");

            Arrays.fill(intA, 1, 3, 2);

            for(int a : intA)

                System.out.println("6  :"+a);

            System.out.println("6  --------");

            Integer[] intB = new Integer[3];

            Arrays.fill(intB, 100);

            for(Integer a : intB)

                System.out.println("6  :"+a);

        }

        //7. 数组扩容

        {

            int[] intA = {5, 4, 2, 3, 1};

            int[] intB = new int[7];

            intB[5] = 5;

            intB[6] = 6;

            System.arraycopy(intA, 0, intB, 0, intA.length);

            for(int a : intB)

                System.out.println("7  :"+a);

        }

        //8. 删除元素

        {

            ArrayList<Integer> al = new ArrayList<Integer>();

            al.add(10);

            al.add(20);

            al.add(30);

            al.remove(1);

            System.out.println("8  :"+al);

        }

        //9. 查看数组中是否包含某个元素

        {

            ArrayList<Integer> al = new ArrayList<Integer>();

            al.add(10);

            al.add(20);

            al.add(30);

            System.out.println("9  :"+al.contains(20));

            System.out.println("9  :"+al.contains(40));

        }

        //10. 查看数组是否相等

        {

            int[] intA = {1,2,3,4,5};

            int[] intB = {1,2,3,4};

            int[] intC = {1,2,3,4,5};

            Integer[] intD = {1,2,3,4,5};

            System.out.println("10 :"+Arrays.equals(intA, intB));

            System.out.println("10 :"+Arrays.equals(intA, intC));

            //System.out.println("10 :"+Arrays.equals(intA, intD));//报错

        }

    }

1  :1

1  :2

1  :3

1  :4

1  :5

1  :索引是从0开始，索引为2

2  :5

2  :5, 4

3  :d

3  :c

3  :b

3  :a

4  :5, 1

5  :5

5  :4

5  :2

5  :3

5  :1

5  :8

5  :9

5  :7

5  :6

5  :[5, 4, 2, 3, 1, 8, 9, 7, 6]

6  :1

6  :1

6  :1

6  --------

6  :1

6  :2

6  :2

6  --------

6  :100

6  :100

6  :100

7  :5

7  :4

7  :2

7  :3

7  :1

7  :5

7  :6

8  :[10, 30]

9  :true

9  :false

10 :false

10 :true