基础-数组-1-基础知识带你飞~

话说：

今晚的雨水下得真是痛快！春天的雨，就是那么柔柔的。虽然雨点蛮猛的，但是雨风很有诗意，并不冷，反倒是有点暖洋洋的感觉。跑到屋檐下，听雨几分钟，快哉！

这里温故下数组基础知识。

目录

---

1.一维数组、二维数组的创建及遍历；
2.java.util.Arrays的API操作
3.总结

---

难度系数：★☆☆ ☆ ☆
建议用时：30min

1.一维数组、二维数组的创建及遍历；
2.java.util.Arrays的API操作

package com.hmc.test;

import java.util.Arrays;

import org.junit.Test;

/**
*
*2018年3月4日
*User:Meice
*下午8:47:51
*/
public class MyArray {
    /**
     * 这个类，我们将一起重温数组,哈哈。
     */

    /**
     * 1.一维数组的声明及使用
     */

    @Test
    public void  bornOfArray() {

        //1.先声明，再分配空间 
        int arr[];
        arr = new int[5];

        //声明的时候即分配空间
        int arr2[] = new int[5];
        int []arr3 = new int[5];

        //2.初始化一维数组
        int arr4[] = new int[] {1,2,3,6,8};//这种写法感觉是不是怪怪的？但确实是对的。不知名长度，就要给定值，本质跟给定长度一样。所以，数组长度是固定的，类型一致，这是最核心的特征。
        int arr5[] = {6,7,99,87,89};

        //3.遍历一维数组
        int day[] = new int[] {31,28,31,30,31,30,31,31,30,31,30,31};
        for(int i=0;i<day.length;i++) {
            System.out.println((i+1)+"月有"+day[i]+"天");
        }
        /**
         * 运行结果：
         * 1月有31天
            2月有28天
            3月有31天
            4月有30天
            5月有31天
            6月有30天
            7月有31天
            8月有31天
            9月有30天
            10月有31天
            11月有30天
            12月有31天
         */
    }


    /**
     * 2.二维数组的创建及使用
     */
    @Test
    public void bornOfTwoDemensionalityArray() {
        //1.先声明，后分配空间
        int myArray[][];
        myArray  = new int[2][4];//2行三列 都是3列 也就是列数一样，固定住了

        int myArray2 [][];
        myArray2 = new int[2][];//分别为每一维度分配内存
        myArray2[0] = new int[3];
        myArray2[1] = new int[5];//这样就是2行  第1行3列 第2行5列；每一行列数就灵活了。

        //2.上面自然啰嗦，声明即分配空间
        int myArray3[][] =  new int[3][5];
        //如果想每列长度不一样呢？
        int myArray4[][] = new int[3][];
        myArray4[0] = new int[3];
        myArray4[1] = new int[4];
        myArray4[2] = new int[5];

        //3.二维数组初始化
        int arrayname[][] = {{1,3},{2,8}};
        System.out.println("arrayname[1][1]的值是："+arrayname[1][1]);//arrayname[1][1]的值是：8



        //4.二维数组遍历    这是重点！因为一维数组太简单，高纬一般用不着，二维运用很多！
        int a[][] = new int[3][4];
        for(int i=0;i<a.length;i++) {//a.length就是二维数组的长度，也就是行  
            for(int j=0;j<a[i].length;j++) {
                System.out.print(a[i][j]+"  ");
            }
            System.out.println();
        }
        /**
         * 运行结果:
         * 0  0  0  0  
            0  0  0  0  
            0  0  0  0  
         */
    }



    /**
     * 3.数组的基本操作：遍历、填充替换数组元素、排序、复制、查询
     */
    @Test
    public void testManuficationOfArray() {

        //3-1遍历

        int b[][] = new int[][] {{1},{2,3},{4,5,6}};
        //1.遍历 法1-双重for循环
        for(int i=0;i<b.length;i++) {
            for(int j=0;j<b[i].length;j++) {
                System.out.print(b[i][j]+"  ");//外层控制行 内存控制列 很类似久久成本高发口诀表
            }
            System.out.println();
        }

        //2.遍历 法2
        for(int x[] :b) {
            for(int m:x) {
                System.out.print(m);
            }
            System.out.println();
        }
        /**
         * 运行结果：
         * 1
            23
            456
         */

        //以下是书本上的遍历方式    这种方式确保遍历结束
        int i=0;
        for(int x[] :b) {
            i++;
            int j=0;
            for(int n:x) {
                j++;
                if(i==b.length && n==x.length) {//如果是最后一个，就不要输出,啦，但是还是输出了
                    System.out.print(n);
                }else {
                    System.out.print(n+"、");
                }
                //System.out.print(n+"、"); //1、2、3、4、5、6、
            }
        }


        //3-2 填充替换数组元素



        /**
         * java.util.Arrays 类 方法都是静态的，直接调用
         * 1.fill(int[] a ,value);把指定元素填充到数组
         * 2.fill(int[] a, int fromIndex, int toIndex, int val) 
          将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。
         */
         int array[]  = new int[5];
         Arrays.fill(array, 8);
         for(int k=0;k<array.length;k++) {
             System.out.println("第"+k+"个元素是:"+array[k]);
         }
         /**
          * 运行结果：
          * 第1个元素是:8
            第2个元素是:8
            第3个元素是:8
            第4个元素是:8
          */


         int array2[] = {45,12,2,12,3};
         //把第二个元素替换为8 当然可以直接赋值  注意 fromIndex 包含   toIndex不包含 前闭后开一般都是这样的规则[)
         Arrays.fill(array2, 1, 2, 8);
         for(int m=0;m<array2.length;m++) {
             System.out.println("第"+m+"个元素是:"+array2[m]);
         }
         /**
          * 运行结果：
          * 第0个元素是:45
            第1个元素是:8
            第2个元素是:2
            第3个元素是:12
            第4个元素是:3
          */


         //排序 

         int arr2[] = {34,56,12,20,22,98};
         Arrays.sort(arr2);
         for(int a:arr2) {
             System.out.print(a+"、");//12、20、22、34、56、98、默认是升序
         }




         //3-3复制数组



        /**
         * 1.copyOf(int[] original, int newLength) 
          复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。

          2.copyOfRange(int[] original, int from, int to) 
          将指定数组的指定范围复制到一个新数组。
          都很简单，看API，无脑操作就行。
         */

         System.out.println();

         int arr3[] = {33,44,55,66};
         int newArr2[] =    Arrays.copyOf(arr3,6);//这个也是常规思维，多余0填充，不够就到哪就到哪
         for(int m:newArr2) {
             System.out.print(m+ "  ");
         }

         System.out.println();
         int newArr3[] = Arrays.copyOfRange(arr3, 1, 3);//这里还是老套路，不包括toIndex
         for(int n:newArr3) {
             System.out.print(n+"  ");
         }


         //3-4数组查询

         /**
          * 1.binarySearch(int[] a, int key) 
          使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。
          2.binarySearch(int[] a, int fromIndex, int toIndex, int key) 
          使用二分搜索法来搜索指定的 int 型数组的范围，以获得指定的值
          */
         int mm[] = {1,8,9,4,6,7,6};
         int index = Arrays.binarySearch(mm, 6);
         System.out.println("6的索引是:"+index);
        Arrays.sort(mm);//必须先排序，否则如果有同样的值，那么不知道找哪个
         System.out.println("6的索引是:"+index);



         String str[] = {"ab","cd","ef","yz"};
         Arrays.sort(str);
         int index2 = Arrays.binarySearch(str, 0, 2, "cd");
         System.out.println("cd在的索引是:"+index2);


    }


}

3.总结

---

1）没有集合之前，数组都是第一选择哈；

2）数组长度固定、类型一致，是最核心的特征；要使用数组，初始化就要分配固定空间；最容易出现的异常就是：ArrayIndexOurofException ；

3）二维数组可以想象成折叠起来的网格子，遍历思路当然是一维数组，然后在遍历单个；

4）重点是数组里面包含的简单排序算法，下一篇重点讲解。

---

好，下期再会~下一篇重点温故简单又经典的排序算法，拭目以待吧！