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行。