本文详细介绍了Java中的数组，包括数组的概念、特点、分类、一维数组和二维数组的使用。讲解了数组的声明、初始化、元素访问、长度获取、遍历以及默认初始化值。还探讨了二维数组的逻辑结构和初始化后的默认值。此外，通过示例展示了冒泡排序和快速排序算法，并介绍了Java中Arrays工具类的使用，如数组比较、打印、填充和排序。最后提到了数组使用过程中可能遇到的异常，如数组角标越界和空指针异常。
1.数组的概述
1.1 数组的理解：
数组（Array），是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
1.2 数组相关的概念：
- 数组名
- 元素
- 下标、下标、索引
- 数组的长度：元素个数
1.3 数组的特点：
- 数组是有序列排列的
- 数组属于引用数据类型的变量。数组的元素。既可以是基本数据类型，也可以是引用数据类型
- 创建数组对象会在内存中开辟一块连续的空间
- 数组的长度一旦确定，就不能修改。
1.4 数组的分类
- 按照维度：一维数组、二维数组…
- 按照数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组
1.5 一维数组的使用
- 一维数组的声明和初始化
- 如何调用数组的指定位置的元素
- 如何获取数组的长度
- 如何遍历数组
- 数组元素的默认初始化值:
-
- 数组元素是整型：0
-
- 数组元素是浮点型：0.0
-
- 数组元素是char型：0或’\u0000’，而非’0’
-
- 数组元素是boolean型：false
-
- 数组元素是引用数据类型：null
- 数组的内存解析
class ArrayTest{
public static void main(String[] args){
//一维数组的声明和初始化
//静态初始化:数组的初始化和数组元素的赋值操作同时进行
int[] ids;//声明
ids = new int[]{1001,1002,1003,1004};
int[] ids2 = {1001,1002,1003,1004};//类型推断
//动态初始化:数组的初始化和数组元素的赋值操作分开进行
String[] names = new String[5];
//总结：数组一旦初始化完成，其长度就确定了
//如何调用数组指定位置的元素：通过索引的方式调用
//素组的索引是从0开始的，到数组的长度-1结束
names[0] = "小A";
names[1] = "小B";
names[2] = "小C";
names[3] = "小D";
names[4] = "小E";
//如何获取数组的长度
//属性：length
System.out.println(ids.length);
System.out.println(names.length);
System.out.println("=========================");
//如何遍历数组
for(int i = 0;i < names.length;i++){
System.out.println(names[i]);
}
System.out.println("=========================");
//数组元素的默认初始化值
int[] arr = new int[3];
for(int i = 0;i < arr.length;i++){
System.out.println(arr[i]);
}
System.out.println("=========================");
double[] arr_d = new double[3];
for(int i = 0;i < arr_d.length;i++){
System.out.println(arr_d[i]);
}
System.out.println("=========================");
char[] arr_c = new char[3];
for(int i = 0;i < arr_c.length;i++){
System.out.println(arr_c[i]);
}
System.out.println("=========================");
boolean[] arr_b = new boolean[3];
for(int i = 0;i < arr_b.length;i++){
System.out.println(arr_b[i]);
}
System.out.println("=========================");
String[] arr_s = new String[5];
System.out.println(arr_s[0]);
}
}
1.6 二维维数组的使用
1.6.1 理解：
对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素存在。其实，从数组底层的机制来看，其实没有二维数组。
规定：二维数组分别为外层数组的元素，内层数组的元素
int[][] arr = new int[4][3];
外层元素：arr[0],arr[1]等
内层元素：arr[0][0]等
1.6.2 数组元素的默认初始化值：
针对初始化方式一：int[][] arr = new int[4][3];
外层元素的初始化值为：地址值
内层元素的初始化值为：与一维数组初始化情况相同
针对初始化方式二：int[][] arr = new int[4][0];
外层元素的初始化值为：null
内层元素的初始化值为：不能调用，否则报错。
class ArrayTest2{
public static void main(String[] args){
//二维数组的声明和初始化
//静态初始化
int[][] arr1 = new int[][]{{1,2,3},{4,5},{6}};
//动态初始化1
String[][] arr2 = new String[3][2];
//动态初始化2
String[][] arr3 = new String[3][];
//调用数组的指定位置的元素
System.out.println(arr1[1][1]);//5
System.out.println(arr2[0][0]);//null
arr3[1] = new String[3];
System.out.println(arr3[1][0]);
//获取数组的长度
System.out.println(arr1.length);//3
System.out.println(arr1[2].length);//1
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();
}
//数组元素默认初始化
int[][] arr_i = new int[4][3];
System.out.println(arr_i[0]);//地址值：[I@58372a00
System.out.println(arr_i[0][0]);//0
}
}
数据结构：
1.数据与数据之间的逻辑关系：集合、一对一、一对多、多对多
2.数据的存储结构：
线性表：顺序表（比如：数组）、链表、栈、队列
树形结构：二叉树等
图形结构：有向图，无向图
算法：
排序算法：冒泡、快排、希尔排序、归并、基数排序等
搜索算法：深度搜索，广度搜索等
冒泡排序
//冒泡排序
class BubbleSortTest{
public static void main(String[] args){
int[] arr = new int[]{43,32,77,64,-1,58,-66,42,-99};
boolean ifFlage;
for(int i = 0;i < arr.length - 1;i++){
ifFlage = false;
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;
ifFlage = true;
}
}
if(!ifFlage)break;
}
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i] + " ");
}
}
}
快速排序
public class QuickSortTest{
public static void main(String[] args){
int[] arr = new int[]{43,32,77,64,-1,58,-66,42,-99};
quickSort(arr,0,arr.length - 1);
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i] + " ");
}
}
public static void swap(int[] data,int a,int b){
int temp = data[a];
data[a] = data[b];
data[b] = temp;
}
public static void quickSort(int[] data,int left,int right){
if(left >= right){
return;
}
int key = data[left];
int start = left;
int end = right + 1;
while(true){
while( start < right && data[++start] <= key );
while(start > left && data[--end] >= key);
if(start < end){
swap(data,start,end);
}else{
break;
}
}
swap(data,left,end);
quickSort(data,left,end - 1);
quickSort(data,end + 1,right);
}
}
Arrays工具类的使用
java.util.Arrays:操作数组的工具类，定义了很多类操作数组的方法
import java.util.Arrays;
class ArraysTest{
public static void main(String[] args){
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);
//输出数组信息
System.out.println(Arrays.toString(arr1));
//将指定值填充到数组中
Arrays.fill(arr1,10);
System.out.println(Arrays.toString(arr1));
//对数组进行排序
Arrays.sort(arr2);
System.out.println(Arrays.toString(arr2));
//二分查找
int[] arr3 = new int[]{-18,-2,13,24,58,94,110,215};
int index = Arrays.binarySearch(arr3,58);
if(index >= 0){
System.out.println(index);
}else{
System.out.println("没找到");
}
}
}
数组使用过程中的常见异常
1.数组角标越界的异常：ArrayIndexOutOfBoundsExcetion
2.空指针异常：NullPointerException
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
