数组，数组类，SyStem类

最新推荐文章于 2023-07-12 21:53:02 发布

不会翘腚的皮柒柒

最新推荐文章于 2023-07-12 21:53:02 发布

阅读量406

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_46656574/article/details/108764496

版权

数组：

什么是数组

数组是具有相同的数据类型且按照一定的次序排列的一组变量的集合体。
用一个变量来表示一组数据。
java中数组在内存中分配一段连续的空间，这段空间中存储数据的个数是固定的

数组的特点

数组是序排列的
数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型
创建数组对象会在内存中开辟一整块连续的空间
数组的长度一旦确定，就不能修改。

使用数组的步骤

定义数组
为数组分配内存
数组元素初始化
使用

一维数组的声明与初始化

int num;//声明

num = 10;//初始化

int id = 1001;//声明 + 初始化
int[] ids;//声明

//1.1 静态初始化:数组的初始化和数组元素的赋值操作同时进行

ids = new int[]{1001,1002,1003,1004};

//1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行

String[] names = new String[5];

int[] arr4 = {1,2,3,4,5};//类型推断

分配内存

通过 new 来为数组分配内存空间

数组名 = new 数据类型[数组长度]; eg: nums = new int[10];

数据类型[] 数组名 = new 数据类型[数组长度]; eg: int[] nums = new int[10];
注意：数组的长度一旦指定，就不能改变了

数组的属性

array.length
说明：数组一旦初始化，其长度就是确定的。arr.length数组长度一旦确定，就不可修改。

遍历输出数组元素

//for循环遍历数组
for(int i = 0; i < nums.length; i ++){ 
	System.out.println(nums[i]); 
}
//for-each用法
for(int i : nums){ 
	System.out.prinln(i); 
}

for-each

		/*
		 *  for-each  数组可以使用for-each循环
		 *  
		 *  for(变量 : 被循环的变量){ 
		 *  	// 代码块
		 *  }
		 *  
		  *   每一次循环都会将 被循环的变量 的对应值赋值给 变量
		 */
		for(int num : nums) { // 可以理解为 for 循环中加入 int num = nums[i];
			System.out.println(num);
		}

数组常见问题

数组下标越界

java.lang.ArrayIndexOutOfBoundsException 原因是下标使用不正确，下标应是从0~数组长度-
空指针异常

java.lang.NullPointerException 我们操作了一个为 null 的变量

语法错误

//因为声明数组时，是没有数组长度的。没有这种写法 
	int array1[3] = new int[]{1,2,3}; 
//在数组声明时要有数组标识[],下面这种声明是声明一个int类型的变量。 
//在初始化时，数组的长度是根据初始化的情况来定的，不需要指定长度 
	int array2 = new int[3]{1,2,3}; 
//直接初始化数组，必须与声明写在一起 
	int array3[]; 
	array3 = {1,2,3};

冒泡排序

/**
* 升序冒泡排序 
* @param nums */ 
  public static void bubbleSort(int[] nums) { 
  //控制排序次数 
  for (int i = 0; i < nums.length - 1; i++) { 
      for (int j = 0; j < nums.length - 1 - i; j++) { 
          //如果前边的数大于后边的数，交换位置 
          if(nums[j] > nums[j + 1]) { 
              //定义临时变量存储值 
              int temp = nums[j]; 
              nums[j] = nums[j + 1]; 
              nums[j + 1] = temp; 
          } 
      } 
  } 
}

二维数组

如何理解二维数组？

数组属于引用数据类型
数组的元素也可以是引用数据类型
一个一维数组A的元素如果还是一个一维数组类型的，则，此数组A称为二维数组

二维数组的声明与初始化

		//静态初始化
		int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
		//动态初始化1
		String[][] arr2 = new String[3][2];
		//动态初始化2
		String[][] arr3 = new String[3][];
		//也是正确的写法：
		int[] arr4[] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};
		int[] arr5[] = {{1,2,3},{4,5},{6,7,8}};//类型推断

二维数组的遍历

//将二维数组遍历成一维数组 
for (int i = 0; i < nums1.length; i++) { 
//遍历输出一维数组 
	for (int j = 0; j < nums1[i].length; j++) { 
		System.out.print(nums1[i][j] + ","); 
	}
    //换行
    System.out.println(); 
}

工具类 java.util.Arrays：static方法可以直接使用类名.方法名()调用

Arrays.equals(a, a2)

判断引用是否一致
判断是否为 null，对于 null 返回 false
判断数组长度是否一致
判断数组中每个元素是否一样

System.out.println(Arrays.equals(nums, nums1)); // true

Arrays.toString(nums)

String result = "[";
		for (int i = 0; i < nums1.length; i++) {
			if(i == nums1.length - 1) {
				result = result + nums1[i] + "]";
			}else {
				result = result + nums1[i] + ", ";
			}
		}
//		
System.out.println(result);
//String str = Arrays.toString(nums);

println

		/*
		 * println(o)方法会执行 String.valueOf(o),
		 * String.valueOf(o)方法中会执行  o.toString()
		 *    类型名称 + @ + hash值
		 */

直接使用System.out.println(arr),得到的是（类型名称 + @ + hash值）一种地址值。

Arrays.sort(nums);

排序

Arrays.sort(nums);
System.out.println("排序后： " + Arrays.toString(nums));

二分搜索

二分搜索，必须先排序

int index = Arrays.binarySearch(nums, 90);
		
System.out.println("90 在数组中的下标是:" + index);

Arrays.fill(nums, 6)

将数组 nums 中的每个元素都填充为 6

Arrays.fill(nums, 6);;
System.out.println(Arrays.toString(nums));

复制数组

int[] newArr = Arrays.copyOf(nums, nums.length);
System.out.println(newArr == nums); // false
System.out.println(Arrays.equals(nums, newArr)); // true
		
int[] newArr1 = Arrays.copyOf(nums, 4);
System.out.println(Arrays.toString(newArr1));
		
// 复制数组的长度大于源数组的长度的话，大于源数组长度部分用数组数据类型的默认值填充
int[] newArr2 = Arrays.copyOf(nums, 14);
System.out.println(Arrays.toString(newArr2));

System

arraycopy(Object src, int srcPos, Object dest, int destPos, int length) ：将指定源数组中的数组从指定位置复制到目标数组的指定位置

src 源数组

srcPos 源数组中的起始位置

dest 目标数组

destPos 目的地数据中的起始位置

length 要复制的数组元素的数量

int[] src = {1, 2, 3, 4, 5};
		int[] dest = new int[3];
		System.arraycopy(src, 0, dest, 0, Math.min(src.length, dest.length));//
		System.out.println(Arrays.toString(dest));
		
		// 将数组中下标为 3 的元素删除掉  {1, 2, 3, 5}
		int[] nums = {1, 2, 3, 4, 5};
		int[] result = new int[nums.length - 1];

		// 先复制原数组 result.length 位
		result = Arrays.copyOf(nums, result.length);
		// 1, 2, 3, 4
		for (int i = 3; i < nums.length - 1; i++) {
			result[i] = nums[i + 1];
		}
		
		
//		for (int i = 0; i < nums.length - 1; i++) {
//			if (i >= 4) {
//				// 跳过删除元素
//				result[i] = nums[i + 1];
//			}else {
//				// 被删除元素之前 复制
//				result[i] = nums[i];
//			}
//		}
		System.out.println(Arrays.toString(result));