零基础学习java------day6----数组

0. 内容概览

补充：main方法中的数组

1. 数组的概述

概念：

　　用来存储一组相同数据类型的集合（或者叫容器）

注意事项：

　　1. 数组中的元素类型必须一致

　　 2. 数组本身是引用数据类型，但是里面的元素既可以是基本数据类型，也可以是引用数据类型

　　 3. 数组的长度一旦给定就无法改变

声明

　　（1）数据类型[]  数组名   （2）数据类型  数组名[]

备注：main方法中只有两个地方可以改变，即中括号的位置和args的名字

2 . 数组的初始化　　

2.1 动态初始化

给定数组的长度，有系统分配空间和初始值

格式：

　　　数据类型[ ]  数组名 = new 数据类型[数组的长度]；

如： int[]  arr = new int[5];

数组的赋值和取值：

　　索引: 索引是从0 开始的,索引的最大值是数组的长度减1

　　赋值: 数组名[索引值] = 要赋的值
　　取值: 数组名[索引值];

案例: 创建一个长度为4的int 数组,并赋值　

package com._51doit.javase.day06;

public class ArrayDemoTest {
    public static void main(String[] args) {
        int[] arr = new int[4] ;//声明
        //System.out.println(arr);//局部变量不赋初值不能使用
        //赋值: 数组名[索引值] = 要赋的值
        //取值: 数组名[索引值];
        arr[0] = 100;
        arr[1] = 20;
        arr[2] = 89;
        arr[3] = 1000;
        for(int i=0;i<=3;i++) {
            System.out.println(arr[i]);
        }
    }
}

练习

1. 创建一个String类型长度为4的数组，输入张三，李四，王二，麻子并分别将其名字存到该数组中

package com._51doit.javase.day06;

import java.util.Scanner;

public class ArrayDemo1 {
    public static void main(String[] args) {
        String[] names = new String[5];
        for(int i=0;i<names.length;i++) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入第"+(i+1)+"个名字");
            String name = sc.nextLine();
            names[i] = name;
        }
        for(int i=0;i<names.length;i++) {
            System.out.println(names[i]);
        }
    }
}

2. 创建一个char 类型的数组,把'多' '易' 教育分别存进去

public class ArrayTest {
    public static void main(String[] args) {
        char[] arr = new char[4];
        arr[0] = '多';
        arr[1] = '易';
        arr[2] = '教';
        arr[3] = '育';
    }
}

2.2数组的静态初始化

 概念：

　　给定数组中的元素，由系统分配长度并赋值

格式：

　　数据类型[ ]  数组名 =  new 数据类型[ ]{元素1，元素2.....}；

简写格式

　　数据类型[ ] 数组名 = {元素1，元素2.......}

注意事项：

　　只有第一次定义的时候可以简写，重写赋值的时候不能简写

数组长度的获取：数组名.length

public class ArrayDemo5 {
    public static void main(String[] args) {
        int[] arr = new int[] {1,2,3,4,5,6,7,8};
        System.out.println(arr.length);//8
        System.out.println(arr[7]);
        String[] arr1 = {"中","发","白"};
        //arr1 = {"梅","蓝"};//重写赋值不能简写
        arr1 = new String[]{"梅","蓝"};
        for(int i=0;i<=arr.length-1;i++) {
            System.out.println(arr[i]);//0-7
        }
    }
}    

练习

1. 创建一个char数组：多易教育，然后遍历

package com._51doit.javase.day06;

public class PracticeDemo1 {
    public static void main(String[] args) {
        char[] arr1 = new char[] {'多','易','教','育'};
        for(int i=0;i<arr1.length;i++) {
            System.out.print(arr1[i]);
        }
    }

}

2. 创建int 数组,存入5 个元素,求该数组的元素之和, 平均值

package com._51doit.javase.day06;

public class PracticeDemo1 {
    public static void main(String[] args) {
        char[] arr1 = new char[]
        int[] arr2 = new int[] {12,11,33,44};
        int sum = 0;
        double aver;
        for(int i=0;i<arr2.length;i++) {
            sum += arr2[i];
        }
        aver = (double)sum/arr2.length;
        System.out.println("元素之和为："+sum);
        System.out.println("平均值为："+aver);
    }
}

 3. 数组的内存分析

栈（stack）：

　　存放局部变量和方法名，没有初始值

堆（heap）：

　　存放new出来的东西（如，new int[1,2,3,4]）,有初始值（基本数据类型：默认值；引用数据类型：null）

如果堆中内存没有栈中变量指向时（python中指的是引用计数为0，此处不知），就会成为垃圾，等待GC自动回收

如图

注意  打印arr时，得到的是一个编号（图中是[I@7852e922, "["表示以为数组，I表示int类型，7852e922则表示存储地址）

当main方法执行完时，main方法就从栈中弹出去了，也就是说arr没了（就没有指向堆的指针了），所以对重的数据就被当垃圾回收掉了，如下

当初始化多个数组时，如将第二个数组赋值给第一个数组（如下图，令arr=arr1），此时数组指向的地址就会发生改变，此处的arr指向由ox0001变为0x0002

4. 数组常见异常

 空指针异常

　　产生的原因: 使用null 调用堆中的内容,要注意的是,如果一个变量的初始值是null,直接打印是不报错的,只有调用他里面的东西才会报空指针

案例：

int [] arr = null;//有初始值,初始值为null
System.out.println(arr); //null
System.out.println(arr[0]);// java.lang.NullPointerException

这里能解释前面比较字符串相等出现的equals，其形式为：字符串a.equals(字符串b)，若将未知字符串放在a位置，若未知字符串是空，则会报空指针异常错误，但将已知的字符串放a位置就不会出现这种情况

 数组角标越界异常：

　　产生的原因:数组的索引值超出的最大的范围,就会出现该异常

案例：　

int[] arr = new int[3];// 索引值0-2
System.out.println(arr[4]);// java.lang.ArrayIndexOutOfBoundsException

　　

 5. 数组案例

5.1 点名系统

从全班同学的名字中随机挑选一个:

分析步骤:
1. 构建一个String 类型的数组,用来存储全班同学的名字
2. 需要生成一个随机数,作为索引值,

Random(java.util)
Random r = new Random();
int a = r.nextInt(20);//生成[0-20) 之间的随机数

3. 根据索引值从数组中取元素

package com._51doit.javase.day06;

import java.util.Random;

public class CallName {
    public static void main(String[] args) {
　　　　　// 1. 构建一个全班同学名字的数组
        String[] names = new String[] {"张三","李四","王二","麻子","小红","小明","小强","老王"};
　　　　　// 2. 生成随机索引
        Random r = new Random();
        int index = r.nextInt(8);
　　　　 //3. 根据随机数从数组中获取元素
        String name = names[index];
        System.out.println("有请"+name+"同学发言");
    }
}

5.2 数组的遍历 

案例：定义一个数组{1,2,3,4,5}，按如下格式打印数据[1,2,3,4,5]

分析: 1. 对数组做遍历
2. 如果是第一个元素:打印” [元素, ”
3. 最后一个元素: 元素]
4.其余元素: 元素,

package com._51doit.javase.day06;

public class ArrayDemo2 {
    public static void main(String[] args){
        int[] arr = {1,2,3,4,5};
//1. 对数组做遍历
        for(int i=0;i<arr.length;i++) {
            //对一个元素的数组做单独处理
            if(arr.length == 1) {
                System.out.println("["+arr[0]+"]");
            }
            //2. 如果是第一个元素:打印[元素,
            else if(i == 0) {
                System.out.print("["+arr[i]+",");//注意不换行
            }else if(i==arr.length-1) {
                //3. 最后一个元素: 元素]
                System.out.println(arr[i]+"]");//可以换行
            }else {
                //4.其余元素: 元素,
                System.out.print(arr[i]+",");//不换行
            }
        }
    }
}

封装成方法：

    public static void printArr(int[] arr) {
        //1. 对数组做遍历
        for(int i=0;i<arr.length;i++) {
            //对一个元素的数组做单独处理
            if(arr.length == 1) {
                System.out.println("["+arr[0]+"]");
            }
            //2. 如果是第一个元素:打印[元素,
            else if(i == 0) {
                System.out.print("["+arr[i]+",");//注意不换行
            }else if(i==arr.length-1) {
                //3. 最后一个元素: 元素]
                System.out.println(arr[i]+"]");//可以换行
            }else {
                //4.其余元素: 元素,
                System.out.print(arr[i]+",");//不换行
            }
        }
    }

在main方法中调用：

public static void main(String[] args){
    int[] arr = {1,2,3,4,5,6};
        printArr(arr);
}

5.3  工具类的封装

1.在我们的项目中创建一个util的包，并在在包下创建一个类：ArrayUtil

在类中建方法：

package com._51doit.javase.util;

public class ArrayUtil {
    // 打印数组
    public static void printArr(int[] arr) {
        //1. 对数组做遍历
        for(int i=0;i<arr.length;i++) {
            //对一个元素的数组做单独处理
            if(arr.length == 1) {
                System.out.println("["+arr[0]+"]");
            }
            //2. 如果是第一个元素:打印[元素,
            else if(i == 0) {
                System.out.print("["+arr[i]+",");//注意不换行
            }else if(i==arr.length-1) {
                //3. 最后一个元素: 元素]
                System.out.println(arr[i]+"]");//可以换行
            }else {
                //4.其余元素: 元素,
                System.out.print(arr[i]+",");//不换行
            }
        }
    }
}

调用

public class ArrayDemo2 {
    public static void main(String[] args){
        int[] arr = {1,2,3,4,5,6};
                ArrayUtil.printArr(arr);
}

5.4 最值

最值：最大值和最小值

案列：数组{1,2,3,4,5,6} 打印最大值和最小值

思路: 1. 设置一个变量用来代表最值(数组中的第一个元素)
　　  2. 用这个变量和数组中的每一个元素作比较
　　  3. 如果数组中有元素比他大,就把他的值重新赋值
　　  4. 比较结束后,打印最值

package com._51doit.javase.day06;

public class PrintMaxAndMinValue {
    public static void main(String[] args) {
        int[] arr1 = new int[] {1,2,3,4,5,6};
        printMaxAndMin(arr1);
    }
    public static inr[] getMaxAndMin(int[] arr) {
        int max = arr[0];
        int min = arr[0];

        for(int i=0;i<arr.length;i++) {
            if(arr[i]>max) {
                max = arr[i];
            }
            if(arr[i]<min) {
                min = arr[i];
            }
        }
        //System.out.println(max);
        //System.out.println(min);
　　　　 int[] result = {max,min}
　　　　 return result;

    }
}

封装方法

    public static int[] getMaxAndMin(int[] arr) {
        int max = arr[0];
        int min = arr[0];

        for(int i=0;i<arr.length;i++) {
            if(arr[i]>max) {
                max = arr[i];
            }
            if(arr[i]<min) {
                min = arr[i];
            }
        }
        int[] result = {max, min};
        return result;
    }

调用

    public static void main(String[] args) {
        int[] arr1 = new int[] {1,2,3,4,5,6};
        ArrayUtil.getMaxAndMin(arr1);

5.5 数组元素索引的查找

案例

查找数组[1,2,3,4,5,6]中数值为5的索引

封装方法

    public static int index(int[] arr,int num) {
        int location = -1;
        for(int i=0;i<arr.length;i++) {
            if(arr[i] == num) {
                location = i;
                break;
            }
        }
        System.out.println(location);
        return location;
    }

调用

    public static void main(String[] args) {
        int[] arr1 = new int[] {1,2,3,4,5,6};
        int num=5;
        ArrayUtil.index(arr1,num); //得到结果为4

5.6 元素交换

如何将数组中的两个元素做交换
举例: 将一杯雪碧和一杯可乐做交换:
　　思路:要引入一个空杯.，先把雪碧倒入空杯，把可乐倒入雪碧杯，再把空杯中的可乐倒入空杯

int temp = arr[0];//第一个元素进空杯
arr[0] = arr[1];//第二个元素进第一个元素被
arr[1] = temp;//空杯中倒入第二个被

//创建一个方法,交换数组中的两个元素:
public static void swap(int[]arr,int x,int y) {
    int temp = arr[x];
    arr[x] = arr[y];
    arr[y] =temp;
}

5.7 逆序
大致流程如下图，第一个数和最后一个数换，第二个数与倒数第二个数换，以此类推。。。。。

封装方法

    // 数组的反转
    public static void reverse(int[] arr) {
        for(int i=0;i<arr.length/2;i++) {
            int temp = arr[i];
            arr[i] = arr[arr.length-1-i];
            arr[arr.length-1-i] = temp;
        }
    }

调用

public class Reverse {
    public static void main(String[] args) {
        int[] arr1 = new int[] {1,2,3,4,5,6};
        ArrayUtil.printArr(arr1);
        ArrayUtil.reverse(arr1);
        ArrayUtil.printArr(arr1);
    }

运行结果如下

6. 多维数组

1 数据类型[ ][ ]  数组名 = new 数据类型[m][n];
　　m: 二维数组中一维数组的个数
　　n: 一维数组中元素的个数
2  数据类型[][] 数组名= new 数据类型[m][];
　　m:二维数组中一维数组的个数
3. 数据类型[][] 数组名= new  数据类型[][]{{元素值,元素值...},{元素值,元素值...},{元素值,
元素值,...}};
简写: = {{元素值,元素值...},{元素值,元素值...},{元素值,元素值,...}};

　　
第一种类型案例

package com._51doit.javase.day06;

public class MultiDArrayDemo {
    public static void main(String[] args) {
        int[][] arr = new int[4][5];
        System.out.println(arr[1][3]); // 打印的是第二个数组中的低是个元素
    }
}

这种类型只能表示元素数相同的数组（二元数组中的数组），为了解决这个问题，类型二就很有必要了

第二种类型

int[][] arr1 = new int[3][];
arr1[0] = new int[] {1,2,3,4,5};
arr1[1] = new int[] {1,2};
arr1[2] = new int[]{7,8,9,9,2}

注意：给二维数组赋值时，不能简写，如下面写法就是错误的

arr1[2]= {3,4}; //给二维数组中一维数组赋值的时候,不能简写

但如上面这样数组一个一个的定义比较麻烦，这时候3的形式就比较重要了（下面代码相当于上面第二种类型的效果）

int[][] arr1 = new int[][] {{1,2,3,4,5},{1,2},{7,8,9,9,2}};

7. main方法中的数组

main方法中的数组是用来接收键盘录入的参数的（即可以在终端命令行输入参数）

用法：

　　javac 命令不变

　　java命令 后面跟参数，多个参数用空格隔开

　　如：java HelloWorld a b c d

　　a b c d就自动装入args数组里了

案例

package com._51doit.javase.day06;

public class ArrayTest {
    public static void main(String[] args) {
        for(int i=0;i<args.length;i++) {
            System.out.print(args[i]);
        }
    }
}

在终端命令行运行的话，直接编译，即javac ArrayTest.java=======>java ArrayTest  1 2 3即可遍历得到数组args的元素分别为1 ，2， 3

若在eclipse上运行的话，run as===>选择run configurations=====>找到要运行的类（如此处是ArrayTest）====>点击Arguments===>输入自己的参数，如下图

应用后，点击run即可得到代码运行后的结果