Java教程
3_数组（Java学习笔记）
本文主要是介绍3_数组（Java学习笔记），对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
1. 数组的概述
* 1.数组的理解：数组(Array)，是多个相同类型数据一定顺序排列的集合，并使用一个名字命名， * 并通过编号的方式对这些数据进行统一管理。 * 2.数组相关的概念： * >数组名 * >元素 * >角标、下标、索引 * >数组的长度：元素的个数 * 3.数组的特点： * ①数组是序排列的 * ②数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型 * ③创建数组对象会在内存中开辟一整块连续的空间 * ④数组的长度一旦确定，就不能修改。 * 4. 数组的分类： * ① 按照维数：一维数组、二维数组、。。。 * ② 按照数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组
2. 一维数组
package com.atguigu.java;
/*
一维数组的使用
* ①一维数组的声明和初始化
* ②如何调用数组的指定位置的元素
* ③如何获取数组的长度
* ④如何遍历数组
* ⑤数组元素的默认初始化值
* ⑥数组的内存解析
*
*/
public class ArrayTest {
public static void main(String[] args) {
//①一维数组的声明和初始化
int[] ids;//声明
//1.1静态初始化:数组的初始化和数组元素的赋值操作同时进行
ids = new int[]{1001, 1002, 1003, 1004};
//1.2动态初始化：数组的初始化和数组元素的赋值操作分开进行
String[] names = new String[5];
//②如何调用数组的指定位置的元素：通过角标的方式调用
names[0] = "王明";
names[1] = "张学良";
names[2] = "王皓";
names[3] = "李名";
names[4] = "王小二";
//③如何获取数组的长度
//属性：length
System.out.println(names.length);
System.out.println(ids.length);
//④如何遍历数组
for (int i = 0; i < names.length; i++) {
System.out.println(names[i]);
}
//⑤数组元素的默认初始化值
/*
* 数组元素是整型：0
* 数组元素是浮点型：0.0
* 数组元素是char型：0或'\u0000',而非'0'
* 数组元素是boolean型：false
* 数组元素是引用数据类型时:null
*/
int[] arr = new int[4];
System.out.println(arr);//[I@15db9742
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
String[] arr1 = new String[5];
System.out.println(arr1[0]);//null
//⑥数组的内存解析（要记住在内存中的结构图见下）
}
}
3. 二维数组
package com.atguigu.java;
/*
* 二维数组的使用：
* 1.理解：
* 其实就是数组的数组；从数组底层的运行机制来看，其实没多维数组。
*
* 2.二维数组的使用：
* ①一维数组的声明和初始化
* ②如何调用数组的指定位置的元素
* ③如何获取数组的长度
* ④如何遍历数组
* ⑤数组元素的默认初始化值
* ⑥数组的内存解析
*/
public class ArrayTest1 {
public static void main(String[] args) {
//①一维数组的声明和初始化
int[] arr = new int[]{1, 2, 3};//一维数组
//静态初始化
int[][] arr1 = new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8}};
//动态初始化
String[][] arr2 = new String[3][2];
String[][] arr3 = new String[3][];
//错误的情况
// String[][] arr4 = new String[][3];
//正确的情况
int arr7[][] = new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8}};
int[] arr5[] = new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8}};
int[] arr6[] = {{1, 2, 3}, {4, 5}, {6, 7, 8}};
//②如何调用数组的指定位置的元素
System.out.println(arr1[0][1]);//2
System.out.println(arr2[1][1]);//null
// System.out.println(arr3[1][0]);//报错
arr3[1] = new String[4];
System.out.println(arr3[1][0]);//null
//③如何获取数组的长度
System.out.println(arr5.length);//3
System.out.println(arr5[1].length);//2
//④如何遍历数组
for (int i = 0; i < arr5.length; i++) {
for (int j = 0; j < arr5[i].length; j++) {
System.out.print(arr5[i][j] + " ");
}
System.out.println();
}
//⑤数组元素的默认初始化值
/*
* 针对于初始化方式一：int[][] arr8 = new int[4][3];
* 外层元素的初始化值为：地址值
* 内层元素的初始化值为：与一维数组初始化情况相同
* 针对于初始化方式二：double[][] arr9 = new double[4][];
* 外层元素的初始化值为：null
* 内层元素的初始化值为：报错
*/
int[][] arr8 = new int[4][3];
System.out.println(arr8[0]);//[I@15db9742
System.out.println(arr8[0][0]);//0
System.out.println(arr8);//[[I@6d06d69c
double[][] arr9 = new double[4][];
System.out.println(arr9[1]);//null 之所以是null，因为数组的元素是引用类型的话，默认值为null，arr9[1]仍然是一个一维数组
// System.out.println(arr9[1][0]);//报错
//⑥数组的内存解析（要记住在内存中的结构图）见下
}
}
4. 数组的常见算法
package com.atguigu.java;
/*
数组中常见的算法：
1.数组元素的赋值（杨辉角、回形数等）
2.求数值型数组中元素的最大值、最小值、平均数、总和等
3.数组的复制、反转、查找（线性查找、二分法查找）
4.数组元素的排序算法
*/
public class ArrayTest2 {
public static void main(String[] args) {
//1.数组元素的赋值（杨辉角、回形数等
//杨辉角
//①声明并初始化二维数组
int[][] yangHui = new int[10][];
//②给数组的元素赋值
for (int i = 0; i < yangHui.length; i++) {
yangHui[i] = new int[i + 1];
//给首末元素赋值
yangHui[i][0] = 1;
yangHui[i][i] = 1;
//给每行的非首末元素赋值
if (i > 1) {
for (int j = 1; j < yangHui[i].length - 1; j++) {
yangHui[i][j] = yangHui[i - 1][j - 1] + yangHui[i - 1][j];
}
}
}
//③遍历二维数组
for (int i = 0; i < yangHui.length; i++) {
for (int j = 0; j < yangHui[i].length; j++) {
System.out.print(yangHui[i][j] + " ");
}
System.out.println();
}
//2.求数值型数组中元素的最大值、最小值、平均数、总和等
/*
* 定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，
然后求出所元素的最大值，最小值，和值，平均值，并输出出来。
要求：所随机数都是两位数。
[10,99]公式：Math.random()*(99 - 10 + 1) + 10
*/
int[] arr = new int[10];
for (int i = 0; i < arr.length; i++) {
arr[i] = (int) (Math.random() * (99 - 10 + 1) + 10);
}
//遍历
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
//最大值
int maxValue = arr[0];
for (int i = 0; i < arr.length; i++) {
if (maxValue < arr[i]) {
maxValue = arr[i];
}
}
System.out.println("最大值为：" + maxValue);
//最小值
int minValue = arr[0];
for (int i = 0; i < arr.length; i++) {
if (minValue > arr[i]) {
minValue = arr[i];
}
}
System.out.println("最小值为：" + minValue);
//总和
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
System.out.println("总和为：" + sum);
//平均值
int avgValue = sum / arr.length;
System.out.println("平均值为：" + avgValue);
//3.数组的复制、反转、查找（线性查找、二分法查找
/*
* 数组的复制
*/
int[] array1, array2;
array1 = new int[]{2, 3, 5, 7, 11, 13, 17, 19};
//赋值array2变量等于array1
//array2 = array1;//array1和array2地址值相同，都指向了堆空间的唯一的一个数组实体。这是赋值，并非复制
//数组的复制
array2 = new int[array1.length];
for (int i = 0; i < array2.length; i++) {
array2[i] = array1[i];
}
//数组的反转
//方法一：
for (int i = 0; i < array1.length / 2; i++) {
int temp = array1[i];
array1[i] = array1[array1.length - i - 1];
array1[array1.length - i - 1] = temp;
}
for (int i = 0; i < array1.length; i++) {
System.out.print(array1[i] + "\t");
}
System.out.println();
//方法二：
for (int i = 0, j = array1.length - 1; i < j; i++, j--) {
int temp = array1[i];
array1[i] = array1[j];
array1[j] = temp;
}
//数组的查找（线性查找、二分法查找
//线性查找：
String[] arr1 = new String[]{"JJ", "DD", "MM", "BB", "GG", "AA"};
String desc = "BB";
boolean isFlag = true;
for (int i = 0; i < arr.length; i++) {
if (desc.equals(arr1[i])) {
System.out.println("找到了指定的元素，位置为：" + i);
isFlag = false;
break;
}
}
if (isFlag) {
System.out.println("很遗憾，没找到哦！");
}
//二分法查找：前提必须是序的
int[] arr2 = new int[]{-98, -34, 2, 34, 54, 66, 79, 105, 210, 333};
int desc1 = -34;
int head = 0;//初始的首索引
int end = arr2.length - 1;//初始的末索引
boolean isFlag1 = true;
while (head <= end) {
int middle = (head + end) / 2;
if (desc1 == arr2[middle]) {
System.out.println("找到了指定的元素，位置为：" + middle);
isFlag1 = false;
break;
} else if (arr2[middle] > desc1) {
end = middle - 1;
} else {
head = middle + 1;
}
}
if (isFlag1) {
System.out.println("很遗憾，没找到哦！");
}
//4.数组元素的排序算法
/*排序算法分类：内部排序和外部排序。
十大排序算法：
择排序
直接择排序、堆排序
交换排序
冒泡排序、快速排序
插入排序
直接插入排序、折半插入排序、Shell排序
归并排序
桶式排序
基数排序
*/
//冒泡排序
//思路：一次冒泡排序出来最大值，二次冒泡排序出来第二大值...
int[] arr3 = new int[]{43, 32, 76, -98, 0, 64, 33, -21, 32, 99};
for (int i = 0; i <= arr3.length - 1; i++) {
for (int j = 0; j < arr3.length - i - 1; j++) {
if (arr3[j] > arr3[j + 1]) {
int temp = arr3[j];
arr3[j] = arr3[j + 1];
arr3[j + 1] = temp;
}
}
}
//快速排序
//思路：low、hight指针，例如arr3，一趟排序结束后，左边的都小于43，右边的都大于43，然后左右分而治之
//。。。（后续再补充）
}
}
4.1 数组的赋值与复制：
int[] array1,array2;
array1 = new int[]{1,2,3,4};
4.1.1 赋值：
array2 = array1;
如何理解：将array1保存的数组的地址值赋给了array2，使得array1和array2共同指向堆空间中的同一个数组实体。
4.1.2 复制：
array2 = new int[array1.length];
for(int i = 0;i < array2.length;i++){
array2[i] = array1[i];
}
如何理解：我们通过new的方式，给array2在堆空间中新开辟了数组的空间。将array1数组中的元素值一个一个的赋值到array2数组中。
4.2 数组的排序算法
理解：
1）衡量排序算法的优劣：
时间复杂度、空间复杂度、稳定性
2）排序的分类：内部排序 与 外部排序（需要借助于磁盘）
3）不同排序算法的时间复杂度
5. Arrays工具类的使用
package com.atguigu.java;
import java.util.Arrays;
/*
* java.util.Arrays:操作数组的工具类，里面定义了很多操作数组的方法
*
*/
public class ArraysTest {
public static void main(String[] args) {
//1.boolean equals(int[] a,int[] b):判断两个数组是否相等
int[] arr1 = new int[]{1,2,3,4};
int[] arr2 = new int[]{1,3,2,4};
boolean isEqueals = Arrays.equals(arr1, arr2);
System.out.println(isEqueals);
//2.String toString(int[] a):输出数组信息
System.out.println(Arrays.toString(arr1));
//3.void fill(int[] a,int val):将指定值填充到数组中
Arrays.fill(arr1,10);
System.out.println(Arrays.toString(arr1));
//4.void sort(int[] a):对数组进行排序
Arrays.sort(arr2);
System.out.println(Arrays.toString(arr1));
//5.int binarySearch(int[] a,int key):查找
int[] arr3 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
int index = Arrays.binarySearch(arr3, 210);
if(index >= 0){
System.out.println(index);
}else{
System.out.println("未找到");
}
}
}
6. 数组常见的异常
package com.atguigu.java;
/*
* 数组中的常见异常：
* 1.数组角标越界ArrayIndexOutOfBoundsExcetion
*
* 2.空指针异常NullPointerException
*
*/
public class ArrayException {
public static void main(String[] args) {
//1.角标越界
int[] arr = new int[]{1,2,3,4,5};
System.out.println(arr[-2]);
//2.空指针异常
//情况一：
int[] arr1 = new int[]{1,2,3};
arr1 = null;
System.out.println(arr1[0]);
//情况二：
int[][] arr2 = new int[4][];
System.out.println(arr2[0][0]);
//情况：
String[] arr3 = new String[]{"AA","BB","CC"};
arr3[0] = null;
System.out.println(arr3[0].toString());
}
}
小知识：一旦程序出现异常，未处理时，就终止执行。
这篇关于3_数组（Java学习笔记）的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
您可能喜欢
-
Mybatis官方生成器资料详解与应用教程11-26
-
Mybatis一级缓存资料详解与实战教程11-26
-
Mybatis一级缓存资料详解：新手快速入门11-26
-
SpringBoot3+JDK17搭建后端资料详尽教程11-26
-
Springboot单体架构搭建资料：新手入门教程11-26
-
Springboot单体架构搭建资料详解与实战教程11-26
-
Springboot框架资料：新手入门教程11-26
-
Springboot企业级开发资料入门教程11-26
-
SpringBoot企业级开发资料详解与实战教程11-26
-
Springboot微服务资料：新手入门全攻略11-26
-
SpringBoot微服务资料入门教程11-26
-
Springboot项目开发资料详解与入门指南11-26
-
SpringBoot项目开发资料详解入门教程11-26
-
SpringBoot应用的生产发布资料详解11-26
-
手写消息中间件：从零开始的指南11-26
栏目导航
