黑马程序员___Java基础[02-Java基础语法](三)

十、数组

1、数组的定义

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

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

C：数组的格式：

格式1：当不明确数组中的元素时

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

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

格式2：当明确数组中的元素时

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

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

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

注意：

int arr[] = new int[5];这种格式java也识别，但不推荐，这种格式是为了照顾C/C++语言的程序员。

arr中存储的是数组实体的地址值，arr[0]中存储的是元素值。

D：什么时候定义数组：当要操作多个同种数据类型的时候，先把这些数据用数组进行存储。

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

1) Java程序在运行时，需要在内存中的分配空间，为了提高运算效率，有对空间进行了不同区域的划分。

    一共划分了五片区域，每一片区域都有特定的处理数据方式和内存管理方式。

A：栈内存：

用于存储局部变量（在函数中定义的变量：方法内、方法参数上、for循环中）。

当数据使用完，所占空间会立即自动释放。

B：堆内存：

用于存储通过new建立的实例（数组和对象）。

堆内存数据的特点：

a、每一个实体都有内存地址：十六进制表示的

b、堆内存中的变量都有默认初始化值：

byte、short、int——>0

long——>0L

float——>0.0F

double——>0.0（或0.0D）

———————————————其实打印出来都是0

char——>'\u0000'

boolean——>false

引用类型（数组、String、class、interface）——>null

c、当实体不再被使用时，会在不确定的时间内通过java垃圾回收机制被垃圾回收器回收，使其自动释放。

C：方法区：后面讲（暂不考虑）。

D：本地方法区：调用是Windows系统底层资源（暂不考虑）。

E：寄存器：和CPU相关（暂不考虑）。

2) 数组内存图及初始化过程

例如：

数组初始化过程：

A：主函数进栈,然后在main()中有一个数组的引用arr

B：在堆内存中开辟空间，分配内存地址值

C：在堆内存中建立数组对象，并进行默认初始化

D：如果有显示初始化值的,对它进行显示初始化

E：将内存地址赋给栈内存中的arr变量

3、数组操作常见问题

A：数组脚标越界异常(ArrayIndexOutOfBoundsException)

int[] arr = new int[2];

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

运行时出现：访问到了数组中的不存在的脚标时发生。

B：空指针异常(NullPointerException)

int[] arr = null;

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

运行时出现：arr引用没有指向实体，却还继续访问实体中的元素时发生。

4、数组中常见的操作

A：遍历

数组的属性：length 数组的长度。

格式：数组名.length

实现方式：通过for循环实现

    //定义功能，用于打印数组中的元素。元素间用逗号隔开。
    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]+"]");

        }        
    }

B：获取最值（最大值，最小值）

/*
    给定一个数组{5,1,6,4,2,8,9}。
    获取数组中的最大值，以及最小值。
*/

class ArrayTest 
{
    /*
    获取最大值。
    */
    public static int getMax(int[] arr)
    {
        int max = arr[0];

        for(int x=1; 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];
    }

    public static void main(String[] args)
    {
        int[] arr ={5,1,6,4,2,8,9};
        int max = getMax_2(arr);
        int min = getMin(arr);
        System.out.println("max="+max);
        System.out.println("min="+min);
    }

}

C：排序：将数组中的元素按照升序或降序排列

选择排序：

代码示例：升序排序

    /*
    选择排序。
    内循环结束一次，最值出现头角标位置上。
    */
    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;
                }
            }
        }
    }

特点：第一次内循环结束后，极值出现在了0角标位置。

插入排序：在已排好序的子数列中反复插入一个新元素，直至整个数列全部排好。

代码示例：

冒泡排序：相邻的两个元素进行比较，如果符合条件就换位。

代码示例：降序排序

/*
    冒泡排序
    */
    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;
                }
            }
        }
    }

特点：第一次比较完以后，极值出现在了最大角标处。

D：查找：在数组中寻找特定元素的过程

无序数组：线性查找

    //定义功能，获取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;
    }

有序数组：折半查找

 

注意：对数组进行折半查找必须要保证该数组是有序的数组。

E：传递参数

调用的时候，传递是基本类型的值的时候，形参改变对实参没有任何影响。

调用的时候，传递是引用类型的地址的时候，形参改变对实参有直接影响。

5、二维数组

1）定义格式

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

A：定义了名称为arr的二维数组

B：二维数组中有3个一维数组

C：每一个一维数组中有2个元素

D：一维数组的名称分别为arr[0], arr[1], arr[2]

arr[0][0],arr[0][1]

arr[1][0],arr[1][1]

arr[2][0],arr[2][1]

arr:二维数组名

arr[1]:二维数组中的第二个一维数组名

arr[1][1]:二维数组中的第二个数组的第二个元素

E：给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;

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

A：二维数组中有3个一维数组

B：每个一维数组都是默认初始化值null

C：可以对这个三个一维数组分别进行初始化

arr[0] = new int[3];

arr[1] = new int[1];

arr[2] = new int[2];

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

A：定义一个名称为arr的二维数组

B：二维数组中的有三个一维数组

C：每一个一维数组中具体元素也都已初始化

第一个一维数组 arr[0] = {3,8,2};

第二个一维数组 arr[1] = {2,7};

第三个一维数组 arr[2] = {9,0,1,6};

D：第三个一维数组的长度表示方式：arr[2].length;

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

例题：

int[]y是一个一维数组

int[]x[]是一个二维数组int[][]x

int[] y, x[];

(a) x=y;   //no

(b)x[0]=y;   //yes

(c)x[0] = y[0];  //no

(d)x = y[0];   //no

(e)x[0][0] = y[0];  //yes

2）二维数组的遍历

int[][] arr2 = new int[2][3];
public static void printArray2(int[][] arr2){
    for(int i=0; i<arr2.length; i++){
        for(int j=0; j<arr2[i].length; j++){
            System.out.print(arr2[i][j]+" ");
        }
        System.out.println();
    }
}