Java-数组
勤能补拙
文章持续更新，可以微信搜索【小奇JAVA面试】第一时间阅读，回复【资料】获取福利，回复【项目】获取项目源码，回复【简历模板】获取简历模板，回复【学习路线图】获取学习路线图。
前言
数组是最为常见的一种数据结构，是相同类型的、用一个标识符封装到一起的基本类型数据序列或对象序列。可以用一个统一的数组名和下标来唯一确定数组中的元素。实质上，数组是一个简单的线性序列，因此访问速度很快。
一、数组概述
数组是具有相同数据类型的一组数据的集合。例如，球类的集合-足球、篮球、羽毛球等；电器集合-电视机、洗衣机、电风扇等。在程序设计中，可以将这些集合称为数组。数组中的每个元素具有相同的数据类型。在Java中同样将数据看作一个对象，虽然基本数据类型不是对象，但由基本数据类型组成的数组却是对象。在程序设计中引入数组可以更有效地管理和处理数据。可根据数组的维数将数组分为一维数组、二维数组。。。
二、一维数组的创建及使用
一维数组实质上是一组相同类型数据的线性集合，当在程序中需要处理一组数据，或者传递一组数据时，可以应用这种类型的数组。
1、创建一维数组
数组作为对象允许使用new关键字进行内存分配。在使用数组之前， 必须首先定义数组变量所属的类型。一维数组的创建有两种形式。
1、先声明，再用new运算符进行内存分配
声明一维数组有下列两种方式：
数组元素类型 数组名字[]；
数组元素类型[] 数组名字；
数组元素类型决定了数组的数据类型。它可以是Java中任意的数据类型，包括简单类型和组合类型。数组名字为一个合法的标识符，符号“[]”指明该变量是一个数组类型变量。单个“[]”表示要创建的数组是一个一维数组。
声明一位数组，实例代码如下：
int arr[]; //声明int型数组，数组中的每个元素都是int型数值
String str[]; //声明String数组，数组中的每个元素都是String型数值
- 1
- 2
声明数组后，还不能立即访问它的任何元素，因为声明数组只是给出了数组名字和元素的数据类型，要想真正使用数组，还要为它分配内存空间。在为数组分配内存空间时必须指明数组的长度。为数组分配内存空间的语法格式如下：
数组名字 = new 数组元素的类型[数组元素的个数];
- 1
例如：
arr = new int[5];
- 1
2、声明的同时为数组分配内存
这种创建数组的方法是将数组的声明和内存的分配合在一起执行。
语法如下：
数组元素的类型 数组名 = new 数组元素的类型[数组元素的个数];
实例代码如下：
int month[] = new int[12]
- 1
2、初始化一维数组
数组与基本数据类型一样可以进行初始化操作。数组的初始化可分别初始化数组中的每个元素。数组的初始化有以下两种形式；
int arr[] = new int[]{1,2,3,4,5}; //第一种初始化方式
int arr2[] = {1,2,3,4,5}; //第二种初始化方式
- 1
- 2
从中可以看出，数组的初始化就是包括在大括号之内用逗号分开的表达式列表。用逗号（,）分割数组中的各个元素，系统自动为数组分配一定的空间。用第一种初始化方式，将创建5个元素的数组。
3、使用一维数组
在Java集合中一维数组是常见的一种数据结构。下面的实例是使用一维数组将1~12月各月的天数输出。
public class Test {
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]+"天"); //输出的信息
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
三、二维数组的创建及使用
如果一维数组中的各个元素仍然是一个数组，那么它就是一个二维数组。二维数组常用于表示表，表中的信息以行和列的形式组织，第一个下标代表元素所在的行，第二个下标代表元素所在的列。
1、二维数组的创建
二维数组可以看作是特殊的一维数组，因此，二维数组的创建同样有两种方式。
1、先声明，再用new运算符进行内存分配
声明二维数组的语法如下：
数组元素的类型 数组名字[][];
数组元素类型[][] 数组名字；
实例如下：
int myarr[][];
- 1
直接为数组分配内存空间
a = new int[2][4];
- 1
分别为每一个维分配内存
a = new int[2][];
a[0] = new int[2];
a[1] = new int[3];
- 1
- 2
- 3
2、声明的同时为数组分配内存
第二种方式同第一种实现的功能相同。使用这种方式为二维数组分配内存时，首先指定最左边维数的内存，然后单独地给余下的维数分配内存。通过第二种方式为二维数组分配内存。
2、二维数组初始化
二维数组的初始化与一维数组初始化类似，同样可以使用大括号完成。
语法如下：
type arrayname[][] = {value1,value2...valuen};
- 1
实例如下：
int myarr[][] = {{12,0},{45,10}};
- 1
初始化二维数组后，要明确数组的下标都是从0开始。例如，上面的代码中myarr[1][1]的值为10。int型二维数组是以int a[][]来定义的，所以可以直接给a[x][y]赋值。例如，给a[1]的第2个元素赋值语句如下：
a[1][1] = 20;
- 1
3、使用二维数组
二维数组在实际应用中用得非常广泛。下面的实例就是使用二维数组输出一个3行4列且所有元素都是0的矩阵。
public class Test {
public static void main(String[] args) {
int a[][] = new int[3][4]; //定义二维数组
for(int i = 0; i < a.length; i++){
for(int j = 0; j < a[i].length; j++){ //循环遍历数组中的每个元素
System.out.print(a[i][j]); //将数组中的元素输出
}
System.out.println(); //输出空格
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
四、数组的基本操作
1、遍历数组
遍历数组就是获取数组中的每个元素。通常遍历数组都是使用for循环来实现。遍历一维数组很简单，也很好理解，下面详细介绍遍历二维数组的方法。
遍历二维数组需使用双层for循环，通过数组的length属性可获得数组的长度。
public class Test {
public static void main(String[] args) {
int a[][] = new int[][]{{1},{2,3},{4,5,6}}; //定义二维数组
for(int k = 0; k < a.length; k++){
for(int c = 0; c < a[k].length; c++){ //循环遍历数组中的每个元素
System.out.print(a[k][c]); //将数组中的元素输出
}
System.out.println(); //输出空格
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
2、填充替换数组元素
数组中的元素定义完成后，可通过Arrays类的静态方法fill()来对数组中的元素进行替换。该方法通过各种重载形式可完成对任意类型的数组元素的替换。fill()方法有两种参数类型，下面以int型数组为例介绍fill()方法的使用方法。
1、fill(int [] a, int value)
该方法可将指定的int值分配给int型数组的每个元素。
语法如下
fill(int[] a,int value)
例如：创建一维数组，并实现通过fill()方法填充数组元素，最后将数组中的各个元素输出。
public class Test {
public static void main(String[] args) {
int arr[] = new int[5];
Arrays.fill(arr,8);
for(int i = 0; i < arr.length; i++){
//将数组中的元素依次输出
System.out.println("第" + i + "个元素是：" + arr[i]);
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
2、fill(int[] a,int fromIndex,int toIndex,int value)
例如：创建一维数组，并实现通过fill()方法替换数组元素，最后将数组中的各个元素输出。
public class Test {
public static void main(String[] args) {
int arr[] = new int[]{33,444,55,66};
Arrays.fill(arr,1,2,8);
for(int i = 0; i < arr.length; i++){
//将数组中的元素依次输出
System.out.println("第" + i + "个元素是：" + arr[i]);
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
3、对数组进行排序
通过Arrays类的静态sort()方法可以实现对数组的排序。sort()方法提供了多种重载形式，可对任意类型的数组进行升序排序。
语法如下：
Arrays.sort(object);
例如：创建一维数组，将数组排序后输出
public class Test {
public static void main(String[] args) {
int arr[] = new int[]{33,444,55,66};
Arrays.sort(arr);
for(int i = 0; i < arr.length; i++){
//将数组中的元素依次输出
System.out.println("第" + i + "个元素是：" + arr[i]);
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
4、复制数组
Arrays类的copyOf()方法与copyOfRange()方法可以实现对数组的复制。copyOf()方法是复制数组至指定长度，copyOfRange()方法则将指定数组的指定长度复制到一个新数组中。
1、copyOf()方法
该方法提供了多种重载形式，用于满足不同类型数组的复制。
语法如下：
copyOf(arr,int newlength)
例如：创建一维数组，实现将此数组复制得到一个长度为5的新数组。
public class Test {
public static void main(String[] args) {
int arr[] = new int[]{23,42,12};
int[] newarr = Arrays.copyOf(arr, 5);
for(int i = 0; i < newarr.length; i++){
//将数组中的元素依次输出
System.out.println("第" + i + "个元素是：" + newarr[i]);
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
2、copyOfRange()方法
语法如下:
copyOfRange(arr,int formIndex,int toIndex)
例如：创建一维数组，并将数组中索引位置是0~3之间的元素复制到新数组中，最后将新数组输出。
public class Test {
public static void main(String[] args) {
int arr[] = new int[]{23,42,12,84,10};
int[] newarr = Arrays.copyOfRange(arr,0,3);
for(int i = 0; i < newarr.length; i++){
//将数组中的元素依次输出
System.out.println("第" + i + "个元素是：" + newarr[i]);
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
5、数组查询
Arrays类的binarySearch()方法，可使用二分搜索法来搜索指定数组，以获得指定对象。该方法返回要搜索元素的索引值。binarySearch()方法提供了多种重载形式，用于满足各种类型数组的查找需要。binarySearch()方法有两种参数类型。
1、binarySearch(Object[],Object key)
语法如下：
binarySearach(Object[] a,Object key)
例如：创建一维数组ia，实现查找元素4在数组ia中的索引位置。
public class Test {
public static void main(String[] args) {
int ia[] = new int[]{23,42,12,4,3};
Arrays.sort(ia);
int index = Arrays.binarySearch(ia,4);
System.out.println("4的索引位置是：" +index);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
2、binarySearch(Object[] a, int fromIndex, int toIndex,Object key)
例如：创建String数组，实现查找元素“cd”在指定范围的数组str中的索引位置。
public class Test {
public static void main(String[] args) {
String str[] = new String[]{"ab","cd","ef","yz"};
Arrays.sort(str);
int index = Arrays.binarySearch(str, 0, 2, "cd");
System.out.println("cd的索引位置是：" +index);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
五、数组排序算法
数组有很多常用的算法，这里将介绍常用的排序算法，包括冒泡排序、直接选择排序和反转排序。
1、冒泡排序
在程序设计中，经常需要将一组数列进行排序，这样更加方便统计与查询。程序常用的排序方法有冒泡排序、选择排序和快速排序等。这里将介绍冒泡排序方法，它以简洁的思想与实现方法而备受青睐。
冒泡排序是最常用的数组排序算法之一，它排序数组元素的过程总是将小数往前放、大数往后放，类似水中气泡往上升的动作，所以称做冒泡排序。
1、基本思想
冒泡排序的基本思想是对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把大的元素移动到数组后面（也就是交换两个元素的位置），这样较小的元素就像气泡一样从底部上升到顶部。
2、算法实现
public class Test {
public static void main(String[] args) {
//创建一个数组，这个数组元素是乱序的
int[] array = {63,4,1,3,15};
//创建冒泡排序类的对象
Test sorter = new Test();
//调用排序方法将数组排序
sorter.sort(array);
}
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){
for (int i : array){
System.out.print(" >" + i); //输出每个数组元素值
}
System.out.println();
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
2、直接选择排序
直接选择排序方法属于选择排序的一种，它的排序速度要比冒泡排序快一些，也是常用的选择排序算法，初学者应该掌握
1、基本思想
直接选择排序的基本思想是将指定排序位置与其他数组元素分别对比，如果满足条件就交换元素值，注意这里区别冒泡排序，不是交换相邻元素，而是把满足条件的元素与指定的排序位置交换（如果从最后一个元素开始排序），这样排序好的位置逐渐扩大，最后整个数组都成为已排序好的格式。
这就好比有一个小学生，从包含数字1-10的乱序的数字堆中分别选择合适的数字，组成一个1-10的排序，而这个学生首先从数字堆中选出1，放在第一位，然后选出2（注意这时数字堆中已经没有1了），放在第二位，依次类推，直到其找到数字9，放到8的后面，最后剩下10，就不用选择了，直接放到最后就可以了。
与冒泡排序相比，直接选择排序的交换次数要少很多，所以速度会快些。
2、算法实现
public class Test {
public static void main(String[] args) {
//创建一个数组，这个数组元素是乱序的
int[] array = {63,4,24,1,3,15};
//创建直接排序类的对象
Test sorter = new Test();
//调用排序对象的方法将数组排序
sorter.sort(array);
}
public void sort(int[] array){
int index;
for(int i =1; i < array.length; i++){
index = 0;
for (int j = 1; j <= array.length -i; j++){
if(array[j] > array[index]){
index = j;
}
}
//交换在位置array.length-i和index（最大值）上的两个数
int temp = array[array.length - i];//把第一个元素值保存到临时变量中
array[array.length-i] = array[index];//把第二个元素值保存到第一个元素单元中
array[index] = temp; //把临时变量也就是第一个元素原值保存到第二个元素中
}
showArray(array);
}
public void showArray(int[] array){
for (int i : array){
System.out.print(" > "+ i);
}
System.out.println();
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
3、反转排序
顾名思义，反转排序就是以相反的顺序把原有数组的内容重新排序。反转排序算法在程序开发中也经常用到。
1、基本思想
反转排序的基本思想比较简单，也很好理解，其实现思路就是把数组最后一个元素与第一个元素替换，倒数第二个元素与第二个元素替换，依次类推，直到把所有的数组元素反转替换。
2、算法实现。
public class Test {
public static void main(String[] args) {
//创建一个数组，这个数组元素是乱序的
int[] array = {63,4,24,1,3,15};
//创建直接排序类的对象
Test sorter = new Test();
//调用排序对象的方法将数组排序
sorter.sort(array);
}
public void sort(int[] array){
System.out.println("数组原有内容：");
showArray(array);//输出排序钱的数组值
int temp;
int len = array.length;
for(int i = 0; i < len /2; i++){
temp = array[i];
array[i] = array[len -1 -i];
array[len -1 -i] = temp;
}
System.out.println("数组排序后内容：");
showArray(array);
}
public void showArray(int[] array){
for (int i : array){
System.out.print(" > "+ i);
}
System.out.println();
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
六、总结
这里的相关内容还没有整理完毕，文章后面持续更新，建议收藏。
文章中涉及到的命令大家一定要像我一样每个都敲几遍，只有在敲的过程中才能发现自己对命令是否真正的掌握了。
可以微信搜索【小奇JAVA面试】第一时间阅读，回复【资料】获取福利，回复【项目】获取项目源码，回复【简历模板】获取简历模板，回复【学习路线图】获取学习路线图。
文章来源: xiaoqijava.blog.csdn.net，作者：旷世奇才李先生，版权归原作者所有，如需转载，请联系作者。
原文链接：xiaoqijava.blog.csdn.net/article/details/125949875
- 点赞
- 收藏
- 关注作者
评论（0）