黑马程序员--数组

数组和数组的操作方法

一、数组

1、数组的概述和定义

数组：同一种类型数据的集合。其实数组就是一个容器。数组是存储数据的一种方式

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

数组定义的第一种格式：元素类型[] 数组名=new 元素类型[元素个数或数组长度];

其中new：用来在内存中产生一个容器实体。其中int代表元素的类型，arr是数组类型的

数组定义的第二种格式：元素类型[] 变量名=new 元素类型[] {元素1,元素2...}

数组是一种单独的数据类型。

2、Java内存空间

Java程序在运行时，在内存中的分配空间共有5种：

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

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

在堆内存中：

(1)每一个实体都有内存地址值；

(2)实体中的变量都有默认初始化值(值是多少是根据元素类型来定的)；

(3)这样实体不在被使用，会在不确定的时间内被垃圾回收器回收。

其余三种：方法区，本地方法区，寄存器

3、数组操作中常见的问题：

(1)数组角标越界异常  ArrayIndexOutOfBoundsException

比如：int arr=new int[3];   Stystem.out.print(arr[3]);

在数组中实际上是没有角标3的，只有0、1、2。这样编写，Java文件在编译的时候是没有问题的，因为语法没有错，但是在执行的时候，就会提示数组角标越界异常。表示操作数组时，访问到了数组中不存在的角标

(2)空指针异常NullPointerException

比如：int arr=new int[3];  arra=null;  Stystem.out.print(arr[1]);

arra=null后，arra这个引用已经不再指向任何数组实体了。当引用没有任何指向，值为空的情况下，该引用还在用于操作实体，就会出现这种问题。

二、二维数组
二维数组的声明方式和一维数组类似，内存的分配也是一样是用new这个关键字。
其声明与分配内存的格式如下所示：
1.初始化：
数据类型 数组名[][]
数组名 = new 数据类型[行的个数][列的个数];
2.声明加初始化
数据类型  数组名[][] = new 数据类型[行的个数][列的个数]
3.二维数组静态初始化
数据类型 数组名[][] = {{第0行初值},{第0行初值},.....{第n行初值}}

三、数组的操作（★★★）

数组常见的操作有：遍历、获取最值、排序、查找。

[java]  view plain copy print ?

1. <span style="color:#330033;">package pack;  
2. // 给定一个数组  
3. // 1，获取数组中的最大值，以及最小值。  
4. // 获取数组中的最大值。  
5. // 思路：  
6. // 1，获取最值需要进行比较，每一次比较都会有一个较大的值，因为该值不确定。  
7. // 通过一个变量进行临时存储。  
8. // 2，让数组中的每一个元素都和这个变量中的值进行比较。  
9. // 如果大于了变量中的值，就用该变量记录较大的值。  
10. // 3，档所有的元素都比较完成，那么该变量中存储的就是数组中的最大值了。  
11. // 步骤：  
12. // 1，定义变量，初始化为数组中任意一个元素即可。  
13. // 2，通过循环语句对数组进行遍历。  
14. // 3，在遍历过程中定义判断条件，如果遍历到的元素比变量中的元素大，就赋值给该变量。  
15. // 需要定义一个功能来完成，以便提高复用性。  
16. // 1，明确结果，数组中的最大元素int，  
17. // 2，未知内容：一个数组，int[]。  
18. class ArrayTest{  
19.     public static void main(String[] args){  
20.           
21.     }  
22.     // 获取最大值。  
23.     public int getMax(int[] arr){  
24.         int max=arr[0];  
25.         for(int x=0; x<arr.length; x++){  
26.             if(arr[x]>max)  
27.                 max=arr[x];  
28.         }  
29.         return max;  
30.     }  
31.     // 获取最大值的另一种方式，  
32.     // 可不可以将临时变量初始化为0呢？可以，这种方式其实是在初始化为数组中任意一个角标。  
33.     public int getMax2(int[] arr){  
34.         int max=0;  
35.         for(int x=0; x<arr.length; x++){  
36.             if(arr[x]>arr[max])  
37.                 max=x;  
38.         }  
39.         return arr[max];  
40.     }  
41.     // 获取最小值。  
42.     public int getMin1(int[] arr){  
43.         int min=arr[0];  
44.         for(int x=0; x<arr.length; x++){  
45.             if(arr[x]<min)  
46.                 min=arr[x];  
47.         }  
48.         return min;  
49.     }  
50.     // 获取最小值的另一种方式.  
51.     public int getMin2(int[] arr){  
52.         int min=0;  
53.         for(int x=0; x<arr.length; x++){  
54.             if(arr[x]<arr[min])  
55.                 min=x;  
56.         }  
57.         return arr[min];  
58.     }  
59.     // 获取double类型数组的最大值，因为功能一致，所以定义相同的函数名称，以重载形式存在。  
60.     public double getMax(double[] arr){  
61.         double max=arr[0];  
62.         for(int x=0; x<arr.length; x++){  
63.             if(arr[x]>max)  
64.                 max=arr[x];  
65.         }  
66.         return max;  
67.     }  
68.     // 获取double类型数组的最大值，因为功能一致，所以定义相同的函数名称，以重载形式存在。  
69.     public double getMin(double[] arr){  
70.         double min=arr[0];  
71.         for(int x=0; x<arr.length; x++){  
72.             if(arr[x]<min)  
73.                 min=arr[x];  
74.         }  
75.         return min;  
76.     }  
77. }  
78.   
79. package pack;  
80. // 对给定数组进行排序。  
81. class ArraySort{  
82.     public static void main(String[] args){  
83.           
84.     }  
85.     // 快速排序：  
86.     public static void fast(int[] arr){  
87.         for(int x=0; x<arr.length; x++){  
88.             for(int y=0; y<arr.length; y++){  
89.                 if(arr[x]>arr[y]){  
90.                     int temp=arr[x];  
91.                     arr[x]=arr[y];  
92.                     arr[y]=temp;  
93.                 }  
94.             }  
95.         }  
96.     }  
97.     // 选择排序：内循环结束一次，最值出现头角标位置上。  
98.     public static void relect(int[] arr){  
99.         for(int x=0; x<arr.length-1; x++){  
100.             for(int y=x+1; y<arr.length; y++){  
101.                 if(arr[x]>arr[y]){  
102.                     int temp=arr[x];  
103.                     arr[x]=arr[y];  
104.                     arr[y]=temp;  
105.                 }  
106.             }  
107.         }  
108.     }  
109.     // 冒泡排序：  
110.     public static void bubbling(int[] arr){  
111.         for(int x=0; x<arr.length; x++){  
112.             // -x:让每一次比较的元素减少，-1：避免角标越界。  
113.             for(int y=0; y<arr.length-x-1; y++){  
114.                 if(arr[y]>arr[y+1]){  
115.                     int temp=arr[x];  
116.                     arr[x]=arr[y];  
117.                     arr[y]=temp;  
118.                 }  
119.             }  
120.         }  
121.     }  
122.     // 发现无论什么排序，都需要对满足条件的元素进行位置置换，  
123.     // 所以可以把这部分相同的代码提取出来，单独封装成一个函数。  
124.     public static void sort(int[] arr,int x,int y){  
125.         int temp=arr[x];  
126.         arr[x]=arr[y];  
127.         arr[y]=temp;  
128.     }  
129.     // 对数组进行打印的功能。  
130.     public static void print(int[] arr){  
131.         System.out.print("[");  
132.         for(int x=0; x<arr.length; x++){  
133.             if(x!=arr.length-1)  
134.                 System.out.print(arr[x]+", ");  
135.             else  
136.                 System.out.println(arr[x]+"]");  
137.         }  
138.     }  
139. }  
140.   
141. package pack;  
142. // 数组的查找操作：  
143. // 练习：有一个有序的数组，想要将一个元素插入到该数组中，  
144. // 还要保证该数组时有序的。  
145. class ArrayFind{  
146.     public static void main(String[] args){  
147.           
148.     }  
149.     // 定义功能，获取key第一次出现在数组中的位置。如果返回是-1，那么代表该key在数组中不存在。  
150.     public static int getKey(int[] arr,int key){  
151.         for(int x=0; x<arr.length; x++){  
152.             if(arr[x]==key)  
153.                 return x;  
154.         }  
155.         return -1;  
156.     }  
157.     public static int getIndex(int[] arr,int key){  
158.         int min=0,max=arr.length-1,mid;  
159.         while(min<=max){  
160.             mid=(max+min)>>1;  
161.             if(key>arr[mid])  
162.                 min=mid+1;  
163.             else if(key<arr[mid])  
164.                 max=mid-1;  
165.             else  
166.                 return mid;  
167.         }  
168.         return min;  
169.     }  
170.     // 折半查找，可以提高效率，但是必须要保证该数组是有序的数组。  
171.     public static int reduce1(int[] arr,int key){  
172.         int min=0,max=arr.length-1,mid=(max+min)/2;  
173.         while(arr[mid]!=key){  
174.             if(key>arr[mid])  
175.                 min=mid+1;  
176.             else if(key<arr[mid])  
177.                 max=mid-1;  
178.             if(min>max)  
179.                 return -1;  
180.             mid=(max+min)/2;  
181.         }  
182.         return mid;  
183.     }  
184.     // 折半查找的第二种方式  
185.     public static int reduce2(int[] arr,int key){  
186.         int min=0,max=arr.length-1,mid;  
187.         while(min<=max){  
188.             mid=(max+min)>>1;  
189.             if(key>arr[mid])  
190.                 min=mid+1;  
191.             else if(key<arr[mid])  
192.                 max=mid-1;  
193.             else  
194.                 return mid;  
195.         }  
196.         return -1;  
197.     }  
198.     //查表法  
199.     //当元素很多，而且这些元素和数组有对应的数字关系，而且这些数字都有角标的规律的时候，就可以使用查表法。  
200.     //练习：使用查表法进行十进制转换为十六进制。  
201.     public static void youHua(int num,int base,int offset)//num：要转换的数，base：要与的值，offset：位移的数  
202.     {  
203.   
204.         char[] chs={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};//定义表  
205.   
206.             char[] arr=new char[32];//定义一个临时存储容器。  
207.   
208.         int pos=arr.length;//定义一个操作数组的指针，将指针初始值定义为数组长度  
209.   
210.         while(num!=0)  
211.         {  
212.   
213.             int temp=num&base;//如果是转化成二进制，base=1，转化成十六进制，base=15  
214.              /*查表，将&后的值放入新数组中,因为pos初始值为数组长度， 
215.             --pos实现从右往左存，这样for遍历打印就是正着的*/  
216.             arr[--pos]=chs[temp];  
217.             num=num>>>offset;//位移。如果是转化成二进制，offset=1，转化成十六进制，offset=4  
218.         }  
219.         for (int x=pos;x<arr.length ;x++ )  
220.         {  
221.             System.out.print(arr[x]);  
222.         }  
223.         if(num==0)  
224.         {  
225.             System.out.println(0);  
226.             return ;  
227.         }  
228.     }  
229. }</span>