day09_数组进阶

今日内容

零、 复习昨日
一、作业
二、引用类型[重要]
三、数组拷贝
四、数组扩容
五、数组排序[面试|笔试]
六、Arrays

零、 复习昨日

数组创建后能否改变长度

• 不能

数组创建后能否存储不同类型的数据

• 不能

数组动态创建的语法,以int数组为例

• int[] arr = new int[长度];

数组静态创建的语法,以int数组为例

• int[] arr = new int[]{1,2,3};
• int[] arr = {1,2,3};

数组取值

• 数据类型 变量名= 数组名[下标];

数组赋值

• 数组名[下标] = 值;

遍历是什么意思

• 获取数组每一个元素

数组的长度属性

• length, 使用时 arr.length

画数组的内存图

一、作业

数组取最值

   // 数组取最大值
    public static void printMax() {
        int[] arr = {3,7,2,5,4,6,1};
        int max = arr[0]; // 假设第一个最大
        for (int i = 0; i < arr.length; i++) {
            // 判断下一个是否比当前最大值还大
            if (arr[i] > max) {
                // 如果大,就重新赋值给最大值
                max = arr[i];
            }
        }
        System.out.println("max = " + max );
    }

数组求和+平均数

 // 求一个整数数组的平均值
    public static void printAvg() {
        int[] arr = {3, 2, 5, 4,  1,6};
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        // System.out.println(sum );
        double avg = 1.0 * sum / arr.length;
        System.out.println("avg = " + avg );
    }

评委打分,去掉最高分和最低分

// 邱哥去参加今年歌唱比奖,
    // 有8个评委打分,(去掉1个最低分,1个最高分)求平均分?
    public static void printAvgPro() {
        int[] scoreArr = {7,2,3,9,8,9,8,10};
        int max = scoreArr[0];
        int min = scoreArr[0];
        int sum = 0;
        for (int i = 0; i < scoreArr.length; i++) {
            if (scoreArr[i] > max) {
                max = scoreArr[i];
            }
            if (scoreArr[i] < min) {
                min = scoreArr[i];
            }
            sum += scoreArr[i];
        }
        // 去掉最高分,最低分
        double avg = (sum - max - min) * 1.0 / (scoreArr.length - 2);
        System.out.println(avg );

    }

根据元素找下标

    // 自定义一个整数数组arr，读入一个整数n，
    // 如果n 在数组中存在，则输出n 的下标；如果不存在，则输出-1。
    // 根据元素找下标(如果有重复元素,找的是第一个出现的元素的下标)
    public static void printIndexByElement(int e) {
        // int[] arr = {1,2,3,4,2,1};
        // boolean flag = false;// 是否有该元素
        // for (int i = 0; i < arr.length; i++) {
        //     if (arr[i] == e) {
        //         flag = true;
        //         System.out.println(i );
        //         break;
        //     }
        // }
        // if (!flag) {
        //     System.out.println(-1 );
        // }

        int[] arr = {1,2,3,4,2,1};
        int index = -1;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == e) {
                index = i;
                break;
            }
        }
        System.out.println(index );
    }

根据下标找元素

    // 根据下标找元素
    public static void printElementByIndex(int index){
        int[] arr = {1,2,3,4,2,1};
        if (index < 0 || index >= arr.length) {
            System.out.println("给的下标有误!!" );
            return;
        }
        int e = arr[index];
        System.out.println(e );
    }

二、引用类型[理解]

Java的数据类型

• 基本数据类型: 四类八种
• 引用数据类型
  • 数组
  • 类
  • 接口

为什么叫做引用数据类型?

int[] arr = int[3];
// 使用数组
arr[0] = 1;
// arr到底是谁? arr其实是地址
// 我们通过arr来操作数组,其实arr引用的是内存中的数组

什么又叫做引用?

// 引用就是一个联系,或者说引用就是对象,引用就是地址
// 只不过在执行时,他会通过引用联系找到内存的对象

引用的是谁?

// 引用的是堆内存的对象,即数组对象

package com.qf.ref;

/**
 * --- 天道酬勤 ---
 *
 * @author QiuShiju
 * @desc
 */
public class Demo1 {
    public static void main(String[] args) {
        // int x = 10;
        // System.out.println("1. " + x );
        // changeBaseValue(x);
        // System.out.println("4. " + x ); // 10

        int[] arr = {1,2,3,4};
        System.out.print("第一次: ");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }

        changeRefValue(arr);


        System.out.print("\r\n第四次: ");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }

    // 改变基本类型的值
    public static void changeBaseValue(int a){
        System.out.println("2. " + a );
        a *= 10;
        System.out.println("3. " + a );
    }

    // 改变引用类型的值
    public static void changeRefValue(int[] arr){
        System.out.print("\r\n第二次: ");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }

        // 改变数组(每个位置放大10倍)
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arr[i] * 10;
        }

        System.out.print("\r\n第三次: ");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LdxMU1F2-1681085172918)(https://qiushiju-tuchuang.oss-cn-hangzhou.aliyuncs.com/image/%E5%9F%BA%E6%9C%AC%E7%B1%BB%E5%9E%8B%E4%BC%A0%E9%80%92.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-694f9pPD-1681085172919)(https://qiushiju-tuchuang.oss-cn-hangzhou.aliyuncs.com/image/%E5%BC%95%E7%94%A8%E7%B1%BB%E5%9E%8B%E4%BC%A0%E9%80%92.png)]

总结:

• 基本类型传参数时是值传递
• 引用类型传参数时是引用传递,将地址传递,多个引用指向同一个对象
• 方法内的基本类型会进内存的栈中,随着方法出现,随着方法消失
• 凡是new的,都会在内存的堆中创建对象
• 引用类型,引用的是内存中的对象

三、数组拷贝[理解]

数组拷贝: 将数组中的元素复制一份放到另一个数组中.

• 创建空数组,长度与原数组一样长
• 遍历原数组
• 从原数组中取值赋值给新数组

3.1 手动拷贝

// 数组拷贝
    public static void copy1(){
        int[] arr = {11,22,33};

        // 数组拷贝,拷贝完需要再有一个数组
        int[] arr2 = new int[arr.length];

        printArray(arr2);
        for (int i = 0; i < arr.length; i++) {
            arr2[i] = arr[i];
        }
        printArray(arr2);

    }

    // 定义一个方法,方便数组遍历
    public static void printArray(int[] arr) {
        // [1,2,3]
        String s = "[";
        for (int i = 0; i < arr.length; i++) {
            s = s + arr[i];
            if (i == arr.length-1) {
                s += "]";
            } else {
                s += ",";
            }
        }
        System.out.println(s );
    }

3.2 JDK自带方法完成数组拷贝

Arrays.copyOf(参数1,参数2);

• Arrays 类是JDK提供的,直接用
• copry 是类的方法
• 参数1 被拷贝的数组
• 参数2 新数组的长度

    // 数组拷贝
    public static void copy2() {
        int[] arr = {11, 22, 33};
        int[] arr2 = Arrays.copyOf(arr,6);
        printArray(arr2);// [11,22,33,0,0,0]
    }

System.arraycopy(src,pos,dest,destPos,length)

   // 数组拷贝方式3
    public static void copy3() {
        int[] arr = {11, 22, 33,44,55};
        int[] arr2 = new int[8];
        printArray(arr2);
        /**
         * src      the source array.
         *          原始数组
         * srcPos   starting position in the source array.
         *          从原数组哪里开始拷贝
         * dest     the destination array.
         *          目的地数组
         * destPos  starting position in the destination data.
         * length   the number of array elements to be copied.
         */
        System.arraycopy(arr,1,arr2,1,3);
        printArray(arr2);
    }

四、数组扩容[理解]

数组扩容: 数组本身是不能改变长度! 此处说的扩容,是指重新新建一个数组,将原数组的数据拷贝到新数组,然后数组命名重新命名为之前的名字

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

        arr = changeLength(arr);
        printArray(arr);
    }

    public static int[] changeLength(int[] arr) {

        // 扩容: 新建+拷贝+改名
        int[] arr2 = new int[arr.length * 2];
        System.arraycopy(arr,0,arr2,0,arr.length);
        return arr2;
    }

    // 定义一个方法,方便数组遍历
    public static void printArray(int[] arr) {
        // [1,2,3]
        String s = "[";
        for (int i = 0; i < arr.length; i++) {
            s = s + arr[i];
            if (i == arr.length-1) {
                s += "]";
            } else {
                s += ",";
            }
        }
        System.out.println(s );
    }

五、数组排序[面试|笔试]

数组的排序算法: 十大排序算法

插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序、计数排序和桶排序

冒选插,快堆希归,桶计基

5.1 冒泡排序

/**
     * 冒泡排序算法,思路
     *  相邻两个比较,通过交互位置,大的放后面
     */
    public static void sort1(int[] arr){
        // 外层循环 比较的趟数
        // -1 最后一趟不用比较
        for (int i = 0; i < arr.length - 1; i++) {
            // 内存循环 每趟内比较的次数
            // -1 防止下标越界.-i 每趟比较的次数要递减
            for (int j = 0; j < arr.length-1 - i; j++) {
                // 如果当前元素比后面的元素大
                if (arr[j] > arr[j+1]){
                    // 就交换位置
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        
    }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3iUT0DRn-1681085172920)(https://qiushiju-tuchuang.oss-cn-hangzhou.aliyuncs.com/image/%E5%86%92%E6%B3%A1%E6%8E%92%E5%BA%8F.gif)]

5.2 选择排序

选择排序:

• 先假定第一个位置最小
• 后续每个属性与最小处进行比较
• 如果更小.就重新记录最小处的下标
• …直到全部比较完
• 然后最小处元素与第一个元素换位

---

• 第一遍完毕,从第二个开始再重复一遍
• 第二遍完毕,从第三个开始再重复一遍

  // 升序排序 : 4,3,1,5,2
    public static void sort2(int[] arr){
        // 每一个元素都进行一趟比较
        for (int i = 0; i < arr.length; i++) {
            // 每次假定第i个位置的数最小
            int minIndex = i;
            // 取后续的每个数
            for (int j = i; j < arr.length; j++) {
                // 如果发现后续有哪个数比最小的数还小
                if (arr[j] < arr[minIndex]) {
                    // 记录最小数的下标
                    minIndex = j;
                }
            }
            // 找到最小值后,与第i个位置交换
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex]  = temp;
        }
    }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xBGTCzr5-1681085172920)(https://qiushiju-tuchuang.oss-cn-hangzhou.aliyuncs.com/image/%E9%80%89%E6%8B%A9%E6%8E%92%E5%BA%8F.gif)]

六、Arrays[熟练用]

Arrays是JDK提供的一个操作数据的工具类,其中有很多操作数据的方法.

• copyOf() 拷贝数组
• sort() 排序
• toString() 数组转成String返回
• ps 使用要导包java.util.Arrays

    public static void main(String[] args) {

        int[] arr = {4,2,1,3,5};
        // for (int i = 0; i < arr.length; i++) {
        //     System.out.println(arr[i] );
        // }
        System.out.println(Arrays.toString(arr) );

        // 排序(从小到大)
        Arrays.sort(arr);

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

        String s = Arrays.toString(arr);
        System.out.println(s );

        System.out.println( Arrays.toString(arr));
    }

附录

index 索引。下标
sum
count
avg
min
max
element 元素
reference 引用
change 改变
value  值
source 源,资源,简写src
position 位置,简写pos
destination 目的目标,简写dest
data  数据
sort 排序