day10_复习_数组_方法

非常重要的: 方法设计(参数,返回值,调用)

数组也重要,但是后续很少用! 是因为后期有更简单的【集合】，重要在于是一种思想，也是一种代码逻辑

---

关于数组:

• 声明创建
• 取值,存值
• 遍历
• 面试|算法 --> 排序
• 内存图(堆,栈,引用)

---

今天

• 数组工具类:Arrays
• 数组扩容(拷贝)
• 作业

一、Arrays

Arrays , 数组工具类, 主要提供一系列操作数组的方法,常用的

• String toString(数组参数) 将数组的元素以字符串的形式返回(将数组转成字符串后返回)
• void sort(数组参数), 将数组按照升序排序
• copy

package com.qf.array;

import java.util.Arrays;

/**
 * @desc
 */
public class Demo1 {

    public static void main(String[] args) {
        // 数组声明创建方式1
        int[] arr1 = new int[3];
        // int arr2[];// 语法不错,但是不建议
        // 数组声明创建方式2
        int[] arr2 = new int[]{1,2,3,4};

        // 数组声明创建方式3
        int[] arr3 = {1,2,3,4};


        /**
         * 使用数组工具类,用法
         *  返回值 = 类名.方法名(参数)
         *------------------------------
         * toString方法,作用是将数组以字符串形式返回
         *-----------------------------
         * 作用:
         *   主要用来遍历数组元素,方便查看
         */
        // String s = Arrays.toString(arr3);
        // System.out.println(s );
        System.out.println( "遍历" + Arrays.toString(arr3));
        /**
         * Arrays工具第二个常用方法
         * void sort(数组),作用是将数组按照升序排序
         */
        int[] arr4 = {5,2,3,1,4};
        // 排序前遍历一遍,看效果
        System.out.println("排序前: "+Arrays.toString(arr4));

        // 调用方法完成排序
        Arrays.sort(arr4);

        System.out.println("排序后: "+Arrays.toString(arr4));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

二、数组扩容

数组特点是长度固定,那还怎么扩容?

• 为什么扩容? 因为装不下
• 怎么扩? 其实是重新创建一个大一点(一般是1.5倍,2倍)的数组,将之前数组的元素拷贝到新的数组

三、拷贝

3.1 手动

思路

1. 手动创建一个数组(假定原数组2倍长度)
2. 遍历老数组取出元素,挨个存储到新数组

package com.qf.array;

import java.util.Arrays;

/**
 * @desc 数组扩容+拷贝
 */
public class Demo2 {

    public static void main(String[] args) {

        // 现有数组
        int[] arr = {1,2,3,4,5};
        System.out.println("扩容前: " + Arrays.toString(arr) );
        // 继续往里存储数据,但是存储不了
        // arr[5] = 6; // 报错,越界
        // 现在想将数组扩容,后再存储
        arr = copy1(arr);

        arr[5] = 6;
        System.out.println("扩容后: " + Arrays.toString(arr) );

    }

    // 需求: 将数组长度扩大2倍
    // 拷贝方式1: 手动实现
    public static int[] copy1(int[] arr) {
        // 创建一个新数组是原来的2倍
        int[] arr2 = new int[arr.length * 2];
        // System.out.println("拷贝前: " + Arrays.toString(arr2) );
        // 开始拷贝
        for (int i = 0; i < arr.length; i++) {
            // 取出老数组中的元素赋值给新数组
            arr2[i] = arr[i];
        }
        // System.out.println("拷贝后: " + Arrays.toString(arr2) );
        return arr2;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

3.2 System工具【重要】

package com.qf.array;

import java.util.Arrays;

/**
 * @desc 数组扩容+拷贝(工具实现)
 */
public class Demo3 {

    public static void main(String[] args) {

        // 现有数组
        int[] arr = {1,2,3,4,5};
        System.out.println("扩容前: " + Arrays.toString(arr) );
        // 继续往里存储数据,但是存储不了
        // arr[5] = 6; // 报错,越界
        // 现在想将数组扩容,后再存储

        arr = copy(arr);// 将新数组地址值覆盖给变量
        // 即arr现在指向新的数组

        arr[5] = 6;
        System.out.println("扩容后: " + Arrays.toString(arr) );

    }

    public static int[] copy(int[] arr) {
        /**
         * 现在使用jdk自带工具方法完成数组拷贝
         * 参数1: src,资源(原始、源），即原数组
         * 参数2: srcPos,原始数组位置
         * 参数3: dest,目的地即新数组
         * 参数4: destPos,新数组位置
         * 参数5: length,长度即拷贝的元素个数
         *
         * 从原数组的指定位置拷贝指定个数到新数组指定位置
         */
        int[] arr2 = new int[arr.length * 2];
        System.arraycopy(arr,0,arr2,0,arr.length);
        return arr2;// 返回的是新数组的地址值
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

3.3 Arrays工具

public class Demo4 {

    public static void main(String[] args) {
        // 现有数组
        int[] arr = {1,2,3,4,5};
        System.out.println("扩容前: " + Arrays.toString(arr) );
        // 继续往里存储数据,但是存储不了
        // arr[5] = 6; // 报错,越界
        // 现在想将数组扩容,后再存储

        /**
         * Arrays提供的方法
         * copyOf方法内部创建了新数组,长度是指定长度
         *   而且还会将之前老数组的元素拷贝到新数组
         *   最后将新数组的地址值返回给变量arr
         * 即arr指向最新的数组
         */
        arr = Arrays.copyOf(arr,arr.length*2);

        arr[5] = 6;
        System.out.println("扩容后: " + Arrays.toString(arr) );

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

四、作业

题19

请创建一个长度为5的整数数组，并为数组中的元素赋值。遍历数组，打印所有元素，元素之间用空格隔开。比如：
数组为：1,2,3,4,5
打印结果：[1,2,3,4,5] 
1
2
3

    public static void main(String[] args) {
        int[] arr = {11, 22, 33, 44, 55};
        String s = toStrPro(arr);
        System.out.println(s );
        Arrays.toString(arr);
    }

    // 请创建一个长度为6的整数数组，并为数组中的元素赋值。遍历数组，打印所有元素，元素之间用空格隔开。比如：
    // 数组为：1,2,3,4,5
    // 打印结果：[1,2,3,4,5]
    public static void toStr(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {// 是不是最后一个
                System.out.print(arr[i] + "]");
            } else {
                System.out.print(arr[i] + ",");
            }
        }
    }

    // 模拟Arrays.toString()方法,将数组元素以字符串形式返回
    public static String toStrPro(int[] arr) {
        String s = "[";
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {// 是不是最后一个
                s += arr[i] + "]";
            } else {
                s += arr[i] + ",";
            }
        }
        return s;// "[1,2,3]"
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

题目23

写一个方法 用于合并两个int类型的数组  合并法则如下
   {1,2,5,8,9}{1,3,0}---->{1,2,5,8,9,1,3,0} (合并)
1
2

 public static void main(String[] args) {
        int[] arr1 = {1,2,5,8,9};
        int[] arr2 = {1,3,0,6,10};
        int[] arr3 = concatArray(arr1,arr2);
        System.out.println(Arrays.toString(arr3) );
    }

    /**
     * 扩展知识:
     * 整型默认值: 0
     * 浮点型默认值: 0.0
     * char默认值: ' '
     * boolean默认值: false
     * ---
     * 引用类型: 数组,类,接口
     * 引用类型的默认初始值都是null
     */
    //  {1,2,5,8,9}{1,3,0}---->{1,2,5,8,9,1,3,0} (合并)
    public static int[] concatArray(int[] arr1, int[] arr2) {
        // 创建新数组,存储所有元素
        int[] arr3 = new int[arr1.length + arr2.length];

        // 方式1
        // for (int i = 0; i < arr1.length; i++) {
        //     arr3[i] = arr1[i];
        // }
        // for (int i = 0; i < arr2.length; i++) {
        //     arr3[arr1.length+i] = arr2[i];
        // }

        // 方式2
        // for (int i = 0; i < arr3.length; i++) {
        //     if (i < arr1.length) {
        //         arr3[i] = arr1[i];
        //     } else {
        //         arr3[i] = arr2[i - arr1.length];
        //     }
        // }

        // 方式3
        System.arraycopy(arr1,0,arr3,0,arr1.length);
        System.arraycopy(arr2,0,arr3,arr1.length,arr2.length);

        return arr3;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

题目24

写一个方法 用于合并两个int类型的数组  合并法则如下
   {1,2,5,3,8,9}{1,3,0}---->{0,1,1,2,3,3,5,8,9} (合并并排序不需要去重)
1
2

 public static void main(String[] args) {
        int[] arr1 = {1,2,5,8,9};
        int[] arr2 = {1,3,0,6,10};
        int[] arr3 = concatSortArray(arr1,arr2);
        System.out.println(Arrays.toString(arr3) );

    }

    // 合并并排序
    //    {1,2,5,3,8,9}{1,3,0}---->{0,1,1,2,3,3,5,8,9} (合并并排序不需要去重)
    public static int[] concatSortArray(int[] arr1, int[] arr2) {
        // 创建新数组,存储所有元素
        int[] arr3 = new int[arr1.length + arr2.length];
        System.arraycopy(arr1,0,arr3,0,arr1.length);
        System.arraycopy(arr2,0,arr3,arr1.length,arr2.length);
        Arrays.sort(arr3);
        return arr3;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

题目25

写一个方法 用于合并去重两个int类型的数组  合并法则如下
   {1,2,5,3,8,9}{1,3,0}---->{0,1,2,3,5,8,9} (合并并排序需要去重)
1
2

    public static void main(String[] args) {
        int[] arr1 = {1,2,5};
        int[] arr2 = {1,6,2,3,10};
        int[] arr3 = concatSortDistinctArray(arr1,arr2);
        System.out.println(Arrays.toString(arr3) );

    }

    // 写一个方法 用于合并去重两个int类型的数组  合并法则如下
    //    {1,2,5,3,8,9}{1,3,0}---->{0,1,2,3,5,8,9} (合并并排序需要去重)
    public static int[] concatSortDistinctArray(int[] arr1, int[] arr2) {
        // 创建新数组,合并所有元素
        int[] arr3 = new int[arr1.length + arr2.length];
        System.arraycopy(arr1,0,arr3,0,arr1.length);
        System.arraycopy(arr2,0,arr3,arr1.length,arr2.length);
        // 排序
        Arrays.sort(arr3);
        // 去重
        // [0,1,1,2,3,5,8,9] --> [0,1,2,3,5,8,9]
        /**
         * 要新建数组存储去重后的元素
         * 利用极值思想,那就创建一个根原数组一样大的数组存储
         */
        int[] arr4 = new int[arr3.length];
        int index = 0;
        for (int i = 0; i < arr3.length; i++) {
            int e = arr3[i];
            boolean flag = false;// 判断是否有重复元素的标志,false是没有重复元素
            for (int j = 0; j < arr4.length; j++) {
                if (e == arr4[j]) {
                    flag = true;// 有重复,标志改动
                    break;
                }
            }
            if (!flag) {
                 arr4[index] = e;
                 index++;
            }
        }
        // 只存储不重复的元素
        int[] arr5 = new int[index];
        System.arraycopy(arr4,0,arr5,0,index);
        return arr5;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44