Java基础语法十（数组一）_java中int[] arr = new int[sc.nextint()]; for (int i-优快云博客

本文链接：https://blog.youkuaiyun.com/tiger_root/article/details/125820544

本文详细介绍了Java中的数组，包括数组的定义、特点、分类、内存分配以及操作方式。内容涵盖数组的基本概念如数组名、元素、索引，数组的创建、初始化，以及动态和静态初始化的区别。此外，还提供了键盘录入数组、生成随机数数组、计算平均成绩、数组元素排序和查找等示例代码，深入探讨了数组的常用操作。文章最后提到了常见的数组操作异常及冒泡排序和查找算法的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

数组

所谓的数组指的就是一组相关类型的变量集合，并且这些变量可以按照统一的方式进行操作，数组本身属于引用数据类型，那么既然是引用数据类型，这里面实际又会牵扯到内存分配，数组变量是引用（地址）型变量

数组相关概念：

1、数组名

2、元素

3、角标、下标、索引

4、数组的长度：元素的个数 length

数组的特点：

        数组是有序排列的

        数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型

        创建数组对象会在内存中开辟一整块连续的空间

        数组的长度一旦确定，就不能更改。

数组的分类：

按照维数：一维数组、二维数组、... ...

按照数组元素的类型：基本数据类型元素的按钮、引用类型元素的数组

数组的定义

1、声明并开辟数组

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

示例：int[] arr=new int[5];

初始化操作

arr[0]=10;

2、静态初始化数组

数组先开辟内存空间，而后使用索引进行内容的设置，实际上这种做法都叫做动态初始化，而如果希望数组在定义的时候可以同时出现设置内容，那么就可以采用静态初始化完成。

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

int[] arr = new int[]{3,5,1,7};

int[] arr={3,5,1,7};

数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。

数组的特点：数组的长度是固定的。

注：使用new关键字分配内存时，简单类型的数组中的元素都有初始值

数组元素的默认初始值

数组元素是整型：0

数组元素是浮点型：0.0

数组元素是char型：0或'\u0000'，而非'0'

数组元素是boolean类型：false，Oracle的JVM中采用byte[]方式进行存储

数组内存分配

数组是对象，也就是说可以以操作对象的方式来操作数组。并且数组在虚拟机中有它特别的类型。既然是对象，遵循Java语言中的规则所有类的顶层父类都是Object。数组的顶层父类也必须是Object，这就说明数组对象可以向上直接转型到Object，也可以向下强制类型转换，也可以使用instanceof关键字做类型判定

String[]的直接父类就是Object而不是Object[]。可是Object[]的引用也可以指向String[]类型的对象。数组类直接继承了Object，关于Object[]类型的引用能够指向String[]类型的对象，这种情况只能是Java语法之中的一个特例，并不是严格意义上的继承。也就是说，String[]继承自Object[]，但是我可以允许你向上转型到Object[]，这种特性是赋予你的一项特权。

数组类直接继承了Object，关于Object[]类型的引用能够指向String[]类型的对象，这种情况

只能是Java语法之中的一个特例，并不是严格意义上的继承。也就是说，String[]不继承自

Object[]，但是我可以允许你向上转型到Object[]，这种特性是赋予你的一项特权。

如果有两个类A和B，如果B继承extends了A，那么A[]类型的引用就可以指向B[]类型的对

象。

数组的操作方式

        数组的访问通过索引完成，即：数组名称[索引]，但是需要注意的是，数组的索引从0开始，所以索引的范围就是0 ~ 数组长度-1，例如开辟了3个空间的数组，所以可以使用的索引是0,1,2，如果此时访问的时候超过了数组的索引范围，会产生ArrayIndexOutOfBoundsException 异常

        当数组采用动态初始化开辟空间后，数组里面的每一个元素都是该数组对应数据类型的默认值

        数组本身是一个有序的集合操作，所以对于数组的内容操作往往会采用循环的模式完成，数组是一个有限的数据集合，所以应该使用 for 循环

        在 Java 中提供有一种动态取得数组长度的方式：数组名称.length；

        数组遍历通常使用for循环来实现。也可以用foreach实现

键盘录入数组6个整数，并输出

import java.util.Scanner;

public class Test1 {

	public static void main(String[] args) {
		// 1、键盘录入数组6个整数，并输出
		int[] arr = new int[6];
		Scanner sc = new Scanner(System.in);
		System.out.println("输出数：");
		for (int i = 0; i < arr.length; i++) {
			arr[i] = sc.nextInt();
		}
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + "\t");
		}
		sc.close();
	}

}

定义一个数组，存储6个0到100的随机数，并输出6个数字的和并打印

public class Test2 {

	public static void main(String[] args) {
		// 2、定义一个数组，存储6个0到100的随机数，并输出6个数字的和并打印
		int[] arr = new int[6];
//		int i = (int) Math.random() * 100;
//		Random r = new Random();
//		int s = r.nextInt(101);
		for (int i = 0; i < arr.length; i++) {
			double dd = Math.random() * 101;
			arr[i] = (int) dd;
			System.out.print(arr[i] + "\t");
		}
		int sum = 0;
		for (int i = 0; i < arr.length; i++) {
			sum += arr[i];
		}
		String ss = "";
		for (int i = 0; i < arr.length; i++) {
			ss += arr[i] + "+";
		}
		ss = ss.substring(0, ss.length() - 1) + "=" + sum;
		System.out.println("\n" + ss);
	}

}

定义一个数组来存储10个学生的成绩{72,89,65,87,91,82,71,93,76,68},计算并输出学生的平均成绩

public class Test3 {

	public static void main(String[] args) {
		// 3、定义一个数组来存储10个学生的成绩{72,89,65,87,91,82,71,93,76,68},计算并输出学生的平均成绩
		int[] arr = new int[] { 72, 89, 65, 87, 91, 82, 71, 93, 76, 68 };
		int sum = 0;
		for (int i = 0; i < arr.length; i++) {
			sum += arr[i];
		}
		int avg = sum / arr.length;
		String ss = "";
		for (int i = 0; i < arr.length; i++) {
			ss += arr[i] + "+";
		}
		ss = ss.substring(0, ss.length() - 1) + "=" + sum;
		System.out.println(ss + "\n学生的平均成绩为 " + avg);

	}

}

有一个数组，其中有十个元素从小到大依次排列 {12,14,23,45,66,68,70,77,90,91}。再通过键盘录入一个整数数字。要求：把数字放入数组序列中，生成一个新的数组，并且数组的元素依旧是从小到大排列的。

public class Test4 {

	public static void main(String[] args) {
		// 4、有一个数组，其中有十个元素从小到大依次排列{12,14,23,45,66,68,70,77,90,91}。再通过
		// 键盘录入一个整数数字。要求：
		int[] old = new int[] { 12, 14, 23, 45, 66, 68, 70, 77, 90, 91 };
		int kk = 56;
		int[] young = new int[old.length + 1];
		boolean bb = true;
		for (int i = 0; i < old.length; i++) {
			if (old[i] < kk) {
				young[i] = old[i];
			} else {
				if (bb) {
					young[i] = kk;
					bb = false;
				}
				young[i + 1] = old[i];
			}
		}
		if (bb) {
			young[old.length] = kk;
		}
		for (int i = 0; i < young.length; i++) {
			System.out.print(young[i] + "\t");
		}
	}

}

定义一个数组其中包含多个数字。用自己的方式最终实现，奇数放在数组的左边，偶数放在数组的右边。（可以创建其他数组，不必须在原数组中改变）

public class Test5 {

	public static void main(String[] args) {
		// 5、定义一个数组其中包含多个数字。用自己的方式最终实现，奇数放在数组的左边，偶数放在数组的右边
		int[] arr = new int[] { 12, 23, 27, 43, 56, 11, 7 };
		int[] newArr = new int[arr.length];
		int i = 0;
		int j = arr.length - 1;
		for (int k = 0; k < arr.length; k++) {
			if (arr[k] % 2 == 0) {
//				newArr[j--]=arr[k];
				newArr[j] = arr[k];
				j--;
			} else {
//				newArr[i++]=arr[k];
				newArr[i] = arr[k];
				i++;
			}
		}
		for (int k = 0; k < newArr.length; k++)
			System.out.print(newArr[k] + "\t");
	}

}

数组常见异常

1、NullPointerException 空指针异常

原因：引用类型变量没有指向任何对象，而访问了对象的属性或者是调用了对象的方法。

2、ArrayIndexOutOfBoundsException 索引值越界
原因：访问了不存在的索引值。数组角标越界异常:，注意：数组的角标从0开始。

public class Test3 {

	public static void main(String[] args) {
		// 空指针异常NullPointerException
//		int[] obj = null;
//		System.out.println(obj.length);
		// ArrayIndexOutOfBoundsException索引值越界
//		int[] arr = new int[] { 1, 2, 3, 4, 5 };
//		for (int i = 0; i <= arr.length; i++)
//			System.out.println(arr[i]);

	}

}

冒泡排序

随机生成20个整数，用冒泡排序排出

public class Test7 {

	public static void main(String[] args) {
		// 随机生成20个整数，用冒泡排序排出
		int[] arr = new int[20];
		for (int i = 0; i < arr.length; i++) {
			int cc = (int) (Math.random() * 101);
			arr[i] = cc;
		}
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + "\t");
		}
		for (int k = 1; k < arr.length; k++) {
			for (int i = 0; i < arr.length - k; i++) {
				if (arr[i] > arr[i + 1]) {
					int tmp = arr[i];
					arr[i] = arr[i + 1];
					arr[i + 1] = tmp;
				}
			}
		}
		System.out.println();
		for (int tmp : arr) { // foreach结构，简化的方法遍历数组中的所有元素
			System.out.print(tmp + "\t");
		}
//		for (int i = 0; i < arr.length; i++) {
//			System.out.print(arr[i] + "\t");
//		}

	}

}

查找算法

遍历查找

int i=0; 
for(;i<arr.length;i++){
    if(arr[i]==target){ 
        break; 
    } 
}
System.out.println(i);
时间复杂度为0(n)

折半查找

package com.yan1;

public class Test4 {

	public static void main(String[] args) {
		// 折半查找
		int[] arr = new int[21];
		for (int i = 0; i < arr.length; i++) {
			int cc = (int) (Math.random() * 101);
			arr[i] = cc;
			for (int j = 0; j < i; j++) {
				if (arr[j] == arr[i]) {
					i--;
					break;
				}
			}
		}

		arr[0] = 33;
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + "\t");
		}

		for (int k = 1; k < arr.length; k++) {
			for (int i = 0; i < arr.length - k; i++) {
				if (arr[i] > arr[i + 1]) {
					int tmp = arr[i];
					arr[i] = arr[i + 1];
					arr[i + 1] = tmp;
				}
			}
		}
		System.out.println();
		for (int tmp : arr) { // foreach结构，简化的方法遍历数组中的所有元素
			System.out.print(tmp + "\t");
		}
		System.out.println();

		int target = 33;

		int pos = -1;
		int m1 = 0;
		int m2 = arr.length - 1;
		boolean flag = false;

		while (m1 < m2) {
			pos = (m1 + m2) / 2;
			if (arr[pos] > target) {
				m2 = pos - 1;
			} else if (arr[pos] < target) {
				m1 = pos + 1;
			} else {
				flag = true;
				break;
			}
		}
		if (flag)
			System.out.println(pos + "::" + arr[pos]);
		else {
			System.out.println("找不到！");
		}
	}
}

数组逆序

package com.yan1;

public class Test2 {

	public static void main(String[] args) {
		int[] arr = new int[] { 4, 7, 8, 2, 1 };
//		arr = reverse(arr);
		reverse(arr);// 为什么？
		for (int tmp : arr) {
			System.out.print(tmp + "\t");
		}
	}

	public static int[] reverse(int[] arr) {
		for (int i = 0; i < arr.length / 2; i++) {
			int tmp = arr[i];
			arr[i] = arr[arr.length - i - 1];
			arr[arr.length - i - 1] = tmp;
		}
		return arr;
	}
//	public static void reverse(int[] arr) {
//		int start=0;
//		int end =arr.length-1;
//		while(start<end) {
//			int tmp=arr[start];
//			arr[start]=arr[end];
//			arr[end]=tmp;
//			start++;
//			end--;
//		}
//	}

}