数组

来源：互联网发布：网络第一楼金宥熙编辑：程序博客网时间：2024/06/07 01:40

1. 概念：数组可以同时存储多个相同类型的数据，
并且可以对多个数据进行统一操作。
2. 数组的基本语法：【开发应用重点】
① 数组的基本使用流程：
a.声明：指定数组中存储数据的数据类型和数组名字；
数据类型[] 数组名; 例如：int[] a; //不建议的写法 int []a; int a[];
b.分配空间：指定数组的长度
数组名=new 数据类型[长度]; 例如： a=new int[5];

② 数组下标的范围：0~数组长度-1
③ 数组中存储的数据称为数组的元素。
④ 对数组中元素进行存取的过程称为元素的访问。
⑤ 对数组中元素的访问通过：数组名[下标]
存元素：数组名[下标]=数据;
取元素：数组名[下标]
⑥ 当访问数组时，超出数组的下标范围时，运行报错，错误信息：
java.lang.ArrayIndexOutOfBoundsException(数组下标越界)
⑦ 数组的遍历：对数组中元素一一访问的过程。
for(int i=0;i<数组长度;i++){
System.out.println(a[i]);
}
注意：获取数组的长度：数组名.length
⑧ 数组具有默认值：
整数：0
小数：0.0
字符：空字符('\u0000')
布尔：false
引用：null
⑨ 数组其他定义语法：
a. 声明的同时分配空间：
数据类型[] 数组名= new 数据类型[长度];
b. 声明并初始化：
数据类型[] 数组名= new 数据类型[]{值1,值2,值3};
注意：[]不能指定数组的长度，长度由{}中数值的个数来确定。
c. 声明并初始化：
数据类型[] 数组名= {值1,值2,值3};
注意：初始化{}必须和声明写在一起。

错误的写法： int[] a;
a={1,2,3};
3. 数组内存【难点】
① 数组在内存的空间是连续的。
② 数组名存储数组的首地址。
③ 数组中每一个内存空间的地址：
首地址+数据类型的字节数*下标
④ 数组类型的变量之间传递的是数组的首地址。
注意：数组是引用、对象数据类型。
4. 数组的扩容【理解】
① 扩容的思想：
a. 在原有数组的基础上，申请一个更大长度的数组。
b. 将原有数组中的元素一一搬运到新数组中。
② 扩容的方法：
a.方法一：
I. 定义一个新数组，长度为原有数组的2倍
II. 利用遍历将原有数组中元素一一搬运到新数组中。
b. 方法二：
I.定义一个新数组，长度为原有数组的2倍
II.利用System.arraycopy(原数组名字,起始下标,新数组名,存储元素的起始下标,长度)
c. 方法三：

I. java.util.Arrays.copyOf(原数组名,新数组的长度);

import java.util.Arrays;
/**
* 数组扩充
*
*/
public class ArraysExpand11 {
public static void main(String[] args) {
int[] a={1,2,3,4,5,6};
a=Dayin(a);
add(a);
}
//先扩充方法一
public static int[] Dayin(int[] a){
// int[] b=new int[a.length*2];
/* for(int i=0;i<a.length;i++)2..{
b[i]=a[i];
}
return b;*/
// 第二种
/* System.arraycopy(a, 0, b, 0, a.length);
return b;*/
// 第三种
int[] b=Arrays.copyOf(a,a.length*2);
return b;
}
//后遍历
public static void add(int[] n){
for(int i=0;i<n.length;i++){
System.out.println(n[i]);
}
}
}

5.可变长参数 [阅读API或是其他文档时，会遇到]
① 概念：函数的参数个数不再定义固定的，而是随着调用传递的实参个数改变。
② 语法：(数据类型... 变量名)
③ 应用：根据实际传递的参数，自动生成一个对应数据类型的数组。
可变长参数在应用时和数组用法一致。
④ 注意：一个函数中最多定义一个可变长参数，并且是参数的最后一个。

6. 排序：[面试重点，开发不重要]

① 冒泡：相邻的两个元素一一比较，每一轮获取最大数据。

public class ArraysMaoPo {
public static void main(String[] args){
int[] a={1,3,2,7,5};
for(int i=1;i<a.length;i++){ //进行的第几次冒泡排序
for(int j=0;j<a.length-i;j++){ //其中j在这的意思，是这个数组的每个元素的下标；控制每一轮具体比较的内容
//前后元素比较
if(a[j]>a[j+1]){
//前后元素交换一个中间变量找q
int q=a[j];
a[j]=a[j+1]; //虽然a[j]被存储空间被a[j+1]覆盖但a[j]赋值给了q变量。
a[j+1]=q;
}
}
}
//排完序遍历打印数组；
for(int i=0;i<a.length;i++){
System.out.print(a[i]+" ");
}
}
}

② 选择：固定下标的元素，和后面的元素一一比较。每一次获取最小的数据。

/**
* 选择排序
*/
public class ArraysXuanZe {
public static void main(String[] args) {
int[] a = { 1,3,2,7,5 };
for(int i=0;i<a.length-1;i++){ //外层循环进行几次排序
for(int j=i+1;j<a.length;j++){//内层循环控制比较内容
if(a[i]<a[j]){
int t=a[i];
a[i]=a[j];
a[j]=t;
}
}
}
pianLi(a);
}
public static void pianLi(int[] a){
for(int i=0;i<a.length;i++){
System.out.print(a[i]+" ");
}
}
}

③ 快速排序：java.util.Arrays.sort(数组名);

import java.util.Arrays;
public class Test {
public static void main(String[] args) {
int[] arrays = { 12, 5, 58, 4, 5, 8989, 74, 55 };
Arrays.sort(arrays);
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]+" ");
}
}
}

7. 二维数组 [了解]
① 二维数组的定义：
a. 声明：指定数据类型和数组名字
数据类型[][] 数组名;
分配空间：指定行数和列数
数组名=new 数据类型[行数/高维][列数/低维];
注意：二维数组同一维数组，具有默认值。
② 基本语法：
a. 访问二维数组中元素通过行和列描述：
a[行数][列数]
b. 获取二维数组的行数：数组名.length
获取二维数组的列数：数组名[行标].length
③ 定义二维数组的其他方式：
a. 声明的同时分配空间：
数据类型[][] 数组名=new 数据类型[行数][列数];
b. 声明的同时初始化：
数据类型[][] 数组名=new 数据类型[][]{{1,2,3,4},{0,2,5,7},{1,8,5,3}};
注意：[][]不允许指定行数和列数，行数和列数由{}中内容决定。
c. 声明的同时初始化：
数据类型[][] 数组名={{1,3},{4,7},{5,9}};
注意：初始化和声明必须一起进行。

注意：二维数组本质是一维数组的一维数组。
④ 不规则的二维数组：每一行的列数不相同。
a. int[][] a=new int[4][];
a[0]=new int[2];
a[1]=new int[3];
a[2]=new int[4];
a[3]=new int[2];

b. int[][] a={{1,2,3},{2,1},{1}};

注意：定义二维数组时，必须指定行数/高维。
int[][] b=new int[][3];//Error（错误）

阅读全文

0 0