Java基础：数组

1.数组的概念

数组是一种数据结构，用来存储同一类型值的集合，相当于一个容器；

2.数组的特点

定义数组后，会为数组中的元素从0开始编号，这种编号也叫下标，通过这些下标来访问数组中的元素；

一旦创建了数组，就不能再改变它的大小(尽管可以改变数组中的每个元素)；

数组中的元素有默认值：

(1).数字数组元素初始化为0；

(2).布尔类型元素初始化为false；

(3).引用类型元素初始化为null；

3.数组的初始化

(1).格式：元素类型[ ] 数组名 = new 元素类型[元素个数或数组长度]；

eg：int[ ] arr = new arr[5]；//定义一个长度为5的，名为arr的数组；

然后通过数组下标，给数组中的元素赋值；arr[x] = 具体值；

(2).格式：元素类型[ ] 数组名 = new 元素类型[ ]{元素，元素...，元素}；

eg：int[ ] arr = new int[ ]{1，3，5，7，9}；

注意：在这样定义时：不能指定数组的大小；

int[ ] arr = {2，4，6，8}；

4.二维数组

(1).二维数组可以理解为数组中的数组；

(2).定义二维数组的格式：规则数组或不规则数组；

格式一：元素类型[ ][ ] 数组名称 = new 元素类型[二维的维数][一维的维数]；

eg：int[ ][ ] arr = new int[3][2]；//二维数组中有三个一维数组，每个一维数组中含有两个元素；

格式二：同上述定义方式，但是只指定二维数组的维数，一维数组在分别进行初始化；

eg：int[ ][ ] arr =  new int[3][ ]；

arr[0] = new int[2]；

arr[1] = new int[1]；

arr[2] = new int[3]；

格式三：在定义的时候初始化；

eg：int[ ][ ] arr = {{1，2，3，4}，{5，6，7}，{8，9}}；

(3).二维数组的内存结构：

5.数组的操作

5.1 数组的获取操作

(1).获取数组的具体元素：利用角标值；

特别注意在二维数组中，利用角标获取时，要区分获取的是一维数组的引用还是数组的元素；

例如：数组arr[2][2]中，利用arr[0]，arr[1]获取的是一维数组的引用，arr[0][0]获取的是数组中的元素；

(2).获取数组的长度：数组名称.length； 获取的是属性，不是方法，使用时不要加括号；

(3).获取数组元素的最值：

[java]  view plain  copy

 

1. /* 
2. 需求：获取数组元素的最值； 
3. 分析：可以将获取最值的功能封装为相应的方法； 
4. 1.确定返回类型：返回的是数组中的最值元素，那么返回类型为数组元素类型； 
5. 2.确定未知参数：获取的是某个数组中的最值，因此数组作为参数传递； 
6.  */  
7. package com.zr.day04;  
8.   
9. class ArrTest  
10. {  
11.     public static void main(String[] args)  
12.     {  
13.         int[] arr = {3,36,25,41,99,87,76,54};  
14.         System.out.println("数组arr中的最大元素为:"+getMax(arr));  
15.         System.out.println("数组arr中的最小元素为:"+getMin(arr));  
16.     }  
17.       
18.     //方式一：将max初始值定义为数组中的某个元素值；这里定义为端点0角标的元素值；  
19.     public static int getMax(int[] array)  
20.     {  
21.         int max = array[0];  
22.         for(int x=1; x<array.length; x++)  
23.         {  
24.             if(max<array[x])  
25.                 max = array[x];  
26.         }  
27.         return max;  
28.     }  
29.       
30.     //方式二：将min初始值定义为数组元素的角标；这里定义为端点元素的角标0角标；  
31.     public static int getMin(int[] array)  
32.     {  
33.         int min = 0;  
34.         for(int x=1; x<array.length; x++)  
35.         {  
36.             if(array[min]>array[x])  
37.                 min = x;  
38.         }  
39.         return array[min];  
40.     }  
41. }  

5.2 数组的遍历操作

(1).普通的for循环；

使用普通for循环的优点是：在遍历时，可以在遍历的同时，利用数组的角标对遍历的元素进行更多更丰富的操作；

[java]  view plain  copy

 

1. /* 
2. 需求：使用普通for循环实现对数组的遍历； 
3.  
4. 分析：最常用的遍历操作之一就是打印，因此可以将打印数组中的元素封装为一个方法，在以后使用的时候只需要调用这个方法即可； 
5. 1.确定功能的返回值类型：打印，没有返回值，void； 
6. 2.确定功能的未知参数：因为打印的是数组元素所以将数组作为参数传递为该功能； 
7. */  
8. package com.zr.day04;  
9. class ArrDemo  
10. {  
11.     //主函数：用来测试打印数组元素功能是否正确；  
12.     public static void main(String[] args)  
13.     {  
14.         int[] arr = {65,91,89,36,42};  
15.         printArr(arr);  
16.     }  
17.       
18.     //打印数组功能的实现；  
19.     public static void printArr(int[] array)  
20.     {  
21.         System.out.print("{");  
22.         for(int x=0; x<array.length; x++)  
23.         {  
24.             if(x == array.length -1)  
25.                 System.out.println(array[x]+"}");  
26.             else  
27.                 System.out.print(array[x]+",");  
28.         }  
29.     }  
30. }  

(2)增强的for循环

增强的for循环格式：for(元素类型 变量名：集合) { 语句 }

其中集合表达式必须是一个数组或者是一个实现了Iterable接口的类对象；

相较于普通的for循环：在语句代码上遍历数组元素显得更加简洁，但是也存在一定的缺陷，比如希望在for循环中只遍历部分元素时，或者希望在for循环中使用具体的角标值时，增强的for循环就不适用了；

[java]  view plain  copy

 

1. package com.zr.day04;  
2. class ArrDemo  
3. {  
4.     //使用增强的for循环遍历数组元素；  
5.     public static void main(String[] args)  
6.     {  
7.         int[] arr = {65,91,89,36,42};  
8.           
9.         for(int x:arr)//此处的x变量用来获取元素值，而不是角标值；  
10.         {  
11.             System.out.print(x+" ");  
12.         }  
13.     }  
14. }  

5.3 数组的排序操作

排序的方法有许多种，这里简单介绍选择排序和冒泡排序；

(1).选择排序：选取数组中某一位置的元素，同其他各个位置的元素相比较，当满足某条件时，进行位置置换；下一趟操作时在选取另一位置的元素重复此操作，直至每个位置都完成上述操作；

选择排序原理示意图如下：

(2).冒泡排序：冒泡排序是数组中相邻两个元素之间进行比较，当满足条件时，作位置置换，每一趟排序完成后数组中的参与该趟排序的最值会依次向数组的某一段移动；

冒泡排序原理示意图：

(3).分析排序功能的设计：明确返回类型和参数列表；

首先，确定参数列表，因为要对数组进行排序，所以未知参数为数组；

接下来，确定返回类型：

通过上图可知：当将数组作为参数传递给功能中定义的形式参数后，由于数组是引用类型，所以通过形式参数操作的也是数组本身，因此排序功能的返回值类型为void；

(4).两种排序方法的详细设计：

[java]  view plain  copy

 

1. /* 
2. 需求：分别实现选择排序和冒泡排序； 
3.  */  
4. package com.zr.day04;  
5. class ArrSortDemo  
6. {  
7.     public static void main(String[] args)  
8.     {  
9.         int[] arr1 = {23,34,45,12,9};  
10.         int[] arr2 = {9,7,5,4,2,1};  
11.           
12.         printArr(arr1);  
13.         selectSort(arr1);  
14.         printArr(arr1);   
15.           
16.         System.out.println("|-------------------------------");  
17.           
18.         printArr(arr2);  
19.         bubbleSort(arr2);  
20.         printArr(arr2);  
21.     }  
22.       
23.     public static void selectSort(int[] array)  //选择排序  
24.     {  
25.         //array.length-1:当最后一趟中要比较的元素只有一个就不要在进行比较；  
26.         for(int x=0; x<array.length-1; x++)  
27.         {  
28.             //x所在位置为这一趟被选择的位置，x+1：与之进行比较的元素在下一个位置；  
29.             for(int y=x+1; y<array.length; y++)  
30.             {  
31.                 if(array[x]>array[y])  
32.                 {  
33.                     int temp = array[x];  
34.                     array[x] = array[y];  
35.                     array[y] = temp;  
36.                 }  
37.             }  
38.         }  
39.     }  
40.       
41.     public static void bubbleSort(int[] array)  //冒泡排序  
42.     {  
43.         //array.length-1:当最后一趟中要比较的元素只有一个就不要在进行比较；  
44.         for(int x=0; x<array.length-1; x++)  
45.         {  
46.             //减x:表示已经进行了x趟排序，在末端有x个已经排序完成的元素；  
47.             //减1:防止y+1出现ArrayIndexOutOfBoundException，数组角标越界异常；  
48.             for(int y=0; y<array.length-x-1; y++)      
49.             {  
50.                 if(array[y]>array[y+1])  
51.                 {  
52.                     int temp = array[y];  
53.                     array[y] = array[y+1];  
54.                     array[y+1] = temp;  
55.                 }  
56.             }  
57.         }  
58.     }  
59.       
60.     public static void printArr(int[] array)    //打印数组  
61.     {  
62.         System.out.print("{");  
63.         for(int x=0; x<array.length; x++)  
64.         {  
65.             if(x == array.length -1)  
66.                 System.out.println(array[x]+"}");  
67.             else  
68.                 System.out.print(array[x]+",");  
69.         }  
70.     }  
71. }  

5.4 数组元素的置换操作

数组元素的置换操作：发现在排序过程中有许多置换元素的操作，因此可以将这个功能进行封装；

确定功能的返回类型：没有返回值，定义为void；

确定功能的参数列表：对哪个数组的元素进行置换，具体哪两个位置的元素需要置换；

[java]  view plain  copy

 

1. package com.zr.day04;  
2. class ArrSwapDemo  
3. {  
4.     public static void main(String[] args)  
5.     {  
6.         int[] arr = {1,2,3};  
7.         printArr(arr);  
8.         swap(arr,0,arr.length-1);  
9.         printArr(arr);  
10.           
11.     }  
12.     public static void swap(int[] array, int x, int y)  
13.     {  
14.         int temp = array[x];  
15.         array[x] = array[y];  
16.         array[y] = temp;  
17.     }  
18. }  

5.5 数组的查找操作

普通查找：可以对无序的数组元素进行查找；效率较低；

折半查找：针对有序数组的查找，可以明显提高查找效率；

(1).折半查找成功

(2).折半查找失败

详细代码设计：

确定返回值类型：当查找成功时，应该返回的是该key值所在的位置或者角标值；当查找失败时，返回的是-1或者是该key值应该插入的位置；

确定参数列表：对指定数组进行指定值的查找；

[java]  view plain  copy

 

1. /* 
2. 实现折半查找； 
3. 1，确定返回值类型： 
4.     当查找成功时返回的是key值所在的位置或者角标值； 
5.     当查找失败时返回的是-1，或者是key值应该插入的位置； 
6. 2，确定参数列表：对指定的数组进行指定值的查找； 
7.  */  
8.   
9. package com.zr.day04;  
10. class BinSearchDemo  
11. {  
12.     public static void main(String[] args)  
13.     {  
14.         int[] arr ={3,12,24,35,45,66,77,88,99};  
15.         int key = 22;  
16.         System.out.println(search(arr,key));  
17.     }  
18.     public static int search(int[] array, int key)  
19.     {  
20.         //分别定义两个指针，分别指向数组两个端点；  
21.         int low = 0;  
22.         int high = array.length-1;  
23.           
24.         //折半查找的中间值；  
25.         int mid;  
26.         while(low<high)//定义循环结束条件  
27.         {  
28.             //每次循环开始时，重新计算中间值；  
29.             mid = (low+high)/2;  
30.             //关键字值小于中间值时，高位指针左移；  
31.             if(key<array[mid])  
32.             {  
33.                 high = mid-1;  
34.             }  
35.             //关键字值大于中间值时，地位指针右移；  
36.             else if(key>array[mid])  
37.             {  
38.                 low = mid+1;  
39.             }  
40.             else  
41.                 return mid;//查找成功  
42.         }  
43.         return -low;//查找失败返回应该插入的位置；  
44.     }  
45. }  

6.数组的应用

查表法实现进制之间的转换：

[java]  view plain  copy

 

1. /* 
2. 需求：利用数组查表实现数制之间的转换； 
3. */  
4. package com.zr.day04;  
5. class AppDemo  
6. {  
7.     public static void main(String[] args)  
8.     {  
9.         toBin(6);  
10.         System.out.println();  
11.         toHex(60);  
12.         System.out.println();  
13.         toOct(60);  
14.     }  
15.       
16.     //十进制转换为二进制  
17.     public static void toBin(int num)  
18.     {  
19.         trans(num,1,1);  
20.     }  
21.       
22.     //十进制转换为十六进制  
23.     public static void toHex(int num)  
24.     {  
25.         trans(num,15,4);  
26.     }  
27.       
28.     //十进制转换为八进制  
29.     public static void toOct(int num)  
30.     {  
31.         trans(num,7,3);  
32.     }  
33.       
34.     /* 
35.      * 调用最底层的转换方法 
36.      * 1.返回类型：直接输出打印； 
37.      * 2.参数列表： 
38.      *      num：从上层调用者接收来的要转换的值； 
39.      *      base：基数，每次移位后与操作值； 
40.      *      offset：移位值； 
41.      */  
42.     private static void trans(int num,int base,int offset)  
43.     {  
44.         //判断当给定值为0时，就可以直接输出，然后返回；  
45.         if(num == 0)  
46.         {  
47.             System.out.println(0);  
48.             return;  
49.         }  
50.           
51.         //定义表格数组，用来实现角标和字符之间的对应关系；  
52.         char[] chs = {'0','1','2','3',  
53.                 '4','5','6','7',  
54.                 '8','9','A','B',  
55.                 'C','D','E','F'};  
56.         //临时数组；用来存储临时值，然后按照指定方式输出；  
57.         //也可以使用StringBuilder，利用字符串对象来存储然后返回；  
58.         char[] arr = new char[32];  
59.         //定义一个指针，用来操作临时数组中的元素；  
60.         int pos = arr.length;  
61.         while(num!=0)   //定义循环结束条件  
62.         {  
63.             //与操作  
64.             int temp = num & base;  
65.             //存储临时值  
66.             arr[--pos] = chs[temp];  
67.             //移位操作  
68.             num = num >>> offset;  
69.         }  
70.           
71.         //打印，从有效值开始打印；  
72.         for(int x=pos; x<arr.length; x++)  
73.         {  
74.             System.out.print(arr[x]);  
75.         }  
76.     }  
77. }  

7.数组工具类

在Java体系中提供了专门用来操作数组的工具类：java.util.Arrays;

Arrays中定义的都是静态方法，包括一系列非常有用的对数组的操作；