第六章 数组
数组的引入
【1】习题引入：
1 import java.util.Scanner;
2 public class TestArray01{
3 public static void main(String[] args){
4 //功能：键盘录入十个学生的成绩，求和，求平均数：
5 //定义一个求和的变量：
6 int sum = 0;
7 Scanner sc = new Scanner(System.in);
8 for(int i=1;i<=10;i++){//i:控制循环次数
9 System.out.print("请录入第"+i+"个学生的成绩：");
10 int score = sc.nextInt();
11 sum += score;
12 }
13
14 System.out.println("十个学生的成绩之和为："+sum);
15 System.out.println("十个学生的成绩平均数为："+sum/10);
16
17 //本题的缺点：
18 //求第6个学生的成绩：？？？？？---》不能
19
20 }
21 }
缺点：就是不能求每个学生的成绩具体是多少
解决：将成绩进行存储 ----》 引入 ： 数组
感受到数组的作用：数组用来存储数据的，在程序设计中，为了处理方便，数组用来将相同类型的若干数据组织起来。
这个若干数据的集合我们称之为数组。
数组的学习
【1】数组的定义
数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引（下标）来访问它们。
数组的四个基本特点：
1.长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
2.其元素的类型必须是相同类型，不允许出现混合类型。
3.数组类型可以是任何数据类型，包括基本类型和引用类型。
4.数组有索引的：索引从0开始，到 数组.length-1 结束
5.数组变量属于引用类型，数组也是对象。
PS:数组变量属于引用类型，数组也是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中存储的。
【2】数组的学习：
1 public class TestArray02{
2 public static void main(String[] args){
3 //数组的作用：用来存储相同类型的数据
4 //以int类型数据为案例：数组用来存储int类型数据
5 //1.声明(定义数组)
6 int[] arr; //定义一个int类型的数组，名字叫arr
7 //int arr2[];
8 //如果数组只声明，没有后续操作，那么这个数组相当于没定义
9 //int[] arr3 = null;//空 辨别：数组赋值为null和什么都没有赋值 不一样的效果
10
11 //2.创建
12 arr = new int[4];//给数组开辟了一个长度为4的空间
13 //编译期声明和创建会被合为一句话: int[] arr = new int[4];
14
15 //3.赋值
16 arr[0] = 12;
17 arr[3] = 47;
18 arr[2] = 98;
19 arr[1] = 56;
20 arr[2] = 66;
21 /*
22 arr[4] = 93;
23 出现异常：Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4
24 Array 数组
25 Index 索引
26 OutOf 超出
27 Bounds 界限
28 Exception 异常
29 ---》数组索引越界异常
30 */
31
32 //4.使用
33 System.out.println(arr[2]);
34 System.out.println(arr[0]+100);
35 //通过数组一个属性来获取 length 长度
36 System.out.println("数组的长度是："+arr.length);
37 }
38 }
内存分析
完善引入的习题_数组的遍历
【1】代码：
1 import java.util.Scanner;
2 public class TestArray03{
3 public static void main(String[] args){
4 //功能：键盘录入十个学生的成绩，求和，求平均数：
5 //定义一个int类型的数组，长度为10 ：
6 int[] scores = new int[10];
7 //定义一个求和的变量：
8 int sum = 0;
9 Scanner sc = new Scanner(System.in);
10 for(int i=1;i<=10;i++){//i:控制循环次数
11 System.out.print("请录入第"+i+"个学生的成绩：");
12 int score = sc.nextInt();
13 scores[i-1] = score;
14 sum += score;
15 }
16
17 System.out.println("十个学生的成绩之和为："+sum);
18 System.out.println("十个学生的成绩平均数为："+sum/10);
19
20
21 //求第6个学生的成绩：
22 //System.out.println(scores[5]);
23 /*
24 System.out.println(scores[0]);
25 System.out.println(scores[1]);
26 System.out.println(scores[2]);
27 System.out.println(scores[3]);
28 //....
29 System.out.println(scores[9]);
30 */
31 //将数组中的每个元素进行查看--》数组的遍历：
32 //方式1：普通for循环---》正向遍历：
33 for(int i=0;i<=9;i++){
34 System.out.println("第"+(i+1)+"个学生的成绩为："+scores[i]);
35 }
36
37 //方式2：增强for循环:
38 //对scores数组进行遍历，遍历出来每个元素都用int类型的num接收：
39 int count = 0;
40 for(int num:scores){
41 count++;
42 //每次都将num在控制台输出
43 System.out.println("第"+count+"个学生的成绩为："+num);
44 }
45
46 /*
47 增强for循环：
48 优点：代码简单
49 缺点：单纯的增强for循环不能涉及跟索引相关的操作
50 */
51
52 //方式3：利用普通for循环： 逆向遍历：
53 for(int i=9;i>=0;i--){
54 System.out.println("第"+(i+1)+"个学生的成绩为："+scores[i]);
55 }
56
57 }
58 }
【2】用IDEA验证数组的确将数据进行存储了：
数组的三种初始化方式
数组的初始化方式总共有三种：静态初始化、动态初始化、默认初始化。
- 静态初始化
除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。
eg:
int[] arr = {12,23,45};
int[] arr = new int[]{12,23,45};
注意：
1.new int[3]{12,23,45};-->错误
2.int[] arr ;
arr = {12,23,45}; --->错误
- 动态初始化
数组定义与为数组元素分配空间并赋值的操作分开进行。
eg:
int[] arr ;
arr = new int[3]
arr[0] = 12;
arr[1] = 23;
arr[2] = 45;
- 默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
int[] arr = new int[3]; ---> 数组有默认的初始化值
数组的应用题
最值问题
【1】实现一个功能：给定一个数组int[] arr = {12,3,7,4,8,125,9,45}; ，求出数组中最大的数。
思路图：
1 public class TestArray04{
2 public static void main(String[] args){
3 //实现一个功能：给定一个数组int[] arr = {12,3,7,4,8,125,9,45}; ，求出数组中最大的数。
4 //1.给定一个数组
5 int[] arr = {12,3,7,4,8,125,9,45,666,36};
6
7 //2.求出数组中的最大值：
8 //先找一个数上擂台，假定认为这个数最大：
9 int maxNum = arr[0];
10 for(int i=0;i<arr.length;i++){
11 if(arr[i]>maxNum){
12 maxNum = arr[i];
13 }
14 }
15 System.out.println("当前数组中最大的数为："+maxNum);
16
17 }
18 }
【2】将求最大值的方法提取出来：
1 public class TestArray04{
2 public static void main(String[] args){
3 //实现一个功能：给定一个数组int[] arr = {12,3,7,4,8,125,9,45}; ，求出数组中最大的数。
4 //1.给定一个数组
5 int[] arr = {12,3,7,4,8,725,9,45,666,36};
6
7 //2.求出数组中的最大值：
8 //调用方法：
9 int num = getMaxNum(arr);
10 System.out.println("当前数组中最大的数为："+num);
11 }
12
13 /*
14 想提取一个方法：求数组中的最大值
15 求哪个数组中的最大值 ---》不确定因素：哪个数组 (形参)---》返回值：最大值
16 */
17 public static int getMaxNum(int[] arr){
18 //先找一个数上擂台，假定认为这个数最大：
19 int maxNum = arr[0];
20 for(int i=0;i<arr.length;i++){
21 if(arr[i]>maxNum){
22 maxNum = arr[i];
23 }
24 }
25 return maxNum;
26
27 }
28 }
【3】画内存：
方法的实参传递给形参的时候一定要注意：一切都是值传递：
如果是基本数据类型，那么传递的就是字面值
如果是引用数据类型，那么传递的就是地址值
查询问题
【1】查询指定位置的元素
1 public class TestArray05{
2 public static void main(String[] args){
3 //查询指定位置的元素
4 //给定一个数组：
5 int[] arr = {12,34,56,7,3,10};
6 //查找索引为2的位置上对应的元素是什么？
7 System.out.println(arr[2]);
8 }
9 }
上面代码体现了数组的一个优点：
在按照位置查询的时候，直接一步到位，效率非常高
【2】查询指定元素的位置--》找出元素对应的索引
1 public class TestArray06{
2 public static void main(String[] args){
3 //查询指定元素的位置--》找出元素对应的索引
4 //给定一个数组：
5 int[] arr = {12,34,56,7,3,56};
6 // 0 1 2 3 4 5
7
8 //功能：查询元素888对应的索引：
9 int index = -1; //这个初始值只要不是数组的索引即可
10 for(int i=0;i<arr.length;i++){
11 if(arr[i]==12){
12 index = i;//只要找到了元素，那么index就变成为i
13 break;//只要找到这个元素，循环就停止
14 }
15 }
16 if(index!=-1){
17 System.out.println("元素对应的索引："+index);
18 }else{//index==-1
19 System.out.println("查无次数！");
20 }
21 }
22 }
【3】将查指定元素对应的索引的功能提取为方法：
1 public class TestArray06{
2 public static void main(String[] args){
3 //查询指定元素的位置--》找出元素对应的索引
4 //给定一个数组：
5 int[] arr = {12,34,56,7,3,56};
6 // 0 1 2 3 4 5
7
8 //功能：查询元素888对应的索引：
9 //调用方法：
10 int index = getIndex(arr,999);
11 //后续对index的值进行判断：
12 if(index!=-1){
13 System.out.println("元素对应的索引："+index);
14 }else{//index==-1
15 System.out.println("查无次数！");
16 }
17 }
18
19 /*
20 定义一个方法：查询数组中指定的元素对应的索引：
21 不确定因素：哪个数组，哪个指定元素 （形参）
22 返回值：索引
23
24 */
25 public static int getIndex(int[] arr,int ele){
26 int index = -1; //这个初始值只要不是数组的索引即可
27 for(int i=0;i<arr.length;i++){
28 if(arr[i]==ele){
29 index = i;//只要找到了元素，那么index就变成为i
30 break;//只要找到这个元素，循环就停止
31 }
32 }
33 return index;
34 }
35 }
添加元素
【1】实现一个功能：
添加逻辑：
1 public class TestArray07{
2 public static void main(String[] args){
3 //功能：给定一个数组,在数组下标为2的位置上添加一个元素91
4
5 //1.给定一个数组：
6 int[] arr = {12,34,56,7,3,10,55,66,77,88,999,89};
7 // 0 1 2 3 4 5
8 //2.输出增加元素前的数组：
9 System.out.print("增加元素前的数组：");
10 for(int i=0;i<arr.length;i++){
11 if(i!=arr.length-1){
12 System.out.print(arr[i]+",");
13 }else{//i==arr.length-1 最后一个元素不用加,
14 System.out.print(arr[i]);
15 }
16 }
17
18 //3.增加元素
19 /*
20 arr[5] = arr[4];
21 arr[4] = arr[3];
22 arr[3] = arr[2];
23 */
24 int index = 1;//在这个指定位置添加 元素
25 for(int i=arr.length-1;i>=(index+1);i--){
26 arr[i] = arr[i-1];
27 }
28 arr[index] = 666;
29
30
31 //4.输出增加元素后的数组：
32 System.out.print("\n增加元素后的数组：");
33 for(int i=0;i<arr.length;i++){
34 if(i!=arr.length-1){
35 System.out.print(arr[i]+",");
36 }else{//i==arr.length-1 最后一个元素不用加,
37 System.out.print(arr[i]);
38 }
39 }
40
41 }
42 }
【2】将添加功能提取为一个 方法：
1 import java.util.Scanner;
2 public class TestArray07{
3 public static void main(String[] args){
4 //功能：给定一个数组,在数组下标为2的位置上添加一个元素91
5
6 //1.给定一个数组：
7 int[] arr = {12,34,56,7,3,10,55,66,77,88,999,89};
8 // 0 1 2 3 4 5
9 //2.输出增加元素前的数组：
10 /*
11 System.out.print("增加元素前的数组：");
12 for(int i=0;i<arr.length;i++){
13 if(i!=arr.length-1){
14 System.out.print(arr[i]+",");
15 }else{//i==arr.length-1 最后一个元素不用加,
16 System.out.print(arr[i]);
17 }
18 }
19 */
20
21 //从键盘接收数据：
22 Scanner sc = new Scanner(System.in);
23 System.out.println("请录入你要添加元素的指定下标：");
24 int index = sc.nextInt();
25 System.out.println("请录入你要添加的元素：");
26 int ele = sc.nextInt();
27
28 //3.增加元素
29 //调用方法：
30 insertEle(arr,index,ele);
31
32
33
34 //4.输出增加元素后的数组：
35 System.out.print("\n增加元素后的数组：");
36 for(int i=0;i<arr.length;i++){
37 if(i!=arr.length-1){
38 System.out.print(arr[i]+",");
39 }else{//i==arr.length-1 最后一个元素不用加,
40 System.out.print(arr[i]);
41 }
42 }
43
44 }
45
46
47 /*
48 提取一个添加元素的方法：
49 在数组的指定位置上添加一个指定的元素。
50 在哪个数组的哪个位置添加哪个元素！
51 不确定因素：形参：哪个数组，哪个位置，哪个元素
52 返回值：无
53
54 */
55 public static void insertEle(int[] arr,int index,int ele){
56 for(int i=arr.length-1;i>=(index+1);i--){
57 arr[i] = arr[i-1];
58 }
59 arr[index] = ele;
60 }
61 }
删除元素
【1】实现一个功能：删除指定位置上的元素
逻辑：
1 import java.util.Arrays;
2 public class TestArray08{
3 public static void main(String[] args){
4 //功能：给定一个数组,删除下标为2元素
5
6 //1.给定一个数组：
7 int[] arr = {12,34,56,7,3,10,34,45,56,7,666};
8 // 0 1 2 3 4 5
9 //2.输出删除前的数组：
10 System.out.println("删除元素前的数组："+Arrays.toString(arr));
11
12 //3.删除
13 /*
14 arr[2] = arr[3];
15 arr[3] = arr[4];
16 arr[4] = arr[5];
17 */
18 int index = 0;
19 for(int i=index;i<=arr.length-2;i++){
20 arr[i] = arr[i+1];
21 }
22 arr[arr.length-1] = 0;
23
24 //4.输出删除后的数组：
25 System.out.println("删除元素后的数组："+Arrays.toString(arr));
26 }
27 }
【2】实现一个功能：删除指定元素
1 import java.util.Arrays;
2 public class TestArray09{
3 public static void main(String[] args){
4 //功能：给定一个数组,删除元素3：
5
6 //1.给定一个数组：
7 int[] arr = {12,34,56,7,3,10,34,45,56,7,666};
8
9 //2.输出删除前的数组：
10 System.out.println("删除元素前的数组："+Arrays.toString(arr));
11
12
13 //找到要删除的元素对应的索引即可：
14 int index = -1 ;
15 for(int i=0;i<arr.length;i++){
16 if(arr[i]==1200){
17 index = i;
18 break;
19 }
20 }
21
22 //3.删除
23
24 if(index!=-1){
25 for(int i=index;i<=arr.length-2;i++){
26 arr[i] = arr[i+1];
27 }
28 arr[arr.length-1] = 0;
29 }else{//index==-1
30 System.out.println("根本没有你要删除的元素！");
31 }
32
33
34 //4.输出删除后的数组：
35 System.out.println("删除元素后的数组："+Arrays.toString(arr));
36 }
37 }
详述main方法
【1】main方法：程序的入口，在同一个类中，如果有多个方法，那么虚拟机就会识别main方法，从这个方法作为程序的入口
【2】main方法格式严格要求：
public static void main(String[] args){}
public static --->修饰符 ，暂时用这个 -->面向对象一章
void --->代表方法没有返回值 对应的类型void
main --->见名知意名字
String[] args --->形参 ---》不确定因素
【3】问题：程序中是否可以有其他的方法也叫main方法？
可以，构成了方法的重载。
1 public class TestArray10{
2 public static void main(String[] args){
3
4 }
5 public static void main(String str){
6
7 }
8 }
【4】形参为String[] 那么实参到底是什么？
1 public class TestArray10{
2 public static void main(String[] args){
3 //从侧面验证：
4 //int[] arr1; //如果对数组只声明，没有后续操作，那么相当于 白定义了。
5 //int[] arr2 = null;
6 //System.out.println(arr2.length);//Exception in thread "main" java.lang.NullPointerException
7 //int[] arr3 = new int[0];
8 //System.out.println(arr3.length);
9 //int[] arr4 = new int[4];
10 //System.out.println(arr4.length);
11
12 //System.out.println(args.length);//0
13 //从这个结果证明，参数是String[],实参是 new String[0]
14 //默认情况下，虚拟机在调用main方法的时候就是传入了一个长度为0的数组
15
16 System.out.println(args.length);
17 for(String str:args){
18 System.out.println(str);
19 }
20 }
21 }
手动传入实参：
有特殊符号的时候可以加上“”
没有特殊符号用空格隔开即可：
可变参数
1 public class TestArray12{
2 /*
3 1.可变参数：作用提供了一个方法，参数的个数是可变的 ,解决了部分方法的重载问题
4 int...num
5 double...num
6 boolean...num
7
8
9 2.可变参数在JDK1.5之后加入的新特性
10 3.方法的内部对可变参数的处理跟数组是一样
11 4.可变参数和其他数据一起作为形参的时候，可变参数一定要放在最后
12 5.我们自己在写代码的时候，建议不要使用可变参数。
13 */
14 public static void main(String[] args){
15 //method01(10);
16 //method01();
17 //method01(20,30,40);
18 method01(30,40,50,60,70);
19 //method01(new int[]{11,22,33,44});
20 }
21 public static void method01(int num2,int...num){
22 System.out.println("-----1");
23 for(int i:num){
24 System.out.print(i+"\t");
25 }
26 System.out.println();
27
28 System.out.println(num2);
29 }
30 }
Arrays工具类
为了方便我们对数组进行操作，系统提供一个类Arrays，我们将它当做工具类来使用。
1 import java.util.Arrays;
2 public class TestArray13{
3 public static void main(String[] args){
4 //给定一个数组：
5 int[] arr = {1,3,7,2,4,8};
6 //toString:对数组进行遍历查看的，返回的是一个字符串，这个字符串比较好看
7 System.out.println(Arrays.toString(arr));
8
9 //binarySearch:二分法查找：找出指定数组中的指定元素对应的索引：
10 //这个方法的使用前提：一定要查看的是一个有序的数组：
11 //sort：排序 -->升序
12 Arrays.sort(arr);
13 System.out.println(Arrays.toString(arr));
14 System.out.println(Arrays.binarySearch(arr,4));
15
16 int[] arr2 = {1,3,7,2,4,8};
17 //copyOf:完成数组的复制：
18 int[] newArr = Arrays.copyOf(arr2,4);
19 System.out.println(Arrays.toString(newArr));
20
21 //copyOfRange:区间复制：
22 int[] newArr2 = Arrays.copyOfRange(arr2,1,4);//[1,4)-->1,2,3位置
23 System.out.println(Arrays.toString(newArr2));
24
25 //equals:比较两个数组的值是否一样：
26 int[] arr3 = {1,3,7,2,4,8};
27 int[] arr4 = {1,3,7,2,4,8};
28 System.out.println(Arrays.equals(arr3,arr4));//true
29 System.out.println(arr3==arr4);//false ==比较左右两侧的值是否相等，比较的是左右的地址值，返回结果一定是false
30
31 //fill：数组的填充：
32 int[] arr5 = {1,3,7,2,4,8};
33 Arrays.fill(arr5,10);
34 System.out.println(Arrays.toString(arr5));
35 }
36 }
数组的复制操作
原理：
代码：
1 import java.util.Arrays;
2 public class TestArray14{
3 public static void main(String[] args){
4 //给一个源数组：
5 int[] srcArr = {11,22,33,44,55,66,77,88};
6 //给一个目标数组：
7 int[] destArr = new int[10];
8
9 //复制：
10 System.arraycopy(srcArr,1,destArr,3,3);
11 //遍历查看目标数组：
12 System.out.println(Arrays.toString(destArr));
13 }
14
15 }
结果：
二维数组
【1】引入：本质上全部都是一维数组：
【2】基本代码：
1 public class TestArray15{
2 public static void main(String[] args){
3 //定义一个二维数组：
4 int[][] arr = new int[3][];//本质上定义了一个一维数组，长度为3
5
6 int[] a1 = {1,2,3};
7 arr[0] = a1;
8
9 arr[1] = new int[]{4,5,6,7};
10
11 arr[2] = new int[]{9,10};
12 }
13 }
对应内存：
【3】四种遍历方式：
1 public class TestArray15{
2 public static void main(String[] args){
3 //定义一个二维数组：
4 int[][] arr = new int[3][];//本质上定义了一个一维数组，长度为3
5
6 int[] a1 = {1,2,3};
7 arr[0] = a1;
8
9 arr[1] = new int[]{4,5,6,7};
10
11 arr[2] = new int[]{9,10};
12
13 //读取6这个元素：
14 //System.out.println(arr[1][2]);
15
16 //对二维数组遍历：
17 //方式1：外层普通for循环+内层普通for循环：
18 for(int i=0;i<arr.length;i++){
19 for(int j=0;j<arr[i].length;j++){
20 System.out.print(arr[i][j]+"\t");
21 }
22 System.out.println();
23 }
24
25 //方式2：外层普通for循环+内层增强for循环：
26 for(int i=0;i<arr.length;i++){
27 for(int num:arr[i]){
28 System.out.print(num+"\t");
29 }
30 System.out.println();
31 }
32
33 //方式3：外层增强for循环+内层增强for循环：
34 for(int[] a:arr){
35 for(int num:a){
36 System.out.print(num+"\t");
37 }
38 System.out.println();
39 }
40
41 //方式4：外层增强for循环+内层普通for循环：
42 for(int[] a:arr){
43 for(int i=0;i<a.length;i++){
44 System.out.print(a[i]+"\t");
45 }
46 System.out.println();
47 }
48 }
49 }
二维数组的初始化方式
数组的初始化方式总共有三种：静态初始化、动态初始化、默认初始化。
- 静态初始化
除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。
eg:
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}};
- 动态初始化
数组定义与为数组元素分配空间并赋值的操作分开进行。
eg:
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};
eg:
int[][] arr = new int[3][2];
1 public class TestArray16{
2 public static void main(String[] args){
3 int[][] arr = new int[3][2];
4 //本质上：定义一维数组，长度为3，每个数组“格子”中，有一个默认的长度为2的数组：
5
6 arr[1] = new int[]{1,2,3,4};
7
8 //数组遍历：
9 for(int[] a:arr){
10 for(int num:a){
11 System.out.print(num+"\t");
12 }
13 System.out.println();
14 }
15
16 }
17 }
- 默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
标签：arr,java,int,System,数组,public,out From： https://www.cnblogs.com/lcs-LLH/p/17825356.html