Java基础4(数组)

JVM中的内存区域

1. 方法区
   类的存放区域。
2. 栈
   变量的存放区域。当我们新建一个方法的时候，就会新建一个栈，也就是一个方法就对应着一个栈。
3. 堆
   数组的存放区域。
4. GC（垃圾回收器）
   当我们创建了一个数组，但是却没有使用，那么数组的存在会占用内存，没有意义，就相当于垃圾，我们不需要了的，当JVM 的内存不够用了的时候，就会去清理这些没有被引用的对象所占用的内存空间。

数组的定义
就是当有多个 相同类型 的常量值有序 存放起来的时候，那就可以定义一个数组，就相当于excel的一列数据。数组中的索引相当于excel中一列数据中对应的行数，元素就是表格中的内容，所以我们使用的是元素，索引只是我们用来记录元素的位置的，数组中的第一个元素对应的索引是0，第二个元素对应的索引是1，以此类推。

定义的语法：数据类型[] 数组名

int[] ages;//定义一个int类型的数组，名称为args
int ages[];//这是另一种定义的方法，但是不推荐，因为要看到名称才知道是数组，只看到数据类型不能确定是数组，可读性不强。

数组的初始化
为数组分配内存，来存放数组的数据（也就是堆）

1. 静态初始化
   当知道元素是什么的时候就使用静态初始化
   语法：数组元素类型[] 数组名 = new 数组元素类型[]{元素1，元素2，…}

//先定义后初始化
String[] s;
s = new String[]{仙女1，仙女2，仙女3}
//定义数组的同时初始化
int[] a = new int[]{1,2,3,4};
//简单方式，可以省略new之后的 数组元素类型[]
int[] a1 = {1,2,3,4};

2. 动态初始化
   只设置数组的元素个数，数据由JVM自行生成。各数据类型的默认值如下图：
   
   语法：数据类型[] 数组名 = new 数据类型{元素个数}；

int[] ages = new int[5];//5表示元素的个数。

数组的元素的操作

1. 获取元素的个数
   语法：数组名.length

int[] nums = {1,2,3,4,5};
int size = nums.length;//size等于nums数组的长度，也就是数组中有多少个元素。

2. 设置数组元素
   语法：数组名[索引] = 值;

int[] nums = {1,2,3,4,5};
nums[2] = 333;//执行这个语句之后，数组就变成了{1，2，333，4，5}，因为索引是从0开始的，索引为2，对应的就是第三位的数据。

3. 获取数组中的元素
   语法：元素类型 变量名 = 数组名[索引]；
   需要确定索引是否存在

int[] nums = {1,2,3,4,5};
//获取第四个数据
int i = nums[3];//第四个数据，索引值为3.

4. 为数组中的指定索引位置设值
   方法一：for

int[] nums = {1,2,3,4,5};
for (int i = 0;i < nums.length;i++){
   System.out.print(nums[i]+",");
 }

方法二：for-each
不会涉及到索引，使用定义的变量去接收每次变量出来的元素。

int[] nums = {1,2,3,4,5};
for(int i:nums){
	System.out.print(i);
}

5. 操作数组过程中可能存在的问题和原因
   NullPointerException：空指针异常（空引用异常）
   操作了一个尚未初始化或者没有分配内存空间的数组
   ArrayIndexOutOfBoundsException：数组的索引越界异常
   操作的数组的索引不在[0，数组名.length-1]范围内

练习

1. ArrayDemo1.java（重点）

需求：定义数组和数组的静态初始化操作

步骤：

（1）先定义后初始化数组（不能使用简写方式）

（2）定义数组，同时初始化

（3）打印数组长度

（4）数组赋值为空，并演示空指针错误

public class ArrayDemo1 {
    public static void main(String[] args){
        //先定义后初始化
        int[] a;
        a = new int[]{1,2,3,4};
        //定义数组同时初始化
        String[] s = new String[]{"张三","李四"};
        //打印数组长度
        System.out.println("数组a的长度为"+a.length);
        //数组赋值为空，错误情况
       int[] a1;
       System.out.print(a1);//因为没有对a1进行初始化，所以在调用a1的时候会报错
        System.out.print(a);//此处a已经被初始化，所以不会报错
    }
}

运行结果（注释掉后两行）

内存分析图

2. ArrayDemo2java（重点）

需求：数组的动态初始化和内存分析

步骤：

（1）动态初始化数组，并打印数组长度

（2）重新初始化数组，并打印数组长度

（3）请在纸上画出以上代码的内存分析图

public class ArrayDemo2 {
    public static void main(String[] args){
        int[] a = new int[5];
        System.out.println("a数组的长度为"+a.length);
        a = new int[2];
        System.out.println("重新初始化后a数组的长度为"+a.length);
    }
}

运行结果

内存分析图

3. ArrayDemo3.java（重点）

需求：数组的基本操作

步骤：

（1）定义一个数组nums,并静态初始化该数组

（2）定义一个变量size获取nums的数组长度

（3）获取数组元素

（4）设置数组元素

（5）遍历数组

public class ArrayDemo3 {
    public static void main(String[] args){
        int[] nums = {1,2,3,4,5};
        int size = nums.length;
       //获取数组元素
        System.out.print("nums数组的当前元素为");
        System.out.println(java.util.Arrays.toString(nums));
//        for (int i = 0;i < size;i++){
//            System.out.print(nums[i]+",");
//        }
//        System.out.println();
        //设置数组长度
        System.out.print("您希望该数组中的元素个数为");
        Scanner sc = new Scanner(System.in);
        size = sc.nextInt();
        nums = new int[size];
        //设置数组元素
        for (int i = 0;i < size;++i){
            System.out.print("第"+(i+1)+"个数据=");
            Scanner sc1 = new Scanner(System.in);
            int info = sc1.nextInt();
            nums[i] = info;
        }
        //遍历数组
        System.out.print("nums数组的当前元素为");
        for (int i = 0;i < size;i++){
            System.out.print(nums[i]+",");
        }
    }
}

运行结果

4. ArrayDemo4.java（重点）

需求：找出数组值元素22,在数组中第一次出现的索引位置

步骤：

（1）定义一个数组nums，并初始化该数组

（2）定义一个变量key，表示被搜索的元素

（3）遍历数组

（4）判断如果当前元素和key相等，证明找到元素，打印并结束循环

public class ArrayDemo4 {
    public static void main(String[] args){
        int[] nums = {11,12,13,14,15,21,22,23,24,25,22};
        int key = 22;
        for (int i =0;i<nums.length;++i){
            if (nums[i]==key){System.out.println("第一个元素等于22的索引值为"+i);break;}
        }
    }
}

运行结果

5. ArrayDemo5.java（重点）

需求：求出int类型数组中最大元素值

步骤：

（1）定义并初始化数组nums

（2）定义一个变量max表示最大的元素，并假设nums的第一个元素为最大值

（3）使用foreach循环遍历nums数组

（4）判断如果遍历的元素和max比较，遍历的元素比较大，就将当前元素赋值给max

（5）遍历完成打印max

public class ArrayDemo5 {
    public static void main(String[] args){
        int[] nums = {10,22,15,88,2};
        int max = nums[0];
        for (int i:nums) {
            if (i > max){ max = i; }
        }
        System.out.print("数组中元素的最大值为"+max);
    }
}

运行结果

6.ArrayDemo6.java（重点）

需求：按照某种格式来打印出数组中的元素，打印效果为：[11,22,33,44,22,55]

步骤：

（1）定义并初始化数组nums

（2）定义一个字符串类型的变量str，用于拼接字符串

（3）遍历数组并拼接元素到str

（4）判断为最后一个元素拼接“]”，否则拼接“，”

（5）打印str

public class ArrayDemo6 {
    public static void main(String[] args){
        int[] nums ={11,22,28,88};
        String str;
        System.out.print("[");
        for (int i = 0; i<nums.length;++i){
           if (i== nums.length-1){str = "]";}
           else {str = ",";}
           System.out.print(nums[i]+str);
        }
    }
}

运行结果

7. ArrayInArrayDemo.java

需求：演示二维数组的基本操作

步骤：

（1）定义一个二维数组

（2）静态初始化二维数组

（3）动态初始化二维数组

（4）获取二维数组的元素

（5）设置二维数组的元素

（6）for循环遍历并打印二维数组的元素

（7）foreach循环遍历并打印二维数组的元素

public class ArrayInArrayDemo {
    public static void main(String[] args){
        //定义一个二维数组
        int[][] arr;
        //静态初始化二维数组
        arr = new int[][]{{1,1,1,1},{2,2,2,2}};
        //动态初始化二维数组
        //2:二维数组的个数；
        //5：一维数组的元素个数，可以省略，省略代表不受限制
        int[][] arr2 = new int[2][3];
        System.out.println(java.util.Arrays.toString(arr2[0]));
        //获取二维数组的元素
        int[] a = arr[0];
        //设置二维数组的元素
        arr2[0] = new int[]{3,3,3,3};
        System.out.println(java.util.Arrays.toString(arr2[0]));
        System.out.println(arr2[0][1]);
        //for循环遍历并打印二维数组的元素
        for (int i = 0 ;i < arr.length;++i){
            for (int j = 0 ; j < arr[i].length;++j){
                System.out.print(arr[i][j]+" ");
            }
        }
        System.out.println();
        //foreach循环遍历并打印二维数组的元素
        for (int[] a2:arr2) {
            for (int a3:a2) {
                System.out.println(a3);
            }
        }
    }
}

运行结果

综合练习

1. LocationDemo.java

需求：定义一个 int 类型数组,求出该数组索引是偶数的元素之和

思路：注意区分索引和元素

public class LocationDemo {
    public static void main(String[] args){
        int[] nums = {1,2,3,4,5};
        int sum = 0;
        for (int i = 0;i < nums.length;++i){
            if (i%2 == 0){sum = sum + nums[i];}
        }
        System.out.print("该数组索引是偶数的元素之和为"+sum);
    }
}

运行结果

2.ReversedDemo.java

需求：定义一个元素为String类型数组，按照格式逆序打印该数组的元素，例如

数组内容为：{“A”，”B”，”C”，”D”},打印效果为：[D,C,B,A]

思路：

（1）索引从大到小逆序遍历

（2）字符串拼接

public class ReversedDemo {
    public static void main(String[] args){
        String[] str = {"a","b","c","d"};
        String str1;
        System.out.print("数组的逆序遍历内容为[");
        for (int i = str.length-1;i>=0;--i){
            if (i == 0){str1 = "]";}
            else {str1 = ",";}
            System.out.print(str[i]+str1);
        }
    }
}

运行结果

3. StatisticsDemo1.java

需求：定义一个 int 类型,长度为2的数组，其索引 0 位置存放指定数组索引为偶数的元素之和，索引 1 位置存放指定数组索引为奇数元素之和。

public class StatisticsDemo1 {
    public static void main(String[] args){
        int[] sum = new int[2];
        int[] arr = {1,2,3,4,5,6,7,8,9};
        for (int i = 0; i<arr.length;++i){
            if (i%2 == 0){sum[0] = sum[0]+arr[i];}
            else {sum[1] = sum[1] + arr[i];}
        }
        System.out.print("数组arr的索引为偶数的元素之和与索引为奇数的元素之和分别为"+java.util.Arrays.toString(sum));
    }
}

运行结果

4. StatisticsDemo2.java

需求：定义一个 int 类型的二维数组，统计数组元素值是 0 的的元素个数。

例如：二维数组：{{1,2,0,4,0}，{0,3,5}}, 0的个数为3

public class StatisticsDemo2 {
    public static void main(String[] args){
        int[][] arr = {{1,2,0,4,0},{0,3,5}};
        int flag = 0;
        for (int i = 0 ;i < arr.length;++i){
            for (int j = 0 ; j < arr[i].length;++j){
                if (arr[i][j] == 0){++flag;}
            }
        }
        System.out.print(flag);
    }
}

运行结果

5.StatisticsDemo3.java(选做)

需求：定义一个整型数组，将数组中的0去掉后返回一个新数组。

例如：数组为 int[] arr={1,13,45,5,0,0,16,6,0,25,4,17,6,7,0,15}; 要求将以上数组中为0的元素去掉，将不为0的值存入一个新数组，生成新的数组作为返回值: int[] newArr={1,13,45,5,16,6,25,4,17,6,7,15};

思路:

1. 统计数组中元素不为0的元素个数length
2. 定义一个新数组, 将上面统计得到的length作为新数组的长度
3. 遍历原数组,将不为0的元素添加到新数组中(注意索引的控制)

public class StatisticsDemo3 {
    public static void main(String[] args){
        int[] arr={1,13,45,5,0,0,16,6,0,25,4,17,6,7,0,15};
        int length = 0;
        for (int i = 0 ;i < arr.length;++i){
            if (arr[i] != 0){++length;}
        }
        int[] arr2 = new int[length];
        int j =0;
        for (int i = 0 ; i< arr.length; ++i){
            if(arr[i] != 0){
                arr2[j] = arr[i];
                j++;
            }
        }

        System.out.print(java.util.Arrays.toString(arr));
    }
}

运行结果