第四章数组总结

何文超哈

已于 2022-04-28 20:13:08 修改

阅读量289

点赞数 1

文章标签： java eclipse 开发语言

于 2022-03-26 16:52:25 首次发布

本文链接：https://blog.csdn.net/qq_65555711/article/details/123718185

版权

1、二维数组可以看做是特殊的一维数组，因此有两种声明方式：

使用 copyOf() 方法和 copyOfRange() 方法

使用 CopyOfRange() 方法对数组进行复制

4.1数组的概述

数组是具有相同数据类型的一组数据的集合。在某些情况下，虽然可以使用单个变量来存储信息，但是如果需要存储的信息较多（例如存储 50 名学生的成绩），这时再依次创建变量声明并赋值显得非常麻烦。

随着处理的信息量越来越大，工作也就越来越烦琐，这时可以使用数组或集合来存储信息。通过使用数组，可以在很大程度上缩短和简化程序代码，从而提高应用程序的效率。

数组（array）是一种最简单的复合数据类型，它是有序数据的集合，数组中的每个元素具有相同的数据类型，可以用一个统一的数组名和不同的下标来确定数组中唯一的元素。根据数组的维度，可以将其分为一维数组、二维数组和多维数组等。

在计算机语言中数组是非常重要的集合类型，大部分计算机语言中数组具有如下三个基本特性：
一致性：数组只能保存相同数据类型元素，元素的数据类型可以是任何相同的数据类型。
有序性：数组中的元素是有序的，通过下标访问。
不可变性：数组一旦初始化，则长度（数组中元素的个数）不可变。
总的来说，数组具有以下特点：
数组可以是一维数组、二维数组或多维数组。
数值数组元素的默认值为 0，而引用元素的默认值为 null。
数组的索引从 0 开始，如果数组有 n 个元素，那么数组的索引是从 0 到（n-1）。
数组元素可以是任何类型，包括数组类型。
数组类型是从抽象基类 Array 派生的引用类型。

注意：如果你熟悉 C/C++，请注意，Java 数组的工作原理与它们不同。
在 Java 中数组的下标是从零开始的，很多计算机语言的数组下标也从零开始。Java 数组下标访问运算符是中括号，如 intArray[0]，表示访问 intArray 数组的第一个元素，0 是第一个元素的下标。Java 中的数组本身是引用数据类型，它的长度属性是 length。

4.2一维数组

指的是一组相同数据类型的线性集合。

4.2.1 创建并使用一维数组

1、创建一维数组

int arr[];//声明int型数组，数组的每个元素都是int型数值
double arr[];//声明double型数组，数组的每个元素都是double型数值

2、分配数组的内存空间

数组名字 = new 数组元素类型 [数组元素的个数];
arr = new int [5];//数组长度为五

3、初始化一维数组

int a [] = {1,2,3};//定义一维数组
int b [] = new int[] {4,5,6};//用new方法新建一维数组
int c [] = new int[3];//新建数组
c[0] = 7;//给第一个值赋值
c[1] = 8;//赋值
c[2] = 9;//给下标为2 的变量赋值

4、获取数组长度

arrayName[index];其中，arrayName 表示数组变量，index 表示下标，下标为 0 表示获取第一个元素，下标为 array.length-1 表示获取最后一个元素。当指定的下标值超出数组的总长度时，会拋出 Array异常。

package javaProject001;

public class wwwwww {

	public static void main(String[] args) {
		char a[] = {'A','B','c','D'};
		System.out.println("数组a长度为" + a.length);
		char b[] = a;
		System.out.println("数组b的长度为" + b.length);
		
	}

}

运行结果如下：

5、使用一维数组

 
import java.util.Scanner;//引入方法
public class Test {//创建类
    public static void main(String[] args) {//主方法
        int[] prices = new int[5]; // 声明数组并分配空间
        Scanner input = new Scanner(System.in); // 接收用户从控制台输入的数据
        for (int i = 0; i < prices.length; i++) {
            System.out.println("请输入第" + (i + 1) + "件商品的价格：");
            prices[i] = input.nextInt(); // 接收用户从控制台输入的数据
        }
        System.out.println("第 3 件商品的价格为：" + prices[2]);
    }
}

运行结果如下：

package shuzutask1;

public class qazxswedc {

	public static void main(String[] args) {
		int day[] = new int[] {31,28,31,30,31,30,31,31,30,31,30,31};
		for (int i=0;i<12;i++)
			System.out.println((i+1)+"月有"+ day[i] +"天");
		

	}

}

运行结果如下：

4.3 二维数组

在 Java 中二维数组被看作数组的数组，即二维数组为一个特殊的一维数组，其每个元素又是一个一维数组。Java 并不直接支持二维数组，但是允许定义数组元素是一维数组的一维数组，以达到同样的效果。

4.3.1 创建并使用二维数组

1、二维数组可以看做是特殊的一维数组，因此有两种声明方式：

int a [] [];
a = new int [2] [34];//直接分配行列
int b [] [];
int b = new int [2] [];//先分配行，不分配列
b[0] = new int [2];//给第一行分配列
b[1] = new int [2];//给第二列分配列

注意：创建二维数组的时候，只可以声明行的长度，而不声明列的长度。

2、初始化二维数组

package boketask;

public class eg1 {

	public static void main(String[] args) {
		int taderr1 [] [] = {{1,2,5},{5,7,9}};
		int tader2 [] [] = new int [] [] {{65,55,12},{97,65,312}};
		int tader3 [] [] = new int [2][3];//先给数组分配内存空间
		tader3[0] = new int [] {78,88,66};//给第一行分配一个一维数组
		tader3[1][0] = 64;//第二行第一列赋值
		tader3[1][1] = 21;//第二行第二列赋值
		tader3[1][2] = 19;//第二行第三列赋值
	}

}

3、使用二维数组

package shuzutask1;//包名

public class asdfdfdfdf {//创建类

	public static void main(String[] args) {//主方法
		char arr[][] = new char[4][];//创建一个四行的二维数组
		arr[0]= new char[] {'春','眠','不','觉','晓'};//给数组赋值
		arr[1]= new char[] {'处','处','闻','啼','鸟'};//给数组赋值
		arr[2]= new char[] {'夜','来','风','雨','声'};//给数组赋值
		arr[3]= new char[] {'花','落','知','多','少'};//给数组赋值
		for (int i = 0;i<arr.length;i++) {//循环四行
			for (int j = 0;j<5;j++) {循环五列
				System.out.print(arr[i][j]);}//输出数组
				if(i%2==0) {
					System.out.println(",");}//如果1、3句输出逗号
				else
				{System.out.println("。");//如果2、4句输出句号
				}
			}
		System.out.println("---------------------------------------");//输出一段横线
		
		for (int j=0;j<5;j++) {//列变行
			for(int i=3;i>=0;i--) {//行变列，反序输出
				System.out.print(arr[i][j]);//输出数组
			}
			System.out.println();//换行
			}
		
	System.out.println("。，。，");//输出标点符号
	

	}}

运行结果如下：

4、遍历数组：

Java 的数组要求所有的数组元素具有相同的数据类型。因此，在一个数组中，数组元素的类型是唯一的，即一个数组里只能存储一种数据类型的数据，而不能存储多种数据类型的数据。

因为 Java 语言是面向对象的语言，而类与类之间可以支持继承关系（从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为），这样可能产生一个数组里可以存放多种数据类型的假象。例如有一个水果数组，要求每个数组元素都是水果，实际上数组元素既可以是苹果，也可以是香蕉（苹果、香蕉都继承了水果，都是一种特殊的水果），但这个数组的数组元素的类型还是唯一的，只能是水果类型。

一旦数组的初始化完成，数组在内存中所占的空间将被固定下来，因此数组的长度将不可改变。即使把某个数组元素的数据清空，但它所占的空间依然被保留，依然属于该数组，数组的长度依然不变。

Java 的数组既可以存储基本类型的数据，也可以存储引用类型的数据，只要所有的数组元素具有相同的类型即可。

值得指出的是，数组也是一种数据类型，它本身是一种引用类型。例如 int 是一个基本类型，但 int[]（这是定义数组的一种方式）就是一种引用类型了。

int[] 是一种类型吗？怎么使用这种类型呢？

没错，int[] 就是一种数据类型，与 int 类型、String 类型相似，一样可以使用该类型来定义变量，也可以使用该类型进行类型转换等。使用 int[] 类型来定义变量、进行类型转换时与使用其他普通类型没有任何区别。int[] 类型是一种引用类型，创建 int[] 类型的对象也就是创建数组，需要使用创建数组的语法。

package shuzutask1;
import java.util.Arrays;
public class mnbnbnbnbnb {

	public static void main(String[] args) {
		int arr[] =new int[] {45,12,2,77,31,91,10};
		Arrays.fill(arr, 1,4,100);
		for (int i=0;i<arr.length;i++) {
		System.out.println("第"+i+"个元素是："+arr[i]);}
	}

}

5、复制数组

在 Java 中实现数组复制分别有以下 4 种方法：
Arrays 类的 copyOf() 方法
Arrays 类的 copyOfRange() 方法
System 类的 arraycopy() 方法
Object 类的 clone() 方法

使用 copyOf() 方法和 copyOfRange() 方法

srcArray 表示要进行复制的数组，length 表示复制后的新数组的长度。

使用这种方法复制数组时，默认从原数组的第一个元素（索引值为 0）开始复制，目标数组的长度将为 length。如果 length 大于 srcArray.length，则目标数组中采用默认值填充；如果 length 小于 srcArray.length，则复制到第 length 个元素（索引值为 length-1）即止。

注意：目标数组如果已经存在，将会被重构。

package boketask;
import java.util.Arrays;
public class boletask2 {

	public static void main(String[] args) {
		int arr[] = new int[] {23,43,54,32,564};//定义数组
		int newarr[] = Arrays.copyOfRange(arr,0,3);//复制数组
		for(int i = 0;i<newarr.length;i++) {//循环遍历赋值后的数组
			System.out.println(newarr[i]);//将新的数组中的元素输出
		}

	}

}

运行结果如下：

import java.util.Arrays;//引入方法
public class Test19{//创建类
    public static void main(String[] args) {//主方法
        // 定义长度为 5 的数组
        int scores[] = new int[]{57,81,68,75,91};
        // 输出原数组
        System.out.println("原数组内容如下：");
        // 循环遍历原数组
        for(int i=0;i<scores.length;i++) {
            // 将数组元素输出
            System.out.print(scores[i]+"\t");
        }
        // 定义一个新的数组，将 scores 数组中的 5 个元素复制过来
        // 同时留 3 个内存空间供以后开发使用
        int[] newScores = (int[])Arrays.copyOf(scores,8);
        System.out.println("\n复制的新数组内容如下：");
        // 循环遍历复制后的新数组
        for(int j=0;j<newScores.length;j++) {
            // 将新数组的元素输出
            System.out.print(newScores[j]+"\t");
        }
    }
}

运行结果如下：

使用 CopyOfRange() 方法对数组进行复制

srcArray 表示原数组。
startIndex 表示开始复制的起始索引，目标数组中将包含起始索引对应的元素，另外，startIndex 必须在 0 到 srcArray.length 之间。
endIndex 表示终止索引，目标数组中将不包含终止索引对应的元素，endIndex 必须大于等于 startIndex，可以大于 srcArray.length，如果大于 srcArray.length，则目标数组中使用默认值填充。

注意：目标数组如果已经存在，将会被重构。

public class Test20 {//创建类
    public static void main(String[] args) {//主方法
        // 定义长度为8的数组
        int scores[] = new int[] { 57, 81, 68, 75, 91 };
        System.out.println("原数组内容如下：");
        // 循环遍历原数组
        for (int i = 0; i < scores.length; i++) {
            System.out.print(scores[i] + "\t");
        }
        // 复制原数组的前5个元素到newScores数组中
        int newScores[] = (int[]) Arrays.copyOfRange(scores, 0, 5);
        System.out.println("\n复制的新数组内容如下：");
        // 循环遍历目标数组，即复制后的新数组
        for (int j = 0; j < newScores.length; j++) {
            System.out.print(newScores[j] + "\t");
        }
    }
}

运行结果如下：

使用 arraycopy() 方法

srcArray 表示原数组；srcIndex 表示原数组中的起始索引；destArray 表示目标数组；destIndex 表示目标数组中的起始索引；length 表示要复制的数组长度。

使用此方法复制数组时，length+srcIndex 必须小于等于 srcArray.length，同时 length+destIndex 必须小于等于 destArray.length。

注意：目标数组必须已经存在，且不会被重构，相当于替换目标数组中的部分元素。

public class Test21 {//创建类
    public static void main(String[] args) {//主方法
        // 定义原数组，长度为8
        int scores[] = new int[] { 100, 81, 68, 75, 91, 66, 75, 100 };
        // 定义目标数组
        int newScores[] = new int[] { 80, 82, 71, 92, 68, 71, 87, 88, 81, 79, 90, 77 };
        System.out.println("原数组中的内容如下：");
        // 遍历原数组
        for (int i = 0; i < scores.length; i++) {
            System.out.print(scores[i] + "\t");
        }
        System.out.println("\n目标数组中的内容如下：");
        // 遍历目标数组
        for (int j = 0; j < newScores.length; j++) {
            System.out.print(newScores[j] + "\t");
        }
        System.arraycopy(scores, 0, newScores, 2, 8);
        // 复制原数组中的一部分到目标数组中
        System.out.println("\n替换元素后的目标数组内容如下：");
        // 循环遍历替换后的数组
        for (int k = 0; k < newScores.length; k++) {
            System.out.print(newScores[k] + "\t");
        }
    }
}

运行结果如下：

使用 clone() 方法

clone() 方法也可以实现复制数组。该方法是类 Object 中的方法，可以创建一个有单独内存空间的对象。因为数组也是一个 Object 类，因此也可以使用数组对象的 clone() 方法来复制数组。

public class Test22 {//创建类
    public static void main(String[] args) {//主方法
        // 定义原数组，长度为8
        int scores[] = new int[] { 100, 81, 68, 75, 91, 66, 75, 100 };
        System.out.println("原数组中的内容如下：");
        // 遍历原数组
        for (int i = 0; i < scores.length; i++) {
            System.out.print(scores[i] + "\t");
        }
        // 复制数组，将Object类型强制转换为int[]类型
        int newScores[] = (int[]) scores.clone();
        System.out.println("\n目标数组内容如下：");
        // 循环遍历目标数组
        for (int k = 0; k < newScores.length; k++) {
            System.out.print(newScores[k] + "\t");
        }
    }
}

运行结果如下：

4.5数组的排序

4.51.冒泡排序

冒泡排序（Bubble Sort）是常用的数组排序算法之一，它以简洁的思想与实现方法而备受青睐，也是广大学习者最先接触的一种排序算法。

冒泡排序的基本思想是：对比相邻的元素值，如果满足条件就交换元素值，把较小的元素值移动到数组前面，把大的元素值移动到数组后面（也就是交换两个元素的位置），这样数组元素就像气泡一样从底部上升到顶部。

冒泡排序的算法比较简单，排序的结果稳定，但时间效率不太高。Java 中的冒泡排序在双层循环中实现，其中外层循环控制排序轮数，总循环次数为要排序数组的长度减 1。而内层循环主要用于对比相邻元素的大小，以确定是否交换位置，对比和交换次数依排序轮数而减少。

package javaProject001;//包名
public class BubbleSort {//创建类
	
			public void sort(int[] array) {
				for(int i = 1;i<array.length;i++)
				{for (int j=0;j<array.length-i;j++) {//比较相邻的两个元素，较大的数往后冒泡
					if (array[j]>array[j+1]) {//如果前者比后者大则互换位置
						int temp = array[j];//把第一个元素的值保存到临时变量中
						array[j]=array[j+1];//把第二个元素值保存到第一个元素单元中
						array[j+1]=temp;}//把临时变量（第一个元素的值）保存到第二个元素中
						
					}
				}
			showArray(array);}//输出冒泡后的数组元素
			public void showArray(int[] array) {
				System.out.println("冒泡排序结果：");
				for (int i :array) {//遍历数组
					System.out.println(i+" ");//输出内容
					
				}
				System.out.println();//换行
				
			}
				
		public static void main(String[] args) {//主方法
				int[] array = {63,3,12,45,54,87,21};//新建无序的数组
				BubbleSort sorter = new BubbleSort();//调用排序方法进行排序
				sorter.sort(array);//输出内容
				
				
		}

	}

运行结果如下：

4.52 排序选择

使用选择排序法也可以对上述数组中的元素进行排序，但是它与冒泡排序不同。选择排序是指每一趟从待排序的数据元素中选出最大（或最小）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。

package javaProject001;//包名

public class SelectSort {//创建类
	public void sort(int[] array) {//定义方法
		int index;//int型变量
		for(int i=1;i<array.length;i++) {//for循环遍历数组
			index =0;//给变量赋值
			for(int j=1;j<=array.length - i;j++) {
				if (array[j] > array[index]) {//如果前一个元素比后一个元素大则位置互换
					index = j;}}//交换位置
					int temp = array[array.length-i];
					array[array.length-i] = array[index];
					array[index] = temp;}
				showArray(array);//输出直接选择排序的数组值
				}
			public void showArray(int[] array) {
				System.out.println("选择排序结果为：");
				for (int i : array) {//遍历数组
					System.out.println(i + " ");//输出
				}
				System.out.println();//换行
			}
			
	public static void main(String[] args) {//主方法
			int[] array = {23,1,55,99,56,45,32};//创建无序的数组
			SelectSort sorter = new SelectSort();//调用排序对象将数组排序
			sorter.sort(array);//输出数组
	}

}

运行结果如下：

4.53 Array.Sort()方法

Array，Sort（object）//object类

升序

public static void main(String[] args) {//主方法
    // 定义含有5个元素的数组
    double[] scores = new double[] { 78, 45, 85, 97, 87 };
    System.out.println("排序前数组内容如下：");
    // 对scores数组进行循环遍历
    for (int i = 0; i < scores.length; i++) {
        System.out.print(scores[i] + "\t");
    }
    System.out.println("\n排序后的数组内容如下：");
    // 对数组进行排序
    Arrays.sort(scores);
    // 遍历排序后的数组
    for (int j = 0; j < scores.length; j++) {
        System.out.print(scores[j] + "\t");
    }
}

运行结果如下：

降序

利用 Collections.reverseOrder() 方法//包装类

package boketask;//包名
import java.util.Arrays;//引入方法
public class boketask3 {//创建类

	public static void main(String[] args) {//主方法
		int arr[] = new int [] {23,34,454,56};//new方法新建数组
		Arrays.sort(arr);//将数组进行排序
		System.out.println("排序后结果为：");//输出内容
		for (int i = 0; i<arr.length;i++) {//for循环遍历数组
			System.out.println(arr[i]+"");//输出内容
		}

	}

}

运行结果如下：

总结：

学完这章，了解到数组是一个用来存放数据信息的一个空间，它具有一致性、有序性和不可变性，

就像是一箱苹果，里面都是同一品种的，并且依次都贴上有规律序号的标签，当封好拿出去卖的时候就不能改变苹果的个数和顺序了。当然，如果需要特定的则需要引用一些方法去达到理想效果。

何文超哈

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第四章数组总结

目录4.1数组的概述4.2一维数组4.2.1 创建并使用一维数组1、创建一维数组2、分配数组的内存空间3、初始化一维数组4、获取数组长度5、使用一维数组4.1数组的概述数组是具有相同数据类型的一组数据的集合。4.2一维数组指的是一组相同数据类型的线性集合。4.2.1 创建并使用一维数组1、创建一维数组int arr[];//声明int型数组，数组的每个元素都是int型数值double arr[];//声明double型数组，数组的每个元素都
复制链接

扫一扫