这篇博客详细介绍了Java中数组的概念、创建、访问、赋值、特性、遍历以及一些经典算法的实现，包括求最值、查找指定成员位置、数组逆序存储、冒泡排序和回文判断。此外，还涉及到了二维数组的创建和遍历。内容深入浅出，适合初学者学习。
目录
1 - 数组
1.1 - 数组的概念
数组本质上就是在内存空间中申请的一块连续的存储空间，用来记录多个类型相同的数据。
1.2 - 数组的创建
数组的定义
格式：数据类型[] 数组名称 = new 数据类型[数组的长度];
int[] arr = new int[10];//定义一个可以存储10个int类型数据的数组，初始值为0
数组的初始化
格式：数据类型[] 数组名称 = {成员1，成员2，成员3....};
int[] arr = {1,2,3,4,5,6,7,8,9,0};
前两种的结合
int[] arr = new int[]{1,2,3,4,5,6};
/**
* @author Mr.乐
* @data 2022/8/2 19:39
*/
public class Demo06 {
public static void main(String[] args) {
//数组的定义方式
int[] arr = new int[10];//在内存空开辟10个长度的大小
//数组初始化
int[] arr01 = {1,2,3,4,5,7,8,9,0};//jvm会根据实际参数开辟相对应的空间大小并赋初始值
//两个方法的结合
int[] arr02 = new int[]{1,2,3,4,5,7,8,9};
}
}
1.3 - 数组的访问和赋值
访问和赋值的格式：数组名[下标] 数组的下标从0开始，一直到数组长度减1
/**
* @author Mr.乐
* @data 2022/8/3 21:04
*/
public class Demo07 {
public static void main(String[] args) {
//使用定义的方式创建数组
int[] arr = new int[10]; //下标范围0~9
arr[0] = 1;
arr[9] = 10;
// arr[10] = 11;//异常，java.lang.ArrayIndexOutOfBoundsException
//访问和赋值时，注意数组下标越界的问题
//借助数组工具类中的toString方法打印数组内容
System.out.println(Arrays.toString(arr));//[1, 0, 0, 0, 0, 0, 0, 0, 0, 10]
//访问指定的下标对应的成员
System.out.println(arr[0]);//1
System.out.println(arr[1]);//数组初始值 0
//直接初始化创建数组
int[] arr01 = {1,2,3,4,5,6,7,8,9,0};//不但创建了数组，也进行了初始化
System.out.println(arr01.toString());//直接调用Object类中toString方法，打印地址
System.out.println(Arrays.toString(arr01));//调用工具类中的toString方法打印数组内容 [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
}
}
数组的默认初始值
创建不同类型的数组，默认初始值不同
| 数组类型 | 默认值 |
|---|---|
| byte short int long | 0 |
| float double | 0.0 |
| boolean | false |
| char | '\u0000'(空) |
| String | null |
数组的内存图
当执行int[] arr=new int[3]时，jvm会在堆中创建对应的内存地址，为0x0001,而arr引用存储在栈中，引用指向堆对象。arr02同理。
当arr=arr02执行时，arr02会把自己指向的堆内存的内存地址赋给arr，所以arr从指向0x0001变成0x0002。
1.4 - 数组的特性
1、数组中的成员占用的连续的存储空间
2、数组名为该数组的首地址，打印格式在堆内存中的地址
3、数组的成员访问时，注意不要下标越界
4、数组的成员数据类型必须相同
5、Java中数组长度一旦确定不能增减
1.5 - 数组的遍历
/**
* @author Mr.乐
* @data 2022/8/3 22:10
*/
public class Demo08 {
public static void main(String[] args) {
//使用初始化的方式创建数组
int[] score = {99,88,77,66,60,70,50};
//通过for循环遍历数组 -- 正向遍历
for (int i = 0; i < score.length; i++) { //score.length获取数组的长度
System.out.println("score[" + i + "] = " + score[i]);
}
System.out.println("--------------------------");
//通过for循环遍历数组 -- 反向遍历
for (int i = score.length - 1; i >= 0 ; i--) {
System.out.println("score[" + i + "] = " + score[i]);
}
System.out.println("----------------------------");
//增强版for循环，foreach
//前面放数组内部成员的类型 和临时变量，后面放想要遍历的数组的引用
for (int n: score) {
System.out.println(n);
}
}
}
1.6 - 数组的扩容以及拷贝
所谓的扩容，就是在创建一个新的数组，将原来数组内部的成员进行拷贝到新的数组中，就实现了数组的扩容。
/**
* @author Mr.乐
* @data 2022/8/3 22:30
*/
public class Demo09 {
public static void main(String[] args) {
int[] arr01 = {1,2,3,4,5,6,7,8,9,0};//数组一旦定义，长度不可改变
//方法一
int[] arr02 = new int[arr01.length * 2];//创建新数组，长度为原来数组的二倍
//循环拷贝数组中成员
for (int i = 0; i < arr01.length; i++) {
arr02[i] = arr01[i];//将arr01数组中的成员按照原来的位置转移到arr02数组中
}
System.out.println(Arrays.toString(arr02));//打印arr02的内容
//[1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
//方法二 参数1：原来数组的引用，参数2：新数组的长度 返回值是新的数组的引用
int[] arr03 = Arrays.copyOf(arr01, arr01.length * 2);
System.out.println(Arrays.toString(arr03));//查看数组内部的成员
//[1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
//方法三
int[] arr04 = new int[arr01.length * 2];//定义新数组，长度为原数组的二倍
//参数1：原数组引用 参数2：原数组起始位置 参数3：目标数组 参数4：目标数组的起始位置 参数5：复制多长的长度
System.arraycopy(arr01,0,arr04,0,10);
System.out.println(Arrays.toString(arr04));
//[1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
}
}
1.7 - 数组中的经典算法
1.7.1 求最值
/**
* @author Mr.乐
* @data 2022/8/3 22:48
*/
public class Demo10 {
public static void main(String[] args) {
int[] arr = new int[10];//定义一个数组
Random ran = new Random();//创建随机类对象
for (int i = 0; i < arr.length; i++) {//先确定数组对应的下标
arr[i] = ran.nextInt(100);//生成一个随机数，范围是0 ~ 99之间
}
System.out.println("数组的成员有：" + Arrays.toString(arr));
//找数组中的最大值
int max = arr[0];//将数组中第一个成员存放到认为是最大值的变量中
for (int i = 1; i < arr.length; i++) {
max = arr[i] > max ? arr[i] : max;
}
System.out.println("最大值为：" + max);//打印最大值
}
}
1.7.2 - 查找数组中指定成员的位置
/**
* @author Mr.乐
* @data 2022/8/3 23:11
*/
public class Demo11 {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6,7,8,9,6,0};//初始化方式创建数组
System.out.println("原数组中的成员：" + Arrays.toString(arr));
//获取用户的键盘输入
System.out.println("请输入想要查找的值：");
int num = new Scanner(System.in).nextInt();//创建扫描器对象,获取用户的键盘输入
int resIndex = 0;//用来记录值在数组中出现的位置
for (int i = 0; i < arr.length; i++) {
if(num == arr[i]){//用户输入的数值与数组中的成员进行比较
resIndex = i;//用来记录想找的值的位置
// break;//停止循环
System.out.println(arr[resIndex] + "在数组中出现的位置是：[" + resIndex + "]");
}
}
}
}
1.7.3 - 数组逆序存储
/**
* @author Mr.乐
* @data 2022/8/3 23:28
*/
public class Demo12 {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6,7,8,9,0};//初始化数组
System.out.println("数组逆序存储前的位置：");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t"); //"\t"表示制表符，代表4个空格
}
System.out.println();
//数组逆序算法
for (int i = 0,t; i < arr.length / 2; i++) {
// t = arr[i];//第一个数放到临时变量中
// arr[i] = arr[arr.length - 1 - i];
// arr[arr.length - 1 - i] = t;
arr[i] ^= arr[arr.length - 1 - i];
arr[arr.length - 1 - i] ^= arr[i];
arr[i] ^= arr[arr.length - 1 - i];
/*相当于
a ^= b;
b ^= a;
a ^= b;
* */
}
System.out.println("逆序之后的数组：" + Arrays.toString(arr));
}
}
1.7.4 - 数组成员排序（升序）冒泡法
/**
* @author Mr.乐
* @data 2022/8/4 23:11
*/
public class Demo13 {
public static void main(String[] args) {
int[] arr=new int[10];
Random ran =new Random();//创建随机类对象
//随机数方式初始化数组
for (int i = 0; i < arr.length; i++) {
arr[i] = ran.nextInt(100);//每次循环将一个随机数存放到数组的相对应下标的位置
}
System.out.println("排序前数组成员顺序：" + Arrays.toString(arr));
//冒泡排序算法
for (int i = 0; i < arr.length - 1; i++) { //0 ~ 8 一共9次，外循环控制比较次数
for (int j = 0; j < arr.length - 1 - i; j++) {//内循环控制前后两个数比较的次数
if(arr[j] > arr[j + 1]){//前后两个数进行比较
int t = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = t;
}
}
}
System.out.println("冒泡排序后：" + Arrays.toString(arr));
}
}
1.7.5 - 回文
/**
* @author Mr.乐
* @data 2022/8/4 23:34
*/
public class Demo14 {
public static void main(String[] args) {
System.out.println("请输入一串字符串：");
String str = new Scanner(System.in).nextLine();//通过扫描器获取用户键盘输入的字符串
//判断位相等
int i;//用来计算循环次数
for (i = 0; i <str.length()/2 ;i++) {
if (str.charAt(i) != str.charAt(str.length() - 1 - i)){//不相等时条件成立
break;//当不相等时，停止循环，i表示的就是一共循环的次数
}
}
//通过循环次数判断是不是回文1
if(i < (str.length() / 2)){
System.out.println(str + "不是回文！");
}else{
System.out.println(str + "是回文！");
}
}
}1.7.6 - 向有序数组中插入成员后仍保证数组原有顺序
/**
* @author Mr.乐
* @data 2022/8/4 23:51
*/
public class Demo15 {
public static void main(String[] args) {
int[] arr = new int[10];//定义10个长度的数组
//循环方式复制
for (int i = 0; i < arr.length - 1; i++) {
arr[i] = i + 1;
}
System.out.println("原数组存储形式" + Arrays.toString(arr));
//获取用户的键盘输入
System.out.println("请输入一个要插入的数值：");
int num = new Scanner(System.in).nextInt();
//先找到成员要插入的位置，然后将位置后面的成员依次向后移动一位，然后将要插入的数值放到指定的位置
int place;//定义位置
for (place = 0 ;place < arr.length - 1;place++){
if(num < arr[place]){//如果条件满足，说明找到了应该存放数据的位置
break;//找到位置直接跳出循环，记录下插入成员的位置
}
}
//将place后面的成员依次向后移动一位
for (int i = arr.length - 2; i >= place; i--) {
arr[i + 1] = arr[i];
}
//将数字插入到指定位置
arr[place] = num;
System.out.println("插入后的数组形式：" + Arrays.toString(arr));
}
}
2 - 二维数组
2.1 - 二维数组概念
二维数组本质上就是指有一维数组组成的数组，也就是说数组中的每个成员还是一个数组。
2.2 - 数组的创建
数组定义
格式：数据类型[][] 数组引用 = new 数据类型[行数][列数]；
int[][] arr = new int[2][3];
数组初始化
int[][] arr = {{1,2,3},{4,5,6}};//直接初始化
2.3 - 数组的遍历
/**
* @author Mr.乐
* @data 2022/8/5 0:15
*/
public class Demo16 {
public static void main(String[] args) {
/*
* 0 0 0
* 0 0 1
*
* */
//数组定义的方式创建数组
int[][] arr = new int[2][3];
//初始化方式创建数组
int[][] arr01 = {{1,2,3},{4,5,6}};
//指定位置进行赋值
arr[1][2] = 1;
arr[0][1] = 1;
//通过遍历二维数组进行赋值
for (int i = 0; i < 2; i++) {//外循环控制行
for (int j = 0; j < 3; j++) {//内循环控制列
arr[i][j] = j + 1;
}
}
//二维数组的遍历
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
System.out.print(arr[i][j] + "\t");
}
System.out.println();
}
}
}
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
