数组需要掌握的：

　　1、数组的定义
　　2、数组的内存分配及特点
　　3、数组操作常见问题
　　4、数组常见操作
　　5、数组中的数组（理解）

数组唯一属性：length，即数组的长度。

1.数组定义

　　格式一：

　　　　元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
　　　　　示例：int[] arr = new int[5];
　 格式二：

　　　　元素类型[] 数组名 = new 元素类型[]{元素，元素，……};
　　　  　 示例：int[] arr = new int[]{3,5,1,7};
　　　　　　　    int[] arr = {3,5,1,7};

区别：方式一定义了数组的长度，但是没有给数组赋值，数组有默认值，和数据类型默认值一样；

　　　方式二定义数组，并赋值，默认指定数组的长度。推荐使用方式二

2.数组的内存分配及特点

3、数组常见操作

3.1数组遍历

　　将数组中的每个数据分别取出，for循环来完成 数组.length数组的长度，也就是存储数据的个数，数组中的最大角标值 = 数组.length - 1

 1 /*
 2   遍历数组，已经用for循环解决掉了
 3   数组越来越多
 4   如何去遍历呢
 5   采用函数的方式，将遍历数组的功能，定义在函数中
 6   直接调用函数的遍历功能就可以了
 7 */
 8 class ArrayDemo5{
 9     /*
10      分析步骤：
11       这个函数就负责遍历数组，并打印在命令行上
12       1. 有没有运算结果，没，void
13       2. 有没有未知数参与函数运算，就那数组
14     */
15
16     /*
17     printArray函数，就负责遍历数组，打印数组
18     调用这个函数的时候，传递函数进来
19     */
20     public static void printArray(int[] arr)
21     {
22         for(int x = 0; x<arr.length ;x++){
23             if(x!=arr.length-1){
24                 System.out.print(arr[x]+",");
25             }
26             else{
27              System.out.print(arr[x]);
28             }
29
30         }
31         System.out.println();
32     }
33     public static void main(String[] args)
34     {
35         int[] arr ={34,435,324,324,3246,63,3};
36         int[] arr1 ={34,435,324,324,3246,63,3,5};
37         printArray(arr);
38     //    printArray(arr1);
39     }
40 }

3.2数组求最值

　　遍历数组，对每一个数组中的元素进行比较，并且记录 较大数据的下标 必须定义函数完成

 1 /*
 2   数组中获取最值的操作
 3   最大值，最小值
 4 */
 5 class  ArrayDemo6{
 6     public static void main(String[] args) {
 7         int[] arr = {4,3,2,6,1,0};
 8         int max = getMax(arr);
 9
10         System.out.println("max="+max);
11     }
12     /*
13      定义函数，来获取数组中的最大值
14      1 明确函数计算后的结果是什么，int
15      2 未知数据就是数组
16     */
17
18     public static int getMax(int[] arr){
19         //定义变量，记录数组中0下标上的数据
20         int max = 0;//4
21         //遍历数组，分别进行比较，保留最大值
22         for(int x = 0 ; x<arr.length;x++){
23             if(arr[max]<arr[x]){
24                max = x;
25             }
26         }
27         return arr[max];
28     }
29
30     public static int getMin(int[] arr){
31         int min = 0;//4
32         //遍历数组，分别进行比较，保留最大值
33         for(int x = 0 ; x<arr.length;x++){
34             if(arr[min]>arr[x])
35             {
36                min = x;
37             }
38         }
39         return arr[min];
40     }
41 }

3.3数组排序

1、选择排序

? 利用原理是：从第0个下标开始进行比较和较大的数进行换位(借用第三方变量)第一次比较完后，从第1个小标开始进行比较和较大的数进行换位(借用第三方变量)

? 特点：第一次都比较完后，最小的数出现在了0下标位置上嵌套的for来完成

2、冒泡排序

相邻两个数据进行比较，根据结果换位

两种排序示意图

3、代码实例

 1         /*
 2          选择排序的三个步骤
 3          1. 遍历数组，把数组中每个元素分别取出
 4          2. 出去后，进行大小的比较
 5          3. 进行数组的换位置
 6         */
 7         //选择排序
 8         for (int x = 0; x < arr.length - 1; x++) {
 9             for (int y = x + 1; y < arr.length; y++) {
10                 // x=1 y=1+1=2
11                 if (arr[x] > arr[y])// arr[1]>arr[2]
12                 {
13                     int temp = arr[x];
14                     arr[x] = arr[y];
15                     arr[y] = temp;
16                 }
17             }
18         }
19
20         /*
21          定义函数实现冒泡排序
22          1. 确定函数运算后没有返回值
23          2. 不确定的数据就是数组
24
25          说明：
26            内圈循环，-x是为了比较的次数一次一次在减少
27                       -1是为了防止数组越界异常
28           希尔排序，公认的效率最高的排序方式
29           插入形式的排序算法
30         */
31         //冒泡排序
32         for(int x =0 ;x<arr.length; x++){
33            for(int y = 0 ; y <arr.length-x-1;y++){
34               if(arr[y]>arr[y+1]){
35                  int temp = arr[y];
36                  arr[y] = arr[y+1];
37                  arr[y+1] = temp;
38               }
39            }
40         }

4、数组操作常见问题

ArrayIndexOutOfBoundsException 数组下标越界异常
NullPointerException 空指针异常，引用类型中最常见