黑马程序员——Java基础——数组

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、数组

1.数组的概念

（1）. 同一种类型数据的集合。简单的来说就是一容器，用来装东西的。

（2）. 使用数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素

2.数组的格式

(1）、一维数组

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

                  如： int []  arr = new int [3];  也可以写成： int arr[] = new int[3];

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

                   如： int []  arr = new int []{1,2,3,4,5};

        还有一种简写的静态初始化格式：如： int [] arr={1,2,3,4,5};

        其中：new是用来在堆内存中产生一个容器实体。

注：

1、System.out.println(arr);得到的结果是一个哈希值，也叫地址值。

        2、数组在堆内存开辟空间后，就有默认的初始化值。如：int默认0；boolean默认false。

内存小知识：

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

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

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

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

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

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

2)、二维数组

也称多维数组，是数组中的数组

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

        解释：以上格式表示定义了名称为arr的二维数组。有3个一维数组，每一个一维数组中有2个元素。一维数组的名称分别为arr[0],arr[1],arr[2]。给第一个一维数组1脚标位赋值为56写法是：arr[0][1] = 56。

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

          注：此种格式中每个一维数组都是默认初始化值null。

        格式3：int[][] arr = {{1,2,5},{6,4},{8,9,3,6}};//每一个一维数组中具体元素都初始化了。

3）数组中容易出现的异常。

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

例：

int[] arr = new int[5];

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

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

2、空指针异常(NullPointerException)。

例：

int[]arr = null;

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

arr引用没有指向实体，却在操作实体中的元素时。

3、数组常见操作

1）、排序：快速排序

注：1、最快的排序方法是希尔排序（Shell Sort）。

　　2、在实际开发中不用自己敲代码。直接调用Arrays.sort();来进行排序。

package com.itheima;

public class Test4 {


	public static void main(String[] args) {
		
		int[] a={2,8,9,-7,88,945,-47,5,32};
		quickSort(a, 0, a.length-1);
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i]+",");
			
		}
		
	}
	private static void quickSort ( int[] array, int start, int end )
    {
        if (start < end)
        {
            int key = array[start];
            int i = start;
            for ( int j = start + 1; j < end + 1; j++ )
            {
                if (key > array[j])
                {
                    int temp = array[j];
                    array[j] = array[i + 1];
                    array[i + 1] = temp;
                    i++;
                }
            }
            array[start] = array[i];
            array[i] = key;
            quickSort (array, start, i - 1);
            quickSort (array, i + 1, end);
        }
    }
 

}

2）、查找： 折半查找：

class  ZheBan
{
    public static void main(String[] args) 
    {
        int[]arr={1,5,6,7,9,15,35,46};
        int index=half(arr,11);
        System.out.println("index="+index);
    }
    public static int half(int[]a,int key)
    {
        int min=0;
        int max=a.length-1;
        int mid=(min+max)>>1;
        while(min<=max)
        {
            if(key>a[mid])
            {
                min=mid+1;
            }
            else if(key<a[mid])
            {
                max=mid-1;
            }
            else
            {
                return mid;
            }
            mid=(min+max)>>1;
        }
        return min;
    }
}

3）、进制转换

class  JinZhi
{
    public static void main(String[] args) 
    {
        //定义一个数
        int n=60;
        //转为二进制
        toBin(n);
        //转为八进制
        toOct(n);
        //转为十六进制
        toHox(n);
        
    }
    //十进制转为二进制
    public static void toBin(int num)
    {
        trans(num,1,1);
        
    }
    //十进制转为八进制
    public static void toOct(int num)
    {
        trans(num,7,3);
    
    }
    //十进制转为十六进制
    public static void toHox(int num)
    {
        trans(num,15,4);
        
    }
    public static void trans(int num,int base,int offset)
    {
        //如果输入的数为0，则直接输出0，并返回
        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[] a=new char[32];
        int pos=a.length;
        while(num!=0)
        {
            int temp=num&base;
            a[--pos]=chs[temp];
            num=num>>>offset;
        }
        for (int x=pos;x<a.length ;x++ )
        {
            System.out.print(a[x]);
        }
        System.out.println();
    }
}