Java 基础是学习 JavaEE、大数据、Android 开发的基石
- 1. 数组的概述
- 2. 一维数组的使用
- 3. 多维数组的使用
- 4. 二维数组打印杨辉三角
- 5. 求数组中元素的最大值、最小值、平均数、总和
- 6. 数组的复制、翻转
- 7. 数组的查找（线性查找、二分查找）
- 8. 数组的排序
- 9. Array 工具类的使用
- 10. 数组常见的异常
1 . 数组：多个相同数据类型按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
2 . 数组的常见概念：数组名、下标（索引）、元素、数组的长度（元素的个数）。
3 . 数组的特点：
- 数组是可以进行排序的。
- 数组本身属于引用数据类型，数组的元素既可以是基本数据类型，也可以是引用数据类型。
- 创建数组的对象会在内存中开辟一块连续的空间进行存储数据，数组名是这块地址的首地址。
- 数组的长度一旦确定就不能修改。
4 . 数组的分类：
- 按照维数：一维数组、二维数组…
- 按照数组元素的类型：基本数据类型的数组、引用数据类型的数组。
- 一维数组的声明和初始化
- 如何调用数组的指定位置的元素
- 如何获取数组的长度
- 如何遍历数组
- 数组元素的默认初始值
- 数组的内存解析
package day05;
public class Array {
public static void main(String[] args) {
// 1.一维数组的声明和初始化
// 声明
int[] ids;
// 静态初始化：数组的初始化和数组元素的赋值操作同时进行
ids = new int[]{1001,1002,1003,1004};
// 动态初始化：数组的初始化和数组元素的赋值操作分开进行
String[] names = new String[5];
// 2.如何调用数组的指定位置的元素：通过角标的方式调用
// 数组的角标（或索引）从0开始，到数组的长度-1结束
names[0] = "小明";
names[1] = "小黑";
names[2] = "小王";
names[3] = "小红";
names[4] = "小郭";
// 3.如何获取数组的长度
// 属性：length
System.out.println(names.length);
System.out.println(ids.length);
// 4.如何遍历数组元素
for(int i = 0;i < names.length;i ++) {
System.out.println(names[i]);
}
// 5.数组元素的默认初始值
// 数组元素是整型：0
// 数组元素是浮点型：0.0
// 数组元素是char型：0（数字零，不是'0'）
// 数组元素是boolean型：false
// 数组元素是引用数据类型：null
int[] arr = new int[4];
for(int i = 0;i < arr.length;i ++) {
System.out.println(arr[i]);
}
System.out.println("************");
short[] arr1 = new short[4];
for(int i = 0;i < arr1.length;i ++) {
System.out.println(arr1[i]);
}
System.out.println("************");
float[] arr2 = new float[4];
for(int i = 0;i < arr2.length;i ++) {
System.out.println(arr2[i]);
}
System.out.println("************");
char[] arr3 = new char[4];
for(int i = 0;i < arr3.length;i ++) {
System.out.println(arr3[i]);
}
System.out.println("************");
boolean[] arr4 = new boolean[4];
System.out.println(arr4[0]);
System.out.println("************");
String[] arr5 = new String[5];
System.out.println(arr5[0]);
}
}
数组的内存解析
栈中存放的声明的变量
堆中存放的 new 的对象、数组…
- Java 语言里提供了支持多维数组的语法。
- 如果说可以把一维数组当成几何中的线性图形，那么二维数组就相当于是一个表格。
- 对于二维数组的理解，我们可以看成一维数组又作为另一个一维数组的元素。其实，从数组的底层运行机制来看，其实没有多维数组。
- 二维数组的声明和初始化
- 如何调用数组的指定位置的元素
- 如何获取数组的长度
- 如何遍历数组
- 数组元素的默认初始值
- 数组的内存解析
package day05;
public class TwoArray {
public static void main(String[] args) {
// 1.二维数组的声明和初始化
// 静态初始化
int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
// 动态初始化
// 几种正确的写法
String[][] arr2 = new String[3][2];
String[][] arr3 = new String[3][];
int[] arr4[] = new int[][] {{1,2,3},{4,5},{6}};
int[] arr5[] = {{1,2,3},{4,5},{6}};
// 2.如何调用二维数组的指定位置的元素
System.out.println(arr1[0][1]); // 2
System.out.println(arr2[1][1]); // null
// System.out.println(arr3[1][0]); // 报错，空指针异常
// 3.获取二维数组的长度
// length 默认获取当前数组（二维数组可以看成两个一维数组的联结）的大小
System.out.println(arr4.length); // 3
System.out.println(arr4[1].length); // 2
// 4.如何遍历二维数组
for(int i = 0;i < arr4.length;i ++) {
for(int j = 0;j < arr4[i].length;j ++) {
System.out.println(arr4[i][j]);
}
}
// 5.二维数组的默认初始化值
// 针对初始化方式一：int[][] arr = new int[4][3];
// 外层元素的初始化值为：地址值
// 内存元素的初始化值为：与一维数组初始化值情况相同
// 针对初始化方式二：int[][] arr = new int[4][];
// 外层元素的初始化值为：null
// 内存元素的初始化值为：不能调用，报错，空指针异常
int[][] arr6 = new int[4][3];
System.out.println(arr6[0]); // 地址值：[I@59f95c5d
System.out.println(arr6[0][0]); // 0
System.out.println("******************");
float[][] arr7 = new float[4][3];
System.out.println(arr7[0]); // 地址值：[F@5ccd43c2
System.out.println(arr7[0][0]); // 0.0
System.out.println("******************");
String[][] arr8 = new String[4][3];
System.out.println(arr8[0]); // 地址值：[Ljava.lang.String;@368239c8
System.out.println(arr8[0][0]); // null
System.out.println("******************");
String[][] arr9 = new String[4][];
System.out.println(arr9[0]); // null
System.out.println(arr9[0][0]); // 报错：空指针异常
}
}
二维数组的内存解析
4. 二维数组打印杨辉三角要求：用数组打印一个 10 行的杨辉三角
规律：
- 第一行有 1 个元素，第 n 行有n个元素
- 每行的第一个元素和最后一个元素都是 1
- 从第三行起，每个数字等于它的左上方与右上方两个数字之和。
根据上面的图不难得出如下的计算规律公式：
yanghui [ i ][ j ] = yanghui [ i - 1 ][ j - 1 ] + yanghui [ i - 1 ][ j ]
package day05;
public class YangHui {
public static void main(String[] args) {
int[][] yanghui = new int[15][15];
yanghui[1][1] = 1;
yanghui[2][1] = 1;
yanghui[2][2] = 1;
for(int i = 3;i <= 10;i ++) {
for(int j = 1;j <= 10;j ++) {
yanghui[i][j] = yanghui[i - 1][j - 1] + yanghui[i - 1][j];
}
}
for(int i = 1;i <= 10;i ++) {
for(int j = 1;j <= 10;j ++) {
if(yanghui[i][j] != 0) System.out.print(yanghui[i][j]+" ");
}
System.out.println();
}
}
}
5. 求数组中元素的最大值、最小值、平均数、总和
定义一个 int 型的一维数组，包含 10 个元素，分别赋一些随机数
求出所有元素的最大值、最小值、平均值、总和，并输出出来
要求：所有的随机数都是两位数 [ 10 , 99 ]
公式：( int ) ( Math.random () * ( 99 - 10 + 1) + 10 )
math.random () ：随机选取大于 0.0 小于 1.0 的数
package day05;
import javax.sound.midi.Soundbank;
public class MaxMinAveSum {
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 = 0;
for(int i = 0;i < arr.length;i ++) {
if(maxValue < arr[i]) maxValue = arr[i];
}
System.out.println(maxValue);
// 最小值
int minValue = 100;
for(int i = 0;i < arr.length;i ++) {
if(minValue > arr[i]) minValue = arr[i];
}
System.out.println(minValue);
// 总和
int sumValue = 0;
for(int i = 0;i < arr.length;i ++) {
sumValue += arr[i];
}
System.out.println(sumValue);
// 平均值
int averValue = 0;
averValue = sumValue / arr.length;
System.out.println(averValue);
}
}
6. 数组的复制、翻转
package day05;
public class CopyReverse {
public static void main(String[] args) {
String[] arr = new String[] {"gg","jj","dd","bb","mm"};
// 数组的复制
String[] arr1 = new String[arr.length];
for(int i = 0;i < arr.length;i ++) {
arr1[i] = arr[i];
}
for(int i = 0;i < arr1.length;i ++) {
System.out.println(arr1[i]);
}
// 数组的翻转
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;i
7. 数组的查找（线性查找、二分查找）
package day05;
import java.util.Iterator;
public class Find {
public static void main(String[] args) {
String[] arr = new String[] {"gg","jj","dd","bb","mm"};
// 查找
// 线性查找
String dest = "bb";
boolean flag = true;
for(int i = 0;i < arr.length;i ++) {
if(dest.equals(arr[i])) {
System.out.println("找到了指定的元素，位置是：" + i);
flag = false;
break;
}
}
if(flag) {
System.out.println("很遗憾，未找到指定元素");
}
// 二分查找
// 前提：所要查找的数组必须有序
int[] arr1 = new arr1[] {-1,0,1,2,3,5,6,7,8,9};
int dest1 = 2;
int head = 0;
int end = arr1.length - 1;
boolean flag = true;
while(head <= end) {
int mid = (head + end) / 2;
if(dest1 == arr1[mid]) {
System.out.println("找到了指定元素，位置为：" + mid);
flag = false;
break;
}
if(arr1[mid] > dest1) end = mid - 1;
if(arr1[mid] < dest1) head = mid - 1;
}
if (flag) {
System.out.println("未找到指定元素");
}
}
}
8. 数组的排序
衡量排序算法的优劣
- 时间复杂度：分析关键字的比较次数和记录的移动次数
- 空间复杂度：分析排序算法中需要多少辅助内存
- 稳定性：若记录 A 和 B 的关键字值相等，但排序后 A 、B 的先后次序保持不变，则称这种排序算法是稳定的。
冒泡排序
package day05;
import java.util.Iterator;
public class BubbleSort {
public static void main(String[] args) {
int[] arr = new int[] {49,38,65,97,76,13,27,49};
for(int i = 0;i < arr.length - 1;i ++) {
for(int j = 0;j < arr.length - i - 1;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.println(arr[i]);
}
}
}
9. Array 工具类的使用
package day05;
import java.util.Arrays;
public class ArrayTool {
public static void main(String[] args) {
// 1.boolean equals(int[] a,int[] b)
// 比较两个数组是否相等
int[] arr1 = new int[] {1,2,3};
int[] arr2 = new int[] {1,3,2};
boolean isEquals = Arrays.equals(arr1,arr2);
System.out.println(isEquals);
// 2.String toString(int[] a)
// 输出数组信息
System.out.println(Arrays.toString(arr1));
// 3.void fill(int[] a,int b)
// 将指定值填充到数组中
Arrays.fill(arr1, 9);
System.out.println(Arrays.toString(arr1));
// 4.void sort(int[] a)
// 对数组进行排序（底层使用的是快速排序算法）
Arrays.sort(arr2);
System.out.println(Arrays.toString(arr2));
// 5.int binarySearch(int[] a,int key)
// 二分查找（前提是有序）
// 找到返回查找的元素的下标，没有找到返回负数
int index = Arrays.binarySearch(arr1, 2);
System.out.println(index);
}
}
10. 数组常见的异常
-
数组角标越界的异常：ArrayIndexOutOfBoundsExcetion
-
空指针异常：NullPointerException
