数组的概念

概念：具有一组相同数据类型的数据结构。（理解为容器，就是装数据的）

相同数据类型

数据结构：在内存中是连续的内存空间。

数组的使用

使用：

        step1：创建数组

        step2：操作数据：存储数据，获取数据

数组中可以存储任意类型的数据，但是数组本身是引用类型的。

语法：

动态创建数组：创建和赋值分开写。

数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度];

数组定义格式详解：

数组存储的数据类型： 创建的数组容器可以存储什么数据类型。

[] : 表示数组。

数组名字：为定义的数组起个变量名，满足标识符规范，可以使用名字操作数组。

new ：关键字，创建数组使用的关键字。

数组存储的数据类型： 创建的数组容器可以存储什么数据类型。

[ 长度]：数组的长度，表示数组容器中可以存储多少个元素。

注意：创建数组时要指明数组的大小(长度，容量)，然后再使用,数组有定长特性，长度一旦指定，不可更改。

int [] arr = new int[5]; //先创建
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;

静态创建数组：创建数组和赋值写一起

数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};
数据类型[] 数组名 = {元素1,元素2,元素3...};
int[] arr = {1,2,3,4,5}

示例：

public class Demo1 {public static void main(String[] args) {/*数组的标识是[];arr=Array语法：数据类型[] 数组名 = new 数据类型[数组的长度];数组是引用类型数组声明之后，没有赋值，那么他的默认值和成员变量一样。。。*///第一种定义方式：动态初始化，int[] arr = new int[3];//System.out.println(arr);//方法数组元素的语法：数组名[下标]arr[0] =1;//存数据arr[1] =2;arr[2]= 5;System.out.println(arr[0]);//取数据System.out.println("arr[1]--->"+arr[1]);System.out.println("arr[2]---->"+arr[2]);//System.out.println("arr[2]---->"+arr[3]);//访问数组的元素的时候，下标超过了边界，那//java.lang.ArrayIndexOutOfBoundsException: 3,这个叫数组越界异常// String[] arr2 = new String[3];// System.out.println("arr2[0]---->"+arr2[0]);//可以新建任意类型的数组，但是数组本身是引用类型//Object[] arr2 = new Object[3];//第二种：静态初始化/*左边是声明数组，开辟内存；右边里面大括号{}包含的元素个数，顺序，会自动计算长度，还有元素的位置*/int[] arr2 = {1,4,5,6,7};//访问数组的长度:数组名.lengthSystem.out.println("arr2.length="+arr2.length);}
}

数组名(arrName)，数组的类型(type)，长度(容量length)，下标(index)，元素(element)

注意点：

        数组只有一个名称，即标识符

        元素索引标明了元素在数组中的位置，下标从0开始

        数组中的每个元素都可以通过下标来访问

        数组的长度固定不变，避免数组越界

        数组变量属于引用类型

        数组元素的默认值和成员变量的默认值一样

数组的遍历

方法一

普通for循环：

for(int i =0 ;i < arr.length;i++){System.out.println(arr[i]);
}

方法二

增强for循环(jdk1.5)：

//语法：
for(type element : array){System.out.println(element);
}//示例代码：
for (int e : arr) {System.out.println("--->" + e);
}

缺陷：遍历数组或集合时无法访问索引(下标)值

用途：一般用于遍历显示数组或集合中元素的内容。

增强for能不能给数组赋值？

int[] arr = {1,3,4};int[] arr2= new int[3];int i=0;
for(int e:arr){//e = 10;//不可以；arr2[i] = e;i++;
}for(int a:arr2){System.out.println(a);
}

public class ArrayDemo2 {public static void main(String[] args) {int[] arr = {1,5,4,3,46};//定义一个数组System.out.println("数组的长度："+arr.length);System.out.println("访问数组的元素arr[0]:"+arr[0]);//第一种方式：for循环，通过下标。。。for(int i=0;i<arr.length;i++){//i=0;arr[0],访问第一个元素//i=1;arr[1],访问第二个元素//...//i=arr.length-1;访问最后一个元素System.out.print(arr[i]+"\\t");}System.out.println("-----------------");//第二种方式：增强for循环，不再通过下标遍历/*//语法：for(type element : array){System.out.println(element);}*/for(int e:arr){//把数组arr里面的元素依次赋值给e,System.out.print(e+"\\t");}System.out.println("----------------");//增强for给数组元素直接赋值int[] arr2 = new int[3];for(int e:arr2){e = 10;//不可以给数组的元素赋值}for(int e:arr2){//把数组arr里面的元素依次赋值给e,System.out.print(e+"\\t");}}
}

可变参数

一个方法中，参数的类型确定，但是数量不确定。就可以使用可变参数。

方法当中可变参数，就是数组。

语法： 参数类型 ... 参数名

调用：参数的数量：0-多个

public class ArrayDemo3 {//求不确定个数int类型的数字的和//可变参数:可以是0个~多个public static int getSum(double d,int... nums){int sum = 0;for (int e:nums){sum +=e;}return sum;}public static void main(String[] args) {int sum = getSum(1,3,56);System.out.println("sum:"+sum);}
}

注意事项：

1.一个方法最多只能有一个可变参数。

2.如果形参列表中，除了可变参数，还有其他的参数，可变参数要位于参数列表的末尾。

数组拷贝

浅拷贝：拷贝的是内存地址，

深拷贝：拷贝的是数值。

public class ArrayDemo4 {public static void main(String[] args) {int[] arr = {3,4,67,3,12};int[] arr2 = arr;//浅拷贝：拷贝的是内存地址arr2[0] = 100;System.out.println("arr[0]:"+arr[0]);System.out.println("arr2[0]:"+arr2[0]);System.out.println("----------------------");//深拷贝：拷贝的是内容int[] arr3 = new int[arr.length];for (int i = 0; i < arr3.length; i++) {int num = arr[i];arr3[i] = num;}arr3[0] = 30;System.out.println("arr[0]:"+arr[0]);System.out.println("arr3[0]:"+arr3[0]);}
}

Arrays数组的工具类

常用方法：

        binarySearch(数组，key)-->int，二分搜索

        sort(数组)-->void，排序

        toString(数组)-->String，按照字符串打印数组中的内容

        copyOf(原始数组，新数组长度)-->新数组，数组拷贝

        equals(数组1，数组2)-->boolean

示例：

import java.util.Arrays;public class ArraysDemo {public static void main(String[] args) {//binarySearch(数组，key)-->int，二分搜索int[] arr = {4,5,12,76,23};//注意：搜索方法一定要先排序//排序Arrays.sort(arr);System.out.println("arr:"+Arrays.toString(arr));//按照字符串打印数组中的内容System.out.println("-------------------");int index = Arrays.binarySearch(arr, 23);//找到要查找的值所在的下标System.out.println("5所在的下标是："+index);//数组的拷贝int[] newArr = Arrays.copyOf(arr, 5);//这个拷贝是深拷贝System.out.println("newArr:"+Arrays.toString(newArr));System.out.println("----------------------");//boolean equals = arr.equals(newArr);//这个equals调用的是Object类的equals方法，比较的是内存地址//只比较数组的内容boolean equals = Arrays.equals(arr, newArr);System.out.println("equals:"+equals);}
}

二维数组

一维数组，容器，存储了一组数据。数组名配合下标获取到的就是元素数据了，也就是数值。

二维数组，容器，存储一维的一维。二维数组中的元素，而是一维数组。

public class ArrayDemo5 {public static void main(String[] args) {int[] arr = {5,4,2,15,45};//二维数组里面的元素就是一维数组//动态声明：int[][] arrEle = new int[3][4];//第一个长度3：表示的这个二维数组存放了3个一维数组；第二个长度4:表示每个一维数组存放多少个数字arrEle[0][0] = 23;arrEle[0][1] = 1;System.out.println("arrEle:"+arrEle);//二维数组的地址System.out.println("arrEle[0]:"+arrEle[0]);//第一个一维数组的地址System.out.println("arrEle[0][0]:"+arrEle[0][0]);//第一个一维数组的第一个元素System.out.println("===================================");//静态初始化：int[][] newArr = {{2,3},{4,23},{98,54,123}};//这个叫锯齿数组//遍历：for (int i = 0; i < newArr.length; i++) {//先获取每一个一维数组int[] ints = newArr[i];//再遍历这个一维数组for (int j = 0; j < ints.length; j++) {int ele = ints[j];System.out.println("ele:"+ele);}System.out.println("-----------------");}//System.out.println("=====================");//foreach快捷键：iter+tab键for (int[] ints : newArr) {for (int ele : ints) {System.out.println("ele:"+ele);}}}
}