Java中 數組的應用及數組常用算法應用

前言

        數組（Array）是相同類型數據的有序集合。數組描述的是相同類型的若干個數據，按照一定的先後次序排列組合而成。其中，每一個數據稱作一個元素，每個元素可以通過一個索引(下標)來訪問它們。

一. 創建數組

  1.1 先聲明，在用new進行分配空間

    1.1.1 聲明

聲明時，[中括號] 可以寫在數據類型後面，也可以寫在數組名後面.

	//一維數組
	int[] array;		
	String[] list;
	
	/*語法：
	    數據類型[] 數組名;		
	    數據類型 數組名[][];
	*/

    1.1.2 分配空間

用 new關鍵字 給數組進行分配空間.

	//一維數組
	array=new int[6];
	
	/*語法：
		數組名=new 數組類型[數組長度];
	*/		

    1.1.3 聲明的同時爲數組分配內存

	//一維數組
	int[] list = new int[6]
	
	/*語法
		數據類型[] 數組名=new 數據類型[數組長度];
	*/

    1.1.4 初始化

	//賦值
	list[0]=90;
	list[1]=99;
	.....
	list[list.lenght-1]=66;
	
	/*語法
		數組名[下標值]=數值;
	*/

  1.2 聲明的同時，直接賦值

	//直接賦值
	int[] list1 = new int[]{1,2,3,4,5,6,7,8,9};
	int[] list2 = {1,2,3,4,5,6,7,8,9};	
	
	/*語法：
		1.數據類型[] 數組名 =  new 數據類型[] {值1,值2,值3,......,值n};
		2.數據類型[] 數組名 = {值1,值2,值3,......,值n};
	*/

二. 遍歷數組

  2.1 獲取數組的長度

	int[] list =new int[5];	//聲明一個數組長度爲5
	int b=list.length;		//獲取數組的長度
	
	/*語法
		數組名.length;
	*/	

  2.2 數組遍歷的兩種方式

    2.2.1 for循環遍歷

	//創建數組
	int[] list = new int[]{1,2,3,4,5,6,7,8,9};		
	//遍歷數組    注意：數組下標從0開始
	for(int i=0;i<list.length;i++){
		System.out.print(list[i]+" ");
	}

    2.2.2 for-each循環遍歷

	//創建數組
	int[] list = new int[]{1,2,3,4,5,6,7,8,9};
	//遍歷數組   
	for(int i:list){
		System.out.print(i+" ");
	}

for與for-each的使用可以參考：https://blog.csdn.net/qq_43636251/article/details/103271458

三. 數組的使用

  3.1 使用Arrays.sort()進行數組排序

	import java.util.Arrays;	//引用util裏的Arrays包；
	public class ArraySort{
		public static void main(String[] args){
			//聲明數組
			int[] list=new int[]{1,53,34,65,23,76,5,74,37};
			
			//遍歷數組
			System.out.print("原數組：");
			for(int i:list){
				System.out.print(i+" ");
			}
		
			//升序排序
			Arrays.sort(list);
			System.out.print("\n升序排序後：");
			for(int j:list){
				System.out.print(j+" ");
			}
			
			/*語法
			引用排序類包：  import java.util.Arrays;
			使用：Arrays.sort(對象名);
			
			Arrays:類
			sort()：方法
			*/
			
		}
	}

  3.2 使用compareToIgnoreCase()進行字符串判斷

public class StringCase{
	public static void main(){
		//創建數組
		String name1 = "abcd";
		String name2 = "bade";
		//判斷		
		if(name1.compareToIgnoreCase(name2)>0){
			System.out.println(name1+"大於name2");
		}
		
		/*語法：字符串1.compareToIgnoreCase(字符串2)>0;
				如果 String1>String2;  	返回值 1;
				如果 String1<String2;	返回值 -1;
				如果 String1==String2;	返回值 0;
		*/
	}
}

  3.3 向數組中的插入元素

import java.util.Scanner;
public class Insert{
	public static void main(String[] args){
		//定義一個數組
		int[] array = new int[]{99,85,82,63,61};
		
		//在定義一個數組，該數組是原數組的長度+1
		int[] list = new int[array.length+1];
		
		//循環賦值
		for(int i=0;i<array.length;i++){
			list[i]=array[i];	
		}

		//創建下標
		int index=list.length;
		
		//插入數字
		Scanner input = new Scanner(System.in);
		System.out.print("請輸入要插入的數字：");
		int insert = input.nextInt();
	
		//從大到小排序，找到該數字下標的位置
		for(int k=0;k<list.length;k++){
			if(list[k]<insert){
				index=k;
				break;	
			}
		}
		
		//元素後移
		for(int j=list.length-1;j>index;j--){
			list[j]=list[j-1];	
		}
		
		//元素賦值
		list[index]=insert;
		//輸出下標
		System.out.println("該數字的下標爲："+index);
		//輸出數組
		System.out.print("插入後的元素爲：");
		for(int n:list){
			System.out.print(n+" ");	
		}
	}

}

  3.4 冒泡排序

口訣：
外層循環n-1;
內層循環n-1-i;
兩兩比較做交換;

升序排序：    判斷：list[j]>list[j+1];
降序排序：   判斷：list[j]<list[j+1];

	public class BubbleSort{
		public static void main(String[] args){
			//創建數組
			int[] list = new int[]{12,45,23,54,34,65,76,24,87,46};
			//輸出當前數組
			System.out.print("原數組：");
			for(int i:list){
				System.out.print(i+" ");
			}
			
			//進行冒泡排序升序排序
			
			
			for(int i=0;i<list.length-1;i++){		//外層循環n-1,控制比較輪數
				for(int j=0;j<list.length-i-1;j++){	//內層循環n-1-i,控制每次比較的次數
						//判斷
						if(list[j]>list[j+1]){		//兩兩比較做交換，判斷大小交換位置
							//交換
							int swop=list[j];
							list[j]=list[j+1];
							list[j+1]=swop;
						}
				}	
			}
			
			//輸出數組
			System.out.print("\n升序排序後：");
			for(int i:list){
				System.out.print(i+" ");	
			}
		}
	}

  3.5 數組的複製

public class ArrayCopy {
	public static void main(String[] args) {
		//聲明數組
		String[] name = new String[] {"a","b","c","d","e","f","g"};
		
		//新建一個數組
		String[] list = new String[name.length];
		//數組的複製
		for(int i=0;i<name.length;i++) {
			list[i]=name[i];
		}
	}
}

  3.6 元素反轉

public class ArrayReversal{
	public static void main(String[] args){
		//創建數組
		int[] list = new int[]{1,2,3,4,5,6};
		
		//元素反轉 
		//方式一
		for(int i=0;i<list.length/2;i++){
			int copy = list[i];
			list[i]=list[list.length-i-1];
			list[list.length-i-1]=copy;	
		}
		
		//方式二：
		for(int i=0,j=list.length-1;i<j;i++;j--){{
			int copy = list[i];
			list[i]=list[j];
			list[j]=copy;	
		}
	}

}

  3.7 線性查找

public class Find {
	public static void main(String[] args) {
		//聲明數組
		String[] name = new String[] {"a","b","c","d","e","f","g"};
		//線性查找
		String dest = "d";
		boolean isFlag = false;
		//循環判斷
		for(int i=0;i<name.length;i++) {
			//判斷是否存在
			if(dest.equals(name[i])) {
				System.out.println("找到了指定的元素,位置爲："+i);
				isFlag = true;
				break;
			}
		}
		//不存在
		if(isFlag=false) {
			System.out.println("沒有這個數字");
		}
	}
}

  3.7 二分法查找

import java.util.Scanner;
public class Find{
	public static void main(String[] args){
		//創建輸入對象
		Scanner input=new Scanner(System.in);
		
		//二分法查找：所有查詢的數組必須有序。
		
		//創建數組
		int[] list = new int[] {-54,-12,2,23,67,79,105,210,333};
		//查找數字
		System.out.print("請輸入要查詢的數字：");
		int num = input.nextInt();
		int head = 0;				//初始化首索引
		int end = list.length-1;	//初始化未索引
		boolean isFlag = true;
		//循環
		while(head <= end){
			int middle = (head+end)/2;
			if(num==list[middle]){
				System.out.println("找到了指定的元素，位置爲："+middle);
				isFlag=false;
				break;	
			}else if(num < list[middle]){
				end = middle-1;
			}else{
				head = middle+1;
			}
		}
		//判斷是否存在
		if(isFlag){
			System.out.println("沒有改元素！");
		}
		
	}
}

四. Arrays常用的工具類

序號	代碼	描述
1	boolean equals(int[] a,int[] b)	判斷兩個數組是否相等。
2	String toString(int[] a)	輸出數組信息。
3	void fill(int[] a,int val)	將指定值填充到數組之中。
4	void sort(int[] a)	對數組進行排序
5	int binarySearch(int[] a,int key)	對排序後的數組進行二分法檢索指定的值。

五. 數組元素的默認初始化值

數組元素類型	元素默認初始值
byte	0
short	0
int	0
long	0L
float	0.0F
double	0.0
char	0 或寫爲:’\u0000’(表現爲空)
boolean	false
引用數據類型	null

六. 數組中常見的錯誤

  6.1 數組越界以及錯誤的位置

控制檯打印出了“java.lang.ArrayIndexOutOfBoundsException”，意思是數組下標超過範圍，即數組越界。
“Error Demo05.java: 13”，指出了出錯的位置，這裏是程序第13行。