黑马程序员——数组

黑马程序员--数组

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

数    组

一、定义
数组：同一个类型数据的集合，就是一个容器。优点：从0自动编号，方便操作。

二、格式
（一）一维数组
格式1：元素类型[] 数组名 = new 元素类型[元素个数或数组长度]；
例：int[] arr = new int[4]; 或写成 int arr[] = new int[4];

格式2：元素类型[] 数组名 = new 元素类型[]{元素1，元素2，...};（数据明确时使用） 
例：int[] arr = new int[]{3,1,6}; 

格式3：元素类型[] 数组名 = {元素1，元素2，...};（简写的静态初始化格式）
例：int[] arr = {3,1,6};

一维数组内存图：

（二）二维数组
格式1：int[][] arr = new int[3][2];
上述格式表示：二维数组中有3个一维数组，每个一维数组包含2个元素； 

格式2：int[][] arr = new int[3][];
上述格式表示：每个一维数组的默认初始化值为null。

格式3：int[][] arr = {{3,8,1},{1,2},{3},...};
上述格式表示：每一个一维数组中具体元素都已经初始化。

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

二维数组内存图：

PS:
1、数据类型包括基本类型和引用类型。数组就是一种引用类型
2、内存结构：java中有5个区域存储数据：栈、堆、方法区、本地方法区、寄存器； 
栈内存：存储局部变量，数据用完，自动释放。
堆内存：  a 数组和对象，通过new建立的实例都在其中；
        b 实体中的变量都有默认初始化值；
c 每个实体都有内存地址值；
d 实体不再被使用后，启动垃圾回收机制。

三、数组常见问题
1、ArrayIndexOutOfBoundsException：数组角标越界异常，访问到数组中不存在的角标

[java] view plaincopyprint?

1. class ArrayDemo1  
2. {  
3.     public static void main(String[] args)   
4.     {  
5.         int[] arr = new int[2];  
6.         System.out.println(arr[2]);  
7.     }  
8. }  

class ArrayDemo1{public static void main(String[] args) {int[] arr = new int[2];System.out.println(arr[2]);}}

运行结果：

2、NullPointerException:空指针异常

[java] view plaincopyprint?

1. class ArrayDemo2  
2. {  
3.     public static void main(String[] args)   
4.     {  
5.         int[] arr = null;  
6.         System.out.println(arr[0]);  
7.     }  
8. }  

class ArrayDemo2{public static void main(String[] args) {int[] arr = null;System.out.println(arr[0]);}}

运行结果：

四、数组常见操作

1、数组排序：常见排序有两种：选择排序、冒泡排序。

选择排序：头角标值和所有值进行比较，内循环结束一次，最值出现在头角标位置上。    

冒泡排序：相邻值比较，最值出现在末角标。

java在开发中常使用已定义好的一种排序方法：Arrays.sort(arr);

下面是数组常用代码：

[java] view plaincopyprint?

1. /* 
2. 选择排序: 
3. */  
4. public class ArraySelect1 {  
5.     public static void main(String[] args)  
6.     {  
7.         int[] arr = {1,12,45,17,45,78,72};  
8.         //输出原数组   
9.         printArray(arr);  
10.         //进行选择排序   
11.         selectSort(arr);  
12.         //输出排序后数组   
13.         printArray(arr);  
14.           
15.     }  
16.     /* 
17.      * 思路： 
18.      * 1，先用0角标元素一次和其他元素比较，在0角标获取最小值； 
19.      * 2，再拿1角标元素和其他元素比较，以此类推。 
20.      */  
21.     public static void selectSort(int[] arr)  
22.     {  
23.         //外循环遍历数组   
24.         for(int x =0;x<arr.length-1;x++)  
25.         {  
26.             //内循环比较大小   
27.             for(int y =x+1;y<arr.length;y++)  
28.             {  
29.                 //比较大小，进行换值   
30.                 if(arr[x]>arr[y])  
31.                 {  
32.                     swap(arr,x,y);  
33.                 }  
34.             }  
35.         }  
36.     }  
37.     //定义换值方法，arr也是未知变量   
38.     public static void swap(int[] arr,int a,int b)   
39.     {  
40.         int temp = arr[a];  
41.         arr[a] = arr[b];  
42.         arr[b] = temp;  
43.     }  
44.     //设置打印格式   
45.     public static void printArray(int[] arr)  
46.     {  
47.         System.out.print("[");  
48.         for(int x=0;x<arr.length;x++)  
49.         {  
50.             if(x!=arr.length-1)  
51.             System.out.print(arr[x]+",");  
52.             else  
53.             System.out.println(arr[x]+"]");  
54.         }  
55.     }  
56. }  

/*选择排序:*/public class ArraySelect1 {public static void main(String[] args){int[] arr = {1,12,45,17,45,78,72};//输出原数组printArray(arr);//进行选择排序selectSort(arr);//输出排序后数组printArray(arr);}/* * 思路： * 1，先用0角标元素一次和其他元素比较，在0角标获取最小值； * 2，再拿1角标元素和其他元素比较，以此类推。 */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]){swap(arr,x,y);}}}}//定义换值方法，arr也是未知变量public static void swap(int[] arr,int a,int b) {int temp = arr[a];arr[a] = arr[b];arr[b] = temp;}//设置打印格式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]+",");elseSystem.out.println(arr[x]+"]");}}}

输出代码：

[java] view plaincopyprint?

1. /* 
2. 冒泡排序 
3. */  
4. public class ArraySelect2 {  
5.     public static void main(String[] args)  
6.     {  
7.         int[] arr = {1,12,45,17,45,78,72};  
8.         //输出原数组   
9.         printArray(arr);  
10.         //进行选择排序   
11.         bubbleSort(arr);  
12.         //输出排序后数组   
13.         printArray(arr);  
14.           
15.     }  
16.     /* 
17.      * 思路：比较相邻项 最值在尾部 
18.      */  
19.   
20.     public static void bubbleSort(int[] arr)  
21.     {  
22.         for(int x=0;x<arr.length-1;x++)  
23.         {  
24.             for(int y =0;y<arr.length-x-1;y++)//-x:让每一次比较的元素减少；-1：避免角标越界  
25.             {  
26.                 if(arr[y]>arr[y+1])  
27.                 {  
28.                     swap(arr,y,y+1);  
29.                 }  
30.             }  
31.         }  
32.     }  
33.     //定义换值方法，arr也是未知变量   
34.     public static void swap(int[] arr,int a,int b)   
35.     {  
36.         int temp = arr[a];  
37.         arr[a] = arr[b];  
38.         arr[b] = temp;  
39.     }  
40.     //设置打印格式   
41.     public static void printArray(int[] arr)  
42.     {  
43.         System.out.print("[");  
44.         for(int x=0;x<arr.length;x++)  
45.         {  
46.             if(x!=arr.length-1)  
47.             System.out.print(arr[x]+",");  
48.             else  
49.             System.out.println(arr[x]+"]");  
50.         }  
51.     }  
52. }  

/*冒泡排序*/public class ArraySelect2 {public static void main(String[] args){int[] arr = {1,12,45,17,45,78,72};//输出原数组printArray(arr);//进行选择排序bubbleSort(arr);//输出排序后数组printArray(arr);}/* * 思路：比较相邻项 最值在尾部 */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]){swap(arr,y,y+1);}}}}//定义换值方法，arr也是未知变量public static void swap(int[] arr,int a,int b) {int temp = arr[a];arr[a] = arr[b];arr[b] = temp;}//设置打印格式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]+",");elseSystem.out.println(arr[x]+"]");}}}

输出结果：

[java] view plaincopyprint?

1. /* 
2.  * 需求：将一个已知元素插入到一个有序数组中，要求不改变数组顺序，打印元素应该插入数组位置的角标。 
3.  * 思路：1、可以利用折半查找的方式，先定义两个变量，一个初始化0角标，作为最小值，一个初始化为最后一个角标， 
4.  *  作为最大值。再定义一个变量，存储最小值与最大值的一半（中间值），然后将目标元素与中间值元素进行比较。 
5.  *      2、如果中间值大，最大值变为中间值-1，继续用中间值和目标元素比较；如此反复。 
6.  *      3、如果目标元素大，最小值变为中间值+1，继续用中间值和目标元素比较；如此反复。 
7.  */  
8.   
9. public class HalfSearch {  
10.     public static void main(String[] args)  
11.     {  
12.         int[] arr = {3,4,6,7,9,14,54};  
13.         //打印原数组   
14.         printArray(arr);  
15.         //插入20   
16.         int index = 20;  
17.         //用方式一输出插入角标值   
18.         System.out.println("方式一获取的插入角标值为"+halfSearch_1(arr,index));  
19.           
20.         index = 4;  
21.         System.out.println("方式二获取的插入角标值为。。。。。"+halfSearch_2(arr,index));  
22.     }  
23.   
24. //折半查找：可提高效率，但必须在有序数组中使用。   
25.     public static int halfSearch_1(int[] arr,int key)  
26.     {  
27.         int min,max, mid;  
28.         min = 0;  
29.         max = arr.length-1;  
30.         mid = (min+max)/2;  
31.   
32.         while(arr[mid]!=key)  
33.         {  
34.             if(key>arr[mid])  
35.                 min = mid +1;  
36.             else if(key<arr[mid])  
37.                 max = mid-1;  
38.   
39.             if(min>max)  
40.                 return min;  
41.             mid = (max+min)/2;  
42.         }  
43.         return mid;  
44.     }  
45.   
46. //折半的第二种方式   
47.     public static int halfSearch_2(int[] arr,int key)  
48.     {  
49.         int min=0,max=arr.length-1,mid;  
50.         while(min<=max)  
51.         {  
52.             mid=max+min>>1;  
53.               
54.             if(key>arr[mid])  
55.                 min=mid+1;  
56.             else if(key<arr[mid])  
57.                 max=mid-1;  
58.             else  
59.                 return mid;  
60.         }  
61.         return -1;  
62.     }  
63.     //设置打印格式   
64.     public static void printArray(int[] arr)  
65.     {  
66.         System.out.print("[");  
67.         for(int x=0;x<arr.length;x++)  
68.         {  
69.             if(x!=arr.length-1)  
70.             System.out.print(arr[x]+",");  
71.             else  
72.             System.out.println(arr[x]+"]");  
73.         }  
74.     }  
75. }  

/* * 需求：将一个已知元素插入到一个有序数组中，要求不改变数组顺序，打印元素应该插入数组位置的角标。 * 思路：1、可以利用折半查找的方式，先定义两个变量，一个初始化0角标，作为最小值，一个初始化为最后一个角标， * 作为最大值。再定义一个变量，存储最小值与最大值的一半（中间值），然后将目标元素与中间值元素进行比较。 * 2、如果中间值大，最大值变为中间值-1，继续用中间值和目标元素比较；如此反复。 * 3、如果目标元素大，最小值变为中间值+1，继续用中间值和目标元素比较；如此反复。 */public class HalfSearch {public static void main(String[] args){int[] arr = {3,4,6,7,9,14,54};//打印原数组printArray(arr);//插入20int index = 20;//用方式一输出插入角标值System.out.println("方式一获取的插入角标值为"+halfSearch_1(arr,index));index = 4;System.out.println("方式二获取的插入角标值为。。。。。"+halfSearch_2(arr,index));}//折半查找：可提高效率，但必须在有序数组中使用。public static int halfSearch_1(int[] arr,int key){int min,max, mid;min = 0;max = arr.length-1;mid = (min+max)/2;while(arr[mid]!=key){if(key>arr[mid])min = mid +1;else if(key<arr[mid])max = mid-1;if(min>max)return min;mid = (max+min)/2;}return mid;}//折半的第二种方式public static int halfSearch_2(int[] arr,int key){int min=0,max=arr.length-1,mid;while(min<=max){mid=max+min>>1;if(key>arr[mid])min=mid+1;else if(key<arr[mid])max=mid-1;elsereturn mid;}return -1;}//设置打印格式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]+",");elseSystem.out.println(arr[x]+"]");}}}

输出结果：

[java] view plaincopyprint?

1. /* 
2.  * 需求：利用查表法将十进制转换为二进制、八进制、十六进制。 
3.  * 思路：1、进制在进行与运算后，会获取相对应的值。 
4.  *      2、数组是同一种类型数据的集合，元素和角标具有对应关系； 
5.  *      3、将进制封装进数组中。 
6.  */  
7. public class TranstionDemo {  
8.     public static void main(String[] args)  
9.     {  
10.         toBin(0);  
11.         show();  
12.         toOct(9);  
13.         show();  
14.         toHex(45);  
15.     }  
16.     //十进制转二进制   
17.     public static void toBin(int num)  
18.     {  
19.         trans(num,1,1);  
20.     }  
21.     //十进制转八进制   
22.     public static void toOct(int num)  
23.     {  
24.         trans(num,7,3);  
25.     }  
26.     //十进制转十六进制   
27.     public static void toHex(int num)  
28.     {  
29.         trans(num,15,4);  
30.     }  
31.       
32.     public static void trans(int num,int base,int offset)  
33.     {  
34.         //因为所有进制的0值都是0，故单独定义   
35.         if(num==0)  
36.         {  
37.             System.out.print(0);  
38.             return;  
39.         }  
40.         //定义数据库表   
41.         char[] chs = {'0','1','2','3',  
42.                       '4','5','6','7',  
43.                       '8','9','A','B',  
44.                       'C','D','E','F'};  
45.         //定义临时容器。因为一个char有32个二进制位，故依最多位值设置数组。  
46.         char[] arr = new char[32];  
47.           
48.         //指针代表存入值的位，这样存可使值倒着输出   
49.         int pos = arr.length;  
50.           
51.         //只运算有效位，提高运算效率。   
52.         while(num!=0)   
53.         {  
54.             int temp = num & base;  
55.               
56.             //--pos是存入角标的移位动作，防止覆盖   
57.             arr[--pos] = chs[temp];  
58.               
59.             //右移位数   
60.             num=num>>>offset;    
61.         }  
62.           
63.         //从pos位开始遍历，可以只输出有效位   
64.         for(int x=pos;x<arr.length;x++)   
65.         {  
66.             System.out.print(arr[x]);  
67.         }         
68.     }  
69.     //定义输出函数   
70.     public static void show()  
71.     {  
72.         System.out.println();  
73.     }  
74. }  

/* * 需求：利用查表法将十进制转换为二进制、八进制、十六进制。 * 思路：1、进制在进行与运算后，会获取相对应的值。 * 2、数组是同一种类型数据的集合，元素和角标具有对应关系； * 3、将进制封装进数组中。 */public class TranstionDemo {public static void main(String[] args){toBin(0);show();toOct(9);show();toHex(45);}//十进制转二进制public static void toBin(int num){trans(num,1,1);}//十进制转八进制public static void toOct(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){//因为所有进制的0值都是0，故单独定义if(num==0){System.out.print(0);return;}//定义数据库表char[] chs = {'0','1','2','3',              '4','5','6','7',              '8','9','A','B',              'C','D','E','F'};//定义临时容器。因为一个char有32个二进制位，故依最多位值设置数组。char[] arr = new char[32];//指针代表存入值的位，这样存可使值倒着输出int pos = arr.length;//只运算有效位，提高运算效率。while(num!=0) {int temp = num & base;//--pos是存入角标的移位动作，防止覆盖arr[--pos] = chs[temp];//右移位数num=num>>>offset;}//从pos位开始遍历，可以只输出有效位for(int x=pos;x<arr.length;x++) {System.out.print(arr[x]);}}//定义输出函数public static void show(){System.out.println();}}

输出结果：