纲领
一维数组
概述
数组是相同类型数据的有序聚集。数组形貌的是相同类型的若干个数据,凭据一定的先后顺序排列组合而成。其中,每一个数据称作一个元素,每个元素可以通过一个索引(下标)来访问它们。

这些按序排列的同类数据元素的聚集称为数组“[]”。

特点
定长
长度一旦确定不可以改变。

相同数据类型
其元素必须是 相同 类型,不允许泛起夹杂类型。数组中的元素可以是任何数据类型,包罗基本类型和引用类型。

位置有序
元素所在的位置是有序的。

数组自己属于引用类型
数组变量属引用类型,数组也可以看成是工具,数组中的每个元素相当于该工具的成员变量。数组自己就是工具Java 中工具是在堆中的,因此数组无论保留基本类型照样其他工具类型,数组工具自己是在堆中的。

数组中可以存储随便类型的数据
界说
数组声明花样
数据类型[] 数组名称; --推荐使用
数据类型 数组名称[];
double[] arr;
char arr2[];
注重 : 引用数据类型只声明不赋值存在默认值null

数组初始化
动态初始化
数组界说与为数组元素分配空间和赋值的操作离开举行

数据类型[] 数组名=new 数据类型[长度];
int[] data = new int[5];
注重:元素为引用数据类型的数组中的每一个元素都需要实例化。

Person[] people; //声明说组
people = new Person[3]; //建立数组
people[0] = new Person(); //数组中元素实例化
people[1] = new Person();
people[2] = new Person();

静态初始化
在界说数组的同时就为数组元素分配空间并赋值

数据类型[] 数组名=new 数据类型[]{值1,值2...};
数据类型[] 数组名={值1,值2...}; --劈面的简写方式
int[] arr=new int[]{1,3,4,6};
int[] arr2={1,2,3,4,5};
注重:
对于返回值类型为数组类型的方式来说,我们可以return new int[3];,我们也可以return new int[]{1, 2, 3};,但我们不可以return {1, 2, 3};。即简写方式,其不能脱离数组的声明,{1, 2, 3}并不能返回一个数组工具。

一维数组工具演示图
数组的默认值
数组中的元素只声明不赋值存在默认值,数组是引用类型,它的元素相当于类的成员变量,因此数组分配空间后,每个元素也被凭据成员变量的规则被隐式初始化。

一样平常纪律为数值型数组默认值为 0,引用型数组默认值为 null:

数组类型 默认初始值
byte 0
short 0
int 0
long 0
char 编码为0的字符
String(引用类型) null
float 0.0
double 0.0
boolean false
使用
数组元素的界线
界说并用 new 为之分配空间之后,才可以引用数组中的每个元素,数组元素的引用方式为:

arrayName[index];
index为数组元素下标|索引,可以是整型常量或整型表达式 , 可以凭据数组元素的下标操作数组中数据。如:

arr1[3] = 5; //为数组索引为0的空间位置赋值
arr2[0] = "张三"; //为数组索引为0的空间位置赋值
System.out.println(arr3[2]);//获取数组中索引为2的数据值
数组元素下标从0最先;长度为n的数组的正当下标取值局限为

0~n-1

,

联博API

www.326681.com采用以太坊区块链高度哈希值作为统计数据,联博以太坊统计数据开源、公平、无任何作弊可能性。联博统计免费提供API接口,支持多语言接入。

,

每个数组都有一个属性length指明它的长度

a.length的值为数组a的长度(元素的个数)

数组元素遍历方式
(1)通俗for循环

for(int 索引=0;索引<长度; 索引++){
数组名称[索引] = 值;
}
int[] arr={1,2,3,4};
//1.遍历数组---基本for循环
for(int i=0;i<arr.length;i++){
//变量i代表索引/元素的下标
System.out.println(arr[i]);
}
(2)增强for循环

for(元素类型 局部变量 : 数组){
局部变量-->为数组中的每一个元素值,从左向右以此获取
}
//2.遍历数组---增强for循环
for(int i : arr){
System.out.println(i); //i中存储数组的元素值,非索引
}
数组基本演习
//A:遍历int类型的数组 依次输出每个数组元素
public static void printArray(int[] arr){
//循环遍历数组下标
for(int i=0;i<arr.length;i++){
System.out.println("输出int类型数组的每一个元素"+arr[i]);
}
}
//B:逆序:倒叙输出数组元素
public static void printArr(String[] arr){
for(int i=arr.length-1;i>=0;i--){
System.out.println(arr[i]);
}
}
//C:最值:获取数组中的最大值和最小值
public static void maxMinValue(int[] arr){
//假设数组中的第一个元素当成最大值
int max=arr[0];
//假设数组中的第一个元素当成最大值
int min=arr[0];
//遍历数组
for(int i=0;i<arr.length;i++){
//对照数组元素与max
if(max<arr[i]){
max=arr[i];
}
//对照数组元素与min
if(min>arr[i]){
min=arr[i];
}
System.out.println("数组中最大的值为max"+max);
System.out.println("数组中最小的值为min"+min);
}
}
Arrays
该类提供了关于数组操作的API.

若何查看API
Arrays中常用方式
打印数组----toString方式。
对照两个数组是否相同----equals方式。
数组排序----sort方式。
数组查找----binarySearch 方式。
数组拷贝----copyOf方式。
数组拷贝----copyOfRange方式。
String[] arr1={"hello","shsxt"};
String[] arr2={"hello","shsxt"};
System.out.println(arr1.equals(arr2)); //false
//1.Arrays.equals() 先判断两个数组的length是否相等,若是相等,再比内容,若是不相等,直接返回false
System.out.println(Arrays.equals(arr1, arr2));
//2.Arrays.toString 字符串形式打印数组信息
System.out.println(Arrays.toString(arr1));

//3.Arrays.sort() 升序
int[] arr3={12,7,0,6,-32};
Arrays.sort(arr3); //-32 0 6 7 12
String[] arr4={"ab","a","bc","abc"}; //凭据Unicode表中的值
Arrays.sort(arr4); //a ab abc bc

//4.Arrays.binarySearch( 数组, 元素) ) :二分法查找 查找元素在数组中泛起的索引
//条件:先升序排序,才气二分法查找
//找到返回索引,找不到返回-(插入点)-1
Arrays.sort(arr3);
System.out.println(Arrays.binarySearch( arr3, 16)); // -6
经典案例实现-点名器
运行代码,随机打印班级同砚名字

//1.数组存储姓名,用String数据类型
String[] names={"杰克","戴维琼斯","伊丽莎白","爱丽丝"};
//2.遍历数组,打印出所有姓名
for(int i=0;i<names.length;i++){
System.out.println(names[i]);
}
//3.随机出一个人名
//行使随机数,天生一个证书,作为索引,到数组中查找对应的元素
Random ran=new Random();
//随机数的局限是[0,names.length-1]
int index=ran.nextInt(names.length); //括号中填写的最大数是获取不到的,由于nextInt获取的局限是左闭右开区间
System.out.println(names[index]);
二维数组
二维数组可以看成以数组为元素的数组。

实在多维数组不仅仅只有二维数组,另有三维数组,四维数组…, 然则三维以上很少见到,以是人人重点领会二维数组即可。

举例
int [][] a = {{1,2},{3,4,0,9},{5,6,7}};
初始化
动态初始化
数组界说与为数组元素分配空间和赋值的操作离开举行

数据类型[][] 数组名 = new 数据类型[一维][二维];
注重:这种初始化方式,每一个内层的二位数组长度相同

int[][] a=new int[3][2];
a[0][0] = 1;
a[0][1] = 2;
数据类型[][] 数组名 = new 数据类型[一维][];
内层数组需要我们自己去建立(下面可以用一维数组的建立方式)
数组名[一维数组索引值] = new 数据类型[二维];
int[][] a=new int[3][];
arr[0]=new int[2];
arr[1]=new int[]{3,4,5,6};
arr[2]=new int[]{7,8,9};
arr[0][0] = 1;
arr[0][1] = 2;
静态初始化
在界说数组的同时就为数组元素分配空间并赋值

数据类型[][] 数组名 = new 数据类型[][]{{...},{...},{...}};
数据类型[][] 数组名 = {{...},{...},{...}}; --简化写法
int[][] arr1=new int[][]{{5,4,8},{3,8},{1}};
char[][] arr2={{'a'},{'b','c'}};
遍历方式
双重循环实现多维数组的遍历

//通俗for循环嵌套增强for循环
for(int i=0;i<=arr1.length-1;i++){
for(int j:arr1[i]){
System.out.println(j);
}
}
//增强 for循环嵌套通俗for循环
for(int[] arr:arr1){
for(int i=0;i<=arr.length-1;i++){
System.out.println(arr[i]);
}
}
//通俗for嵌套通俗for循环
...
//增强for嵌套增强for循环
...
Arrays中提供操作多维数组的方式:

static boolean deepEquals(Object[] a1, Object[] a2) 若是两个指定的数组相互 深度相等 ,则返回 true 。
static String deepToString(Object[] a) 返回指定数组的“深度内容”的字符串示意形式。
double[][] arr1= new double[][] {{1.0,2.0},{3.0,4.0,5.0},{6.0}};
double[][] arr2= new double[][] {{1.0,2.0},{3.0,4.0,5.0},{6.0}};
System.out.println(Arrays.deepToString(arr1)); //[[1.0, 2.0], [3.0, 4.0, 5.0], [6.0]]
System.out.println(Arrays.deepEquals(arr1, arr2)