------- android培训、java培训、期待与您交流！ ----------

1、数组的定义

   概念：同一种类型数据的集合。其实数组就是一个容器。

   数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。

   格式1：元素类型[] 数组名= new 元素类型[元素个数或数组长度];

   示例：int[] arr = new int[5];

   格式2：元素类型[] 数组名= new 元素类型[]{元素，元素，……};

       int[] arr= new int[]{3,5,1,7};

       int[] arr= {3,5,1,7};

2、数组的内存分配及特点

   数组内存结构

   内存结构

   Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放。

堆内存：数组和对象，通过new建立的实例都存放在堆内存中。每一个实体都有内存地址值。实体中的变量都有默认初始化值。实体不在被使用，会在不确定的时间内被垃圾回收器回收。

方法区，本地方法区，寄存器。

3、数组操作常见问题

   数组脚标越界异常(ArrayIndexOutOfBoundsException) 访问到了数组中的不存在的脚标时发生。

       int[] arr= new int[2];

       System.out.println(arr[3]);

   空指针异常(NullPointerException) arr引用没有指向实体，却在操作实体中的元素时。

       int[] arr= null;

       System.out.println(arr[0]);

4、数组常见操作

   获取最值(最大值，最小值)

/*
给定一个数组{5,1,6,4,2,8,9}
1，获取数组中的最大值，以及最小值。
思路：
遍历数组，并比较相邻的元素，将符合条件的赋值给一个变量。
*/
class ArrayTest
{
    public static void main(String[] args)
    {
        int[] arr = {2,4,3,5,7,8};
        int max = getMax_2(arr);
        System.out.println(max);
        int min = getMin(arr);
        System.out.println(min);
    }
    public static int getMax(int[] arr)
    {
        int max = arr[0];
        for (int x=0;x<arr.length;x++ )
        {
            if(arr[x]>max)
                max = arr[x];  
        }
        return max;
    }
    public static int getMax_2(int[] arr)
    {
        int max = 0;
        for (int x=1;x<arr.length;x++ )
        {
            if (arr[x]>arr[max])
                max = x;
        }
        return arr[max];
    }
    public static int getMin(int[] arr)
    {
        int min = 0;
        for (int x= 1;x<arr.length ;x++ )
        {
            if (arr[x]<arr[min])
            {
                min = x ;
            }
        }
        return arr[min];
    }
}

   排序（选择排序，冒泡排序）

/*
对给定数组进行排序。
{5,1,6,4,2,8,9}
*/
class ArrayTest2
{
    /*
    选择排序。
    内循环结束一次，最值出现在头角标位置上。
    */
    public static void selectSort(int[] arr)
    {
        for (int x=0;x<arr.length-1;x++)
        {
            for (int y=x+1;y<arr.length;y++ )
            {
                if (arr[x]>arr[y])//更改比较符号就能选择升序或降序
                {
                    /*
                    int temp =arr[x];
                    arr[x] = arr[y];
                    arr[y] = temp;
                    */
                    swap(arr,x,y);
                }
            }
        }
                                                                 
    }
    /*
    冒泡排序。 
    */
    public static void bubbleSort(int[] arr)
    {
        for (int x=0;x<arr.length-1;x++)
        {
            for (int y=0;y<arr.length-x-1;y++)//-x：让每次比较元素减少，-1：避免角标越界。
            {
                if (arr[y]>arr[y+1])
                {
                    /*
                    int temp = arr[y];
                    arr[y] = arr[y+1];
                    arr[y+1] = temp;
                    */
                    swap(arr,y,y+1);
                }
            }
        }
    }
    /*
    发现无论什么排序，都需要对满足条件的元素进行位置置换。
    所以可以把这部分相同的代码提取出来，单独封装成一个函数
    */
    public static void swap(int[] arr,int a,int b)
    {
        int temp =arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
    public static void main(String[] args)
    {
        int[] arr = {5,1,6,4,2,8,9};
        printArray(arr);
        //selectSort(arr);
        bubbleSort(arr);
        printArray(arr);
        //Array.sort(arr);//java中已经定义好的一种排序方式。开发中对数组排序要使用该句代码。
    }
    public static void printArray(int[] arr)
    {
        System.out.print("[");
        for (int x= 0;x<arr.length;x++ )
        {
            if(x!=arr.length-1)
                System.out.print(arr[x]+",");
            else
                System.out.println(arr[x]+"]");
        }
    }
}

   折半查找(二分查找)

/*
数组的查找操作。
练习：有一个有序的数组，想要将一个元素插入到该数组中，
还要保证该数组是有序的。如何获取该元素在数组中的位置。
*/
class ArrayTest4
{
    public static void main(String[] args)
    {
        int[] arr = {32,34,53,35,12,13};
        int x = getIndex(arr,34);
        System.out.println("所查找的数是第"+(x+1)+"个");//错误的把方法中返回的x当作此处的x。
        int[] arr1={1,4,6,8,13,23,45,67,123};
        System.out.println("插入的位置"+(getIndex_2(arr1,12)+1));
    }
    //插入函数
    public static int getIndex_2(int[] arr,int key)
    {
        int min=0,max=arr.length,mid;
        while (min<=max)
        {
            mid = (min+max)>>1;
            if (key>arr[mid])
                min=mid+1;
            else if (key<arr[mid])
                max=mid-1;
            else
                return mid;
        }
            return min;
    }
    /*
    折半的第二种方式。
    */
    public static int halfSearch_2(int[] arr,int key)
    {
        int min=0,max=arr.length,mid;
        while (min<=max)
        {
            mid = (min+max)>>1;
            if (key>arr[mid])
                min=mid+1;
            else if (key<arr[mid])
                max=mid-1;
            else
                return mid;
        }
            return -1;
    }
    /*
    折半查找.提高效率。但是必须要保证该数组是有序的数组。
    */
    public static int halfSearch(int[] arr,int key)
    {     
        int max = arr.length-1;
        int min = 0;
        int mid = (max+min)/2;
        while (arr[mid]!=key)
        {
            if (arr[mid]>key)
                max=mid-1;    
            else
                min=mid+1;
            if (min>max)
                return -1;
            mid=(max+min)/2;
        }
                return mid ;
        }
    //定义功能：获取key第一次出现在数组中的位置。如果返回的是-1，那么代表该key在数组中不存在。
    public static int getIndex(int[] arr,int key)
    {
        for (int x=0;x<arr.length;x++)
        {
            if (arr[x]==key)
            {
                return x;
            }
        }
        return -1;
    }
}

       练习：进制转换

class ArrayTest7
{
    public static void main(String[] args)
    {
        toBin(6);
        toBa(60);
        toHex(60);
    }
    /*
    十进制-->二进制
    */
    public static void toBin(int num)
    {
        trans(num,1,1);
    }
    /*
    十进制-->八进制
    */
    public static void toBa(int num)
    {
        trans(num,7,3);
    }
    /*
    十进制-->十六进制
    */
    public static void toHex(int num)
    {
        trans(num,15,4);
    }
    //定义一个转换方法。
    public static void trans(int num,int base,int offset)
    {
        //定义表
        char[] chs = {'0','1','2','3',
                      '4','5','6','7',
                      '8','9','A','B',
                      'C','D','E','F'};
        //定义容器。
        char[] arr = new char[32];
        int pos = arr.length;
        //当传入的num为0时。
        if (num==0)
        {
            arr[--pos] = chs[num];
        }
                                                  
        while (num!=0)
        {
            int temp = num & base;
            arr[--pos] = chs[temp];
            num = num >>> offset;
        }
        System.out.print("[");
        for (int x=pos;x<arr.length;x++ )
        {
            if(x!=arr.length-1)
                System.out.print(arr[x]+",");
            else
                System.out.println(arr[x]+"]");
        }
    }
}

   5、数组中的数组

   5.1二维数组[][]

       格式1：int[][] arr = new int[3][2];

       定义了名称为arr的二维数组；二维数组中有3个一维数组；每一个一维数组中有2个元素；一维数组的名称分别为arr[0], arr[1], arr[2]；给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;

       格式2：int[][] arr = new int[3][];

       二维数组中有3个一维数组；每个一维数组都是默认初始化值null；可以对这个三个一维数组分别进行初始化：arr[0] = new int[3];arr[1] = newint[1];arr[2] = new int[2];

       格式3：int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};

       定义一个名称为arr的二维数组；二维数组中的有三个一维数组；每一个一维数组中具体元素也都已初始化；第一个一维数组arr[0] = {3,8,2};第二个一维数组arr[1] = {2,7};第三个一维数组arr[2] = {9,0,1,6};第三个一维数组的长度表示方式：arr[2].length;

注意特殊写法情况：int[] x,y[]; x是一维数组，y是二维数组。

   5.2数组的内存分配栈内存和堆内存

       如定义一个数组 int[]scores将在栈内存中为scores 分配内存空间，其值是一个不确定的值。

       当执行语句scores=new int[5]时，将在堆内存分配连续5个空间，每个空间4个字节，用于存放整型数据，其初始值为0，然后将该段空间首地址，也就是第一个元素的地址，比如0x3543，赋给scores变量。该地址相当于一个指针，指向堆内存中分配的空间。此时堆内存中分配的5个空间可以分别使用scores[0],一直到scores[4]来表示。当执行四个赋值语句时，分别用指定值填充到对应元素位置。如果此时将null值赋给scores时，scores变量将不再指向任何位置，此时堆内存中分配的空间就变成了垃圾，由垃圾回收器在某一时间进行回收。

       在方法中定义的变量，包括基本数据类型变量和引用数据类型变量，都将在栈内存中分配空间，当超过变量作用范围后，自动回收。