Java中的数组--一维数组

太过爱你忘了你带给我的痛 2023-09-24 22:08 100阅读 0赞

## 1、 理解数组 ##

（1）在Java中，数组是用来存储一组相同类型数据的数据结构。

（2）当数组初始化完毕后，Java为数组在内存中分配一段连续的空间，其在内存中开辟的空间也将随之固定，此时数组的长度就不能再发生改变。

（3）即使数组中没有保存任何数据，数组所占据的空间依然存在。

### 2、定义数组 ###

在Java中，定义数组的语法有如下两种：

数据类型\[\] 数组名 = new 数据类型\[数组长度\];

或者：

数据类型 数组名\[\] = new 数据类型\[数组长度\];

\--->定义数组时一定要指定数组名和数组类型

\--->必须书写“\[\]”，表示定义了一个数组，而不是一个普通的变量。

\--->“\[数组长度\]”决定连续分配的空间的个数，通过数组的length属性可获取此长度。

\--->数组的数据类型用于确定分配的每个空间的大小。

\--->数组元素分配的初始值如下

public class Test {
    
    	public static void main(String[] args) {
    		/*
    		 * 只要是能存储数据的，都可以看成是变量（容器）
    		 * 
    		 * 变量：存储数据的空间（装数据的容器），变量中只能存储1个数据，内存会给这个变量分配一个内存地址
    		 * 数组：存储数据的空间（装数据的容器），数组中可以存储多个（具体多少个由你来定义）相同类型的数据，内存会给这个数组分配一个内存地址 
    		 */
    		
    		//数组声明：数据类型[] 数组名;   或者  数据类型 数组名[]
    		byte[] nums1;
    		short[] nums2;
    		int[] nums3;
    		long nums4[];
    		float nums5[];
    		double[] nums6;
    		char[] chas1;
    		boolean[] bools1;
    		String[] strs1;
    		
    		//数组声明好后，分类空间（告诉数组里能够存储数据的个数）：数组名 = new 数据类型[数组长度];
    		nums1 = new byte[3];
    		nums2 = new short[4];
    		nums3 = new int[2];
    		nums4 = new long[5];
    		nums5 = new float[6];
    		nums6 = new double[3];
    		chas1 = new char[3];
    		bools1 = new boolean[4];
    		strs1 = new String[3];
    		
    		//赋值，将数据存储在数组的指定位置，位置通过下标来控制，下标从0开始：数组名[下标] = 数据;
    		nums3[0] = 10;
    		nums3[1] = 20;
    		//nums3[2] = 100;//ArrayIndexOutOfBoundsException 数组下标越界异常，nums3数组的长度为2，下标从0-1，下标不可能超过1，所以你写2，就越界
    		
    		//操作数组中的数据：通过数组名[下标]来操作
    		System.out.println(nums3[0]);//10
    		nums3[0]+=20;
    		System.out.println(nums3[0]);//30
    		System.out.println(nums3[1]);		
    	}
    
    }

### 3、数组元素的表示与赋值 ###

（1）数组元素在数组里顺序排列编号，该编号即元素下标，它标明了元素在数组中的位置。

（2）首元素（第一个元素）的编号规定为0，因此，数组的下标依次为0、1、2、3、4······依次递增，每次增长数是1.

（3）数组中的每个元素都可以通过下标来访问。

获取数组元素的语法格式如下：

数组名\[下标值\]

### 4、数组的初始化 ###

所谓数组的初始化，就是在定义数组的同时并完成赋值操作。

数组初始化的语法格式如下：

数据类型\[\] 数组名 = \{值1,值2,值3,····,值n\};

或者：

数据类型\[\] 数组名 = new 数据类型\[\]\{值1,值2,值3,····,值n\};

注意：第二种初始化数组的方式里new 数据类型\[\]的\[\]括号里不能写数组长度。

public class Test {
    
    	public static void main(String[] args) {
    		//声明数组、分配空间、赋值合并一步写
    		//数据类型[] 数组名 = new 数据类型[]{数据1,数据2,...,数据n};  或者  数据类型 数组名[] = new 数据类型[]{数据1,数据2,...,数据n};   注意：{}前面的[]中不能写数组长度
    
    		char[] chas1 = new char[]{'你','好'};
    		boolean[] bools1 = new boolean[]{false,false,true,false};
    		
    		//操作数据：数组名[下标]
    		System.out.println(bools1[2]);
    		
    		
    		//上面声明数组、分配空间、赋值合并写可以简写
    		//数据类型[] 数组名 = {数据1,数据2,...,数据n};  或者    数据类型 数组名[] = {数据1,数据2,...,数据n};
    		int[] nums = {10,52,46,78,91,66};
    		double[] nums2 = {12.5,56.5,78,16.55,9};
    		
    		//直接输出数组名称，输出的是数组的内存地址值
    		System.out.println(nums);//[I@7910769b
    		
    	}
    
    }

### 5、遍历数组 ###

（1）使用for循环遍历数组

for(int i = 0;i<数组名.length;i++)\{

System.out.println(数组名\[i\]);

（2）使用增强for循环遍历数组

for(元素类型 变量名:数组名)\{

System.out.println(变量名);

public class Test {
    
    	public static void main(String[] args) {
    		
    		int[] nums = {11,25,46,78,10,63};
    		
    		for(int i =0;i<nums.length;i++){
    			System.out.println(nums[i]);
    		}
    		
    		System.out.println("-------------------");
    		
    		//除了上述普通for循环可以遍历数组，增强for循环也可以
    		/*
    		 * 增强for循环：
    		 * 	语法结构
    		 * 		for(数据类型 变量名:数组名){
    		 * 			//操作变量名
    		 * 		}
    		 * 	执行规律：
    		 * 		将数组中的元素按照下标顺序依次取出来存储在变量中，通过操作变量就可以操作数组中的元素 
    		 */
    		
    		for(int a:nums){
    			System.out.println(a);
    		}
    
    	}
    
    }

注意：

增强for循环是JDK1.5之后提供的，用来实现对数组和集合中数据的访问。

### 6、数组应用 ###

（1）求数组中的最大最小值；

思路：

1）假设数组中第一个元素（下标为0的元素）为最大值/最小值。

2）然后依次将后面元素和假设的最大值/最小值进行比较。

3）如果后续元素比假设的最大值/最小值大/小的话，就取代假设的最大值/最小值，成为

新的最大值/最小值。

4）比较完数组里所有的元素后，获得最大值/最小值。

实现代码如下：

public class Test{
    
    	public static void main(String[] args) {
    		// 定义一个数组
    		int[] nums = {25,63,12,54,99};
    		//假设第一个数组中的元素为最大值
    		int max=nums[0];
    		//假设第一个数组中的数为最小值
    		int min=nums[0];
    		//比较数组中的每一个元素与假设的最大值和最小值
    		for (int i=0;i<nums.length;i++){
    			if(nums[i]>max){
    				max=nums[i];
    			}
    			if(nums[i]<min){
    				min=nums[i];
    			}
    			
    		}
    		//输出最大最小值
    		System.out.println("最大值："+max);
    		System.out.println("最小值："+min);
    	}
    
    }

（2）向数组中添加元素

思路：

1）创建一个比原来数组长度大1的新数组。

2）将原来数组的元素存储在新数组中，按照从前到后的顺序存储。

3）找到插入元素要插入的位置。

4）从插入位置开始到后面的元素依次往后移动一个位置（最后一个元素先移）。

5）插入元素

实现代码如下：

import java.util.Scanner;
    
    public class Test {
    
    	public static void main(String[] args) {
    		
    		Scanner sc = new Scanner(System.in);
    		
    		int[] scores = {99,85,82,63,60};
    		
    		//1、声明一个比原来数组长度大1的新数组
    		int[] newScores = new int[scores.length+1];
    		
    		//2、使用循环，将原来数组中的元素依次存储到新创建的数组中
    		for(int i =0;i<scores.length;i++){
    			newScores[i]=scores[i];
    		}
    		
    		System.out.println("数组中的元素：");
    		for (int i = 0; i < newScores.length; i++) {
    			System.out.print(newScores[i]+" ");
    		}
    		
    		System.out.println();
    		
    		//3、获取你想要插入的数据
    		System.out.println("请输入你想要插入的数据（整数）：");
    		int insert = sc.nextInt();
    		
    		//4、获取插入元素的插入位置
    		//声明一个变量用来存储插入元素插入的位置
    		int index = newScores.length-1;
    		for(int i =0;i<newScores.length;i++){
    			if(insert>newScores[i]){
    				index=i;
    				//得到插入元素比数组中的元素大之后，后续元素不再进行比较。否则，会比较到最后一个元素
    				break;
    			}
    		}
    		
    		//5、从插入位置开始及之后的元素依次往后移动一位，从最后面开始
    		for(int i =newScores.length-1;i>index;i--){
    			//移动元素
    			newScores[i]=newScores[i-1];
    		}
    		
    		//6、将插入元素赋值到插入位置
    		newScores[index]=insert;
    		System.out.println("数组中插入元素之后的数组：");
    		for (int i = 0; i < newScores.length; i++) {
    			System.out.print(newScores[i]+" ");
    		}
    		
    		System.out.println();
    		
    
    	}
    
    }

（3）数组冒泡排序

思路：

1）将数组中元素两两比较，大的数（小的数）往后排（往前排）。

2）每一轮将大数（小数）排在最后面（最前面）位置。

3）多轮比较后，得出升序（降序）排列的数组。

代码（升序排序）：以int类型的数组arr为例

for(int i = 0;i<arr.length-1;i++)\{

for(int j = 0;j<arr.length-1-i;j++)\{

if(arr\[j\]>arr\[j+1\])\{

int temp = arr\[j\];

arr\[j\] = arr\[j+1\];

arr\[j+1\] = temp;