Java -- 数组的创建与使用

怼烎@ 2023-07-22 13:28 1阅读 0赞

本篇主要讲解的就是数组的创建和使用方法，以及Arrays类提供的操作数组的方法。

## 一、数组概述 ##

1.  数组是具有相同数据类型的一组数据的集合。例如：球类的集合—乒乓球、足球、篮球等。在程序设计中，可以将这些集合称为数组，数组中每个元素具有相同的数据类型。在程序设计中引入数组可以更有效地管理和处理数据，可以根据数组的维数分为一维数组和二维数组…
2.  在java中，同样可以将数组看成一个对象，虽然基本数据类型不是对象，但是基本数据类型组成的数组却是对象。

## 二、一维数组的创建及使用 ##

一维数组实质上是一组相同类型数据的线性集合，当程序中需要处理一组数据或者传递一组数据时可以应用这种类型的数组。

#### 2.1 创建一维数组 ####

数组作为对象允许使用`new`关键字进行内存分配。在使用之前，必须先定义数组变量所属的数据类型。有两种创建一维数组的形式：

1.  先声明，再用new运算符进行内存分配

声明一维数组有两种形式：

数据元素类型 数组名字[];
    数据元素类型[] 数组名字;

> 1、数组元素类型决定了数组的数据类型。  
> 2、`[]`指明了该变量是一个数组类型变量，单个`[]`表示创建的数组是一个一维数组

例：

int arr[];//定义一个int型数组
    String str[];//定义一个String型数组

声明数组后不可以立即访问他的任何元素，因为没有为其分配内存空间。为数组分配空间的时候必须指明数组的长度。

数组名字 = new 数组元素类型[数组元素的个数];

数组元素个数即数组的长度  
例：

arr = new int[7];

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70]  
`[]`中数字为数组的下标。数组通过下标来区分数组中不同的元素。数组下标从0开始

> 使用`new`关键字为数组分配内存时，整型数组中各个元素的初始值都是0

1.  声明的同时为数组分配内存

这种方法是将数组的声明和内存的分配放在一起执行。

数组元素类型 数组名 = new 数组元素类型[数组元素个数];

例：

int week[] = new int[7];//创建week数组，指定长度为7

#### 2.2 初始化一维数组 ####

数组的初始化可分别初始化数组中的每个元素。

int arr[] = new int[]{ 1,2,3,4,5,6,7};//第一种初始化方式
    inr arr2[] = { 1,2,3,4,5,6,7};//第二种初始化方式

> 数组的初始化就是包括在大括号`{}`之内用逗号`,`分开的表达式列表。  
> 系统自动为数组分配一定的空间

#### 2.3 使用一维数组 ####

在Java集合中一维数组是最常见的一种数据结构

package cn.tedu.test;
    
    public class Test { 
    	public static void main(String[] args) { 
    		//创建并初始化一维数组
    		int week[] = new int[] { 1,2,3,4,5,6,7};
    		//利用循环将信息输出
    		for (int i = 0; i < week.length; i++) { 
    			//输出的信息
    			System.out.println("今天是一周的第" + week[i] + "天");
    		}
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 1]

## 三、二维数组的创建及使用 ##

如果一维数组中的各个元素仍然是一个数组，那么他就是一个一维数组。  
二维数组常用于表达表中的信息以行和列的形式组织，第一个下标代表元素所在的行，第二个元素代表元素所在的列

#### 3.1 二维数组的创建 ####

1.  先声明，再用new运算符进行分配内存

创建形式：

数组元素类型 数组名字[][];
    数组元素类型[][] 数组名字;

例：

int arr[][];

二维数组同样需要分配内存空间之后才可以访问每个元素  
对于高维数组，分配内存的方式有两种：  
（1） 直接为每一维分配内存空间

a = new int[2][4];

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 2]  
（2）分别为每一维分配空间

a = new int[2][];
    a[0] = new int[2];
    a[1] = new int[3];

1.  声明数组的同时为数组分配内存  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 3]

#### 3.2 二维数组的初始化 ####

语法格式：

type arrayname[][] = { value1,value2......valuen};

*  type：数组的数据类型
 *  arrayname：数组名称，一个合法的标识符
 *  value：数组中各元素的值

int arr[][] = { { 12,0}{ 10,23}};

#### 3.3 使用二维数组 ####

使用二维数组输出一个3行4列且所有元素都是0的矩阵。

package cn.tedu.test;
    
    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();
    		}
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 4]

> 对于整型二维数组，创建成功之后系统会赋值给数组中每个元素初始值`0`

## 四、数组的基本操作 ##

java.util包的Arrays类包含了用来操作数组的各种方法。

#### 4.1 遍历数组 ####

遍历数组就是获取数组中的每个元素。通常都是用`for`循环来实现。  
遍历二维数组通常是使用双层for循环。通过数组的`length`属性可以获得数组的长度

package cn.tedu.test;
    
    public class Test { 
    	public static void main(String[] args) { 
    		//定义一个二维数组
    		int b[][] = new int[][] { { 1},{ 2,3},{ 4,5,6}};
    		for (int i = 0; i < b.length; i++) { 
    			//循环遍历数组中的每个元素
    			for (int j = 0; j < b[i].length; j++) { 
    				System.out.print(b[i][j]);
    			}
    			System.out.println();
    		}
    	}
    }

![在这里插入图片描述][20200406115041274.png]  
在遍历数组时，使用增强for（foreach）可能会更简单。

package cn.tedu.test;
    
    public class Test { 
    	public static void main(String[] args) { 
    		//增强for---foreach
    		int arr[][] = { { 4,2,9},{ 1,5}};//定义一个二维数组
    		System.out.println("数组中的元素:");
    		//外层循环遍历为一维数组
    		for (int i[] : arr) { 
    			//循环遍历每一个数组的元素
    			for (int e : i) { 
    				//判断变量是否是二维数组中的最后一个元素
    				if (e == i.length) { 
    					//输出二维数组的最后一个元素
    					System.out.print(e);
    				}else { 
    					//如果不是二维数组的最后一个元素
    					System.out.print(e + "、");//输出信息
    				}
    			}
    		}
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 5]

#### 4.2 填充替换数组元素 ####

数组中的元素定义完成后，可以通过`Arrars`类的静态方法`fill()`来对数组中的元素进行替换。  
（1）fill(int\[\] a,int value)

fill(int[] a ,int value)

*  a：要进行元素替换的数组
 *  value：要存储数组中所有元素的值

package cn.tedu.test;
    
    import java.util.Arrays;
    
    public class Test_Swap { 
    
    	public static void main(String[] args) { 
    		// 创建int型数组
    		int arr[] = new int[5];
    		//使用同一个值对数组进行填充
    		Arrays.fill(arr, 8);
    		for (int i = 0; i < arr.length; i++) { 
    			System.out.println("第"+ i + "个元素是" + arr[i]);
    		}
    	}
    
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 6]

（2）fill(int\[\] a,int fromIndex,int toIndex,int value)

fill(int[] a,int fromIndex,int toIndex,int value)

*  fromIndex：要使用指定值填充的第一个元素的索引（包括）
 *  toIndex：要使用的指定值填充的最后一个元素的索引（不包括）

> 如果指定的索引位置大于或等于要进行填充的数组的长度，会报错。  
> `ArrayIndexOutOfBoundsException`（数组越界异常）

package cn.tedu.test;
    
    import java.util.Arrays;
    
    public class Test_Swap { 
    
    	public static void main(String[] args) { 
    		// 创建int型数组
    		int arr[] = new int[] { 1,2,3,4,5,6};
    		//使用fill方法对数组进行初始化
    		Arrays.fill(arr,1,2,8);
    		for (int i = 0; i < arr.length; i++) { 
    			System.out.println("第"+ i + "个元素是" + arr[i]);
    		}
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 7]

#### 4.3 数组排序 ####

通过`Arrays`类的静态方法`sort()`可以实现对数组的排序。  
语法格式：

Arrays.sort(object)

*  object：要进行排序的数组的名称

package cn.tedu.test;
    
    import java.util.Arrays;
    
    public class Test_Swap { 
    
    	public static void main(String[] args) { 
    		// 创建int型数组
    		int arr[] = new int[] { 1,6,8,2,4};
    		//将数组进行排序
    		Arrays.sort(arr);
    		for (int i = 0; i < arr.length; i++) { 
    			System.out.print(arr[i] + "、");
    		}
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 8]

> **注意：**  
> 在Java中的String类型数组的排序算法是根据字典编排顺序排序，因此数字排在字母前面，大小字母排在小写字母前面

#### 4.4 数组复制 ####

`Arrays`类里面的`copyOf()`方法与`copyOfRange()`方法可以实现对数组的复制

*  `copyOf()`方法：是复制数组至指定长度
 *  `copyOfRange()`方法：将指定数组的指定长度复制到一个新的数组中

（1）copyOf()方法  
语法格式：

copyOf(arr,int newlength)

*  arr：要进行复制的数组
 *  newlength：复制后新数组的长度。int型常量

> 如果新数组的长度大于arr数组的长度，则用0填充（整型数组用0填充，char型数组则使用null填充）；  
> 如果复制后的数组长度小于数组arr的长度，则会从数组arr的第一个元素开始截取至满足新数组长度为止

package cn.tedu.test;
    
    import java.util.Arrays;
    
    public class Test_Swap { 
    	public static void main(String[] args) { 
    		int arr[] = new int[] { 54,62,13}; 
    		int newarr[] = Arrays.copyOf(arr, 6);
    		for (int i = 0; i < newarr.length; i++) { 
    			System.out.println(newarr[i]);
    		}
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 9]  
（2）copyOfRange()方法  
语法格式：

copyOfRange(arr,int formIndex,int toIndex)

*  formIndex：指定开始复制数组的索引位置，范围必须在0至整个数组的长度之间。新数组包括索引是formIndex的元素
 *  toIndex：要复制范围的最后索引位置。可大于数组arr的长度，新数组不包括索引是toIndex的元素。

package cn.tedu.test;
    
    import java.util.Arrays;
    
    public class Test_Swap { 
    
    	public static void main(String[] args) { 
    		int arr[] = new int[] { 54,62,13,5,43};
    		int newarr[] = Arrays.copyOfRange(arr, 0, 3);
    		for (int i = 0; i < newarr.length; i++) { 
    			System.out.println(newarr[i]);
    		}
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 10]

#### 4.5 数组查询 ####

`Arrays`类中的`binarySearch()`方法，可使用二分搜索法来搜索指定数组，以获得指定对象。  
该方法返回的是要搜索的元素的索引值。  
（1）binarySearch(Object\[\] .Object key)  
语法格式：

binarySearch(Object[] a.Object key)

*  a：要搜索的数组
 *  key：要搜索的值

如果key包含在数组中，则返回搜索值得索引；否则返回`-1`或`-(插入点)`。插入点是搜索键将要插入数组的那一点，即第一个大于此键的元素索引

package cn.tedu.test;
    
    import java.util.Arrays;
    
    public class Test_Swap { 
    
    	public static void main(String[] args) { 
    		int arr[] = new int[]{ 4,25,10};
    		Arrays.sort(arr);
    		int index = Arrays.binarySearch(arr,0,1,8);
    		System.out.println(index);
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 11]  
如果数组中的所有元素都小于指定的键，则为a.length（注意，这保证了当且仅当此键被找到时，返回的值将大于等于0）

> 注意：  
> 必须在进行调用之前对数组进行排序（通过`sort()`方法），如果没有对数组进行排序，则结果是不确定的，如果数组包含多个带有指定值得元素，则无法保证找到的是哪一个。

int arr[] = new int[]{ 1,8,9,4,5};
    		Arrays.sort(arr);
    		int index = Arrays.binarySearch(arr,4);
    		System.out.println("4位置的索引是：" + index);

![在这里插入图片描述][20200406152105836.png]

> 返回值“1”是对数组arr进行排序后元素4的索引位置

（2）binarySearch()方法  
语法格式：

binarySearch(Object[].,int fromIndex,int toIndex,Object key)

*  fromIndex：指定范围的开始处索引（包括）
 *  toIndex：指定范围的结束处索引（不包括）

使用该方法依旧要先进行排序，来获得准确的索引值。  
如果要搜索的key包含在数组中，则返回搜索值得索引；否则返回`-1`或`-(插入点)`。  
如果范围内的所有元素都小于指定的键，则为toIndex（注意，这保证了当且仅当此键被找到时，返回的值将大于等于0）。

> 注意：  
> 如果指定的范围大于或等于数组的长度，则会报出`ArraysIndexOutOfBoundsException`异常。

package cn.tedu.test;
    
    import java.util.Arrays;
    
    public class Test_Swap { 
    
    	public static void main(String[] args) { 
    		String[] str = new String[] { "ab","cd","ef","yz"};
    		Arrays.sort(str);
    		//在指定范围内搜索元素“cd”的索引位置
    		int index = Arrays.binarySearch(str, 0,2,"cd");
    		System.out.println("cd的索引位置是：" + index);
    	}
    }

![在这里插入图片描述][20200406153416189.png]

##### 总结： #####

需要注意的是数组的下标是从0开始的，最后一个元素的总是`数组名.length - 1`…，遍历数组和`Arrays`类中的各种方法对数组进行操作等。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70]: /images/20230528/f3adf4a0a6db40dc927d1c166d764a86.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 1]: /images/20230528/1b86960f78e24407aeb235d822ede257.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 2]: /images/20230528/82a52f40dbc34da9a3d2d3152108e1bf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 3]: /images/20230528/4583a8c830ea4842804d4e09205dd2eb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 4]: /images/20230528/a9c6a0fac358403ba3e0a09a100bf11f.png
[20200406115041274.png]: /images/20230528/25ce1c6a87f14024932b5314ce7d7c4e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 5]: /images/20230528/67cda5135f804dcda00e421b4ad005b8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 6]: /images/20230528/ddeeaeb0651c4d459d2db4e9a9f72540.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 7]: /images/20230528/0c120f0582414f85b10638ea132c03fe.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 8]: /images/20230528/4e1016daf4564b87bf370445de254248.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 9]: /images/20230528/4fadce8bd99a469f9457b1eb299e6942.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 10]: /images/20230528/3fe9f78cfe924cd28712476d1d425262.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 11]: /images/20230528/dd24f17314f9485687474dbb83009a73.png
[20200406152105836.png]: /images/20230528/7847f3d10796489bbeedbf00dc1a7b49.png
[20200406153416189.png]: /images/20230528/c489f6592b6b42af8010dcdfe29b8cbf.png