文章目录
一、数组的创建和属性
数组是一种有序数据的集合,数组中的每个元素具有相同的数据类型,Java 中有基本数据类型和引用数据类型两种数据类型。数组就是引用数据类型。,可以用一个统一的数组名和不同的下标来唯一确定数组中的元素。根据数组的维度,可以将其分为一维数组、二维数组和多维数组等。
数组的索引从 0 开始,如果数组有 n 个元素,那么数组的索引是从 0 到(n-1)。
1.一维数组的创建:
首先说一下要想创建一个一维数组需要两步:
- 1.声明一个数组
- 2.分配空间
我们先说第一点,声明数组,声明数组有两种格式:
这里我们看一下数据类型+数组名+[],这里面,数据类型可以是:
- 基本数据类型
- 也可以是引用数据类型
然后数组名可以是任意合法的变量名
[],这个标志就是说明它是一个一维数组
大多数Java程序员喜欢用第二种格式,因为它可以把数据类型和变量名字用[],清晰的分开。
注意点:
- 1.声明数组的时候,不需要规定数组的长度,例如:
int socre[10],这样写是错误的 - 2.在声明数组的时候,千万不要忘记写[],这个标识。
我们再说第二点分配空间:
声明了数组,只是得到了一个存放数组的变量,并没有为数组元素分配内存空间,是不能够去使用的,因此我们要为数组分配内存空间,这样数组的每一个元素才能够进行存储。
我们来看一下分配内存的格式:
当然啦,我们在工作中,通常声明一个数组,不会分为两步,可以直接一步到位,声明加分配空间,格式是这样的:
一维数组的内存格式:
其实声明和分配空间之后,还有一步初始化数组,这里有三种方式:
注意:第二种方式中,[],里面不能写数值。
获取单个元素
获取单个元素的方法非常简单,指定元素所在数组的下标即可
1. int[] number={1,2,3,5,8};
2. System.out.println("获取第一个元素:"+number[0]);
3. System.out.println("获取最后一个元素:"+number[number.length-1]);
4. 输出结果为:
5. 获取第一个元素:1
获取最后一个元素:8
获取全部元素
获取全部元素——使用循环语句。
下面利用 for 循环语句遍历 number 数组中的全部元素,并将元素的值输出。代码如下:
1. int[] number={1,2,3,5,8};
2. for (int i=0;i<number.length;i++)
3. {
4. System.out.println("第"+(i+1)+"个元素的值是:"+number[i]);
5. }
这里的for循环也可以换成增强for循环输出:
6. for(int val:number)
7. {
8. System.out.print("元素的值依次是:"+val+"\t");
9. }
int是变量类型,val是变量名字,number是数组名字。
2.二维数组的创建:
为了方便组织各种信息,计算机常将信息以表的形式进行组织,然后再以行和列的形式呈现出来。
二维数组的结构决定了其能非常方便地表示计算机中的表:
- 第一个下标表示元素所在的行
- 第二个下标表示元素所在的列
下面简单了解一下二维数组,包括数组的声明和初始化。
声明二维数组的语法如下:
这里提供两种初始化的方法:
上述代码创建了一个二行二列的二维数组 temp,并对数组中的元素进行了初始化。图 1 所示为该数组的内存结构。
图1 二维数组内存结构
获取单个元素
获取单个元素的方法非常简单,指定元素所在数组的下标即可
1. public static void main(String[] args)
2. {
3. double[][] class_score={{10.0,99,99},{100,98,97},{100,100,99.5},{99.5,99,98.5}};
4. System.out.println("第二行第二列元素的值:"+class_score[1][1]);
5. System.out.println("第四行第一列元素的值:"+class_score[3][0]);
6. }
执行上述代码,输出结果如下:
第二行第二列元素的值:98.0
第四行第一列元素的值:99.5
获取全部元素
如果要获取二维数组中的全部元素,最简单、最常用的办法就是使用 for 语句。
1. public static void main(String[] args)
2. {
3. double[][] class_score={{100,99,99},{100,98,97},{100,100,99.5},{99.5,99,98.5 }};
4. for(int i=0;i<class_score.length;i++)
5. { //遍历行
6. for(int j=0;j<class_score[i].length;j++)
7. {
8. System.out.println("class_score["+i+"]["+j+"]="+class_score[i][j]);
9. }
10. }
11. }
执行上述代码,输出结果如下所示。
class_score[0][0]=100.0
class_score[0][1]=99.0
class_score[0][2]=99.0
class_score[1][0]=100.0
class_score[1][1]=98.0
class_score[1][2]=97.0
class_score[2][0]=100.0
class_score[2][1]=100.0
class_score[2][2]=99.5
class_score[3][0]=99.5
class_score[3][1]=99.0
class_score[3][2]=98.5
上述代码使用嵌套 for 循环语句输出二维数组。在输出二维数组时,第一个 for 循环语句表示以行进行循环,第二个 for 循环语句表示以列进行循环,这样就实现了获取二维数组中每个元素的值的功能。
3.数组的长度属性:
用数组名.length可以获取数组的长度。
因为数组索引是由0开始的,所以数组最大的索引值为数组名.length-1。
4.比较两个数组是否相等:
数组相等的条件不仅要求数组元素的个数必须相等,而且要求对应位置的元素也相等。Arrays 类提供了 equals() 方法比较整个数组。语法如下:
Arrays.equals(arrayA, arrayB);
举个例子:
5.复制数组的方法:
所谓复制数组,是指将一个数组中的元素在另一个数组中进行复制。
使用 copyOf() 方法和 copyOfRange() 方法
Arrays 类的 copyOf() 方法与 copyOfRange() 方法都可实现对数组的复制。copyOf() 方法是复制数组至指定长度,copyOfRange() 方法则将指定数组的指定长度复制到一个新数组中。
1. 使用 copyOf() 方法对数组进行复制
Arrays 类的 copyOf() 方法的语法格式如下:
Arrays.copyOf(dataType[] srcArray,int length);
其中,(dataType[] srcArray 表示要进行复制的数组,length 表示复制后的新数组的长度。
使用这种方法复制数组时,默认从源数组的第一个元素(索引值为 0)开始复制,目标数组的长度将为 length。如果 length 大于 srcArray.length,则目标数组中采用默认值填充;如果 length 小于 srcArray.length,则复制到第 length 个元素(索引值为 length-1)即止。
举个例子:
在上述代码中,由于源数组 scores 的长度为 5,而要复制的新数组 newScores 的长度为 8,因此在将源数组中的 5 个元素复制完之后,会采用默认值填充剩余 3 个元素的内容。
2.使用 CopyOfRange() 方法对数组进行复制
Arrays 类的 CopyOfRange() 方法是另一种复制数组的方法,其语法形式如下:
Arrays.copyOfRange(dataType[] srcArray,int startIndex,int endIndex)
其中,srcArray 表示源数组;startIndex 表示开始复制的起始索引,目标数组中将包含起始索引对应的元素,另外,startIndex 必须在 0 到 srcArray.length 之间;endIndex 表示终止索引,目标数组中将不包含终止索引对应的元素,endIndex 必须大于等于 startIndex,可以大于 srcArray.length,如果大于 srcArray.length,则目标数组中使用默认值填充。
举个例子:
6.数组查找指定元素:
从数组中查询指定位置的元素,或者查询某元素在指定数组中的位置。使用 Arrays 类的 binarySearch() 方法可以实现数组的查找,该方法可使用二分搜索法来搜索指定数组,以获得指定对象,该方法返回要搜索元素的索引值。
有两种方式查找:
第一种形式如下:
binarySearch(Object[] a,Object key);
其中,a 表示要搜索的数组,key 表示要搜索的值。如果 key 包含在数组中,则返回搜索值的索引;否则返回 -1 或“-插入点”。插入点指搜索键将要插入数组的位置,即第一个大于此键的元素索引。
在进行数组查询之前,必须对数组进行排序(可以使用 sort() 方法)。如果没有对数组进行排序,则结果是不确定的。如果数组包含多个带有指定值的元素,则无法确认找到的是哪一个。
举个例子:
声明 double 类型的 score 数组,接着调用 Arrays 类的 sort() 方法对 score 数组排序,排序后分别查找数组中值为 100 和 60 的元素,分别将结果保存到 index1 和 index2 变量中,最后输出变量的值。代码如下:
第二种形式如下:
binarySearch(Object[] a,int fromIndex,int toIndex,Object key);
其中,a 表示要进行查找的数组,fromIndex 指定范围的开始处索引(包含开始处),toIndex 指定范围的结束处索引(不包含结束处),key 表示要搜索的元素。
**在使用 binarySearch() 方法的上述重载形式时,也需要对数组进行排序,**以便获取准确的索引值。如果要查找的元素 key 在指定的范围内,则返回搜索键的索引;否则返回 -1 或 “-插入点”。插入点指要将键插入数组的位置,即范围内第一个大于此键的元素索引。
举个例子:
这里的-3,因为60没找到,然后我们从第二个位置开始找的,那就第二个位置为基准0,往前是-1,-2,而60比-1位置上的85.5还小,故,它应该放在-3的位置,所以,这里得到-3
7.数组填充:
Arrays 类提供了一个 fill() 方法,可以在指定位置进行数值填充。fill() 方法虽然可以填充数组,但是它的功能有限制,只能使用同一个数值进行填充。语法如下:
Arrays.fill(array,value);
其中,array 表示数组,value 表示填充的值。
举个例子:
8.数组转为字符串:
Arrays.toString(type[] a)方法:
该方法将一个数组转换成一个字符串。该方法按顺序把多个数组元素连缀在一起,多个数组元素使用英文逗号,和空格隔开。
例如:
只不过转为的字符串形式,是个数组的模样的形式。
二、数组的排序
1.sort() 方法排序
使用 Armys.sort(数组名) 语法对数组进行排序,排序规则是从小到大,即升序。
举个例子:
2.冒泡排序(Bubble Sort)
冒泡排序的基本思想是:对比相邻的元素值,如果满足条件就交换元素值,把较小的元素值移动到数组前面,把大的元素值移动到数组后面(也就是交换两个元素的位置),这样数组元素就像气泡一样从底部上升到顶部。
冒泡排序的算法比较简单,排序的结果稳定,但时间效率不太高。Java 中的冒泡排序在双层循环中实现,其中外层循环控制排序轮数,总循环次数为要排序数组的长度减 1。而内层循环主要用于对比相邻元素的大小,以确定是否交换位置,对比和交换次数依排序轮数而减少。
举个例子:
3.快速排序(Quicksort)
快速排序(Quicksort)是对冒泡排序的一种改进。
快速排序的基本思想是:通过一趟排序,将要排序的数据分隔成独立的两部分,其中一部分的所有数据比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此使整个数据变成有序序列。
具体做法是:假设要对某个数组进行排序,首先需要任意选取一个数据(通常选用第一个数据)作为关键数据,然后将所有比它小的数都放到它的前面,所有比它大的数都放到它的后面。这个过程称为一趟快速排序;递归调用此过程,即可实现数据的快速排序。
举个例子:
import java.util.Arrays;
public class test2 {
public static void main(String[] args) {
int[] arr = new int[] { 5, 2, 6, 8, 7, 9 };
quickSort(arr, 0, arr.length - 1);
System.out.println(Arrays.toString(arr));
}
public static void quickSort(int arr[], int left, int right) {
// 递归要求第一步写结束递归的条件
if (left > right) {
return;
}
// 设置基准值是arr[0]
int base = arr[left];
// 保留left和right目的保证下面的递归能正确找到相应位置
int i = left;
int j = right;
// 经行位置移动
while (i != j) {
// 从右往左寻找比基准小的值的下标
while (arr[j] >= base && i < j) {
j--;
}
// 从左往右寻找比基准大的值的下标
while (arr[i] <= base && i < j) {
i++;
}
if (i < j) {
// 将找到的比基准数大的数和比基准数小的数交换
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
// 最后将原来的基准数和当前的i==j索引值进行交换
arr[left] = arr[i];
arr[i] = base;
System.out.println(Arrays.toString(arr));
// 按照刚刚思想,基数两边继续递归
quickSort(arr, left, i - 1);
quickSort(arr, j + 1, right);
}
}
4.选择排序
选择排序是指每一趟从待排序的数据元素中选出最大(或最小)的一个元素,顺序放在已排好序的数列的最后,直到全部待排序的数据元素排完。
选择排序原理为:随机确定一个标志位(一般为第一个数字)作为最小数,然后向后遍历,找到比标志位更小的数便与标志位互换位置并更新最小数,实现步骤为:
- 将数组的第一个数字设置为标志位最小数并记录最小数下标。
- 向后遍历,发现更小数后将该数与标志位互换位置并更新最小数与最小数下标。
- 循环完成排序
举个例子:
public static void main(String[] args){
int int[] arr = new int[]{1,6,8,9,2,3,5,4,7};
for(int i=0;i<arr.length-1;i++){//每次循环都会找出最小的数
int minIndex = i;//记录最小数的下标
int minNum = arr[i];//记录最小数
for(int j=i+1;j<arr.length;j++){//每次循环都会找出最小的数
if(arr[j]<minNum){//如果当前数比最小数小,则更新最小数
minNum = arr[j];//更新最小数
minIndex = j;//更新最小数的下标
}
}
arr[minIndex]=arr[i];//将最小数放到最前面
arr[i]=minNum;//将标志位放到最小数原来所在的位置
}
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]);
}
}
5.直接插入排序
直接插入排序的基本思想是:将 n 个有序数存放在数组 a 中,要插入的数为 x,首先确定 x 插在数组中的位置 p,然后将 p 之后的元素都向后移一个位置,空出 a§,将 x 放入 a§,样可实现插入 x 后仍然有序。
举个例子:
int[] arr={3,2,5,1,4};
for (int i=1;i<arr.length ;i++ )
{
int index = arr[i];//先把操作数取出来
int insertNum = i;//假设要插入的位置是当前位置
for(int j = i-1;j>=0;j--){
if(arr[j]>index){
arr[j+1]=arr[j];//后移,给操作数腾位置
insertNum=j;//记录当前位置
}
if(insertNum!=i){
arr[insertNum]=index;//将操作数插入到排好序的位置
}
}
}
System.out.println(Arrays.toString(arr));
总结
各位小主,如果感觉有一点点帮助到你的话,麻烦留下赞赞一枚哦~