黑马程序员__JAVA基础__数组

 -------android培训、java培训、java学习型技术博客、期待与您交流！ ------------

 

1.定义

数组是一种单独的数据类型，其属于三种引用数据类型当中的一种。

概念：

    同一种类型数据的集合，其实数组就是一个容器（就是用于存储数据的一种方式）。

好处：

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

格式：

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

      如：int[] arr = new int[5];

    2.元素类型[] 数组名 = new 元素类型[]{元素,元素,元素...};

      如：int[] arr = new int[]{4,3,9,7};

          int[] arr = {4,3,9,7};

 

2.数组的内存结构

如图：

内存结构：

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

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

堆内存：

    1.数组和对象，通过new建立的实例都存放在堆内存中。

    2.每一个实体都有内存地址值。

    3.实体中的变量都有默认初始化值。

    4.实体不在被使用，会在不确定的时间内被垃圾回收器回收。

方法区：存储被虚拟机加载的类信息(类名、访问修饰符、字段描述、方法描述等)、常量、静态变量、即时编译器编译后的代码等数据。垃圾收集器主要是针对该区域的常量的回收和对类型的卸载。

还包括本地方法区，和寄存器。

 

3.数组常见操作

获取最值(最大值，最小值)，代码如下：

/**
获取数组中的最大值。
思路：
1，获取最值需要进行比较。每一次比较都会有一个较大的值。因为该值不确定。
通过一个变量进行临储。
2，让数组中的每一个元素都和这个变量中的值进行比较。
如果大于了变量中的值，就用该该变量记录较大值。
3，当所有的元素都比较完成，那么该变量中存储的就是数组中的最大值了。

步骤：
1，定义变量。初始化为数组中任意一个元素即可。
2，通过循环语句对数组进行遍历。
3，在变量过程中定义判断条件，如果遍历到的元素比变量中的元素大，就赋值给该变量；

需要定义一个功能来完成。以便提高复用性。
1，明确结果，数组中的最大元素 int。、
2，未知内容：一个数组。int[]
*/
/*
获取最大值。
*/
public static int getMax(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 selectSort(int[] arr)
{
    for (int x=0; x<arr.length-1 ; x++)//x<arr.length-1是因为最后一位是不用对比
    {
        for(int y=x+1; y<arr.length; y++)
        {
            if(arr[x] > arr[y])//如果改成arr[x] < arr[y]则是降序排序
            {
                int temp = arr[x];
                arr[x] = arr[y];
                arr[y]= temp;
            }
        }
    }
}
　　
/*
冒泡排序
把相邻的两个数之前比较
*/
public static void selectSort(int[] arr)
{
    for (int x=0; x<arr.length-1 ; x++)
    {
        for(int y=0; y<arr.length-x-1; y++)
        {
            if(arr[y] > arr[y++])//如果改成arr[x] < arr[y]则是降序排序
            {
                int temp = arr[y];
                arr[y] = arr[y++];
                arr[y++]= temp;
            }
        }
    }
}

注：无论什么排序，都需要对满足条件的元素进行位置置换，所以可以把这部分相同的代码单独封装成一个函数。代码如下：

　　public static void swap(int[] arr,int a,int b)
　　{
　　    int temp = arr[a];
　　    arr[a] = arr[b];
　　    arr[b] = temp;
　　}

数组的查找

1.遍历，代码如下：

public static int getIndex(int[] arr,int key)
{
    for(int x=0; x<arr.length; x++)//循环次数为数组的长度
    {
        if(arr[x]==key)
        return x;
    }
    return -1;//如果没找到，返回-1，因为数组中不存在-1这个角标
}

2.拆半查找(必须要保证该数组是有序的数组)

 

public static int halfSearch(int[] arr,int key)
{
    int min = 0,max = arr.length-1,mid;
    while(min<=max)//如果小角标大于大脚标，就跳出循环
    {
        mid = (max+min)>>1;//右移，与除以2同理
         if(key>arr[mid])
            min = mid + 1;
        else if(key<arr[mid])
            max = mid - 1;
        else
            return mid;
    }
    return -1;
}

4.二维数组[][]

格式

    1：int[][] arr = new int[2][1];

       解释：定义了一个名称为arr的二维数组，二维数组中有2个一维数组，每个一维数组中有1个元素，一维数组的名称分别为arr[0]，arr[1]。

       arr[1][1] = 30;//给第二个一维数组1脚标赋值

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

       这个二维数组里面的每一个一维数组的默认初始化值为null

       arr[0] = new int[2];//给这个数组初始化

    3：int[][] arr = {{1,8,6},{7,5,3},{4,2,1,3},{8,3}}

       这个二维数组里面的每一个一维数组都已经初始化，要获取一个一维数组的长度，可以定样写：

       int i = arr[2].length;

    特殊写法：int[] x,y[];其中x是一维数组，y是二维数组。

获取二维数组所有元素的和，代码如下：

int[][] arr = {{7,8,4,1},{9,3,5,4},{8,6,4,2}};
int sum = 0;
for(int x=0; x<arr.length;x++)//外循环中x控制第x个一维数组
{
    for(int y=0; y<arr[x].length; y++)//内循环中y控制每个一维数组中元素的角标
    {
        sum = sum + arr[x][y];
    }
}
System.out.println("sum="+sum);

 

5.数组操作常见问题

1.数组脚标越界异常(ArrayIndexOutOfBoundsException)

    int[] arr = new int[2];

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

    访问到了数组中的不存在的脚标时发生

2.空指针异常(NullPointerException)

    int[] arr = null;

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

    arr引用没有指向任何实体，却在操作实体中元素时发生

 

6.数组练习

1.对给定的数组进行反转，代码如下：

 

public static void reverseArray(int[] arr)
{
    for(int start=0,end=arr.length-1; start<end ; start++,end--)
    {
        int temp = arr[start];
        arr[start] = arr[end];
        arr[end] = temp;
    }
}

2.运用数组进行进制转换，代码如下：

/*

参数说明：

int num为要被转换的数

int base为要被转换与上的基数，2进制与1，8进制与7，16进制与15

int offset为偏移位数，2进制右移1位，8进制右移3位，16进制右移4位

*/

public static void trans(int num,int base,int offset)
{
    if(num==0)
    {
        System.out.println(0);
        return ;
    }
    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;
    while(num!=0)
    {
        int temp = num & base;
        arr[--pos] = chs[temp];
        num = num >>> offset;
    }
    for(int x=pos; x<arr.length; x++)
    {
        System.out.print(arr[x]);
    }
    return ;
}
调用方法：
十进制-->二进制：trans(num,1,1);
十进制-->八进制：trans(num,7,3);
十进制-->十六进制：trans(num,15,4);

 

个人总结：

1.编译只检查语法是否有错误

2.int[] arr = new int[3];

  arr = null;//这个表示arr引用没有指向任何实体。

3.但凡涉及数组操作的情况下，通常会用到for循环。

4.Arrays.sort(arr);这是java中已经定义好的一种排序方式，开发中，对数组排序，要使用该句代码，直接调用。

5.int x = Arrays.binarySearch(arr,5);这是java定义好的一个进行折半查找的功能。开发时使用这句代码。

本节要了解数组在内存是怎样的一个存储方式，重点掌握数组的各种基本操作，明白数组的定义方式，对二维数组的几种特殊写法要求掌握。在操作数组的时候如果发现异常要能够自行判断是什么错误。