day09_数组进阶

今日内容

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

零、 复习昨日

1数组创建后能否改变长度

• 不能

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

• 不能 √
• 能,能默认转型的可以存储
  double[] arr2 = new double[3];
  arr2[0] = 1.1; //double数组中存储double
  arr2[1] = 1;//double数组中存储int,因为可以默认转型

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

• 动态是给长度不给值
• new int[3];

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

• 静态是指定元素,不指定长度
• new int[]{1,2,3,4}
• 简写 {1,2,3,4}

5数组取值

• 数据类型 变量名 = 数组名[下标]
• int a = arr[0];

6数组存值

• 数组名[下标] = 值;
• arr[0] = 100;

7遍历是什么意思,尝试手写代码

• 挨个找到数组元素
  // i是下标
  for(int i = 0;i < arr.length;i++){
  int a = arr[i];
  }

8数组的长度属性

• length

9画数组的内存图

10 下标就是索引,是数组中存储元素的编号,从0开始

一、作业

package com.qf.homework;

/**
 * @desc
 * 1 读完需求,能写多少写多少
 * 2 倒推,以结果为导向,再往上细分步骤
 * 3
 * 4 出错误,读代码
 */
public class Homework2 {

    // 邱哥去参加今年歌唱比奖,有8个评委打分,(去掉1个最低分,1个最高分)求平均分
    public static void main(String[] args) {
        avg();
    }

    public static void avg() {
        double[] arr = {2,3,2,2,2,2,0,2};
        // 遍历数组挨个比较找到最高最低
        // 得到最高和最低
        // 先全部求和
        double max = arr[0];
        double min = arr[0];
        double sum = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
            if (arr[i] < min) {
                min = arr[i];
            }
            sum += arr[i];
        }
        // 再去掉最高最低
        sum = sum - max - min;
        // 平均分
        double avg = sum / (arr.length - 2);
        System.out.println("最终得分: " + avg );
    }
}
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

二、引用类型[理解]

ps: 讲解引用类型重要的不是代码,而是思想

java的数据类型

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

---

要想了解引用类型,先知道一些jvm知识

• jvm是java虚拟机,其中有内存可以运行代码
• java内存中堆区域,栈区域
• java中方法执行进栈,凡是new都会在堆中开辟空间,分地址,初始化
• 方法执行完弹栈(出栈消失)

2.1 基本类型

// 设计方法,方法有参数(基本类型) , 方法内对该数据进行修改,最终查看数据的值

基本类型

• 基本类型变量是随着方法进栈,在栈中出现
• 方法执行完弹栈,消失
• 基本类型在方法传参数时,是值传递

package com.qf.array;

/**
 * |-----------------------------------------------
 * |  ____   _          _____  _      _  _        |
 * | / __ \ (_)        / ____|| |    (_)(_)       |
 * || |  | | _  _   _ | (___  | |__   _  _  _   _ |
 * || |  | || || | | | \___ \ | '_ \ | || || | | ||
 * || |__| || || |_| | ____) || | | || || || |_| ||
 * | \___\_\|_| \__,_||_____/ |_| |_||_|| | \__,_||
 * |                                   _/ |       |
 * |                                  |__/        |
 * |-----------------------------------------------
 * |                 天道酬勤                     |
 * |             代码敲烂 月薪过万                |
 * L----------------------------------------------
 *
 * @desc 引用类型和基本类型的区别
 */
public class Demo1 {

    public static void main(String[] args) {
        int a = 1;
        System.out.println("1 a = " + a );
        changeValue(a);
        System.out.println("4 a = " + a );
    }

    // 设计方法,方法有参数(基本类型) ,
    // 方法内对该数据进行修改,最终查看数据的值
    public static void changeValue(int n) {
        System.out.println("2 n = " + n );
        n *= 10;
        System.out.println("3 n = " + n );
    }
}
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

2.2 引用类型

引用类型

• 引用类型有个特点,就是它们都是new出来
• 凡是new出来的都会在堆中出现
• 数组在堆中创建完后,赋值出去的地址值,包括以后传参数**,传递也是地址**
• 即 new一次,内存中数组只有一个
• 这个地址值就是引用,或者说数组名就是引用,因为通过数组名找到内存中的数组
• String排除

package com.qf.array;

/**
 * @desc 引用类型和基本类型的区别
 */
public class Demo1 {

    public static void main(String[] args) {
        int[] arr = {1,2,3,4};
        System.out.println("----- 第一次 -----" );
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i] );
        }
        changeArray(arr);
        System.out.println("----- 第四次 -----" );
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i] );
        }
    }

    // 设计方法,方法有参数(引用类型-数组) ,
    // 方法内对该数组进行修改,最终查看数据的值
    public static void changeArray(int[] arr){
        System.out.println("----- 第二次 -----" );
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i] );
        }
        // 改变数组
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arr[i] * 10;
        }
        System.out.println("----- 第三次 -----" );
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i] );
        }
    }
}

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

2.3 总结

关于基本和引用

• 凡是基本类型的数据,即变量都是在栈中的方法内,与方法同在
  • 常见情况就是方法传参时,基本类型是将值本身传递出去
• 引用类型是new出来的,存在于堆中,平时操作这些数组对象都是通过地址值操作的
  • 常见情况就是方法传参数时,引用类型传递的是地址值
  • 即虽然是不同的方法但是操作的是同一个数组对象
  • 因为大家都是引用的堆中的数组对象

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

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

冒泡,选择,插入

快速,堆排序,希尔,归并排序

桶排序,计数排序,基数排序

3.1 冒泡排序

冒泡排序思路: 相邻两个比较,交互位置

package com.qf.array;

/**
 * |-----------------------------------------------
 * |  ____   _          _____  _      _  _        |
 * | / __ \ (_)        / ____|| |    (_)(_)       |
 * || |  | | _  _   _ | (___  | |__   _  _  _   _ |
 * || |  | || || | | | \___ \ | '_ \ | || || | | ||
 * || |__| || || |_| | ____) || | | || || || |_| ||
 * | \___\_\|_| \__,_||_____/ |_| |_||_|| | \__,_||
 * |                                   _/ |       |
 * |                                  |__/        |
 * |-----------------------------------------------
 * |                 天道酬勤                     |
 * |             代码敲烂 月薪过万                |
 * L----------------------------------------------
 *
 * @desc
 */
public class Demo2 {

    public static void main(String[] args) {
        int[] arr = {5,4,3,2,1};
        System.out.println("-- 排序前 --" );
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println( );
        // 开始排序
        // 外层循环控制比较的趟数
        // -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;
                }
            }
        }

        System.out.println("-- 排序后 --" );
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] +" " );
        }
    }
}
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
47
48
49
50

3.2 选择排序

选择排序:

• 第一趟: 选择最小的与第一个交换位置
• 第一趟: 剩下的元素选择最小的与第2个交换位置

package com.qf.array;

import javax.print.attribute.standard.OrientationRequested;

/**
 * |-----------------------------------------------
 * |  ____   _          _____  _      _  _        |
 * | / __ \ (_)        / ____|| |    (_)(_)       |
 * || |  | | _  _   _ | (___  | |__   _  _  _   _ |
 * || |  | || || | | | \___ \ | '_ \ | || || | | ||
 * || |__| || || |_| | ____) || | | || || || |_| ||
 * | \___\_\|_| \__,_||_____/ |_| |_||_|| | \__,_||
 * |                                   _/ |       |
 * |                                  |__/        |
 * |-----------------------------------------------
 * |                 天道酬勤                     |
 * |             代码敲烂 月薪过万                |
 * L----------------------------------------------
 *
 * @desc 选择排序
 */
public class Demo3 {

    public static void main(String[] args) {
        int[] arr = {5,4,3,6,2,1};
        System.out.println("-- 排序前 --" );
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println( );
        // 开始排序
        for (int i = 0; i < arr.length; i++) {
            // 假定第一个最小
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            // 交换位置
            int temp = arr[minIndex];
            arr[minIndex] = arr[i];
            arr[i] = temp;
        }
        System.out.println("-- 排序后 --" );
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println( );

    }
}
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
47
48
49
50
51
52

选择排序过程

• 遍历一趟,找到最小的数据,然后该位置数据与第一位交换位置
  • 这一趟比较完,确定最小数据在第一位
• 下一趟,从第二个开始,继续找最小的,找到后与第二个交互位置
  • 这一趟走完,确定第二个较小的数据
• …

附录

change 改变
value 值
temp 临时
index 索引。下标
sum
count
avg
min
max
element 元素
reference 引用
change 改变
value  值
source 源,资源,简写src
position 位置,简写pos
destination 目的目标,简写dest
data  数据
sort 排序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

mg-5gA4UWNf-1695886209906)]

选择排序过程

• 遍历一趟,找到最小的数据,然后该位置数据与第一位交换位置
  • 这一趟比较完,确定最小数据在第一位
• 下一趟,从第二个开始,继续找最小的,找到后与第二个交互位置
  • 这一趟走完,确定第二个较小的数据
• …

附录

change 改变
value 值
temp 临时
index 索引。下标
sum
count
avg
min
max
element 元素
reference 引用
change 改变
value  值
source 源,资源,简写src
position 位置,简写pos
destination 目的目标,简写dest
data  数据
sort 排序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18