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

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

1号线

算法很美 java基础篇

基本数据类型

数值型

整数类型

byte 一个字节 -128 ~ 127
short 二个字节 -2^15 ~ 2^15 - 1
int 四个字节 -2^31 ~ 2^31 - 1 32位处理器
long 八个字节 -2^63 ~ 2^63 - 1

浮点数据类型

float 四个字节 -3.403E38 ~ 3.403E38
double 八个字节 -1.798E308 ~ 1.798E308

字符类型

char Unicode编码 0 ~ 65535 0x0000 ~ 0xffff

布尔类型

boolean 值 true false

常量(字面量)

整型

十进制数

正常人们所用的数字 5 21 13 14

八进制数

用0开头表示 05 021 013 014

十六进制数

用0x或0X开头表示 0x5 0x21 0x13 0x14

二进制数(java7开始)

用0b开头表示 0b5 0b21 0b13 0b14

字面量加下划线(java7开始)

用下划线表示便于阅读 1_000_000 一百万

浮点数

十进制

float 521.1314f 或 5211314.0F
double 521.1314 5211314.0

科学计数法

52113.14e2 52113.14E2 52113.14E-2

转义字符

转义字符 含义
' 单引号字符
" 双引号字符
\ 反斜杠字符
\t 垂直制表符
\b 退格
\r 回车
\n 换行
\f 换页

变量

标识符

数字字母下划线美元符 中文可以 但是不推荐基本可以省略 关键字不能使用

变量

算术运算符

+ 加
- 减
* 乘
/ 除
% 求模/取余
++ 自增
-- 自减
整数被除0会产生一个异常 浮点数被除0会产生一个无穷大或NaN

逻辑运算符

&& 逻辑与 都真为真

|| 逻辑或 有真为真

! 逻辑非 真为假 假为真

三元运算符

Love ? lucky : regretful

love 为 true lucky

love 为 false regretful

如果 爱 为真 是 幸运的 否则 遗憾的

位运算

位运算符

& 与运算符 都为1 结果为 1

| 或运算符 有一个为1 结果为 1

^ 异或运算符 二者不同时结果为 1 任何数同自己异或为0 同0异或为自己 连续和同一个因子做异或运算
最终结果为自己

~ 非/取反运算符 1 结果为 0 0结果为 1

a b ~a a&b a或b a^b
1 1 0 1 1 0
0 1 1 0 1 1
0 0 1 0 0 0

>> 右移运算符 用符号位填充高位

<< 左移运算符

>>> 用0填充高位

例

int类型 1 << 35 和 1 << 3 相同 因为int类型时32为 所以对32求模相同

long类型对64求模

简单的求奇偶数

1
2
3
4
5
6
7
8
public static void main(String[] args) {
        int num;

        num = new Random().nextInt(100);

        System.out.println(num + "是" + ((num & 1) == 1 ? "奇数" : "偶数"));

    }

思路： 奇数的二进制最后一位一定是1 偶数的二进制最后一位一定是0 所以与1进行与运算即可

获取二进制某一位是0还是1

1
2
3
4
5
6
public static void main(String[] args) {
       int num = 86;

       System.out.println(num + "的二进制第五位是" 
               + (((num >> 4) &1) == 1 ? "1": "0"));
   }

交换两个变量的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public static void main(String[] args) {
        int a;
        int b;
        a = new Random().nextInt(100);
        b = new Random().nextInt(100);

        System.out.println("a = " + a + "\t" + "b = " + b);

        System.out.println("交换后");

        a = a ^ b;
        b = a ^ b;
        a = a ^ b;

        System.out.println("a = " + a + "\t" + "b = " + b);
    }

不用判断语句 求整数绝对值

1
2
3
4
5
public static void main(String[] args) {
        int num = -521;

        System.out.println("num的绝对值为" + ((num ^ (num >> 31)) + (num >>> 31)));
    }

赋值运算符

操作符 用法案例 等价表达式
+= a+=b a = a + b
-+ a-=b a = a - b
*= a*=b a = a * b
/= a/=b a = a / b
%= a%=b a = a % b

类型转化

自动类型转换

小类型转换成大类型

强制类型转换

大类型转换成小类型

类型转换

运算符优先级

案例

不调用系统的Date和Calendar API 输出当前系统时间

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
public static void main(String[] args) {
        //返回1970年1月1日零点至今的毫秒数

//        currentTimeMillis用的是零区 我们用的是8区时间
        long time = System.currentTimeMillis();

        long miao = time / 1000;

        long locationMiao = miao % 60;

        long fen = miao / 60;

        long locationFen = fen % 60;

        long shi = fen / 60;

        long locationShi = shi % 24;

        //小时加8
        System.out.println("当前系统时间为：" + (locationShi + 8) + "时" + locationFen + "分" + locationMiao + "秒");
//        Date date = new Date();
//        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//        String format = simpleDateFormat.format(date);
//        System.out.println(format);
    }

随机数

1
Math.random() 随机返回[0,1) 之间的一个double行浮点数 Math在lang包下 不用导包

字符进制转换问题

整数转换成16进制0至15以内

1
2
3
4
5
6
7
8
public static void main(String[] args) {
        int x;
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入0~15的整数");
        x = scanner.nextInt();

        System.out.println(x + "的十六进制为" + (x > 9 ? (char)('A' + (x - 10)) : (char)('0' + x)));
    }

字符串 String 引用数据类型

字符串 和 整数相加 就是拼接

String的常用方法

自行查阅API 常用的方法必须会

控制流程

顺序结构

分支结构

循环结构

案例

闰年问题

能被4整除且不能被100整除 或者能被400整除

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

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个年份");
        int x = scanner.nextInt();
        if(x < 1582){
            System.out.println("输入的是错误信息 在1582年之前公里还未被采用");
        }else if((x % 4 == 0 && x % 100 != 0 ) || (x % 400 == 0)){
            System.out.println(x + "是润年");
        }else{
            System.out.println(x + "不是闰年");
        }
    }

十六进制转换成十进制问题

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) {

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个0~9 A~F a~f 我们来给您转换成十进制数");

        String x = scanner.next();

        char result = x.charAt(0);

        if(x.length() >= 2){
            System.out.println("您输入的有误");
            return;
        }

        if(result >= 48 && result <= 57){
            System.out.println(result + "的十进制数为" + result);
        }else if(result >= 'A' && result <= 'F'){
            System.out.println(result + "的十进制数为" + (result - 'A' + 10));
        }else if(result >= 'a' && result <= 'f'){
            System.out.println(result + "的十进制数为" + (result - 'a' + 10));
        }
    }

十六进制转十进制(任意十六进制)

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

        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入一个十六进制数");

        String x = scanner.next();

        char[] arr = x.toCharArray();

        int result = 0;
        for(int i = 0; i < arr.length; i++){

            char x1 = arr[i];
            int x11 = x1 - '0';
            if(x1 >= 'A' && x1 <= 'F'){
                x11 = x1 - 'A' + 10;
            }
            if (x1 >= 'a' && x1 <= 'f') {
                x11 = x1 - 'a' + 10;
            }
            result += x11 * (int)(Math.pow(16,arr.length - i - 1));
        }

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

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个十进制数");
        int x = scanner.nextInt();
        int yushu = 0;
        char weizhi = 0;
        String result = "";
        String newResult = "";

     while (x != 0){
         yushu = x % 16;
         x = x / 16;

         if(yushu > 9){
             weizhi = (char)('A' + yushu - 10);
         }else{
             weizhi = (char)('0' + yushu);
         }

         result += weizhi;
     }

     for (int i = result.length() - 1; i >= 0; i--){
         newResult += result.charAt(i);
     }

        System.out.println("0x" + newResult);
    }

十进制转二进制

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

        Scanner scanner = new Scanner(System.in);
        int yushu = 0;
        int x;
        int y;
        int count = 0;
        while(true){

            System.out.println("请输入一个十进制数");

            //非法字符 或 越界程序终止
            try {
                x = scanner.nextInt();
                y = x;
            }catch (Exception e){
                System.out.println("输入有误 程序运行终止");
                return;
            }

            //存值变量
            String result = "";
            //逆序输出变量
            String newResult = "";
            //计数器
            count = 0;

            //输入负数相当于2的31次幂 + 本身
            if(x < 0){
                x = (int) (Math.pow(2,31) + x);
            }

            //0还是0
            if(x == 0){
                newResult += 0;
            }

            //开始进行转换计算
            while (x != 0){

                yushu = x % 2;
                x = x / 2;

                count++;

                if(count % 4 == 0){
                    result += yushu;
                    result += "_";
                }else{
                    result += yushu;
                }

            }
            //补齐位数
            while(count < 31){
                count++;
                if(count % 4 == 0){
                    result += 0;
                    result += "_";
                }else{
                    result += 0;
                }
            }

            //补全符号位
            if(y < 0){
                result += 1;
            }else if(y > 0){
                result += 0;
            }

            //逆序输出
            for (int i = result.length() - 1; i >= 0; i--){
                newResult += result.charAt(i);
            }

            //输出
            System.out.println(newResult);
        }

    }

随机数和循环的应用

随机生成字符串

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

        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入您要生成的字符串长度");

        int x = scanner.nextInt();

        int i = 0;

        String result = "";

        while (i < x){

            //随机生成 0 ~ 0xffff 的字符
            char c = (char) (Math.random() *(0xffff + 1));

            //生成数字字母随机数
            if((c > '0' && c < '9') || (c > 'a' && c < 'z') || (c > 'A' && c < 'Z')){
                //字符串拼接
                result += c;
                i++;
            }
        }

        System.out.println("生成的随机字符串为:" + result );
    }

PI的近似值

1
2
3
4
5
6
7
8
9
10
11
public static void main(String[] args) {

        double result = 0;

        for (int i = 1; i <= 100000; i++) {
            //数学家说的公式
            result += Math.pow(-1,i+1) / (double)(2 * i - 1);
        }
        //结果乘4
        System.out.println(4 * result);
    }

回文串

回文串就是正序和反序一致

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

        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入一个字符串");

        String result;
        result = scanner.next();
        int begin = 0;
        int end = result.length() - 1;

        while(begin < end && result.charAt(begin) == result.charAt(end)){
            begin++;
            end--;
        }

        System.out.println(result + ((begin >= end) ? "" : "不") + "是一个回文串");

    }

最大公约数问题

最大公约数：指两个或多个整数共有约数中最大的一个

两个整数 4 和 2 的最大公约数是 2

两个整数 16 和 24 的最大公约数是 8

普通算法

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

        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入两个正整数");

        int x = scanner.nextInt();

        int y = scanner.nextInt();

        //交换位置 找到较小值
        if(x > y){
            x = x ^ y;
            y = x ^ y;
            x = x ^ y;
        }else if(x == y){
            //两个数相等最大公约数是其本身
            System.out.println(x + "和" + y + "的最大公约数是" + x);
            return;
        }

        //当两个数成倍数时 最大公约数为较小的
        if(y % x == 0){
            System.out.println(x + "和" + y + "的最大公约数是" + x);
            return;
        }

        int gcd = 1;
        //找到最大公约数 因为最大公约数不可能大于较小数的一半 所以从一半开始
        for(int i = x / 2; i >= 1; i--){
            if(x % i == 0){
                gcd = i;
                break;
            }
        }

        //输出
        System.out.println(x + "和" + y + "的最大公约数是" + gcd);
    }

欧几里德算法

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

        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入两个正整数");

        int x = scanner.nextInt();

        int y = scanner.nextInt();

        //交换位置 找到较小值
        if(x > y){
            x = x ^ y;
            y = x ^ y;
            x = x ^ y;
        }else if(x == y){
            //两个数相等最大公约数是其本身
            System.out.println(x + "和" + y + "的最大公约数是" + x);
            return;
        }

        //当两个数成倍数时 最大公约数为较小的
        if(y % x == 0){
            System.out.println(x + "和" + y + "的最大公约数是" + x);
            return;
        }

        //欧几里德法
        while (y % x != 0){
            int temp = x;
            x = y % x;
            y = temp;
        }

        //输出
        System.out.println(x + "和" + y + "的最大公约数是" + x);
    }

简单的随机生成数封装

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
/**
     * 随机生成两个字符间的一个字符
     * @param a 一个字符
     * @param b 一个字符
     * @return a ~ b 之间的任意一个字符
     */
    public static char randomChar(char a, char b){

        if(a < b){
            return (char) (a + (int)(Math.random() * (b - a +1)));
        }else{
            return (char) (a + (int)(Math.random() * (a - b + 1)));
        }
    }

    /**
     * 随机生成一个小写字母
     * @return
     */
    public static char randomLowercase(){


//        return (char) ('a' + Math.random() * ('z' - 'a' + 1));
        return randomChar('a','z');
    }

    /**
     * 随机生成一个大写字母
     * @return
     */
    public static char randomCapital(){

//        return (char) ('A' + Math.random() * ('Z' - 'A' + 1));
        return randomChar('A','Z');
    }

    /**
     * 随机生成一个数字字符
     * @return
     */
    public static char randomNumber(){

//        return (char)((int)(Math.random() * 10) + '0');
        return randomChar('0','9');
    }

    /**
     * 随机生成一个数字串
     * @param length 生成的字符串长度
     * @return
     */
    public static String randomnumberString(int length){

        StringBuilder stringBuilder = new StringBuilder();

        for(int i = 0; i < length; i++){
            stringBuilder.append(randomNumber());
        }

        return stringBuilder.toString();
    }

    /**
     * 随机生成一个小写字母串
     * @param length 生成的字符串长度
     * @return
     */
    public static String randomLowercaseString(int length){

        StringBuilder stringBuilder = new StringBuilder();

        for(int i = 0; i < length; i++){
            stringBuilder.append(randomLowercase());
        }

        return stringBuilder.toString();
    }

    /**
     * 随机生成一个大写字母串
     * @param length 生成的字符串长度
     * @return
     */
    public static String randomCapitalString(int length){
        StringBuilder stringBuilder = new StringBuilder();

        for (int i = 0; i < length; i++) {
            stringBuilder.append(randomCapital());
        }
        return stringBuilder.toString();
    }

    /**
     * 随机生成一个数字字母的串
     * @param length 生成的字符串长度
     * @return
     */
    public static String randomLetterAndNumber(int length){

        StringBuilder stringBuilder = new StringBuilder();

        for (int i = 0; i < length; i++) {
            int random = (int)(Math.random() * 3);
            char x = ' ';
            switch (random){
                case 0:
                    x = randomNumber();
                break;
                case 1:
                    x = randomLowercase();
                break;
                case 2:
                    x = randomCapital();
                break;
            }

            stringBuilder.append(x);
        }
        return stringBuilder.toString();
    }

    public static void main(String[] args) {
        System.out.println(randomChar('a','z'));
        System.out.println(randomLowercase());
        System.out.println(randomCapital());
        System.out.println(randomNumber());
        System.out.println(randomnumberString(10));
        System.out.println(randomLowercaseString(10));
        System.out.println(randomCapitalString(10));
        System.out.println(randomLetterAndNumber(10));
    }

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

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

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

文章作者:小博

发布时间:2021年12月26日 - 00:28

最后更新:2021年12月26日 - 00:30

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

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