本文介绍了Java中的数组概念、特点、分类，包括一维数组和多维数组的声明、初始化、使用方法，以及常见的数组算法操作如反转、复制、排序。同时，讲解了Arrays工具类在数组操作中的应用，如排序、查找和填充等。
一、数组的概念和几个相关概念
1.概念
是多个相同数据类型按照一定的顺序排列的集合。
2.相关概念
—>数组名
—>数组的元素（即内部存储的多个元素）
—>数组的下标、角标、下角标、索引、index（即找到指定数组元素所使用的编号）
—>数组的长度（即数组容器中存储的元素的个数）
二、数组的特点
1.数组中的元素在内存中是依次紧密排列的，有序的。
2.数组，一旦初始化完成，其长度就是确定的。数组的长度一旦确定，就不能修改。
3.数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型
4.创建数组对象会在内存中开辟一整块连续的空间。占据的空间的大小，取决于数组的长度和数组中元素的类型。
5.可以直接通过下标(或索引)的方式调用指定位置的元素
6.数组名中引用的是这块连续空间的首地址
三、数组的分类
1.按照元素的类型：
1）基本数据类元素的数组
int[] arr = new int[]{1,2,3};
2）引用数据类型元素的数组
String [] str = new String[]{"张三","李四","王五"};
2.按照数组的维数来分：
1）一维数组
int [] arr = new int[]{1,2,3};
2）二维数组
int [][]arr = new int[][]{{1,2,3},{1,2},{1,2,3,4}};
3.多维数组等等
四、一维数组的使用：
1.数组的声明和初始化
//方式一：静态初始化
double [] prices = new double[]{8.5,5.6,95.3};
//方式二：动态初始化
String [] foods = new String[5];
2.一维数组的使用
1）数组的调用
String [] foods = new String[5];
//赋值
foods[0] = "麻婆豆腐";
foods[1] = "小面";
foods[2] = "尖椒肉丝";
foods[3] = "土豆片";
foods[4] = "鱼香肉丝";
//数组元素的调用（数组名[索引/下标]）
System.out.println(prices[0]);
System.out.println(prices[2]);
2）数组的属性：length，表示数组的长度
int sum = foods.length;
3）数组的遍历
//4.遍历数组
for (int i = 0; i < foods.length; i++) {
System.out.println(foods[i]);
}
for (String s : foods) {
System.out.println(s);
}
4）数组元素的默认值初始化值
整形数组数据类型默认初始化值：0
浮点型数组数据类型默认初始化值：0.0
字符型数组数据类型默认初始化值：'\u0000'或0
布尔型数据类型默认初始化值：false
引用数组数据类型默认初始化值：null
五、多维数组的使用
1.声明与初始化
元素的数据类型[][] 二维数组的名称;
静态化初始：
String [][] str = new String [][]{{"张三丰","张无忌"},{"岳不群","令狐冲","东方不败"},{"杨过"}};
动态化初始：（1）确定行数和列数
String [][] str = new String [3][2];
（2）先确定总行数
String [][] str = new String [2][];
案例:打印杨辉三角，提示 yanghui[i][j] = yanghui[i-1][j-1]+yanghui[i-1][j]
效果：
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1
//杨辉三角
int [][] yanghui = new int[10][];
for (int i = 0; i < yanghui.length; i++) {
//每行创建列数
yanghui[i] = new int[i + 1];
for (int j = 0; j < yanghui[i].length; j++) {
//首、末行值都为1，第一，二行值全为1，从第三行开始
if(i >= 2 && j != 0 && j != i){
yanghui[i][j] = yanghui[i-1][j-1]+yanghui[i-1][j];
}else{
yanghui[i][j] = 1;
}
System.out.print(yanghui[i][j] + "\t");
}
System.out.println();
}
六、数组的常见算法操作
1.数组元素的反转
//数组反转
//方式1：
int [] num = new int[]{34,54,3,2,78,90,45,34,22,11,55};
for (int i = 0; i < num.length; i++) {
System.out.print(num[i] + "\t");
}
for (int i = 0; i < num.length / 2; i++) {
int temp = num[i];
num[i] = num[num.length - i - 1];
num[num.length - i - 1] = temp;
}
//方式2：
int temp = 0;
for (int i = 0, j = num.length - 1; i < j; i++,j--) {
temp = num [i];
num[i] = num[j];
num[j] = temp;
}
System.out.println();
for (int i = 0; i < num.length; i++) {
System.out.print(num[i] + "\t");
}
2.数组的复制
//数组的复制
int [] num = new int[]{34,54,3,2,78,90,45,34,22,11,55};
int [] arr = new int[num.length];
for (int i = 0; i < num.length; i++) {
arr[i] = num[i];
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
System.out.println();
System.out.println("arr的内存地址为：" + arr + ",num的内存地址为：" + num);
3.数组的扩容
//数组的扩容
int [] arr = new int[]{1,2,3,4,5};
//扩容1倍的容量
int [] newArr = new int[arr.length << 1];
for (int i = 0; i < arr.length; i++) {
newArr[i] = arr[i];
}
arr = newArr;
4.数组的缩容
//数组的缩容
//现有数组int [] arr = new int[]{1,2,3,4,5,6,7}，删除数组中索引为4的元素
//方式1：不新建数组
int [] arr = new int[]{1,2,3,4,5,6,7};
for (int i = 4; i < arr.length - 1; i++) {
arr[i] = arr[i + 1];
}
arr[arr.length - 1] = 0;
//方式2：新建数组
int [] newArr = new int[arr.length - 1];
for (int i = 0; i < 4; i++) {
newArr[i] = arr[i];
}
for (int i = 4; i < arr.length - 1; i++) {
newArr[i] = arr[i + 1];
}
arr = newArr;
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
5.数组的查找
//索引：1.线性查找
int [] arr = new int[]{23,34,45,23,66,77,54,87,78,90};
int target = 66;
for (int i = 0; i < arr.length; i++) {
if(target == arr[i]){
System.out.println("找到此元素" + target + "位置为：" + (i + 1));
break;
}
}
//2.二分法查找 (必须是排好顺序的数组)
//排序
boolean isFlag = true;
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr.length - i -1; j++) {
if(arr[j] > arr[j + 1]){
int temp = 0;
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
isFlag = false;
}
}
if (isFlag){
break;
}
isFlag = true;
}
int head = 0;
int end = arr.length - 1;
while (head <= end){
int middle = (head + end) / 2;
if(target == arr[middle]){
System.out.println("找到此元素" + target + "位置为：" + (middle + 1));
break;
}else if(target > arr[middle]){
head = middle + 1;
}else {
end = middle - 1;
}
}
6.数组的排序
1）冒泡排序
int [] arr = new int[]{23,34,45,23,66,77,54,87,78,90};
boolean isFlag = true;
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr.length - i -1; j++) {
if(arr[j] > arr[j + 1]){
int temp = 0;
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
isFlag = false;
}
}
if (isFlag){
break;
}
isFlag = true;
}
2）快速排序
public class QuickSort {
private static void swap(int[] data, int i, int j) {
int temp = data[i];
data[i] = data[j];
data[j] = temp;
}
private static void subSort(int[] data, int start, int end) {
if (start < end) {
int base = data[start];
int low = start;
int high = end + 1;
while (true) {
while (low < end && data[++low] - base <= 0)
;
while (high > start && data[--high] - base >= 0)
;
if (low < high) {
swap(data, low, high);
} else {
break;
}
}
swap(data, start, high);
subSort(data, start, high - 1);//递归调用
subSort(data, high + 1, end);
}
}
public static void quickSort(int[] data){
subSort(data,0,data.length-1);
}
public static void main(String[] args) {
int[] data = { 9, -16, 30, 23, -30, -49, 25, 21, 30 };
System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
quickSort(data);
System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
}
}
七、Arrays工具类的使用
1.数组元素的拼接
* static String toString(int[] a) ：字符串表示形式由数组的元素列表组成，括在方括号（"[]"）中。
相邻元素用字符 ", "（逗号加空格）分隔。形式为：[元素1，元素2，元素3。。。]
* static String toString(Object[] a) ：字符串表示形式由数组的元素列表组成，括在方括号（"[]"）中。
相邻元素用字符 ", "（逗号加空格）分隔。元素将自动调用自己从Object继承的toString方法将对象转为字符串进行拼接，如果没有重写，
则返回类型@hash值，如果重写则按重写返回的字符串进行拼接。
2.数组排序
* static void sort(int[] a) ：将a数组按照从小到大进行排序
* static void sort(int[] a, int fromIndex, int toIndex) ：将a数组的[fromIndex, toIndex)部分按照升序排列
* static void sort(Object[] a) ：根据元素的自然顺序对指定对象数组按升序进行排序。
* static <T> void sort(T[] a, Comparator<? super T> c) ：根据指定比较器产生的顺序对指定对象数组进行排序。
3.数组的二分查找
* static int binarySearch(int[] a, int key) 、static int binarySearch(Object[] a, Object key) ：要求数组有序，
在数组中查找key是否存在，如果存在返回第一次找到的下标，不存在返回负数。
4.数组的复制
* static int[] copyOf(int[] original, int newLength) ：根据original原数组复制一个长度为newLength的新数组，并返回新数组
* static <T> T[] copyOf(T[] original,int newLength)：根据original原数组复制一个长度为newLength的新数组，并返回新数组
* static int[] copyOfRange(int[] original, int from, int to) ：复制original原数组的[from,to)构成新数组，并返回新数组
* static <T> T[] copyOfRange(T[] original,int from,int to)：复制original原数组的[from,to)构成新数组，并返回新数组
5.比较两个数组是否相等
* static boolean equals(int[] a, int[] a2) ：比较两个数组的长度、元素是否完全相同
* static boolean equals(Object[] a,Object[] a2)：比较两个数组的长度、元素是否完全相同
6.填充数组
* static void fill(int[] a, int val) ：用val值填充整个a数组
* static void fill(Object[] a,Object val)：用val对象填充整个a数组
* static void fill(int[] a, int fromIndex, int toIndex, int val)：将a数组[fromIndex,toIndex)部分填充为val值
* static void fill(Object[] a, int fromIndex, int toIndex, Object val) ：将a数组[fromIndex,toIndex)部分填充为val对象
扫一扫
1184
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
