Java基础——数组

一、Java数组概述

数组是一种引用数据类型，是对象集合，存储相同数据类型的一组数据，比如几个学生的成绩可以只用变量来声明存储，但是一个班的成绩使用单个变量来定义存储就过于麻烦，声明一个数组来存储这组数据，无疑是最好的选择，然后通过数组元素的索引来访问数组元素。

二、数组的初始化

1. 声明数组：数据类型 [] 数组名，例：int [] a;
2. 分配空间：a=new int[5];//分配5个int类型的的空间；
3. 赋值：a[0]=8;//没有赋值的话数组默认为零；数组的下标从零开始
4. 处理数据：a[0]=a[0]*10;
   综上所述，数组初始化有两种：int [] a=new int [10]定义数组并为其分配空间，int [] a={1,2,3,4},声明数组并为其元素赋值，元素之间用逗号隔开
5. 数组的属性：

• 数组的长度用length表示，即数组的空间有多少个，访问时通过数组名.length即可访问长度
• 一旦数组的初始化完成，数组在内存中所占的空间将被固定下来，因此数组的长度将不可改变。即使把某个数组元素的数据清空，但它所占的空间依然被保留，依然属于该数组，数组的长度依然不变。
• 数组的初始化规则：
  若数组的值未定义，它将被系统默认为：

|数组类型| int |long|float|double|char|boolean|byte
|–|–|-|-|-|-|-|-|-|-|
| 值 | 0 |0|0.0|0.0|空|false|0|||

三、数组元素的遍历

public class Test {
   public static void main(String args[]){
	   int [] a={1,3,5,4,2};//空间为5的数组
	   for(int i=0;i<a.length;i++){
	   System.out.print(a[i]+"\t");
	   }
   }
}

运行结果

实现数组元素的打印输出

四、求数组的最值

下面一个简单的例子求各学生成绩的最大值

import java.util.Scanner;//使用扫描仪
public class shuzu_1 {
	public static void main(String[] args){
		Scanner in=new Scanner(System.in);
		int[] arr=new int[5];//申明空间为5的int数组
		for(int i=0;i<arr.length;i++){//使用for循环来提取数组元素
			System.out.println("请输入第"+(i+1)+"个学生的成绩");//键盘输入数字
			arr[i]=in.nextInt();//将输入的数字赋值给数组的元素
		}
		int max=arr[0];
		for(int i=0;i<arr.length;i++){
			if(max<arr[i]){
			max=arr[i];//数组元素间比较最大值
			}
		} 
		System.out.println("最大值为："+max);
	}
}

运行结果

五、数组的冒泡排序

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

例：将数组中一推数据实现从小到大排序输出

public class Test {
	public static void main(String[] args){
		int[] arr={9,7,8,6,5,4,3,2,1};
		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 t=arr[j];		//将大的元素赋给t
					arr[j]=arr[j+1];	//将小的元素往前排序
					arr[j+1]=t;			//将大的元素往后面排序
				}//然后j自增，实现第二个元素和第三个元素的排序，直至第一轮排序完成实现最小元素排在第一个位置
			}//外层循环控制排序趟数
		}
		for(int i=0;i<arr.length;i++){
			System.out.println(arr[i]);//已排序好后输出
		}
	}
}//若需要从大到小排序，则需要将式子改为arr[j]<arr[j+1];

六、数组的选择排序

选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小(或最大)的一个元素，存放在序列的起始位置，将剩下的元素和它作比较，直到全部待排序的数据元素排完。

public class Test {
    public static void main(String[] args) {
        int[] arr={1,3,2,45,65,33,12};
        System.out.println("排序之前：");
        for(int num:arr){
            System.out.print(num+" ");
        }        
        //选择排序的优化
        for(int i = 0; i < arr.length - 1; i++) {// 做第i趟排序
            int k = i;
            for(int j = k + 1; j < arr.length; j++){// 选最小的记录
                if(arr[j] < arr[k]){ 
                    k = j; //记下目前找到的最小值所在的位置
                }
            }
            //在内层循环结束，也就是找到本轮循环的最小的数以后，再进行交换
            if(i != k){  //交换a[i]和a[k]
                int temp = arr[i];
                arr[i] = arr[k];
                arr[k] = temp;
            }    
        }
        System.out.println();
        System.out.println("排序之后：");
        for(int num:arr){
            System.out.print(num+" ");
        }
    }

}

运行结果

冒泡排序与选择排序的特点与区别：
（1）冒泡排序是比较相邻位置的两个数，而选择排序是按顺序比较，找最大值或者最小值；

（2）冒泡排序每一轮比较后，位置不对都需要换位置，选择排序每一轮比较都只需要换一次位置；

（3）冒泡排序是通过数去找位置，选择排序是给定位置去找数；

冒泡排序优缺点：

• 优点:比较简单，空间复杂度较低，是稳定的；
• 缺点:时间复杂度太高，效率慢；

选择排序优缺点：

• 优点：一轮比较只需要换一次位置；时间复杂度低
• 缺点：不稳定性

七、多维数组（理解）

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组，例如：
String str[][] = new String[3][4];
多维数组的动态初始化（以二维数组为例）

1. 直接为每一维分配空间，格式如下：

例如：

int a[][] = new int[2][3];
解析：

二维数组 a 可以看成一个两行三列的数组。

2. 从最高维开始，分别为每一维分配空间，例如：

String s[][] = new String[2][];
s[0] = new String[2];
s[1] = new String[3];
s[0][0] = new String(“Good”);
s[0][1] = new String(“Luck”);
s[1][0] = new String(“to”);
s[1][1] = new String(“you”);
s[1][2] = new String(“!”);
解析：

s[0]=new String[2] 和 s[1]=new String[3] 是为最高维分配引用空间，也就是为最高维限制其能保存数据的最长的长度，然后再为其每个数组元素单独分配空间 s0=new String(“Good”) 等操作。