数组
数组
- 数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
- 数组的常见概念：数组名，下标(或索引)，元素，数组的长度
数组的概述
- 数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
- 创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。
- 数组的长度一旦确定，就不能修改。
- 我们可以直接通过下标(或索引)的方式调用指定位置的元素，速度很快。
- 数组的分类：
- 按照维度：一维数组、二维数组、三维数组、…
- 按照元素的数据类型分：基本数据类型元素的数组、引用数据类型元素的数组。
1. 一维数组
1. 声明与初始化
声明和初始化可分开使用
public class array {
public static void main(String[] args) {
int[] arr1 = new int[3];//动态初始化
arr1[0] = 3;
arr1[1] = 9;
arr1[2] = 8;
arr1[3] = 5;
//java.lang.ArrayIndexOutOfBoundsException下标越界异常
int[] arr2= {3,9,8};//静态态初始化
}
}
2. 元素的引用
定义并用运算符new为之分配空间后，才可以引用数组中的每个元素。
public class array {
public static void main(String[] args) {
int[] arr= {3,9,8};
//arr[下标]来索引数组的值
System.out.println(arr[0]);//3
System.out.println(arr[1]);//9
System.out.println(arr[2]);//8
//length是数组的长度属性
System.out.println(arr.length);//3
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);//遍历数组3，9，8
}
}
}
3. 数组元素初始值
- byte数组：0
- short数组：0
- int数组：0
- long数组：0 L
- float数组：0.0 f
- double数组：0.0
- char数组：0或’\u 0000 ’
- 引用数组：null
4. JVM 简单内存结构
2.二维数组
二维数组中的每一个元素可由一个一维数组组成
1. 初始化
public class array {
public static void main(String[] args) {
int[][] arr1 = new int[3][2];//动态初始化一
int[][] arr2 = new int[3][];//动态初始化二
arr2[0] = new int[3];
arr2[1] = new int[1];
arr2[2] = new int[2];
//int[][] arr3 = new int[][3];非法
int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};//静态初始化
}
}
2. JVM 简单内存
3. 数组中常见的算法
1. 数组元素的赋值(杨辉三角、回形数等)
//使用二维数组打印一个 10 行杨辉三角。
public class YangHuiTest {
public static void main(String[] args) {
//初始化二维数组
int[][] yangHui = new int[10][];
//给数组的元素赋值
for(int i = 0;i < yangHui.length;i++){
yangHui[i] = new int[i + 1];
//给首末元素赋值
yangHui[i][0] = yangHui[i][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个元素，分别赋一些随机整数，然后求出所有元素的最大值，最小值，和值，平均值并输出出来 。要求：所有随机数都是两位数。
*/
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);
}
//遍历
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i] + "\t");
}
System.out.println();
//求数组元素的最大值
int maxValue = arr[0];
for(int i = 1;i < arr.length;i++){
if(maxValue < arr[i]){
maxValue = arr[i];
}
}
System.out.println("最大值为：" + maxValue);
//求数组元素的最小值
int minValue = arr[0];
for(int i = 1;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.数组的复制、反转、查找(线性查找、二分法查找)
public class ArrayTest2 {
public static void main(String[] args) {
String[] arr = new String[]{"JJ","DD","MM","BB","GG","AA"};
//数组的复制(区别于数组变量的赋值：arr1 = arr)
String[] arr1 = new String[arr.length];
for(int i = 0;i < arr1.length;i++){
arr1[i] = arr[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,j = arr.length - 1;i < j;i++,j--){
// String temp = arr[i];
// arr[i] = arr[j];
// arr[j] = temp;
// }
//遍历
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i] + "\t");
}
System.out.println();
//查找（或搜索）
//线性查找：
String dest = "BB";
dest = "CC";
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("很遗憾，没有找到的啦！");
}
}
}
//二分法查找,所要查找的数组必须有序。
public class ArrayTest3 {
public static void main(String[] args) {
int[] arr2 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
int dest1 = -34;
dest1 = 54;
int head = 0;//初始的首索引
int end = arr2.length - 1;//初始的末索引
boolean isFlag1 = true;
while(head <= end){
int middle = (head + end)/2;
if(dest1 == arr2[middle]){
System.out.println("找到了指定的元素，位置为：" + middle);
isFlag1 = false;
break;
}else if(arr2[middle] > dest1){
end = middle - 1;
}else{//arr2[middle] < dest1
head = middle + 1;
}
}
if(isFlag1){
System.out.println("很遗憾，没有找到的啦！");
}
}
}
4.数组元素的排序算法
//冒泡排序
public class BubbleSortTest {
public static void main(String[] args) {
int[] arr = new int[]{43,32,76,-98,0,64,33,-21,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");
}
}
}
4. 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);//false
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]
//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[]{-98,-34,2,34,54,66,79,105,210,333};
int index = Arrays.binarySearch(arr3, 54);
if(index >= 0){
System.out.println(index);//4
}else{
System.out.println("未找到");
}
}
}
5. 数组中常见的异常
arr1[-2] = 5;//java.lang.ArrayIndexOutOfBoundsException下标越界异常
//1
int[] arr1 = new int[]{1,2,3};
arr1 = null;
System.out.println(arr1[0]);//java.lang.NullPointerException空指针异常
//2
int[][] arr2 = new int[4][];
System.out.println(arr2[0][0]);//java.lang.NullPointerException空指针异常
//3
String[] arr3 = new String[]{"AA","BB","CC"};
arr3[0] = null;
System.out.println(arr3[0].toString());//java.lang.NullPointerException空指针异常
