数组的定义
数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引（下标）来访问它们。
数组的四个基本特点：
- 长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
- 其元素的类型必须是相同类型，不允许出现混合类型。
- 数组类型可以是任何数据类型，包括基本类型和引用类型。
- 数组有索引的：索引从0开始，到 数组.length-1 结束
PS：:数组变量属于引用类型，数组也是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中存储的。
示例
public class TestArray02{
public static void main(String[] args){
//数组的作用：用来存储相同类型的数据
//以int类型数据为案例：数组用来存储int类型数据
//1.声明(定义数组)
int[] arr; //定义一个int类型的数组，名字叫arr
//int arr2[];
//如果数组只声明，没有后续操作，那么这个数组相当于没定义
//int[] arr3 = null;//空 辨别：数组赋值为null和什么都没有赋值 不一样的效果
//2.创建
arr = new int[4];//给数组开辟了一个长度为4的空间
//编译期声明和创建会被合为一句话: int[] arr = new int[4];
//3.赋值
arr[0] = 12;
arr[3] = 47;
arr[2] = 98;
arr[1] = 56;
arr[2] = 66;
/*
arr[4] = 93;
出现异常：Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4
Array 数组
Index 索引
OutOf 超出
Bounds 界限
Exception 异常
---》数组索引越界异常
*/
//4.使用
System.out.println(arr[2]);
System.out.println(arr[0]+100);
//通过数组一个属性来获取 length 长度
System.out.println("数组的长度是："+arr.length);
}
}
数组的初始化
数组的初始化方式总共有三种：静态初始化、动态初始化、默认初始化。
-
静态初始化：除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。
int[] arr = {12,23,45};
int[] arr = new int[]{12,23,45};
注意：
new int[3]{12,23,45};–>错误
int[] arr ;
arr = {12,23,45}; —>错误 -
动态初始化：数组定义与为数组元素分配空间并赋值的操作分开进行。
int[] arr ;
arr = new int[3]
arr[0] = 12;
arr[1] = 23;
arr[2] = 45; -
默认初始化：数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
int[] arr = new int[3]; —> 数组有默认的初始化值
数组的可变参数
可变参数：作用提供了一个方法，参数的个数是可变的 ,解决了部分方法的重载问题
示例
public class TestArray12{
/*
1.可变参数：作用提供了一个方法，参数的个数是可变的 ,解决了部分方法的重载问题
int...num
double...num
boolean...num
2.可变参数在JDK1.5之后加入的新特性
3.方法的内部对可变参数的处理跟数组是一样
4.可变参数和其他数据一起作为形参的时候，可变参数一定要放在最后
5.我们自己在写代码的时候，建议不要使用可变参数。
*/
public static void main(String[] args){
//method01(10);
//method01();
//method01(20,30,40);
method01(30,40,50,60,70);
//method01(new int[]{11,22,33,44});
}
public static void method01(int num2,int...num){
System.out.println("-----1");
for(int i:num){
System.out.print(i+"\t");
}
System.out.println();
System.out.println(num2);
}
}
Arrays工具类
为了方便我们对数组进行操作，系统提供一个类Arrays，我们将它当做工具类来使用。
示例
import java.util.Arrays;
public class TestArray13{
public static void main(String[] args){
//给定一个数组：
int[] arr = {1,3,7,2,4,8};
//toString:对数组进行遍历查看的，返回的是一个字符串，这个字符串比较好看
System.out.println(Arrays.toString(arr));
//binarySearch:二分法查找：找出指定数组中的指定元素对应的索引：
//这个方法的使用前提：一定要查看的是一个有序的数组：
//sort：排序 -->升序
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
System.out.println(Arrays.binarySearch(arr,4));
int[] arr2 = {1,3,7,2,4,8};
//copyOf:完成数组的复制：
int[] newArr = Arrays.copyOf(arr2,4);
System.out.println(Arrays.toString(newArr));
//copyOfRange:区间复制：
int[] newArr2 = Arrays.copyOfRange(arr2,1,4);//[1,4)-- >1,2,3位置
System.out.println(Arrays.toString(newArr2));
//equals:比较两个数组的值是否一样：
int[] arr3 = {1,3,7,2,4,8};
int[] arr4 = {1,3,7,2,4,8};
System.out.println(Arrays.equals(arr3,arr4));//true
System.out.println(arr3==arr4);
//false == 比较的是左右的地址值，返回结果一定是false
//fill：数组的填充：
int[] arr5 = {1,3,7,2,4,8};
Arrays.fill(arr5,10);
System.out.println(Arrays.toString(arr5));
}
}
数组的复制
使用JDK提供的某个方法完成
参数：
src - 源数组
srcPos - 源数组中的起始位置
dest - 目标数组
destPos - 目标数据中的起始位置
length - 要复制的数组元素的位置
示例
import java.util.Arrays;
public class TestArray14{
public static void main(String[] args){
//给一个源数组：
int[] srcArr = {11,22,33,44,55,66,77,88};
//给一个目标数组：
int[] destArr = new int[10];
//复制：
System.arraycopy(srcArr,1,destArr,3,3);
//遍历查看目标数组：
System.out.println(Arrays.toString(destArr));
}
}
二维数组
定义：本质上全部都是一维数组
示例
public class TestArray15{
public static void main(String[] args){
//定义一个二维数组：
int[][] arr = new int[3][];//本质上定义了一个一维数组，长度为3
int[] a1 = {1,2,3};
arr[0] = a1;
arr[1] = new int[]{4,5,6,7};
arr[2] = new int[]{9,10};
}
}
四种遍历方式
public class TestArray15{
public static void main(String[] args){
//定义一个二维数组：
int[][] arr = new int[3][];//本质上定义了一个一维数组，长度为3
int[] a1 = {1,2,3};
arr[0] = a1;
arr[1] = new int[]{4,5,6,7};
arr[2] = new int[]{9,10};
//读取6这个元素：
//System.out.println(arr[1][2]);
//对二维数组遍历：
//方式1：外层普通for循环+内层普通for循环：
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr[i].length;j++){
System.out.print(arr[i][j]+"\t");
}
System.out.println();
}
//方式2：外层普通for循环+内层增强for循环：
for(int i=0;i<arr.length;i++){
for(int num:arr[i]){
System.out.print(num+"\t");
}
System.out.println();
}
//方式3：外层增强for循环+内层增强for循环：
for(int[] a:arr){
for(int num:a){
System.out.print(num+"\t");
}
System.out.println();
}
//方式4：外层增强for循环+内层普通for循环：
for(int[] a:arr){
for(int i=0;i<a.length;i++){
System.out.print(a[i]+"\t");
}
System.out.println();
}
}
}
二维数组初始化
数组的初始化方式总共有三种：静态初始化、动态初始化、默认初始化。
-
静态初始化：除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。
int[][] arr = {{1,2},{4,5,6},{4,5,6,7,8,9,9}};
int[][] arr =new int[][] {{1,2},{4,5,6},{4,5,6,7,8,9,9}}; -
动态初始化：数组定义与为数组元素分配空间并赋值的操作分开进行。
int[][] arr = new int[3][] //本质上定义了一维数组长度为3，每个“格子”中放入的是一个数组 arr[0] = new int[]{1,2};
arr[1] = new int[]{3,4,5,6};
arr[2] = new int[]{34,45,56};int[][] arr = new int[3][2];
-
默认初始化: 数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
始化**：数组定义与为数组元素分配空间并赋值的操作分开进行。
int[][] arr = new int[3][] //本质上定义了一维数组长度为3，每个“格子”中放入的是一个数组 arr[0] = new int[]{1,2};
arr[1] = new int[]{3,4,5,6};
arr[2] = new int[]{34,45,56};
int[][] arr = new int[3][2];
- 默认初始化: 数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
1688
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
