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