Java基础第6讲--数组

1、数组概述

1.1、数组在生活中的应用

在日常生活中，盒子的作用是存放东西，但是是不能把衣服和食品放在一起的，会有专门放衣服的盒子，也会有专门放食品的盒子。

在Java中，数组就好比日常生活中的盒子，用来存放数据。每一个数组也是有类型的，用来存放相应类型的数据。数组是一种存放数据的数据结构。

1.2、什么是数组

int arr[] = {1, 2, 3, 4, 5};

• 数组可以看成是多个相同类型的数据的组合，对这些数据统一进行管理。
• 数组变量属于【引用数据类型】，可以把数组看成是一个对象，数组中的每个元素相当于该对象的成员变量。
• 数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。

1.3、什么是数组的元素

• 数组中的变量被称作数组的元素
• 数组的元素没有名字，通过数组的名称和非负整数下标值可以获取数组元素
• 数组的长度指的是该数组中可以容纳的元素的个数

2、数组的创建和引用

2.1、数组的声明

2.1.1、声明数组的方法

数据类型 数组名称[];

或

数据类型[] 数组名称;

2.1.2、示例

int arr[];int[] arr1; 

2.2、数组的创建

2.2.1、创建静态数组

声明数组时，给出了数组的初始值，这种创建方法叫做创建静态数组，例如：

int arr[] = {1, 2, 3, 4, 5};String[] arr1 = {"BeiJing", "ShangHai", "HangZhou"};

2.2.2、创建动态数组

声明数组时，没有给出数组的初始值，但是指定了数组的长度，这种创建方法叫做创建动态数组。可以通过数组下标找到数组元素，给指定的元素赋值，例如：

int[] arr = new int[4]; //创建动态数组//数组元素赋值arr[0] = 1;arr[1] = 2;arr[2] = 3;arr[3] = 4;

2.2.3、注意事项

• 数组下标必须是int、short、byte，或是char
• 数组下标从0开始计数
• 元素的个数就是数组的长度，可以通过arrayName.length引用
• 数组下标最大值为arrayName.length – 1，如果超过最大值，程序将会抛出数组下标越界异常（ArrayIndexOutOfBoundsException）

2.2.4、面试题：以下获取数组元素的方法正确的是？

int[] data = new int[10];

a、data[-1]

b、data[10]

c、data[1.5]

d、data[0]

e、data[9] 

2.3、二维数组

2.3.1、如何声明二维数组

二维数组可以看成以数组为元素的数组。

2.3.2、示例

int[][] arr = {{1, 2}, {3, 4}, {5, 6}};int[][] arr1 = new int[3][2];

2.3.3、二维数组静态初始化

int[][] arr = {{1, 2}, {3, 4}, {5, 6}};

2.3.4、二维数组动态初始化

int[][] arr1 = new int[3][2];arr1[0] = new int[]{1, 2};arr1[1] = new int[]{3, 4};arr1[2] = new int[]{5, 6};

3、面试题

3.1、获取最大值

int arr[] = {1, 2, 7, 4, 5};int k = arr[0];for(int i=0; i<arr.length; i++){if(arr[i]>k){k = arr[i];}}System.out.println(k);

3.2、获取最小值

int arr[] = {1, 2, 7, 4, 0};int k = arr[0];for(int i=0; i<arr.length; i++){if(arr[i]<k){k = arr[i];}}System.out.println(k);

3.3、数组排序

3.3.1、使用Arrays.sort(arrayName);方法排序

int arr[] = {1, 9, 7, 4, 0};Arrays.sort(arr);for(int i=0; i<arr.length; i++){System.out.println(i);}

3.3.2、冒泡排序

冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

参考：http://www.cnblogs.com/shen-hua/p/5422676.html

示例：

//冒泡排序法int arr[] = {1, 9, 7, 4, 0};for(int i=0; i<arr.length-1;i++){for(int j=0; j<arr.length-1;j++){if(arr[j]>arr[j+1]){int temp = arr[j+1];arr[j+1] = arr[j];arr[j] = temp;}}}//以下代码是将数组中的所有元素输出到控制台for(int i=0; i<arr.length; i++){System.out.println(arr[i]);}

4、使用数组的常见问题

4.1、数组下标越界

int arr[] = {1, 9, 7, 4, 0};for(int i=0; i<=6; i++){System.out.println(arr[i]);}

4.2、空指针异常

int arr[] = null;System.out.println(arr[0]);

附录：Java中的经典算法之冒泡排序(Bubble Sort)

原理：比较两个相邻的元素，将值大的元素交换至右端。

思路：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。重复第一趟步骤，直至全部排序完成。

举例说明：要排序数组：int[] arr={6,3,8,2,9,1};   

第一趟排序：

　　　　第一次排序：6和3比较，6大于3，交换位置：  3  6  8  2  9  1

　　　　第二次排序：6和8比较，6小于8，不交换位置：3  6  8  2  9  1

　　　　第三次排序：8和2比较，8大于2，交换位置：  3  6  2  8  9  1

　　　　第四次排序：8和9比较，8小于9，不交换位置：3  6  2  8  9  1

　　　　第五次排序：9和1比较：9大于1，交换位置：  3  6  2  8  1  9

　　　　第一趟总共进行了5次比较，排序结果：      3  6  2  8  1  9

---------------------------------------------------------------------

第二趟排序：

　　　　第一次排序：3和6比较，3小于6，不交换位置：3  6  2  8  1  9

　　　　第二次排序：6和2比较，6大于2，交换位置：  3  2  6  8  1  9

　　　　第三次排序：6和8比较，6大于8，不交换位置：3  2  6  8  1  9

　　　　第四次排序：8和1比较，8大于1，交换位置：  3  2  6  1  8  9

　　　　第二趟总共进行了4次比较，排序结果：      3  2  6  1  8  9

---------------------------------------------------------------------

第三趟排序：

　　　　第一次排序：3和2比较，3大于2，交换位置：  2  3  6  1  8  9

　　　　第二次排序：3和6比较，3小于6，不交换位置：2  3  6  1  8  9

　　　　第三次排序：6和1比较，6大于1，交换位置：  2  3  1  6  8  9

　　　　第二趟总共进行了3次比较， 排序结果：         2  3  1  6  8  9

---------------------------------------------------------------------

第四趟排序：

　　　　第一次排序：2和3比较，2小于3，不交换位置：2  3  1  6  8  9

　　　　第二次排序：3和1比较，3大于1，交换位置：  2  1  3  6  8  9

　　　　第二趟总共进行了2次比较， 排序结果：        2  1  3  6  8  9

---------------------------------------------------------------------

第五趟排序：

　　　　第一次排序：2和1比较，2大于1，交换位置：  1  2  3  6  8  9

　　　　第二趟总共进行了1次比较， 排序结果：  1  2  3  6  8  9

---------------------------------------------------------------------

最终结果：1  2  3  6  8  9

---------------------------------------------------------------------

由此可见：N个数字要排序完成，总共进行N-1趟排序，每i趟的排序次数为(N-i)次，所以可以用双重循环语句，外层控制循环多少趟，内层控制每一趟的循环次数，即

for(int i=1;i<arr.length;i++){    for(int j=1;j<arr.length-i;j++){    //交换位置}    

冒泡排序的优点：每进行一趟排序，就会少比较一次，因为每进行一趟排序都会找出一个较大值。如上例：第一趟比较之后，排在最后的一个数一定是最大的一个数，第二趟排序的时候，只需要比较除了最后一个数以外的其他的数，同样也能找出一个最大的数排在参与第二趟比较的数后面，第三趟比较的时候，只需要比较除了最后两个数以外的其他的数，以此类推……也就是说，没进行一趟比较，每一趟少比较一次，一定程度上减少了算法的量。

代码实现：

 

/* * 冒泡排序 */public class BubbleSort {　　public static void main(String[] args) {　　　　int[] arr={6,3,8,2,9,1};　　　　System.out.println("排序前数组为：");　　　　for(int num:arr){　　　　　　System.out.print(num+" ");　　　　}　　　　for(int i=0;i<arr.length-1;i++){//外层循环控制排序趟数　　　　　　for(int j=0;j<arr.length-1-i;j++){//内层循环控制每一趟排序多少次　　　　　　　　if(arr[j]>arr[j+1]){　　　　　　　　　　int temp=arr[j];　　　　　　　　　　arr[j]=arr[j+1];　　　　　　　　　　arr[j+1]=temp;　　　　　　　　}　　　　　　}　　　　} 　　　　System.out.println();　　　　System.out.println("排序后的数组为："); 　　　　for(int num:arr){ 　　　　　　System.out.print(num+" "); 　　　　} 　　} }