第六章数组

最新推荐文章于 2023-08-08 08:42:29 发布

墨渐生微

最新推荐文章于 2023-08-08 08:42:29 发布

阅读量288

点赞数 1

分类专栏： Java编程基础文章标签：数组冒泡 Arrays break out foreach

本文链接：https://blog.csdn.net/Mythology_px/article/details/81545564

版权

Java编程基础专栏收录该内容

8 篇文章 0 订阅

订阅专栏

数组的定义

数组是引用类型的变量，存储一组数据类型相同的数据，声明一个数组就是在内存中开辟一系列连续的存储空间

数组基本要素

数组元素：数组中存放的数据

元素类型：数组元素的数据类型

标识符：数组的名称，用于区分不同的数组

数组下标：对数组元素进行编号，从0开始，数组的每个元素都可通过下标访问

注：数组长度固定不变，避免数组越界

数组的使用

数组声明：数组必须先声明后使用

数据类型数组名[ ];

数据类型[ ] 数组名;

分配空间:数组声明成功后，只是得到了一个存放数组的变量，并没有在内存中为它分配空间，才可以在数组中放入元素。

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

赋值:数组声明并分配空间完成后，就可以为数组赋值。一次只能对一个数组元素进行赋值，通过下标确定数组元素

数组名[下标] = 元素值;

注：分组声明分配空间成功后，会自动赋值初始化。

此外数组还有一种赋值方式，可将数组声明、分配空间、赋值一起完成

数据类型[ ] = {数组元素};

或

数据类型[ ] 数组名 = new 数据类型[ ]{数组元素};

访问数组元素：获取数组元素的值可以使用数组下标；每个数组都有length属性，用来获取数组的长度

注：在访问数组时，数组下标小于0或者大于数组长度，会出现下标越界的错误

/*
 * 数组的使用
 * */
public class D1 {
	public static void main(String[] args) {
		// 1.数组声明
		int[] arr; // 第一种方法
		//intarr[] ; // 第二种方法
		// 2.分配空间
		arr = new int[5];
		//int[] arr = new int[5] ; // 声明和分配空间一起
		//intarr[] = new int[5] ; // 声明和分配空间一起
		// 3.赋值
		arr[0] = 1; // 下标从0开始
		arr[1] = 2;
		arr[2] = 3;
		// 4.访问数组元素
		System.out.println(arr[1]);
		System.out.println(arr[4]); // 默认赋值
	}
}

/*
 * 赋值的不同方式
 * */
public class D2 {
	public static void main(String[] args) {
		// 1.第一种
		int[] arr1 = new int[3];
		arr1[0] = 45;
		arr1[2] = 32;
		// 2.第二种
		int[] arr2 = new int[] { 12, 23, 45 };
		// 3.第三种
		int[] arr3 = { 23, 45, 66 };
	}
}

Arrays类

sort( )

import java.util.Arrays;
/*
 * Arrays.sort(数组名)
 * 对数组升序排序
 * 
 */
public class D2 {
	public static void main(String[] args) {
		int num[] = { 45, 56, 23, 78, 02, 23, 54, 78, 89, 22, 55 };
		/********************排序前***************************/
		for (int i = 0; i<num.length; i++) {
			System.out.print(num[i] + "\t");
		}
		System.out.println("\n");

		/********************排序后***************************/
		Arrays.sort(num);
		
		for (int i = 0; i<num.length; i++) {
			System.out.print(num[i] + "\t");
		}
		System.out.println("\n");
		
		/********************降序输出***************************/
		for (int i = num.length-1; i>= 0; i--) {
			System.out.print(num[i] + "\t");
		}
		System.out.println("\n");

	}
}

注：整数是以补码的形式转化为二进制代码存储在计算机中

实数是以IEEE754标准转化为二进制代码存储在计算机中

字符的本质与整数的存储方式相同

equals( )

import java.util.Arrays;
/*
 * 
 * Arrays.equals(数组1，数组2)
 * 
 *声明或赋值方式不同，但是数据元素顺序与长度相等，则为true
 */
public class D4 {
	public static void main(String[] args) {
		int[] num1 = { 12, 45, 66 };
		int num2[] = { 12, 45, 66 };
		int[] num3 = new int[]{12 ,45 ,66} ;

		System.out.println(Arrays.equals(num1, num2));
		System.out.println(Arrays.equals(num1, num3));

	}
}

fill()

copyOf( )

toString()

import java.util.Arrays;
/*
 * Arrays.fill(数组名，填充的数字)
 * Arrays.copyof(数组名，长度len）：复制长度len的数组，不够填充0
 * Arrays.toString(数组名）
 */
public class D5 {
	public static void main(String[] args) {
		int[] num = {12,45,56,8} ;
		
		Arrays.fill(num, 'a');// 等同于Arrays.fill(num,97);
		
		System.out.println(Arrays.toString(num));
		int[] num2 = Arrays.copyOf(num, 6) ;
		
		System.out.println(Arrays.toString(num2));
	}
}

binarySearch( )

import java.util.Arrays;
/*
 * Arrays.binarySearch(数组名，目标)
 * 二分查找，返回下标
 */
public class D4 {

	public static void main(String[] args) {
		int[] num = { 12, 45, 78, 13, 23, 56, 79, 43, 6, 45, 78 };
		Arrays.sort(num); // 升序排序
		System.out.println(Arrays.toString(num));
		int i = Arrays.binarySearch(num, 78);
		System.out.println(i);
	}
}

二维数组

数据类型[ ][ ] 数组名;

数据类型数组名[ ][ ];

二维数组本质上是一维数组，每个元素又是一个一维数组，二维数组的定义以及使用与一维数组基本相同

import java.util.Arrays;
public class D1 {
	public static void main(String[] args) {
		//定义二维数组
		int[][] a = new int[3][2];
		
		// a是二维数组名，存储存储a[0]、a[1]、a[2]的数组地址
		System.out.println(a);
		// a[0]是存储一维数组地址的空间
		System.out.println(a[0]);
		System.out.println(a[1]);
		// 将a转换成数组输出就是a[0]、a[1]、a[2]
		System.out.println(Arrays.toString(a));
		// 将a[0]转换成数组输出就是a[0][0]、a[0][1]
		System.out.println(Arrays.toString(a[0]));
		System.out.println(Arrays.toString(a[1]));

	}
}

import java.util.Arrays;
public class D2 {
	public static void main(String[] args) {
		// 二维数组支持长度不等赋值
		int[][] c = {{1,2,3},{1,2},{0}};
		// c 的内容就是一维数组的地址
		System.out.println(Arrays.toString(c));
		// c[0] 的内容就是对应一维数组的元素
		System.out.println(Arrays.toString(c[0]));
		System.out.println(Arrays.toString(c[1]));
		System.out.println(Arrays.toString(c[2]));
		
		// 注：定义多维数组时要定义最大维数，但是其内容是null
		int[][]  b = new int[3][] ; 
		System.out.println(Arrays.toString(b));
		// 故可对其重新赋值指向
		b[0] = new int[2] ;
		b[1] = new int[4] ;
		
		System.out.println(Arrays.toString(b));
		System.out.println(Arrays.toString(b[0]));
		System.out.println(Arrays.toString(b[1]));
		System.out.println(Arrays.toString(b[2]));
	
	}
}

多维数组

不存在多维数组，因为内存是线性唯一的

n维数组可以当做每个元素都是n-1维数组的一维数组

注：定义多维数组时要定义最大维数

import java.util.Arrays;
/*
 * 
 * 多维数组的复杂之处
 */
public class D3 {
	public static void main(String[] args) {
		// 注：定义多维数组时要定义最大维数，但是其内容是null
		int[][][] b = new int[5][][];
		System.out.println(Arrays.toString(b));
		
		//三维指向空二维
		b[0] = new int[5][] ;
		//三维指向空二维
		b[1] = new int[3][3] ;
		// 对空二维赋值一维
		b[0][0] = new int[5] ;
		
		System.out.println(Arrays.toString(b));
		
		System.out.println(Arrays.toString(b[0]));
		System.out.println(Arrays.toString(b[1]));
		System.out.println(Arrays.toString(b[2]));
		
		System.out.println(Arrays.toString(b[0][0]));
		System.out.println(Arrays.toString(b[1][2]));
		/*
		 * 多维数组逻辑比较复杂，可以不用过多的钻研，大致理解即可。
		 * 适当时候可以通过图形内存指向来表示加深理解
		 */
	}
}

循环嵌套

多重循环是指一个循环又包含另一个完整的循环结构，外层循环变量变化一次，内层循环从初始值到结束值变化一轮；

import java.util.Arrays;
/*
 * 冒泡排序
 */
public class D7 {
	public static void main(String[] args) {
		int[] a = new int[]{12,66,23,77,99,56,2};
		int temp ;
		
		//相邻起泡--- 升序
		for (int i = 0; i < a.length-1; i++) {
			for (int j = 0; j < a.length-1-i; j++) {
				if(a[j] > a[j+1]){
					temp = a[j] ;
					a[j] = a[j+1];
					a[j+1] = temp ;
				}
			}
		}		
		System.out.println(Arrays.toString(a));
		
		// 首起泡  --- 降序
		for (int i = 0; i < a.length-1; i++) {
			for (int j = i+1; j < a.length; j++) {
				if(a[i]<a[j]){
					temp = a[j] ;
					a[j] = a[i];
					a[i] = temp ;
				}
			}
		}
		System.out.println(Arrays.toString(a));

	}
}

foreach 语句为数组或对象集合中的每个元素重复一个嵌入语句组

foreach（数据类型标识符 : 表达式）

{

循环体

}

/*
 * 遍历二维数组
 */
public class D4 {
	public static void main(String[] args) {
		int[][] a = new int[5][3] ;
		for (int[] is : a) {
			for (int i : is) {
				System.out.println(i);
			}
		}
	}
}

break/continue 标签: 终止/跳过标签所标的代码块

public class D5 {
	public static void main(String[] args) {
		//out：标签
		out:for (int i = 0; i < 5; i++) {
			for (int j = 0; j < 4; j++) {
				if(j == 2){
					// 终止标签里的语句
					break out ;
				}
				System.out.println(i+"\t"+j);
			}
		}
	}
}