黑马程序员——Java基础语法(三)---数组

一、概念

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

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

二、一维数组的格式

        格式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、实体不在被使用，会在不确定的时间内被垃圾回收器回收。

三、数组操作常见问题

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

             int[] arr = new int[2];

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

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

    2、空指针异常(NullPointerException)。例：

            int[]arr = null;

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

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

四、数组中的数组

        也称多维数组，这里我们主要讲二维数组。

        格式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][];

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

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

注：一种特殊定义写法：int[]x,y[]; x是一维数组，y是二维数组。

二维数组在内存中的分配情况示例：

五、数组常见操作

1、 数组排序：

        常见的排序方式：冒泡排序和选择排序。在Java已经定义好了一种排序方式，在开发使用中，直接调用即可。排序的方式有很多，其中最快的排序方式为希尔排序。

下面是我自己敲的选择和冒泡两种排序方式的程序：

        选择排序程序：

[java]  view plain copy

1. //使用选择排序方式对指定的数组进行排序  
2. class  Demo  
3. {  
4.     public static void main(String[] args)   
5.     {  
6.         int[] arr= {1,11,5,3,9,55,23,67,18};  
7.         //输出原数组  
8.         printArray(arr);  
9.         //调用排序方法  
10.         selectSort(arr);  
11.         //输出排序后的数组  
12.         printArray(arr);  
13.     }  
14.     public static void selectSort(int[] arr)  
15.     {  
16.         //外循环遍历数组  
17.         for (int x=0;x<arr.length-1;x++)  
18.         {  
19.             //内循环比较大小  
20.             for (int y=x+1;y<arr.length;y++)  
21.             {  
22.                 //如果后一个元素比拿去比较的元素大，就交换两元素位置  
23.                 if(arr[x]>arr[y])  
24.                 {  
25.                     //arr[x]=arr[y];  
26.                     //arr[y]=temp;  
27.                     swap(arr,x,y);  
28.                 }     
29.             }  
30.         }  
31.     }  
32.     //遍历数组  
33.     public static void printArray(int[] arr)  
34.     {  
35.         System.out.print("[");  
36.         for (int x=0;x<arr.length;x++)  
37.         {  
38.             if(x!=arr.length-1)  
39.                 System.out.print(arr[x]+",");  
40.             else  
41.                 System.out.print(arr[x]+"]");  
42.         }  
43.         //换行  
44.         System.out.println();  
45.     }  
46.     //互换方法  
47.     public static void swap(int[] arr,int a,int b)  
48.     {  
49.         arr[a]=arr[a]^arr[b];  
50.         arr[b]=arr[a]^arr[b];  
51.         arr[a]=arr[a]^arr[b];  
52.     }  
53. }  

 输出结果：

冒泡排序程序：

[java]  view plain copy

1. //使用冒泡排序方式对指定程序进行排序  
2. class Demo1   
3. {  
4.     public static void main(String[] args)   
5.     {  
6.         int arr[]={22,63,89,13,6};  
7.         //打印原数组  
8.         printArray(arr);  
9.         //调用排序方法  
10.         bubbleSort(arr);  
11.         //打印排序后的数组  
12.         printArray(arr);  
13.     }  
14.     public static void bubbleSort(int[] arr)  
15.     {  
16.         for (int x=0;x<arr.length-1;x++)  
17.         {  
18.             for (int y=0;y<arr.length-1-x;y++)//-x:让没每一次比较的元素减少。-1：避免角标越界。  
19.             {  
20.                 if(arr[y]>arr[y+1])  
21.                     swap(arr,y,y+1);  
22.             }  
23.         }  
24.     }  
25.     //遍历数组  
26.     public static void printArray(int[] arr)  
27.     {  
28.         System.out.print("[");  
29.         for (int x=0;x<arr.length;x++)  
30.         {  
31.             if(x!=arr.length-1)  
32.                 System.out.print(arr[x]+",");  
33.             else  
34.                 System.out.print(arr[x]+"]");  
35.         }  
36.         //换行  
37.         System.out.println();  
38.     }  
39.     //互换方法  
40.     public static void swap(int[] arr,int a,int b)  
41.     {  
42.         arr[a]=arr[a]^arr[b];  
43.         arr[b]=arr[a]^arr[b];  
44.         arr[a]=arr[a]^arr[b];  
45.     }  
46. }  

 输出结果

2、 折半查找

程序：

[java]  view plain copy

1. class  HalfSearch  
2. {  
3.     public static void main(String[] args)   
4.     {  
5.         int[] arr={2,6,9,11,15,19,22,30};  
6.         //打印数组  
7.         printArray(arr);  
8.         int key=20;  
9.         //用第一种折半方式输出插入的角标值  
10.         System.out.println("当key=20在数组arr中插入的角标位置是："+halfSearch1(arr,key));  
11.         key=1;  
12.         //用第二种折半方式输出插入的角标值  
13.         System.out.println("当key=1在数组arr中插入的角标位置是："+halfSearch2(arr,key));  
14.     }  
15.     //折半查找<一>  
16.     public static int halfSearch1(int[] arr,int key)  
17.     {  
18.         int min=0,max=arr.length-1,mid=(max+min)/2;  
19.         while(key!=arr[mid])  
20.         {  
21.             if(min>max)  
22.                 return min;  
23.             else if(key>arr[mid])  
24.                 min=mid+1;  
25.             else   
26.                 max=mid-1;  
27.             mid=(max+min)>>>1;//折半操作             
28.         }  
29.         return mid;   
30.     }  
31.     //折半查找<二>  
32.     public static int halfSearch2(int[] arr,int key)  
33.     {  
34.         int min=0,max=arr.length-1,mid;  
35.         while(min<max)  
36.         {  
37.             mid=(max+min)>>>1;//折半操作  
38.             if(key>arr[mid])  
39.                 min=mid+1;  
40.             else if(key<arr[mid])  
41.                 max=mid-1;  
42.             else  
43.                 return mid;  
44.         }  
45.         return min;   
46.     }  
47.     //遍历数组  
48.     public static void printArray(int[] arr)  
49.     {  
50.         System.out.print("[");  
51.         for (int x=0;x<arr.length;x++)  
52.         {  
53.             if(x!=arr.length-1)  
54.                 System.out.print(arr[x]+",");  
55.             else  
56.                 System.out.print(arr[x]+"]");  
57.         }  
58.         //换行  
59.         System.out.println();  
60.     }  
61. }  

运行结果：

3、 进制转换

十进制转换为二进制、八进制、十六进制的小程序：

[java]  view plain copy

1. class  Conversion  
2. {  
3.     public static void main(String[] args)   
4.     {  
5.         int num=60;  
6.         toBin(num);  
7.         toOct(0);  
8.         toHex(-num);  
9.     }  
10.     //转换为二进制  
11.     public static void toBin(int num)  
12.     {  
13.         conversion(num,1,1);  
14.     }  
15.     //转换为八进制  
16.     public static void toOct(int num)  
17.     {  
18.         conversion(num,7,3);  
19.     }  
20.     //转换为十六进制  
21.     public static void toHex(int num)  
22.     {  
23.         conversion(num,15,4);  
24.     }  
25.     //转换  
26.     public static void conversion(int num,int diwei,int yiwei)  
27.     {  
28.         //如果num等于0，结果输出为0  
29.         if(num==0)  
30.         {  
31.             System.out.println("num="+0);  
32.             return;  
33.         }  
34.         //定义一个包含二进制、八进制、十六进制的表  
35.         char[] chs={'0','1','2','3','4','5','6','7',  
36.                     '8','9','A','B','C','D','E','F',};  
37.         //定义一个临时容器  
38.         char[] arr=new char[32];  
39.         //定义一个操作数组的指针  
40.         int pos=arr.length;  
41.         //利用与低位最大值的方式取出低位，存到临时数组中  
42.         while(num!=0)  
43.         {  
44.             arr[--pos]=chs[num&diwei];//--pos倒着往临时容器里存  
45.             num >>>=yiwei; //无条件右移相应位数  
46.         }  
47.         //打印转换后的结果  
48.         for(int x=pos;x<arr.length; x++)  
49.             System.out.print(arr[x]);  
50.         //换行  
51.         System.out.println();  
52.     }  
53. }  

 输出结果：