03-java数组的使用

文章列表

03-java数组的使用

概念

数组就是存储数据长度固定的容器，存储多个数据的数据类型要一致。

数组的定义格式

// 第一种格式
// 数据类型[] 数组名
int[] arr;        
double[] arr;      
char[] arr;// 第二种格式
// 数据类型 数组名[]
int arr[];
double arr[];
char arr[];

数组的动态初始化

什么是动态初始化

数组动态初始化就是只给定数组的长度，由系统给出默认初始化值

动态初始化格式

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

动态初始化格式详解

等号左边：
- int:数组的数据类型
- []:代表这是一个数组
- arr:代表数组的名称
等号右边：
- new:为数组开辟内存空间
- int:数组的数据类型
- []:代表这是一个数组
- 5:代表数组的长度

代码 :

package com.itheima.array;public class Demo2Array {/*数组的动态初始化:在初始化的时候, 需要手动指定数组的长度, 系统会为数组容器分配初始值.动态初始化格式:数据类型[] 数组名 = new 数据类型[数组的长度];注意:打印数组变量的时候, 会打印出数组的内存地址[I@10f87f48 :@ : 分隔符[ : 当前的空间是一个数组类型I : 当前数组容器中所存储的数据类型10f87f48 : 十六进制内存地址0 1 2 3 4 5 6 7 8 9 a b c d e f*/public static void main(String[] args) {// 数据类型[] 数组名 = new 数据类型[数组的长度];// 通过new关键字创建了一个int类型的数组容器, 该容器可以存储5个int类型的整数, 该容器被arr数组变量所记录int[] arr = new int[5];// [I@10f87f48System.out.println(arr);byte[] bArr = new byte[3];// [B@b4c966aSystem.out.println(bArr);}
}

数组的静态初始化

什么是静态初始化

在创建数组时，直接将元素确定

静态初始化格式

完整版格式  
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};简化版格式  
数据类型[] 数组名 = {元素1,元素2,...};

数组元素访问

什么是索引

每一个存储到数组的元素，都会自动的拥有一个编号，从0开始。

这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。

访问数组元素格式

数组名[索引];

内存概述

内存是计算机中的重要原件，临时存储区域，作用是运行程序。

我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的。

必须放进内存中才能运行，运行完毕后会清空内存。

Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。

数组操作的两个常见问题

索引越界异常

出现原因
数组长度为3，索引范围是0~2，但是我们却访问了一个3的索引。
程序运行后，将会抛出ArrayIndexOutOfBoundsException 数组越界异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。

public class ArrayDemo {public static void main(String[] args) {int[] arr = new int[3];System.out.println(arr[3]);}
}

解决方案
将错误的索引修改为正确的索引范围即可！

空指针异常

出现原因
arr = null 这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时候会抛出 NullPointerException 空指针异常。在开发中，空指针异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。

public class ArrayDemo {public static void main(String[] args) {int[] arr = new int[3];//把null赋值给数组arr = null;System.out.println(arr[0]);}
}

解决方案
给数组一个真正的堆内存空间引用即可！

数组常用操作

数组遍历

数组遍历：就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。
其实遍历的就两种,对象和数组.只是哪个遍历适用于哪个而已，后面会总结一下

package com.demo;import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;public class demo {public static void main(String[] args) {// 数组遍历方式String[] arrs = {"a", "b", "c"};// forfor (int i = 0; i < arrs.length; i++) {System.out.println(arrs[i]);}System.out.println("================");// for增强for (String str : arrs) {System.out.println(str);}System.out.println("================");// Iterator（迭代器）Iterator<String> iterator = Arrays.stream(arrs).iterator();while (iterator.hasNext()){String next = iterator.next();System.out.println(next);}System.out.println("================");//streamArrays.stream(arrs).forEach(System.out::println);// ArraysSystem.out.println(Arrays.toString(arrs));}
}

数组过滤/查找

常见过滤

代码实现：

public static void main(String[] args) {String[] arrs = {"a", "b", "c"};for (String arr : arrs) {if(!"a".equals(arr)){System.out.println("打印出不是a的值："+ arr);}}
}

二分查找 (理解)

注意事项:有一个前提条件，数组内的元素一定要按照大小顺序排列，如果没有大小顺序，是不能使用二分查找法的

二分查找概述

查找指定元素在数组中的位置时,以前的方式是通过遍历,逐个获取每个元素,看是否是要查找的元素,这种方式当数组元素较多时,查找的效率很低
二分查找也叫折半查找,每次可以去掉一半的查找范围,从而提高查找的效率

需求

在数组{1,2,3,4,5,6,7,8,9,10}中,查找某个元素的位置

实现步骤

定义两个变量，表示要查找的范围。默认min = 0 ，max = 最大索引
循环查找，但是min <= max
计算出mid的值
判断mid位置的元素是否为要查找的元素，如果是直接返回对应索引
如果要查找的值在mid的左半边，那么min值不变，max = mid -1.继续下次循环查找
如果要查找的值在mid的右半边，那么max值不变，min = mid + 1.继续下次循环查找
当min > max 时，表示要查找的元素在数组中不存在，返回-1.

代码实现

public class MyBinarySearchDemo {public static void main(String[] args) {int [] arr = {1,2,3,4,5,6,7,8,9,10};int number = 11;//1,我现在要干嘛? --- 二分查找//2.我干这件事情需要什么? --- 数组 元素//3,我干完了,要不要把结果返回调用者 --- 把索引返回给调用者int index = binarySearchForIndex(arr,number);System.out.println(index);}private static int binarySearchForIndex(int[] arr, int number) {//1,定义查找的范围int min = 0;int max = arr.length - 1;//2.循环查找 min <= maxwhile(min <= max){//3.计算出中间位置 midint mid = (min + max) >> 1;//mid指向的元素 > numberif(arr[mid] > number){//表示要查找的元素在左边.max = mid -1;}else if(arr[mid] < number){//mid指向的元素 < number//表示要查找的元素在右边.min = mid + 1;}else{//mid指向的元素 == numberreturn mid;}}//如果min大于了max就表示元素不存在,返回-1.return -1;}}

数据排序

冒泡排序

步骤

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

动图演示

03-java数组的使用

代码实现

public class Demo01 {public static void main(String[] args) {int[] arr = {3,4,1,2};int[] ints = bubbleSort(arr);Arrays.stream(ints).forEach(System.out::println);System.out.println(Arrays.toString(bubbleSort(arr)));}// 返回一个对原数组没有影响的排好序的新数组public static int[] bubbleSort(int[] sourceArray)   {// 对 arr 进行拷贝，不改变参数内容int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);for (int i = 1; i < arr.length; i++) {for (int j = 0; j < arr.length - i; j++) {if (arr[j] > arr[j + 1]) {int tmp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = tmp;}}}return arr;}
}

选择排序

步骤

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

动图演示

03-java数组的使用

代码实现

public class Demo01 {public static void main(String[] args) {int[] arr = {3,4,1,2};int[] ints = selectSort(arr);Arrays.stream(ints).forEach(System.out::println);}public static int[] selectSort(int[] arrs){int minIndex,temp;for (int i = 0; i < arrs.length-1; i++) {  // 注意，这里需要减一minIndex = i; // 默认最小值元素的索引for (int j = i+1; j < arrs.length; j++) {if(arrs[minIndex] > arrs[j]){  // 依次查找最小值的索引minIndex = j;}}if(minIndex != i){   // 如果最小值的索引不一样，交换位置temp = arrs[minIndex];arrs[minIndex] = arrs[i];arrs[i] = temp;}}return arrs;}
}

插入排序

步骤

将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。

从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。

说真的，说的有点迷糊，按照我的理解来说，举个例子, 玩牌，我们玩牌的时候怎么对牌进行排序

从所有牌中拿一个牌
第二次拿牌，比较和第一章那个大，然后排序
第三次，和前面那的两张牌比较，插入指定位置。。。
最后一次，拿到最后一张牌，和你手里的牌对比，插入指定位置

动图演示

03-java数组的使用

代码实现

public class Demo01 {public static void main(String[] args) {int[] arr = {3,4,1,2};int[] ints = insertSort(arr);Arrays.stream(ints).forEach(System.out::println);}public static int[] insertSort(int[] sourceArray) {// 对 arr 进行拷贝，不改变参数内容int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);// 从下标为1的元素开始选择合适的位置插入，因为下标为0的只有一个元素，默认是有序的for (int i = 1; i < arr.length; i++) {// 记录要插入的数据int tmp = arr[i];// 从已经排序的序列最右边的开始比较，找到比其小的数int j = i;while (j > 0 && tmp < arr[j - 1]) {arr[j] = arr[j - 1];j--;}// 存在比其小的数，插入if (j != i) {arr[j] = tmp;}}return arr;}
}

数组元素求和/字符串拼接

    public static void main(String[] args) {// 求和int[] arr = {1,2,3,4};int total = 0;for (int i : arr) {total += i;}System.out.println("合为："+total);String[] strs = {"a","b","c","d"};String str = "";for (String s : strs) {str += s;}System.out.println("拼接后的字符串为："+str);}

数组获取最大值

最大值获取：从数组的所有元素中找出最大值。
实现思路：
- 定义变量，保存数组0索引上的元素
- 遍历数组，获取出数组中的每个元素
- 将遍历到的元素和保存数组0索引上值的变量进行比较
- 如果数组元素的值大于了变量的值，变量记录住新的值
- 数组循环遍历结束，变量保存的就是数组中的最大值
代码实现：

package com.itheima.test;import java.util.Scanner;public class Test2Array {/*需求: 从数组中查找最大值int[] arr = {12,45,98,73,60};实现步骤:1. 假设数组中的第一个元素为最大值2. 遍历数组, 获取每一个元素, 准备进行比较3. 如果比较的过程中, 出现了比max更大的, 让max记录更大的值4. 循环结束后, 打印最大值.*/public static void main(String[] args) {int[] arr = {12,45,98,73,60};// 1. 假设数组中的第一个元素为最大值int max = arr[0];// 2. 遍历数组, 获取每一个元素, 准备进行比较for(int i = 1; i < arr.length; i++){// 3. 如果比较的过程中, 出现了比max更大的, 让max记录更大的值if(arr[i] > max){max = arr[i];}}//  4. 循环结束后, 打印最大值.System.out.println("max:" + max);}
}

Arrays (应用)

Arrays的常用方法

方法名	说明
public static String toString(int[] a)	返回指定数组的内容的字符串表示形式
public static void sort(int[] a)	按照数字顺序排列指定的数组
public static int binarySearch(int[] a, int key)	利用二分查找返回指定元素的索引

示例代码

public class MyArraysDemo {public static void main(String[] args) {//        public static String toString(int[] a)    返回指定数组的内容的字符串表示形式//        int [] arr = {3,2,4,6,7};//        System.out.println(Arrays.toString(arr));//        public static void sort(int[] a)      按照数字顺序排列指定的数组//        int [] arr = {3,2,4,6,7};//        Arrays.sort(arr);//        System.out.println(Arrays.toString(arr));//        public static int binarySearch(int[] a, int key) 利用二分查找返回指定元素的索引int [] arr = {1,2,3,4,5,6,7,8,9,10};int index = Arrays.binarySearch(arr, 0);System.out.println(index);//1,数组必须有序//2.如果要查找的元素存在,那么返回的是这个元素实际的索引//3.如果要查找的元素不存在,那么返回的是 (-插入点-1)//插入点:如果这个元素在数组中,他应该在哪个索引上.}}

工具类设计思想

1. 构造方法用 private 修饰
2. 成员用 public static 修饰

二维数组概述

概述 : 二维数组也是一种容器，不同于一维数组，该容器存储的都是一维数组容器

二维数组动态初始化

动态初始化格式：数据类型[][] 变量名 = new 数据类型[m][n];
m表示这个二维数组，可以存放多少个一维数组
n表示每一个一维数组，可以存放多少个元素

package com.itheima.demo;public class Demo1Array {/*动态初始化格式：数据类型[][] 变量名 = new 数据类型[m][n];m表示这个二维数组，可以存放多少个一维数组n表示每一个一维数组，可以存放多少个元素*/public static void main(String[] args) {// 数据类型[][] 变量名 = new 数据类型[m][n];int[][] arr = new int[3][3];/*[[I@10f87f48@ : 分隔符10f87f48 : 十六进制内存地址I : 数组中存储的数据类型[[ : 几个中括号就代表的是几维数组*/System.out.println(arr);/*二维数组存储一维数组的时候, 存储的是一维数组的内存地址*/System.out.println(arr[0]);System.out.println(arr[1]);System.out.println(arr[2]);System.out.println(arr[0][0]);System.out.println(arr[1][1]);System.out.println(arr[2][2]);// 向二维数组中存储元素arr[0][0] = 11;arr[0][1] = 22;arr[0][2] = 33;arr[1][0] = 11;arr[1][1] = 22;arr[1][2] = 33;arr[2][0] = 11;arr[2][1] = 22;arr[2][2] = 33;// 从二维数组中取出元素并打印System.out.println(arr[0][0]);System.out.println(arr[0][1]);System.out.println(arr[0][2]);System.out.println(arr[1][0]);System.out.println(arr[1][1]);System.out.println(arr[1][2]);System.out.println(arr[2][0]);System.out.println(arr[2][1]);System.out.println(arr[2][2]);}
}

二维数组静态初始化

代码实现 :

package com.itheima.demo;public class Demo3Array {/*完整格式：数据类型[][] 变量名 = new 数据类型[][]{ {元素1, 元素2...} , {元素1, 元素2...} ...};简化格式: 数据类型[][] 变量名 = { {元素1, 元素2...} , {元素1, 元素2...} ...};*/public static void main(String[] args) {int[] arr1 = {11,22,33};int[] arr2 = {44,55,66};int[][] arr = {{11,22,33}, {44,55,66}};System.out.println(arr[0][2]);int[][] array = {arr1,arr2};System.out.println(array[0][2]);}
}

二维数组遍历

需求 :

已知一个二维数组 arr = {{11, 22, 33}, {33, 44, 55}};

遍历该数组，取出所有元素并打印

步骤 :

遍历二维数组，取出里面每一个一维数组
在遍历的过程中，对每一个一维数组继续完成遍历，获取内部存储的每一个元素

代码实现 :

package com.itheima.test;public class Test1 {/*需求:已知一个二维数组 arr = {{11, 22, 33}, {33, 44, 55}};遍历该数组，取出所有元素并打印步骤:1. 遍历二维数组，取出里面每一个一维数组2. 在遍历的过程中，对每一个一维数组继续完成遍历，获取内部存储的每一个元素*/public static void main(String[] args) {int[][] arr = {{11, 22, 33}, {33, 44, 55}};// 1. 遍历二维数组，取出里面每一个一维数组for (int i = 0; i < arr.length; i++) {//System.out.println(arr[i]);// 2. 在遍历的过程中，对每一个一维数组继续完成遍历，获取内部存储的每一个元素//int[] temp = arr[i];for (int j = 0; j < arr[i].length; j++) {System.out.println(arr[i][j]);}}}
}

二维数组求和

需求 :

某公司季度和月份统计的数据如下：单位(万元)
第一季度：22,66,44
第二季度：77,33,88
第三季度：25,45,65
第四季度：11,66,99

步骤 :

定义求和变量，准备记录最终累加结果
使用二维数组来存储数据，每个季度是一个一维数组，再将4个一维数组装起来
遍历二维数组，获取所有元素，累加求和
输出最终结果

代码实现 :

package com.itheima.test;public class Test2 {/*需求:某公司季度和月份统计的数据如下：单位(万元)第一季度：22,66,44第二季度：77,33,88第三季度：25,45,65第四季度：11,66,99步骤:1. 定义求和变量，准备记录最终累加结果2. 使用二维数组来存储数据，每个季度是一个一维数组，再将4个一维数组装起来3. 遍历二维数组，获取所有元素，累加求和4. 输出最终结果*/public static void main(String[] args) {// 1. 定义求和变量，准备记录最终累加结果int sum = 0;// 2. 使用二维数组来存储数据，每个季度是一个一维数组，再将4个一维数组装起来int[][] arr = { {22,66,44} , {77,33,88} , {25,45,65} , {11,66,99}};// 3. 遍历二维数组，获取所有元素，累加求和for (int i = 0; i < arr.length; i++) {for(int j = 0; j < arr[i].length; j++){sum += arr[i][j];}}// 4. 输出最终结果System.out.println(sum);}
}

03-java数组的使用

概念

数组的定义格式

数组的动态初始化

什么是动态初始化

动态初始化格式

动态初始化格式详解

数组的静态初始化

什么是静态初始化

静态初始化格式

数组元素访问

什么是索引

访问数组元素格式

内存概述

数组操作的两个常见问题

索引越界异常

空指针异常

数组常用操作

数组遍历

数组过滤/查找

常见过滤

二分查找 (理解)

数据排序

冒泡排序

选择排序

插入排序

数组元素求和/字符串拼接

数组获取最大值

Arrays (应用)

二维数组概述

二维数组动态初始化

二维数组静态初始化

二维数组遍历

二维数组求和

公告

DeepSeek全套部署资料免费下载

免费可商用字体批量下载

标签

03-java数组的使用

概念

数组的定义格式

数组的动态初始化

什么是动态初始化

动态初始化格式

动态初始化格式详解

数组的静态初始化

什么是静态初始化

静态初始化格式

数组元素访问

什么是索引

访问数组元素格式

内存概述

数组操作的两个常见问题

索引越界异常

空指针异常

数组常用操作

数组遍历

数组过滤/查找

常见过滤

二分查找 (理解)

数据排序

冒泡排序

选择排序

插入排序

数组元素求和/字符串拼接

数组获取最大值

Arrays (应用)

二维数组概述

二维数组动态初始化

二维数组静态初始化

二维数组遍历

二维数组求和

相关问题

公告

DeepSeek全套部署资料免费下载

免费可商用字体批量下载

标签