Java基础-----------数组
文章目录
一、一维数组
1.数组的理解：数组(array)是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
2.数组的相关概念：
- 数组名
- 元素
- 角标、下标、索引
- 数组的长度：元素的个数
3.数组的特点：数
- ①数组是有序排列的
- ②数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型
- ③创建数组对象会在内存中开辟一整块连续的空间
- ④数组的长度一旦确定，就不能修改
4.数组的分类：
- ① 按照维数：一维数组、二维数组…
- ② 按照数组元素的类型：基本数据类型数组、引用数据类型数组
5.一维数组的使用
-
① 一维数组的声明和初始化
-
② 如何调用数组的指定位置的元素
-
③ 如何获取数组的长度
-
④ 如何遍历数组
public class ArrayTest { public static void main(String[] args) { // 1.一维数组的声明和初始化 int[] ids;// 声明 //1.1 静态初始化:数组的初始化和数组元素的赋值操作同时进行 ids = new int[] {1001, 1002, 1003, 1004};// 初始化 //1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行 String[] names = new String[5]; // 总结：数组一旦初始化完成，其长度就确定了。 // 2.如何调用数组的指定位置的元素：通过角标的方式调用。 // 数组的角标(或索引)从0开始，到数组的长度-1结束。 names[0] = "Marry"; names[1] = "Allen"; names[2] = "Jack"; names[3] = "Sarah"; names[4] = "Jimmy"; // charAt(0) // 3.如何获取数组的长度 // 属性：length System.out.println(names.length); //5 System.out.println(ids.length);//4 // 4.如何遍历数组 for(int i = 0; i < names.length; i++) { System.out.println(names[i]); } } } -
⑤ 数组元素的默认初始化值: 见ArrayTest1.java
数组元素是整型：默认都是0
数组元素是浮点型：默认都是0.0
数组元素是char型：默认0或\u0000, 而非’0’
数组元素是boolean型：默认false
数组元素是引用数据类型：默认null
public class ArrayTest1 { public static void main(String[] args) { //5.数组元素的默认初始化值 int []arr = new int[4]; for(int i = 0; i < arr.length; i++) { System.out.println(arr[i]); // 0 } float []arr1 = new float[4]; for(int i = 0; i < arr1.length; i++) { System.out.println(arr1[i]);// 0.0 } String []arr2 = new String[5]; System.out.println(arr2[0]); // null } -
⑥ 数组的内存解析: 见ArrayTest1.java
二、二维数组
1.理解
对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。
其实，从数组底层的运行机制来看，其实没有多维数组。
2.二维数组的使用
① 二维数组的声明和初始化
-
② 如何调用数组的指定位置的元素
-
③ 如何获取数组的长度
-
④ 如何遍历数组
public class ArrayTest2 { public static void main(String[] args) { //1.二维数组的声明和初始化 int[] arr = new int[]{1,2,3};//一维数组 // 静态初始化 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][]; // 错误的情况 // String[][] arr4 = new String[][4]; //2.如何调用数组指定位置的元素 System.out.println(arr1[0][2]); // 3 System.out.println(arr2[1][1]); // null //3.获取数组的长度 System.out.println(arr1.length); //3 System.out.println(arr1[0].length); //3 //4.如何遍历二维数组 for(int i = 0; i < arr1.length; i++) { for(int j = 0; j < arr1[i].length; j++) { System.out.print(arr1[i][j] + " "); } System.out.println(); } } } -
⑤ 数组元素的默认初始化值：见ArrayTest3.java
规定：二维数组分为外层数组的元素，内层数组的元素
int[][] arr = new int[4][3]; 外层元素:
arr[0], arr[1]等 内层元素：
arr[0][0], arr[1][2]等 针对初始化方式一：比如：
int[][] arr = new int[4][3]; 外层元素的初始化值为：地址值
内层元素的初始化值为：与一维数组初始化情况相同
针对初始化方式二：比如：
int[][] arr = new int[4][]; 外层元素的初始化值为：null
内层元素的初始化值为：不能调用，否则报错
public class ArrayTest3 { public static void main(String[] args) { int[][] arr = new int[4][3]; System.out.println(arr[0]); // [I@3d012ddd 地址值 System.out.println(arr[0][0]); // 0 } } -
⑥ 数组的内存解析：见ArrayTest3.java
三、应用练习
算法考察
3.1 求数值型数组中元素的最大值、最小值、平均数、总和等
定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，然后求出所有元素的最大值，最小值，和值、平均值，并输出出来。 要求所有的随机数都是两位数。
随机生成两位数公式：
eg：随机生成[10,99]
(int)(Math.random() * (99 - 10 + 1) + 10)
public class ArrayTest1 {
public static void main(String[] args) {
int [] arr = new int[10];
for(int i = 0;i < arr.length; i++) {
arr[i] = (int)(Math.random() * (99 - 10 + 1) + 10);
}
// 求数组的最大值
int maxValue = arr[0];
for(int i = 1; i < arr.length; i++) {
if(arr[i] > maxValue) {
maxValue = arr[i];
}
}
System.out.println("最大值为：" + maxValue);
// 求数组元素的最小值
int minValue = arr[0];
for(int i = 1; i < arr.length; i++) {
if(arr[i] < minValue) {
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.2 数组的复制、反转、查找(线性查找，二分查找)
public class ArrayTest2 {
public static void main(String[] args) {
String[] arr = new String[] {"AA", "bb", "cc", "dd", "ee"};
// 数组的复制
String[] arr1 = new String[arr.length];
for(int i = 0; i < arr1.length; i++) {
arr1[i] = arr[i];
}
for(int i = 0; i < arr1.length; i++) {
System.out.print(arr1[i] + "\t");
}
System.out.println();
// 数组的反转
// 反转操作方式一：
// for(int i = 0; i < arr.length / 2; i++) {
// String temp = arr[i];
// arr[i] = arr[arr.length - i -1];
// arr[arr.length - i -1] = temp;
// }
//
// 方式二：
// for(int i = 0,j = arr.length -1; i < j; i++, j--) {
// String temp = arr[i];
// arr[i] = arr[arr.length - i -1];
// arr[arr.length - i -1] = temp;
// }
// 遍历
for(int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
// 查找(搜索)
// 线性查找:
String dest = "bb";
boolean isFlag = true;
for(int i = 0; i < arr.length; i++) {
if(dest.equals(arr[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 dest1 = -34;
int head = 0; //初始首索引
int end = arr2.length - 1; // 初始末索引
boolean isFlag = true;
while(head > end) {
int middle = (head + end) / 2;
if(dest1 == arr2[middle]) {
System.out.println("找到了指定的元素，位置为：" + middle);
isFlag = true;
break;
}else if(arr2[middle] > dest1){
end = middle - 1;
}else { // arr2[middle] < dest1
head = middle + 1;
}
}
if(isFlag) {
System.out.println("很遗憾，没有找到！");
}
}
}
3.3 使用简单数组
- (1)创建一个名为AarryExer2的类，在main()方法中声明array1和array2两个变量，他们是int[]型数组。
- (2)使用大括号{}，把array1初始化为素数：2, 3, 5, 7, 11, 13, 17, 19.
- (3)显示array1的内容。
- (4)赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值(如
array[0]=0,array[2]=2) - 打印array1。
- 思考:array1 和 array2是什么关系？
- array1和array2地址值相同，都指向了堆空间的唯一的一个数组实体。
- 拓展：修改题目，实现array2对array1数组的复制
public class ArrayExer2 {
public static void main(String[] args) {
int[] array1, array2;
array1 = new int[]{2, 3, 5, 7, 11, 13, 17, 19};
// 显示array1的内容
for(int i = 0; i < array1.length; i++) {
System.out.print(array1[i] + "\t");
}
//赋值array2变量等于array1
// 不能称作数组的复制
array2 = array1;
// 修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)
for(int i = 0; i < array2.length; i++) {
if(i % 2 == 0) {
array2[i] = i;
}
}
System.out.println();
// 打印array1
for(int i = 0; i < array1.length; i++) {
System.out.print(array1[i] + "\t");
}
}
}
3.4 拓展：修改题目，实现array2对array1数组的复制
public class ArrayExer3 {
public static void main(String[] args) {
int[] array1, array2;
array1 = new int[]{2, 3, 5, 7, 11, 13, 17, 19};
// 显示array1的内容
for(int i = 0; i < array1.length; i++) {
System.out.print(array1[i] + "\t");
}
// 数组的复制
array2 = new int[array1.length];
for(int i = 0; i < array2.length; i++) {
array2[i] = array1[i];
}
// 修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)
for(int i = 0; i < array2.length; i++) {
if(i % 2 == 0) {
array2[i] = i;
}
}
System.out.println();
// 打印array1
for(int i = 0; i < array1.length; i++) {
System.out.print(array1[i] + "\t");
}
}
}
3.5 排序
3.5.1 冒泡排序
public class BubbleSortTest {
public static void main(String[] args) {
int[] arr = new int[] {43, 23, 76, -98, 64, 33, 23, 32, 99};
// 冒泡排序
for(int i = 0; i < arr.length -1; i++) {
for(int j = 0; j < arr.length - 1 - i; j++){
if(arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
for(int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
}
}
3.5.2 快速排序
3.6 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 isEquals = Arrays.equals(arr1, arr2);
System.out.println(isEquals);
// 2. String toString(int[], a):输出数组信息
System.out.println(Arrays.toString(arr1)); //[1, 2, 3, 4]
// 3. void fill(int[] a, int val):将指定的值填充到数组当中
Arrays.fill(arr1, 10);
System.out.println(Arrays.toString(arr1));//[10, 10, 10, 10]将数组中所有的值都替换成10
// 4. void sort(int[] a):对数组进行排序
Arrays.sort(arr2);
System.out.println(Arrays.toString(arr2)); //[1, 2, 3, 4]
// 5. int binarySearch(int[] a, int[] key)
int[] arr3 = new int[] {23, 28, 30, 35, 37, 39, 40, 51};
int index = Arrays.binarySearch(arr3, 30);
System.out.println(index); //2 负数就是没找到
}
}
3.7 数组使用中的常见异常
数组中常见的异常：
- 1.数组角标越界的异常：ArrayIndexOutOfBoundsExcetion
- 2.空指针异常：NullPointerException
public class ArrayExceptionTest {
public static void main(String[] args) {
// 1.数组角标越界的异常：ArrayIndexOutOfBoundsExcetion
int[] arr = new int[] {1, 2, 3, 4, 5};
// for(int i = 0; i <= arr.length; i++) {
// System.out.println(arr[i]);
// }
// System.out.println(arr[-2]); 也属于越界
// 2.空指针异常：NullPointerException
// 情况一：
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]);// 报错
}
}
4783
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
