蓝桥杯 大学B组 java基础篇 下

发表于 阅读次数：
本文字数： 6.9k 阅读时长 ≈ 6 分钟

像什么

算法很美 java基础篇

数组

数组的声明

1
元素类型[] 数组引用变量;

数组的创建

1
元素类型[] 数组引用变量 = new 元素类型[数组大小]

默认值

数组的默认值为创建数组类型的默认值
数值型 0/0.0
布尔类型 false
引用型 null

内存模型

数组内存模型

数组变量实际存储的是指向数组的引用
数组变量是存放在栈中的 而数组是存储在堆中的 变量引用指向堆内存中的数组

数组的简单案例

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
/**
     * 随机生成一个指定长度指定范围的数组
     * @param length 数组长度
     * @param min 数组最小值
     * @param max 数组最大值
     * @return 数组
     */
    public static Integer[] initArr(int length, int min, int max){

        Integer[] arr = new Integer[length];

        for(int i = 0; i < arr.length; i++){
            arr[i] = (int)(min + Math.random() * (max - min + 1));
        }

        return arr;
    }

    /**
     * 打印数组
     * @param arr
     */
    public static void printArr(Integer[] arr){
        for(int i = 0; i < arr.length; i++){
            System.out.print(arr[i] + "\t");
        }
        System.out.println();
    }

    /**
     * 找出数组中最大值
     * @param arr 数组
     * @return 最大值
     */
    public static Integer arrMax(Integer[] arr){

        Integer max = arr[0];

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

        return max;
    }

    /**
     * 找出数组中最小值
     * @param arr 数组
     * @return 最小值
     */
    public static Integer arrMin(Integer[] arr){

        Integer min = arr[0];

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

        return min;
    }

    /**
     * 求数组元素的总和
     * @param arr 数组
     * @return 和
     */
    public static Integer arrSum(Integer[] arr){

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

        return sum;
    }

    /**
     * 数组的平均值
     * @param arr
     * @return
     */
    public static Double arrAvg(Integer[] arr){

        Integer arrSum = arrSum(arr);

        Double avg = Double.valueOf((arrSum / arr.length));

        return avg;
    }

    /**
     * 数组随机交换位置
     * @param arr
     */
    public static void randomArr(Integer[] arr){

        for(int i = 0; i < arr.length; i++){
            int j = (int)(Math.random() * 10);
            int temp;
            temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }

        printArr(arr);
    }

    /**
     * 数组前移
     * @param arr
     */
    public static void frontArr(Integer[] arr){

        int temp = arr[0];
        for (int i = 1; i < arr.length; i++) {
            arr[i - 1] = arr[i];
        }

        arr[arr.length - 1] = temp;

        printArr(arr);
    }

    /**
     * 主方法
     * @param args
     */
    public static void main(String[] args) {

        Integer[] initArr = initArr(10, 10, 20);

        printArr(initArr);

        System.out.println("最大值 " +  arrMax(initArr));
        System.out.println("最小值 " + arrMin(initArr));
        System.out.println("总和 " + arrSum(initArr));
        System.out.println("平均值 " + arrAvg(initArr));
        System.out.println("前移后数组为");
        frontArr(initArr);
        System.out.println("交换位置后的数组为");
        randomArr(initArr);
    }

foreach(jdk1.5开始引用出来的)

1
2
3
for(double e:myList){
  System.out.println(e);
}

理解：对myList中每个元素e进行以下操作

基本数据类型和引用数据类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public static void main(String[] args) {

        //基本数据类型
        System.out.println("基本数据类型演示");
        int i = 10;
        int j = i;
        i = 20;
        System.out.println("j = " + j);

        System.out.println("引用数据类型演示");
        double[] arr1 = {1,2,3,4,5};

        double[] arr2 = new double[5];

        arr2 = arr1;
        arr1[0] = 0;

        for(double e : arr2){
            System.out.println(e);
        }

    }

基本数据类型和引用数据类型

System.arraycopy

复制数组

1
2
3
public static native void arraycopy(Object src,  int  srcPos,
                                    Object dest, int destPos,
                                    int length);

src原数组

srcPos原数组下标

dest目的地数组

destPos目的地下标

lengthcopy长度

arraycopy方法不会给目标分配内存空间 复制前必须创建目标数组以及分配内存空间

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

double[] arr2 = new double[5];

System.arraycopy(arr1,1,arr2,0,3);

        for(double e : arr2){
            System.out.println(e);
        }

值传递

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static void main(String[] args) {

        int x = 1;
        int[] y = new int[5];

        m(x,y);

        System.out.println("x = " + x);// 1

        System.out.println("y[0] = " + y[0]);// 1314

    }

    public static void m(int number, int[] arr){
        number = 521;
        arr[0] = 1314;
    }

这个就是栈和堆的问题 基本数据类型和引用数据类型的区别 因为基本数据类型是存放在栈内存中的 传递回去的时候不受影响 而引用数据类型是指向堆内存的 而上面这个例子操作的是同一块堆内存 所以引用数据类型改变 基本数据类型不变

检测数组中每个字母出现的数量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public static void main(String[] args) {

        //随机生成一个长度为100的小写字母字符串
        String s = RandomUtil.randomLowercaseString(100);

        //将字符串拆分成字符数组
        char[] c = s.toCharArray();

        //将每个字母存放到数组中
        int[] letter = new int[26];

        //遍历字符数组
        for(int cc : c){
            //与字符a进行处理一下 并记录每次出现的字母+1 
            letter[cc - 'a']++;
        }

        //遍历输出
        for(int i = 0; i < 26; i++){
            System.out.println((char)(i + 'a') + "=" + letter[i]);
        }
    }

排序

冒泡排序

冒泡排序例图

可以看成向右看齐 一次次的筛选高个子 首先将高个子放在前面 然后在从剩下的里面继续找高个子

1
2
3
4
5
6
7
8
9
10
11
public static void bubble(Integer[] arr){
        for (int i = 0; i < arr.length; i++) {
            for(int j = 0; j < arr.length - i - 1; j++){
                if(arr[j] > arr[j + 1]){
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

选择排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/**
     * 插入排序
     * @param arr 数组
     */
    public static void selectSort(Integer[] arr){

        for(int i = 0; i < arr.length; i++){
            //定义最小值
            int min = i;
            //定义中间值
            int temp;
            //遍历最小值的其他值
            for(int j = i + 1; j < arr.length; j++){

                //判断最小值和其他值的关系、并进行排序交换
                if(arr[min] > arr[j]){
                    temp = arr[min];
                    arr[min] = arr[j];
                    arr[j] = temp;
                }
            }
        }

    }

插入排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
for(int i = 1; i < arr.length; i++){

            //判断后一个是否比前一个数据小
            if(arr[i] < arr[i - 1]){

                //定义一个中间变量来存放小的那个数据
                int temp = arr[i];
                //定义一个变量j
                int j;

                //遍历当前数字的所有前面的数字
                for(j = i - 1; j >= 0&&temp<arr[j]; j--){
                    //将前一个赋值给后一个
                    arr[j + 1] = arr[j];
                }
                //将中间变量temp赋值给不满足条件的那个值
                arr[j + 1] = temp;
            }
        }

查找

普通查找

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
     * 普通查找方法
     * @param arr 数组
     * @param target 寻找的目标
     * @return 下标
     */
    public static int commonFind(int[] arr,int target){

        int result = -1;

        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == target){
                result = arr[i];
                break;
            }
        }

        return result;
    }

二分法查找

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
/**
     * 二分法查找 前提 数组必须是有序排序的
     * @param arr 数组
     * @param target 查找的目标
     * @return 下标
     */
    public static int binarySearch(int[] arr, int target){

        //初始化起始下标
        int begin = 0;
        //初始化末尾下标
        int end = arr.length - 1;

        //循环遍历 只要起始下标不大于末尾下标
        while (begin <= end){

            //找到中间下标
            int indexMiddle = (begin + (end - begin) >> 1);

            //开始进行二分查找 大于中间值 向后寻找 小于 向前寻找 找到相应值返回 没找到返回-1
            if(target > indexMiddle){
                begin = indexMiddle + 1;
            }else if(target < indexMiddle){
                end = indexMiddle - 1;
            }else{
                return indexMiddle;
            }
        }
        return -1;
    }

Arrays类

java.util.Arrays包下

数组相关的工具类

sort() 排序 （快速排序）

parallelSort() 部分数组进行排序

binarySearch() 二分法查找

equals() 检测两个数组是否相等

fill() 填充整个数组或部分数组

toString 返回一个字符串

二维数组

数组的声明

1
数据类型[][] arr;

数组的初始化

1
数据类型[][] arr = new 数据类型[数组行大小][数组列大小];

数组列大小可以不写 但是数组行大小必须写

在坐标轴上找到两点间距离最小的两个点的坐标

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
public static void main(String[] args) {

        //定义数组
        double[][] arr = {
            {1,1},
            {2,2},
            {13,12},
            {1,2},
            {2,3},
            {3,3},
            {11,11},
            {13,13},
            {15,12},
            {0.5,1}
        };
        //设置个最小的距离 等于 一个Double的最大值 假设两个点的距离不可能比这个大
        double min = Double.MAX_VALUE;
        //第一个点的下标
        int mini = 0;
        //第二个点的下标
        int minj = 0;
        //依次把每个点作为起点
        for(int i = 0; i < arr.length; i++){
            //与每个点进行距离计算
            for(int j = i + 1; j < arr.length; j++){
                double x1 = arr[i][0];
                double x2 = arr[j][0];
                double y1 = arr[i][1];
                double y2 = arr[j][1];
                double dis = Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
                
                //找到最小的距离
                if(dis < min){
                    min = dis;
                    mini = i;
                    minj = j;
                }
            }
        }
        //输出
        System.out.println("最小距离" + min + " mini：" + mini + " minj：" + minj);
    }

你懂得越多 你不懂的越多 嘿 我是小博 带你一起看我目之所及的世界……

-------------本文结束 感谢您的阅读-------------

本文标题:蓝桥杯 大学B组 java基础篇 下

文章作者:小博

发布时间:2021年12月28日 - 02:19

最后更新:2021年12月28日 - 02:27

原始链接:https://codexiaobo.github.io/posts/2931258348/

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际 转载请保留原文链接及作者。