From 713b81bdd56e196ec023893ae8d833cd2aee48ae Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E2=80=9Cwind=E2=80=9D?= <1493020035@qq.com> Date: Sun, 24 Sep 2023 09:45:16 +0800 Subject: [PATCH] Site updated: 2023-09-24 09:45:15 --- .../index.html" | 12 +- 2021/10/13/leetcode_412/index.html | 2 +- .../index.html" | 2 +- .../index.html" | 6 +- .../14/\347\210\254\350\231\253/index.html" | 2 +- .../index.html" | 14 +- .../index.html" | 14 +- 2021/10/20/SpringMvc/index.html | 2 +- 2021/10/20/leetcode_453/index.html | 12 +- .../index.html" | 2 +- .../index.html" | 16 +- .../index.html" | 2 +- 2021/11/01/leetcode_1221/index.html | 4 +- 2021/11/01/leetcode_561/index.html | 4 +- 2021/11/01/leetcode_575/index.html | 10 +- .../index.html" | 8 +- .../index.html" | 4 +- 2021/11/04/leetcode/index.html | 10 +- .../index.html" | 2 +- "2021/11/08/Thread\347\261\273/index.html" | 8 +- .../index.html" | 4 +- .../index.html" | 4 +- .../index.html" | 4 +- .../index.html" | 8 +- .../17/nginx\345\222\214servelt/index.html" | 2 +- .../index.html" | 6 +- .../index.html" | 36 +- .../index.html" | 4 +- .../index.html" | 6 +- .../index.html" | 20 +- .../01/\351\233\206\345\220\210/index.html" | 4 +- .../index.html" | 2 +- .../index.html" | 22 +- .../index.html" | 6 +- .../index.html" | 12 +- .../index.html" | 2 +- .../index.html" | 8 +- .../index.html" | 16 +- .../index.html" | 14 +- .../index.html" | 14 +- 2022/04/03/AOP/index.html | 2 +- .../index.html" | 12 +- .../index.html" | 56 +- .../index.html" | 4 +- .../28/\346\263\233\345\236\213/index.html" | 18 +- .../index.html" | 12 +- .../index.html" | 14 +- .../index.html" | 4 +- atom.xml | 24 +- css/gitalk.css | 546 ------------------ css/highlight-dark.css | 64 -- css/highlight.css | 80 --- css/main.css | 481 +++++++++------ img/avatar.png | Bin 5709 -> 0 bytes img/default.png | Bin 400730 -> 0 bytes img/fluid.png | Bin 4678 -> 0 bytes img/loading.gif | Bin 17142 -> 0 bytes img/police_beian.png | Bin 1246 -> 0 bytes index.html | 48 +- js/boot.js | 16 - js/color-schema.js | 266 --------- js/events.js | 167 ------ js/img-lazyload.js | 10 - js/leancloud.js | 194 ------- js/plugins.js | 99 ---- page/2/index.html | 98 ++-- page/3/index.html | 24 +- page/4/index.html | 44 +- page/5/index.html | 90 +-- page/6/index.html | 44 +- page/7/index.html | 78 +-- page/8/index.html | 22 +- sitemap.xml | 38 +- tags/java/index.html | 101 ++++ xml/local-search.xml | 45 -- 75 files changed, 900 insertions(+), 2131 deletions(-) delete mode 100644 css/gitalk.css delete mode 100644 css/highlight-dark.css delete mode 100644 css/highlight.css delete mode 100644 img/avatar.png delete mode 100644 img/default.png delete mode 100644 img/fluid.png delete mode 100644 img/loading.gif delete mode 100644 img/police_beian.png delete mode 100644 js/boot.js delete mode 100644 js/color-schema.js delete mode 100644 js/events.js delete mode 100644 js/img-lazyload.js delete mode 100644 js/leancloud.js delete mode 100644 js/plugins.js delete mode 100644 xml/local-search.xml diff --git "a/2021/10/12/nginx\346\220\255\345\273\272\345\211\215\347\253\257\351\241\271\347\233\256/index.html" "b/2021/10/12/nginx\346\220\255\345\273\272\345\211\215\347\253\257\351\241\271\347\233\256/index.html" index fcd40aef5..52f1ba066 100644 --- "a/2021/10/12/nginx\346\220\255\345\273\272\345\211\215\347\253\257\351\241\271\347\233\256/index.html" +++ "b/2021/10/12/nginx\346\220\255\345\273\272\345\211\215\347\253\257\351\241\271\347\233\256/index.html" @@ -228,18 +228,18 @@

image-20211012100409206

xtfp这软件上手很容易

只需要左右拖拽文件即刻互相传输

-

1.首先在Xshell上利用yum工具下载nginx

1
yum install nginx -y
+

1.首先在Xshell上利用yum工具下载nginx

1
yum install nginx -y
-

2.测试启动nginx

1
nginx
+

2.测试启动nginx

1
nginx
-

3.配置nginx配置文件

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
1.进入/etc/nginx文件夹
cd /etc/nginx
2.编辑nginx.conf
vim nginx.conf
3.添加一个server
server实例：
server {
        listen       80 default_server;
        listen       [::]:80 default_server;
        server_name  _;
        
        root         /usr/share/nginx/html;        #修改为root         /data/www;
        
        include /etc/nginx/default.d/*.conf;

        location / {
        }

        error_page 404 /404.html;
            location = /40x.html {
        }
        
        error_page 500 502 503 504 /50x.html;
            location = /50x.html {
        }
    }

+

3.配置nginx配置文件

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
1.进入/etc/nginx文件夹
cd /etc/nginx
2.编辑nginx.conf
vim nginx.conf
3.添加一个server
server实例：
server {
        listen       80 default_server;
        listen       [::]:80 default_server;
        server_name  _;
        
        root         /usr/share/nginx/html;        #修改为root         /data/www;
        
        include /etc/nginx/default.d/*.conf;

        location / {
        }

        error_page 404 /404.html;
            location = /40x.html {
        }
        
        error_page 500 502 503 504 /50x.html;
            location = /50x.html {
        }
    }

-

4.贴上我自己的nginx.conf完整配置

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
# For more information on configuration, see:
#   * Official English Documentation: http://nginx.org/en/docs/
#   * Official Russian Documentation: http://nginx.org/ru/docs/

user nginx;
worker_processes auto;
error_log /var/log/nginx/error.log;
pid /run/nginx.pid;

# Load dynamic modules. See /usr/share/nginx/README.dynamic.
include /usr/share/nginx/modules/*.conf;

events {
    worker_connections 1024;
}

http {
    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile            on;
    tcp_nopush          on;
    tcp_nodelay         on;
    keepalive_timeout   65;
    types_hash_max_size 2048;

    include             /etc/nginx/mime.types;
    default_type        application/octet-stream;

    # Load modular configuration files from the /etc/nginx/conf.d directory.
    # See http://nginx.org/en/docs/ngx_core_module.html#include
    # for more information.
    include /etc/nginx/conf.d/*.conf;

    server {
        listen       80 default_server;
        listen       [::]:80 default_server;
        server_name  _;
        root         /usr/share/nginx/html;

        # Load configuration files for the default server block.
        include /etc/nginx/default.d/*.conf;

        location / {
        }

        error_page 404 /404.html;
            location = /40x.html {
        }

        error_page 500 502 503 504 /50x.html;
            location = /50x.html {
        }
    }
    
    server {
        listen       8001 default_server;
        listen       [::]:8001 default_server;
        server_name  _;
        
        root         /usr/local/java/resources;        #修改为root         /data/www;
        
        include /etc/nginx/default.d/*.conf;

        location / {
        }

        error_page 404 /404.html;
            location = /40x.html {
        }
        
        error_page 500 502 503 504 /50x.html;
            location = /50x.html {
        }
    }

# Settings for a TLS enabled server.
#
#    server {
#        listen       443 ssl http2 default_server;
#        listen       [::]:443 ssl http2 default_server;
#        server_name  _;
#        root         /usr/share/nginx/html;
#
#        ssl_certificate "/etc/pki/nginx/server.crt";
#        ssl_certificate_key "/etc/pki/nginx/private/server.key";
#        ssl_session_cache shared:SSL:1m;
#        ssl_session_timeout  10m;
#        ssl_ciphers HIGH:!aNULL:!MD5;
#        ssl_prefer_server_ciphers on;
#
#        # Load configuration files for the default server block.
#        include /etc/nginx/default.d/*.conf;
#
#        location / {
#        }
#
#        error_page 404 /404.html;
#            location = /40x.html {
#        }
#
#        error_page 500 502 503 504 /50x.html;
#            location = /50x.html {
#        }
#    }

}
+

4.贴上我自己的nginx.conf完整配置

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
# For more information on configuration, see:
#   * Official English Documentation: http://nginx.org/en/docs/
#   * Official Russian Documentation: http://nginx.org/ru/docs/

user nginx;
worker_processes auto;
error_log /var/log/nginx/error.log;
pid /run/nginx.pid;

# Load dynamic modules. See /usr/share/nginx/README.dynamic.
include /usr/share/nginx/modules/*.conf;

events {
    worker_connections 1024;
}

http {
    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile            on;
    tcp_nopush          on;
    tcp_nodelay         on;
    keepalive_timeout   65;
    types_hash_max_size 2048;

    include             /etc/nginx/mime.types;
    default_type        application/octet-stream;

    # Load modular configuration files from the /etc/nginx/conf.d directory.
    # See http://nginx.org/en/docs/ngx_core_module.html#include
    # for more information.
    include /etc/nginx/conf.d/*.conf;

    server {
        listen       80 default_server;
        listen       [::]:80 default_server;
        server_name  _;
        root         /usr/share/nginx/html;

        # Load configuration files for the default server block.
        include /etc/nginx/default.d/*.conf;

        location / {
        }

        error_page 404 /404.html;
            location = /40x.html {
        }

        error_page 500 502 503 504 /50x.html;
            location = /50x.html {
        }
    }
    
    server {
        listen       8001 default_server;
        listen       [::]:8001 default_server;
        server_name  _;
        
        root         /usr/local/java/resources;        #修改为root         /data/www;
        
        include /etc/nginx/default.d/*.conf;

        location / {
        }

        error_page 404 /404.html;
            location = /40x.html {
        }
        
        error_page 500 502 503 504 /50x.html;
            location = /50x.html {
        }
    }

# Settings for a TLS enabled server.
#
#    server {
#        listen       443 ssl http2 default_server;
#        listen       [::]:443 ssl http2 default_server;
#        server_name  _;
#        root         /usr/share/nginx/html;
#
#        ssl_certificate "/etc/pki/nginx/server.crt";
#        ssl_certificate_key "/etc/pki/nginx/private/server.key";
#        ssl_session_cache shared:SSL:1m;
#        ssl_session_timeout  10m;
#        ssl_ciphers HIGH:!aNULL:!MD5;
#        ssl_prefer_server_ciphers on;
#
#        # Load configuration files for the default server block.
#        include /etc/nginx/default.d/*.conf;
#
#        location / {
#        }
#
#        error_page 404 /404.html;
#            location = /40x.html {
#        }
#
#        error_page 500 502 503 504 /50x.html;
#            location = /50x.html {
#        }
#    }

}

其中8001端口为我的静态资源访问端口
/usr/local/java/resources 为我的静态资源存放位置

-

5.重启nginx

1
nginx -s reload
+

5.重启nginx

1
nginx -s reload
-

6.测试nginx静态资源访问是否成功

1
2
例如：/usr/local/java/resources下有一个index.html文件
访问则是：www.huhdcc.top:8001/index.html
+

6.测试nginx静态资源访问是否成功

1
2
例如：/usr/local/java/resources下有一个index.html文件
访问则是：www.huhdcc.top:8001/index.html

如果还不能使用的话 是服务器没有开放端口问题

进入阿里云

diff --git a/2021/10/13/leetcode_412/index.html b/2021/10/13/leetcode_412/index.html index d02aff148..a5b2368bf 100644 --- a/2021/10/13/leetcode_412/index.html +++ b/2021/10/13/leetcode_412/index.html @@ -222,7 +222,7 @@

输入：n = 3
输出：[“1”,”2”,”Fizz”]
示例 2：

输入：n = 5
输出：[“1”,”2”,”Fizz”,”4”,”Buzz”]
示例 3：

输入：n = 15
输出：[“1”,”2”,”Fizz”,”4”,”Buzz”,”Fizz”,”7”,”8”,”Fizz”,”Buzz”,”11”,”Fizz”,”13”,”14”,”FizzBuzz”]

-
1
2
3
4
5
6
7
8
9
10
11
12
13
class Solution {
    public List<String> fizzBuzz(int n) {
        List<String> li = new ArrayList<>();
        for(Integer i=1;i<=n;i++)
      {  
        if(i % 3 == 0 && i % 5 == 0) li.add("FizzBuzz");
        else if(i%3==0)li.add("Fizz");
        else if(i%5==0)li.add("Buzz");
        else li.add(i.toString());
    }
    return li;
    }
}
+
1
2
3
4
5
6
7
8
9
10
11
12
13
class Solution {
    public List<String> fizzBuzz(int n) {
        List<String> li = new ArrayList<>();
        for(Integer i=1;i<=n;i++)
      {  
        if(i % 3 == 0 && i % 5 == 0) li.add("FizzBuzz");
        else if(i%3==0)li.add("Fizz");
        else if(i%5==0)li.add("Buzz");
        else li.add(i.toString());
    }
    return li;
    }
}
diff --git "a/2021/10/13/\347\273\251\347\202\271\350\256\241\347\256\227\345\231\250/index.html" "b/2021/10/13/\347\273\251\347\202\271\350\256\241\347\256\227\345\231\250/index.html" index e16168e48..ffbfcadf2 100644 --- "a/2021/10/13/\347\273\251\347\202\271\350\256\241\347\256\227\345\231\250/index.html" +++ "b/2021/10/13/\347\273\251\347\202\271\350\256\241\347\256\227\345\231\250/index.html" @@ -223,7 +223,7 @@

所以自己想了一下自己可以写一个绩点计算器出来吗 好像也不是很难的样子

所以自己用了差不多20分钟帮这个写出来了

下面是源码

-
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
#include<stdio.h>

int main()

{

	int number;

	float score;

	float credit,creditsum=0; 

	float gpasum=0.0,GPA=0.0;

	printf("请输入需要计算的科目数量");

	scanf("%d",&number);

		int count=1;

	for(int i=0;i<number;i++)

	{

	printf("请输入第%d科的成绩和学分",count); 

	scanf("%f %f",&score,&credit);

	creditsum+=credit;

//	printf("%.1f",(score/10-5)*credit);

	gpasum+=(score/10-5)*credit;

	GPA=gpasum/creditsum;

		count++;

	}

//	printf("学分总和：%.1f",creditsum);

//	printf("总分：%.1f",gpasum);

	printf("您的GPA是%.1f",GPA);

	

}
+
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
#include<stdio.h>

int main()

{

	int number;

	float score;

	float credit,creditsum=0; 

	float gpasum=0.0,GPA=0.0;

	printf("请输入需要计算的科目数量");

	scanf("%d",&number);

		int count=1;

	for(int i=0;i<number;i++)

	{

	printf("请输入第%d科的成绩和学分",count); 

	scanf("%f %f",&score,&credit);

	creditsum+=credit;

//	printf("%.1f",(score/10-5)*credit);

	gpasum+=(score/10-5)*credit;

	GPA=gpasum/creditsum;

		count++;

	}

//	printf("学分总和：%.1f",creditsum);

//	printf("总分：%.1f",gpasum);

	printf("您的GPA是%.1f",GPA);

	

}

功能样图
在这里插入图片描述
欢迎关注微信公众号 ：打码少年风萧
程序链接
链接：https://pan.baidu.com/s/1MzkRQ3XCtWadlWFxFDef4g
提取码：30qf

diff --git "a/2021/10/14/\345\211\221\346\214\207offer2_69/index.html" "b/2021/10/14/\345\211\221\346\214\207offer2_69/index.html" index 6dee7f3e7..0774176c0 100644 --- "a/2021/10/14/\345\211\221\346\214\207offer2_69/index.html" +++ "b/2021/10/14/\345\211\221\346\214\207offer2_69/index.html" @@ -216,10 +216,10 @@

剑指 Offer II 069. 山峰数组的顶部

题目

-
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
符合下列属性的数组 arr 称为 山峰数组（山脉数组） ：

arr.length >= 3
存在 i（0 < i < arr.length - 1）使得：
arr[0] < arr[1] < ... arr[i-1] < arr[i]
arr[i] > arr[i+1] > ... > arr[arr.length - 1]
给定由整数组成的山峰数组 arr ，返回任何满足 arr[0] < arr[1] < ... arr[i - 1] < arr[i] > arr[i + 1] > ... > arr[arr.length - 1] 的下标 i ，即山峰顶部。

 

示例 1：

输入：arr = [0,1,0]
输出：1
示例 2：

输入：arr = [1,3,5,4,2]
输出：2
示例 3：

输入：arr = [0,10,5,2]
输出：1
示例 4：

输入：arr = [3,4,5,1]
输出：2
示例 5：

输入：arr = [24,69,100,99,79,78,67,36,26,19]
输出：2
 

提示：

3 <= arr.length <= 104
0 <= arr[i] <= 106
题目数据保证 arr 是一个山脉数组
 

进阶：很容易想到时间复杂度 O(n) 的解决方案，你可以设计一个 O(log(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
37
38
39
40
符合下列属性的数组 arr 称为 山峰数组（山脉数组） ：

arr.length >= 3
存在 i（0 < i < arr.length - 1）使得：
arr[0] < arr[1] < ... arr[i-1] < arr[i]
arr[i] > arr[i+1] > ... > arr[arr.length - 1]
给定由整数组成的山峰数组 arr ，返回任何满足 arr[0] < arr[1] < ... arr[i - 1] < arr[i] > arr[i + 1] > ... > arr[arr.length - 1] 的下标 i ，即山峰顶部。

 

示例 1：

输入：arr = [0,1,0]
输出：1
示例 2：

输入：arr = [1,3,5,4,2]
输出：2
示例 3：

输入：arr = [0,10,5,2]
输出：1
示例 4：

输入：arr = [3,4,5,1]
输出：2
示例 5：

输入：arr = [24,69,100,99,79,78,67,36,26,19]
输出：2
 

提示：

3 <= arr.length <= 104
0 <= arr[i] <= 106
题目数据保证 arr 是一个山脉数组
 

进阶：很容易想到时间复杂度 O(n) 的解决方案，你可以设计一个 O(log(n)) 的解决方案吗？

我写的想法 第一次就想到for循环遍历 写出了O（n）的学法

-
1
2
3
4
5
6
7
8
int peakIndexInMountainArray(int* arr, int arrSize){
    int temp=0;
    for(;temp<arrSize-1;temp++){
        if(arr[temp]>arr[temp+1])
        break;
    }
    return temp;
}
+
1
2
3
4
5
6
7
8
int peakIndexInMountainArray(int* arr, int arrSize){
    int temp=0;
    for(;temp<arrSize-1;temp++){
        if(arr[temp]>arr[temp+1])
        break;
    }
    return temp;
}

三叶姐姐的解法

二分
往常我们使用「二分」进行查值，需要确保序列本身满足「二段性」：当选定一个端点（基准值）后，结合「一段满足 & 另一段不满足」的特性来实现“折半”的查找效果。

@@ -228,7 +228,7 @@ 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Solution {
    // 根据 arr[i-1] < arr[i] 在 [1,n-1] 范围内找值
    // 峰顶元素为符合条件的最靠近中心的元素
    public int peakIndexInMountainArray(int[] arr) {
        int n = arr.length;
        int l = 1, r = n - 1;
        while (l < r) {
            int mid = l + r + 1 >> 1;
            if (arr[mid - 1] < arr[mid]) l = mid;
            else r = mid - 1;
        }
        return r;
    }
}
+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Solution {
    // 根据 arr[i-1] < arr[i] 在 [1,n-1] 范围内找值
    // 峰顶元素为符合条件的最靠近中心的元素
    public int peakIndexInMountainArray(int[] arr) {
        int n = arr.length;
        int l = 1, r = n - 1;
        while (l < r) {
            int mid = l + r + 1 >> 1;
            if (arr[mid - 1] < arr[mid]) l = mid;
            else r = mid - 1;
        }
        return r;
    }
}

预备知识

Java Web开发 Web服务器

slf4j打印日志是好的实践

才用lombok简化Java bean编写

给线程取一个好名字

并发与并行

Rob Pike(Golang语言创始者)的一段描述

进程与线程

多线程demo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class deno01 {
    public static void main(String[] args) {
        new Thread(() ->{
            while (true)
            {
                System.out.println(1);
            }
        },"t1").start();

        new Thread(() ->{
            while (true)
            {
                System.out.println(2);
            }
        },"t2").start();
    }

}

很明显得到的结果是交替打印1 和 2。

拓展

tasklist 查看进程

taskkill 杀死进程

Jdk自带的命令 jps

可以查看java运行的程序类名

tasklist | findstr java 可以查看java的程序

taskkill /F /PID pid端口号 可以杀死进程

top命令查看服务器资源占有情况

synchronized关键字

synchronized关键字解决的是多个线程之间访问资源的同步性

]]> + JUC Java并发

预备知识

Java Web开发 Web服务器

slf4j打印日志是好的实践

才用lombok简化Java bean编写

给线程取一个好名字

并发与并行

Rob Pike(Golang语言创始者)的一段描述

进程与线程

多线程demo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class deno01 {
    public static void main(String[] args) {
        new Thread(() ->{
            while (true)
            {
                System.out.println(1);
            }
        },"t1").start();

        new Thread(() ->{
            while (true)
            {
                System.out.println(2);
            }
        },"t2").start();
    }

}

很明显得到的结果是交替打印1 和 2。

拓展

tasklist 查看进程

taskkill 杀死进程

Jdk自带的命令 jps

可以查看java运行的程序类名

tasklist | findstr java 可以查看java的程序

taskkill /F /PID pid端口号 可以杀死进程

top命令查看服务器资源占有情况

synchronized关键字

synchronized关键字解决的是多个线程之间访问资源的同步性

]]> @@ -157,7 +157,7 @@ 2022-06-29T07:27:15.543Z 2022-07-07T10:13:55.120Z - Java基础复习

1、== 与equals方法

对于八种基本数据类型来说(byte short int long float double boolean char) == 是比较的值 而八种基本数据类型 是没有equals方法的

对于引用数据类型来说 == 比较的是对象的内存地址 而equals比较的字面值(例:String类型)

2、Synchronized关键字

作用

Synchronized主要有三种用法：

1
2
3
synchronized void method() {
  //业务代码
}
1
2
3
synchronized void staic method() {
  //业务代码
}
1
2
3
synchronized(this) {
  //业务代码
}

3.Java容器

一、Collection

简单来说就是单个集合的元素

分为List、Set、Queue三大类

List有ArrayList(底层由数组组成 查找快 支持随机访问) LinkedList(底层由双向链表组成 修改快 还可以做栈 队列 以及双向队列) 以及Vector(线程安全 但是效率低 很少用)

List

ArrayList

JDK 7 以无参数构造方法创建 ArrayList 时，直接创建了长度是10的Object[]数组elementData 。

JDK 8 以无参数构造方法创建 ArrayList 时，实际上初始化赋值的是一个空数组。当真正对数组进行添加元素操作时，才真正分配容量。即向数组中添加第一个元素时，数组容量扩为 10。

底层为一个Object类型的数组 初始长度为0;若采用了泛型 ArrayList list = new ArrayList<>();

则生成的是String[]类型的数组 初始长度为0

扩容

当初始长度为10已经加入了十个元素之后，我们需要再加一个元素的时候，我们就需要扩容

1
2
3
4
5
6
private void add(E e, Object[] elementData, int s) {
    if (s == elementData.length)
        elementData = grow();
    elementData[s] = e;
    size = s + 1;
}

这段源代码就是ArrayList的add()方法 如果添加的元素已经满了 则调用grow()函数 很明显 这是一个扩容函数

grow函数有两个 一个有参函数 一个无参函数

无参参数会调用有参参数 进行1.5倍的扩容

1
ArrayList list1 = new ArrayList(23);

这表示着生成了一个初始长度为23的ArrayList数组

Vector

和ArrayList数组类似 线程安全 效率低 用的很少

但是我们用的Stack(栈)则是基于Vector设计的

实现栈

Stack继承Vector 是Vector的子类

LinkedList

基于双向链表实现 增删元素效率高 查询效率低

LinkedList可以用作栈 队列 以及双向队列

Set

集合 无序可去重的集合

TreeSet

​ 无序 不可重复 自动排序 相当于存放在TreeMap的Key部分

HashSet

​ 无序 不可重复 支持快速查找 存放在HashMap中相当于key部分

LinkedHashSet

​ 基于双向链表实现，具有HashSet的查找效率

Queue

LinkedList

可以用他来实现双向队列

PriorityQueue

用于堆实现 可以用它实现优先队列

二、Map

映射类型 Key - Value类型结构、

HashMap

比如最为常见的HashMap

JDK 1.7 底层是数组+链表

JDK 1.8 底层是数组+链表+红黑树 加入红黑树的目的是增加HashMap的插入和查询速率

HaashMap通过key进行hashcode与 与运算 得到下标。

HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。

HashMap 实现了 Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度，最多允许一条记录的键为 null，不支持线程同步。

HashMap 是无序的，即不会记录插入的顺序。

HashMap 继承于AbstractMap，实现了 Map、Cloneable、java.io.Serializable 接口。

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
public class Main {
    public static void main(String[] args) throws IOException, Exception {
        HashMap<String,String> map = new HashMap<>();
        map.put("1","one");
        map.put("2","two");
        map.put("3","three");
        map.put("4","four");
        System.out.println(map);

        HashMap<String, String> Sites = new HashMap<String, String>();
        // 添加键值对
        Sites.put("one", "Google");
        Sites.put("two", "Runoob");
        Sites.put("three", "Taobao");
        Sites.put("four", "Zhihu");
        Sites.put("apple","lll");
        System.out.println(Sites);
        // key=商品名称,value=价格,这里以这个例子实现按名称排序和按价格排序.
        Map store = new HashMap();

        store.put("iphone12", 6799);
        store.put("iphone12pro", 8499);
        store.put("macbookPro", 19499);
        store.put("ipadAir", 6999);
        store.put("watch6", 3199);

// 直接输出HashMap得到的是一个无序Map(不是Arraylist那种顺序型储存)
        System.out.println(store);

//        {ipadAir=6999, iphone12pro=8499, macbookPro=19499, watch6=3199, iphone12=6799}
    }

    }

起初我验证Map的无序的时候 输出的总是有序的 增加了样本之后才变得无序

但是输入 它内部就有机构形成 无论你是输出十遍还是一百遍 他都是输出一样的顺序

这就是HashMap的无序性和有序性

采用拉链法解决哈希冲突

JDK1.7采用头插法，有可能形成回路

JDK1.8以后采用尾插法

HashMap的默认初始容量为16

HashMap 默认加载因⼦：0.75

数组容器达到 3/4 时，开始扩容

JDK 8 之后，对 HashMap 底层数据结构（单链表）进⾏了改进

hashcode() :通过调用Hashcode()方法得到key的哈希值

通过哈希函数/哈希算法 转换成数组的下表

重写Hashcode()和equals()的原因是

需要达到散列分布均匀

4.JVM,JRE,JDK的区别

总的来说 JVM包括JRE JRE包括JVM

Java 虚拟机（JVM）是运行 Java 字节码的虚拟机。JVM 有针对不同系统的特定实现（Windows，Linux，macOS），目的是使用相同的字节码，它们都会给出相同的结果。字节码和不同系统的 JVM 实现是 Java 语言“一次编译，随处可以运行”的关键所在。

]]> + Java基础复习

1、== 与equals方法

对于八种基本数据类型来说(byte short int long float double boolean char) == 是比较的值 而八种基本数据类型 是没有equals方法的

对于引用数据类型来说 == 比较的是对象的内存地址 而equals比较的字面值(例:String类型)

2、Synchronized关键字

作用

Synchronized主要有三种用法：

1
2
3
synchronized void method() {
  //业务代码
}
1
2
3
synchronized void staic method() {
  //业务代码
}
1
2
3
synchronized(this) {
  //业务代码
}

3.Java容器

一、Collection

简单来说就是单个集合的元素

分为List、Set、Queue三大类

List有ArrayList(底层由数组组成 查找快 支持随机访问) LinkedList(底层由双向链表组成 修改快 还可以做栈 队列 以及双向队列) 以及Vector(线程安全 但是效率低 很少用)

List

ArrayList

JDK 7 以无参数构造方法创建 ArrayList 时，直接创建了长度是10的Object[]数组elementData 。

JDK 8 以无参数构造方法创建 ArrayList 时，实际上初始化赋值的是一个空数组。当真正对数组进行添加元素操作时，才真正分配容量。即向数组中添加第一个元素时，数组容量扩为 10。

底层为一个Object类型的数组 初始长度为0;若采用了泛型 ArrayList list = new ArrayList<>();

则生成的是String[]类型的数组 初始长度为0

扩容

当初始长度为10已经加入了十个元素之后，我们需要再加一个元素的时候，我们就需要扩容

1
2
3
4
5
6
private void add(E e, Object[] elementData, int s) {
    if (s == elementData.length)
        elementData = grow();
    elementData[s] = e;
    size = s + 1;
}

这段源代码就是ArrayList的add()方法 如果添加的元素已经满了 则调用grow()函数 很明显 这是一个扩容函数

grow函数有两个 一个有参函数 一个无参函数

无参参数会调用有参参数 进行1.5倍的扩容

1
ArrayList list1 = new ArrayList(23);

这表示着生成了一个初始长度为23的ArrayList数组

Vector

和ArrayList数组类似 线程安全 效率低 用的很少

但是我们用的Stack(栈)则是基于Vector设计的

实现栈

Stack继承Vector 是Vector的子类

LinkedList

基于双向链表实现 增删元素效率高 查询效率低

LinkedList可以用作栈 队列 以及双向队列

Set

集合 无序可去重的集合

TreeSet

​ 无序 不可重复 自动排序 相当于存放在TreeMap的Key部分

HashSet

​ 无序 不可重复 支持快速查找 存放在HashMap中相当于key部分

LinkedHashSet

​ 基于双向链表实现，具有HashSet的查找效率

Queue

LinkedList

可以用他来实现双向队列

PriorityQueue

用于堆实现 可以用它实现优先队列

二、Map

映射类型 Key - Value类型结构、

HashMap

比如最为常见的HashMap

JDK 1.7 底层是数组+链表

JDK 1.8 底层是数组+链表+红黑树 加入红黑树的目的是增加HashMap的插入和查询速率

HaashMap通过key进行hashcode与 与运算 得到下标。

HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。

HashMap 实现了 Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度，最多允许一条记录的键为 null，不支持线程同步。

HashMap 是无序的，即不会记录插入的顺序。

HashMap 继承于AbstractMap，实现了 Map、Cloneable、java.io.Serializable 接口。

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
public class Main {
    public static void main(String[] args) throws IOException, Exception {
        HashMap<String,String> map = new HashMap<>();
        map.put("1","one");
        map.put("2","two");
        map.put("3","three");
        map.put("4","four");
        System.out.println(map);

        HashMap<String, String> Sites = new HashMap<String, String>();
        // 添加键值对
        Sites.put("one", "Google");
        Sites.put("two", "Runoob");
        Sites.put("three", "Taobao");
        Sites.put("four", "Zhihu");
        Sites.put("apple","lll");
        System.out.println(Sites);
        // key=商品名称,value=价格,这里以这个例子实现按名称排序和按价格排序.
        Map store = new HashMap();

        store.put("iphone12", 6799);
        store.put("iphone12pro", 8499);
        store.put("macbookPro", 19499);
        store.put("ipadAir", 6999);
        store.put("watch6", 3199);

// 直接输出HashMap得到的是一个无序Map(不是Arraylist那种顺序型储存)
        System.out.println(store);

//        {ipadAir=6999, iphone12pro=8499, macbookPro=19499, watch6=3199, iphone12=6799}
    }

    }

起初我验证Map的无序的时候 输出的总是有序的 增加了样本之后才变得无序

但是输入 它内部就有机构形成 无论你是输出十遍还是一百遍 他都是输出一样的顺序

这就是HashMap的无序性和有序性

采用拉链法解决哈希冲突

JDK1.7采用头插法，有可能形成回路

JDK1.8以后采用尾插法

HashMap的默认初始容量为16

HashMap 默认加载因⼦：0.75

数组容器达到 3/4 时，开始扩容

JDK 8 之后，对 HashMap 底层数据结构（单链表）进⾏了改进

hashcode() :通过调用Hashcode()方法得到key的哈希值

通过哈希函数/哈希算法 转换成数组的下表

重写Hashcode()和equals()的原因是

需要达到散列分布均匀

4.JVM,JRE,JDK的区别

总的来说 JVM包括JRE JRE包括JVM

Java 虚拟机（JVM）是运行 Java 字节码的虚拟机。JVM 有针对不同系统的特定实现（Windows，Linux，macOS），目的是使用相同的字节码，它们都会给出相同的结果。字节码和不同系统的 JVM 实现是 Java 语言“一次编译，随处可以运行”的关键所在。

]]> @@ -179,7 +179,7 @@ 2022-06-28T07:37:44.595Z 2022-06-29T06:17:26.380Z - 泛型

前言之ArrayList

ArrayList大家都肯定很熟悉 在需要存储一个不定长度的时候，我们通常第一时间想的就是ArrayList。

实际上ArrayList内部就是一个Object[]数组，配合存储一个当前分配的长度，就可以充当“可变数组”：

引用自廖雪峰老师的博客

我们翻开他的底层源码 我们会发现

原型是创建了一个Object[]的数组(初始容量为空 如果add第一个元素则会吧数组大小赋成10) 刚开始的 DEFAULT_CAPACITY 为10

未指定泛型前 我们需要这样写来获取对象

很容易出现ClassCastException，因为容易“误转型”：

1
2
3
4
5
6
7
8
9
10
11
public class Main {
    public static void main(String[] args) throws IOException {
        ArrayList list = new ArrayList();
        list.add("hello world");
        String s = (String) list.get(0);
        System.out.println(s);
        list.add(new Integer(123));
        String s2 = (String) list.get(1);
        }
    }

则控制台会报错ClassCastException

要解决上述问题，我们可以为String单独编写一种ArrayList

StringArrayList stringarraylist = new Stringarraylist()

底层就是String类型的数组了

1
2
3
4
5
6
7
public class StringArrayList {
    private String[] array;
    private int size;
    public void add(String e) {...}
    public void remove(int index) {...}
    public String get(int index) {...}
}

这样一来，存入的必须是String，取出的也一定是String，不需要强制转型，因为编译器会强制检查放入的类型：

但是我们总不能针对Integer类型再写个IngtegerArrayList类型 针对Character再写个。。。

工程量十分的巨大 以及累赘

所以泛型的出现解决了这个问题

我们必须把ArrayList变成一种模板：ArrayList

1
2
3
4
5
6
7
public class ArrayList<T> {
    private T[] array;
    private int size;
    public void add(T e) {...}
    public void remove(int index) {...}
    public T get(int index) {...}
}

T可以是任何class。这样一来，我们就实现了：编写一次模版，可以创建任意类型的ArrayList：

我们可以定义任何一种类型的ArrayList啦

1
2
3
ArrayList<String> stringArrayList = new ArrayList<>();
ArrayList<Integer> IntegerArrayList = new ArrayList<>();
ArrayList<Character> characterArrayList = new ArrayList<>();

这样一来，既实现了编写一次，万能匹配，又通过编译器保证了类型安全：这就是泛型。

向上转型

在Java标准库中的ArrayList<T>实现了List<T>接口，它可以向上转型为List<T>：

使用泛型

使用ArrayList时，如果不定义泛型类型时，泛型类型实际上就是Object：

1
ArrayList list = new ArrayList();//此为Object
1
2
3
4
5
List list = new ArrayList();
list.add("Hello");
list.add("World");
String first = list.get(0); //这里会报错 因为默认是Object对象 需要强转
String second = (String) list.get(1);

当我们定义泛型 List<String> list = new List<>();

1
2
3
4
5
6
7
//无编译器警告:
    List<String> list = new ArrayList<String>();
    list.add("Hello");
    list.add("World");
// 无强制转型:
    String first = list.get(0);
    String second = list.get(1);

当我们定义泛型类型<Number>后，List<T>的泛型接口变为强类型List<Number>：

1
2
3
4
5
6
7
8
List<Number> list = new ArrayList<>();
list.add(3.14);//double类型
list.add(3.15);//float类型
list.add(1);//Integer类型
Number first = list.get(0);
Number second = list.get(1);
Number third = list.get(2);
System.out.println("first"+" "+first+" "+"second"+" "+second+" "+"third"+" "+third);

泛型接口

除了ArrayList<T>使用了泛型，还可以在接口中使用泛型。例如，Arrays.sort(Object[])可以对任意数组进行排序，但待排序的元素必须实现Comparable<T>这个泛型接口：

1
2
3
4
5
6
7
8
public interface Comparable<T> {
    /**
     * 返回负数: 当前实例比参数o小
     * 返回0: 当前实例与参数o相等
     * 返回正数: 当前实例比参数o大
     */
    int compareTo(T o);
}
]]> + 泛型

前言之ArrayList

ArrayList大家都肯定很熟悉 在需要存储一个不定长度的时候，我们通常第一时间想的就是ArrayList。

实际上ArrayList内部就是一个Object[]数组，配合存储一个当前分配的长度，就可以充当“可变数组”：

引用自廖雪峰老师的博客

我们翻开他的底层源码 我们会发现

原型是创建了一个Object[]的数组(初始容量为空 如果add第一个元素则会吧数组大小赋成10) 刚开始的 DEFAULT_CAPACITY 为10

未指定泛型前 我们需要这样写来获取对象

很容易出现ClassCastException，因为容易“误转型”：

1
2
3
4
5
6
7
8
9
10
11
public class Main {
    public static void main(String[] args) throws IOException {
        ArrayList list = new ArrayList();
        list.add("hello world");
        String s = (String) list.get(0);
        System.out.println(s);
        list.add(new Integer(123));
        String s2 = (String) list.get(1);
        }
    }

则控制台会报错ClassCastException

要解决上述问题，我们可以为String单独编写一种ArrayList

StringArrayList stringarraylist = new Stringarraylist()

底层就是String类型的数组了

1
2
3
4
5
6
7
public class StringArrayList {
    private String[] array;
    private int size;
    public void add(String e) {...}
    public void remove(int index) {...}
    public String get(int index) {...}
}

这样一来，存入的必须是String，取出的也一定是String，不需要强制转型，因为编译器会强制检查放入的类型：

但是我们总不能针对Integer类型再写个IngtegerArrayList类型 针对Character再写个。。。

工程量十分的巨大 以及累赘

所以泛型的出现解决了这个问题

我们必须把ArrayList变成一种模板：ArrayList

1
2
3
4
5
6
7
public class ArrayList<T> {
    private T[] array;
    private int size;
    public void add(T e) {...}
    public void remove(int index) {...}
    public T get(int index) {...}
}

T可以是任何class。这样一来，我们就实现了：编写一次模版，可以创建任意类型的ArrayList：

我们可以定义任何一种类型的ArrayList啦

1
2
3
ArrayList<String> stringArrayList = new ArrayList<>();
ArrayList<Integer> IntegerArrayList = new ArrayList<>();
ArrayList<Character> characterArrayList = new ArrayList<>();

这样一来，既实现了编写一次，万能匹配，又通过编译器保证了类型安全：这就是泛型。

向上转型

在Java标准库中的ArrayList<T>实现了List<T>接口，它可以向上转型为List<T>：

使用泛型

使用ArrayList时，如果不定义泛型类型时，泛型类型实际上就是Object：

1
ArrayList list = new ArrayList();//此为Object
1
2
3
4
5
List list = new ArrayList();
list.add("Hello");
list.add("World");
String first = list.get(0); //这里会报错 因为默认是Object对象 需要强转
String second = (String) list.get(1);

当我们定义泛型 List<String> list = new List<>();

1
2
3
4
5
6
7
//无编译器警告:
    List<String> list = new ArrayList<String>();
    list.add("Hello");
    list.add("World");
// 无强制转型:
    String first = list.get(0);
    String second = list.get(1);

当我们定义泛型类型<Number>后，List<T>的泛型接口变为强类型List<Number>：

1
2
3
4
5
6
7
8
List<Number> list = new ArrayList<>();
list.add(3.14);//double类型
list.add(3.15);//float类型
list.add(1);//Integer类型
Number first = list.get(0);
Number second = list.get(1);
Number third = list.get(2);
System.out.println("first"+" "+first+" "+"second"+" "+second+" "+"third"+" "+third);

泛型接口

除了ArrayList<T>使用了泛型，还可以在接口中使用泛型。例如，Arrays.sort(Object[])可以对任意数组进行排序，但待排序的元素必须实现Comparable<T>这个泛型接口：

1
2
3
4
5
6
7
8
public interface Comparable<T> {
    /**
     * 返回负数: 当前实例比参数o小
     * 返回0: 当前实例与参数o相等
     * 返回正数: 当前实例比参数o大
     */
    int compareTo(T o);
}
]]> @@ -201,7 +201,7 @@ 2022-05-11T11:47:46.565Z 2022-05-11T12:19:51.427Z - 通过rpm源安装RabbitMQ后 15672端口开放却访问不到网页(附安装方法)

先创建两个路径 先安装erlang环境

rabbitmq资源地址https://wwb.lanzoum.com/igycS04nk2ej

erlang资源 https://wwb.lanzoum.com/ic3df04nk6sh 密码:emig

安装erlang资源

先下载erlang资源 并且安装

yum -y install esl-erlang_23.0.2-1_centos_7_amd64.rpm

检测erlang

安装Rabittmq

安装UI插件命令

rabbitmq-plugins enable rabbitmq_management systemctl start rabbitmq-server.service systemctl status rabbitmq-server.service

！！！这个很重要 我安装的时候排查了很久 发现就是忘记敲了这个命令

启用rabbitmq服务

systemctl start rabbitmq-server.service

检测服务命令

systemctl status rabbitmq-server.service

查看是否是绿色的running

访问 ip+15672

打开防火墙

进入界面

默认账号guest 密码 guest

但是是默认不是本机是登不上去的

在rabbitmq的配置文件目录下（默认为：/etc/rabbitmq）创建一个rabbitmq.config文件。 文件中添加如下配置（请不要忘记那个“.”）：

cd /etc/rabbitmq

vim rabbitmq.config

加入下面一句话

[{rabbit, [{loopback_users, []}]}].

重启rabbitmq服务

systemctl restart rabbitmq-server.service

重新访问即可

Maven依赖

1
2
3
4
5
<!-- AMQP依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

配置

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
application.yml

RabbitMQConfig.java

spring:

  \#RabbitMQ

 rabbitmq:

   \#服务器地址

  host: 192.168.10.100

   \#用户名

  username: guest

   \#密码

  password: guest

   \#虚拟主机

  virtual-host: /

   \#端口

  port: 5672

  listener:

   simple:

​     \#消费者最小数量

​    concurrency: 10

​     \#消费者最大数量

​    max-concurrency: 10

​     \#限制消费者每次只处理一条消息，处理完再继续下一条消息

​    prefetch: 1

​     \#启动时是否默认启动容器，默认true

​    auto-startup: true

​     \#被拒绝时重新进入队列

​    default-requeue-rejected: true

  template:

   retry:

​     \#发布重试，默认false

​    enabled: true

​     \#重试时间 默认1000ms

​    initial-interval: 1000

​     \#重试最大次数，默认3次

​    max-attempts: 3

​     \#重试最大间隔时间，默认10000ms

​    max-interval: 10000

​     \#重试间隔的乘数。比如配2.0 第一次等10s，第二次等20s，第三次等40s

​    multiplier: 1.0
]]> + 通过rpm源安装RabbitMQ后 15672端口开放却访问不到网页(附安装方法)

先创建两个路径 先安装erlang环境

rabbitmq资源地址https://wwb.lanzoum.com/igycS04nk2ej

erlang资源 https://wwb.lanzoum.com/ic3df04nk6sh 密码:emig

安装erlang资源

先下载erlang资源 并且安装

yum -y install esl-erlang_23.0.2-1_centos_7_amd64.rpm

检测erlang

安装Rabittmq

安装UI插件命令

rabbitmq-plugins enable rabbitmq_management systemctl start rabbitmq-server.service systemctl status rabbitmq-server.service

！！！这个很重要 我安装的时候排查了很久 发现就是忘记敲了这个命令

启用rabbitmq服务

systemctl start rabbitmq-server.service

检测服务命令

systemctl status rabbitmq-server.service

查看是否是绿色的running

访问 ip+15672

打开防火墙

进入界面

默认账号guest 密码 guest

但是是默认不是本机是登不上去的

在rabbitmq的配置文件目录下（默认为：/etc/rabbitmq）创建一个rabbitmq.config文件。 文件中添加如下配置（请不要忘记那个“.”）：

cd /etc/rabbitmq

vim rabbitmq.config

加入下面一句话

[{rabbit, [{loopback_users, []}]}].

重启rabbitmq服务

systemctl restart rabbitmq-server.service

重新访问即可

Maven依赖

1
2
3
4
5
<!-- AMQP依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

配置

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
application.yml

RabbitMQConfig.java

spring:

  \#RabbitMQ

 rabbitmq:

   \#服务器地址

  host: 192.168.10.100

   \#用户名

  username: guest

   \#密码

  password: guest

   \#虚拟主机

  virtual-host: /

   \#端口

  port: 5672

  listener:

   simple:

​     \#消费者最小数量

​    concurrency: 10

​     \#消费者最大数量

​    max-concurrency: 10

​     \#限制消费者每次只处理一条消息，处理完再继续下一条消息

​    prefetch: 1

​     \#启动时是否默认启动容器，默认true

​    auto-startup: true

​     \#被拒绝时重新进入队列

​    default-requeue-rejected: true

  template:

   retry:

​     \#发布重试，默认false

​    enabled: true

​     \#重试时间 默认1000ms

​    initial-interval: 1000

​     \#重试最大次数，默认3次

​    max-attempts: 3

​     \#重试最大间隔时间，默认10000ms

​    max-interval: 10000

​     \#重试间隔的乘数。比如配2.0 第一次等10s，第二次等20s，第三次等40s

​    multiplier: 1.0
]]> @@ -334,7 +334,7 @@ 2022-04-07T00:17:05.425Z 2022-05-17T12:39:35.879Z - 阅文笔试复习

1.详细描述ThreadPoolExecutor的各个参数的含义，介绍一个任务提交到线程池后的执行流程

2.请简要说明Servlet中的生命周期

1.Servlet初始化后调用Init()方法

2.Servlet调用service()方法来处理客户端的请求。

3.Servlet销毁前调用destroy()方法终止

3.开启两个线程A,B，打印1到10 线程A打印奇数(1,3,5,7,9),线程B打印偶数(2,4,6,8,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
27
28
29
package com.yuewen;

import java.util.Scanner;
import java.util.concurrent.locks.LockSupport;

public class ABXianC {
    static Thread thread1;
    static Thread thread2;
    public static void main(String[] args) {
                thread1 = new Thread(() -> {
            for (int i = 1; i <= 9; i += 2) {
                System.out.println(i);
                LockSupport.unpark(thread2);
                LockSupport.park();
            }
        });
        thread2 = new Thread(() -> {
            for (int i = 2; i <= 10; i = i + 2) {
                LockSupport.park();
                System.out.println(i);
                LockSupport.unpark(thread1);
            }
        });
        thread1.start();
        thread2.start();
    }

}

4.请编写代码实现单例模式,类名为Singletion

1.饿汉模式

1
2
3
4
5
6
public class Singleton{
    static private Singleton instance = new Singleton();//因为无法实例化，所以必须是静态的
    static public Singleton getInstance(){
        return instance;
    }
}

2.懒汉线程安全

1
2
3
4
5
6
7
8
9
10
11
12
package com.yuewen;

import java.util.Scanner;

public class Singletion {
    private static Singleton instance;
    private Singletion(){};
    public static synchronized Singleton getInstance(){
        if(instance == null) instance = new Singleton();
        return instance;
    }
}

5.写一个Map转换成JavaBean的工具类方法，实现如下mapToObject方法(使用Java反射，不允许使用第三方库)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public static Object mapToObject(Map<String,Object> map,Class<?> beanClass){
    if(map == null) return null;
    Object obj = null;
    try{
        obj = beanClass.newInstance();
        Field[] fields = obj.getClass().getDeclaredFields();
        for(Field field : fields)
        {
           int mod = field.getModifiers();
           if(Modifier.isStatic(mod) || Modifier.isFinal(mod)){
continue;
           }
            field.setAccessible(true);
            field.set(obj,map.get(field.getName()));
        }
        catch(Exception e)
            e.printStackTrace();
        }
        return obj;
    }
}

6.数据库操作是我们经常使用的一个技能， 请你完成一个简单的用户密码验证过程 ，给定的条件如下：

数据库中存在个用户表:users ,表结构如下：

1
2
3
4
5
6
7
CREATE TABLE `users` (
  `uid` bigint(20) NOT NULL COMMENT '用户ID',
  `user_name` varchar(32) NOT NULL  COMMENT '用户账号',
  `password` varchar(64) NOT NULL  COMMENT '用户混淆密码',
  PRIMARY KEY (`uid`),
  UNIQUE KEY `u_user_name` (`user_name`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户表'

完善以下方法

public boolean verifyPassword(String username,String password) {
Connection con = getConnection () ;// getConnection（） 方法是个已有的方法可以获取到数据库连接 ，

// here is your code
}

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
public boolean verifyPassword(String username,String password){
        Connection con=getConnection;
        String sql="SELECT password FROM users WHERE user_name=?";
        PreparedStatement pst=null;
        ResultSet rs=null;
        boolean flag=false;
        try{
            pst=con.prepareStatement(sql);
            pst.setObject(1,username);
            rs=pst.executeQuery();
            while(rs.next()){
                if(rs.getString("password").equals(password)){
                    flag=true;
                }
            }
        }catch(ClassNotFoundException e){
            e.printStackTrace();
        }catch (SQLException e){
            e.printStackTrace();
        }finally {
            try{
                if(rs!=null) rs.close();
                if(pst!=null) pst.close();
                if(con!=null) con.close();
            }catch(SQLException e){
                e.printStackTrace();
            }
        }
        return flag;
    }

7.介绍HashMap的数据结构、扩容机制，HashMap与Hashtable的区别，是否是线程安全的，并介绍ConcurrentHashMap的实现机制。

HashMap JDK1.8之前 数组+链表

JDK1.8之后 数组+链表+红黑树

1.数组结构

数组用于存储内容，链表（红黑树）用于解决hash冲突。如果链表长度大于阈值8，但是当前数组长度小于树化阈值64，则进行数组扩容操作；如果数组长度大于树化阈值64，则进行链表树化操作，将单向链表转化为红黑树结构。

2.扩容机制：

如果不指定容量，则初始容量默认为16。如果指定容量，则初始容量设置为大于指定容量的最小2的幂数。当当前容量大于容量*负载因子（默认为0.75）时进行扩容操作，扩容为原容量的2倍。

3.HashMap与HashTable的区别

1）数据结构区别：HashMap为数组+链表（红黑树），HashTable为数组+链表，HashTable没有树化操作。

2）扩容机制区别：未指定容量情况下，HashMap容量默认16，每次扩容为2n（n：原容量）。HashTable容量默认为11，每次扩容为2n+1（n：原容量）。指定容量情况下，HashMap将保证容量为2的幂数，HashTable将直接使用指定容量。

3）数据插入方式的区别：当发生hash冲突时，HashMap使用尾插法插入链表，HashTable使用头插法插入链表。

4）线程安全区别：HashMap是非线程安全的，HashTable因为使用synchronized修饰方法，所以HashTable是线程安全的。

ConcurrentHashMap的实现机制

1）ConcurrentHashMap通过synchronized关键字和CAS操作实现线程安全，若插入的槽没有数据，使用CAS操作执行插入操作，若插入的槽有数据，通过synchronized锁住链表的头节点，从而实现效率与线程安全的平衡

8.介绍数据库连接池的实现方式。如何从连接池中获取连接、将连接放回连接池？使用连接池的优势是什么？列举一下自己用过的连接池。

连接池实现原理：

1.用户给servlet发送请求，请求Dao要Connection

2.Dao从“连接池”中取出Connection资源，与DB的通讯

3.当用户离开之后，释放该Connection,那么该Connection被释放到连接池中，等待下一个用户来

Demo目标:

通过简单的增删改查来做到下面几个关于连接池的方式，让我们更了解几种优化的方式

1.自定义一个Pool,来实现类似于现在开源连接池为我们做的一些操作

2.使用Tomcat内置的连接池（apache dbcp）

3.使用DBCP数据库连接池

4.使用C3P0数据库连接池（推荐）

数据库连接池技术带来的优势：

1． 资源重用

由于数据库连接得到重用，避免了频繁创建、释放连接引起的大量性能开销。在减少系统消耗的基础上，另一方面也增进了系统运行环境的平稳性（减少内存碎片以及数据库临时进程/线程的数量）。

2． 更快的系统响应速度

数据库连接池在初始化过程中，往往已经创建了若干数据库连接置于池中备用。此时连接的初始化工作均已完成。对于业务请求处理而言，直接利用现有可用连接，避免了数据库连接初始化和释放过程的时间开销，从而缩减了系统整体响应时间。

3． 新的资源分配手段

对于多应用共享同一数据库的系统而言，可在应用层通过数据库连接的配置，实现数据库连接池技术，几年钱也许还是个新鲜话题，对于目前的业务系统而言，如果设计中还没有考虑到连接池的应用，那么…….快在设计文档中加上这部分的内容吧。某一应用最大可用数据库连接数的限制，避免某一应用独占所有数据库资源。

4． 统一的连接管理，避免数据库连接泄漏

在较为完备的数据库连接池实现中，可根据预先的连接占用超时设定，强制收回被占用连接。从而避免了常规数据库连接操作中可能出现的资源泄漏。一个最小化的数据库连接池实现：

9.什么是死锁？JAVA程序中什么情况下回出现死锁？如何避免出现死锁？

死锁是一种特定的程序状态，在实体之间，由于循环依赖导致彼此一直处于等待之中，没有任何个体可以继续前进。死锁不仅仅会发生在线程之间，存在资源独占的进程之间同样也可能出现死锁。通常来说，我们大多是聚焦在多线程场景中的死锁，指两个或多个线程之间，由于互相持有对方需要的锁，而永久处于阻塞的状态。

基本上死锁的发生是因为：互斥条件，类似Java中Monitor都是独占的，要么是我用，要么是你用。互斥条件是长期持有的，在使用结束之前，自己不会释放，也不能被其它线程抢占。循环依赖关系，两个或者多个个体之间出现了锁的链条环。免死锁的思路和方法。****1、如果可能的话，尽量避免使用多个锁，并且只有需要时才持有锁。2、如果必须使用多个锁，尽量设计好锁的获取顺序。

3、使用带超时的方法，为程序带来更多可控性

10. 分布式锁有几种实现方式，并介绍每种方式的优缺点。

分布式锁一般有三种实现方式：
1、 数据库锁
2、基于Redis的分布式锁
3、基于ZooKeeper的分布式锁

11. 什么是TCP粘包拆包？为什么会出现粘包拆包？如何在应用层面解决此问题？

​ 如果客户端连续不断的向服务端发送数据包时，服务端接收的数据会出现两个数据包粘在一起的情况，这就是TCP协议中经常会遇到的粘包以及拆包的问题。

1、TCP是基于字节流的，虽然应用层和传输层之间的数据交互是大小不等的数据块，但是TCP把这些数据块仅仅看成一连串无结构的字节流，没有边界；

2、在TCP的首部没有表示数据长度的字段，

基于上面两点，在使用TCP传输数据时，才有粘包或者拆包现象发生的可能。

解决

1、发送端给每个数据包添加包首部，首部中应该至少包含数据包的长度，这样接收端在接收到数据后，通过读取包首部的长度字段，便知道每一个数据包的实际长度了。
2、发送端将每个数据包封装为固定长度（不够的可以通过补0填充），这样接收端每次从接收缓冲区中读取固定长度的数据就自然而然的把每个数据包拆分开来。
3、可以在数据包之间设置边界，如添加特殊符号，这样，接收端通过这个边界就可以将不同的数据包拆分开。

12 请大致描述一下BIO，AIO和NIO的区别？

BIO：同步阻塞式IO，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。
NIO：同步非阻塞式IO，服务器实现模式为一个请求一个线程，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。
AIO：异步非阻塞式IO，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理。

13 在JAVA语法中加载类的的方式有哪些？

1、创建类的实例（开辟地址空间）

2、访问某个静态类或接口的静态常量，或者对该静态变量赋值（类初始化）

3、调用类的静态访问（new，也会占用空间）

4、反射（类初始化）

5、初始化一个类的子类（继承）

6、JAVA虚拟机启动被称标明为启动类的类

7、调用某个 ClassLoader 实例的 loadClass() 方法（类不会初始化）

14 建立三个线程A、B、C，A线程打印10次字母A，B线程打印10次字母B,C线程打印10次字母C，但是要求三个线程同时运行，并且实现交替打印，即按照ABCABCABC的顺序打印。

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
package com.yuewen;

import java.util.Scanner;
import java.util.concurrent.locks.LockSupport;
public class ABC {
    static Thread A, B, C;

    public static void main(String[] args) {
        A = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                LockSupport.park();
                System.out.print("A");
                LockSupport.unpark(B);
            }
        });
        B = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                LockSupport.park();
                System.out.print("B");
                LockSupport.unpark(C);
            }
        });
        C = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                LockSupport.unpark(A);
                LockSupport.park();
                System.out.print("C");
            }
        });
        A.start();
        B.start();
        C.start();
    }
}

15 请列举5个spring框架中的注解，并说明注解的用法以及使用场景

16 给定一组自然数，数字的值有可能会大于2^64 ，要求计算出所有数字的和

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
import org.junit.Test;

import java.util.ArrayList;

public class Solution {

    /**
     * 计算一组数字的和
     * @param numbers string字符串ArrayList 一组自然数
     * @return string字符串
     */
    public String sum (ArrayList<String> numbers) {
        // write code here

        String result="0";
        for (String number : numbers) {

            if(number==null||number.length()==0){
                continue;
            }
            int resultLen = result.length();
            int curNumLen = number.length();
            int sum=0;
            int remain;
            StringBuilder stringBuilder = new StringBuilder();
            while (resultLen>0||curNumLen>0){

                int resultNum=0;
                if(resultLen>0){
                    resultNum = result.charAt(--resultLen) - '0';
                }

                int curNum=0;
                if(curNumLen>0){
                    curNum = number.charAt(--curNumLen) - '0';
                }

                sum=sum+resultNum+curNum;
                remain=sum%10;
                stringBuilder.append(remain);
                sum/=10;
            }

            if(sum!=0){
                stringBuilder.append(sum);
            }
            result=stringBuilder.reverse().toString();


        }

        return result;
    }

    @Test
    public void test(){

        String num1="123456";
        String num2="123456789";
        String num3="123456789123";
        ArrayList<String> strings = new ArrayList<>();
        strings.add(num1);
        strings.add(num2);
        strings.add(num3);
        System.out.println(sum(strings));
    }
}

17 给定一个int数字 要求计算出int数字对应的二进制中1的个数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.yuewen;

import java.util.Scanner;

public class Erjinzhi {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int ans = 0;
        while (n > 0){
            n = n & (n-1);
            ans++;
        }
        System.out.println(ans);
    }

}

18 根据产品策略某本书可以设置包月到期时间，需要计算指定时间到包月到期时间还有多少分钟,不足60S的不计入。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public static String dateSub(String a, String b) {
    try {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        sdf.parse(a);
        LocalDateTime t1 =  LocalDateTime.parse(a, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")),
        t2 = LocalDateTime.parse(b, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        long pass = t1.until(t2, ChronoUnit.MINUTES);
        return String.valueOf(Math.abs(pass));
    } catch (Exception e) {
        System.out.println(String.format("格式转化错误：%s, 检查是否格式输入错误", e.getMessage()));
    }
    return "0";
}

public static void main(String[] args) {
    System.out.println("请输入指定的两个日期【小者在前，大者在后，格式：yyyy-MM-dd hh:mm:ss】:");
    Scanner sc = new Scanner(System.in);
    String a = sc.nextLine(), b = sc.nextLine();
    sc.close();
    System.out.println(dateSub(a, b));
}

19 map是一种开发过程中经常使用的k-v数据结构，有个map保存了书名和书字数的关系，编写代码对map里面的书按照字数进行升序排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public static Map<String, Integer> sortMap(Map<String, Integer> map) {
    TreeMap<Integer, List<String>> treeMap = new TreeMap<>();
    map.entrySet().forEach(entry -> {
        List<String> indexList = treeMap.computeIfAbsent(entry.getValue(), k -> new ArrayList<>());
        indexList.add(entry.getKey());
    });
    Map<String, Integer> result = new ListOrderedMap();
    treeMap.entrySet().forEach(entry -> {
        entry.getValue().forEach(key -> result.put(key, map.get(key)));
    });
    return result;
}

public static Map<String, Integer> sortMap2(Map<String, Integer> map) {
    Map result = new ListOrderedMap();
    map.entrySet().stream().
            sorted(Map.Entry.comparingByValue()).
            forEachOrdered(entry -> result.put(entry.getKey(), entry.getValue()));

    return result;
}


20 起点APP上允许用户对作品进行评论，为了防止用户恶意评论，发表不当内容，需要对用户发布的内容进行过滤，请写程序过滤用户发布内容中带有的QQ号（6~10位数字组成） 允许对内容严格操作，如用户发表了 作者大大666666，为你点赞 ，经过过滤后也可以为作者大大****，为你点赞 ，将666666过滤掉了。

把6-10位的数字替换成””;

1
2
3
public static String filterQQ(String s) {
    return s.replaceAll("\\d{6,10}","");
}

21 质数(又称素数),是指在大于1的自然数中,除了1和它本身外,不能被其他自然数整除(除0以外)的数称之为素数(质数)。请写个程序判断输入的数字是否是质数，如果是素数请输出：true，不是请输出false

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

public class IsPrimeDemo {
    public static boolean isPrime(int n){
        if (n < 1){
            return false;
        }
        int i = 2;
        int end = (int) Math.sqrt(n);
        while (i <= end ){
            if (n % i == 0){
                return false;
            }
            ++i;
        }
        return true;
    }

    public static void main(String[] args) {
        int n = 7;
        System.out.println(isPrime(n));
    }
}

22 有 n 个台阶，你一次能走 1 个或者 2 个台阶，那么请问，走完这 n 个台阶共有几种方式？

经典爬楼梯问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com.yuewen;

import java.util.Scanner;

public class ZouTaiJie {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[] dp = new int[n];
        int i = 2;
        dp[0] = 1;
        dp[1] = 2;
        while (i < n)
        {
            dp[i] = dp[i-1] + dp[i-2];
            i++;
        }
        System.out.println(dp[n-1]);
    }

}

23 给定一个字符串，返回这个字符串中有多少个回文子串。两个相同的回文子串出现在不同的位置，认为是2个回文子串。a、aa、aaa、aba、aabaa、abcba均认为是回文子串。

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
import java.util.*;


public class Solution {
  /**
   * 
   * @param str string字符串 
   * @return int整型
   */
  public int palindromeCount (String str) {
    int ans = 0;
    for (int center = 0; center < str.length(); center++) {
      ans += expand(str, center, center) + expand(str, center, center + 1);
    }
    return ans;
  }

  private int expand(String str, int left, int right) {
    int ans = 0;
    while (left >= 0 && right < str.length() && str.charAt(left) == str.charAt(right)) {
      ans++;
      left--;
      right++;
    }
    return ans;
  }
}

24 将一个给定的单链表反转，例：1-2-3-4-5，反转为5-4-3-2-1

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
import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param head ListNode类 
     * @return ListNode类
     */
    public ListNode reverseList (ListNode head) {
       ListNode pre = null, post = head, tmp;
        while (post != null) {
            tmp = post.next;//临时工具人结点
            post.next = pre;//反转
            pre = post;//pre进1
            post = tmp;//post进1
        }
        return pre;
    }
}

25 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

例：图中给定树 {3,5,1,6,2,0,8,#,#,7,4} 中，节点6、节点4的最近公共祖先为5。

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
import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
  /**
   * 
   * @param root TreeNode类 
   * @param p TreeNode类 
   * @param q TreeNode类 
   * @return TreeNode类
  */
  public TreeNode nearestCommonAncestor (TreeNode root, TreeNode p, TreeNode q) {
    if (root == null) {
      return null;
    }
    if (root.val == p.val || root.val == q.val) {
      return root;
    }
    TreeNode leftAns = nearestCommonAncestor(root.left, p, q), 
    rightAns = nearestCommonAncestor(root.right, p, q);
    if (leftAns != null && rightAns != null) {
      return root;
    }
    return leftAns != null ? leftAns : rightAns;
  }
}

26 给定一个递增排序的数组，查找某个数字是否在数组中，如果在数组中，则返回该数字在数组中第一次出现的位置（从0开始）；如果不在数组中，返回-1 。不需要考虑给定的数组不是递增的情况。务必使用二分查找的方式。

好像是错误的！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
int binarySearch(int* arr, int arrLen, int a) {
       // write code here
       int left = 0;
       int right = arrLen-1;
       int mid = 0;
       while(left<=right)
       {
           mid = (left+right)/2;
           if(arr[mid]==a)
           {
               if(arr[mid-1]!=a)
                   return mid;
               else
                   return mid-1;
           }        
           else if(arr[mid]>a)
               right = mid - 1;
           else
               left = mid + 1;
       }  
       return -1;
   }

27 请编写程序实现矩阵的乘法

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
import java.util.*;
public class Main {
        private static int[][] matrixMuilty(int[][] a, int[][] b) {
            int m = a.length, p = b.length, n = b[0].length;
            int[][] res = new int[m][n];
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < n; j++) {
                    for (int k = 0; k < p; k++) {
                        res[i][j] += a[i][k] * b[k][j];
                    }
                }
            }
            return res;
        }

        //输入三个整数，分别表示：第一个矩阵的 行 列【也就是第二个矩阵的行】 第二个矩阵的列
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            String s = sc.nextLine();
            String[] ss = s.split(",");
            int m = Integer.parseInt(ss[0]), p = Integer.parseInt(ss[1]), n = Integer.parseInt(ss[2]);
            if (m == 0 || p == 0 || n == 0) {
                sc.close();
                return;
            }
            int[][] a = new int[m][p];
            int[][] b = new int[p][n];
            for (int i = 0; i < m; i++) {
                s = sc.nextLine();
                ss = s.split(",");
                for (int j = 0; j < p; j++) {
                    a[i][j] = Integer.parseInt(ss[j]);
                }
            }
            for (int i = 0; i < p; i++) {
                s = sc.nextLine();
                ss = s.split(",");
                for (int j = 0; j < n; j++) {
                    b[i][j] = Integer.parseInt(ss[j]);
                }
            }
            sc.close();
            int[][] res = matrixMuilty(a, b);
            for (int i = 0; i < m; i++) {
                StringBuilder sb = new StringBuilder();
                for (int j = 0; j < n; j++) {
                    sb.append(res[i][j]).append(",");
                }
                System.out.println(sb.substring(0, sb.length() - 1));
            }
        }
    }

28 求出一个正整数转换成二进制后的数字“1”的个数。

例：数字23转为二进制为 10111，其中1的个数为4

1
2
3
4
5
public static int binaryTo(int num) { int sum = 0;  while (num > 0) {
        sum += num % 2;
        num = num / 2;
    } return sum;
}

29 去除字符串中的重复字符，对于出现超过2次（包含2次）的字符，只保留第一个。

例：输入abcbdde，输出abcde。

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
import java.util.*;


public class Solution {
    /**
     * 
     * @param str string字符串 
     * @return string字符串
     */
    public String removeDuplicatedChars (String str) {
        // write code here
        boolean[] isExistChar = new boolean[26];
        boolean[] isExistNum = new boolean[10];
        char[] chars = str.toCharArray();
        StringBuilder sb = new StringBuilder();
        for (char c : chars) {
            //是字母
            if(c >= 'a' && c <= 'z'){
                if(!isExistChar[c - 'a']){
                    sb.append(c);
                    isExistChar[c - 'a'] = true;
                }    
            }
            //是数字
            if(c >= '0' && c <= '9'){
                if(!isExistNum[c - '0']){
                    sb.append(c);
                    isExistNum[c - '0'] = true;
                }
            }
        }
        return sb.toString();
    }
}

30 给定一个整型数组，移除数组的某个元素使其剩下的元素乘积最大，如果数组出现相同的元素 ，请输出第一次出现的元素

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 class Main {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    String[] nums = scanner.next().split(",");
    int n = nums.length;
    // dp[i] -> 除 nums[i] 以外的其余所有元素的乘积
    BigDecimal[] dp = new BigDecimal[n];
    dp[0] = BigDecimal.valueOf(1);
    for (int i = 1; i < n; i++) {
      dp[i] = dp[i - 1].multiply(BigDecimal.valueOf(Integer.parseInt(nums[i - 1])));
    }
    BigDecimal temp = BigDecimal.valueOf(1);
    for (int i = n - 1; i >= 0; i--) {
      dp[i] = dp[i].multiply(temp);
      temp = temp.multiply(BigDecimal.valueOf(Integer.parseInt(nums[i])));
    }
    BigDecimal max = dp[0];
    int idx = 0;
    for (int i = 1; i < n; i++) {
      if (dp[i].compareTo(max) > 0) {
        max = dp[i];
        idx = i;
      }
    }
    System.out.println(idx);
  }
}

31 给定一个整型正方形矩阵 Matrix，请把该矩阵调整成顺时针旋转90度的样子。

1
2
3
4
5
6
7
8
9
10
11
12
public static int[][] rotationMatrix(int[][] matrix) {
    if (matrix != null && matrix.length > 0 && matrix.length == matrix[0].length) {
        int[][] result = new int[matrix.length][matrix.length];
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                result[i][j] = matrix[matrix.length - j - 1][i];
            }
        }
        return result;
    }
    return null;
}

32 在字符串中找到第一个不重复的字符。

例：对于字符串“hellohehe”，第一个不重复的字符是“o”。如果每个字符都有重复，则抛出运行时异常。

1
2
3
4
5
6
7
8
9
10
11
12
public char findFirstNonRepeatChar (String str) {
        int[] map = new int[128];
        for (char c: str.toCharArray()) {
            map[c]++;
        }
        for (char c: str.toCharArray()) {
            if (map[c] == 1) {
                return c;
            }
        }
        throw new RuntimeException("没有只有一个的字符");
    }

33.假设有N个用户，其中有些人是朋友，有些则不是。A和B是朋友，B和C是朋友，这样ABC就是一个朋友圈，请计算给定的朋友关系的朋友圈数。

给定一个 N * N 的矩阵 M，表示用户之间的朋友关系。如果M[i][j] = 1，表示已知第 i 个和 j 个人互为朋友关系，否则为不知道。你必须输出所有用户中的已知的朋友圈总数。

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
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
public class Main {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int n = scanner.nextInt();
    String[][] relations = new String[n][n];
    for (int i = 0; i < n; i++) {
      relations[i] = scanner.next().split(",");
    }
    scanner.close();
    System.out.println(friendCircle(relations));
  }
  private static int friendCircle(String[][] relations) {
    int n = relations.length;
    // graph[i] -> 用户 i 的所有朋友
    Set[] graph = new HashSet[n];
    for (int i = 0; i < n; i++) {
      graph[i] = new HashSet();
      for (int j = 0; j < n; j++) {
        int relation = Integer.parseInt(relations[i][j]);
        if (relation == 1) {
          graph[i].add(j);
        }
      }
    }
    int ans = 0;
    boolean[] visited = new boolean[n];
    for (int i = 0; i < n; i++) {
      if (!visited[i]) {
        ans++;
        dfs(graph, i, visited);
      }
    }
    return ans;
  }
  private static void dfs(Set[] graph, int cur, boolean[] visited) {
    visited[cur] = true;
    for (int next : graph[cur]) {
      if (!visited[next]) {
        dfs(graph, next, visited);
      }
    }
  }
}

34 假设有个文件，文件的每一行是书信息数据，分4个部分用逗号（,）进行分割,格式如下

id,category,words,updatetime

id 表示书id，long类型，id不重复；

category 表示书的分类，int类型，请注意全部数据的分类只有几个

words 表示书的字数，int类型

updatetime 表示书的更新时间 ，格式为2020-02-01 23:00:00

请编写程序对文件数据进行排序后输出id，排序优先级为： category>updatetime > words > id , 增序排序

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
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.Scanner;

public class Main {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int n = scanner.nextInt();
    Book[] books = new Book[n];
    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    for (int i = 0; i < n; i++) {
      String[] row = scanner.next().split(",");
      try {
        String updateTime = row[3] + " " + scanner.next();
        Book book =
            new Book(
                Long.parseLong(row[0]),
                Integer.parseInt(row[1]),
                Integer.parseInt(row[2]),
                dateFormat.parse(updateTime));
        books[i] = book;
      } catch (ParseException e) {
        e.printStackTrace();
      }
    }
    scanner.close();
    // 升序排列。字段优先级：category > updateTime > words > id
    Arrays.sort(books, (book1, book2) -> {
      if (book1.getCategory() != book2.getCategory()) {
        return book1.getCategory() - book2.getCategory();
      }
      long update1 = book1.getUpdateTime().getTime(), update2 = book2.getUpdateTime().getTime();
      if (update1 != update2) {
        return (int) (update1 - update2);
      }
      if (book1.getWords() != book2.getWords()) {
        return book1.getWords() - book2.getWords();
      }
      return (int) (book1.getId() - book2.getId());
    });
    for (int i = 0; i < n; i++) {
      System.out.println(books[i].getId());
    }
  }
}

class Book {
  private final long id;
  private final int category;
  private final int words;
  private final Date updateTime;

  public Book(long id, int category, int words, Date updateTime) {
    this.id = id;
    this.category = category;
    this.words = words;
    this.updateTime = updateTime;
  }

  public long getId() {
    return this.id;
  }

  public int getCategory() {
    return this.category;
  }

  public int getWords() {
    return this.words;
  }

  public Date getUpdateTime() {
    return this.updateTime;
  }
}

35请使用堆栈这一个数据结构实现简单FIFO（先入先出）队列，队列要实现两个方法： push、pop。

为自动测试方便，使用每行输入模拟操作：

1） push 1 表明向队列里面新增一个元素 1 , push 和元素之间用空格表示；

2） pop 表明输出当前队列里面的第一个元素，如果当前队列为空请输出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
static class MyQueue {
    int[] queue;
    int lo, hi, size, capacity;

    public MyQueue(int n) {
        this.lo = this.hi = this.size = 0;
        this.capacity = n;
        this.queue = new int[n];
    }

    public MyQueue() {
        this(10);
    }

    public void push(int val) {
        if (hi == capacity) {
            if (lo > 0) {
                int idx = 0;
                for (int i = lo; i < hi; i++) {
                    queue[idx++] = queue[i];
                }
                lo = 0;
                hi = idx;
            } else {
                //扩容
                int[] newQueue = new int[capacity * 2];
                System.arraycopy(queue, 0, newQueue, 0, capacity);
                this.queue = newQueue;
            }
        }
        this.queue[hi++] = val;
    }

    public int pop() {
        if (lo == hi) return -1;
        else {
            return this.queue[lo++];
        }
    }

}

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    // int[] nums = Arrays.stream().mapToInt(Integer::parseInt).toArray();
    String[] ss = scanner.nextLine().split(",");
    YuewenJavaTest.MyQueue myQueue = new YuewenJavaTest.MyQueue();
    for (String s: ss) {
        if (s.startsWith("push")) {
            myQueue.push(Integer.parseInt(s.split(" ")[1]));
        } else {
            System.out.println(myQueue.pop());
        }
    }

    scanner.close();
}

36 在和外部公司联调HTTP接口时，对方要求调用的接口需要计算token，给到的规则如下：

1） 所有的参数值必须经过urlencode,编码为utf-8；

2） 对编码后数据按照key值进行字典升序排序；

3）将所有的参数按照排序的顺序拼接成字符串 ，格式如下: k1=v1&k2=v2&k3=v3;

\4) 将第三步的算出的值计算md5值，md5加密的值小写

请你编写一段方法计算token值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public String getToken(Map<String, String> params) {
    List<String> ss = params.keySet().stream().sorted().map(
        k -> {
            String v = params.get(k);
            String kv = null;
            try {
                kv = k + "=" + URLEncoder.encode(v, "utf-8");
            } catch (Exception e) {

            }
            return kv;
        }
    ).collect(Collectors.toList());
    String token = null;
    try {
        token = new String(MessageDigest.getInstance("md5").digest(String.join("&", ss).getBytes()));
    } catch (Exception e) {
    }
    return token;
}
]]> + 阅文笔试复习

1.详细描述ThreadPoolExecutor的各个参数的含义，介绍一个任务提交到线程池后的执行流程

2.请简要说明Servlet中的生命周期

1.Servlet初始化后调用Init()方法

2.Servlet调用service()方法来处理客户端的请求。

3.Servlet销毁前调用destroy()方法终止

3.开启两个线程A,B，打印1到10 线程A打印奇数(1,3,5,7,9),线程B打印偶数(2,4,6,8,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
27
28
29
package com.yuewen;

import java.util.Scanner;
import java.util.concurrent.locks.LockSupport;

public class ABXianC {
    static Thread thread1;
    static Thread thread2;
    public static void main(String[] args) {
                thread1 = new Thread(() -> {
            for (int i = 1; i <= 9; i += 2) {
                System.out.println(i);
                LockSupport.unpark(thread2);
                LockSupport.park();
            }
        });
        thread2 = new Thread(() -> {
            for (int i = 2; i <= 10; i = i + 2) {
                LockSupport.park();
                System.out.println(i);
                LockSupport.unpark(thread1);
            }
        });
        thread1.start();
        thread2.start();
    }

}

4.请编写代码实现单例模式,类名为Singletion

1.饿汉模式

1
2
3
4
5
6
public class Singleton{
    static private Singleton instance = new Singleton();//因为无法实例化，所以必须是静态的
    static public Singleton getInstance(){
        return instance;
    }
}

2.懒汉线程安全

1
2
3
4
5
6
7
8
9
10
11
12
package com.yuewen;

import java.util.Scanner;

public class Singletion {
    private static Singleton instance;
    private Singletion(){};
    public static synchronized Singleton getInstance(){
        if(instance == null) instance = new Singleton();
        return instance;
    }
}

5.写一个Map转换成JavaBean的工具类方法，实现如下mapToObject方法(使用Java反射，不允许使用第三方库)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public static Object mapToObject(Map<String,Object> map,Class<?> beanClass){
    if(map == null) return null;
    Object obj = null;
    try{
        obj = beanClass.newInstance();
        Field[] fields = obj.getClass().getDeclaredFields();
        for(Field field : fields)
        {
           int mod = field.getModifiers();
           if(Modifier.isStatic(mod) || Modifier.isFinal(mod)){
continue;
           }
            field.setAccessible(true);
            field.set(obj,map.get(field.getName()));
        }
        catch(Exception e)
            e.printStackTrace();
        }
        return obj;
    }
}

6.数据库操作是我们经常使用的一个技能， 请你完成一个简单的用户密码验证过程 ，给定的条件如下：

数据库中存在个用户表:users ,表结构如下：

1
2
3
4
5
6
7
CREATE TABLE `users` (
  `uid` bigint(20) NOT NULL COMMENT '用户ID',
  `user_name` varchar(32) NOT NULL  COMMENT '用户账号',
  `password` varchar(64) NOT NULL  COMMENT '用户混淆密码',
  PRIMARY KEY (`uid`),
  UNIQUE KEY `u_user_name` (`user_name`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户表'

完善以下方法

public boolean verifyPassword(String username,String password) {
Connection con = getConnection () ;// getConnection（） 方法是个已有的方法可以获取到数据库连接 ，

// here is your code
}

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
public boolean verifyPassword(String username,String password){
        Connection con=getConnection;
        String sql="SELECT password FROM users WHERE user_name=?";
        PreparedStatement pst=null;
        ResultSet rs=null;
        boolean flag=false;
        try{
            pst=con.prepareStatement(sql);
            pst.setObject(1,username);
            rs=pst.executeQuery();
            while(rs.next()){
                if(rs.getString("password").equals(password)){
                    flag=true;
                }
            }
        }catch(ClassNotFoundException e){
            e.printStackTrace();
        }catch (SQLException e){
            e.printStackTrace();
        }finally {
            try{
                if(rs!=null) rs.close();
                if(pst!=null) pst.close();
                if(con!=null) con.close();
            }catch(SQLException e){
                e.printStackTrace();
            }
        }
        return flag;
    }

7.介绍HashMap的数据结构、扩容机制，HashMap与Hashtable的区别，是否是线程安全的，并介绍ConcurrentHashMap的实现机制。

HashMap JDK1.8之前 数组+链表

JDK1.8之后 数组+链表+红黑树

1.数组结构

数组用于存储内容，链表（红黑树）用于解决hash冲突。如果链表长度大于阈值8，但是当前数组长度小于树化阈值64，则进行数组扩容操作；如果数组长度大于树化阈值64，则进行链表树化操作，将单向链表转化为红黑树结构。

2.扩容机制：

如果不指定容量，则初始容量默认为16。如果指定容量，则初始容量设置为大于指定容量的最小2的幂数。当当前容量大于容量*负载因子（默认为0.75）时进行扩容操作，扩容为原容量的2倍。

3.HashMap与HashTable的区别

1）数据结构区别：HashMap为数组+链表（红黑树），HashTable为数组+链表，HashTable没有树化操作。

2）扩容机制区别：未指定容量情况下，HashMap容量默认16，每次扩容为2n（n：原容量）。HashTable容量默认为11，每次扩容为2n+1（n：原容量）。指定容量情况下，HashMap将保证容量为2的幂数，HashTable将直接使用指定容量。

3）数据插入方式的区别：当发生hash冲突时，HashMap使用尾插法插入链表，HashTable使用头插法插入链表。

4）线程安全区别：HashMap是非线程安全的，HashTable因为使用synchronized修饰方法，所以HashTable是线程安全的。

ConcurrentHashMap的实现机制

1）ConcurrentHashMap通过synchronized关键字和CAS操作实现线程安全，若插入的槽没有数据，使用CAS操作执行插入操作，若插入的槽有数据，通过synchronized锁住链表的头节点，从而实现效率与线程安全的平衡

8.介绍数据库连接池的实现方式。如何从连接池中获取连接、将连接放回连接池？使用连接池的优势是什么？列举一下自己用过的连接池。

连接池实现原理：

1.用户给servlet发送请求，请求Dao要Connection

2.Dao从“连接池”中取出Connection资源，与DB的通讯

3.当用户离开之后，释放该Connection,那么该Connection被释放到连接池中，等待下一个用户来

Demo目标:

通过简单的增删改查来做到下面几个关于连接池的方式，让我们更了解几种优化的方式

1.自定义一个Pool,来实现类似于现在开源连接池为我们做的一些操作

2.使用Tomcat内置的连接池（apache dbcp）

3.使用DBCP数据库连接池

4.使用C3P0数据库连接池（推荐）

数据库连接池技术带来的优势：

1． 资源重用

由于数据库连接得到重用，避免了频繁创建、释放连接引起的大量性能开销。在减少系统消耗的基础上，另一方面也增进了系统运行环境的平稳性（减少内存碎片以及数据库临时进程/线程的数量）。

2． 更快的系统响应速度

数据库连接池在初始化过程中，往往已经创建了若干数据库连接置于池中备用。此时连接的初始化工作均已完成。对于业务请求处理而言，直接利用现有可用连接，避免了数据库连接初始化和释放过程的时间开销，从而缩减了系统整体响应时间。

3． 新的资源分配手段

对于多应用共享同一数据库的系统而言，可在应用层通过数据库连接的配置，实现数据库连接池技术，几年钱也许还是个新鲜话题，对于目前的业务系统而言，如果设计中还没有考虑到连接池的应用，那么…….快在设计文档中加上这部分的内容吧。某一应用最大可用数据库连接数的限制，避免某一应用独占所有数据库资源。

4． 统一的连接管理，避免数据库连接泄漏

在较为完备的数据库连接池实现中，可根据预先的连接占用超时设定，强制收回被占用连接。从而避免了常规数据库连接操作中可能出现的资源泄漏。一个最小化的数据库连接池实现：

9.什么是死锁？JAVA程序中什么情况下回出现死锁？如何避免出现死锁？

死锁是一种特定的程序状态，在实体之间，由于循环依赖导致彼此一直处于等待之中，没有任何个体可以继续前进。死锁不仅仅会发生在线程之间，存在资源独占的进程之间同样也可能出现死锁。通常来说，我们大多是聚焦在多线程场景中的死锁，指两个或多个线程之间，由于互相持有对方需要的锁，而永久处于阻塞的状态。

基本上死锁的发生是因为：互斥条件，类似Java中Monitor都是独占的，要么是我用，要么是你用。互斥条件是长期持有的，在使用结束之前，自己不会释放，也不能被其它线程抢占。循环依赖关系，两个或者多个个体之间出现了锁的链条环。免死锁的思路和方法。****1、如果可能的话，尽量避免使用多个锁，并且只有需要时才持有锁。2、如果必须使用多个锁，尽量设计好锁的获取顺序。

3、使用带超时的方法，为程序带来更多可控性

10. 分布式锁有几种实现方式，并介绍每种方式的优缺点。

分布式锁一般有三种实现方式：
1、 数据库锁
2、基于Redis的分布式锁
3、基于ZooKeeper的分布式锁

11. 什么是TCP粘包拆包？为什么会出现粘包拆包？如何在应用层面解决此问题？

​ 如果客户端连续不断的向服务端发送数据包时，服务端接收的数据会出现两个数据包粘在一起的情况，这就是TCP协议中经常会遇到的粘包以及拆包的问题。

1、TCP是基于字节流的，虽然应用层和传输层之间的数据交互是大小不等的数据块，但是TCP把这些数据块仅仅看成一连串无结构的字节流，没有边界；

2、在TCP的首部没有表示数据长度的字段，

基于上面两点，在使用TCP传输数据时，才有粘包或者拆包现象发生的可能。

解决

1、发送端给每个数据包添加包首部，首部中应该至少包含数据包的长度，这样接收端在接收到数据后，通过读取包首部的长度字段，便知道每一个数据包的实际长度了。
2、发送端将每个数据包封装为固定长度（不够的可以通过补0填充），这样接收端每次从接收缓冲区中读取固定长度的数据就自然而然的把每个数据包拆分开来。
3、可以在数据包之间设置边界，如添加特殊符号，这样，接收端通过这个边界就可以将不同的数据包拆分开。

12 请大致描述一下BIO，AIO和NIO的区别？

BIO：同步阻塞式IO，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。
NIO：同步非阻塞式IO，服务器实现模式为一个请求一个线程，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。
AIO：异步非阻塞式IO，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理。

13 在JAVA语法中加载类的的方式有哪些？

1、创建类的实例（开辟地址空间）

2、访问某个静态类或接口的静态常量，或者对该静态变量赋值（类初始化）

3、调用类的静态访问（new，也会占用空间）

4、反射（类初始化）

5、初始化一个类的子类（继承）

6、JAVA虚拟机启动被称标明为启动类的类

7、调用某个 ClassLoader 实例的 loadClass() 方法（类不会初始化）

14 建立三个线程A、B、C，A线程打印10次字母A，B线程打印10次字母B,C线程打印10次字母C，但是要求三个线程同时运行，并且实现交替打印，即按照ABCABCABC的顺序打印。

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
package com.yuewen;

import java.util.Scanner;
import java.util.concurrent.locks.LockSupport;
public class ABC {
    static Thread A, B, C;

    public static void main(String[] args) {
        A = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                LockSupport.park();
                System.out.print("A");
                LockSupport.unpark(B);
            }
        });
        B = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                LockSupport.park();
                System.out.print("B");
                LockSupport.unpark(C);
            }
        });
        C = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                LockSupport.unpark(A);
                LockSupport.park();
                System.out.print("C");
            }
        });
        A.start();
        B.start();
        C.start();
    }
}

15 请列举5个spring框架中的注解，并说明注解的用法以及使用场景

16 给定一组自然数，数字的值有可能会大于2^64 ，要求计算出所有数字的和

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
import org.junit.Test;

import java.util.ArrayList;

public class Solution {

    /**
     * 计算一组数字的和
     * @param numbers string字符串ArrayList 一组自然数
     * @return string字符串
     */
    public String sum (ArrayList<String> numbers) {
        // write code here

        String result="0";
        for (String number : numbers) {

            if(number==null||number.length()==0){
                continue;
            }
            int resultLen = result.length();
            int curNumLen = number.length();
            int sum=0;
            int remain;
            StringBuilder stringBuilder = new StringBuilder();
            while (resultLen>0||curNumLen>0){

                int resultNum=0;
                if(resultLen>0){
                    resultNum = result.charAt(--resultLen) - '0';
                }

                int curNum=0;
                if(curNumLen>0){
                    curNum = number.charAt(--curNumLen) - '0';
                }

                sum=sum+resultNum+curNum;
                remain=sum%10;
                stringBuilder.append(remain);
                sum/=10;
            }

            if(sum!=0){
                stringBuilder.append(sum);
            }
            result=stringBuilder.reverse().toString();


        }

        return result;
    }

    @Test
    public void test(){

        String num1="123456";
        String num2="123456789";
        String num3="123456789123";
        ArrayList<String> strings = new ArrayList<>();
        strings.add(num1);
        strings.add(num2);
        strings.add(num3);
        System.out.println(sum(strings));
    }
}

17 给定一个int数字 要求计算出int数字对应的二进制中1的个数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.yuewen;

import java.util.Scanner;

public class Erjinzhi {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int ans = 0;
        while (n > 0){
            n = n & (n-1);
            ans++;
        }
        System.out.println(ans);
    }

}

18 根据产品策略某本书可以设置包月到期时间，需要计算指定时间到包月到期时间还有多少分钟,不足60S的不计入。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public static String dateSub(String a, String b) {
    try {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        sdf.parse(a);
        LocalDateTime t1 =  LocalDateTime.parse(a, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")),
        t2 = LocalDateTime.parse(b, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        long pass = t1.until(t2, ChronoUnit.MINUTES);
        return String.valueOf(Math.abs(pass));
    } catch (Exception e) {
        System.out.println(String.format("格式转化错误：%s, 检查是否格式输入错误", e.getMessage()));
    }
    return "0";
}

public static void main(String[] args) {
    System.out.println("请输入指定的两个日期【小者在前，大者在后，格式：yyyy-MM-dd hh:mm:ss】:");
    Scanner sc = new Scanner(System.in);
    String a = sc.nextLine(), b = sc.nextLine();
    sc.close();
    System.out.println(dateSub(a, b));
}

19 map是一种开发过程中经常使用的k-v数据结构，有个map保存了书名和书字数的关系，编写代码对map里面的书按照字数进行升序排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public static Map<String, Integer> sortMap(Map<String, Integer> map) {
    TreeMap<Integer, List<String>> treeMap = new TreeMap<>();
    map.entrySet().forEach(entry -> {
        List<String> indexList = treeMap.computeIfAbsent(entry.getValue(), k -> new ArrayList<>());
        indexList.add(entry.getKey());
    });
    Map<String, Integer> result = new ListOrderedMap();
    treeMap.entrySet().forEach(entry -> {
        entry.getValue().forEach(key -> result.put(key, map.get(key)));
    });
    return result;
}

public static Map<String, Integer> sortMap2(Map<String, Integer> map) {
    Map result = new ListOrderedMap();
    map.entrySet().stream().
            sorted(Map.Entry.comparingByValue()).
            forEachOrdered(entry -> result.put(entry.getKey(), entry.getValue()));

    return result;
}


20 起点APP上允许用户对作品进行评论，为了防止用户恶意评论，发表不当内容，需要对用户发布的内容进行过滤，请写程序过滤用户发布内容中带有的QQ号（6~10位数字组成） 允许对内容严格操作，如用户发表了 作者大大666666，为你点赞 ，经过过滤后也可以为作者大大****，为你点赞 ，将666666过滤掉了。

把6-10位的数字替换成””;

1
2
3
public static String filterQQ(String s) {
    return s.replaceAll("\\d{6,10}","");
}

21 质数(又称素数),是指在大于1的自然数中,除了1和它本身外,不能被其他自然数整除(除0以外)的数称之为素数(质数)。请写个程序判断输入的数字是否是质数，如果是素数请输出：true，不是请输出false

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

public class IsPrimeDemo {
    public static boolean isPrime(int n){
        if (n < 1){
            return false;
        }
        int i = 2;
        int end = (int) Math.sqrt(n);
        while (i <= end ){
            if (n % i == 0){
                return false;
            }
            ++i;
        }
        return true;
    }

    public static void main(String[] args) {
        int n = 7;
        System.out.println(isPrime(n));
    }
}

22 有 n 个台阶，你一次能走 1 个或者 2 个台阶，那么请问，走完这 n 个台阶共有几种方式？

经典爬楼梯问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com.yuewen;

import java.util.Scanner;

public class ZouTaiJie {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[] dp = new int[n];
        int i = 2;
        dp[0] = 1;
        dp[1] = 2;
        while (i < n)
        {
            dp[i] = dp[i-1] + dp[i-2];
            i++;
        }
        System.out.println(dp[n-1]);
    }

}

23 给定一个字符串，返回这个字符串中有多少个回文子串。两个相同的回文子串出现在不同的位置，认为是2个回文子串。a、aa、aaa、aba、aabaa、abcba均认为是回文子串。

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
import java.util.*;


public class Solution {
  /**
   * 
   * @param str string字符串 
   * @return int整型
   */
  public int palindromeCount (String str) {
    int ans = 0;
    for (int center = 0; center < str.length(); center++) {
      ans += expand(str, center, center) + expand(str, center, center + 1);
    }
    return ans;
  }

  private int expand(String str, int left, int right) {
    int ans = 0;
    while (left >= 0 && right < str.length() && str.charAt(left) == str.charAt(right)) {
      ans++;
      left--;
      right++;
    }
    return ans;
  }
}

24 将一个给定的单链表反转，例：1-2-3-4-5，反转为5-4-3-2-1

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
import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param head ListNode类 
     * @return ListNode类
     */
    public ListNode reverseList (ListNode head) {
       ListNode pre = null, post = head, tmp;
        while (post != null) {
            tmp = post.next;//临时工具人结点
            post.next = pre;//反转
            pre = post;//pre进1
            post = tmp;//post进1
        }
        return pre;
    }
}

25 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

例：图中给定树 {3,5,1,6,2,0,8,#,#,7,4} 中，节点6、节点4的最近公共祖先为5。

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
import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
  /**
   * 
   * @param root TreeNode类 
   * @param p TreeNode类 
   * @param q TreeNode类 
   * @return TreeNode类
  */
  public TreeNode nearestCommonAncestor (TreeNode root, TreeNode p, TreeNode q) {
    if (root == null) {
      return null;
    }
    if (root.val == p.val || root.val == q.val) {
      return root;
    }
    TreeNode leftAns = nearestCommonAncestor(root.left, p, q), 
    rightAns = nearestCommonAncestor(root.right, p, q);
    if (leftAns != null && rightAns != null) {
      return root;
    }
    return leftAns != null ? leftAns : rightAns;
  }
}

26 给定一个递增排序的数组，查找某个数字是否在数组中，如果在数组中，则返回该数字在数组中第一次出现的位置（从0开始）；如果不在数组中，返回-1 。不需要考虑给定的数组不是递增的情况。务必使用二分查找的方式。

好像是错误的！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
int binarySearch(int* arr, int arrLen, int a) {
       // write code here
       int left = 0;
       int right = arrLen-1;
       int mid = 0;
       while(left<=right)
       {
           mid = (left+right)/2;
           if(arr[mid]==a)
           {
               if(arr[mid-1]!=a)
                   return mid;
               else
                   return mid-1;
           }        
           else if(arr[mid]>a)
               right = mid - 1;
           else
               left = mid + 1;
       }  
       return -1;
   }

27 请编写程序实现矩阵的乘法

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
import java.util.*;
public class Main {
        private static int[][] matrixMuilty(int[][] a, int[][] b) {
            int m = a.length, p = b.length, n = b[0].length;
            int[][] res = new int[m][n];
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < n; j++) {
                    for (int k = 0; k < p; k++) {
                        res[i][j] += a[i][k] * b[k][j];
                    }
                }
            }
            return res;
        }

        //输入三个整数，分别表示：第一个矩阵的 行 列【也就是第二个矩阵的行】 第二个矩阵的列
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            String s = sc.nextLine();
            String[] ss = s.split(",");
            int m = Integer.parseInt(ss[0]), p = Integer.parseInt(ss[1]), n = Integer.parseInt(ss[2]);
            if (m == 0 || p == 0 || n == 0) {
                sc.close();
                return;
            }
            int[][] a = new int[m][p];
            int[][] b = new int[p][n];
            for (int i = 0; i < m; i++) {
                s = sc.nextLine();
                ss = s.split(",");
                for (int j = 0; j < p; j++) {
                    a[i][j] = Integer.parseInt(ss[j]);
                }
            }
            for (int i = 0; i < p; i++) {
                s = sc.nextLine();
                ss = s.split(",");
                for (int j = 0; j < n; j++) {
                    b[i][j] = Integer.parseInt(ss[j]);
                }
            }
            sc.close();
            int[][] res = matrixMuilty(a, b);
            for (int i = 0; i < m; i++) {
                StringBuilder sb = new StringBuilder();
                for (int j = 0; j < n; j++) {
                    sb.append(res[i][j]).append(",");
                }
                System.out.println(sb.substring(0, sb.length() - 1));
            }
        }
    }

28 求出一个正整数转换成二进制后的数字“1”的个数。

例：数字23转为二进制为 10111，其中1的个数为4

1
2
3
4
5
public static int binaryTo(int num) { int sum = 0;  while (num > 0) {
        sum += num % 2;
        num = num / 2;
    } return sum;
}

29 去除字符串中的重复字符，对于出现超过2次（包含2次）的字符，只保留第一个。

例：输入abcbdde，输出abcde。

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
import java.util.*;


public class Solution {
    /**
     * 
     * @param str string字符串 
     * @return string字符串
     */
    public String removeDuplicatedChars (String str) {
        // write code here
        boolean[] isExistChar = new boolean[26];
        boolean[] isExistNum = new boolean[10];
        char[] chars = str.toCharArray();
        StringBuilder sb = new StringBuilder();
        for (char c : chars) {
            //是字母
            if(c >= 'a' && c <= 'z'){
                if(!isExistChar[c - 'a']){
                    sb.append(c);
                    isExistChar[c - 'a'] = true;
                }    
            }
            //是数字
            if(c >= '0' && c <= '9'){
                if(!isExistNum[c - '0']){
                    sb.append(c);
                    isExistNum[c - '0'] = true;
                }
            }
        }
        return sb.toString();
    }
}

30 给定一个整型数组，移除数组的某个元素使其剩下的元素乘积最大，如果数组出现相同的元素 ，请输出第一次出现的元素

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 class Main {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    String[] nums = scanner.next().split(",");
    int n = nums.length;
    // dp[i] -> 除 nums[i] 以外的其余所有元素的乘积
    BigDecimal[] dp = new BigDecimal[n];
    dp[0] = BigDecimal.valueOf(1);
    for (int i = 1; i < n; i++) {
      dp[i] = dp[i - 1].multiply(BigDecimal.valueOf(Integer.parseInt(nums[i - 1])));
    }
    BigDecimal temp = BigDecimal.valueOf(1);
    for (int i = n - 1; i >= 0; i--) {
      dp[i] = dp[i].multiply(temp);
      temp = temp.multiply(BigDecimal.valueOf(Integer.parseInt(nums[i])));
    }
    BigDecimal max = dp[0];
    int idx = 0;
    for (int i = 1; i < n; i++) {
      if (dp[i].compareTo(max) > 0) {
        max = dp[i];
        idx = i;
      }
    }
    System.out.println(idx);
  }
}

31 给定一个整型正方形矩阵 Matrix，请把该矩阵调整成顺时针旋转90度的样子。

1
2
3
4
5
6
7
8
9
10
11
12
public static int[][] rotationMatrix(int[][] matrix) {
    if (matrix != null && matrix.length > 0 && matrix.length == matrix[0].length) {
        int[][] result = new int[matrix.length][matrix.length];
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                result[i][j] = matrix[matrix.length - j - 1][i];
            }
        }
        return result;
    }
    return null;
}

32 在字符串中找到第一个不重复的字符。

例：对于字符串“hellohehe”，第一个不重复的字符是“o”。如果每个字符都有重复，则抛出运行时异常。

1
2
3
4
5
6
7
8
9
10
11
12
public char findFirstNonRepeatChar (String str) {
        int[] map = new int[128];
        for (char c: str.toCharArray()) {
            map[c]++;
        }
        for (char c: str.toCharArray()) {
            if (map[c] == 1) {
                return c;
            }
        }
        throw new RuntimeException("没有只有一个的字符");
    }

33.假设有N个用户，其中有些人是朋友，有些则不是。A和B是朋友，B和C是朋友，这样ABC就是一个朋友圈，请计算给定的朋友关系的朋友圈数。

给定一个 N * N 的矩阵 M，表示用户之间的朋友关系。如果M[i][j] = 1，表示已知第 i 个和 j 个人互为朋友关系，否则为不知道。你必须输出所有用户中的已知的朋友圈总数。

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
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
public class Main {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int n = scanner.nextInt();
    String[][] relations = new String[n][n];
    for (int i = 0; i < n; i++) {
      relations[i] = scanner.next().split(",");
    }
    scanner.close();
    System.out.println(friendCircle(relations));
  }
  private static int friendCircle(String[][] relations) {
    int n = relations.length;
    // graph[i] -> 用户 i 的所有朋友
    Set[] graph = new HashSet[n];
    for (int i = 0; i < n; i++) {
      graph[i] = new HashSet();
      for (int j = 0; j < n; j++) {
        int relation = Integer.parseInt(relations[i][j]);
        if (relation == 1) {
          graph[i].add(j);
        }
      }
    }
    int ans = 0;
    boolean[] visited = new boolean[n];
    for (int i = 0; i < n; i++) {
      if (!visited[i]) {
        ans++;
        dfs(graph, i, visited);
      }
    }
    return ans;
  }
  private static void dfs(Set[] graph, int cur, boolean[] visited) {
    visited[cur] = true;
    for (int next : graph[cur]) {
      if (!visited[next]) {
        dfs(graph, next, visited);
      }
    }
  }
}

34 假设有个文件，文件的每一行是书信息数据，分4个部分用逗号（,）进行分割,格式如下

id,category,words,updatetime

id 表示书id，long类型，id不重复；

category 表示书的分类，int类型，请注意全部数据的分类只有几个

words 表示书的字数，int类型

updatetime 表示书的更新时间 ，格式为2020-02-01 23:00:00

请编写程序对文件数据进行排序后输出id，排序优先级为： category>updatetime > words > id , 增序排序

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
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.Scanner;

public class Main {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int n = scanner.nextInt();
    Book[] books = new Book[n];
    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    for (int i = 0; i < n; i++) {
      String[] row = scanner.next().split(",");
      try {
        String updateTime = row[3] + " " + scanner.next();
        Book book =
            new Book(
                Long.parseLong(row[0]),
                Integer.parseInt(row[1]),
                Integer.parseInt(row[2]),
                dateFormat.parse(updateTime));
        books[i] = book;
      } catch (ParseException e) {
        e.printStackTrace();
      }
    }
    scanner.close();
    // 升序排列。字段优先级：category > updateTime > words > id
    Arrays.sort(books, (book1, book2) -> {
      if (book1.getCategory() != book2.getCategory()) {
        return book1.getCategory() - book2.getCategory();
      }
      long update1 = book1.getUpdateTime().getTime(), update2 = book2.getUpdateTime().getTime();
      if (update1 != update2) {
        return (int) (update1 - update2);
      }
      if (book1.getWords() != book2.getWords()) {
        return book1.getWords() - book2.getWords();
      }
      return (int) (book1.getId() - book2.getId());
    });
    for (int i = 0; i < n; i++) {
      System.out.println(books[i].getId());
    }
  }
}

class Book {
  private final long id;
  private final int category;
  private final int words;
  private final Date updateTime;

  public Book(long id, int category, int words, Date updateTime) {
    this.id = id;
    this.category = category;
    this.words = words;
    this.updateTime = updateTime;
  }

  public long getId() {
    return this.id;
  }

  public int getCategory() {
    return this.category;
  }

  public int getWords() {
    return this.words;
  }

  public Date getUpdateTime() {
    return this.updateTime;
  }
}

35请使用堆栈这一个数据结构实现简单FIFO（先入先出）队列，队列要实现两个方法： push、pop。

为自动测试方便，使用每行输入模拟操作：

1） push 1 表明向队列里面新增一个元素 1 , push 和元素之间用空格表示；

2） pop 表明输出当前队列里面的第一个元素，如果当前队列为空请输出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
static class MyQueue {
    int[] queue;
    int lo, hi, size, capacity;

    public MyQueue(int n) {
        this.lo = this.hi = this.size = 0;
        this.capacity = n;
        this.queue = new int[n];
    }

    public MyQueue() {
        this(10);
    }

    public void push(int val) {
        if (hi == capacity) {
            if (lo > 0) {
                int idx = 0;
                for (int i = lo; i < hi; i++) {
                    queue[idx++] = queue[i];
                }
                lo = 0;
                hi = idx;
            } else {
                //扩容
                int[] newQueue = new int[capacity * 2];
                System.arraycopy(queue, 0, newQueue, 0, capacity);
                this.queue = newQueue;
            }
        }
        this.queue[hi++] = val;
    }

    public int pop() {
        if (lo == hi) return -1;
        else {
            return this.queue[lo++];
        }
    }

}

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    // int[] nums = Arrays.stream().mapToInt(Integer::parseInt).toArray();
    String[] ss = scanner.nextLine().split(",");
    YuewenJavaTest.MyQueue myQueue = new YuewenJavaTest.MyQueue();
    for (String s: ss) {
        if (s.startsWith("push")) {
            myQueue.push(Integer.parseInt(s.split(" ")[1]));
        } else {
            System.out.println(myQueue.pop());
        }
    }

    scanner.close();
}

36 在和外部公司联调HTTP接口时，对方要求调用的接口需要计算token，给到的规则如下：

1） 所有的参数值必须经过urlencode,编码为utf-8；

2） 对编码后数据按照key值进行字典升序排序；

3）将所有的参数按照排序的顺序拼接成字符串 ，格式如下: k1=v1&k2=v2&k3=v3;

\4) 将第三步的算出的值计算md5值，md5加密的值小写

请你编写一段方法计算token值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public String getToken(Map<String, String> params) {
    List<String> ss = params.keySet().stream().sorted().map(
        k -> {
            String v = params.get(k);
            String kv = null;
            try {
                kv = k + "=" + URLEncoder.encode(v, "utf-8");
            } catch (Exception e) {

            }
            return kv;
        }
    ).collect(Collectors.toList());
    String token = null;
    try {
        token = new String(MessageDigest.getInstance("md5").digest(String.join("&", ss).getBytes()));
    } catch (Exception e) {
    }
    return token;
}
]]> @@ -356,13 +356,13 @@ 2022-04-06T12:27:56.513Z 2022-04-06T12:28:18.055Z - 题干

1
2
3
4
5
6
秋天快到啦，天气慢慢凉爽了下来，所以实验室要组织去骊山进行一次野餐活动。

最底层的Lofipure被迫背背包给大家装各种零食，但是实验室的大佬们并不打算轻易放过Lofipure，他们打算把Lofipure的背包装的尽量满

现在知道Lofipure的背包容量为 V（正整数，0 <= V <= 20000），同时有 n 件小零食（0＜n<=30），每个小零食的重量。
现在在 n 个小零食中，任取若干个装入Lofipure的背包内，使得Lofipure背包的剩余空间为最小。借此达到压榨Lofipure的目的。

Input

输入：一个整数v，表示背包容量 一个整数n，表示有n个物品 接下来 n 个整数，分别表示这 n 个物品的各自体积

Output

输出：一个整数，表示背包最小的剩余空间

Sample Input

1
2
3
4
5
6
7
8
24
6
8
3
12
7
9
7

Sample Output

1
0

看到这道理的第一时刻想的是暴力枚举出所有零食混合装的重量 可复杂度太高 遂放弃。

然后看了一下大佬们的代码

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
#include<bits/stdc++.h>
#define int long long
#define MAXN 1000005
using namespace std;
int dp[20005];
signed main()
{
    dp[0]=1;
    int v,n;cin>>v>>n;
    for(int i=1;i<=n;i++)
    {
        int t;cin>>t;
        for(int j=v;j>=t;j--)
            dp[j]|=dp[j-t];
    }
    for(int i=v;i>=0;i--)
    {
        if(dp[i])
        {
            cout<<v-i<<endl;
            return 0;
        }
    }
}

刚开始我用Java实现的时候，

1
2
3
4
5
6
7
8
9

后面经过自己  ~~人眼比对~~ 发现这个错误  发现之后感到不解。

```dp [j]|=dp[j-t]```这个式子用来干嘛的呢

后面经过输出

```java
System.out.println(j+" "+(j-t)+" "+dp[j]+" "+dp[j - t]);

形式一下子就清楚了 dp是为了统计零食能够组成的重量

拿本题例子来说

输入 t = 8 时 只有dp[8] = dp[8] | dp[0] 才变成1 这代表着能够组成8的重量

输入 t = 3 时 有了dp[11] = dp[11] | dp[11 - 3] dp[3] = dp[3] | dp[0] 这次增加 11（8+3） 3(3+0)l两种可能

输入t = 12时 有dp[23] = 1 ,dp[20] = 1 dp[15] =1 dp[12] = 1

输入t = 7时 有 dp[22] = 1,dp[22] = 1 dp[19] = 1 dp[18] = 1 dp[15] = 1 dp[10] = 1

。。。。

到最后会使所有能够凑出重量的dp数都为1

从最大的量递减便利 当dp[i] 不为0 时 也就是为1 代表着这是能够装载着最大的重量 直接输出V-i

感叹算法的奇妙与精彩，只恨自己接触晚与学校氛围不好，蹉跎了许久时光。

JAVA版代码

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
package com.VG;

import java.util.Arrays;
import java.util.Scanner;

public class C {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int V = scanner.nextInt();
        int N = scanner.nextInt();
        int[] dp = new int[200005];
        dp[0] = 1;
        for (int i = 1; i <= N; i++) {
            int t = scanner.nextInt();
            for (int j = V; j >=t ; j--) {
                dp[j] |= dp[j - t];
                System.out.println(j+" "+(j-t)+" "+dp[j]+" "+dp[j - t]);
            }
        }
        for (int i = V; i >= 0 ; i--) {
            if(dp[i]!=0)
            {
                System.out.println(V- i);
                return;
            }
        }

    }
}

]]> + 题干

1
2
3
4
5
6
秋天快到啦，天气慢慢凉爽了下来，所以实验室要组织去骊山进行一次野餐活动。

最底层的Lofipure被迫背背包给大家装各种零食，但是实验室的大佬们并不打算轻易放过Lofipure，他们打算把Lofipure的背包装的尽量满

现在知道Lofipure的背包容量为 V（正整数，0 <= V <= 20000），同时有 n 件小零食（0＜n<=30），每个小零食的重量。
现在在 n 个小零食中，任取若干个装入Lofipure的背包内，使得Lofipure背包的剩余空间为最小。借此达到压榨Lofipure的目的。

Input

输入：一个整数v，表示背包容量 一个整数n，表示有n个物品 接下来 n 个整数，分别表示这 n 个物品的各自体积

Output

输出：一个整数，表示背包最小的剩余空间

Sample Input

1
2
3
4
5
6
7
8
24
6
8
3
12
7
9
7

Sample Output

1
0

看到这道理的第一时刻想的是暴力枚举出所有零食混合装的重量 可复杂度太高 遂放弃。

然后看了一下大佬们的代码

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
#include<bits/stdc++.h>
#define int long long
#define MAXN 1000005
using namespace std;
int dp[20005];
signed main()
{
    dp[0]=1;
    int v,n;cin>>v>>n;
    for(int i=1;i<=n;i++)
    {
        int t;cin>>t;
        for(int j=v;j>=t;j--)
            dp[j]|=dp[j-t];
    }
    for(int i=v;i>=0;i--)
    {
        if(dp[i])
        {
            cout<<v-i<<endl;
            return 0;
        }
    }
}

刚开始我用Java实现的时候，

1
2
3
4
5
6
7
8
9

后面经过自己  ~~人眼比对~~ 发现这个错误  发现之后感到不解。

```dp [j]|=dp[j-t]```这个式子用来干嘛的呢

后面经过输出

```java
System.out.println(j+" "+(j-t)+" "+dp[j]+" "+dp[j - t]);

形式一下子就清楚了 dp是为了统计零食能够组成的重量

拿本题例子来说

输入 t = 8 时 只有dp[8] = dp[8] | dp[0] 才变成1 这代表着能够组成8的重量

输入 t = 3 时 有了dp[11] = dp[11] | dp[11 - 3] dp[3] = dp[3] | dp[0] 这次增加 11（8+3） 3(3+0)l两种可能

输入t = 12时 有dp[23] = 1 ,dp[20] = 1 dp[15] =1 dp[12] = 1

输入t = 7时 有 dp[22] = 1,dp[22] = 1 dp[19] = 1 dp[18] = 1 dp[15] = 1 dp[10] = 1

。。。。

到最后会使所有能够凑出重量的dp数都为1

从最大的量递减便利 当dp[i] 不为0 时 也就是为1 代表着这是能够装载着最大的重量 直接输出V-i

感叹算法的奇妙与精彩，只恨自己接触晚与学校氛围不好，蹉跎了许久时光。

JAVA版代码

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
package com.VG;

import java.util.Arrays;
import java.util.Scanner;

public class C {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int V = scanner.nextInt();
        int N = scanner.nextInt();
        int[] dp = new int[200005];
        dp[0] = 1;
        for (int i = 1; i <= N; i++) {
            int t = scanner.nextInt();
            for (int j = V; j >=t ; j--) {
                dp[j] |= dp[j - t];
                System.out.println(j+" "+(j-t)+" "+dp[j]+" "+dp[j - t]);
            }
        }
        for (int i = V; i >= 0 ; i--) {
            if(dp[i]!=0)
            {
                System.out.println(V- i);
                return;
            }
        }

    }
}

]]> <p>题干</p> -<figure class="highlight excel"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br>< +<figure class="highlight plaintext"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span>< @@ -379,7 +379,7 @@ 2022-04-03T06:44:18.118Z 2022-04-03T09:33:29.183Z - AOP

什么是 AOP

面向切面编程（方面）， 利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

通俗描述：不通过修改源代码方式，在主干功能里面添加新功能。

AOP 底层使用动态代理

两种情况的动态代理

1
newProxyInstance(ClassLoader loader,类<?>[] interfaces,InvacationHandle)

方法有三个参数

第一个参数：类加载器

第二个参数：增加方法所在的类。

第三个参数：

]]> + AOP

什么是 AOP

面向切面编程（方面）， 利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

通俗描述：不通过修改源代码方式，在主干功能里面添加新功能。

AOP 底层使用动态代理

两种情况的动态代理

1
newProxyInstance(ClassLoader loader,类<?>[] interfaces,InvacationHandle)

方法有三个参数

第一个参数：类加载器

第二个参数：增加方法所在的类。

第三个参数：

]]> @@ -401,7 +401,7 @@ 2022-04-02T13:32:25.724Z 2022-04-02T13:32:25.725Z - 回溯问题

解决一个回溯问题,实际上就是一个决策树的遍历过程，需要思考三个问题

回溯算法框架

1
2
3
4
5
6
7
8
9
10
result = []
def backtrack(路径, 选择列表):
    if 满足结束条件:
        result.add(路径)
        return
    
    for 选择 in 选择列表:
        做选择
        backtrack(路径, 选择列表)
        撤销选择

核心在于for循环里面的递归，在递归调用之前做选择，在递归调用之后撤销选择。

例子1 全排列问题

有n个数 每个数都只能用一次 求出所有能排列的可能性。全排列个数为n!个

PS：为了简单清晰起见，我们这次讨论的全排列问题不包含重复的数字。

如果已知有多少个数的情况下，我们通常可以使用n层for循环暴力遍历所有数

例如3个数 我们可以暴力写法为

1
2
3
4
5
6
7
8
9
10
11
12
13
for(int i = 0;i < n;i++)
    for(int j = 0;j < n;j++)
        for(int k = 0;k < n;k++)
        {
if(i!=j && i!=k && j!=k)
            {
                // 1 2 3   1 3 2   2 1 3   2 3 1  3 2 1  3 1 2
list.add(nums[i]);
                list.add(nums[j]);
                list.add(nums[k]);
                res.add(list);
            }
        }

回溯数如下图所示，只要从根遍历这棵树，记录路径下的数字，其实就是所有的全排列，我们不妨把这棵树称之为回溯算法的决策树

为什么叫决策树呢，顾名思义，每次遍历的时候都需要做决策来去避开那些已经走过的路。

现在可以解答开头的几个名词：[2] 就是「路径」，记录你已经做过的选择；[1,3] 就是「选择列表」，表示你当前可以做出的选择；「结束条件」就是遍历到树的底层，在这里就是选择列表为空的时候。

如果明白了这几个名词，可以把「路径」和「选择」列表作为决策树上每个节点的属性，比如下图列出了几个节点的属性：

我们定义的backtrack函数就是指针一样，在这棵树上游走，同时要正确维护每个节点的属性，每当走到树的底层，其路径就是一个全排列。

再进一步，如何遍历一颗树，

1
2
3
4
5
6
void traverse(TreeNode root) {
    for (TreeNode child : root.childern)
        // 前序遍历需要的操作
        traverse(child);
        // 后序遍历需要的操作
}

前序遍历的代码在进入某一个节点之前的那个时间点执行，后序遍历代码在离开某个节点之后的那个时间点执行。

回想我们刚才说的，「路径」和「选择」是每个节点的属性，函数在树上游走要正确维护节点的属性，那么就要在这两个特殊时间点搞点动作：

回溯代码核心框架

1
2
3
4
5
6
7
8
9
for 选择 in 选择列表:
    # 做选择
    将该选择从选择列表移除
    路径.add(选择)
    backtrack(路径, 选择列表)
    # 撤销选择
    路径.remove(选择)
    将该选择再加入选择列表

我们只要在递归之前做出选择，在递归之后撤销自己的选择，就能得到每个节点的选择路径和列表。

全排列代码

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
List<List<Integer>> res = new LinkedList<>();

/* 主函数，输入一组不重复的数字，返回它们的全排列 */
List<List<Integer>> permute(int[] nums) {
    // 记录「路径」
    LinkedList<Integer> track = new LinkedList<>();
    backtrack(nums, track);
    return res;
}

// 路径：记录在 track 中
// 选择列表：nums 中不存在于 track 的那些元素
// 结束条件：nums 中的元素全都在 track 中出现
void backtrack(int[] nums, LinkedList<Integer> track) {
    // 触发结束条件
    if (track.size() == nums.length) {
        res.add(new LinkedList(track));
        return;
    }
    
    for (int i = 0; i < nums.length; i++) {
        // 排除不合法的选择
        if (track.contains(nums[i]))
            continue;
        // 做选择
        track.add(nums[i]);
        // 进入下一层决策树
        backtrack(nums, track);
        // 取消选择
        track.removeLast();
    }
}

我们这里稍微做了些变通，没有显式记录「选择列表」，而是通过 nums 和 track 推导出当前的选择列表：

通过contains函数来判断该数是否已经被使用。

至此，我们就通过全排列问题详解了回溯算法的底层原理。当然，这个算法解决全排列不是很高效，应为对链表使用 contains 方法需要 O(N) 的时间复杂度。有更好的方法通过交换元素达到目的，但是难理解一些，这里就不写了，有兴趣可以自行搜索一下。

但是必须说明的是，不管怎么优化，都符合回溯框架，而且时间复杂度都不可能低于 O(N!)，因为穷举整棵决策树是无法避免的。这也是回溯算法的一个特点，不像动态规划存在重叠子问题可以优化，回溯算法就是纯暴力穷举，复杂度一般都很高。

明白了全排列问题，就可以直接套回溯算法框架了，下面简单看看 N 皇后问题。

例子2 N皇后问题

题意

给你一个N*N的棋盘，，让你放置 N 个皇后，使得它们不能互相攻击。

PS：皇后可以攻击同一行、同一列、左上左下右上右下四个方向的任意单位。

这个问题本质上跟全排列问题差不多，决策树的每一层表示棋盘上的每一行；每个节点可以做出的选择是，在该行的任意一列放置一个皇后。

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
vector<vector<string>> res;

/* 输入棋盘边长 n，返回所有合法的放置 */
vector<vector<string>> solveNQueens(int n) {
    // '.' 表示空，'Q' 表示皇后，初始化空棋盘。
    vector<string> board(n, string(n, '.'));
    backtrack(board, 0);
    return res;
}

// 路径：board 中小于 row 的那些行都已经成功放置了皇后
// 选择列表：第 row 行的所有列都是放置皇后的选择
// 结束条件：row 超过 board 的最后一行
void backtrack(vector<string>& board, int row) {
    // 触发结束条件
    if (row == board.size()) {
        res.push_back(board);
        return;
    }
    
    int n = board[row].size();
    for (int col = 0; col < n; col++) {
        // 排除不合法选择
        if (!isValid(board, row, col)) 
            continue;
        // 做选择
        board[row][col] = 'Q';
        // 进入下一行决策
        backtrack(board, row + 1);
        // 撤销选择
        board[row][col] = '.';
    }
}

IsValid()函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/* 是否可以在 board[row][col] 放置皇后？ */
bool isValid(vector<string>& board, int row, int col) {
    int n = board.size();
    // 检查列是否有皇后互相冲突
    for (int i = 0; i < n; i++) {
        if (board[i][col] == 'Q')
            return false;
    }
    // 检查右上方是否有皇后互相冲突
    for (int i = row - 1, j = col + 1; 
            i >= 0 && j < n; i--, j++) {
        if (board[i][j] == 'Q')
            return false;
    }
    // 检查左上方是否有皇后互相冲突
    for (int i = row - 1, j = col - 1;
            i >= 0 && j >= 0; i--, j--) {
        if (board[i][j] == 'Q')
            return false;
    }
    return true;
}

函数 backtrack 依然像个在决策树上游走的指针，通过 row 和 col 就可以表示函数遍历到的位置，通过 isValid 函数可以将不符合条件的情况剪枝：

某种程度上说，动态规划的暴力求解阶段就是回溯算法。只是有的问题具有重叠子问题性质，可以用 dp table 或者备忘录优化，将递归树大幅剪枝，这就变成了动态规划。而今天的两个问题，都没有重叠子问题，也就是回溯算法问题了，复杂度非常高是不可避免的。

参考链接：https://leetcode-cn.com/problems/permutations/solution/hui-su-suan-fa-xiang-jie-by-labuladong-2/

]]> + 回溯问题

解决一个回溯问题,实际上就是一个决策树的遍历过程，需要思考三个问题

回溯算法框架

1
2
3
4
5
6
7
8
9
10
result = []
def backtrack(路径, 选择列表):
    if 满足结束条件:
        result.add(路径)
        return
    
    for 选择 in 选择列表:
        做选择
        backtrack(路径, 选择列表)
        撤销选择

核心在于for循环里面的递归，在递归调用之前做选择，在递归调用之后撤销选择。

例子1 全排列问题

有n个数 每个数都只能用一次 求出所有能排列的可能性。全排列个数为n!个

PS：为了简单清晰起见，我们这次讨论的全排列问题不包含重复的数字。

如果已知有多少个数的情况下，我们通常可以使用n层for循环暴力遍历所有数

例如3个数 我们可以暴力写法为

1
2
3
4
5
6
7
8
9
10
11
12
13
for(int i = 0;i < n;i++)
    for(int j = 0;j < n;j++)
        for(int k = 0;k < n;k++)
        {
if(i!=j && i!=k && j!=k)
            {
                // 1 2 3   1 3 2   2 1 3   2 3 1  3 2 1  3 1 2
list.add(nums[i]);
                list.add(nums[j]);
                list.add(nums[k]);
                res.add(list);
            }
        }

回溯数如下图所示，只要从根遍历这棵树，记录路径下的数字，其实就是所有的全排列，我们不妨把这棵树称之为回溯算法的决策树

为什么叫决策树呢，顾名思义，每次遍历的时候都需要做决策来去避开那些已经走过的路。

现在可以解答开头的几个名词：[2] 就是「路径」，记录你已经做过的选择；[1,3] 就是「选择列表」，表示你当前可以做出的选择；「结束条件」就是遍历到树的底层，在这里就是选择列表为空的时候。

如果明白了这几个名词，可以把「路径」和「选择」列表作为决策树上每个节点的属性，比如下图列出了几个节点的属性：

我们定义的backtrack函数就是指针一样，在这棵树上游走，同时要正确维护每个节点的属性，每当走到树的底层，其路径就是一个全排列。

再进一步，如何遍历一颗树，

1
2
3
4
5
6
void traverse(TreeNode root) {
    for (TreeNode child : root.childern)
        // 前序遍历需要的操作
        traverse(child);
        // 后序遍历需要的操作
}

前序遍历的代码在进入某一个节点之前的那个时间点执行，后序遍历代码在离开某个节点之后的那个时间点执行。

回想我们刚才说的，「路径」和「选择」是每个节点的属性，函数在树上游走要正确维护节点的属性，那么就要在这两个特殊时间点搞点动作：

回溯代码核心框架

1
2
3
4
5
6
7
8
9
for 选择 in 选择列表:
    # 做选择
    将该选择从选择列表移除
    路径.add(选择)
    backtrack(路径, 选择列表)
    # 撤销选择
    路径.remove(选择)
    将该选择再加入选择列表

我们只要在递归之前做出选择，在递归之后撤销自己的选择，就能得到每个节点的选择路径和列表。

全排列代码

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
List<List<Integer>> res = new LinkedList<>();

/* 主函数，输入一组不重复的数字，返回它们的全排列 */
List<List<Integer>> permute(int[] nums) {
    // 记录「路径」
    LinkedList<Integer> track = new LinkedList<>();
    backtrack(nums, track);
    return res;
}

// 路径：记录在 track 中
// 选择列表：nums 中不存在于 track 的那些元素
// 结束条件：nums 中的元素全都在 track 中出现
void backtrack(int[] nums, LinkedList<Integer> track) {
    // 触发结束条件
    if (track.size() == nums.length) {
        res.add(new LinkedList(track));
        return;
    }
    
    for (int i = 0; i < nums.length; i++) {
        // 排除不合法的选择
        if (track.contains(nums[i]))
            continue;
        // 做选择
        track.add(nums[i]);
        // 进入下一层决策树
        backtrack(nums, track);
        // 取消选择
        track.removeLast();
    }
}

我们这里稍微做了些变通，没有显式记录「选择列表」，而是通过 nums 和 track 推导出当前的选择列表：

通过contains函数来判断该数是否已经被使用。

至此，我们就通过全排列问题详解了回溯算法的底层原理。当然，这个算法解决全排列不是很高效，应为对链表使用 contains 方法需要 O(N) 的时间复杂度。有更好的方法通过交换元素达到目的，但是难理解一些，这里就不写了，有兴趣可以自行搜索一下。

但是必须说明的是，不管怎么优化，都符合回溯框架，而且时间复杂度都不可能低于 O(N!)，因为穷举整棵决策树是无法避免的。这也是回溯算法的一个特点，不像动态规划存在重叠子问题可以优化，回溯算法就是纯暴力穷举，复杂度一般都很高。

明白了全排列问题，就可以直接套回溯算法框架了，下面简单看看 N 皇后问题。

例子2 N皇后问题

题意

给你一个N*N的棋盘，，让你放置 N 个皇后，使得它们不能互相攻击。

PS：皇后可以攻击同一行、同一列、左上左下右上右下四个方向的任意单位。

这个问题本质上跟全排列问题差不多，决策树的每一层表示棋盘上的每一行；每个节点可以做出的选择是，在该行的任意一列放置一个皇后。

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
vector<vector<string>> res;

/* 输入棋盘边长 n，返回所有合法的放置 */
vector<vector<string>> solveNQueens(int n) {
    // '.' 表示空，'Q' 表示皇后，初始化空棋盘。
    vector<string> board(n, string(n, '.'));
    backtrack(board, 0);
    return res;
}

// 路径：board 中小于 row 的那些行都已经成功放置了皇后
// 选择列表：第 row 行的所有列都是放置皇后的选择
// 结束条件：row 超过 board 的最后一行
void backtrack(vector<string>& board, int row) {
    // 触发结束条件
    if (row == board.size()) {
        res.push_back(board);
        return;
    }
    
    int n = board[row].size();
    for (int col = 0; col < n; col++) {
        // 排除不合法选择
        if (!isValid(board, row, col)) 
            continue;
        // 做选择
        board[row][col] = 'Q';
        // 进入下一行决策
        backtrack(board, row + 1);
        // 撤销选择
        board[row][col] = '.';
    }
}

IsValid()函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/* 是否可以在 board[row][col] 放置皇后？ */
bool isValid(vector<string>& board, int row, int col) {
    int n = board.size();
    // 检查列是否有皇后互相冲突
    for (int i = 0; i < n; i++) {
        if (board[i][col] == 'Q')
            return false;
    }
    // 检查右上方是否有皇后互相冲突
    for (int i = row - 1, j = col + 1; 
            i >= 0 && j < n; i--, j++) {
        if (board[i][j] == 'Q')
            return false;
    }
    // 检查左上方是否有皇后互相冲突
    for (int i = row - 1, j = col - 1;
            i >= 0 && j >= 0; i--, j--) {
        if (board[i][j] == 'Q')
            return false;
    }
    return true;
}

函数 backtrack 依然像个在决策树上游走的指针，通过 row 和 col 就可以表示函数遍历到的位置，通过 isValid 函数可以将不符合条件的情况剪枝：

某种程度上说，动态规划的暴力求解阶段就是回溯算法。只是有的问题具有重叠子问题性质，可以用 dp table 或者备忘录优化，将递归树大幅剪枝，这就变成了动态规划。而今天的两个问题，都没有重叠子问题，也就是回溯算法问题了，复杂度非常高是不可避免的。

参考链接：https://leetcode-cn.com/problems/permutations/solution/hui-su-suan-fa-xiang-jie-by-labuladong-2/

]]> @@ -425,7 +425,7 @@ 2022-04-01T12:29:24.771Z 2022-04-02T11:58:36.671Z - 回溯问题

解决一个回溯问题,实际上就是一个决策树的遍历过程，需要思考三个问题

回溯算法框架

1
2
3
4
5
6
7
8
9
10
result = []
def backtrack(路径, 选择列表):
    if 满足结束条件:
        result.add(路径)
        return
    
    for 选择 in 选择列表:
        做选择
        backtrack(路径, 选择列表)
        撤销选择

核心在于for循环里面的递归，在递归调用之前做选择，在递归调用之后撤销选择。

例子1 全排列问题

有n个数 每个数都只能用一次 求出所有能排列的可能性。全排列个数为n!个

PS：为了简单清晰起见，我们这次讨论的全排列问题不包含重复的数字。

如果已知有多少个数的情况下，我们通常可以使用n层for循环暴力遍历所有数

例如3个数 我们可以暴力写法为

1
2
3
4
5
6
7
8
9
10
11
12
13
for(int i = 0;i < n;i++)
    for(int j = 0;j < n;j++)
        for(int k = 0;k < n;k++)
        {
if(i!=j && i!=k && j!=k)
            {
                // 1 2 3   1 3 2   2 1 3   2 3 1  3 2 1  3 1 2
list.add(nums[i]);
                list.add(nums[j]);
                list.add(nums[k]);
                res.add(list);
            }
        }

回溯数如下图所示，只要从根遍历这棵树，记录路径下的数字，其实就是所有的全排列，我们不妨把这棵树称之为回溯算法的决策树

为什么叫决策树呢，顾名思义，每次遍历的时候都需要做决策来去避开那些已经走过的路。

现在可以解答开头的几个名词：[2] 就是「路径」，记录你已经做过的选择；[1,3] 就是「选择列表」，表示你当前可以做出的选择；「结束条件」就是遍历到树的底层，在这里就是选择列表为空的时候。

如果明白了这几个名词，可以把「路径」和「选择」列表作为决策树上每个节点的属性，比如下图列出了几个节点的属性：

我们定义的backtrack函数就是指针一样，在这棵树上游走，同时要正确维护每个节点的属性，每当走到树的底层，其路径就是一个全排列。

再进一步，如何遍历一颗树，

1
2
3
4
5
6
void traverse(TreeNode root) {
    for (TreeNode child : root.childern)
        // 前序遍历需要的操作
        traverse(child);
        // 后序遍历需要的操作
}

前序遍历的代码在进入某一个节点之前的那个时间点执行，后序遍历代码在离开某个节点之后的那个时间点执行。

回想我们刚才说的，「路径」和「选择」是每个节点的属性，函数在树上游走要正确维护节点的属性，那么就要在这两个特殊时间点搞点动作：

回溯代码核心框架

1
2
3
4
5
6
7
8
9
for 选择 in 选择列表:
    # 做选择
    将该选择从选择列表移除
    路径.add(选择)
    backtrack(路径, 选择列表)
    # 撤销选择
    路径.remove(选择)
    将该选择再加入选择列表

我们只要在递归之前做出选择，在递归之后撤销自己的选择，就能得到每个节点的选择路径和列表。

全排列代码

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
List<List<Integer>> res = new LinkedList<>();

/* 主函数，输入一组不重复的数字，返回它们的全排列 */
List<List<Integer>> permute(int[] nums) {
    // 记录「路径」
    LinkedList<Integer> track = new LinkedList<>();
    backtrack(nums, track);
    return res;
}

// 路径：记录在 track 中
// 选择列表：nums 中不存在于 track 的那些元素
// 结束条件：nums 中的元素全都在 track 中出现
void backtrack(int[] nums, LinkedList<Integer> track) {
    // 触发结束条件
    if (track.size() == nums.length) {
        res.add(new LinkedList(track));
        return;
    }
    
    for (int i = 0; i < nums.length; i++) {
        // 排除不合法的选择
        if (track.contains(nums[i]))
            continue;
        // 做选择
        track.add(nums[i]);
        // 进入下一层决策树
        backtrack(nums, track);
        // 取消选择
        track.removeLast();
    }
}

我们这里稍微做了些变通，没有显式记录「选择列表」，而是通过 nums 和 track 推导出当前的选择列表：

通过contains函数来判断该数是否已经被使用。

至此，我们就通过全排列问题详解了回溯算法的底层原理。当然，这个算法解决全排列不是很高效，应为对链表使用 contains 方法需要 O(N) 的时间复杂度。有更好的方法通过交换元素达到目的，但是难理解一些，这里就不写了，有兴趣可以自行搜索一下。

但是必须说明的是，不管怎么优化，都符合回溯框架，而且时间复杂度都不可能低于 O(N!)，因为穷举整棵决策树是无法避免的。这也是回溯算法的一个特点，不像动态规划存在重叠子问题可以优化，回溯算法就是纯暴力穷举，复杂度一般都很高。

明白了全排列问题，就可以直接套回溯算法框架了，下面简单看看 N 皇后问题。

例子2 N皇后问题

题意

给你一个N*N的棋盘，，让你放置 N 个皇后，使得它们不能互相攻击。

PS：皇后可以攻击同一行、同一列、左上左下右上右下四个方向的任意单位。

这个问题本质上跟全排列问题差不多，决策树的每一层表示棋盘上的每一行；每个节点可以做出的选择是，在该行的任意一列放置一个皇后。

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
vector<vector<string>> res;

/* 输入棋盘边长 n，返回所有合法的放置 */
vector<vector<string>> solveNQueens(int n) {
    // '.' 表示空，'Q' 表示皇后，初始化空棋盘。
    vector<string> board(n, string(n, '.'));
    backtrack(board, 0);
    return res;
}

// 路径：board 中小于 row 的那些行都已经成功放置了皇后
// 选择列表：第 row 行的所有列都是放置皇后的选择
// 结束条件：row 超过 board 的最后一行
void backtrack(vector<string>& board, int row) {
    // 触发结束条件
    if (row == board.size()) {
        res.push_back(board);
        return;
    }
    
    int n = board[row].size();
    for (int col = 0; col < n; col++) {
        // 排除不合法选择
        if (!isValid(board, row, col)) 
            continue;
        // 做选择
        board[row][col] = 'Q';
        // 进入下一行决策
        backtrack(board, row + 1);
        // 撤销选择
        board[row][col] = '.';
    }
}

IsValid()函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/* 是否可以在 board[row][col] 放置皇后？ */
bool isValid(vector<string>& board, int row, int col) {
    int n = board.size();
    // 检查列是否有皇后互相冲突
    for (int i = 0; i < n; i++) {
        if (board[i][col] == 'Q')
            return false;
    }
    // 检查右上方是否有皇后互相冲突
    for (int i = row - 1, j = col + 1; 
            i >= 0 && j < n; i--, j++) {
        if (board[i][j] == 'Q')
            return false;
    }
    // 检查左上方是否有皇后互相冲突
    for (int i = row - 1, j = col - 1;
            i >= 0 && j >= 0; i--, j--) {
        if (board[i][j] == 'Q')
            return false;
    }
    return true;
}

函数 backtrack 依然像个在决策树上游走的指针，通过 row 和 col 就可以表示函数遍历到的位置，通过 isValid 函数可以将不符合条件的情况剪枝：

某种程度上说，动态规划的暴力求解阶段就是回溯算法。只是有的问题具有重叠子问题性质，可以用 dp table 或者备忘录优化，将递归树大幅剪枝，这就变成了动态规划。而今天的两个问题，都没有重叠子问题，也就是回溯算法问题了，复杂度非常高是不可避免的。

参考链接：https://leetcode-cn.com/problems/permutations/solution/hui-su-suan-fa-xiang-jie-by-labuladong-2/

]]> + 回溯问题

解决一个回溯问题,实际上就是一个决策树的遍历过程，需要思考三个问题

回溯算法框架

1
2
3
4
5
6
7
8
9
10
result = []
def backtrack(路径, 选择列表):
    if 满足结束条件:
        result.add(路径)
        return
    
    for 选择 in 选择列表:
        做选择
        backtrack(路径, 选择列表)
        撤销选择

核心在于for循环里面的递归，在递归调用之前做选择，在递归调用之后撤销选择。

例子1 全排列问题

有n个数 每个数都只能用一次 求出所有能排列的可能性。全排列个数为n!个

PS：为了简单清晰起见，我们这次讨论的全排列问题不包含重复的数字。

如果已知有多少个数的情况下，我们通常可以使用n层for循环暴力遍历所有数

例如3个数 我们可以暴力写法为

1
2
3
4
5
6
7
8
9
10
11
12
13
for(int i = 0;i < n;i++)
    for(int j = 0;j < n;j++)
        for(int k = 0;k < n;k++)
        {
if(i!=j && i!=k && j!=k)
            {
                // 1 2 3   1 3 2   2 1 3   2 3 1  3 2 1  3 1 2
list.add(nums[i]);
                list.add(nums[j]);
                list.add(nums[k]);
                res.add(list);
            }
        }

回溯数如下图所示，只要从根遍历这棵树，记录路径下的数字，其实就是所有的全排列，我们不妨把这棵树称之为回溯算法的决策树

为什么叫决策树呢，顾名思义，每次遍历的时候都需要做决策来去避开那些已经走过的路。

现在可以解答开头的几个名词：[2] 就是「路径」，记录你已经做过的选择；[1,3] 就是「选择列表」，表示你当前可以做出的选择；「结束条件」就是遍历到树的底层，在这里就是选择列表为空的时候。

如果明白了这几个名词，可以把「路径」和「选择」列表作为决策树上每个节点的属性，比如下图列出了几个节点的属性：

我们定义的backtrack函数就是指针一样，在这棵树上游走，同时要正确维护每个节点的属性，每当走到树的底层，其路径就是一个全排列。

再进一步，如何遍历一颗树，

1
2
3
4
5
6
void traverse(TreeNode root) {
    for (TreeNode child : root.childern)
        // 前序遍历需要的操作
        traverse(child);
        // 后序遍历需要的操作
}

前序遍历的代码在进入某一个节点之前的那个时间点执行，后序遍历代码在离开某个节点之后的那个时间点执行。

回想我们刚才说的，「路径」和「选择」是每个节点的属性，函数在树上游走要正确维护节点的属性，那么就要在这两个特殊时间点搞点动作：

回溯代码核心框架

1
2
3
4
5
6
7
8
9
for 选择 in 选择列表:
    # 做选择
    将该选择从选择列表移除
    路径.add(选择)
    backtrack(路径, 选择列表)
    # 撤销选择
    路径.remove(选择)
    将该选择再加入选择列表

我们只要在递归之前做出选择，在递归之后撤销自己的选择，就能得到每个节点的选择路径和列表。

全排列代码

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
List<List<Integer>> res = new LinkedList<>();

/* 主函数，输入一组不重复的数字，返回它们的全排列 */
List<List<Integer>> permute(int[] nums) {
    // 记录「路径」
    LinkedList<Integer> track = new LinkedList<>();
    backtrack(nums, track);
    return res;
}

// 路径：记录在 track 中
// 选择列表：nums 中不存在于 track 的那些元素
// 结束条件：nums 中的元素全都在 track 中出现
void backtrack(int[] nums, LinkedList<Integer> track) {
    // 触发结束条件
    if (track.size() == nums.length) {
        res.add(new LinkedList(track));
        return;
    }
    
    for (int i = 0; i < nums.length; i++) {
        // 排除不合法的选择
        if (track.contains(nums[i]))
            continue;
        // 做选择
        track.add(nums[i]);
        // 进入下一层决策树
        backtrack(nums, track);
        // 取消选择
        track.removeLast();
    }
}

我们这里稍微做了些变通，没有显式记录「选择列表」，而是通过 nums 和 track 推导出当前的选择列表：

通过contains函数来判断该数是否已经被使用。

至此，我们就通过全排列问题详解了回溯算法的底层原理。当然，这个算法解决全排列不是很高效，应为对链表使用 contains 方法需要 O(N) 的时间复杂度。有更好的方法通过交换元素达到目的，但是难理解一些，这里就不写了，有兴趣可以自行搜索一下。

但是必须说明的是，不管怎么优化，都符合回溯框架，而且时间复杂度都不可能低于 O(N!)，因为穷举整棵决策树是无法避免的。这也是回溯算法的一个特点，不像动态规划存在重叠子问题可以优化，回溯算法就是纯暴力穷举，复杂度一般都很高。

明白了全排列问题，就可以直接套回溯算法框架了，下面简单看看 N 皇后问题。

例子2 N皇后问题

题意

给你一个N*N的棋盘，，让你放置 N 个皇后，使得它们不能互相攻击。

PS：皇后可以攻击同一行、同一列、左上左下右上右下四个方向的任意单位。

这个问题本质上跟全排列问题差不多，决策树的每一层表示棋盘上的每一行；每个节点可以做出的选择是，在该行的任意一列放置一个皇后。

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
vector<vector<string>> res;

/* 输入棋盘边长 n，返回所有合法的放置 */
vector<vector<string>> solveNQueens(int n) {
    // '.' 表示空，'Q' 表示皇后，初始化空棋盘。
    vector<string> board(n, string(n, '.'));
    backtrack(board, 0);
    return res;
}

// 路径：board 中小于 row 的那些行都已经成功放置了皇后
// 选择列表：第 row 行的所有列都是放置皇后的选择
// 结束条件：row 超过 board 的最后一行
void backtrack(vector<string>& board, int row) {
    // 触发结束条件
    if (row == board.size()) {
        res.push_back(board);
        return;
    }
    
    int n = board[row].size();
    for (int col = 0; col < n; col++) {
        // 排除不合法选择
        if (!isValid(board, row, col)) 
            continue;
        // 做选择
        board[row][col] = 'Q';
        // 进入下一行决策
        backtrack(board, row + 1);
        // 撤销选择
        board[row][col] = '.';
    }
}

IsValid()函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/* 是否可以在 board[row][col] 放置皇后？ */
bool isValid(vector<string>& board, int row, int col) {
    int n = board.size();
    // 检查列是否有皇后互相冲突
    for (int i = 0; i < n; i++) {
        if (board[i][col] == 'Q')
            return false;
    }
    // 检查右上方是否有皇后互相冲突
    for (int i = row - 1, j = col + 1; 
            i >= 0 && j < n; i--, j++) {
        if (board[i][j] == 'Q')
            return false;
    }
    // 检查左上方是否有皇后互相冲突
    for (int i = row - 1, j = col - 1;
            i >= 0 && j >= 0; i--, j--) {
        if (board[i][j] == 'Q')
            return false;
    }
    return true;
}

函数 backtrack 依然像个在决策树上游走的指针，通过 row 和 col 就可以表示函数遍历到的位置，通过 isValid 函数可以将不符合条件的情况剪枝：

某种程度上说，动态规划的暴力求解阶段就是回溯算法。只是有的问题具有重叠子问题性质，可以用 dp table 或者备忘录优化，将递归树大幅剪枝，这就变成了动态规划。而今天的两个问题，都没有重叠子问题，也就是回溯算法问题了，复杂度非常高是不可避免的。

参考链接：https://leetcode-cn.com/problems/permutations/solution/hui-su-suan-fa-xiang-jie-by-labuladong-2/

]]> diff --git a/css/gitalk.css b/css/gitalk.css deleted file mode 100644 index a268f1d28..000000000 --- a/css/gitalk.css +++ /dev/null @@ -1,546 +0,0 @@ -@font-face { - font-family: octicons-link; - src: url(data:font/woff;charset=utf-8;base64,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) format('woff'); -} -/* variables */ -/* functions & mixins */ -/* variables - calculated */ -/* styles */ -.gt-container { - -webkit-box-sizing: border-box; - box-sizing: border-box; - font-size: 16px; - /* loader */ - /* error */ - /* initing */ - /* no int */ - /* link */ - /* meta */ - /* popup */ - /* header */ - /* comments */ - /* comment */ -} -.gt-container * { - -webkit-box-sizing: border-box; - box-sizing: border-box; -} -.gt-container a { - color: #6190e8; -} -.gt-container a:hover { - color: #81a6ed; - border-color: #81a6ed; -} -.gt-container a.is--active { - color: #333; - cursor: default !important; -} -.gt-container a.is--active:hover { - color: #333; -} -.gt-container .hide { - display: none !important; -} -.gt-container .gt-svg { - display: inline-block; - width: 1em; - height: 1em; - vertical-align: sub; -} -.gt-container .gt-svg svg { - width: 100%; - height: 100%; - fill: #6190e8; -} -.gt-container .gt-ico { - display: inline-block; -} -.gt-container .gt-ico-text { - margin-left: 0.3125em; -} -.gt-container .gt-ico-github { - width: 100%; - height: 100%; -} -.gt-container .gt-ico-github .gt-svg { - width: 100%; - height: 100%; -} -.gt-container .gt-ico-github svg { - fill: inherit; -} -.gt-container .gt-spinner { - position: relative; -} -.gt-container .gt-spinner::before { - content: ''; - -webkit-box-sizing: border-box; - box-sizing: border-box; - position: absolute; - top: 3px; - width: 0.75em; - height: 0.75em; - margin-top: -0.1875em; - margin-left: -0.375em; - border-radius: 50%; - border: 1px solid #fff; - border-top-color: #6190e8; - -webkit-animation: gt-kf-rotate 0.6s linear infinite; - animation: gt-kf-rotate 0.6s linear infinite; -} -.gt-container .gt-loader { - position: relative; - border: 1px solid #999; - -webkit-animation: ease gt-kf-rotate 1.5s infinite; - animation: ease gt-kf-rotate 1.5s infinite; - display: inline-block; - font-style: normal; - width: 1.75em; - height: 1.75em; - line-height: 1.75em; - border-radius: 50%; -} -.gt-container .gt-loader:before { - content: ''; - position: absolute; - display: block; - top: 0; - left: 50%; - margin-top: -0.1875em; - margin-left: -0.1875em; - width: 0.375em; - height: 0.375em; - background-color: #999; - border-radius: 50%; -} -.gt-container .gt-avatar { - display: inline-block; - width: 3.125em; - height: 3.125em; -} -@media (max-width: 479px) { - .gt-container .gt-avatar { - width: 2em; - height: 2em; - } -} -.gt-container .gt-avatar img { - width: 100%; - height: auto; - border-radius: 3px; -} -.gt-container .gt-avatar-github { - width: 3em; - height: 3em; -} -@media (max-width: 479px) { - .gt-container .gt-avatar-github { - width: 1.875em; - height: 1.875em; - } -} -.gt-container .gt-btn { - padding: 0.75em 1.25em; - display: inline-block; - line-height: 1; - text-decoration: none; - white-space: nowrap; - cursor: pointer; - border: 1px solid #6190e8; - border-radius: 5px; - background-color: #6190e8; - color: #fff; - outline: none; - font-size: 0.75em; -} -.gt-container .gt-btn-text { - font-weight: 400; -} -.gt-container .gt-btn-loading { - position: relative; - margin-left: 0.5em; - display: inline-block; - width: 0.75em; - height: 1em; - vertical-align: top; -} -.gt-container .gt-btn.is--disable { - cursor: not-allowed; - opacity: 0.5; -} -.gt-container .gt-btn-login { - margin-right: 0; -} -.gt-container .gt-btn-preview { - background-color: #fff; - color: #6190e8; -} -.gt-container .gt-btn-preview:hover { - background-color: #f2f2f2; - border-color: #81a6ed; -} -.gt-container .gt-btn-public:hover { - background-color: #81a6ed; - border-color: #81a6ed; -} -.gt-container .gt-error { - text-align: center; - margin: 0.625em; - color: #ff3860; -} -.gt-container .gt-initing { - padding: 1.25em 0; - text-align: center; -} -.gt-container .gt-initing-text { - margin: 0.625em auto; - font-size: 92%; -} -.gt-container .gt-no-init { - padding: 1.25em 0; - text-align: center; -} -.gt-container .gt-link { - border-bottom: 1px dotted #6190e8; -} -.gt-container .gt-link-counts, -.gt-container .gt-link-project { - text-decoration: none; -} -.gt-container .gt-meta { - margin: 1.25em 0; - padding: 1em 0; - position: relative; - border-bottom: 1px solid #e9e9e9; - font-size: 1em; - position: relative; - z-index: 10; -} -.gt-container .gt-meta:before, -.gt-container .gt-meta:after { - content: " "; - display: table; -} -.gt-container .gt-meta:after { - clear: both; -} -.gt-container .gt-counts { - margin: 0 0.625em 0 0; -} -.gt-container .gt-user { - float: right; - margin: 0; - font-size: 92%; -} -.gt-container .gt-user-pic { - width: 16px; - height: 16px; - vertical-align: top; - margin-right: 0.5em; -} -.gt-container .gt-user-inner { - display: inline-block; - cursor: pointer; -} -.gt-container .gt-user .gt-ico { - margin: 0 0 0 0.3125em; -} -.gt-container .gt-user .gt-ico svg { - fill: inherit; -} -.gt-container .gt-user .is--poping .gt-ico svg { - fill: #6190e8; -} -.gt-container .gt-version { - color: #a1a1a1; - margin-left: 0.375em; -} -.gt-container .gt-copyright { - margin: 0 0.9375em 0.5em; - border-top: 1px solid #e9e9e9; - padding-top: 0.5em; -} -.gt-container .gt-popup { - position: absolute; - right: 0; - top: 2.375em; - background: #fff; - display: inline-block; - border: 1px solid #e9e9e9; - padding: 0.625em 0; - font-size: 0.875em; - letter-spacing: 0.5px; -} -.gt-container .gt-popup .gt-action { - cursor: pointer; - display: block; - margin: 0.5em 0; - padding: 0 1.125em; - position: relative; - text-decoration: none; -} -.gt-container .gt-popup .gt-action.is--active:before { - content: ''; - width: 0.25em; - height: 0.25em; - background: #6190e8; - position: absolute; - left: 0.5em; - top: 0.4375em; -} -.gt-container .gt-header { - position: relative; - display: -webkit-box; - display: -ms-flexbox; - display: flex; -} -.gt-container .gt-header-comment { - -webkit-box-flex: 1; - -ms-flex: 1; - flex: 1; - margin-left: 1.25em; -} -@media (max-width: 479px) { - .gt-container .gt-header-comment { - margin-left: 0.875em; - } -} -.gt-container .gt-header-textarea { - padding: 0.75em; - display: block; - -webkit-box-sizing: border-box; - box-sizing: border-box; - width: 100%; - min-height: 5.125em; - max-height: 15em; - border-radius: 5px; - border: 1px solid rgba(0,0,0,0.1); - font-size: 0.875em; - word-wrap: break-word; - resize: vertical; - background-color: #f6f6f6; - outline: none; - -webkit-transition: all 0.25s ease; - transition: all 0.25s ease; -} -.gt-container .gt-header-textarea:hover { - background-color: #fbfbfb; -} -.gt-container .gt-header-preview { - padding: 0.75em; - border-radius: 5px; - border: 1px solid rgba(0,0,0,0.1); - background-color: #f6f6f6; -} -.gt-container .gt-header-controls { - position: relative; - margin: 0.75em 0 0; -} -.gt-container .gt-header-controls:before, -.gt-container .gt-header-controls:after { - content: " "; - display: table; -} -.gt-container .gt-header-controls:after { - clear: both; -} -@media (max-width: 479px) { - .gt-container .gt-header-controls { - margin: 0; - } -} -.gt-container .gt-header-controls-tip { - font-size: 0.875em; - color: #6190e8; - text-decoration: none; - vertical-align: sub; -} -@media (max-width: 479px) { - .gt-container .gt-header-controls-tip { - display: none; - } -} -.gt-container .gt-header-controls .gt-btn { - float: right; - margin-left: 1.25em; -} -@media (max-width: 479px) { - .gt-container .gt-header-controls .gt-btn { - float: none; - width: 100%; - margin: 0.75em 0 0; - } -} -.gt-container:after { - content: ''; - position: fixed; - bottom: 100%; - left: 0; - right: 0; - top: 0; - opacity: 0; -} -.gt-container.gt-input-focused { - position: relative; -} -.gt-container.gt-input-focused:after { - content: ''; - position: fixed; - bottom: 0%; - left: 0; - right: 0; - top: 0; - background: #000; - opacity: 0.6; - -webkit-transition: opacity 0.3s, bottom 0s; - transition: opacity 0.3s, bottom 0s; - z-index: 9999; -} -.gt-container.gt-input-focused .gt-header-comment { - z-index: 10000; -} -.gt-container .gt-comments { - padding-top: 1.25em; -} -.gt-container .gt-comments-null { - text-align: center; -} -.gt-container .gt-comments-controls { - margin: 1.25em 0; - text-align: center; -} -.gt-container .gt-comment { - position: relative; - padding: 0.625em 0; - display: -webkit-box; - display: -ms-flexbox; - display: flex; -} -.gt-container .gt-comment-content { - -webkit-box-flex: 1; - -ms-flex: 1; - flex: 1; - margin-left: 1.25em; - padding: 0.75em 1em; - background-color: #f9f9f9; - overflow: auto; - -webkit-transition: all ease 0.25s; - transition: all ease 0.25s; -} -.gt-container .gt-comment-content:hover { - -webkit-box-shadow: 0 0.625em 3.75em 0 #f4f4f4; - box-shadow: 0 0.625em 3.75em 0 #f4f4f4; -} -@media (max-width: 479px) { - .gt-container .gt-comment-content { - margin-left: 0.875em; - padding: 0.625em 0.75em; - } -} -.gt-container .gt-comment-header { - margin-bottom: 0.5em; - font-size: 0.875em; - position: relative; -} -.gt-container .gt-comment-block-1 { - float: right; - height: 1.375em; - width: 2em; -} -.gt-container .gt-comment-block-2 { - float: right; - height: 1.375em; - width: 4em; -} -.gt-container .gt-comment-username { - font-weight: 500; - color: #6190e8; - text-decoration: none; -} -.gt-container .gt-comment-username:hover { - text-decoration: underline; -} -.gt-container .gt-comment-text { - margin-left: 0.5em; - color: #a1a1a1; -} -.gt-container .gt-comment-date { - margin-left: 0.5em; - color: #a1a1a1; -} -.gt-container .gt-comment-like, -.gt-container .gt-comment-edit, -.gt-container .gt-comment-reply { - position: absolute; - height: 1.375em; -} -.gt-container .gt-comment-like:hover, -.gt-container .gt-comment-edit:hover, -.gt-container .gt-comment-reply:hover { - cursor: pointer; -} -.gt-container .gt-comment-like { - top: 0; - right: 2em; -} -.gt-container .gt-comment-edit, -.gt-container .gt-comment-reply { - top: 0; - right: 0; -} -.gt-container .gt-comment-body { - color: #333 !important; -} -.gt-container .gt-comment-body .email-hidden-toggle a { - display: inline-block; - height: 12px; - padding: 0 9px; - font-size: 12px; - font-weight: 600; - line-height: 6px; - color: #444d56; - text-decoration: none; - vertical-align: middle; - background: #dfe2e5; - border-radius: 1px; -} -.gt-container .gt-comment-body .email-hidden-toggle a:hover { - background-color: #c6cbd1; -} -.gt-container .gt-comment-body .email-hidden-reply { - display: none; - white-space: pre-wrap; -} -.gt-container .gt-comment-body .email-hidden-reply .email-signature-reply { - padding: 0 15px; - margin: 15px 0; - color: #586069; - border-left: 4px solid #dfe2e5; -} -.gt-container .gt-comment-body .email-hidden-reply.expanded { - display: block; -} -.gt-container .gt-comment-admin .gt-comment-content { - background-color: #f6f9fe; -} -@-webkit-keyframes gt-kf-rotate { - 0% { - -webkit-transform: rotate(0); - transform: rotate(0); - } - 100% { - -webkit-transform: rotate(360deg); - transform: rotate(360deg); - } -} -@keyframes gt-kf-rotate { - 0% { - -webkit-transform: rotate(0); - transform: rotate(0); - } - 100% { - -webkit-transform: rotate(360deg); - transform: rotate(360deg); - } -} diff --git a/css/highlight-dark.css b/css/highlight-dark.css deleted file mode 100644 index 29f08c513..000000000 --- a/css/highlight-dark.css +++ /dev/null @@ -1,64 +0,0 @@ -/* - -Dark style from softwaremaniacs.org (c) Ivan Sagalaev - -*/ - -.hljs { - display: block; - overflow-x: auto; - padding: 0.5em; - background: #444; -} - -.hljs-keyword, -.hljs-selector-tag, -.hljs-literal, -.hljs-section, -.hljs-link { - color: white; -} - -.hljs, -.hljs-subst { - color: #ddd; -} - -.hljs-string, -.hljs-title, -.hljs-name, -.hljs-type, -.hljs-attribute, -.hljs-symbol, -.hljs-bullet, -.hljs-built_in, -.hljs-addition, -.hljs-variable, -.hljs-template-tag, -.hljs-template-variable { - color: #d88; -} - -.hljs-comment, -.hljs-quote, -.hljs-deletion, -.hljs-meta { - color: #777; -} - -.hljs-keyword, -.hljs-selector-tag, -.hljs-literal, -.hljs-title, -.hljs-section, -.hljs-doctag, -.hljs-type, -.hljs-name, -.hljs-strong { - font-weight: bold; -} - -.hljs-emphasis { - font-style: italic; -} - diff --git a/css/highlight.css b/css/highlight.css deleted file mode 100644 index 8f451dea3..000000000 --- a/css/highlight.css +++ /dev/null @@ -1,80 +0,0 @@ -/** - * GitHub Gist Theme - * Author : Anthony Attard - https://github.com/AnthonyAttard - * Author : Louis Barranqueiro - https://github.com/LouisBarranqueiro - */ - -.hljs { - display: block; - background: white; - padding: 0.5em; - color: #333333; - overflow-x: auto; -} - -.hljs-comment, -.hljs-meta { - color: #969896; -} - -.hljs-variable, -.hljs-template-variable, -.hljs-strong, -.hljs-emphasis, -.hljs-quote { - color: #df5000; -} - -.hljs-keyword, -.hljs-selector-tag, -.hljs-type { - color: #d73a49; -} - -.hljs-literal, -.hljs-symbol, -.hljs-bullet, -.hljs-attribute { - color: #0086b3; -} - -.hljs-section, -.hljs-name { - color: #63a35c; -} - -.hljs-tag { - color: #333333; -} - -.hljs-title, -.hljs-attr, -.hljs-selector-id, -.hljs-selector-class, -.hljs-selector-attr, -.hljs-selector-pseudo { - color: #6f42c1; -} - -.hljs-addition { - color: #55a532; - background-color: #eaffea; -} - -.hljs-deletion { - color: #bd2c00; - background-color: #ffecec; -} - -.hljs-link { - text-decoration: underline; -} - -.hljs-number { - color: #005cc5; -} - -.hljs-string { - color: #032f62; -} - diff --git a/css/main.css b/css/main.css index ba3081b1f..c61a56bda 100644 --- a/css/main.css +++ b/css/main.css @@ -1,5 +1,5 @@ :root { - --body-bg-color: #fff; + --body-bg-color: #f5f7f9; --content-bg-color: #fff; --card-bg-color: #f5f5f5; --text-color: #555; @@ -10,11 +10,11 @@ --table-row-odd-bg-color: #f9f9f9; --table-row-hover-bg-color: #f5f5f5; --menu-item-bg-color: #f5f5f5; - --btn-default-bg: #222; - --btn-default-color: #fff; - --btn-default-border-color: #222; - --btn-default-hover-bg: #fff; - --btn-default-hover-color: #222; + --btn-default-bg: #fff; + --btn-default-color: #555; + --btn-default-border-color: #555; + --btn-default-hover-bg: #222; + --btn-default-hover-color: #fff; --btn-default-hover-border-color: #222; } html { @@ -314,7 +314,7 @@ td { .btn { background: var(--btn-default-bg); border: 2px solid var(--btn-default-border-color); - border-radius: 0; + border-radius: 2px; color: var(--btn-default-color); display: inline-block; font-size: 0.875em; @@ -356,36 +356,33 @@ td { margin-top: 3px; } .toggle.toggle-arrow .toggle-line-first { - left: 50%; top: 2px; - transform: rotate(45deg); + transform: rotate(-45deg); width: 50%; } .toggle.toggle-arrow .toggle-line-middle { - left: 2px; width: 90%; } .toggle.toggle-arrow .toggle-line-last { - left: 50%; top: -2px; - transform: rotate(-45deg); + transform: rotate(45deg); width: 50%; } .toggle.toggle-close .toggle-line-first { - transform: rotate(-45deg); top: 5px; + transform: rotate(-45deg); } .toggle.toggle-close .toggle-line-middle { opacity: 0; } .toggle.toggle-close .toggle-line-last { - transform: rotate(45deg); top: -5px; + transform: rotate(45deg); } .highlight, pre { - background: #f7f7f7; - color: #4d4d4c; + background: #1d1f21; + color: #c5c8c6; line-height: 1.6; margin: 0 auto 20px; } @@ -402,7 +399,7 @@ code { word-wrap: break-word; } .highlight *::selection { - background: #d6d6d6; + background: #373b41; } .highlight pre { border: 0; @@ -419,8 +416,8 @@ code { padding: 0; } .highlight figcaption { - background: #eff2f3; - color: #4d4d4c; + background: #000; + color: #c5c8c6; display: flex; font-size: 0.875em; justify-content: space-between; @@ -428,10 +425,10 @@ code { padding: 0.5em; } .highlight figcaption a { - color: #4d4d4c; + color: #c5c8c6; } .highlight figcaption a:hover { - border-bottom-color: #4d4d4c; + border-bottom-color: #c5c8c6; } .highlight .gutter { -moz-user-select: none; @@ -440,14 +437,14 @@ code { user-select: none; } .highlight .gutter pre { - background: #eff2f3; - color: #869194; + background: #000; + color: #888f96; padding-left: 10px; padding-right: 10px; text-align: right; } .highlight .code pre { - background: #f7f7f7; + background: #1d1f21; padding-left: 10px; width: 100%; } @@ -463,26 +460,26 @@ pre { } pre code { background: none; - color: #4d4d4c; + color: #c5c8c6; font-size: 0.875em; padding: 0; text-shadow: none; } pre .deletion { - background: #fdd; + background: #800000; } pre .addition { - background: #dfd; + background: #008000; } pre .meta { - color: #eab700; + color: #f0c674; -moz-user-select: none; -ms-user-select: none; -webkit-user-select: none; user-select: none; } pre .comment { - color: #8e908c; + color: #969896; } pre .variable, pre .attribute, @@ -497,7 +494,7 @@ pre .html .doctype, pre .css .id, pre .css .class, pre .css .pseudo { - color: #c82829; + color: #c66; } pre .number, pre .preprocessor, @@ -507,7 +504,7 @@ pre .literal, pre .params, pre .constant, pre .command { - color: #f5871f; + color: #de935f; } pre .ruby .class .title, pre .css .rules .attribute, @@ -520,11 +517,11 @@ pre .ruby .symbol, pre .xml .cdata, pre .special, pre .formula { - color: #718c00; + color: #b5bd68; } pre .title, pre .css .hexcolor { - color: #3e999f; + color: #8abeb7; } pre .function, pre .python .decorator, @@ -534,11 +531,11 @@ pre .ruby .title .keyword, pre .perl .sub, pre .javascript .title, pre .coffeescript .title { - color: #4271ae; + color: #81a2be; } pre .keyword, pre .javascript .function { - color: #8959a8; + color: #b294bb; } .blockquote-center { border-left: none; @@ -928,16 +925,16 @@ pre .javascript .function { } .main-inner { margin: 0 auto; - width: 700px; + width: calc(100% - 20px); } @media (min-width: 1200px) { .main-inner { - width: 800px; + width: 1160px; } } @media (min-width: 1600px) { .main-inner { - width: 900px; + width: 73%; } } @media (max-width: 767px) { @@ -950,16 +947,16 @@ pre .javascript .function { } .header-inner { margin: 0 auto; - width: 700px; + width: calc(100% - 20px); } @media (min-width: 1200px) { .header-inner { - width: 800px; + width: 1160px; } } @media (min-width: 1600px) { .header-inner { - width: 900px; + width: 73%; } } .site-brand-container { @@ -998,7 +995,7 @@ pre .javascript .function { margin: 0; } .site-subtitle { - color: #999; + color: #ddd; font-size: 0.8125em; margin: 10px 0; } @@ -1140,22 +1137,23 @@ pre .javascript .function { display: inline-block; } .site-author-image { - border: 2px solid #333; + border: 1px solid #eee; display: block; margin: 0 auto; - max-width: 96px; + max-width: 120px; padding: 2px; + border-radius: 50%; } .site-author-name { - color: #f5f5f5; - font-weight: normal; - margin: 5px 0 0; + color: var(--text-color); + font-weight: 600; + margin: 0; text-align: center; } .site-description { color: #999; - font-size: 1em; - margin-top: 5px; + font-size: 0.8125em; + margin-top: 0; text-align: center; } .links-of-author { @@ -1172,7 +1170,7 @@ pre .javascript .function { } .links-of-author a::before, .links-of-author span.exturl::before { - background: #16219c; + background: #f95d4e; border-radius: 50%; content: ' '; display: inline-block; @@ -1253,14 +1251,14 @@ pre .javascript .function { margin-left: 10px; } .sidebar-nav li:hover { - color: #f5f5f5; + color: #fc6423; } .sidebar-nav .sidebar-nav-active { - border-bottom-color: #87daff; - color: #87daff; + border-bottom-color: #fc6423; + color: #fc6423; } .sidebar-nav .sidebar-nav-active:hover { - color: #87daff; + color: #fc6423; } .sidebar-panel { display: none; @@ -1289,7 +1287,7 @@ pre .javascript .function { } } .sidebar-toggle:hover .toggle-line { - background: #87daff; + background: #fc6423; } .post-toc { font-size: 0.875em; @@ -1328,14 +1326,14 @@ pre .javascript .function { display: block; } .post-toc .nav .active > a { - border-bottom-color: #87daff; - color: #87daff; + border-bottom-color: #fc6423; + color: #fc6423; } .post-toc .nav .active-current > a { - color: #87daff; + color: #fc6423; } .post-toc .nav .active-current > a:hover { - color: #87daff; + color: #fc6423; } .site-state { display: flex; @@ -1350,20 +1348,20 @@ pre .javascript .function { padding: 0 15px; } .site-state-item:not(:first-child) { - border-left: 1px solid #333; + border-left: 1px solid #eee; } .site-state-item a { border-bottom: none; } .site-state-item-count { display: block; - font-size: 1.25em; + font-size: 1em; font-weight: 600; text-align: center; } .site-state-item-name { - color: inherit; - font-size: 0.875em; + color: #999; + font-size: 0.8125em; } .footer { color: #999; @@ -1380,16 +1378,16 @@ pre .javascript .function { box-sizing: border-box; margin: 0 auto; text-align: center; - width: 700px; + width: calc(100% - 20px); } @media (min-width: 1200px) { .footer-inner { - width: 800px; + width: 1160px; } } @media (min-width: 1600px) { .footer-inner { - width: 900px; + width: 73%; } } .languages { @@ -1487,7 +1485,7 @@ pre .javascript .function { color: #fff; cursor: pointer; left: 30px; - opacity: 1; + opacity: 0.6; padding: 0 6px; position: fixed; transition-property: bottom; @@ -1498,10 +1496,10 @@ pre .javascript .function { display: none; } .back-to-top:hover { - color: #87daff; + color: #fc6423; } .back-to-top.back-to-top-on { - bottom: 19px; + bottom: 30px; } @media (max-width: 991px) { .back-to-top { @@ -2141,156 +2139,301 @@ ul.breadcrumb li + li:last-child { .tag-cloud a:hover { color: #222 !important; } -@media (max-width: 767px) { - .header-inner, - .main-inner, - .footer-inner { +.header { + margin: 0 auto; + position: relative; + width: calc(100% - 20px); +} +@media (min-width: 1200px) { + .header { + width: 1160px; + } +} +@media (min-width: 1600px) { + .header { + width: 73%; + } +} +@media (max-width: 991px) { + .header { width: auto; } } .header-inner { - padding-top: 100px; + background: var(--content-bg-color); + border-radius: initial; + box-shadow: initial; + overflow: hidden; + padding: 0; + position: absolute; + top: 0; + width: 240px; } -@media (max-width: 767px) { +@media (min-width: 1200px) { .header-inner { - padding-top: 50px; + width: 240px; } } -.main-inner { - padding-bottom: 60px; +@media (max-width: 991px) { + .header-inner { + border-radius: initial; + position: relative; + width: auto; + } } -.content { - padding-top: 70px; +.main-inner { + align-items: flex-start; + display: flex; + justify-content: space-between; } -@media (max-width: 767px) { - .content { - padding-top: 35px; +@media (max-width: 991px) { + .main-inner { + width: auto; } } -embed { - display: block; - margin: 0 auto 25px auto; -} -.custom-logo .site-meta-headline { - text-align: center; +.content-wrap { + background: var(--content-bg-color); + border-radius: initial; + box-shadow: initial; + box-sizing: border-box; + padding: 40px; + width: calc(100% - 252px); } -.custom-logo .site-title { - color: #222; - margin: 10px auto 0; +@media (max-width: 991px) { + .content-wrap { + border-radius: initial; + padding: 20px; + width: 100%; + } } -.custom-logo .site-title a { - border: 0; +.header-inner { + right: 0; } -.custom-logo-image { - background: #fff; - margin: 0 auto; - max-width: 150px; - padding: 5px; +.book-mark-link { + left: 30px; } -.brand { - background: var(--btn-default-bg); +.footer-inner { + padding-right: 260px; } -@media (max-width: 767px) { - .site-nav { - border-bottom: 1px solid #ddd; - border-top: 1px solid #ddd; - left: 0; - margin: 0; - padding: 0; - width: 100%; +@media (max-width: 991px) { + .footer-inner { + padding-left: 0; + padding-right: 0; + width: auto; } } -@media (max-width: 767px) { - .menu { - text-align: left; +.site-brand-container { + background: #222; +} +@media (max-width: 991px) { + .site-brand-container { + box-shadow: 0 0 16px rgba(0,0,0,0.5); } } -.menu-item-active a, -.menu .menu-item a:hover, -.menu .menu-item span.exturl:hover { - background: transparent; - border-bottom: 1px solid var(--link-hover-color) !important; +.site-meta { + padding: 20px 0; } -@media (max-width: 767px) { - .menu-item-active a, - .menu .menu-item a:hover, - .menu .menu-item span.exturl:hover { - border-bottom: 1px dotted #ddd !important; +.brand { + padding: 0; +} +.site-subtitle { + margin: 10px 10px 0; +} +.custom-logo-image { + margin-top: 20px; +} +@media (max-width: 991px) { + .custom-logo-image { + display: none; } } -@media (max-width: 767px) { - .menu .menu-item { - margin: 0 10px; +@media (min-width: 768px) and (max-width: 991px) { + .site-nav-toggle, + .site-nav-right { + display: flex; + flex-direction: column; + justify-content: center; } } -.menu .menu-item a, -.menu .menu-item span.exturl { - border-bottom: 1px solid transparent; +.site-nav-toggle .toggle, +.site-nav-right .toggle { + color: #fff; } -@media (max-width: 767px) { - .menu .menu-item a, - .menu .menu-item span.exturl { - padding: 5px 10px; - } +.site-nav-toggle .toggle .toggle-line, +.site-nav-right .toggle .toggle-line { + background: #fff; } @media (min-width: 768px) and (max-width: 991px) { - .menu .menu-item .fa { - display: block; - line-height: 2; - margin-right: 0; - width: 100%; + .site-nav { + display: none; } } -@media (min-width: 992px) { - .menu .menu-item .fa { - display: block; - line-height: 2; - margin-right: 0; - width: 100%; +.menu-item-active a::after { + background: #bbb; + border-radius: 50%; + content: ' '; + height: 6px; + margin-top: -3px; + position: absolute; + right: 15px; + top: 50%; + width: 6px; +} +.menu .menu-item { + display: block; + margin: 0; +} +.menu .menu-item a, +.menu .menu-item span.exturl { + padding: 5px 20px; + position: relative; + text-align: left; + transition-property: background-color; +} +@media (max-width: 991px) { + .menu .menu-item.menu-item-search { + display: none; } } .menu .menu-item .badge { - background: #eee; - padding: 1px 4px; + background: #ccc; + border-radius: 10px; + color: #fff; + float: right; + padding: 2px 5px; + text-shadow: 1px 1px 0 rgba(0,0,0,0.1); + vertical-align: middle; } .sub-menu { - margin: 10px 0; + background: var(--content-bg-color); + border-bottom: 1px solid #ddd; + margin: 0; + padding: 6px 0; } .sub-menu .menu-item { display: inline-block; } -.sidebar { - left: -320px; +.sub-menu .menu-item a, +.sub-menu .menu-item span.exturl { + background: transparent; + margin: 5px 10px; + padding: initial; } -.sidebar.sidebar-active { - left: 0; +.sub-menu .menu-item a:hover, +.sub-menu .menu-item span.exturl:hover { + background: transparent; + color: #fc6423; +} +.sub-menu .menu-item a::after, +.sub-menu .menu-item span.exturl::after { + content: initial !important; +} +.sub-menu .menu-item-active a { + border-bottom-color: #fc6423; + color: #fc6423; +} +.sub-menu .menu-item-active a:hover { + border-bottom-color: #fc6423; } .sidebar { - width: 320px; - z-index: 1200; - transition-delay: 0s; - transition-duration: 0.2s; - transition-timing-function: ease-out; + background: var(--body-bg-color); + box-shadow: none; + margin-top: 100%; + position: static; + width: 240px; } -.sidebar a, -.sidebar span.exturl { - border-bottom-color: #555; - color: #999; +@media (max-width: 991px) { + .sidebar { + display: none; + } } -.sidebar a:hover, -.sidebar span.exturl:hover { - border-bottom-color: #eee; - color: #eee; +.sidebar-toggle { + display: none; } -.links-of-blogroll-item { - padding: 2px 10px; +.sidebar-inner { + background: var(--content-bg-color); + border-radius: initial; + box-shadow: initial; + box-sizing: border-box; + color: var(--text-color); + width: 240px; + opacity: 0; +} +.sidebar-inner.affix { + position: fixed; + top: 12px; +} +.sidebar-inner.affix-bottom { + position: absolute; +} +.site-state-item { + padding: 0 10px; +} +.sidebar-button { + border-bottom: 1px dotted #ccc; + border-top: 1px dotted #ccc; + margin-top: 10px; + text-align: center; +} +.sidebar-button a { + border: 0; + color: #fc6423; + display: block; +} +.sidebar-button a:hover { + background: none; + border: 0; + color: #e34603; } -.links-of-blogroll-item a, -.links-of-blogroll-item span.exturl { +.sidebar-button a:hover .fa { + color: #e34603; +} +.links-of-author { + display: flex; + flex-wrap: wrap; + margin-top: 10px; + justify-content: center; +} +.links-of-author-item { + margin: 5px 0 0; + width: 50%; +} +.links-of-author-item a, +.links-of-author-item span.exturl { box-sizing: border-box; display: inline-block; - max-width: 280px; + margin-bottom: 0; + margin-right: 0; + max-width: 216px; overflow: hidden; + padding: 0 5px; text-overflow: ellipsis; white-space: nowrap; } +.links-of-author-item a, +.links-of-author-item span.exturl { + border-bottom: none; + display: block; + text-decoration: none; +} +.links-of-author-item a::before, +.links-of-author-item span.exturl::before { + display: none; +} +.links-of-author-item a:hover, +.links-of-author-item span.exturl:hover { + background: var(--body-bg-color); + border-radius: 4px; +} +.links-of-author-item .fa { + margin-right: 2px; +} +.links-of-blogroll-item { + padding: 0; +} +.post-toc .nav .nav-child { + display: block; +} +.post-toc ol { + font-size: 13px; +} diff --git a/img/avatar.png b/img/avatar.png deleted file mode 100644 index ffd1c77930f623902ad3106a25247370b44e4ccd..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 5709 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 S>%bMTfVqkFrJ9S^6aEh$*dHYT diff --git a/img/default.png b/img/default.png deleted file mode 100644 index 2bc2cd744cb49e00c98f17dba523970ff1b7f476..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 400730 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
0MKM6xp`925_<0xFq=fO^q&Xlb49^?* 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�_FvhxaV1ye*|4Q|J_a8IY!Qshi)un;sFDf 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≪N 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 +%{~t&;0E9}ixs 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%0ATVk4yXSqzN%jigIQV$~Rd>NNPO6x?NS9xg)i# z?w+Uv2}lArRQn5=<~jI_u^h`|G=VvJiEkCAM)!&seyxGy)DUXsA~AI($4OzQ^FlC` z?cZ-;mZ$=nfll=Uo?;Rid2K@b+KQbnSqSWUy4*GH0iIqmbJLVA*JIK*89HN6DxY^4 zvK(kbW_#xD+`WkrNRVfX%X!@nj2XU=RON8d`+44@8%bm@enw>5XQ(aiflHkQKG-m^ zWHR9RX$SmG1y7EC?(j2&e#=$^W(K)y1FD3ts7&4G&7^K22F5)^%|@?F*Bposn~DF5 znZs&~^Gk+UXZ@U>E14uR1#7%z@FFbnD@t*wAVL(N;Wh3OlPct+6lTv%&iFRc6p||~ z{F$;pC#H628c*Zvr1#(R&a$ZNg;(w8;B<{>MjZr}$YHjTO|Jzi6P`kIG|9p(o9A)c z*Wdp^+qvyV&fH)yH(3c9CxGwf{hu`5g=!QAMB+FHdelvRWNWW&v9T=n!F0P*4ppRZnZUKUN!Mm!VbTdib_0OU11O>j=)_OM#q03 z$3DB_YDegf@zQ!7e`h_64i>eJ_>-$QxCVqf<0MP_-o8x@L*tjnm1gE+ud9#|yKq{~ z=sazW@|&yiKv?k0)<@*9fB7X#MfVLt>xxjI

Dx;zQE(4^L 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�@V>9Y*2kdK8 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 IM6N<$f}ZVbV*mgE diff --git a/img/loading.gif b/img/loading.gif deleted file mode 100644 index c5126ed9c993a540f00d7580819096de15cd02a7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 17142 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 diff --git a/img/police_beian.png b/img/police_beian.png deleted file mode 100644 index 60190da03c7ffbc39d90b68bb675902eb4f3ca72..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1246 zcmV<41R?v0P)xN#0008qP)t-s0002~ z{NVHGs{jAv-l$jDu6^;>uH?{_=*E1SXbyjkhUUhmm|qwQLT%5w3L42wu0-)dHugs_|AI&?}q2RZ1mrY z{@9P?wt(~LlH|dU!+$>8x`*w}hU(aZ>(ZF)-LmiKqtUK*%7k0{^w9Y8$^ZG#*{_1} z-^c&?!TbzS2(pcoM zPT!+S)*l#ac834}fB*z{_2YB$%Wm-0Yz6~p?aE>4!C>meU+T$RlXzO|z*ptKQ{u8y z{>4)1uu9vRN7ax<@~}kSnMCP=KGTIg*L65K6gb_5HP&S?+Ds|COeWJfBG*13{VWgA z77f$`3C;lngpZjVK9_QZl&Q3l00@z3evSYeju$YA#l45qyoaNigq4tka(aSuc7naS zev*xT#jbn+5PE!idGgqJ*1&kmws>4$c-YK$jfQvb*mabQb*!Ru&BAf}(r;EyZvX*r z|L<+-%5B}YY5&q@=fq~Tqh?-NX8g=#|Kelq!eVY>V*lG<|Gr>(WMI9JUjN!%3;P<;EqT8pGMb;M*74=LL@}ppF-S`LA8KC z=%78+mObN>J=0}9){Z>RcshYtI`^bG;FUQ{06E)jH}--y~Ss3J}vx?EXi3a)krGqUn%o^DAjZ**+(eTKqkdfB;{Zu*F7Q2Jt5XH zAMjot;zl0EJ{`|28qy&e)*2VgClkge6VVJ2zW@=o01&Yb4#5ly#25chy;M>yC%g4mS!M?n@vaze5 zoS2o9jDvh{U0hmBNI^k0FexV?92D))h!g+-0dq-2K~xyiVt@i>HW_I)W(H(n#>##9 z*tXT2ti}j2##xDHFW$e>*PghD5w2BXL&&YHw3O_f`O8(HqLy4+CS7~(@$63K`x%~l zgss4W=51c{9%nsz@jC6(%_@f$3y_$Ne6{!fCm%f?q%p#f@Zpur*~Cd#6uV*(Ze0QcsGKri{E7XSbN07*qo IM6N<$f_veL&j0`b diff --git a/index.html b/index.html index 80e593b3d..b8c84b8d9 100644 --- a/index.html +++ b/index.html @@ -443,7 +443,7 @@

发表于 - + @@ -691,10 +691,16 @@

发表于 - - + + + + + + 更新于 + + @@ -731,7 +737,7 @@

进程与线程

多线程demo

-
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class deno01 {
    public static void main(String[] args) {
        new Thread(() ->{
            while (true)
            {
                System.out.println(1);
            }
        },"t1").start();

        new Thread(() ->{
            while (true)
            {
                System.out.println(2);
            }
        },"t2").start();
    }

}
+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class deno01 {
    public static void main(String[] args) {
        new Thread(() ->{
            while (true)
            {
                System.out.println(1);
            }
        },"t1").start();

        new Thread(() ->{
            while (true)
            {
                System.out.println(2);
            }
        },"t2").start();
    }

}

很明显得到的结果是交替打印1 和 2。

拓展

@@ -835,17 +841,17 @@ 

1
2
3
synchronized void method() {
  //业务代码
}
+
1
2
3
synchronized void method() {
  //业务代码
}
  • 修饰静态方法: 也就是给当前类加锁，会作用于类的所有对象实例 ，进入同步代码前要获得 当前 class 的锁。因为静态成员不属于任何一个实例对象，是类成员（ static 表明这是该类的一个静态资源，不管 new 了多少个对象，只有一份）。所以，如果一个线程 A 调用一个实例对象的非静态 synchronized 方法，而线程 B 需要调用这个实例对象所属类的静态 synchronized 方法，是允许的，不会发生互斥现象，因为访问静态 synchronized 方法占用的锁是当前类的锁，而访问非静态 synchronized 方法占用的锁是当前实例对象锁。
-
1
2
3
synchronized void staic method() {
  //业务代码
}
+
1
2
3
synchronized void staic method() {
  //业务代码
}
  • 修饰代码块 ：指定加锁对象，对给定对象/类加锁。synchronized(this|object) 表示进入同步代码库前要获得给定对象的锁。synchronized(类.class) 表示进入同步代码前要获得 当前 class 的锁
-
1
2
3
synchronized(this) {
  //业务代码
}
+
1
2
3
synchronized(this) {
  //业务代码
}
@@ -858,13 +864,13 @@

List

则生成的是String[]类型的数组 初始长度为0

扩容

当初始长度为10已经加入了十个元素之后，我们需要再加一个元素的时候，我们就需要扩容

-
1
2
3
4
5
6
private void add(E e, Object[] elementData, int s) {
    if (s == elementData.length)
        elementData = grow();
    elementData[s] = e;
    size = s + 1;
}
+
1
2
3
4
5
6
private void add(E e, Object[] elementData, int s) {
    if (s == elementData.length)
        elementData = grow();
    elementData[s] = e;
    size = s + 1;
}

这段源代码就是ArrayList的add()方法 如果添加的元素已经满了 则调用grow()函数 很明显 这是一个扩容函数

grow函数有两个 一个有参函数 一个无参函数

无参参数会调用有参参数 进行1.5倍的扩容

-
1
ArrayList list1 = new ArrayList(23);
+
1
ArrayList list1 = new ArrayList(23);

这表示着生成了一个初始长度为23的ArrayList数组

Vector

和ArrayList数组类似 线程安全 效率低 用的很少

@@ -890,7 +896,7 @@

HashM

HashMap 是无序的，即不会记录插入的顺序。

HashMap 继承于AbstractMap，实现了 Map、Cloneable、java.io.Serializable 接口。

-
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
public class Main {
    public static void main(String[] args) throws IOException, Exception {
        HashMap<String,String> map = new HashMap<>();
        map.put("1","one");
        map.put("2","two");
        map.put("3","three");
        map.put("4","four");
        System.out.println(map);

        HashMap<String, String> Sites = new HashMap<String, String>();
        // 添加键值对
        Sites.put("one", "Google");
        Sites.put("two", "Runoob");
        Sites.put("three", "Taobao");
        Sites.put("four", "Zhihu");
        Sites.put("apple","lll");
        System.out.println(Sites);
        // key=商品名称,value=价格,这里以这个例子实现按名称排序和按价格排序.
        Map store = new HashMap();

        store.put("iphone12", 6799);
        store.put("iphone12pro", 8499);
        store.put("macbookPro", 19499);
        store.put("ipadAir", 6999);
        store.put("watch6", 3199);

// 直接输出HashMap得到的是一个无序Map(不是Arraylist那种顺序型储存)
        System.out.println(store);

//        {ipadAir=6999, iphone12pro=8499, macbookPro=19499, watch6=3199, iphone12=6799}
    }

    }

+
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
public class Main {
    public static void main(String[] args) throws IOException, Exception {
        HashMap<String,String> map = new HashMap<>();
        map.put("1","one");
        map.put("2","two");
        map.put("3","three");
        map.put("4","four");
        System.out.println(map);

        HashMap<String, String> Sites = new HashMap<String, String>();
        // 添加键值对
        Sites.put("one", "Google");
        Sites.put("two", "Runoob");
        Sites.put("three", "Taobao");
        Sites.put("four", "Zhihu");
        Sites.put("apple","lll");
        System.out.println(Sites);
        // key=商品名称,value=价格,这里以这个例子实现按名称排序和按价格排序.
        Map store = new HashMap();

        store.put("iphone12", 6799);
        store.put("iphone12pro", 8499);
        store.put("macbookPro", 19499);
        store.put("ipadAir", 6999);
        store.put("watch6", 3199);

// 直接输出HashMap得到的是一个无序Map(不是Arraylist那种顺序型储存)
        System.out.println(store);

//        {ipadAir=6999, iphone12pro=8499, macbookPro=19499, watch6=3199, iphone12=6799}
    }

    }

起初我验证Map的无序的时候 输出的总是有序的 增加了样本之后才变得无序

@@ -1010,7 +1016,7 @@

泛型未指定泛型前 我们需要这样写来获取对象

很容易出现ClassCastException，因为容易“误转型”：

-
1
2
3
4
5
6
7
8
9
10
11
public class Main {
    public static void main(String[] args) throws IOException {
        ArrayList list = new ArrayList();
        list.add("hello world");
        String s = (String) list.get(0);
        System.out.println(s);
        list.add(new Integer(123));
        String s2 = (String) list.get(1);
        }
    }

+
1
2
3
4
5
6
7
8
9
10
11
public class Main {
    public static void main(String[] args) throws IOException {
        ArrayList list = new ArrayList();
        list.add("hello world");
        String s = (String) list.get(0);
        System.out.println(s);
        list.add(new Integer(123));
        String s2 = (String) list.get(1);
        }
    }

则控制台会报错ClassCastException

@@ -1018,35 +1024,35 @@

泛型要解决上述问题，我们可以为String单独编写一种ArrayList

StringArrayList stringarraylist = new Stringarraylist()

底层就是String类型的数组了

-
1
2
3
4
5
6
7
public class StringArrayList {
    private String[] array;
    private int size;
    public void add(String e) {...}
    public void remove(int index) {...}
    public String get(int index) {...}
}
+
1
2
3
4
5
6
7
public class StringArrayList {
    private String[] array;
    private int size;
    public void add(String e) {...}
    public void remove(int index) {...}
    public String get(int index) {...}
}

这样一来，存入的必须是String，取出的也一定是String，不需要强制转型，因为编译器会强制检查放入的类型：

但是我们总不能针对Integer类型再写个IngtegerArrayList类型 针对Character再写个。。。

工程量十分的巨大 以及累赘

所以泛型的出现解决了这个问题

我们必须把ArrayList变成一种模板：ArrayList

-
1
2
3
4
5
6
7
public class ArrayList<T> {
    private T[] array;
    private int size;
    public void add(T e) {...}
    public void remove(int index) {...}
    public T get(int index) {...}
}
+
1
2
3
4
5
6
7
public class ArrayList<T> {
    private T[] array;
    private int size;
    public void add(T e) {...}
    public void remove(int index) {...}
    public T get(int index) {...}
}

T可以是任何class。这样一来，我们就实现了：编写一次模版，可以创建任意类型的ArrayList：

我们可以定义任何一种类型的ArrayList啦

-
1
2
3
ArrayList<String> stringArrayList = new ArrayList<>();
ArrayList<Integer> IntegerArrayList = new ArrayList<>();
ArrayList<Character> characterArrayList = new ArrayList<>();
+
1
2
3
ArrayList<String> stringArrayList = new ArrayList<>();
ArrayList<Integer> IntegerArrayList = new ArrayList<>();
ArrayList<Character> characterArrayList = new ArrayList<>();

这样一来，既实现了编写一次，万能匹配，又通过编译器保证了类型安全：这就是泛型。

向上转型

在Java标准库中的ArrayList<T>实现了List<T>接口，它可以向上转型为List<T>：

使用泛型

使用ArrayList时，如果不定义泛型类型时，泛型类型实际上就是Object：

-
1
ArrayList list = new ArrayList();//此为Object
+
1
ArrayList list = new ArrayList();//此为Object
-
1
2
3
4
5
List list = new ArrayList();
list.add("Hello");
list.add("World");
String first = list.get(0); //这里会报错 因为默认是Object对象 需要强转
String second = (String) list.get(1);
+
1
2
3
4
5
List list = new ArrayList();
list.add("Hello");
list.add("World");
String first = list.get(0); //这里会报错 因为默认是Object对象 需要强转
String second = (String) list.get(1);

当我们定义泛型 List<String> list = new List<>();

-
1
2
3
4
5
6
7
//无编译器警告:
    List<String> list = new ArrayList<String>();
    list.add("Hello");
    list.add("World");
// 无强制转型:
    String first = list.get(0);
    String second = list.get(1);
+
1
2
3
4
5
6
7
//无编译器警告:
    List<String> list = new ArrayList<String>();
    list.add("Hello");
    list.add("World");
// 无强制转型:
    String first = list.get(0);
    String second = list.get(1);

当我们定义泛型类型<Number>后，List<T>的泛型接口变为强类型List<Number>：

-
1
2
3
4
5
6
7
8
List<Number> list = new ArrayList<>();
list.add(3.14);//double类型
list.add(3.15);//float类型
list.add(1);//Integer类型
Number first = list.get(0);
Number second = list.get(1);
Number third = list.get(2);
System.out.println("first"+" "+first+" "+"second"+" "+second+" "+"third"+" "+third);
+
1
2
3
4
5
6
7
8
List<Number> list = new ArrayList<>();
list.add(3.14);//double类型
list.add(3.15);//float类型
list.add(1);//Integer类型
Number first = list.get(0);
Number second = list.get(1);
Number third = list.get(2);
System.out.println("first"+" "+first+" "+"second"+" "+second+" "+"third"+" "+third);

泛型接口

除了ArrayList<T>使用了泛型，还可以在接口中使用泛型。例如，Arrays.sort(Object[])可以对任意数组进行排序，但待排序的元素必须实现Comparable<T>这个泛型接口：

-
1
2
3
4
5
6
7
8
public interface Comparable<T> {
    /**
     * 返回负数: 当前实例比参数o小
     * 返回0: 当前实例与参数o相等
     * 返回正数: 当前实例比参数o大
     */
    int compareTo(T o);
}
+
1
2
3
4
5
6
7
8
public interface Comparable<T> {
    /**
     * 返回负数: 当前实例比参数o小
     * 返回0: 当前实例与参数o相等
     * 返回正数: 当前实例比参数o大
     */
    int compareTo(T o);
}
@@ -1143,9 +1149,9 @@

重新访问即可

Maven依赖

1
2
3
4
5
<!-- AMQP依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
+

重新访问即可

Maven依赖

1
2
3
4
5
<!-- AMQP依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
-

配置

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
application.yml

RabbitMQConfig.java

spring:

  \#RabbitMQ

 rabbitmq:

   \#服务器地址

  host: 192.168.10.100

   \#用户名

  username: guest

   \#密码

  password: guest

   \#虚拟主机

  virtual-host: /

   \#端口

  port: 5672

  listener:

   simple:

​     \#消费者最小数量

​    concurrency: 10

​     \#消费者最大数量

​    max-concurrency: 10

​     \#限制消费者每次只处理一条消息，处理完再继续下一条消息

​    prefetch: 1

​     \#启动时是否默认启动容器，默认true

​    auto-startup: true

​     \#被拒绝时重新进入队列

​    default-requeue-rejected: true

  template:

   retry:

​     \#发布重试，默认false

​    enabled: true

​     \#重试时间 默认1000ms

​    initial-interval: 1000

​     \#重试最大次数，默认3次

​    max-attempts: 3

​     \#重试最大间隔时间，默认10000ms

​    max-interval: 10000

​     \#重试间隔的乘数。比如配2.0 第一次等10s，第二次等20s，第三次等40s

​    multiplier: 1.0
+

配置

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
application.yml

RabbitMQConfig.java

spring:

  \#RabbitMQ

 rabbitmq:

   \#服务器地址

  host: 192.168.10.100

   \#用户名

  username: guest

   \#密码

  password: guest

   \#虚拟主机

  virtual-host: /

   \#端口

  port: 5672

  listener:

   simple:

​     \#消费者最小数量

​    concurrency: 10

​     \#消费者最大数量

​    max-concurrency: 10

​     \#限制消费者每次只处理一条消息，处理完再继续下一条消息

​    prefetch: 1

​     \#启动时是否默认启动容器，默认true

​    auto-startup: true

​     \#被拒绝时重新进入队列

​    default-requeue-rejected: true

  template:

   retry:

​     \#发布重试，默认false

​    enabled: true

​     \#重试时间 默认1000ms

​    initial-interval: 1000

​     \#重试最大次数，默认3次

​    max-attempts: 3

​     \#重试最大间隔时间，默认10000ms

​    max-interval: 10000

​     \#重试间隔的乘数。比如配2.0 第一次等10s，第二次等20s，第三次等40s

​    multiplier: 1.0
diff --git a/js/boot.js b/js/boot.js deleted file mode 100644 index 7c0dfea0e..000000000 --- a/js/boot.js +++ /dev/null @@ -1,16 +0,0 @@ -/* global Fluid */ - -Fluid.boot = {}; - -Fluid.boot.registerEvents = function() { - Fluid.events.billboard(); - Fluid.events.registerNavbarEvent(); - Fluid.events.registerParallaxEvent(); - Fluid.events.registerScrollDownArrowEvent(); - Fluid.events.registerScrollTopArrowEvent(); - Fluid.events.registerImageLoadedEvent(); -}; - -document.addEventListener('DOMContentLoaded', function() { - Fluid.boot.registerEvents(); -}); diff --git a/js/color-schema.js b/js/color-schema.js deleted file mode 100644 index 14f458287..000000000 --- a/js/color-schema.js +++ /dev/null @@ -1,266 +0,0 @@ -/* global Fluid */ - -/** - * Modified from https://blog.skk.moe/post/hello-darkmode-my-old-friend/ - */ -(function(window, document) { - var rootElement = document.documentElement; - var colorSchemaStorageKey = 'Fluid_Color_Scheme'; - var colorSchemaMediaQueryKey = '--color-mode'; - var userColorSchemaAttributeName = 'data-user-color-scheme'; - var defaultColorSchemaAttributeName = 'data-default-color-scheme'; - var colorToggleButtonSelector = '#color-toggle-btn'; - var colorToggleIconSelector = '#color-toggle-icon'; - - function setLS(k, v) { - try { - localStorage.setItem(k, v); - } catch (e) {} - } - - function removeLS(k) { - try { - localStorage.removeItem(k); - } catch (e) {} - } - - function getLS(k) { - try { - return localStorage.getItem(k); - } catch (e) { - return null; - } - } - - function getSchemaFromHTML() { - var res = rootElement.getAttribute(defaultColorSchemaAttributeName); - if (typeof res === 'string') { - return res.replace(/["'\s]/g, ''); - } - return null; - } - - function getSchemaFromCSSMediaQuery() { - var res = getComputedStyle(rootElement).getPropertyValue( - colorSchemaMediaQueryKey - ); - if (typeof res === 'string') { - return res.replace(/["'\s]/g, ''); - } - return null; - } - - function resetSchemaAttributeAndLS() { - rootElement.setAttribute(userColorSchemaAttributeName, getDefaultColorSchema()); - removeLS(colorSchemaStorageKey); - } - - var validColorSchemaKeys = { - dark : true, - light: true - }; - - function getDefaultColorSchema() { - // 取默认字段的值 - var schema = getSchemaFromHTML(); - // 如果明确指定了 schema 则返回 - if (validColorSchemaKeys[schema]) { - return schema; - } - // 默认优先按 prefers-color-scheme - schema = getSchemaFromCSSMediaQuery(); - if (validColorSchemaKeys[schema]) { - return schema; - } - // 否则按本地时间是否大于 18 点或凌晨 0 ~ 6 点 - var hours = new Date().getHours(); - if (hours >= 18 || (hours >= 0 && hours <= 6)) { - return 'dark'; - } - return 'light'; - } - - function applyCustomColorSchemaSettings(schema) { - // 接受从「开关」处传来的模式，或者从 localStorage 读取，否则按默认设置值 - var current = schema || getLS(colorSchemaStorageKey) || getDefaultColorSchema(); - - if (current === getDefaultColorSchema()) { - // 当用户切换的显示模式和默认模式相同时，则恢复为自动模式 - resetSchemaAttributeAndLS(); - } else if (validColorSchemaKeys[current]) { - rootElement.setAttribute( - userColorSchemaAttributeName, - current - ); - } else { - // 特殊情况重置 - resetSchemaAttributeAndLS(); - return; - } - - // 根据当前模式设置图标 - setButtonIcon(current); - - // 设置代码高亮 - setHighlightCSS(current); - - // 设置其他应用 - setApplications(current); - } - - var invertColorSchemaObj = { - dark : 'light', - light: 'dark' - }; - - function getIconClass(scheme) { - return 'icon-' + scheme; - } - - function toggleCustomColorSchema() { - var currentSetting = getLS(colorSchemaStorageKey); - - if (validColorSchemaKeys[currentSetting]) { - // 从 localStorage 中读取模式，并取相反的模式 - currentSetting = invertColorSchemaObj[currentSetting]; - } else if (currentSetting === null) { - // 当 localStorage 中没有相关值，或者 localStorage 抛了 Error - // 先按照按钮的状态进行切换 - var iconElement = document.querySelector(colorToggleIconSelector); - if (iconElement) { - currentSetting = iconElement.getAttribute('data'); - } - if (!iconElement || !validColorSchemaKeys[currentSetting]) { - // 当 localStorage 中没有相关值，或者 localStorage 抛了 Error，则读取默认值并切换到相反的模式 - currentSetting = invertColorSchemaObj[getSchemaFromCSSMediaQuery()]; - } - } else { - return; - } - // 将相反的模式写入 localStorage - setLS(colorSchemaStorageKey, currentSetting); - - return currentSetting; - } - - function setButtonIcon(schema) { - if (validColorSchemaKeys[schema]) { - // 切换图标 - var icon = getIconClass('dark'); - if (schema) { - icon = getIconClass(schema); - } - var iconElement = document.querySelector(colorToggleIconSelector); - if (iconElement) { - iconElement.setAttribute( - 'class', - 'iconfont ' + icon - ); - iconElement.setAttribute( - 'data', - invertColorSchemaObj[schema] - ); - } else { - // 如果图标不存在则说明图标还没加载出来，等到页面全部加载再尝试切换 - Fluid.utils.waitElementLoaded(colorToggleIconSelector, function() { - var iconElement = document.querySelector(colorToggleIconSelector); - if (iconElement) { - iconElement.setAttribute( - 'class', - 'iconfont ' + icon - ); - iconElement.setAttribute( - 'data', - invertColorSchemaObj[schema] - ); - } - }); - } - } - } - - function setHighlightCSS(schema) { - // 启用对应的代码高亮的样式 - var lightCss = document.getElementById('highlight-css'); - var darkCss = document.getElementById('highlight-css-dark'); - if (schema === 'dark') { - if (darkCss) { - darkCss.removeAttribute('disabled'); - } - if (lightCss) { - lightCss.setAttribute('disabled', ''); - } - } else { - if (lightCss) { - lightCss.removeAttribute('disabled'); - } - if (darkCss) { - darkCss.setAttribute('disabled', ''); - } - } - - setTimeout(function() { - // 设置代码块组件样式 - document.querySelectorAll('.markdown-body pre').forEach((pre) => { - var cls = Fluid.utils.getBackgroundLightness(pre) >= 0 ? 'code-widget-light' : 'code-widget-dark'; - var widget = pre.querySelector('.code-widget-light, .code-widget-dark'); - if (widget) { - widget.classList.remove('code-widget-light', 'code-widget-dark'); - widget.classList.add(cls); - } - }); - }, 200); - } - - function setApplications(schema) { - // 设置 remark42 评论主题 - if (window.REMARK42) { - window.REMARK42.changeTheme(schema); - } - - // 设置 cusdis 评论主题 - if (window.CUSDIS) { - window.CUSDIS.setTheme(schema); - } - - // 设置 utterances 评论主题 - var utterances = document.querySelector('.utterances-frame'); - if (utterances) { - var theme = window.UtterancesThemeLight; - if (schema === 'dark') { - theme = window.UtterancesThemeDark; - } - const message = { - type : 'set-theme', - theme: theme - }; - utterances.contentWindow.postMessage(message, 'https://utteranc.es'); - } - } - - // 当页面加载时，将显示模式设置为 localStorage 中自定义的值（如果有的话） - applyCustomColorSchemaSettings(); - - Fluid.utils.waitElementLoaded(colorToggleIconSelector, function() { - applyCustomColorSchemaSettings(); - var button = document.querySelector(colorToggleButtonSelector); - if (button) { - // 当用户点击切换按钮时，获得新的显示模式、写入 localStorage、并在页面上生效 - button.addEventListener('click', function() { - applyCustomColorSchemaSettings(toggleCustomColorSchema()); - }); - var icon = document.querySelector(colorToggleIconSelector); - if (icon) { - // 光标悬停在按钮上时，切换图标 - button.addEventListener('mouseenter', function() { - var current = icon.getAttribute('data'); - icon.classList.replace(getIconClass(invertColorSchemaObj[current]), getIconClass(current)); - }); - button.addEventListener('mouseleave', function() { - var current = icon.getAttribute('data'); - icon.classList.replace(getIconClass(current), getIconClass(invertColorSchemaObj[current])); - }); - } - } - }); -})(window, document); diff --git a/js/events.js b/js/events.js deleted file mode 100644 index e13ed077b..000000000 --- a/js/events.js +++ /dev/null @@ -1,167 +0,0 @@ -/* global Fluid */ - -HTMLElement.prototype.wrap = function(wrapper) { - this.parentNode.insertBefore(wrapper, this); - this.parentNode.removeChild(this); - wrapper.appendChild(this); -}; - -Fluid.events = { - - registerNavbarEvent: function() { - var navbar = jQuery('#navbar'); - if (navbar.length === 0) { - return; - } - var submenu = jQuery('#navbar .dropdown-menu'); - if (navbar.offset().top > 0) { - navbar.removeClass('navbar-dark'); - submenu.removeClass('navbar-dark'); - } - Fluid.utils.listenScroll(function() { - navbar[navbar.offset().top > 50 ? 'addClass' : 'removeClass']('top-nav-collapse'); - submenu[navbar.offset().top > 50 ? 'addClass' : 'removeClass']('dropdown-collapse'); - if (navbar.offset().top > 0) { - navbar.removeClass('navbar-dark'); - submenu.removeClass('navbar-dark'); - } else { - navbar.addClass('navbar-dark'); - submenu.removeClass('navbar-dark'); - } - }); - jQuery('#navbar-toggler-btn').on('click', function() { - jQuery('.animated-icon').toggleClass('open'); - jQuery('#navbar').toggleClass('navbar-col-show'); - }); - }, - - registerParallaxEvent: function() { - var ph = jQuery('#banner[parallax="true"]'); - if (ph.length === 0) { - return; - } - var board = jQuery('#board'); - if (board.length === 0) { - return; - } - var parallax = function() { - var pxv = jQuery(window).scrollTop() / 5; - var offset = parseInt(board.css('margin-top'), 10); - var max = 96 + offset; - if (pxv > max) { - pxv = max; - } - ph.css({ - transform: 'translate3d(0,' + pxv + 'px,0)' - }); - var sideCol = jQuery('.side-col'); - if (sideCol) { - sideCol.css({ - 'padding-top': pxv + 'px' - }); - } - }; - Fluid.utils.listenScroll(parallax); - }, - - registerScrollDownArrowEvent: function() { - var scrollbar = jQuery('.scroll-down-bar'); - if (scrollbar.length === 0) { - return; - } - scrollbar.on('click', function() { - Fluid.utils.scrollToElement('#board', -jQuery('#navbar').height()); - }); - }, - - registerScrollTopArrowEvent: function() { - var topArrow = jQuery('#scroll-top-button'); - if (topArrow.length === 0) { - return; - } - var board = jQuery('#board'); - if (board.length === 0) { - return; - } - var posDisplay = false; - var scrollDisplay = false; - // Position - var setTopArrowPos = function() { - var boardRight = board[0].getClientRects()[0].right; - var bodyWidth = document.body.offsetWidth; - var right = bodyWidth - boardRight; - posDisplay = right >= 50; - topArrow.css({ - 'bottom': posDisplay && scrollDisplay ? '20px' : '-60px', - 'right' : right - 64 + 'px' - }); - }; - setTopArrowPos(); - jQuery(window).resize(setTopArrowPos); - // Display - var headerHeight = board.offset().top; - Fluid.utils.listenScroll(function() { - var scrollHeight = document.body.scrollTop + document.documentElement.scrollTop; - scrollDisplay = scrollHeight >= headerHeight; - topArrow.css({ - 'bottom': posDisplay && scrollDisplay ? '20px' : '-60px' - }); - }); - // Click - topArrow.on('click', function() { - jQuery('body,html').animate({ - scrollTop: 0, - easing : 'swing' - }); - }); - }, - - registerImageLoadedEvent: function() { - if (!('NProgress' in window)) { return; } - - var bg = document.getElementById('banner'); - if (bg) { - var src = bg.style.backgroundImage; - var url = src.match(/\((.*?)\)/)[1].replace(/(['"])/g, ''); - var img = new Image(); - img.onload = function() { - window.NProgress && window.NProgress.inc(0.2); - }; - img.src = url; - if (img.complete) { img.onload(); } - } - - var notLazyImages = jQuery('main img:not([lazyload])'); - var total = notLazyImages.length; - for (const img of notLazyImages) { - const old = img.onload; - img.onload = function() { - old && old(); - window.NProgress && window.NProgress.inc(0.5 / total); - }; - if (img.complete) { img.onload(); } - } - }, - - billboard: function() { - if (!('console' in window)) { - return; - } - // eslint-disable-next-line no-console - console.log(` ------------------------------------------------- -| | -| ________ __ _ __ | -| |_ __ |[ | (_) | ] | -| | |_ \\_| | | __ _ __ .--.| | | -| | _| | |[ | | | [ |/ /'\`\\' | | -| _| |_ | | | \\_/ |, | || \\__/ | | -| |_____| [___]'.__.'_/[___]'.__.;__] | -| | -| Powered by Hexo x Fluid | -| GitHub: https://git.io/JqpVD | -| | ------------------------------------------------- - `); - } -}; diff --git a/js/img-lazyload.js b/js/img-lazyload.js deleted file mode 100644 index c0c8e4ef7..000000000 --- a/js/img-lazyload.js +++ /dev/null @@ -1,10 +0,0 @@ -/* global Fluid, CONFIG */ - -(function(window, document) { - for (const each of document.querySelectorAll('img[lazyload]')) { - Fluid.utils.waitElementVisible(each, function() { - each.removeAttribute('srcset'); - each.removeAttribute('lazyload'); - }, CONFIG.lazyload.offset_factor); - } -})(window, document); diff --git a/js/leancloud.js b/js/leancloud.js deleted file mode 100644 index 568faae92..000000000 --- a/js/leancloud.js +++ /dev/null @@ -1,194 +0,0 @@ -/* global CONFIG */ - -(function(window, document) { - // 查询存储的记录 - function getRecord(Counter, target) { - return new Promise(function(resolve, reject) { - Counter('get', '/classes/Counter?where=' + encodeURIComponent(JSON.stringify({ target }))) - .then(resp => resp.json()) - .then(({ results, code, error }) => { - if (code === 401) { - throw error; - } - if (results && results.length > 0) { - var record = results[0]; - resolve(record); - } else { - Counter('post', '/classes/Counter', { target, time: 0 }) - .then(resp => resp.json()) - .then((record, error) => { - if (error) { - throw error; - } - resolve(record); - }).catch(error => { - // eslint-disable-next-line no-console - console.error('Failed to create', error); - reject(error); - }); - } - }).catch((error) => { - // eslint-disable-next-line no-console - console.error('LeanCloud Counter Error:', error); - reject(error); - }); - }); - } - - // 发起自增请求 - function increment(Counter, incrArr) { - return new Promise(function(resolve, reject) { - Counter('post', '/batch', { - 'requests': incrArr - }).then((res) => { - res = res.json(); - if (res.error) { - throw res.error; - } - resolve(res); - }).catch((error) => { - // eslint-disable-next-line no-console - console.error('Failed to save visitor count', error); - reject(error); - }); - }); - } - - // 构建自增请求体 - function buildIncrement(objectId) { - return { - 'method': 'PUT', - 'path' : `/1.1/classes/Counter/${objectId}`, - 'body' : { - 'time': { - '__op' : 'Increment', - 'amount': 1 - } - } - }; - } - - // 校验是否为有效的 Host - function validHost() { - if (CONFIG.web_analytics.leancloud.ignore_local) { - var hostname = window.location.hostname; - if (hostname === 'localhost' || hostname === '127.0.0.1') { - return false; - } - } - return true; - } - - // 校验是否为有效的 UV - function validUV() { - var key = 'LeanCloud_UV_Flag'; - var flag = localStorage.getItem(key); - if (flag) { - // 距离标记小于 24 小时则不计为 UV - if (new Date().getTime() - parseInt(flag, 10) <= 86400000) { - return false; - } - } - localStorage.setItem(key, new Date().getTime().toString()); - return true; - } - - function addCount(Counter) { - var enableIncr = CONFIG.web_analytics.enable && !Fluid.ctx.dnt && validHost(); - var getterArr = []; - var incrArr = []; - - // 请求 PV 并自增 - var pvCtn = document.querySelector('#leancloud-site-pv-container'); - if (pvCtn) { - var pvGetter = getRecord(Counter, 'site-pv').then((record) => { - enableIncr && incrArr.push(buildIncrement(record.objectId)); - var ele = document.querySelector('#leancloud-site-pv'); - if (ele) { - ele.innerText = (record.time || 0) + (enableIncr ? 1 : 0); - pvCtn.style.display = 'inline'; - } - }); - getterArr.push(pvGetter); - } - - // 请求 UV 并自增 - var uvCtn = document.querySelector('#leancloud-site-uv-container'); - if (uvCtn) { - var uvGetter = getRecord(Counter, 'site-uv').then((record) => { - var incrUV = validUV() && enableIncr; - incrUV && incrArr.push(buildIncrement(record.objectId)); - var ele = document.querySelector('#leancloud-site-uv'); - if (ele) { - ele.innerText = (record.time || 0) + (incrUV ? 1 : 0); - uvCtn.style.display = 'inline'; - } - }); - getterArr.push(uvGetter); - } - - // 如果有页面浏览数节点，则请求浏览数并自增 - var viewCtn = document.querySelector('#leancloud-page-views-container'); - if (viewCtn) { - var path = eval(CONFIG.web_analytics.leancloud.path || 'window.location.pathname'); - var target = decodeURI(path.replace(/\/*(index.html)?$/, '/')); - var viewGetter = getRecord(Counter, target).then((record) => { - enableIncr && incrArr.push(buildIncrement(record.objectId)); - var ele = document.querySelector('#leancloud-page-views'); - if (ele) { - ele.innerText = (record.time || 0) + (enableIncr ? 1 : 0); - viewCtn.style.display = 'inline'; - } - }); - getterArr.push(viewGetter); - } - - // 如果启动计数自增，批量发起自增请求 - if (enableIncr) { - Promise.all(getterArr).then(() => { - incrArr.length > 0 && increment(Counter, incrArr); - }); - } - } - - var appId = CONFIG.web_analytics.leancloud.app_id; - var appKey = CONFIG.web_analytics.leancloud.app_key; - var serverUrl = CONFIG.web_analytics.leancloud.server_url; - - if (!appId) { - throw new Error('LeanCloud appId is empty'); - } - if (!appKey) { - throw new Error('LeanCloud appKey is empty'); - } - - function fetchData(api_server) { - var Counter = (method, url, data) => { - return fetch(`${api_server}/1.1${url}`, { - method, - headers: { - 'X-LC-Id' : appId, - 'X-LC-Key' : appKey, - 'Content-Type': 'application/json' - }, - body: JSON.stringify(data) - }); - }; - - addCount(Counter); - } - - var apiServer = serverUrl || `https://${appId.slice(0, 8).toLowerCase()}.api.lncldglobal.com`; - - if (apiServer) { - fetchData(apiServer); - } else { - fetch('https://app-router.leancloud.cn/2/route?appId=' + appId) - .then(resp => resp.json()) - .then((data) => { - if (data.api_server) { - fetchData('https://' + data.api_server); - } - }); - } -})(window, document); diff --git a/js/plugins.js b/js/plugins.js deleted file mode 100644 index ba89b89d1..000000000 --- a/js/plugins.js +++ /dev/null @@ -1,99 +0,0 @@ -/* global Fluid, CONFIG */ - -HTMLElement.prototype.wrap = function(wrapper) { - this.parentNode.insertBefore(wrapper, this); - this.parentNode.removeChild(this); - wrapper.appendChild(this); -}; - -Fluid.plugins = { - - typing: function(text) { - if (!('Typed' in window)) { return; } - - var typed = new window.Typed('#subtitle', { - strings: [ - ' ', - text + ' ' - ], - cursorChar: CONFIG.typing.cursorChar, - typeSpeed : CONFIG.typing.typeSpeed, - loop : CONFIG.typing.loop - }); - typed.stop(); - var subtitle = document.getElementById('subtitle'); - if (subtitle) { - subtitle.innerText = ''; - } - jQuery(document).ready(function() { - typed.start(); - }); - }, - - fancyBox: function(selector) { - if (!CONFIG.image_zoom.enable || !('fancybox' in jQuery)) { return; } - - jQuery(selector || '.markdown-body :not(a) > img, .markdown-body > img').each(function() { - var $image = jQuery(this); - var imageUrl = $image.attr('data-src') || $image.attr('src') || ''; - if (CONFIG.image_zoom.img_url_replace) { - var rep = CONFIG.image_zoom.img_url_replace; - var r1 = rep[0] || ''; - var r2 = rep[1] || ''; - if (r1) { - if (/^re:/.test(r1)) { - r1 = r1.replace(/^re:/, ''); - var reg = new RegExp(r1, 'gi'); - imageUrl = imageUrl.replace(reg, r2); - } else { - imageUrl = imageUrl.replace(r1, r2); - } - } - } - var $imageWrap = $image.wrap(` - ` - ).parent('a'); - if ($imageWrap.length !== 0) { - if ($image.is('.group-image-container img')) { - $imageWrap.attr('data-fancybox', 'group').attr('rel', 'group'); - } else { - $imageWrap.attr('data-fancybox', 'default').attr('rel', 'default'); - } - - var imageTitle = $image.attr('title') || $image.attr('alt'); - if (imageTitle) { - $imageWrap.attr('title', imageTitle).attr('data-caption', imageTitle); - } - } - }); - - jQuery.fancybox.defaults.hash = false; - jQuery('.fancybox').fancybox({ - loop : true, - helpers: { - overlay: { - locked: false - } - } - }); - }, - - imageCaption: function(selector) { - if (!CONFIG.image_caption.enable) { return; } - - jQuery(selector || `.markdown-body > p > img, .markdown-body > figure > img, - .markdown-body > p > a.fancybox, .markdown-body > figure > a.fancybox`).each(function() { - var $target = jQuery(this); - var $figcaption = $target.next('figcaption'); - if ($figcaption.length !== 0) { - $figcaption.addClass('image-caption'); - } else { - var imageTitle = $target.attr('title') || $target.attr('alt'); - if (imageTitle) { - $target.after(``); - } - } - }); - } -}; diff --git a/page/2/index.html b/page/2/index.html index 5fc7b449c..234862144 100644 --- a/page/2/index.html +++ b/page/2/index.html @@ -756,21 +756,21 @@

2.请简要说明Servlet中的生命周期

1.Servlet初始化后调用Init()方法

2.Servlet调用service()方法来处理客户端的请求。

3.Servlet销毁前调用destroy()方法终止

-

3.开启两个线程A,B，打印1到10 线程A打印奇数(1,3,5,7,9),线程B打印偶数(2,4,6,8,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
27
28
29
package com.yuewen;

import java.util.Scanner;
import java.util.concurrent.locks.LockSupport;

public class ABXianC {
    static Thread thread1;
    static Thread thread2;
    public static void main(String[] args) {
                thread1 = new Thread(() -> {
            for (int i = 1; i <= 9; i += 2) {
                System.out.println(i);
                LockSupport.unpark(thread2);
                LockSupport.park();
            }
        });
        thread2 = new Thread(() -> {
            for (int i = 2; i <= 10; i = i + 2) {
                LockSupport.park();
                System.out.println(i);
                LockSupport.unpark(thread1);
            }
        });
        thread1.start();
        thread2.start();
    }

}

+

3.开启两个线程A,B，打印1到10 线程A打印奇数(1,3,5,7,9),线程B打印偶数(2,4,6,8,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
27
28
29
package com.yuewen;

import java.util.Scanner;
import java.util.concurrent.locks.LockSupport;

public class ABXianC {
    static Thread thread1;
    static Thread thread2;
    public static void main(String[] args) {
                thread1 = new Thread(() -> {
            for (int i = 1; i <= 9; i += 2) {
                System.out.println(i);
                LockSupport.unpark(thread2);
                LockSupport.park();
            }
        });
        thread2 = new Thread(() -> {
            for (int i = 2; i <= 10; i = i + 2) {
                LockSupport.park();
                System.out.println(i);
                LockSupport.unpark(thread1);
            }
        });
        thread1.start();
        thread2.start();
    }

}

-

4.请编写代码实现单例模式,类名为Singletion

1.饿汉模式

1
2
3
4
5
6
public class Singleton{
    static private Singleton instance = new Singleton();//因为无法实例化，所以必须是静态的
    static public Singleton getInstance(){
        return instance;
    }
}
+

4.请编写代码实现单例模式,类名为Singletion

1.饿汉模式

1
2
3
4
5
6
public class Singleton{
    static private Singleton instance = new Singleton();//因为无法实例化，所以必须是静态的
    static public Singleton getInstance(){
        return instance;
    }
}
-

2.懒汉线程安全

1
2
3
4
5
6
7
8
9
10
11
12
package com.yuewen;

import java.util.Scanner;

public class Singletion {
    private static Singleton instance;
    private Singletion(){};
    public static synchronized Singleton getInstance(){
        if(instance == null) instance = new Singleton();
        return instance;
    }
}
+

2.懒汉线程安全

1
2
3
4
5
6
7
8
9
10
11
12
package com.yuewen;

import java.util.Scanner;

public class Singletion {
    private static Singleton instance;
    private Singletion(){};
    public static synchronized Singleton getInstance(){
        if(instance == null) instance = new Singleton();
        return instance;
    }
}
-

5.写一个Map转换成JavaBean的工具类方法，实现如下mapToObject方法(使用Java反射，不允许使用第三方库)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public static Object mapToObject(Map<String,Object> map,Class<?> beanClass){
    if(map == null) return null;
    Object obj = null;
    try{
        obj = beanClass.newInstance();
        Field[] fields = obj.getClass().getDeclaredFields();
        for(Field field : fields)
        {
           int mod = field.getModifiers();
           if(Modifier.isStatic(mod) || Modifier.isFinal(mod)){
				continue;
           }
            field.setAccessible(true);
            field.set(obj,map.get(field.getName()));
        }
        catch(Exception e)
            e.printStackTrace();
        }
        return obj;
    }
}
+

5.写一个Map转换成JavaBean的工具类方法，实现如下mapToObject方法(使用Java反射，不允许使用第三方库)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public static Object mapToObject(Map<String,Object> map,Class<?> beanClass){
    if(map == null) return null;
    Object obj = null;
    try{
        obj = beanClass.newInstance();
        Field[] fields = obj.getClass().getDeclaredFields();
        for(Field field : fields)
        {
           int mod = field.getModifiers();
           if(Modifier.isStatic(mod) || Modifier.isFinal(mod)){
				continue;
           }
            field.setAccessible(true);
            field.set(obj,map.get(field.getName()));
        }
        catch(Exception e)
            e.printStackTrace();
        }
        return obj;
    }
}

6.数据库操作是我们经常使用的一个技能， 请你完成一个简单的用户密码验证过程 ，给定的条件如下：

数据库中存在个用户表:users ,表结构如下：

-
1
2
3
4
5
6
7
CREATE TABLE `users` (
  `uid` bigint(20) NOT NULL COMMENT '用户ID',
  `user_name` varchar(32) NOT NULL  COMMENT '用户账号',
  `password` varchar(64) NOT NULL  COMMENT '用户混淆密码',
  PRIMARY KEY (`uid`),
  UNIQUE KEY `u_user_name` (`user_name`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户表'
+
1
2
3
4
5
6
7
CREATE TABLE `users` (
  `uid` bigint(20) NOT NULL COMMENT '用户ID',
  `user_name` varchar(32) NOT NULL  COMMENT '用户账号',
  `password` varchar(64) NOT NULL  COMMENT '用户混淆密码',
  PRIMARY KEY (`uid`),
  UNIQUE KEY `u_user_name` (`user_name`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户表'

完善以下方法

public boolean verifyPassword(String username,String password) {
Connection con = getConnection () ;// getConnection（） 方法是个已有的方法可以获取到数据库连接 ，

// here is your code
}

-
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
public boolean verifyPassword(String username,String password){
        Connection con=getConnection;
        String sql="SELECT password FROM users WHERE user_name=?";
        PreparedStatement pst=null;
        ResultSet rs=null;
        boolean flag=false;
        try{
            pst=con.prepareStatement(sql);
            pst.setObject(1,username);
            rs=pst.executeQuery();
            while(rs.next()){
                if(rs.getString("password").equals(password)){
                    flag=true;
                }
            }
        }catch(ClassNotFoundException e){
            e.printStackTrace();
        }catch (SQLException e){
            e.printStackTrace();
        }finally {
            try{
                if(rs!=null) rs.close();
                if(pst!=null) pst.close();
                if(con!=null) con.close();
            }catch(SQLException e){
                e.printStackTrace();
            }
        }
        return flag;
    }

+
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
public boolean verifyPassword(String username,String password){
        Connection con=getConnection;
        String sql="SELECT password FROM users WHERE user_name=?";
        PreparedStatement pst=null;
        ResultSet rs=null;
        boolean flag=false;
        try{
            pst=con.prepareStatement(sql);
            pst.setObject(1,username);
            rs=pst.executeQuery();
            while(rs.next()){
                if(rs.getString("password").equals(password)){
                    flag=true;
                }
            }
        }catch(ClassNotFoundException e){
            e.printStackTrace();
        }catch (SQLException e){
            e.printStackTrace();
        }finally {
            try{
                if(rs!=null) rs.close();
                if(pst!=null) pst.close();
                if(con!=null) con.close();
            }catch(SQLException e){
                e.printStackTrace();
            }
        }
        return flag;
    }

7.介绍HashMap的数据结构、扩容机制，HashMap与Hashtable的区别，是否是线程安全的，并介绍ConcurrentHashMap的实现机制。

HashMap JDK1.8之前 数组+链表

JDK1.8之后 数组+链表+红黑树

@@ -817,7 +817,7 @@

14 建立三个线程A、B、C，A线程打印10次字母A，B线程打印10次字母B,C线程打印10次字母C，但是要求三个线程同时运行，并且实现交替打印，即按照ABCABCABC的顺序打印。

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
package com.yuewen;

import java.util.Scanner;
import java.util.concurrent.locks.LockSupport;
public class ABC {
    static Thread A, B, C;

    public static void main(String[] args) {
        A = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                LockSupport.park();
                System.out.print("A");
                LockSupport.unpark(B);
            }
        });
        B = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                LockSupport.park();
                System.out.print("B");
                LockSupport.unpark(C);
            }
        });
        C = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                LockSupport.unpark(A);
                LockSupport.park();
                System.out.print("C");
            }
        });
        A.start();
        B.start();
        C.start();
    }
}

+

14 建立三个线程A、B、C，A线程打印10次字母A，B线程打印10次字母B,C线程打印10次字母C，但是要求三个线程同时运行，并且实现交替打印，即按照ABCABCABC的顺序打印。

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
package com.yuewen;

import java.util.Scanner;
import java.util.concurrent.locks.LockSupport;
public class ABC {
    static Thread A, B, C;

    public static void main(String[] args) {
        A = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                LockSupport.park();
                System.out.print("A");
                LockSupport.unpark(B);
            }
        });
        B = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                LockSupport.park();
                System.out.print("B");
                LockSupport.unpark(C);
            }
        });
        C = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                LockSupport.unpark(A);
                LockSupport.park();
                System.out.print("C");
            }
        });
        A.start();
        B.start();
        C.start();
    }
}

15 请列举5个spring框架中的注解，并说明注解的用法以及使用场景

  • @component 标注一个POJO类
    • @@ -830,53 +830,53 @@

    16 给定一组自然数，数字的值有可能会大于2^64 ，要求计算出所有数字的和

    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
    import org.junit.Test;

    import java.util.ArrayList;

    public class Solution {

        /**
         * 计算一组数字的和
         * @param numbers string字符串ArrayList 一组自然数
         * @return string字符串
         */
        public String sum (ArrayList<String> numbers) {
            // write code here

            String result="0";
            for (String number : numbers) {

                if(number==null||number.length()==0){
                    continue;
                }
                int resultLen = result.length();
                int curNumLen = number.length();
                int sum=0;
                int remain;
                StringBuilder stringBuilder = new StringBuilder();
                while (resultLen>0||curNumLen>0){

                    int resultNum=0;
                    if(resultLen>0){
                        resultNum = result.charAt(--resultLen) - '0';
                    }

                    int curNum=0;
                    if(curNumLen>0){
                        curNum = number.charAt(--curNumLen) - '0';
                    }

                    sum=sum+resultNum+curNum;
                    remain=sum%10;
                    stringBuilder.append(remain);
                    sum/=10;
                }

                if(sum!=0){
                    stringBuilder.append(sum);
                }
                result=stringBuilder.reverse().toString();


            }

            return result;
        }

        @Test
        public void test(){

            String num1="123456";
            String num2="123456789";
            String num3="123456789123";
            ArrayList<String> strings = new ArrayList<>();
            strings.add(num1);
            strings.add(num2);
            strings.add(num3);
            System.out.println(sum(strings));
        }
    }

    +

    16 给定一组自然数，数字的值有可能会大于2^64 ，要求计算出所有数字的和

    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
    import org.junit.Test;

    import java.util.ArrayList;

    public class Solution {

        /**
         * 计算一组数字的和
         * @param numbers string字符串ArrayList 一组自然数
         * @return string字符串
         */
        public String sum (ArrayList<String> numbers) {
            // write code here

            String result="0";
            for (String number : numbers) {

                if(number==null||number.length()==0){
                    continue;
                }
                int resultLen = result.length();
                int curNumLen = number.length();
                int sum=0;
                int remain;
                StringBuilder stringBuilder = new StringBuilder();
                while (resultLen>0||curNumLen>0){

                    int resultNum=0;
                    if(resultLen>0){
                        resultNum = result.charAt(--resultLen) - '0';
                    }

                    int curNum=0;
                    if(curNumLen>0){
                        curNum = number.charAt(--curNumLen) - '0';
                    }

                    sum=sum+resultNum+curNum;
                    remain=sum%10;
                    stringBuilder.append(remain);
                    sum/=10;
                }

                if(sum!=0){
                    stringBuilder.append(sum);
                }
                result=stringBuilder.reverse().toString();


            }

            return result;
        }

        @Test
        public void test(){

            String num1="123456";
            String num2="123456789";
            String num3="123456789123";
            ArrayList<String> strings = new ArrayList<>();
            strings.add(num1);
            strings.add(num2);
            strings.add(num3);
            System.out.println(sum(strings));
        }
    }

    -

    17 给定一个int数字 要求计算出int数字对应的二进制中1的个数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    package com.yuewen;

    import java.util.Scanner;

    public class Erjinzhi {
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            int n = scanner.nextInt();
            int ans = 0;
            while (n > 0){
                n = n & (n-1);
                ans++;
            }
            System.out.println(ans);
        }

    }

    +

    17 给定一个int数字 要求计算出int数字对应的二进制中1的个数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    package com.yuewen;

    import java.util.Scanner;

    public class Erjinzhi {
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            int n = scanner.nextInt();
            int ans = 0;
            while (n > 0){
                n = n & (n-1);
                ans++;
            }
            System.out.println(ans);
        }

    }

    -

    18 根据产品策略某本书可以设置包月到期时间，需要计算指定时间到包月到期时间还有多少分钟,不足60S的不计入。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    public static String dateSub(String a, String b) {
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            sdf.parse(a);
            LocalDateTime t1 =  LocalDateTime.parse(a, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")),
            t2 = LocalDateTime.parse(b, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
            long pass = t1.until(t2, ChronoUnit.MINUTES);
            return String.valueOf(Math.abs(pass));
        } catch (Exception e) {
            System.out.println(String.format("格式转化错误：%s, 检查是否格式输入错误", e.getMessage()));
        }
        return "0";
    }

    public static void main(String[] args) {
        System.out.println("请输入指定的两个日期【小者在前，大者在后，格式：yyyy-MM-dd hh:mm:ss】:");
        Scanner sc = new Scanner(System.in);
        String a = sc.nextLine(), b = sc.nextLine();
        sc.close();
        System.out.println(dateSub(a, b));
    }
    +

    18 根据产品策略某本书可以设置包月到期时间，需要计算指定时间到包月到期时间还有多少分钟,不足60S的不计入。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    public static String dateSub(String a, String b) {
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            sdf.parse(a);
            LocalDateTime t1 =  LocalDateTime.parse(a, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")),
            t2 = LocalDateTime.parse(b, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
            long pass = t1.until(t2, ChronoUnit.MINUTES);
            return String.valueOf(Math.abs(pass));
        } catch (Exception e) {
            System.out.println(String.format("格式转化错误：%s, 检查是否格式输入错误", e.getMessage()));
        }
        return "0";
    }

    public static void main(String[] args) {
        System.out.println("请输入指定的两个日期【小者在前，大者在后，格式：yyyy-MM-dd hh:mm:ss】:");
        Scanner sc = new Scanner(System.in);
        String a = sc.nextLine(), b = sc.nextLine();
        sc.close();
        System.out.println(dateSub(a, b));
    }
    -

    19 map是一种开发过程中经常使用的k-v数据结构，有个map保存了书名和书字数的关系，编写代码对map里面的书按照字数进行升序排序

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    public static Map<String, Integer> sortMap(Map<String, Integer> map) {
        TreeMap<Integer, List<String>> treeMap = new TreeMap<>();
        map.entrySet().forEach(entry -> {
            List<String> indexList = treeMap.computeIfAbsent(entry.getValue(), k -> new ArrayList<>());
            indexList.add(entry.getKey());
        });
        Map<String, Integer> result = new ListOrderedMap();
        treeMap.entrySet().forEach(entry -> {
            entry.getValue().forEach(key -> result.put(key, map.get(key)));
        });
        return result;
    }

    public static Map<String, Integer> sortMap2(Map<String, Integer> map) {
        Map result = new ListOrderedMap();
        map.entrySet().stream().
                sorted(Map.Entry.comparingByValue()).
                forEachOrdered(entry -> result.put(entry.getKey(), entry.getValue()));

        return result;
    }


    +

    19 map是一种开发过程中经常使用的k-v数据结构，有个map保存了书名和书字数的关系，编写代码对map里面的书按照字数进行升序排序

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    public static Map<String, Integer> sortMap(Map<String, Integer> map) {
        TreeMap<Integer, List<String>> treeMap = new TreeMap<>();
        map.entrySet().forEach(entry -> {
            List<String> indexList = treeMap.computeIfAbsent(entry.getValue(), k -> new ArrayList<>());
            indexList.add(entry.getKey());
        });
        Map<String, Integer> result = new ListOrderedMap();
        treeMap.entrySet().forEach(entry -> {
            entry.getValue().forEach(key -> result.put(key, map.get(key)));
        });
        return result;
    }

    public static Map<String, Integer> sortMap2(Map<String, Integer> map) {
        Map result = new ListOrderedMap();
        map.entrySet().stream().
                sorted(Map.Entry.comparingByValue()).
                forEachOrdered(entry -> result.put(entry.getKey(), entry.getValue()));

        return result;
    }


    20 起点APP上允许用户对作品进行评论，为了防止用户恶意评论，发表不当内容，需要对用户发布的内容进行过滤，请写程序过滤用户发布内容中带有的QQ号（6~10位数字组成） 允许对内容严格操作，如用户发表了 作者大大666666，为你点赞 ，经过过滤后也可以为作者大大****，为你点赞 ，将666666过滤掉了。

    把6-10位的数字替换成””;

    -
    1
    2
    3
    public static String filterQQ(String s) {
        return s.replaceAll("\\d{6,10}","");
    }
    +
    1
    2
    3
    public static String filterQQ(String s) {
        return s.replaceAll("\\d{6,10}","");
    }
    -

    21 质数(又称素数),是指在大于1的自然数中,除了1和它本身外,不能被其他自然数整除(除0以外)的数称之为素数(质数)。请写个程序判断输入的数字是否是质数，如果是素数请输出：true，不是请输出false

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

    public class IsPrimeDemo {
        public static boolean isPrime(int n){
            if (n < 1){
                return false;
            }
            int i = 2;
            int end = (int) Math.sqrt(n);
            while (i <= end ){
                if (n % i == 0){
                    return false;
                }
                ++i;
            }
            return true;
        }

        public static void main(String[] args) {
            int n = 7;
            System.out.println(isPrime(n));
        }
    }

    +

    21 质数(又称素数),是指在大于1的自然数中,除了1和它本身外,不能被其他自然数整除(除0以外)的数称之为素数(质数)。请写个程序判断输入的数字是否是质数，如果是素数请输出：true，不是请输出false

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

    public class IsPrimeDemo {
        public static boolean isPrime(int n){
            if (n < 1){
                return false;
            }
            int i = 2;
            int end = (int) Math.sqrt(n);
            while (i <= end ){
                if (n % i == 0){
                    return false;
                }
                ++i;
            }
            return true;
        }

        public static void main(String[] args) {
            int n = 7;
            System.out.println(isPrime(n));
        }
    }

    22 有 n 个台阶，你一次能走 1 个或者 2 个台阶，那么请问，走完这 n 个台阶共有几种方式？

    经典爬楼梯问题

    -
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    package com.yuewen;

    import java.util.Scanner;

    public class ZouTaiJie {
        public static void main(String[] args) {

            Scanner scanner = new Scanner(System.in);
            int n = scanner.nextInt();
            int[] dp = new int[n];
            int i = 2;
            dp[0] = 1;
            dp[1] = 2;
            while (i < n)
            {
                dp[i] = dp[i-1] + dp[i-2];
                i++;
            }
            System.out.println(dp[n-1]);
        }

    }

    +
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    package com.yuewen;

    import java.util.Scanner;

    public class ZouTaiJie {
        public static void main(String[] args) {

            Scanner scanner = new Scanner(System.in);
            int n = scanner.nextInt();
            int[] dp = new int[n];
            int i = 2;
            dp[0] = 1;
            dp[1] = 2;
            while (i < n)
            {
                dp[i] = dp[i-1] + dp[i-2];
                i++;
            }
            System.out.println(dp[n-1]);
        }

    }

    -

    23 给定一个字符串，返回这个字符串中有多少个回文子串。两个相同的回文子串出现在不同的位置，认为是2个回文子串。a、aa、aaa、aba、aabaa、abcba均认为是回文子串。

    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
    import java.util.*;


    public class Solution {
      /**
       * 
       * @param str string字符串 
       * @return int整型
       */
      public int palindromeCount (String str) {
        int ans = 0;
        for (int center = 0; center < str.length(); center++) {
          ans += expand(str, center, center) + expand(str, center, center + 1);
        }
        return ans;
      }

      private int expand(String str, int left, int right) {
        int ans = 0;
        while (left >= 0 && right < str.length() && str.charAt(left) == str.charAt(right)) {
          ans++;
          left--;
          right++;
        }
        return ans;
      }
    }
    +

    23 给定一个字符串，返回这个字符串中有多少个回文子串。两个相同的回文子串出现在不同的位置，认为是2个回文子串。a、aa、aaa、aba、aabaa、abcba均认为是回文子串。

    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
    import java.util.*;


    public class Solution {
      /**
       * 
       * @param str string字符串 
       * @return int整型
       */
      public int palindromeCount (String str) {
        int ans = 0;
        for (int center = 0; center < str.length(); center++) {
          ans += expand(str, center, center) + expand(str, center, center + 1);
        }
        return ans;
      }

      private int expand(String str, int left, int right) {
        int ans = 0;
        while (left >= 0 && right < str.length() && str.charAt(left) == str.charAt(right)) {
          ans++;
          left--;
          right++;
        }
        return ans;
      }
    }

    24 将一个给定的单链表反转，例：1-2-3-4-5，反转为5-4-3-2-1

    -
    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
    import java.util.*;

    /*
     * public class ListNode {
     *   int val;
     *   ListNode next = null;
     * }
     */

    public class Solution {
        /**
         * 
         * @param head ListNode类 
         * @return ListNode类
         */
        public ListNode reverseList (ListNode head) {
           ListNode pre = null, post = head, tmp;
            while (post != null) {
                tmp = post.next;//临时工具人结点
                post.next = pre;//反转
                pre = post;//pre进1
                post = tmp;//post进1
            }
            return pre;
        }
    }
    +
    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
    import java.util.*;

    /*
     * public class ListNode {
     *   int val;
     *   ListNode next = null;
     * }
     */

    public class Solution {
        /**
         * 
         * @param head ListNode类 
         * @return ListNode类
         */
        public ListNode reverseList (ListNode head) {
           ListNode pre = null, post = head, tmp;
            while (post != null) {
                tmp = post.next;//临时工具人结点
                post.next = pre;//反转
                pre = post;//pre进1
                post = tmp;//post进1
            }
            return pre;
        }
    }

    25 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

    例：图中给定树 {3,5,1,6,2,0,8,#,#,7,4} 中，节点6、节点4的最近公共祖先为5。

    -
    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
    import java.util.*;

    /*
     * public class TreeNode {
     *   int val = 0;
     *   TreeNode left = null;
     *   TreeNode right = null;
     * }
     */

    public class Solution {
      /**
       * 
       * @param root TreeNode类 
       * @param p TreeNode类 
       * @param q TreeNode类 
       * @return TreeNode类
      */
      public TreeNode nearestCommonAncestor (TreeNode root, TreeNode p, TreeNode q) {
        if (root == null) {
          return null;
        }
        if (root.val == p.val || root.val == q.val) {
          return root;
        }
        TreeNode leftAns = nearestCommonAncestor(root.left, p, q), 
        rightAns = nearestCommonAncestor(root.right, p, q);
        if (leftAns != null && rightAns != null) {
          return root;
        }
        return leftAns != null ? leftAns : rightAns;
      }
    }
    +
    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
    import java.util.*;

    /*
     * public class TreeNode {
     *   int val = 0;
     *   TreeNode left = null;
     *   TreeNode right = null;
     * }
     */

    public class Solution {
      /**
       * 
       * @param root TreeNode类 
       * @param p TreeNode类 
       * @param q TreeNode类 
       * @return TreeNode类
      */
      public TreeNode nearestCommonAncestor (TreeNode root, TreeNode p, TreeNode q) {
        if (root == null) {
          return null;
        }
        if (root.val == p.val || root.val == q.val) {
          return root;
        }
        TreeNode leftAns = nearestCommonAncestor(root.left, p, q), 
        rightAns = nearestCommonAncestor(root.right, p, q);
        if (leftAns != null && rightAns != null) {
          return root;
        }
        return leftAns != null ? leftAns : rightAns;
      }
    }

    26 给定一个递增排序的数组，查找某个数字是否在数组中，如果在数组中，则返回该数字在数组中第一次出现的位置（从0开始）；如果不在数组中，返回-1 。不需要考虑给定的数组不是递增的情况。务必使用二分查找的方式。

    好像是错误的！

    -
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    int binarySearch(int* arr, int arrLen, int a) {
           // write code here
           int left = 0;
           int right = arrLen-1;
           int mid = 0;
           while(left<=right)
           {
               mid = (left+right)/2;
               if(arr[mid]==a)
               {
                   if(arr[mid-1]!=a)
                       return mid;
                   else
                       return mid-1;
               }        
               else if(arr[mid]>a)
                   right = mid - 1;
               else
                   left = mid + 1;
           }  
           return -1;
       }
    +
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    int binarySearch(int* arr, int arrLen, int a) {
           // write code here
           int left = 0;
           int right = arrLen-1;
           int mid = 0;
           while(left<=right)
           {
               mid = (left+right)/2;
               if(arr[mid]==a)
               {
                   if(arr[mid-1]!=a)
                       return mid;
                   else
                       return mid-1;
               }        
               else if(arr[mid]>a)
                   right = mid - 1;
               else
                   left = mid + 1;
           }  
           return -1;
       }

    27 请编写程序实现矩阵的乘法

    -
    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
    import java.util.*;
    public class Main {
            private static int[][] matrixMuilty(int[][] a, int[][] b) {
                int m = a.length, p = b.length, n = b[0].length;
                int[][] res = new int[m][n];
                for (int i = 0; i < m; i++) {
                    for (int j = 0; j < n; j++) {
                        for (int k = 0; k < p; k++) {
                            res[i][j] += a[i][k] * b[k][j];
                        }
                    }
                }
                return res;
            }

            //输入三个整数，分别表示：第一个矩阵的 行 列【也就是第二个矩阵的行】 第二个矩阵的列
            public static void main(String[] args) {
                Scanner sc = new Scanner(System.in);
                String s = sc.nextLine();
                String[] ss = s.split(",");
                int m = Integer.parseInt(ss[0]), p = Integer.parseInt(ss[1]), n = Integer.parseInt(ss[2]);
                if (m == 0 || p == 0 || n == 0) {
                    sc.close();
                    return;
                }
                int[][] a = new int[m][p];
                int[][] b = new int[p][n];
                for (int i = 0; i < m; i++) {
                    s = sc.nextLine();
                    ss = s.split(",");
                    for (int j = 0; j < p; j++) {
                        a[i][j] = Integer.parseInt(ss[j]);
                    }
                }
                for (int i = 0; i < p; i++) {
                    s = sc.nextLine();
                    ss = s.split(",");
                    for (int j = 0; j < n; j++) {
                        b[i][j] = Integer.parseInt(ss[j]);
                    }
                }
                sc.close();
                int[][] res = matrixMuilty(a, b);
                for (int i = 0; i < m; i++) {
                    StringBuilder sb = new StringBuilder();
                    for (int j = 0; j < n; j++) {
                        sb.append(res[i][j]).append(",");
                    }
                    System.out.println(sb.substring(0, sb.length() - 1));
                }
            }
        }
    +
    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
    import java.util.*;
    public class Main {
            private static int[][] matrixMuilty(int[][] a, int[][] b) {
                int m = a.length, p = b.length, n = b[0].length;
                int[][] res = new int[m][n];
                for (int i = 0; i < m; i++) {
                    for (int j = 0; j < n; j++) {
                        for (int k = 0; k < p; k++) {
                            res[i][j] += a[i][k] * b[k][j];
                        }
                    }
                }
                return res;
            }

            //输入三个整数，分别表示：第一个矩阵的 行 列【也就是第二个矩阵的行】 第二个矩阵的列
            public static void main(String[] args) {
                Scanner sc = new Scanner(System.in);
                String s = sc.nextLine();
                String[] ss = s.split(",");
                int m = Integer.parseInt(ss[0]), p = Integer.parseInt(ss[1]), n = Integer.parseInt(ss[2]);
                if (m == 0 || p == 0 || n == 0) {
                    sc.close();
                    return;
                }
                int[][] a = new int[m][p];
                int[][] b = new int[p][n];
                for (int i = 0; i < m; i++) {
                    s = sc.nextLine();
                    ss = s.split(",");
                    for (int j = 0; j < p; j++) {
                        a[i][j] = Integer.parseInt(ss[j]);
                    }
                }
                for (int i = 0; i < p; i++) {
                    s = sc.nextLine();
                    ss = s.split(",");
                    for (int j = 0; j < n; j++) {
                        b[i][j] = Integer.parseInt(ss[j]);
                    }
                }
                sc.close();
                int[][] res = matrixMuilty(a, b);
                for (int i = 0; i < m; i++) {
                    StringBuilder sb = new StringBuilder();
                    for (int j = 0; j < n; j++) {
                        sb.append(res[i][j]).append(",");
                    }
                    System.out.println(sb.substring(0, sb.length() - 1));
                }
            }
        }

    28 求出一个正整数转换成二进制后的数字“1”的个数。

    例：数字23转为二进制为 10111，其中1的个数为4

    -
    1
    2
    3
    4
    5
    public static int binaryTo(int num) { int sum = 0;  while (num > 0) {
            sum += num % 2;
            num = num / 2;
        } return sum;
    }
    +
    1
    2
    3
    4
    5
    public static int binaryTo(int num) { int sum = 0;  while (num > 0) {
            sum += num % 2;
            num = num / 2;
        } return sum;
    }

    29 去除字符串中的重复字符，对于出现超过2次（包含2次）的字符，只保留第一个。

    例：输入abcbdde，输出abcde。

    -
    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
    import java.util.*;


    public class Solution {
        /**
         * 
         * @param str string字符串 
         * @return string字符串
         */
        public String removeDuplicatedChars (String str) {
            // write code here
            boolean[] isExistChar = new boolean[26];
            boolean[] isExistNum = new boolean[10];
            char[] chars = str.toCharArray();
            StringBuilder sb = new StringBuilder();
            for (char c : chars) {
                //是字母
                if(c >= 'a' && c <= 'z'){
                    if(!isExistChar[c - 'a']){
                        sb.append(c);
                        isExistChar[c - 'a'] = true;
                    }    
                }
                //是数字
                if(c >= '0' && c <= '9'){
                    if(!isExistNum[c - '0']){
                        sb.append(c);
                        isExistNum[c - '0'] = true;
                    }
                }
            }
            return sb.toString();
        }
    }
    +
    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
    import java.util.*;


    public class Solution {
        /**
         * 
         * @param str string字符串 
         * @return string字符串
         */
        public String removeDuplicatedChars (String str) {
            // write code here
            boolean[] isExistChar = new boolean[26];
            boolean[] isExistNum = new boolean[10];
            char[] chars = str.toCharArray();
            StringBuilder sb = new StringBuilder();
            for (char c : chars) {
                //是字母
                if(c >= 'a' && c <= 'z'){
                    if(!isExistChar[c - 'a']){
                        sb.append(c);
                        isExistChar[c - 'a'] = true;
                    }    
                }
                //是数字
                if(c >= '0' && c <= '9'){
                    if(!isExistNum[c - '0']){
                        sb.append(c);
                        isExistNum[c - '0'] = true;
                    }
                }
            }
            return sb.toString();
        }
    }

    30 给定一个整型数组，移除数组的某个元素使其剩下的元素乘积最大，如果数组出现相同的元素 ，请输出第一次出现的元素

    -
    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 class Main {
      public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String[] nums = scanner.next().split(",");
        int n = nums.length;
        // dp[i] -> 除 nums[i] 以外的其余所有元素的乘积
        BigDecimal[] dp = new BigDecimal[n];
        dp[0] = BigDecimal.valueOf(1);
        for (int i = 1; i < n; i++) {
          dp[i] = dp[i - 1].multiply(BigDecimal.valueOf(Integer.parseInt(nums[i - 1])));
        }
        BigDecimal temp = BigDecimal.valueOf(1);
        for (int i = n - 1; i >= 0; i--) {
          dp[i] = dp[i].multiply(temp);
          temp = temp.multiply(BigDecimal.valueOf(Integer.parseInt(nums[i])));
        }
        BigDecimal max = dp[0];
        int idx = 0;
        for (int i = 1; i < n; i++) {
          if (dp[i].compareTo(max) > 0) {
            max = dp[i];
            idx = i;
          }
        }
        System.out.println(idx);
      }
    }
    +
    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 class Main {
      public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String[] nums = scanner.next().split(",");
        int n = nums.length;
        // dp[i] -> 除 nums[i] 以外的其余所有元素的乘积
        BigDecimal[] dp = new BigDecimal[n];
        dp[0] = BigDecimal.valueOf(1);
        for (int i = 1; i < n; i++) {
          dp[i] = dp[i - 1].multiply(BigDecimal.valueOf(Integer.parseInt(nums[i - 1])));
        }
        BigDecimal temp = BigDecimal.valueOf(1);
        for (int i = n - 1; i >= 0; i--) {
          dp[i] = dp[i].multiply(temp);
          temp = temp.multiply(BigDecimal.valueOf(Integer.parseInt(nums[i])));
        }
        BigDecimal max = dp[0];
        int idx = 0;
        for (int i = 1; i < n; i++) {
          if (dp[i].compareTo(max) > 0) {
            max = dp[i];
            idx = i;
          }
        }
        System.out.println(idx);
      }
    }
    -

    31 给定一个整型正方形矩阵 Matrix，请把该矩阵调整成顺时针旋转90度的样子。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    public static int[][] rotationMatrix(int[][] matrix) {
        if (matrix != null && matrix.length > 0 && matrix.length == matrix[0].length) {
            int[][] result = new int[matrix.length][matrix.length];
            for (int i = 0; i < matrix.length; i++) {
                for (int j = 0; j < matrix[i].length; j++) {
                    result[i][j] = matrix[matrix.length - j - 1][i];
                }
            }
            return result;
        }
        return null;
    }
    +

    31 给定一个整型正方形矩阵 Matrix，请把该矩阵调整成顺时针旋转90度的样子。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    public static int[][] rotationMatrix(int[][] matrix) {
        if (matrix != null && matrix.length > 0 && matrix.length == matrix[0].length) {
            int[][] result = new int[matrix.length][matrix.length];
            for (int i = 0; i < matrix.length; i++) {
                for (int j = 0; j < matrix[i].length; j++) {
                    result[i][j] = matrix[matrix.length - j - 1][i];
                }
            }
            return result;
        }
        return null;
    }

    32 在字符串中找到第一个不重复的字符。

    例：对于字符串“hellohehe”，第一个不重复的字符是“o”。如果每个字符都有重复，则抛出运行时异常。

    -
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    public char findFirstNonRepeatChar (String str) {
            int[] map = new int[128];
            for (char c: str.toCharArray()) {
                map[c]++;
            }
            for (char c: str.toCharArray()) {
                if (map[c] == 1) {
                    return c;
                }
            }
            throw new RuntimeException("没有只有一个的字符");
        }
    +
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    public char findFirstNonRepeatChar (String str) {
            int[] map = new int[128];
            for (char c: str.toCharArray()) {
                map[c]++;
            }
            for (char c: str.toCharArray()) {
                if (map[c] == 1) {
                    return c;
                }
            }
            throw new RuntimeException("没有只有一个的字符");
        }

    33.假设有N个用户，其中有些人是朋友，有些则不是。A和B是朋友，B和C是朋友，这样ABC就是一个朋友圈，请计算给定的朋友关系的朋友圈数。

    给定一个 N * N 的矩阵 M，表示用户之间的朋友关系。如果M[i][j] = 1，表示已知第 i 个和 j 个人互为朋友关系，否则为不知道。你必须输出所有用户中的已知的朋友圈总数。

    -
    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
    import java.util.HashSet;
    import java.util.Scanner;
    import java.util.Set;
    public class Main {
      public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        String[][] relations = new String[n][n];
        for (int i = 0; i < n; i++) {
          relations[i] = scanner.next().split(",");
        }
        scanner.close();
        System.out.println(friendCircle(relations));
      }
      private static int friendCircle(String[][] relations) {
        int n = relations.length;
        // graph[i] -> 用户 i 的所有朋友
        Set[] graph = new HashSet[n];
        for (int i = 0; i < n; i++) {
          graph[i] = new HashSet();
          for (int j = 0; j < n; j++) {
            int relation = Integer.parseInt(relations[i][j]);
            if (relation == 1) {
              graph[i].add(j);
            }
          }
        }
        int ans = 0;
        boolean[] visited = new boolean[n];
        for (int i = 0; i < n; i++) {
          if (!visited[i]) {
            ans++;
            dfs(graph, i, visited);
          }
        }
        return ans;
      }
      private static void dfs(Set[] graph, int cur, boolean[] visited) {
        visited[cur] = true;
        for (int next : graph[cur]) {
          if (!visited[next]) {
            dfs(graph, next, visited);
          }
        }
      }
    }
    +
    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
    import java.util.HashSet;
    import java.util.Scanner;
    import java.util.Set;
    public class Main {
      public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        String[][] relations = new String[n][n];
        for (int i = 0; i < n; i++) {
          relations[i] = scanner.next().split(",");
        }
        scanner.close();
        System.out.println(friendCircle(relations));
      }
      private static int friendCircle(String[][] relations) {
        int n = relations.length;
        // graph[i] -> 用户 i 的所有朋友
        Set[] graph = new HashSet[n];
        for (int i = 0; i < n; i++) {
          graph[i] = new HashSet();
          for (int j = 0; j < n; j++) {
            int relation = Integer.parseInt(relations[i][j]);
            if (relation == 1) {
              graph[i].add(j);
            }
          }
        }
        int ans = 0;
        boolean[] visited = new boolean[n];
        for (int i = 0; i < n; i++) {
          if (!visited[i]) {
            ans++;
            dfs(graph, i, visited);
          }
        }
        return ans;
      }
      private static void dfs(Set[] graph, int cur, boolean[] visited) {
        visited[cur] = true;
        for (int next : graph[cur]) {
          if (!visited[next]) {
            dfs(graph, next, visited);
          }
        }
      }
    }

    34 假设有个文件，文件的每一行是书信息数据，分4个部分用逗号（,）进行分割,格式如下

    id,category,words,updatetime

    id 表示书id，long类型，id不重复；

    @@ -884,20 +884,20 @@ 

    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
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Arrays;
    import java.util.Date;
    import java.util.Scanner;

    public class Main {
      public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        Book[] books = new Book[n];
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        for (int i = 0; i < n; i++) {
          String[] row = scanner.next().split(",");
          try {
            String updateTime = row[3] + " " + scanner.next();
            Book book =
                new Book(
                    Long.parseLong(row[0]),
                    Integer.parseInt(row[1]),
                    Integer.parseInt(row[2]),
                    dateFormat.parse(updateTime));
            books[i] = book;
          } catch (ParseException e) {
            e.printStackTrace();
          }
        }
        scanner.close();
        // 升序排列。字段优先级：category > updateTime > words > id
        Arrays.sort(books, (book1, book2) -> {
          if (book1.getCategory() != book2.getCategory()) {
            return book1.getCategory() - book2.getCategory();
          }
          long update1 = book1.getUpdateTime().getTime(), update2 = book2.getUpdateTime().getTime();
          if (update1 != update2) {
            return (int) (update1 - update2);
          }
          if (book1.getWords() != book2.getWords()) {
            return book1.getWords() - book2.getWords();
          }
          return (int) (book1.getId() - book2.getId());
        });
        for (int i = 0; i < n; i++) {
          System.out.println(books[i].getId());
        }
      }
    }

    class Book {
      private final long id;
      private final int category;
      private final int words;
      private final Date updateTime;

      public Book(long id, int category, int words, Date updateTime) {
        this.id = id;
        this.category = category;
        this.words = words;
        this.updateTime = updateTime;
      }

      public long getId() {
        return this.id;
      }

      public int getCategory() {
        return this.category;
      }

      public int getWords() {
        return this.words;
      }

      public Date getUpdateTime() {
        return this.updateTime;
      }
    }
    +
    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
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Arrays;
    import java.util.Date;
    import java.util.Scanner;

    public class Main {
      public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        Book[] books = new Book[n];
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        for (int i = 0; i < n; i++) {
          String[] row = scanner.next().split(",");
          try {
            String updateTime = row[3] + " " + scanner.next();
            Book book =
                new Book(
                    Long.parseLong(row[0]),
                    Integer.parseInt(row[1]),
                    Integer.parseInt(row[2]),
                    dateFormat.parse(updateTime));
            books[i] = book;
          } catch (ParseException e) {
            e.printStackTrace();
          }
        }
        scanner.close();
        // 升序排列。字段优先级：category > updateTime > words > id
        Arrays.sort(books, (book1, book2) -> {
          if (book1.getCategory() != book2.getCategory()) {
            return book1.getCategory() - book2.getCategory();
          }
          long update1 = book1.getUpdateTime().getTime(), update2 = book2.getUpdateTime().getTime();
          if (update1 != update2) {
            return (int) (update1 - update2);
          }
          if (book1.getWords() != book2.getWords()) {
            return book1.getWords() - book2.getWords();
          }
          return (int) (book1.getId() - book2.getId());
        });
        for (int i = 0; i < n; i++) {
          System.out.println(books[i].getId());
        }
      }
    }

    class Book {
      private final long id;
      private final int category;
      private final int words;
      private final Date updateTime;

      public Book(long id, int category, int words, Date updateTime) {
        this.id = id;
        this.category = category;
        this.words = words;
        this.updateTime = updateTime;
      }

      public long getId() {
        return this.id;
      }

      public int getCategory() {
        return this.category;
      }

      public int getWords() {
        return this.words;
      }

      public Date getUpdateTime() {
        return this.updateTime;
      }
    }

    35请使用堆栈这一个数据结构实现简单FIFO（先入先出）队列，队列要实现两个方法： push、pop。

    为自动测试方便，使用每行输入模拟操作：

    1） push 1 表明向队列里面新增一个元素 1 , push 和元素之间用空格表示；

    2） pop 表明输出当前队列里面的第一个元素，如果当前队列为空请输出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
    static class MyQueue {
        int[] queue;
        int lo, hi, size, capacity;

        public MyQueue(int n) {
            this.lo = this.hi = this.size = 0;
            this.capacity = n;
            this.queue = new int[n];
        }

        public MyQueue() {
            this(10);
        }

        public void push(int val) {
            if (hi == capacity) {
                if (lo > 0) {
                    int idx = 0;
                    for (int i = lo; i < hi; i++) {
                        queue[idx++] = queue[i];
                    }
                    lo = 0;
                    hi = idx;
                } else {
                    //扩容
                    int[] newQueue = new int[capacity * 2];
                    System.arraycopy(queue, 0, newQueue, 0, capacity);
                    this.queue = newQueue;
                }
            }
            this.queue[hi++] = val;
        }

        public int pop() {
            if (lo == hi) return -1;
            else {
                return this.queue[lo++];
            }
        }

    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // int[] nums = Arrays.stream().mapToInt(Integer::parseInt).toArray();
        String[] ss = scanner.nextLine().split(",");
        YuewenJavaTest.MyQueue myQueue = new YuewenJavaTest.MyQueue();
        for (String s: ss) {
            if (s.startsWith("push")) {
                myQueue.push(Integer.parseInt(s.split(" ")[1]));
            } else {
                System.out.println(myQueue.pop());
            }
        }

        scanner.close();
    }
    +
    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
    static class MyQueue {
        int[] queue;
        int lo, hi, size, capacity;

        public MyQueue(int n) {
            this.lo = this.hi = this.size = 0;
            this.capacity = n;
            this.queue = new int[n];
        }

        public MyQueue() {
            this(10);
        }

        public void push(int val) {
            if (hi == capacity) {
                if (lo > 0) {
                    int idx = 0;
                    for (int i = lo; i < hi; i++) {
                        queue[idx++] = queue[i];
                    }
                    lo = 0;
                    hi = idx;
                } else {
                    //扩容
                    int[] newQueue = new int[capacity * 2];
                    System.arraycopy(queue, 0, newQueue, 0, capacity);
                    this.queue = newQueue;
                }
            }
            this.queue[hi++] = val;
        }

        public int pop() {
            if (lo == hi) return -1;
            else {
                return this.queue[lo++];
            }
        }

    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // int[] nums = Arrays.stream().mapToInt(Integer::parseInt).toArray();
        String[] ss = scanner.nextLine().split(",");
        YuewenJavaTest.MyQueue myQueue = new YuewenJavaTest.MyQueue();
        for (String s: ss) {
            if (s.startsWith("push")) {
                myQueue.push(Integer.parseInt(s.split(" ")[1]));
            } else {
                System.out.println(myQueue.pop());
            }
        }

        scanner.close();
    }

    36 在和外部公司联调HTTP接口时，对方要求调用的接口需要计算token，给到的规则如下：

    1） 所有的参数值必须经过urlencode,编码为utf-8；

    2） 对编码后数据按照key值进行字典升序排序；

    3）将所有的参数按照排序的顺序拼接成字符串 ，格式如下: k1=v1&k2=v2&k3=v3;

    \4) 将第三步的算出的值计算md5值，md5加密的值小写

    请你编写一段方法计算token值

    -
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    public String getToken(Map<String, String> params) {
        List<String> ss = params.keySet().stream().sorted().map(
            k -> {
                String v = params.get(k);
                String kv = null;
                try {
                    kv = k + "=" + URLEncoder.encode(v, "utf-8");
                } catch (Exception e) {

                }
                return kv;
            }
        ).collect(Collectors.toList());
        String token = null;
        try {
            token = new String(MessageDigest.getInstance("md5").digest(String.join("&", ss).getBytes()));
        } catch (Exception e) {
        }
        return token;
    }
    +
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    public String getToken(Map<String, String> params) {
        List<String> ss = params.keySet().stream().sorted().map(
            k -> {
                String v = params.get(k);
                String kv = null;
                try {
                    kv = k + "=" + URLEncoder.encode(v, "utf-8");
                } catch (Exception e) {

                }
                return kv;
            }
        ).collect(Collectors.toList());
        String token = null;
        try {
            token = new String(MessageDigest.getInstance("md5").digest(String.join("&", ss).getBytes()));
        } catch (Exception e) {
        }
        return token;
    }
    @@ -972,24 +972,24 @@

    题干

    -
    1
    2
    3
    4
    5
    6
    秋天快到啦，天气慢慢凉爽了下来，所以实验室要组织去骊山进行一次野餐活动。

    最底层的Lofipure被迫背背包给大家装各种零食，但是实验室的大佬们并不打算轻易放过Lofipure，他们打算把Lofipure的背包装的尽量满

    现在知道Lofipure的背包容量为 V（正整数，0 <= V <= 20000），同时有 n 件小零食（0＜n<=30），每个小零食的重量。
    现在在 n 个小零食中，任取若干个装入Lofipure的背包内，使得Lofipure背包的剩余空间为最小。借此达到压榨Lofipure的目的。
    +
    1
    2
    3
    4
    5
    6
    秋天快到啦，天气慢慢凉爽了下来，所以实验室要组织去骊山进行一次野餐活动。

    最底层的Lofipure被迫背背包给大家装各种零食，但是实验室的大佬们并不打算轻易放过Lofipure，他们打算把Lofipure的背包装的尽量满

    现在知道Lofipure的背包容量为 V（正整数，0 <= V <= 20000），同时有 n 件小零食（0＜n<=30），每个小零食的重量。
    现在在 n 个小零食中，任取若干个装入Lofipure的背包内，使得Lofipure背包的剩余空间为最小。借此达到压榨Lofipure的目的。

    Input

    输入：一个整数v，表示背包容量 一个整数n，表示有n个物品 接下来 n 个整数，分别表示这 n 个物品的各自体积

    Output

    输出：一个整数，表示背包最小的剩余空间

    Sample Input

    -
    1
    2
    3
    4
    5
    6
    7
    8
    24
    6
    8
    3
    12
    7
    9
    7
    +
    1
    2
    3
    4
    5
    6
    7
    8
    24
    6
    8
    3
    12
    7
    9
    7

    Sample Output

    -
    1
    0
    +
    1
    0

    看到这道理的第一时刻想的是暴力枚举出所有零食混合装的重量 可复杂度太高 遂放弃。

    然后看了一下大佬们的代码

    -
    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
    #include<bits/stdc++.h>
    #define int long long
    #define MAXN 1000005
    using namespace std;
    int dp[20005];
    signed main()
    {
        dp[0]=1;
        int v,n;cin>>v>>n;
        for(int i=1;i<=n;i++)
        {
            int t;cin>>t;
            for(int j=v;j>=t;j--)
                dp[j]|=dp[j-t];
        }
        for(int i=v;i>=0;i--)
        {
            if(dp[i])
            {
                cout<<v-i<<endl;
                return 0;
            }
        }
    }

    +
    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
    #include<bits/stdc++.h>
    #define int long long
    #define MAXN 1000005
    using namespace std;
    int dp[20005];
    signed main()
    {
        dp[0]=1;
        int v,n;cin>>v>>n;
        for(int i=1;i<=n;i++)
        {
            int t;cin>>t;
            for(int j=v;j>=t;j--)
                dp[j]|=dp[j-t];
        }
        for(int i=v;i>=0;i--)
        {
            if(dp[i])
            {
                cout<<v-i<<endl;
                return 0;
            }
        }
    }

    刚开始我用Java实现的时候，

    -
    1
    2
    3
    4
    5
    6
    7
    8
    9

    后面经过自己  ~~人眼比对~~ 发现这个错误  发现之后感到不解。

    ```dp [j]|=dp[j-t]```这个式子用来干嘛的呢

    后面经过输出

    ```java
    System.out.println(j+" "+(j-t)+" "+dp[j]+" "+dp[j - t]);
    +
    1
    2
    3
    4
    5
    6
    7
    8
    9

    后面经过自己  ~~人眼比对~~ 发现这个错误  发现之后感到不解。

    ```dp [j]|=dp[j-t]```这个式子用来干嘛的呢

    后面经过输出

    ```java
    System.out.println(j+" "+(j-t)+" "+dp[j]+" "+dp[j - t]);

    形式一下子就清楚了 dp是为了统计零食能够组成的重量

    拿本题例子来说

    @@ -1002,7 +1002,7 @@

    从最大的量递减便利 当dp[i] 不为0 时 也就是为1 代表着这是能够装载着最大的重量 直接输出V-i

    感叹算法的奇妙与精彩，只恨自己接触晚与学校氛围不好，蹉跎了许久时光。

    JAVA版代码

    -
    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
    package com.VG;

    import java.util.Arrays;
    import java.util.Scanner;

    public class C {
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            int V = scanner.nextInt();
            int N = scanner.nextInt();
            int[] dp = new int[200005];
            dp[0] = 1;
            for (int i = 1; i <= N; i++) {
                int t = scanner.nextInt();
                for (int j = V; j >=t ; j--) {
                    dp[j] |= dp[j - t];
                    System.out.println(j+" "+(j-t)+" "+dp[j]+" "+dp[j - t]);
                }
            }
            for (int i = V; i >= 0 ; i--) {
                if(dp[i]!=0)
                {
                    System.out.println(V- i);
                    return;
                }
            }

        }
    }

    +
    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
    package com.VG;

    import java.util.Arrays;
    import java.util.Scanner;

    public class C {
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            int V = scanner.nextInt();
            int N = scanner.nextInt();
            int[] dp = new int[200005];
            dp[0] = 1;
            for (int i = 1; i <= N; i++) {
                int t = scanner.nextInt();
                for (int j = V; j >=t ; j--) {
                    dp[j] |= dp[j - t];
                    System.out.println(j+" "+(j-t)+" "+dp[j]+" "+dp[j - t]);
                }
            }
            for (int i = V; i >= 0 ; i--) {
                if(dp[i]!=0)
                {
                    System.out.println(V- i);
                    return;
                }
            }

        }
    }

    @@ -1082,7 +1082,7 @@

    有接口情况：使用 JDK 动态代理，创建接口实现类代理对象，增强类的方法。
  • 没有接口情况：使用 CGLIB 动态代理，创建子类的代理对象，增强类的方法。

-
1
newProxyInstance(ClassLoader loader,类<?>[] interfaces,InvacationHandle)
+
1
newProxyInstance(ClassLoader loader,类<?>[] interfaces,InvacationHandle)

方法有三个参数

第一个参数：类加载器

@@ -1166,14 +1166,14 @@ 

1
2
3
4
5
6
7
8
9
10
result = []
def backtrack(路径, 选择列表):
    if 满足结束条件:
        result.add(路径)
        return
    
    for 选择 in 选择列表:
        做选择
        backtrack(路径, 选择列表)
        撤销选择
+
1
2
3
4
5
6
7
8
9
10
result = []
def backtrack(路径, 选择列表):
    if 满足结束条件:
        result.add(路径)
        return
    
    for 选择 in 选择列表:
        做选择
        backtrack(路径, 选择列表)
        撤销选择

核心在于for循环里面的递归，在递归调用之前做选择，在递归调用之后撤销选择。

例子1 全排列问题

有n个数 每个数都只能用一次 求出所有能排列的可能性。全排列个数为n!个

PS：为了简单清晰起见，我们这次讨论的全排列问题不包含重复的数字。

如果已知有多少个数的情况下，我们通常可以使用n层for循环暴力遍历所有数

例如3个数 我们可以暴力写法为

-
1
2
3
4
5
6
7
8
9
10
11
12
13
for(int i = 0;i < n;i++)
    for(int j = 0;j < n;j++)
        for(int k = 0;k < n;k++)
        {
			if(i!=j && i!=k && j!=k)
            {
                // 1 2 3   1 3 2   2 1 3   2 3 1  3 2 1  3 1 2
				list.add(nums[i]);
                list.add(nums[j]);
                list.add(nums[k]);
                res.add(list);
            }
        }
+
1
2
3
4
5
6
7
8
9
10
11
12
13
for(int i = 0;i < n;i++)
    for(int j = 0;j < n;j++)
        for(int k = 0;k < n;k++)
        {
			if(i!=j && i!=k && j!=k)
            {
                // 1 2 3   1 3 2   2 1 3   2 3 1  3 2 1  3 1 2
				list.add(nums[i]);
                list.add(nums[j]);
                list.add(nums[k]);
                res.add(list);
            }
        }
@@ -1185,7 +1185,7 @@

我们定义的backtrack函数就是指针一样，在这棵树上游走，同时要正确维护每个节点的属性，每当走到树的底层，其路径就是一个全排列。

再进一步，如何遍历一颗树，

-
1
2
3
4
5
6
void traverse(TreeNode root) {
    for (TreeNode child : root.childern)
        // 前序遍历需要的操作
        traverse(child);
        // 后序遍历需要的操作
}
+
1
2
3
4
5
6
void traverse(TreeNode root) {
    for (TreeNode child : root.childern)
        // 前序遍历需要的操作
        traverse(child);
        // 后序遍历需要的操作
}
@@ -1194,12 +1194,12 @@

回溯代码核心框架

-
1
2
3
4
5
6
7
8
9
for 选择 in 选择列表:
    # 做选择
    将该选择从选择列表移除
    路径.add(选择)
    backtrack(路径, 选择列表)
    # 撤销选择
    路径.remove(选择)
    将该选择再加入选择列表

+
1
2
3
4
5
6
7
8
9
for 选择 in 选择列表:
    # 做选择
    将该选择从选择列表移除
    路径.add(选择)
    backtrack(路径, 选择列表)
    # 撤销选择
    路径.remove(选择)
    将该选择再加入选择列表

我们只要在递归之前做出选择，在递归之后撤销自己的选择，就能得到每个节点的选择路径和列表。

-

全排列代码

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
List<List<Integer>> res = new LinkedList<>();

/* 主函数，输入一组不重复的数字，返回它们的全排列 */
List<List<Integer>> permute(int[] nums) {
    // 记录「路径」
    LinkedList<Integer> track = new LinkedList<>();
    backtrack(nums, track);
    return res;
}

// 路径：记录在 track 中
// 选择列表：nums 中不存在于 track 的那些元素
// 结束条件：nums 中的元素全都在 track 中出现
void backtrack(int[] nums, LinkedList<Integer> track) {
    // 触发结束条件
    if (track.size() == nums.length) {
        res.add(new LinkedList(track));
        return;
    }
    
    for (int i = 0; i < nums.length; i++) {
        // 排除不合法的选择
        if (track.contains(nums[i]))
            continue;
        // 做选择
        track.add(nums[i]);
        // 进入下一层决策树
        backtrack(nums, track);
        // 取消选择
        track.removeLast();
    }
}
+

全排列代码

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
List<List<Integer>> res = new LinkedList<>();

/* 主函数，输入一组不重复的数字，返回它们的全排列 */
List<List<Integer>> permute(int[] nums) {
    // 记录「路径」
    LinkedList<Integer> track = new LinkedList<>();
    backtrack(nums, track);
    return res;
}

// 路径：记录在 track 中
// 选择列表：nums 中不存在于 track 的那些元素
// 结束条件：nums 中的元素全都在 track 中出现
void backtrack(int[] nums, LinkedList<Integer> track) {
    // 触发结束条件
    if (track.size() == nums.length) {
        res.add(new LinkedList(track));
        return;
    }
    
    for (int i = 0; i < nums.length; i++) {
        // 排除不合法的选择
        if (track.contains(nums[i]))
            continue;
        // 做选择
        track.add(nums[i]);
        // 进入下一层决策树
        backtrack(nums, track);
        // 取消选择
        track.removeLast();
    }
}

我们这里稍微做了些变通，没有显式记录「选择列表」，而是通过 nums 和 track 推导出当前的选择列表：

通过contains函数来判断该数是否已经被使用。

@@ -1210,10 +1210,10 @@

例子2 N皇后问题

题意

给你一个N*N的棋盘，，让你放置 N 个皇后，使得它们不能互相攻击。

PS：皇后可以攻击同一行、同一列、左上左下右上右下四个方向的任意单位。

这个问题本质上跟全排列问题差不多，决策树的每一层表示棋盘上的每一行；每个节点可以做出的选择是，在该行的任意一列放置一个皇后。

-
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
vector<vector<string>> res;

/* 输入棋盘边长 n，返回所有合法的放置 */
vector<vector<string>> solveNQueens(int n) {
    // '.' 表示空，'Q' 表示皇后，初始化空棋盘。
    vector<string> board(n, string(n, '.'));
    backtrack(board, 0);
    return res;
}

// 路径：board 中小于 row 的那些行都已经成功放置了皇后
// 选择列表：第 row 行的所有列都是放置皇后的选择
// 结束条件：row 超过 board 的最后一行
void backtrack(vector<string>& board, int row) {
    // 触发结束条件
    if (row == board.size()) {
        res.push_back(board);
        return;
    }
    
    int n = board[row].size();
    for (int col = 0; col < n; col++) {
        // 排除不合法选择
        if (!isValid(board, row, col)) 
            continue;
        // 做选择
        board[row][col] = 'Q';
        // 进入下一行决策
        backtrack(board, row + 1);
        // 撤销选择
        board[row][col] = '.';
    }
}
+
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
vector<vector<string>> res;

/* 输入棋盘边长 n，返回所有合法的放置 */
vector<vector<string>> solveNQueens(int n) {
    // '.' 表示空，'Q' 表示皇后，初始化空棋盘。
    vector<string> board(n, string(n, '.'));
    backtrack(board, 0);
    return res;
}

// 路径：board 中小于 row 的那些行都已经成功放置了皇后
// 选择列表：第 row 行的所有列都是放置皇后的选择
// 结束条件：row 超过 board 的最后一行
void backtrack(vector<string>& board, int row) {
    // 触发结束条件
    if (row == board.size()) {
        res.push_back(board);
        return;
    }
    
    int n = board[row].size();
    for (int col = 0; col < n; col++) {
        // 排除不合法选择
        if (!isValid(board, row, col)) 
            continue;
        // 做选择
        board[row][col] = 'Q';
        // 进入下一行决策
        backtrack(board, row + 1);
        // 撤销选择
        board[row][col] = '.';
    }
}

IsValid()函数

-
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/* 是否可以在 board[row][col] 放置皇后？ */
bool isValid(vector<string>& board, int row, int col) {
    int n = board.size();
    // 检查列是否有皇后互相冲突
    for (int i = 0; i < n; i++) {
        if (board[i][col] == 'Q')
            return false;
    }
    // 检查右上方是否有皇后互相冲突
    for (int i = row - 1, j = col + 1; 
            i >= 0 && j < n; i--, j++) {
        if (board[i][j] == 'Q')
            return false;
    }
    // 检查左上方是否有皇后互相冲突
    for (int i = row - 1, j = col - 1;
            i >= 0 && j >= 0; i--, j--) {
        if (board[i][j] == 'Q')
            return false;
    }
    return true;
}

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/* 是否可以在 board[row][col] 放置皇后？ */
bool isValid(vector<string>& board, int row, int col) {
    int n = board.size();
    // 检查列是否有皇后互相冲突
    for (int i = 0; i < n; i++) {
        if (board[i][col] == 'Q')
            return false;
    }
    // 检查右上方是否有皇后互相冲突
    for (int i = row - 1, j = col + 1; 
            i >= 0 && j < n; i--, j++) {
        if (board[i][j] == 'Q')
            return false;
    }
    // 检查左上方是否有皇后互相冲突
    for (int i = row - 1, j = col - 1;
            i >= 0 && j >= 0; i--, j--) {
        if (board[i][j] == 'Q')
            return false;
    }
    return true;
}

函数 backtrack 依然像个在决策树上游走的指针，通过 row 和 col 就可以表示函数遍历到的位置，通过 isValid 函数可以将不符合条件的情况剪枝：

@@ -1304,14 +1304,14 @@ 

1
2
3
4
5
6
7
8
9
10
result = []
def backtrack(路径, 选择列表):
    if 满足结束条件:
        result.add(路径)
        return
    
    for 选择 in 选择列表:
        做选择
        backtrack(路径, 选择列表)
        撤销选择
+
1
2
3
4
5
6
7
8
9
10
result = []
def backtrack(路径, 选择列表):
    if 满足结束条件:
        result.add(路径)
        return
    
    for 选择 in 选择列表:
        做选择
        backtrack(路径, 选择列表)
        撤销选择

核心在于for循环里面的递归，在递归调用之前做选择，在递归调用之后撤销选择。

例子1 全排列问题

有n个数 每个数都只能用一次 求出所有能排列的可能性。全排列个数为n!个

PS：为了简单清晰起见，我们这次讨论的全排列问题不包含重复的数字。

如果已知有多少个数的情况下，我们通常可以使用n层for循环暴力遍历所有数

例如3个数 我们可以暴力写法为

-
1
2
3
4
5
6
7
8
9
10
11
12
13
for(int i = 0;i < n;i++)
    for(int j = 0;j < n;j++)
        for(int k = 0;k < n;k++)
        {
			if(i!=j && i!=k && j!=k)
            {
                // 1 2 3   1 3 2   2 1 3   2 3 1  3 2 1  3 1 2
				list.add(nums[i]);
                list.add(nums[j]);
                list.add(nums[k]);
                res.add(list);
            }
        }
+
1
2
3
4
5
6
7
8
9
10
11
12
13
for(int i = 0;i < n;i++)
    for(int j = 0;j < n;j++)
        for(int k = 0;k < n;k++)
        {
			if(i!=j && i!=k && j!=k)
            {
                // 1 2 3   1 3 2   2 1 3   2 3 1  3 2 1  3 1 2
				list.add(nums[i]);
                list.add(nums[j]);
                list.add(nums[k]);
                res.add(list);
            }
        }
@@ -1323,7 +1323,7 @@

我们定义的backtrack函数就是指针一样，在这棵树上游走，同时要正确维护每个节点的属性，每当走到树的底层，其路径就是一个全排列。

再进一步，如何遍历一颗树，

-
1
2
3
4
5
6
void traverse(TreeNode root) {
    for (TreeNode child : root.childern)
        // 前序遍历需要的操作
        traverse(child);
        // 后序遍历需要的操作
}
+
1
2
3
4
5
6
void traverse(TreeNode root) {
    for (TreeNode child : root.childern)
        // 前序遍历需要的操作
        traverse(child);
        // 后序遍历需要的操作
}
@@ -1332,12 +1332,12 @@

回溯代码核心框架

-
1
2
3
4
5
6
7
8
9
for 选择 in 选择列表:
    # 做选择
    将该选择从选择列表移除
    路径.add(选择)
    backtrack(路径, 选择列表)
    # 撤销选择
    路径.remove(选择)
    将该选择再加入选择列表

+
1
2
3
4
5
6
7
8
9
for 选择 in 选择列表:
    # 做选择
    将该选择从选择列表移除
    路径.add(选择)
    backtrack(路径, 选择列表)
    # 撤销选择
    路径.remove(选择)
    将该选择再加入选择列表

我们只要在递归之前做出选择，在递归之后撤销自己的选择，就能得到每个节点的选择路径和列表。

-

全排列代码

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
List<List<Integer>> res = new LinkedList<>();

/* 主函数，输入一组不重复的数字，返回它们的全排列 */
List<List<Integer>> permute(int[] nums) {
    // 记录「路径」
    LinkedList<Integer> track = new LinkedList<>();
    backtrack(nums, track);
    return res;
}

// 路径：记录在 track 中
// 选择列表：nums 中不存在于 track 的那些元素
// 结束条件：nums 中的元素全都在 track 中出现
void backtrack(int[] nums, LinkedList<Integer> track) {
    // 触发结束条件
    if (track.size() == nums.length) {
        res.add(new LinkedList(track));
        return;
    }
    
    for (int i = 0; i < nums.length; i++) {
        // 排除不合法的选择
        if (track.contains(nums[i]))
            continue;
        // 做选择
        track.add(nums[i]);
        // 进入下一层决策树
        backtrack(nums, track);
        // 取消选择
        track.removeLast();
    }
}
+

全排列代码

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
List<List<Integer>> res = new LinkedList<>();

/* 主函数，输入一组不重复的数字，返回它们的全排列 */
List<List<Integer>> permute(int[] nums) {
    // 记录「路径」
    LinkedList<Integer> track = new LinkedList<>();
    backtrack(nums, track);
    return res;
}

// 路径：记录在 track 中
// 选择列表：nums 中不存在于 track 的那些元素
// 结束条件：nums 中的元素全都在 track 中出现
void backtrack(int[] nums, LinkedList<Integer> track) {
    // 触发结束条件
    if (track.size() == nums.length) {
        res.add(new LinkedList(track));
        return;
    }
    
    for (int i = 0; i < nums.length; i++) {
        // 排除不合法的选择
        if (track.contains(nums[i]))
            continue;
        // 做选择
        track.add(nums[i]);
        // 进入下一层决策树
        backtrack(nums, track);
        // 取消选择
        track.removeLast();
    }
}

我们这里稍微做了些变通，没有显式记录「选择列表」，而是通过 nums 和 track 推导出当前的选择列表：

通过contains函数来判断该数是否已经被使用。

@@ -1348,10 +1348,10 @@

例子2 N皇后问题

题意

给你一个N*N的棋盘，，让你放置 N 个皇后，使得它们不能互相攻击。

PS：皇后可以攻击同一行、同一列、左上左下右上右下四个方向的任意单位。

这个问题本质上跟全排列问题差不多，决策树的每一层表示棋盘上的每一行；每个节点可以做出的选择是，在该行的任意一列放置一个皇后。

-
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
vector<vector<string>> res;

/* 输入棋盘边长 n，返回所有合法的放置 */
vector<vector<string>> solveNQueens(int n) {
    // '.' 表示空，'Q' 表示皇后，初始化空棋盘。
    vector<string> board(n, string(n, '.'));
    backtrack(board, 0);
    return res;
}

// 路径：board 中小于 row 的那些行都已经成功放置了皇后
// 选择列表：第 row 行的所有列都是放置皇后的选择
// 结束条件：row 超过 board 的最后一行
void backtrack(vector<string>& board, int row) {
    // 触发结束条件
    if (row == board.size()) {
        res.push_back(board);
        return;
    }
    
    int n = board[row].size();
    for (int col = 0; col < n; col++) {
        // 排除不合法选择
        if (!isValid(board, row, col)) 
            continue;
        // 做选择
        board[row][col] = 'Q';
        // 进入下一行决策
        backtrack(board, row + 1);
        // 撤销选择
        board[row][col] = '.';
    }
}
+
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
vector<vector<string>> res;

/* 输入棋盘边长 n，返回所有合法的放置 */
vector<vector<string>> solveNQueens(int n) {
    // '.' 表示空，'Q' 表示皇后，初始化空棋盘。
    vector<string> board(n, string(n, '.'));
    backtrack(board, 0);
    return res;
}

// 路径：board 中小于 row 的那些行都已经成功放置了皇后
// 选择列表：第 row 行的所有列都是放置皇后的选择
// 结束条件：row 超过 board 的最后一行
void backtrack(vector<string>& board, int row) {
    // 触发结束条件
    if (row == board.size()) {
        res.push_back(board);
        return;
    }
    
    int n = board[row].size();
    for (int col = 0; col < n; col++) {
        // 排除不合法选择
        if (!isValid(board, row, col)) 
            continue;
        // 做选择
        board[row][col] = 'Q';
        // 进入下一行决策
        backtrack(board, row + 1);
        // 撤销选择
        board[row][col] = '.';
    }
}

IsValid()函数

-
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/* 是否可以在 board[row][col] 放置皇后？ */
bool isValid(vector<string>& board, int row, int col) {
    int n = board.size();
    // 检查列是否有皇后互相冲突
    for (int i = 0; i < n; i++) {
        if (board[i][col] == 'Q')
            return false;
    }
    // 检查右上方是否有皇后互相冲突
    for (int i = row - 1, j = col + 1; 
            i >= 0 && j < n; i--, j++) {
        if (board[i][j] == 'Q')
            return false;
    }
    // 检查左上方是否有皇后互相冲突
    for (int i = row - 1, j = col - 1;
            i >= 0 && j >= 0; i--, j--) {
        if (board[i][j] == 'Q')
            return false;
    }
    return true;
}

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/* 是否可以在 board[row][col] 放置皇后？ */
bool isValid(vector<string>& board, int row, int col) {
    int n = board.size();
    // 检查列是否有皇后互相冲突
    for (int i = 0; i < n; i++) {
        if (board[i][col] == 'Q')
            return false;
    }
    // 检查右上方是否有皇后互相冲突
    for (int i = row - 1, j = col + 1; 
            i >= 0 && j < n; i--, j++) {
        if (board[i][j] == 'Q')
            return false;
    }
    // 检查左上方是否有皇后互相冲突
    for (int i = row - 1, j = col - 1;
            i >= 0 && j >= 0; i--, j--) {
        if (board[i][j] == 'Q')
            return false;
    }
    return true;
}

函数 backtrack 依然像个在决策树上游走的指针，通过 row 和 col 就可以表示函数遍历到的位置，通过 isValid 函数可以将不符合条件的情况剪枝：

diff --git a/page/3/index.html b/page/3/index.html index efdd32cc0..220f0bde3 100644 --- a/page/3/index.html +++ b/page/3/index.html @@ -575,16 +575,16 @@

题

输入格式

一个整数 nn。

输出格式

一个整数，表示整数 nn 的十六进制表示包含的圈圈总数。

数据范围

前三个测试点满足 0≤n≤1000≤n≤100,
所有测试点满足 0≤n≤2×1090≤n≤2×109。

-

输入样例1：

1
11
+

输入样例1：

1
11
-

输出样例1：

1
2
+

输出样例1：

1
2
-

输入样例2：

1
14
+

输入样例2：

1
14
-

输出样例2：

1
0
+

输出样例2：

1
0

简单模拟即可 注意特判0 每次都在这里栽跟头…

-
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// package com.ACC;

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        long n = scanner.nextLong();
        long ans = 0;
        if(n == 0)     System.out.println(1);
        else{while(n > 0)
        {
            long m = n% 16;
//            System.out.println(m);
            if(m == 0|| m == 4 || m == 6 || m==9 || m== 10||m == 13) ans++;
            else if(m == 8 || m == 11) ans +=2;
            n = n / 16;
        }
        System.out.println(ans);
    }
    }
}

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// package com.ACC;

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        long n = scanner.nextLong();
        long ans = 0;
        if(n == 0)     System.out.println(1);
        else{while(n > 0)
        {
            long m = n% 16;
//            System.out.println(m);
            if(m == 0|| m == 4 || m == 6 || m==9 || m== 10||m == 13) ans++;
            else if(m == 8 || m == 11) ans +=2;
            n = n / 16;
        }
        System.out.println(ans);
    }
    }
}

题目B

农夫约翰有 nn 片连续的农田，编号依次为 1∼n1∼n。

其中有 kk 片农田中装有洒水器。

@@ -600,12 +600,12 @@

输出格式

每组数据输出一行答案。

数据范围

前三个测试点满足 1≤n≤51≤n≤5,
所有测试点满足 1≤T≤2001≤T≤200，1≤n≤2001≤n≤200，1≤k≤n1≤k≤n，1≤xi≤n1≤xi≤n，xi−1<xixi−1<xi，TT 组数据的 nn 相加之和不超过 200200。

-

输入样例：

1
2
3
4
5
6
7
3
5 1
3
3 3
1 2 3
4 1
1
+

输入样例：

1
2
3
4
5
6
7
3
5 1
3
3 3
1 2 3
4 1
1
-

输出样例：

1
2
3
3
1
4
+

输出样例：

1
2
3
3
1
4

模拟即可

-
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
// package com.ACC;

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int T = scanner.nextInt();
        int[] n = new int[T];
        int[] k = new int[T];
        for (int i = 0; i < T; i++) {
            n[i] = scanner.nextInt();
            k[i] = scanner.nextInt();
            int[] a = new int[k[i]];
            for (int j = 0; j < k[i]; j++) {
                a[j] = scanner.nextInt();
            }
            int q = n[i] - a[k[i] -1]+1;
            int ans = Math.max(a[0],q);
            if(k[i] == 1)   ans =Math.max(a[0],n[i] - a[0]+1);
            else {
                for (int j = 0; j + 1 < k[i]; j++) {
                    ans = Math.max(ans, (a[j + 1] - a[j]+2)/2);
                }
            }
            System.out.println(ans);
        }
    }
}

+
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
// package com.ACC;

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int T = scanner.nextInt();
        int[] n = new int[T];
        int[] k = new int[T];
        for (int i = 0; i < T; i++) {
            n[i] = scanner.nextInt();
            k[i] = scanner.nextInt();
            int[] a = new int[k[i]];
            for (int j = 0; j < k[i]; j++) {
                a[j] = scanner.nextInt();
            }
            int q = n[i] - a[k[i] -1]+1;
            int ans = Math.max(a[0],q);
            if(k[i] == 1)   ans =Math.max(a[0],n[i] - a[0]+1);
            else {
                for (int j = 0; j + 1 < k[i]; j++) {
                    ans = Math.max(ans, (a[j + 1] - a[j]+2)/2);
                }
            }
            System.out.println(ans);
        }
    }
}

题目C

@@ -1338,16 +1338,16 @@

语法

1.无参数，无返回值

1
2
Runnable t = () -> System.out.println("Hello Lambda")
t.run();
+

语法

1.无参数，无返回值

1
2
Runnable t = () -> System.out.println("Hello Lambda")
t.run();
-

2.有参数，无返回值

1
(x)-> System.out.println(x)
+

2.有参数，无返回值

1
(x)-> System.out.println(x)

若只有一个参数,小括号可以省略不写

-
1
x-> System.out.println(x)
+
1
x-> System.out.println(x)

3.有两个以上的参数,有返回值,并且 Lambda体中有多条语句

-
1
Comparator<Integer> com =(x,y)->(System.out.print1n("函数式接口") return Integer.compare(x,y)
+
1
Comparator<Integer> com =(x,y)->(System.out.print1n("函数式接口") return Integer.compare(x,y)

…待续

diff --git a/page/4/index.html b/page/4/index.html index fbf5ec7dd..e0bd05500 100644 --- a/page/4/index.html +++ b/page/4/index.html @@ -252,7 +252,7 @@

== 与 equals

String类中的equals方法是重写过的 因为Object的equals类方法是比较的对象的内存地址 而String类中的equals方法比较的是对象的值

当创建 String 类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象，如果有就把它赋给当前引用。如果没有就在常量池中重新创建一个 String 对象

String类equals()方法：

-
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

HashCode() 与 equals()

@@ -527,26 +527,26 @@

准备找到这一项 点开

记录下这个的信息 userAccount即是学号 encodedd是学号+密码的base64加密

maven依赖

-
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
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.2</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>JWXT</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>JWXT</name>
    <description>JWXT</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.jsoup</groupId>
            <artifactId>jsoup</artifactId>
            <version>1.10.3</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-mail -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-mail</artifactId>
            <version>2.5.4</version>
        </dependency>
        <!--Lang3工具类-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.7</version>
        </dependency>
        <!-- 发送邮件 -->
        <dependency>
            <groupId>javax.mail</groupId>
            <artifactId>mail</artifactId>
            <version>1.4.7</version>
        </dependency>

        <!--HttpClient-->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.6</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.3.4</version>
        </dependency>
        <!--阿里巴巴 json-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.51</version>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.1.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

+
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
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.2</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>JWXT</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>JWXT</name>
    <description>JWXT</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.jsoup</groupId>
            <artifactId>jsoup</artifactId>
            <version>1.10.3</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-mail -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-mail</artifactId>
            <version>2.5.4</version>
        </dependency>
        <!--Lang3工具类-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.7</version>
        </dependency>
        <!-- 发送邮件 -->
        <dependency>
            <groupId>javax.mail</groupId>
            <artifactId>mail</artifactId>
            <version>1.4.7</version>
        </dependency>

        <!--HttpClient-->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.6</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.3.4</version>
        </dependency>
        <!--阿里巴巴 json-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.51</version>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.1.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

在IDEA新建Springboot框架 然后在新建类LoginPZ

-
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
package com.example.jwxt;


import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.protocol.HttpClientContext;
import org.apache.http.cookie.Cookie;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;

import java.io.IOException;
import java.net.URI;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 登录
 */
public class LoginPz {
    public static String hello() {
        Map<String,String> param = new HashMap<>();
        String userAccount = "你的学号";
        String userPassword = "密码";
        String encoded = "上文提到的加密信息";//加密信息
        param.put("userAccount",userAccount);
        param.put("userPassword",userPassword);
        param.put("encoded",encoded);
        List<URI> redirectLocations = null;
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost("http://218.75.197.123:83/jsxsd/xk/LoginToXk");
            //请求头
            httpPost.addHeader("Content-Type","application/x-www-form-urlencoded");
            httpPost.addHeader("Cookie","JSESSIONID=22B4C4CE6240C6C53FF6BC3C197E3B83; SERVERID=121; JSESSIONID=8FFFAEA49DC840CE5A3135330C06CED3");
            // 创建参数列表
            if (param != null) {
                List<NameValuePair> paramList = new ArrayList<>();
                for (String key : param.keySet()) {
                    paramList.add(new BasicNameValuePair(key, param.get(key)));
                }
                // 模拟表单登录
                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList);
                httpPost.setEntity(entity);
            }
            // 执行http请求
            HttpClientContext context = HttpClientContext.create();
            response = httpClient.execute(httpPost,context);
            //获取Cookie信息,得到两个参数 JSESSIONID 、 Serverid
            List<Cookie> cookies = context.getCookieStore().getCookies();
            for (Cookie cookie : cookies) {
                String name = cookie.getName();
                String value = cookie.getValue();
//                System.out.println("name:"+name+","+value);
                return value;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return " ";
    }
}
+
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
package com.example.jwxt;


import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.protocol.HttpClientContext;
import org.apache.http.cookie.Cookie;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;

import java.io.IOException;
import java.net.URI;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 登录
 */
public class LoginPz {
    public static String hello() {
        Map<String,String> param = new HashMap<>();
        String userAccount = "你的学号";
        String userPassword = "密码";
        String encoded = "上文提到的加密信息";//加密信息
        param.put("userAccount",userAccount);
        param.put("userPassword",userPassword);
        param.put("encoded",encoded);
        List<URI> redirectLocations = null;
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost("http://218.75.197.123:83/jsxsd/xk/LoginToXk");
            //请求头
            httpPost.addHeader("Content-Type","application/x-www-form-urlencoded");
            httpPost.addHeader("Cookie","JSESSIONID=22B4C4CE6240C6C53FF6BC3C197E3B83; SERVERID=121; JSESSIONID=8FFFAEA49DC840CE5A3135330C06CED3");
            // 创建参数列表
            if (param != null) {
                List<NameValuePair> paramList = new ArrayList<>();
                for (String key : param.keySet()) {
                    paramList.add(new BasicNameValuePair(key, param.get(key)));
                }
                // 模拟表单登录
                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList);
                httpPost.setEntity(entity);
            }
            // 执行http请求
            HttpClientContext context = HttpClientContext.create();
            response = httpClient.execute(httpPost,context);
            //获取Cookie信息,得到两个参数 JSESSIONID 、 Serverid
            List<Cookie> cookies = context.getCookieStore().getCookies();
            for (Cookie cookie : cookies) {
                String name = cookie.getName();
                String value = cookie.getValue();
//                System.out.println("name:"+name+","+value);
                return value;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return " ";
    }
}

这是模拟教务系统登陆 然后我们新建类GetUserInfo

代码如下

-
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
package com.example.jwxt;

import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

import java.util.ArrayList;
import java.util.List;
import java.util.Timer;
import java.util.stream.Collectors;

/**
 * 登录后获取用户信息
 * 相关解析HTMl的操作不是固定的
 * 需要结合自己的需求来操作
 * 此处仅作为演示。
 */
public class GetUserInfo {
    static int idx = 0;
    public static void cj() throws Exception {
        for (int i = 0; i < 1000000000; ) {
            LoginPz loginPz = new LoginPz();
            String cookies = loginPz.hello();
            CloseableHttpClient httpClient = HttpClients.createDefault();
            try {
                HttpGet httpGet = new HttpGet("http://218.75.197.123:83/jsxsd/kscj/cjcx_list?kksj=2021-2022-1");//2021-2022-1为学期信息 可自行更改
                //增加头信息
                //注意此处需要修改为正确的JSESSIONID 和 SERVERID
                httpGet.addHeader("Cookie", "JSESSIONID" + "=" + cookies + "; SERVERID=121; JSESSIONID=8FFFAEA49DC840CE5A3135330C06CED3");
                httpGet.addHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36");
                httpGet.addHeader("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9");
                httpGet.addHeader("Connection", "keep-alive");

                //执行
                CloseableHttpResponse response = httpClient.execute(httpGet);
                String html = EntityUtils.toString(response.getEntity(), "utf8");
                Document parse = Jsoup.parse(html);
                parseHtml(parse);
                Thread thread = new Thread();
                thread.sleep(600000);
            } catch (Exception e) {
            }

        }
    }

    private static void parseHtml(Document parse) throws Exception {
//        int idx = 2;//目前已出成绩科目
        //选择table
        Element table = parse.getElementById("dataList");
        //选择tr
        Elements cells = table.select("tr");

        StringBuilder stringBuilder = new StringBuilder(); //用来存储成绩信息
        //自己存储的每一行数据
        List<List<String>> tables = new ArrayList<>();

        for (int index = 1; index < cells.size(); index++) {
            //第一行是表头 index = 0 跳过

            //第二行开始table数据

            Element row = cells.get(index);

            //搜索tr下的所有的td
            Elements rows = row.select("td");

            //每一行的数据
            List<String> dataList = new ArrayList<>();

            for (Element element : rows) {
                dataList.add(element.text());
            }
            tables.add(dataList);
        }

        //获取表头
        Elements headers = cells.get(0).select("th");
        List<String> tableHeader = headers.stream()
                .map(Element::text)
                .collect(Collectors.toList());

        //打印数据
        for (String str : tableHeader) {
            System.out.printf(str + "    ");
            stringBuilder.append(str + "      ");
        }
        stringBuilder.append("\r\n");
        System.out.println("");
        for (List<String> strs : tables) {
            for (String str : strs) {
                System.out.printf(str + "        ");
                stringBuilder.append(str + "         ");
            }
            stringBuilder.append("\r\n");
            System.out.println("");
        }
        System.out.println();
//        System.out.println(tables.size());
        if (tables.size() > idx)//idx 为原先的成绩数量123
        {
            //发送邮件给自己
            System.out.println("这是一个标志");
            SendMailUtil.sendEmail("你的邮箱 xxxx@qq.com", "成绩更新", stringBuilder.toString());
            idx = tables.size();
        }
    }
}

+
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
package com.example.jwxt;

import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

import java.util.ArrayList;
import java.util.List;
import java.util.Timer;
import java.util.stream.Collectors;

/**
 * 登录后获取用户信息
 * 相关解析HTMl的操作不是固定的
 * 需要结合自己的需求来操作
 * 此处仅作为演示。
 */
public class GetUserInfo {
    static int idx = 0;
    public static void cj() throws Exception {
        for (int i = 0; i < 1000000000; ) {
            LoginPz loginPz = new LoginPz();
            String cookies = loginPz.hello();
            CloseableHttpClient httpClient = HttpClients.createDefault();
            try {
                HttpGet httpGet = new HttpGet("http://218.75.197.123:83/jsxsd/kscj/cjcx_list?kksj=2021-2022-1");//2021-2022-1为学期信息 可自行更改
                //增加头信息
                //注意此处需要修改为正确的JSESSIONID 和 SERVERID
                httpGet.addHeader("Cookie", "JSESSIONID" + "=" + cookies + "; SERVERID=121; JSESSIONID=8FFFAEA49DC840CE5A3135330C06CED3");
                httpGet.addHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.110 Safari/537.36");
                httpGet.addHeader("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9");
                httpGet.addHeader("Connection", "keep-alive");

                //执行
                CloseableHttpResponse response = httpClient.execute(httpGet);
                String html = EntityUtils.toString(response.getEntity(), "utf8");
                Document parse = Jsoup.parse(html);
                parseHtml(parse);
                Thread thread = new Thread();
                thread.sleep(600000);
            } catch (Exception e) {
            }

        }
    }

    private static void parseHtml(Document parse) throws Exception {
//        int idx = 2;//目前已出成绩科目
        //选择table
        Element table = parse.getElementById("dataList");
        //选择tr
        Elements cells = table.select("tr");

        StringBuilder stringBuilder = new StringBuilder(); //用来存储成绩信息
        //自己存储的每一行数据
        List<List<String>> tables = new ArrayList<>();

        for (int index = 1; index < cells.size(); index++) {
            //第一行是表头 index = 0 跳过

            //第二行开始table数据

            Element row = cells.get(index);

            //搜索tr下的所有的td
            Elements rows = row.select("td");

            //每一行的数据
            List<String> dataList = new ArrayList<>();

            for (Element element : rows) {
                dataList.add(element.text());
            }
            tables.add(dataList);
        }

        //获取表头
        Elements headers = cells.get(0).select("th");
        List<String> tableHeader = headers.stream()
                .map(Element::text)
                .collect(Collectors.toList());

        //打印数据
        for (String str : tableHeader) {
            System.out.printf(str + "    ");
            stringBuilder.append(str + "      ");
        }
        stringBuilder.append("\r\n");
        System.out.println("");
        for (List<String> strs : tables) {
            for (String str : strs) {
                System.out.printf(str + "        ");
                stringBuilder.append(str + "         ");
            }
            stringBuilder.append("\r\n");
            System.out.println("");
        }
        System.out.println();
//        System.out.println(tables.size());
        if (tables.size() > idx)//idx 为原先的成绩数量123
        {
            //发送邮件给自己
            System.out.println("这是一个标志");
            SendMailUtil.sendEmail("你的邮箱 xxxx@qq.com", "成绩更新", stringBuilder.toString());
            idx = tables.size();
        }
    }
}

新建发邮件的类SendMailUtil
邮箱建议使用qq邮箱 需要拿到授权码

-
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
package com.example.jwxt;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Properties;

import javax.mail.Address;
import javax.mail.Message;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;

import com.sun.mail.util.MailSSLSocketFactory;

public class SendMailUtil {

    //邮件服务器主机名
    // QQ邮箱的 SMTP 服务器地址为: smtp.qq.com
    private static String myEmailSMTPHost = "smtp.qq.com";

    //发件人邮箱
    private static String myEmailAccount = "xx@qq.com";

    //发件人邮箱密码（授权码）
    //在开启SMTP服务时会获取到一个授权码，把授权码填在这里
    private static String myEmailPassword = "授权码  需要自己去qq邮箱拿";

    /**
     * 邮件单发（自由编辑短信，并发送，适用于私信）
     *
     * @param toEmailAddress 收件箱地址
     * @param emailTitle 邮件主题
     * @param emailContent 邮件内容
     * @throws Exception
     */
    public static void sendEmail(String toEmailAddress, String emailTitle, String emailContent) throws Exception{

        Properties props = new Properties();

        // 开启debug调试
        props.setProperty("mail.debug", "true");

        // 发送服务器需要身份验证
        props.setProperty("mail.smtp.auth", "true");

        // 端口号
        props.put("mail.smtp.port", 465);

        // 设置邮件服务器主机名
        props.setProperty("mail.smtp.host", myEmailSMTPHost);

        // 发送邮件协议名称
        props.setProperty("mail.transport.protocol", "smtp");

        /**SSL认证，注意腾讯邮箱是基于SSL加密的，所以需要开启才可以使用**/
        MailSSLSocketFactory sf = new MailSSLSocketFactory();
        sf.setTrustAllHosts(true);

        //设置是否使用ssl安全连接（一般都使用）
        props.put("mail.smtp.ssl.enable", "true");
        props.put("mail.smtp.ssl.socketFactory", sf);

        //创建会话
        Session session = Session.getInstance(props);

        //获取邮件对象
        //发送的消息，基于观察者模式进行设计的
        Message msg = new MimeMessage(session);

        //设置邮件标题
        msg.setSubject(emailTitle);

        //设置邮件内容
        //使用StringBuilder，因为StringBuilder加载速度会比String快，而且线程安全性也不错
        StringBuilder builder = new StringBuilder();

        //写入内容
        builder.append("\n" + emailContent);

        //设置显示的发件时间
        msg.setSentDate(new Date());

        //设置邮件内容
        msg.setText(builder.toString());

        //设置发件人邮箱
        // InternetAddress 的三个参数分别为: 发件人邮箱, 显示的昵称(只用于显示, 没有特别的要求), 昵称的字符集编码
        msg.setFrom(new InternetAddress(myEmailAccount,"我的工作站", "UTF-8"));

        //得到邮差对象
        Transport transport = session.getTransport();

        //连接自己的邮箱账户
        //密码不是自己QQ邮箱的密码，而是在开启SMTP服务时所获取到的授权码
        //connect(host, user, password)
        transport.connect( myEmailSMTPHost, myEmailAccount, myEmailPassword);

        //发送邮件
        transport.sendMessage(msg, new Address[] { new InternetAddress(toEmailAddress) });

        //将该邮件保存到本地
        OutputStream out = new FileOutputStream("MyEmail.eml");
        msg.writeTo(out);
        out.flush();
        out.close();

        transport.close();
    }

}

+
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
package com.example.jwxt;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Properties;

import javax.mail.Address;
import javax.mail.Message;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;

import com.sun.mail.util.MailSSLSocketFactory;

public class SendMailUtil {

    //邮件服务器主机名
    // QQ邮箱的 SMTP 服务器地址为: smtp.qq.com
    private static String myEmailSMTPHost = "smtp.qq.com";

    //发件人邮箱
    private static String myEmailAccount = "xx@qq.com";

    //发件人邮箱密码（授权码）
    //在开启SMTP服务时会获取到一个授权码，把授权码填在这里
    private static String myEmailPassword = "授权码  需要自己去qq邮箱拿";

    /**
     * 邮件单发（自由编辑短信，并发送，适用于私信）
     *
     * @param toEmailAddress 收件箱地址
     * @param emailTitle 邮件主题
     * @param emailContent 邮件内容
     * @throws Exception
     */
    public static void sendEmail(String toEmailAddress, String emailTitle, String emailContent) throws Exception{

        Properties props = new Properties();

        // 开启debug调试
        props.setProperty("mail.debug", "true");

        // 发送服务器需要身份验证
        props.setProperty("mail.smtp.auth", "true");

        // 端口号
        props.put("mail.smtp.port", 465);

        // 设置邮件服务器主机名
        props.setProperty("mail.smtp.host", myEmailSMTPHost);

        // 发送邮件协议名称
        props.setProperty("mail.transport.protocol", "smtp");

        /**SSL认证，注意腾讯邮箱是基于SSL加密的，所以需要开启才可以使用**/
        MailSSLSocketFactory sf = new MailSSLSocketFactory();
        sf.setTrustAllHosts(true);

        //设置是否使用ssl安全连接（一般都使用）
        props.put("mail.smtp.ssl.enable", "true");
        props.put("mail.smtp.ssl.socketFactory", sf);

        //创建会话
        Session session = Session.getInstance(props);

        //获取邮件对象
        //发送的消息，基于观察者模式进行设计的
        Message msg = new MimeMessage(session);

        //设置邮件标题
        msg.setSubject(emailTitle);

        //设置邮件内容
        //使用StringBuilder，因为StringBuilder加载速度会比String快，而且线程安全性也不错
        StringBuilder builder = new StringBuilder();

        //写入内容
        builder.append("\n" + emailContent);

        //设置显示的发件时间
        msg.setSentDate(new Date());

        //设置邮件内容
        msg.setText(builder.toString());

        //设置发件人邮箱
        // InternetAddress 的三个参数分别为: 发件人邮箱, 显示的昵称(只用于显示, 没有特别的要求), 昵称的字符集编码
        msg.setFrom(new InternetAddress(myEmailAccount,"我的工作站", "UTF-8"));

        //得到邮差对象
        Transport transport = session.getTransport();

        //连接自己的邮箱账户
        //密码不是自己QQ邮箱的密码，而是在开启SMTP服务时所获取到的授权码
        //connect(host, user, password)
        transport.connect( myEmailSMTPHost, myEmailAccount, myEmailPassword);

        //发送邮件
        transport.sendMessage(msg, new Address[] { new InternetAddress(toEmailAddress) });

        //将该邮件保存到本地
        OutputStream out = new FileOutputStream("MyEmail.eml");
        msg.writeTo(out);
        out.flush();
        out.close();

        transport.close();
    }

}

拿授权码过程

拿到授权码之后复制到上面去

再到Application添加启动类

-
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.example.jwxt;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class  JwxtApplication {

    public static void main(String[] args) throws Exception {
        SpringApplication.run(JwxtApplication.class, args);
        GetUserInfo getUserInfo = new GetUserInfo();
        getUserInfo.cj();
    }

}

+
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.example.jwxt;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class  JwxtApplication {

    public static void main(String[] args) throws Exception {
        SpringApplication.run(JwxtApplication.class, args);
        GetUserInfo getUserInfo = new GetUserInfo();
        getUserInfo.cj();
    }

}

如果自己有服务器就把这个项目打包成jar包上跑起来

没有的话只能把项目一直跑着不关

@@ -558,7 +558,7 @@

准备然后用xshell 一直cd到jar包所在的路径

使用命令

-
1
nohup java -jar JWXT-0.0.1-SNAPSHOT.jar 2>&1 &
+
1
nohup java -jar JWXT-0.0.1-SNAPSHOT.jar 2>&1 &

然后就大功告成了 一般你跑起来之后就会收到一封邮件提醒

github的项目地址 https://github.com/fengxiaop/JWXT

@@ -721,14 +721,14 @@

我试了一下我的打表方式 20分钟还没打出最后一个数

直接搬官方的吧

-
1
2
3
4
5
   class Solution {
   public boolean checkPerfectNumber(int num) {
        return num == 6 || num == 28 || num == 496 || num == 8128 || num == 33550336;
    }
}
+
1
2
3
4
5
   class Solution {
   public boolean checkPerfectNumber(int num) {
        return num == 6 || num == 28 || num == 496 || num == 8128 || num == 33550336;
    }
}

方法二 枚举

-
1
2
3
4
5
6
7
8
9
10
11
12
class Solution {
    public boolean checkPerfectNumber(int num) {
        int sum = 0;
        if(num==1) return false;
    for(int i = 1;i <= num/2;i++)
    {
        if(num%i==0)
        sum+=i;
    }
    return sum==num;
    }
}
+
1
2
3
4
5
6
7
8
9
10
11
12
class Solution {
    public boolean checkPerfectNumber(int num) {
        int sum = 0;
        if(num==1) return false;
    for(int i = 1;i <= num/2;i++)
    {
        if(num%i==0)
        sum+=i;
    }
    return sum==num;
    }
}

这个稍微时间稍微长了一点

​

-
1
2
3
4
5
6
7
8
9
10
11
12
13
class Solution {
    public boolean checkPerfectNumber(int num) {
        if (num == 1) return false;
        int ans = 1;
        for (int i = 2; i <= num / i; i++) {
            if (num % i == 0) {
                ans += i;
                if (i * i != num) ans += num / i;
            }
        }
        return ans == num;
    }
}
+
1
2
3
4
5
6
7
8
9
10
11
12
13
class Solution {
    public boolean checkPerfectNumber(int num) {
        if (num == 1) return false;
        int ans = 1;
        for (int i = 2; i <= num / i; i++) {
            if (num % i == 0) {
                ans += i;
                if (i * i != num) ans += num / i;
            }
        }
        return ans == num;
    }
}

这个就很快了

同样是枚举 别人写的和我写的 感觉自己在时间复杂度方法还得加强

@@ -960,13 +960,13 @@

50. Pow(x, n)

难度中等8

实现 pow(x, n) ，即计算 x 的 n 次幂函数（即，xn）。

示例 1：

-
1
2
输入：x = 2.00000, n = 10
输出：1024.00000
+
1
2
输入：x = 2.00000, n = 10
输出：1024.00000

示例 2：

-
1
2
输入：x = 2.10000, n = 3
输出：9.26100
+
1
2
输入：x = 2.10000, n = 3
输出：9.26100

示例 3：

-
1
2
3
输入：x = 2.00000, n = -2
输出：0.25000
解释：2-2 = 1/22 = 1/4 = 0.25
+
1
2
3
输入：x = 2.00000, n = -2
输出：0.25000
解释：2-2 = 1/22 = 1/4 = 0.25

提示：

    @@ -976,29 +976,29 @@ 

    1
    1->2->4->8->16->32->64->128->256->512->1024
    +
    1
    1->2->4->8->16->32->64->128->256->512->1024

    时间复杂的为O（log 1024）也就是10

    算法板子

    -
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    class Solution {
        public double myPow(double x, int n) {
            long N = n;
            return N >= 0 ? quickMul(x, N) : 1.0 / quickMul(x, -N);
        }

        public double quickMul(double x, long N) {
            if (N == 0) {
                return 1.0;
            }
            double y = quickMul(x, N / 2);
            return N % 2 == 0 ? y * y : y * y * x;
        }
    }
    +
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    class Solution {
        public double myPow(double x, int n) {
            long N = n;
            return N >= 0 ? quickMul(x, N) : 1.0 / quickMul(x, -N);
        }

        public double quickMul(double x, long N) {
            if (N == 0) {
                return 1.0;
            }
            double y = quickMul(x, N / 2);
            return N % 2 == 0 ? y * y : y * y * x;
        }
    }
    -
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    class Solution {
        public double myPow(double x, int n) {
            long N = n;
           double ans = quickMul(x,N);
            if(N>=0) return ans;
            else return 1.0/ans;
        }

        public double quickMul(double x, long N) {
            if (N == 0) {
                return 1.0;
            }
            double y = quickMul(x, N / 2);
            if(N%2==0) return y*y;
            else return y*y*x;
        }
    }

    +
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    class Solution {
        public double myPow(double x, int n) {
            long N = n;
           double ans = quickMul(x,N);
            if(N>=0) return ans;
            else return 1.0/ans;
        }

        public double quickMul(double x, long N) {
            if (N == 0) {
                return 1.0;
            }
            double y = quickMul(x, N / 2);
            if(N%2==0) return y*y;
            else return y*y*x;
        }
    }

    进阶

    372. 超级次方

    难度 中等

    你的任务是计算 ab 对 1337 取模，a 是一个正整数，b 是一个非常大的正整数且会以数组形式给出。

    示例 1：

    -
    1
    2
    输入：a = 2, b = [3]
    输出：8
    +
    1
    2
    输入：a = 2, b = [3]
    输出：8

    示例 2：

    -
    1
    2
    输入：a = 2, b = [1,0]
    输出：1024
    +
    1
    2
    输入：a = 2, b = [1,0]
    输出：1024

    示例 3：

    -
    1
    2
    输入：a = 1, b = [4,3,3,8,5,2]
    输出：1
    +
    1
    2
    输入：a = 1, b = [4,3,3,8,5,2]
    输出：1

    示例 4：

    -
    1
    2
    输入：a = 2147483647, b = [2,0,0]
    输出：1198
    +
    1
    2
    输入：a = 2147483647, b = [2,0,0]
    输出：1198

    提示：

      @@ -1007,7 +1007,7 @@ 

      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
      class Solution {
          static final int MOD = 1337;

          public int superPow(int a, int[] b) {
              int ans = 1;
              for (int i = b.length - 1; i >= 0; --i) {
                  ans = (int) ((long) ans * pow(a, b[i]) % MOD);
                  a = pow(a, 10);
              }
              return ans;
          }

          public int pow(int x, int n) {
              int res = 1;
              while (n != 0) {
                  if (n % 2 != 0) {
                      res = (int) ((long) res * x % MOD);
                  }
                  x = (int) ((long) x * x % MOD);
                  n /= 2;
              }
              return res;
          }
      }


      +
      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
      class Solution {
          static final int MOD = 1337;

          public int superPow(int a, int[] b) {
              int ans = 1;
              for (int i = b.length - 1; i >= 0; --i) {
                  ans = (int) ((long) ans * pow(a, b[i]) % MOD);
                  a = pow(a, 10);
              }
              return ans;
          }

          public int pow(int x, int n) {
              int res = 1;
              while (n != 0) {
                  if (n % 2 != 0) {
                      res = (int) ((long) res * x % MOD);
                  }
                  x = (int) ((long) x * x % MOD);
                  n /= 2;
              }
              return res;
          }
      }


      作者：LeetCode-Solution
      链接：      https://leetcode-cn.com/problems/super-pow/solution/chao-ji-ci-fang-by-leetcode-solution-ow8j/

      @@ -1084,7 +1084,7 @@

      Contains方法

      ​

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      package com.HUToh;
      import java.io.BufferedInputStream;
      import java.io.BufferedReader;
      import java.io.IOException;
      import java.io.InputStreamReader;
      import java.util.*  ;

      public class Main {
          public static void main(String[] args){
              ArrayList arrayList = new ArrayList();
          String s1 = new String("abc");
              String s2 = new String("abc");
          arrayList.add(s1);
              arrayList.add(s2);
              String s3 = new String("abc");
              System.out.println(s1==s2);
              System.out.println(s1.equals(s2));
              System.out.println(arrayList.contains(s1));
              System.out.println(arrayList.contains(s3));
          }

      }
      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      package com.HUToh;
      import java.io.BufferedInputStream;
      import java.io.BufferedReader;
      import java.io.IOException;
      import java.io.InputStreamReader;
      import java.util.*  ;

      public class Main {
          public static void main(String[] args){
              ArrayList arrayList = new ArrayList();
          String s1 = new String("abc");
              String s2 = new String("abc");
          arrayList.add(s1);
              arrayList.add(s2);
              String s3 = new String("abc");
              System.out.println(s1==s2);
              System.out.println(s1.equals(s2));
              System.out.println(arrayList.contains(s1));
              System.out.println(arrayList.contains(s3));
          }

      }

      这段代码输出的是什么是

      是false true true true

      diff --git a/page/5/index.html b/page/5/index.html index 87070f9f2..6ba4c12b8 100644 --- a/page/5/index.html +++ b/page/5/index.html @@ -246,10 +246,10 @@

      Interator为对象 可以用hasNext和next

      hasNext下一个是不是还有

      next下一个

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      public class Main {
          public static void main(String[] args){
           ArrayList  list = new ArrayList();
              list.add(1);
              list.add(2);
              list.add(3);
              list.add(4);
              list.add(5);
              list.add(4);
              list.add(3);
              list.add(2);
              list.add(1);
              Iterator iterator = list.iterator();
              while (iterator.hasNext())
              {
                  System.out.println(iterator.next());
              }
          }

      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      public class Main {
          public static void main(String[] args){
           ArrayList  list = new ArrayList();
              list.add(1);
              list.add(2);
              list.add(3);
              list.add(4);
              list.add(5);
              list.add(4);
              list.add(3);
              list.add(2);
              list.add(1);
              Iterator iterator = list.iterator();
              while (iterator.hasNext())
              {
                  System.out.println(iterator.next());
              }
          }

      输出顺序也就是输入的顺序

      -
      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
      package com.HUToh;
      import java.io.BufferedInputStream;
      import java.io.BufferedReader;
      import java.io.IOException;
      import java.io.InputStreamReader;
      import java.util.*  ;

      public class Main {
          public static void main(String[] args){
           Set list = new HashSet();
              list.add(1);
              list.add(2);
              list.add(3);
              list.add(5);
              list.add(4);
              list.add(4);
              list.add(3);
              list.add(2);
              list.add(1);
              Iterator iterator = list.iterator();
              while (iterator.hasNext())
              {
                  System.out.println(iterator.next());
              }
          }

      }
      +
      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
      package com.HUToh;
      import java.io.BufferedInputStream;
      import java.io.BufferedReader;
      import java.io.IOException;
      import java.io.InputStreamReader;
      import java.util.*  ;

      public class Main {
          public static void main(String[] args){
           Set list = new HashSet();
              list.add(1);
              list.add(2);
              list.add(3);
              list.add(5);
              list.add(4);
              list.add(4);
              list.add(3);
              list.add(2);
              list.add(1);
              Iterator iterator = list.iterator();
              while (iterator.hasNext())
              {
                  System.out.println(iterator.next());
              }
          }

      }

      输出顺序和输入顺序并不一样

      所以说Set是无序的 而且Set是不重复的

      @@ -327,10 +327,10 @@

      L. 恭喜edg夺得S11冠军

      纯属签到题 细致一点就好了

      -
      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
      #include<stdio.h>
      int main(){
      printf("EDGNBEDGNBEDGNBEDGNBEDGNBEDGNBEDGNB\n");
      printf("EDGNBEDGNBEDGNBEDGNBEDGNBEDGNBEDGNB\n");
      printf("                             EDGNB\n");
      printf("                            EDGNB\n");
      printf("                           EDGNB\n");
      printf("                          EDGNB\n");
      printf("                         EDGNB\n");
      printf("                        EDGNB\n");
      printf("                       EDGNB\n");
      printf("                      EDGNB\n");
      printf("                     EDGNB\n");
      printf("                    EDGNB\n");
      printf("                   EDGNB\n");
      printf("                  EDGNB\n");
      printf("                 EDGNB\n");
      printf("                EDGNB\n");
      printf("               EDGNB\n");
      printf("              EDGNB\n");
      printf("             EDGNB\n");
      printf("            EDGNB\n");
      printf("           EDGNB\n");
      printf("          EDGNB\n");
      printf("         EDGNB\n");
      printf("        EDGNB\n");
      printf("       EDGNB\n");
      printf("      EDGNB\n");
      printf("     EDGNB\n");
      printf("    EDGNB\n");
      printf("   EDGNB\n");
      printf("  EDGNB\n");
      printf(" EDGNB\n");
      printf("EDGNB");
      return 0;
      }
      +
      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
      #include<stdio.h>
      int main(){
      printf("EDGNBEDGNBEDGNBEDGNBEDGNBEDGNBEDGNB\n");
      printf("EDGNBEDGNBEDGNBEDGNBEDGNBEDGNBEDGNB\n");
      printf("                             EDGNB\n");
      printf("                            EDGNB\n");
      printf("                           EDGNB\n");
      printf("                          EDGNB\n");
      printf("                         EDGNB\n");
      printf("                        EDGNB\n");
      printf("                       EDGNB\n");
      printf("                      EDGNB\n");
      printf("                     EDGNB\n");
      printf("                    EDGNB\n");
      printf("                   EDGNB\n");
      printf("                  EDGNB\n");
      printf("                 EDGNB\n");
      printf("                EDGNB\n");
      printf("               EDGNB\n");
      printf("              EDGNB\n");
      printf("             EDGNB\n");
      printf("            EDGNB\n");
      printf("           EDGNB\n");
      printf("          EDGNB\n");
      printf("         EDGNB\n");
      printf("        EDGNB\n");
      printf("       EDGNB\n");
      printf("      EDGNB\n");
      printf("     EDGNB\n");
      printf("    EDGNB\n");
      printf("   EDGNB\n");
      printf("  EDGNB\n");
      printf(" EDGNB\n");
      printf("EDGNB");
      return 0;
      }

      A. 阳阳姐的魔力数

      描述

      对于我们的出色的冒险者阳阳姐来说，魔力数对他有奇特的作用，能在战斗中助他一臂之力，所以他知道的魔力数越多越好，但是令他头疼的是，他不知道范围NN之内的自然数有多少个魔力数，于是他向你求助，你能帮帮他吗。 一个自然数有魔力，当且仅当这个自然数数可以由两个相同的自然数拼接起来，比如”2020”这个数字就是由两个”20”拼接而成，但是”2002”却不是魔力数，因为”20”和”02”是两个不同的数字。

      -
      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
      import java.util.*;
      class Main{
          public static void main(String[] args) {
              Scanner scan = new Scanner(System.in);
              long n = scan.nextLong();
              long sum =0;
              String s = n+"";
              String[]  str = {"9","99","999","9999","99999","999999","9999999","99999999","999999999","9999999999"};
              int m = s.length();
              int k = m/2;
              if(n<100){
              	if(n<11) System.out.print(0);
              	else if(n<22) System.out.print(1);
              	else if(n<33) System.out.print(2);
              	else if(n<44) System.out.print(3);
              	else if(n<55) System.out.print(4);
              	else if(n<66) System.out.print(5);
              	else if(n<77) System.out.print(6);
              	else if(n<88) System.out.print(7);
              	else if(n<99) System.out.print(8);
              	else if(n==99) System.out.print(9);
              }
              else{
              if(m%2==1)
              {
              	System.out.print(str[k-1]);
              }
              else{
              	String string ="";
              	String string1 ="";
              	for(int i = 0,j=k;i < k;i++,j++)
              	{
              		String t = s.charAt(i)+"";
              		String t1 = s.charAt(j)+"";
              		string = string+t;
              		string1 = string1+t1;
              	}
              	int a = Integer.parseInt(string);
              	int b = Integer.parseInt(string1);
              	if(a<=b)
              	{int q = (int) (Integer.parseInt(string)-Math.pow(10,(m/2)-1)+1);
              	int p = Integer.parseInt(str[(m/2)-2]);
              	System.out.print(q+p);}
              	else{
              		int q = (int) (Integer.parseInt(string)-Math.pow(10, (m/2)-1));
                  	int p = Integer.parseInt(str[(m/2)-2]);
                  	System.out.print(q+p);
              	}
              }
          }
          
      }
      }
      +
      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
      import java.util.*;
      class Main{
          public static void main(String[] args) {
              Scanner scan = new Scanner(System.in);
              long n = scan.nextLong();
              long sum =0;
              String s = n+"";
              String[]  str = {"9","99","999","9999","99999","999999","9999999","99999999","999999999","9999999999"};
              int m = s.length();
              int k = m/2;
              if(n<100){
              	if(n<11) System.out.print(0);
              	else if(n<22) System.out.print(1);
              	else if(n<33) System.out.print(2);
              	else if(n<44) System.out.print(3);
              	else if(n<55) System.out.print(4);
              	else if(n<66) System.out.print(5);
              	else if(n<77) System.out.print(6);
              	else if(n<88) System.out.print(7);
              	else if(n<99) System.out.print(8);
              	else if(n==99) System.out.print(9);
              }
              else{
              if(m%2==1)
              {
              	System.out.print(str[k-1]);
              }
              else{
              	String string ="";
              	String string1 ="";
              	for(int i = 0,j=k;i < k;i++,j++)
              	{
              		String t = s.charAt(i)+"";
              		String t1 = s.charAt(j)+"";
              		string = string+t;
              		string1 = string1+t1;
              	}
              	int a = Integer.parseInt(string);
              	int b = Integer.parseInt(string1);
              	if(a<=b)
              	{int q = (int) (Integer.parseInt(string)-Math.pow(10,(m/2)-1)+1);
              	int p = Integer.parseInt(str[(m/2)-2]);
              	System.out.print(q+p);}
              	else{
              		int q = (int) (Integer.parseInt(string)-Math.pow(10, (m/2)-1));
                  	int p = Integer.parseInt(str[(m/2)-2]);
                  	System.out.print(q+p);
              	}
              }
          }
          
      }
      }

      这题有着更好的方法 纯数学题 我直接吧所有情况考虑上了

      奇数位的时候为固定数 不满足魔力数

      @@ -339,7 +339,7 @@ 

      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
      import java.util.*;
      class Main{
          public static void main(String[] args) {
              Scanner scan = new Scanner(System.in);
              int n = scan.nextInt(); 
             	String s = scan.next(); 
              if(n < 10){ System.out.print("Yuuki is unhappy");}
              else{
                  int l = 0,r=10;
                  while(r <=n)
                  {
                      int p=0,q=0;
                  	for(;l<r;l++){
                      if(s.charAt(l)=='a') p++;
                      else q++;
                  	}	
                  if(p==5&&q==5) {System.out.println(r-9+" "+r);
                  break;}
          		else {
                      r++;
                      l = r-10;
          			}
                  }
                  if(r > n) System.out.print("Yuuki is unhappy");
      }
      }
      }
      +
      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
      import java.util.*;
      class Main{
          public static void main(String[] args) {
              Scanner scan = new Scanner(System.in);
              int n = scan.nextInt(); 
             	String s = scan.next(); 
              if(n < 10){ System.out.print("Yuuki is unhappy");}
              else{
                  int l = 0,r=10;
                  while(r <=n)
                  {
                      int p=0,q=0;
                  	for(;l<r;l++){
                      if(s.charAt(l)=='a') p++;
                      else q++;
                  	}	
                  if(p==5&&q==5) {System.out.println(r-9+" "+r);
                  break;}
          		else {
                      r++;
                      l = r-10;
          			}
                  }
                  if(r > n) System.out.print("Yuuki is unhappy");
      }
      }
      }

      这题卡回车

      卡了半个小时 挺恶心的 。。。。

      @@ -356,23 +356,23 @@

      输出第一行输出能否到达目的地。

      如果能，输出”YES”(不包含引号)，否则输出”NO“(不包含引号)。

      如果能够到达目的地，在第二行输出所需的最小步数，定义每一步为坐标加一或者减一。

      -
      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
      import java.util.*;
      class Main{
          public static void main(String[] args) {
              Scanner scan = new Scanner(System.in);
              int n = scan.nextInt();
              long []arr = new long[2];
              long []arr2 = new long[2]; 
              for(int i = 0;i < n;i++)
              {
              	arr[0] = scan.nextLong();
              	arr[1] = scan.nextLong();
              	arr2[0] = scan.nextLong();
              	arr2[1] = scan.nextLong();	
              	long x = Math.abs(arr[0]-arr2[0]);
              	long y = Math.abs(arr[1]-arr2[1]);
              	long z = Math.min(x, y);
                 	long sum = z*2;
              	long p = Math.max(x,y);
              	p = p-z;
              	if(p%2==0) sum = sum + p*2;
              	else sum = sum +(p*2)-1;
              	System.out.println("YES");
              	System.out.println(sum);
              		}
              
          }
      }
      +
      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
      import java.util.*;
      class Main{
          public static void main(String[] args) {
              Scanner scan = new Scanner(System.in);
              int n = scan.nextInt();
              long []arr = new long[2];
              long []arr2 = new long[2]; 
              for(int i = 0;i < n;i++)
              {
              	arr[0] = scan.nextLong();
              	arr[1] = scan.nextLong();
              	arr2[0] = scan.nextLong();
              	arr2[1] = scan.nextLong();	
              	long x = Math.abs(arr[0]-arr2[0]);
              	long y = Math.abs(arr[1]-arr2[1]);
              	long z = Math.min(x, y);
                 	long sum = z*2;
              	long p = Math.max(x,y);
              	p = p-z;
              	if(p%2==0) sum = sum + p*2;
              	else sum = sum +(p*2)-1;
              	System.out.println("YES");
              	System.out.println(sum);
              		}
              
          }
      }

      单纯的模拟题 只是这里就需要回车了 卡的我头大了

      K. 樊学长的馈赠

      描述

      fzx学长是一位非常厉害的老学长，他在备战考研时依旧挂念着我们的小萌新们，于是他特意给大家出了一道有意思的题目：
      在茫茫大海中有n座独立的岛屿，岛上生活着一些淳朴善良的村民。
      但是有一天，大海上出现了一群可怕的海盗，海盗们虽然不敢直接攻击岛屿，但是会在海上等待他们出来捕鱼，然后趁机袭击他们。
      村民们为了抵御海盗，决定与其他岛屿结成攻守同盟，现在你需要为他们规划航线，使得n个岛屿形成一个整体(从任意一个岛屿出发，都能到达其他的n-1个岛屿)。
      但是由于村民们没有接受过现代化的教育，所以他们看不懂你画的航线图，所以你只能告诉他们要设立一些航线，村民们会随机选择两个之前没有建立过航线的岛屿，在两个岛屿之间建立一条航线。
      但是设立航线也是很麻烦的事情，为了尽快组成同盟抵御海盗，你需要找到一个最小的航线数量m，确保n个岛屿一定能形成一个整体。
      ***注意：一条航线可以看作连接两个岛屿**u**和*v*的一条边，相同的两个岛屿之间不会有重复的航线,同时也不会有岛屿规划到自己本身的航线*

      输入

      第一行输入一个整数t(t\leq 5 \times 10^5)t(t≤5×105)，代表有tt个样例。
      每组样例有一行，输入一个整数n(1 < n \leq 10^9)n(1<n≤109)，代表有nn个独立的岛屿。

      输出

      每个样例输出一行，一行包含一个正整数mm代表生成的航线数量。

      -

      样例

      输入复制

      1
      2
      1
      3
      +

      样例

      输入复制

      1
      2
      1
      3
      -

      输出复制

      1
      2
      +

      输出复制

      1
      2
      -

      输入复制

      1
      2
      3
      2
      4
      5
      +

      输入复制

      1
      2
      3
      2
      4
      5
      -

      输出复制

      1
      2
      4
      7
      +

      输出复制

      1
      2
      4
      7
      -

      输入复制

      1
      2
      1
      65536
      +

      输入复制

      1
      2
      1
      65536
      -

      输出复制

      1
      2147385346
      +

      输出复制

      1
      2147385346

      这题看题目根本没用 直接撸样例 还是能够通过65536和2147385346

      后者的位数是前者的两倍

      @@ -458,7 +458,7 @@

      第一步创建一个Application类 加上@SpringBootApplication的注解

      打印控制台消息

      System.out.println("SpringBoot启动成功");

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      package com.example;

      import org.springframework.boot.SpringApplication;
      import org.springframework.boot.autoconfigure.SpringBootApplication;


      @SpringBootApplication
      public class Application {

          public static void main(String[] args) {
              SpringApplication.run(Application.class, args);
              System.out.println("SpringBoot启动成功");
          }

      }
      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      package com.example;

      import org.springframework.boot.SpringApplication;
      import org.springframework.boot.autoconfigure.SpringBootApplication;


      @SpringBootApplication
      public class Application {

          public static void main(String[] args) {
              SpringApplication.run(Application.class, args);
              System.out.println("SpringBoot启动成功");
          }

      }

      水印程序

      @@ -467,12 +467,12 @@

      文件序号 index

      文件路径 path

      构造有参无参

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

          /**
           * 文件序号
           */
          private Integer index;

          /**
           * 文件路径
           */
          private String path;

          public Integer getIndex() {
              return index;
          }

          public void setIndex(Integer index) {
              this.index = index;
          }

          public String getPath() {
              return path;
          }

          public void setPath(String path) {
              this.path = path;
          }
      }
      +
      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
      {

          /**
           * 文件序号
           */
          private Integer index;

          /**
           * 文件路径
           */
          private String path;

          public Integer getIndex() {
              return index;
          }

          public void setIndex(Integer index) {
              this.index = index;
          }

          public String getPath() {
              return path;
          }

          public void setPath(String path) {
              this.path = path;
          }
      }

      PDF拆分为image

      -
      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
      package com.example.pdfwatermark;


      import org.apache.pdfbox.pdmodel.PDDocument;
      import org.apache.pdfbox.rendering.ImageType;
      import org.apache.pdfbox.rendering.PDFRenderer;

      import javax.imageio.ImageIO;
      import java.awt.image.BufferedImage;
      import java.io.*;
      import java.util.ArrayList;
      import java.util.List;

      public class Pdf2Image {

          /**
           * 将File PDF文件转化为每一张图片
           * @param file PDF文件
           * @return 返回每一张图片的实体对象集合
           */
          public static List<FileDTO> generate(File file) {
              try {
                  Long now = System.currentTimeMillis();

                  //读取PDF
                  PDDocument document = PDDocument.load(file);

                  //加载PDF对象
                  PDFRenderer pdfRenderer = new PDFRenderer(document);

                  //存储的PDF每一张图片的路径以及索引
                  List<FileDTO> dataList = new ArrayList<>();

                  for (int page = 0;page<document.getNumberOfPages();page++){

                      //读取PDF每一页的图片
                      BufferedImage img = pdfRenderer.renderImageWithDPI(page, 300, ImageType.RGB);

                      //生成图片的本地路径
                      String pathname = PdfWatermarkConstants.PDF_2_IMAGE + now + "/" + file.getName() + page + ".png";

                      //创建本地文件
                      File imageFile = new File(pathname);
                      //创建文件夹
                      imageFile.mkdirs();
                      //创建文件
                      imageFile.createNewFile();

                      FileDTO dto = new FileDTO();
                      dataList.add(dto);

                      dto.setIndex(page);
                      dto.setPath(pathname);

                      //生成PNG格式的图片
                      ImageIO.write(img, "png", imageFile);
                  }
                  //关闭Doc流
                  document.close();

                  return dataList;
              } catch (Exception e) {
                  e.printStackTrace();
              }
              return new ArrayList<>();
          }
      }
      +
      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
      package com.example.pdfwatermark;


      import org.apache.pdfbox.pdmodel.PDDocument;
      import org.apache.pdfbox.rendering.ImageType;
      import org.apache.pdfbox.rendering.PDFRenderer;

      import javax.imageio.ImageIO;
      import java.awt.image.BufferedImage;
      import java.io.*;
      import java.util.ArrayList;
      import java.util.List;

      public class Pdf2Image {

          /**
           * 将File PDF文件转化为每一张图片
           * @param file PDF文件
           * @return 返回每一张图片的实体对象集合
           */
          public static List<FileDTO> generate(File file) {
              try {
                  Long now = System.currentTimeMillis();

                  //读取PDF
                  PDDocument document = PDDocument.load(file);

                  //加载PDF对象
                  PDFRenderer pdfRenderer = new PDFRenderer(document);

                  //存储的PDF每一张图片的路径以及索引
                  List<FileDTO> dataList = new ArrayList<>();

                  for (int page = 0;page<document.getNumberOfPages();page++){

                      //读取PDF每一页的图片
                      BufferedImage img = pdfRenderer.renderImageWithDPI(page, 300, ImageType.RGB);

                      //生成图片的本地路径
                      String pathname = PdfWatermarkConstants.PDF_2_IMAGE + now + "/" + file.getName() + page + ".png";

                      //创建本地文件
                      File imageFile = new File(pathname);
                      //创建文件夹
                      imageFile.mkdirs();
                      //创建文件
                      imageFile.createNewFile();

                      FileDTO dto = new FileDTO();
                      dataList.add(dto);

                      dto.setIndex(page);
                      dto.setPath(pathname);

                      //生成PNG格式的图片
                      ImageIO.write(img, "png", imageFile);
                  }
                  //关闭Doc流
                  document.close();

                  return dataList;
              } catch (Exception e) {
                  e.printStackTrace();
              }
              return new ArrayList<>();
          }
      }
      @@ -553,11 +553,11 @@

      题目其实很容易 但是这个输入卡的人傻了

      用nextInt() nextLong()都会爆

      后面我写的是字符串

      -
      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
      import java.util.Scanner;
      class Main {
          public static void main(String[] args) {
              Scanner scanner = new Scanner(System.in);
              int n = scanner.nextInt();
              for (int i = 0; i < n; i++) {
                  String s = scanner.next();
                  int m = s.length();
                  if(m == 1){
                      int k = s.charAt(0)-'0';
                      if(k%8==0) System.out.println("yes");
                      else System.out.println("no");
                  }
                  else if(m==2)
                  {
                      int q = s.charAt(0)-'0';
                      int w = s.charAt(1)-'0';
                      int k = q*10+w;
                      if(k%8==0) System.out.println("yes");
                      else System.out.println("no");
                  }
                  else if (m == 3) {
                      int q = s.charAt(0)-'0';
                      int w = s.charAt(1)-'0';
                      int e = s.charAt(2)-'0';
                      int k = q*100+w*10+e;
                      if (k % 8 == 0) System.out.println("yes");
                      else System.out.println("no");
                  } else if(m > 3) {
                      int st = s.charAt(m - 1) - '0';
                      int st1 = s.charAt(m - 2) - '0';
                      int st2 = s.charAt(m - 3) - '0';
                      int ans = st + st1*10 +  st2*100;
                      if (ans % 8 == 0) System.out.println("yes");
                      else System.out.println("no");
                  }
              }
              scanner.close();

          }
      }
      +
      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
      import java.util.Scanner;
      class Main {
          public static void main(String[] args) {
              Scanner scanner = new Scanner(System.in);
              int n = scanner.nextInt();
              for (int i = 0; i < n; i++) {
                  String s = scanner.next();
                  int m = s.length();
                  if(m == 1){
                      int k = s.charAt(0)-'0';
                      if(k%8==0) System.out.println("yes");
                      else System.out.println("no");
                  }
                  else if(m==2)
                  {
                      int q = s.charAt(0)-'0';
                      int w = s.charAt(1)-'0';
                      int k = q*10+w;
                      if(k%8==0) System.out.println("yes");
                      else System.out.println("no");
                  }
                  else if (m == 3) {
                      int q = s.charAt(0)-'0';
                      int w = s.charAt(1)-'0';
                      int e = s.charAt(2)-'0';
                      int k = q*100+w*10+e;
                      if (k % 8 == 0) System.out.println("yes");
                      else System.out.println("no");
                  } else if(m > 3) {
                      int st = s.charAt(m - 1) - '0';
                      int st1 = s.charAt(m - 2) - '0';
                      int st2 = s.charAt(m - 3) - '0';
                      int ans = st + st1*10 +  st2*100;
                      if (ans % 8 == 0) System.out.println("yes");
                      else System.out.println("no");
                  }
              }
              scanner.close();

          }
      }

      刚开始 判断k的位数是1位是 我用的判定条件是 if(k == 8) 漏了k==0的这种情况 0也是0的倍数

      看了一位学弟的代码 让我尤为惊人

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      import java.math.BigInteger;
      import java.util.Scanner;

      public class B {
          public static void main(String[] args) {
              Scanner scanner = new Scanner(System.in);
              int n = scanner.nextInt();
              BigInteger  a = scanner.nextBigInteger();
              BigInteger b=new BigInteger("8");
              BigInteger c=BigInteger.ZERO;
              if(a.mod(b)==c) System.out.println("yes");
              else System.out.println("no");
          }
      }

      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      import java.math.BigInteger;
      import java.util.Scanner;

      public class B {
          public static void main(String[] args) {
              Scanner scanner = new Scanner(System.in);
              int n = scanner.nextInt();
              BigInteger  a = scanner.nextBigInteger();
              BigInteger b=new BigInteger("8");
              BigInteger c=BigInteger.ZERO;
              if(a.mod(b)==c) System.out.println("yes");
              else System.out.println("no");
          }
      }

      青出如蓝 让我觉得学弟学妹太优秀了

      @@ -774,70 +774,70 @@

      数据输入
      一般我常用的数据输入方法有两种，Scanner和BufferedReader。BufferedReader可以读一行，速度比Scanner快，所以数据较多的时候使用。注意BufferedReader用完记得关。

      Scanner

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      import java.util.*;

      public class Main{
          public static void main(String[] args) {
              Scanner scan = new Scanner(System.in);
              int n = scan.nextInt(); // String: next(), double: nextDouble()
              int[] nums = new int[n];
              for (int i = 0; i < n; i++)
                  nums[i] = scan.nextInt();
              // ...
          }
      }
      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      import java.util.*;

      public class Main{
          public static void main(String[] args) {
              Scanner scan = new Scanner(System.in);
              int n = scan.nextInt(); // String: next(), double: nextDouble()
              int[] nums = new int[n];
              for (int i = 0; i < n; i++)
                  nums[i] = scan.nextInt();
              // ...
          }
      }

      BufferedReader

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      import java.util.*;
      import java.io.*;

      public class Main{
          public static void main(String[] args) throws IOException {
              BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
              int n = Integer.parseInt(reader.readLine());
              int[] nums = new int[n];
              String[] strs = reader.readLine().split(" ");
              for (int i = 0; i < n; i++)
                  nums[i] = Integer.parseInt(strs[i]);
              // ...
              reader.close(); // 记得关闭
          }
      }
      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      import java.util.*;
      import java.io.*;

      public class Main{
          public static void main(String[] args) throws IOException {
              BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
              int n = Integer.parseInt(reader.readLine());
              int[] nums = new int[n];
              String[] strs = reader.readLine().split(" ");
              for (int i = 0; i < n; i++)
                  nums[i] = Integer.parseInt(strs[i]);
              // ...
              reader.close(); // 记得关闭
          }
      }

      快速排序quickSort
      快速排序要注意x取值的边界情况。取x = nums[left], nums分为[left, j]和[j + 1, right]，或x = nums[right], nums分为[left, i - 1]和[i, right],否则会StackOverflow。

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      public void quickSort(int[] nums, int left, int right) {
          if (left >= right)
              return;
          int i = left - 1, j = right + 1, x = nums[left];
          while (i < j) {
              do i++; while (nums[i] < x);
              do j--; while (nums[j] > x);
              if (i < j) {
                  int temp = nums[i];
                  nums[i] = nums[j];
                  nums[j] = temp;
              }
          }
          quickSort(nums, left, j);
          quickSort(nums, j + 1, right);
      }
      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      public void quickSort(int[] nums, int left, int right) {
          if (left >= right)
              return;
          int i = left - 1, j = right + 1, x = nums[left];
          while (i < j) {
              do i++; while (nums[i] < x);
              do j--; while (nums[j] > x);
              if (i < j) {
                  int temp = nums[i];
                  nums[i] = nums[j];
                  nums[j] = temp;
              }
          }
          quickSort(nums, left, j);
          quickSort(nums, j + 1, right);
      }

      例题：AcWing 785, LeetCode 912

      归并排序mergeSort
      mergeSort时间复杂度是稳定O(nlogn)，空间复杂度O(n)，稳定的。quickSort时间复杂度平均O(nlogn)，最坏O(n^2)，最好O(nlogn)，空间复杂度O(nlogn)，不稳定的。

      public void mergeSort(int[] nums, int left, int right) {
      if (left >= right)
      return;

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      int mid = left + (right - left) / 2;
      mergeSort(nums, left, mid);
      mergeSort(nums, mid + 1, right);

      int k = 0, i = left, j = mid + 1;
      int[] temp = new int[right - left + 1];
      while (i <= mid && j <= right)
          if (nums[i] < nums[j])
              temp[k++] = nums[i++];
          else
              temp[k++] = nums[j++];
      while (i <= mid)
          temp[k++] = nums[i++];
      while (j <= right)
          temp[k++] = nums[j++];
      for (i = left, j = 0; i <= right; i++, j++)
          nums[i] = temp[j];
      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      int mid = left + (right - left) / 2;
      mergeSort(nums, left, mid);
      mergeSort(nums, mid + 1, right);

      int k = 0, i = left, j = mid + 1;
      int[] temp = new int[right - left + 1];
      while (i <= mid && j <= right)
          if (nums[i] < nums[j])
              temp[k++] = nums[i++];
          else
              temp[k++] = nums[j++];
      while (i <= mid)
          temp[k++] = nums[i++];
      while (j <= right)
          temp[k++] = nums[j++];
      for (i = left, j = 0; i <= right; i++, j++)
          nums[i] = temp[j];

      }
      例题：AcWing 787, LeetCode 912

      二分搜索binarySearch
      二分搜索逼近左边界，区间[left, right]被分为左区间[left, mid]和右区间[mid + 1, right]。

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      public int binarySearchLeft(int[] nums, int target) {
          int left = 0, right = nums.length - 1;
          while (left < right) {
              int mid = left + (right - left) / 2;
              if (check(mid))
                  right = mid;
              else
                  left = mid + 1;
          }
          return nums[left];
      }
      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      public int binarySearchLeft(int[] nums, int target) {
          int left = 0, right = nums.length - 1;
          while (left < right) {
              int mid = left + (right - left) / 2;
              if (check(mid))
                  right = mid;
              else
                  left = mid + 1;
          }
          return nums[left];
      }

      二分搜索逼近右边界，区间[left, right]被分为左区间[left, mid - 1]和右区间[mid, right]。

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      public int binarySearchRight(int[] nums, int target) {
          int left = 0, right = nums.length - 1;
          while (left < right) {
              int mid = left + (right - left) / 2 + 1;
              if (check(mid))
                  left = mid;
              else
                  right = mid - 1;
          }
          return nums[left];
      }
      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      public int binarySearchRight(int[] nums, int target) {
          int left = 0, right = nums.length - 1;
          while (left < right) {
              int mid = left + (right - left) / 2 + 1;
              if (check(mid))
                  left = mid;
              else
                  right = mid - 1;
          }
          return nums[left];
      }

      暑假在LeetCode打卡的时候发现还有第三种模板,nums[mid] == target 直接return，区间[left, right]被分为[left, mid - 1]和[mid + 1, right]。

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      public int searchInsert(int[] nums, int target) {
              int left = 0, right = nums.length - 1;
              while (left <= right) {
                  int mid = left + (right - left) / 2;
                  if (nums[mid] == target)
                      return mid;
                  else if (check(mid))
                      right = mid - 1;
                  else
                      left = mid + 1;
              }
              return left;
          }
      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      public int searchInsert(int[] nums, int target) {
              int left = 0, right = nums.length - 1;
              while (left <= right) {
                  int mid = left + (right - left) / 2;
                  if (nums[mid] == target)
                      return mid;
                  else if (check(mid))
                      right = mid - 1;
                  else
                      left = mid + 1;
              }
              return left;
          }

      例题：AcWing 789, LeetCode 34, LeetCode 35

      KMP

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      public int kmp(String text, String pattern) {
          int m = pattern.length();
          if (m == 0)
              return 0;
          int n = text.length();
          int[] next = new int[m + 1];
          for (int i = 2, j = 0; i <= m; i++) {
              while (j > 0 && pattern.charAt(i - 1) != pattern.charAt(j))
                  j = next[j];
              if (pattern.charAt(i - 1) == pattern.charAt(j))
                  j++;
              next[i] = j;
          }
          for (int i = 1, j = 0; i <= n; i++) {
              while (j > 0 && text.charAt(i - 1) != pattern.charAt(j))
                  j = next[j];
              if (text.charAt(i - 1) == pattern.charAt(j))
                  j++;
              if (j == m)
                  return i - m;
          }
          return -1;
      }
      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      public int kmp(String text, String pattern) {
          int m = pattern.length();
          if (m == 0)
              return 0;
          int n = text.length();
          int[] next = new int[m + 1];
          for (int i = 2, j = 0; i <= m; i++) {
              while (j > 0 && pattern.charAt(i - 1) != pattern.charAt(j))
                  j = next[j];
              if (pattern.charAt(i - 1) == pattern.charAt(j))
                  j++;
              next[i] = j;
          }
          for (int i = 1, j = 0; i <= n; i++) {
              while (j > 0 && text.charAt(i - 1) != pattern.charAt(j))
                  j = next[j];
              if (text.charAt(i - 1) == pattern.charAt(j))
                  j++;
              if (j == m)
                  return i - m;
          }
          return -1;
      }

      例题：AcWing 831, LeetCode 28

      Trie

      -
      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 final int SIZE = 26;

      public static class TrieNode {
          TrieNode[] children = new TrieNode[SIZE];
          int times;

          TrieNode() {
              times = 0;
              for (int i = 0; i < SIZE; i++)
                  children[i] = null;
          }

      }

      public static TrieNode root = new TrieNode();

      public static void insert(String word) {
          TrieNode node = root;
          for (int i = 0; i < word.length(); i++) {
              int index = word.charAt(i) - 'a';
              if (node.children[index] == null)
                  node.children[index] = new TrieNode();
              node = node.children[index];
          }
          node.times++;
      }

      public static int query(String word) {
          TrieNode node = root;
          for (int i = 0; i < word.length(); i++) {
              int index = word.charAt(i) - 'a';
              if (node.children[index] == null)
                  return 0;
              node = node.children[index];
          }
          return node.times;
      }
      +
      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 final int SIZE = 26;

      public static class TrieNode {
          TrieNode[] children = new TrieNode[SIZE];
          int times;

          TrieNode() {
              times = 0;
              for (int i = 0; i < SIZE; i++)
                  children[i] = null;
          }

      }

      public static TrieNode root = new TrieNode();

      public static void insert(String word) {
          TrieNode node = root;
          for (int i = 0; i < word.length(); i++) {
              int index = word.charAt(i) - 'a';
              if (node.children[index] == null)
                  node.children[index] = new TrieNode();
              node = node.children[index];
          }
          node.times++;
      }

      public static int query(String word) {
          TrieNode node = root;
          for (int i = 0; i < word.length(); i++) {
              int index = word.charAt(i) - 'a';
              if (node.children[index] == null)
                  return 0;
              node = node.children[index];
          }
          return node.times;
      }

      例题：AcWing 835

      并查集
      朴素并查集

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      public static int[] p;

      public static int find(int x) {
          if (p[x] != x)
              p[x] = find(p[x]);
          return p[x];
      }

      p[find(a)] = find(b);
      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      public static int[] p;

      public static int find(int x) {
          if (p[x] != x)
              p[x] = find(p[x]);
          return p[x];
      }

      p[find(a)] = find(b);

      例题：AcWing 836

      图的存储
      n个点，m条边，m约等于n2n2叫做稠密图，用邻接矩阵存储；n个点，m条边，m远小于n2n2叫做稀疏图，用邻接表存储。

      邻接矩阵

      -
      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 class Main{
          public static final int INF = 0x3f3f3f3f;
          public static int n;
          public static int[][] g;
          public static int[] dist;
          public static boolean[] visit;

          public static void main(String[] args) {
              Scanner scan = new Scanner(System.in);
              n = scan.nextInt();
              int m = scan.nextInt();
              g = new int[n + 1][n + 1];
              dist = new int[n + 1];
              visit = new boolean[n + 1];
              for (int i = 1; i <= n; i++)
                  for (int j = 1; j <= n; j++)
                      if (i == j)
                          g[i][j] = 0;
                      else
                          g[i][j] = INF;
              for (int i = 0; i < m; i++) {
                  int x = scan.nextInt(), y = scan.nextInt(), z = scan.nextInt();
                  g[a][b] = Math.min(g[a][b], c);
              }
              int res = dijkstra();
              System.out.println(res);
          }

      }
      +
      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 class Main{
          public static final int INF = 0x3f3f3f3f;
          public static int n;
          public static int[][] g;
          public static int[] dist;
          public static boolean[] visit;

          public static void main(String[] args) {
              Scanner scan = new Scanner(System.in);
              n = scan.nextInt();
              int m = scan.nextInt();
              g = new int[n + 1][n + 1];
              dist = new int[n + 1];
              visit = new boolean[n + 1];
              for (int i = 1; i <= n; i++)
                  for (int j = 1; j <= n; j++)
                      if (i == j)
                          g[i][j] = 0;
                      else
                          g[i][j] = INF;
              for (int i = 0; i < m; i++) {
                  int x = scan.nextInt(), y = scan.nextInt(), z = scan.nextInt();
                  g[a][b] = Math.min(g[a][b], c);
              }
              int res = dijkstra();
              System.out.println(res);
          }

      }

      邻接表

      -
      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
      import java.util.*;

      public class Main{
          public static int INF = 0x3f3f3f3f;
          public static int n;
          public static Map<Integer, List<Node>> map = new HashMap<>();
          public static int[] dist;
          public static boolean[] visit;

          public static class Node {
              public int node;
              public int length;
          
              public Node(int node, int length) {
                  this.node = node;
                  this.length = length;
              }
          }
          
          public static void main(String[] args) {
              Scanner scan = new Scanner(System.in);
              n = scan.nextInt();
              dist = new int[n + 1];
              visit = new boolean[n + 1];
              int m = scan.nextInt();
              for (int i = 1; i <= n; i++)
                  map.put(i, new ArrayList<>());
              for (int i = 0; i < m; i++) {
                  int x = scan.nextInt(), y = scan.nextInt(), z = scan.nextInt();
                  map.get(x).add(new Node(y, z));
              }
              int res = dijkstra();
              System.out.println(res);
          }

      }
      +
      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
      import java.util.*;

      public class Main{
          public static int INF = 0x3f3f3f3f;
          public static int n;
          public static Map<Integer, List<Node>> map = new HashMap<>();
          public static int[] dist;
          public static boolean[] visit;

          public static class Node {
              public int node;
              public int length;
          
              public Node(int node, int length) {
                  this.node = node;
                  this.length = length;
              }
          }
          
          public static void main(String[] args) {
              Scanner scan = new Scanner(System.in);
              n = scan.nextInt();
              dist = new int[n + 1];
              visit = new boolean[n + 1];
              int m = scan.nextInt();
              for (int i = 1; i <= n; i++)
                  map.put(i, new ArrayList<>());
              for (int i = 0; i < m; i++) {
                  int x = scan.nextInt(), y = scan.nextInt(), z = scan.nextInt();
                  map.get(x).add(new Node(y, z));
              }
              int res = dijkstra();
              System.out.println(res);
          }

      }

      Dijkstra
      边权不能是负数！
      1.dist[1] = 0, dist[i] = +∞
      2.for i 1 ~ n
      t <- 不在s中的，距离最近的点 – n2n2 / n
      s <- t – n
      用t更新其他点的距离 – m / mlogn

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      public static int dijkstra() {
          for (int i = 1; i <= n; i++)
              dist[i] = INF;
          dist[1] = 0;
          for (int i = 0; i < n - 1; i++) {
              int t = -1;
              for (int j = 1; j <= n; j++)
                  if (!visit[j] && (t == -1 || dist[t] > dist[j]))
                      t = j;
              if (t == n)
                  break;
              for (int j = 1; j <= n; j++)
                  dist[j] = Math.min(dist[j], dist[t] + g[t][j]);
              visit[t] = true;
          }
          if (dist[n] == INF)
              return -1;
          return dist[n];
      }
      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      public static int dijkstra() {
          for (int i = 1; i <= n; i++)
              dist[i] = INF;
          dist[1] = 0;
          for (int i = 0; i < n - 1; i++) {
              int t = -1;
              for (int j = 1; j <= n; j++)
                  if (!visit[j] && (t == -1 || dist[t] > dist[j]))
                      t = j;
              if (t == n)
                  break;
              for (int j = 1; j <= n; j++)
                  dist[j] = Math.min(dist[j], dist[t] + g[t][j]);
              visit[t] = true;
          }
          if (dist[n] == INF)
              return -1;
          return dist[n];
      }

      例题：AcWing 849

      优化Dijkstra

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      public static int dijkstra() {
              for (int i = 1; i <= n; i++)
                  dist[i] = INF;
              dist[1] = 0;
              PriorityQueue<Node> heap = new PriorityQueue<>((node1, node2) -> node1.length - node2.length);
              heap.add(new Node(1, 0));
              while (!heap.isEmpty()) {
                  Node top = heap.poll();
                  int length = top.length, cur = top.node;
                  if (visit[cur])
                      continue;
                  visit[cur] = true;
                  for (Node next: map.get(cur)) {
                      int node = next.node, cost = next.length;
                      if (dist[node] > length + cost) {
                          dist[node] = length + cost;
                          heap.add(new Node(node, dist[node]));
                      }
                  }
              }
              if (dist[n] == INF)
                  return -1;
              return dist[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
      public static int dijkstra() {
              for (int i = 1; i <= n; i++)
                  dist[i] = INF;
              dist[1] = 0;
              PriorityQueue<Node> heap = new PriorityQueue<>((node1, node2) -> node1.length - node2.length);
              heap.add(new Node(1, 0));
              while (!heap.isEmpty()) {
                  Node top = heap.poll();
                  int length = top.length, cur = top.node;
                  if (visit[cur])
                      continue;
                  visit[cur] = true;
                  for (Node next: map.get(cur)) {
                      int node = next.node, cost = next.length;
                      if (dist[node] > length + cost) {
                          dist[node] = length + cost;
                          heap.add(new Node(node, dist[node]));
                      }
                  }
              }
              if (dist[n] == INF)
                  return -1;
              return dist[n];
          }

      例题：AcWing 850

      Bellman-ford
      O(nm)

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      public static int bellman_ford() {
          for (int i = 1; i <= n; i++)
              dist[i] = INF;
          dist[1] = 0;
          for (int i = 0; i < k; i++) {
              for (int j = 1; j <= n; j++)
                  backup[j] = dist[j]; // deep copy
              for (int k = 0; k < m; k++) {
                  int x = edges[k].x;
                  int y = edges[k].y;
                  int z = edges[k].z;
                  dist[y] = Math.min(dist[y], backup[x] + z);
              }
          }
          if (dist[n] > INF / 2)
              return -1;
          else
              return dist[n];
      }
      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      public static int bellman_ford() {
          for (int i = 1; i <= n; i++)
              dist[i] = INF;
          dist[1] = 0;
          for (int i = 0; i < k; i++) {
              for (int j = 1; j <= n; j++)
                  backup[j] = dist[j]; // deep copy
              for (int k = 0; k < m; k++) {
                  int x = edges[k].x;
                  int y = edges[k].y;
                  int z = edges[k].z;
                  dist[y] = Math.min(dist[y], backup[x] + z);
              }
          }
          if (dist[n] > INF / 2)
              return -1;
          else
              return dist[n];
      }

      例题：AcWing 853

      SPFA (队列优化的Bellman-ford算法)
      一般O(m)，最坏O(nm)。n表示点数，m表示边数。

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      public static int spfa() {
          for (int i = 1; i <= n; i++)
              dist[i] = INF;
          dist[1] = 0;
          Queue<Integer> queue = new LinkedList<>();
          queue.add(1);
          visit[1] = true;
          while (!queue.isEmpty()) {
              int t = queue.poll();
              visit[t] = false;
              for (Node cur: map.get(t)) {
                  int node = cur.node, length = cur.length;
                  if (dist[node] > dist[t] + length) {
                      dist[node] = dist[t] + length;
                      if (!visit[node]) {
                          queue.add(node);
                          visit[node] = true;
                      }
                  }
              }
          }
          return dist[n];
      }
      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      public static int spfa() {
          for (int i = 1; i <= n; i++)
              dist[i] = INF;
          dist[1] = 0;
          Queue<Integer> queue = new LinkedList<>();
          queue.add(1);
          visit[1] = true;
          while (!queue.isEmpty()) {
              int t = queue.poll();
              visit[t] = false;
              for (Node cur: map.get(t)) {
                  int node = cur.node, length = cur.length;
                  if (dist[node] > dist[t] + length) {
                      dist[node] = dist[t] + length;
                      if (!visit[node]) {
                          queue.add(node);
                          visit[node] = true;
                      }
                  }
              }
          }
          return dist[n];
      }

      例题：AcWing 851

      SPFA 判断图中是否存在负环
      O(nm)，n表示点数，m表示边数。

      -
      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 boolean spfa() {
          Queue<Integer> queue = new LinkedList<>();
          for (int i = 1; i <= n; i++) {
              queue.add(i);
              visit[i] = true;
          }
          while (!queue.isEmpty()) {
              int t = queue.poll();
              visit[t] = false;
              for (Node cur: map.get(t)) {
                  int node = cur.node, length = cur.length;
                  if (dist[node] > dist[t] + length) {
                      dist[node] = dist[t] + length;
                      count[node] = count[t] + 1;
                      if (count[node] >= n)
                          return true;
                      if (!visit[node]) {
                          queue.add(node);
                          visit[node] = true;
                      }
                  }
              }
          }
          return false;
      }
      +
      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 boolean spfa() {
          Queue<Integer> queue = new LinkedList<>();
          for (int i = 1; i <= n; i++) {
              queue.add(i);
              visit[i] = true;
          }
          while (!queue.isEmpty()) {
              int t = queue.poll();
              visit[t] = false;
              for (Node cur: map.get(t)) {
                  int node = cur.node, length = cur.length;
                  if (dist[node] > dist[t] + length) {
                      dist[node] = dist[t] + length;
                      count[node] = count[t] + 1;
                      if (count[node] >= n)
                          return true;
                      if (!visit[node]) {
                          queue.add(node);
                          visit[node] = true;
                      }
                  }
              }
          }
          return false;
      }

      例题：AcWing 852

      Floyd
      O(n3)O(n3)

      -
      1
      2
      3
      4
      5
      6
      7
      public static void floyd() {
          for (int k = 1; k <= n; k++)
              for (int i = 1; i <= n; i++)
                  for (int j = 1; j <= n; j++)
                      d[i][j] = Math.min(d[i][j], d[i][k] + d[k][j]);
      }

      +
      1
      2
      3
      4
      5
      6
      7
      public static void floyd() {
          for (int k = 1; k <= n; k++)
              for (int i = 1; i <= n; i++)
                  for (int j = 1; j <= n; j++)
                      d[i][j] = Math.min(d[i][j], d[i][k] + d[k][j]);
      }

      例题：AcWing 854

      作者：Lic
      链接：https://www.acwing.com/file_system/file/content/whole/index/content/5873/
      来源：AcWing
      著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

      @@ -921,14 +921,14 @@

      新建一个包boot

      在boot包下创建一个类 MainApplication

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      package org.example.boot;

      import org.springframework.boot.SpringApplication;
      import org.springframework.boot.autoconfigure.SpringBootApplication;

      @SpringBootApplication
      public class MainApplication {
          public static void main(String[] args) {
              SpringApplication.run(MainApplication.class,args);
          }
      }

      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      package org.example.boot;

      import org.springframework.boot.SpringApplication;
      import org.springframework.boot.autoconfigure.SpringBootApplication;

      @SpringBootApplication
      public class MainApplication {
          public static void main(String[] args) {
              SpringApplication.run(MainApplication.class,args);
          }
      }

      点击pom.xml 进行导包

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      <parent>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter-parent</artifactId>
              <version>2.3.4.RELEASE</version>
          </parent>

          <dependencies>
              <dependency>
                  <groupId>org.springframework.boot</groupId>
                  <artifactId>spring-boot-starter-web</artifactId>
              </dependency>

          </dependencies>
      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      <parent>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter-parent</artifactId>
              <version>2.3.4.RELEASE</version>
          </parent>

          <dependencies>
              <dependency>
                  <groupId>org.springframework.boot</groupId>
                  <artifactId>spring-boot-starter-web</artifactId>
              </dependency>

          </dependencies>

      建立controller层

      创建了类HelloController

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      package org.example.boot.Controller;

      import org.springframework.stereotype.Controller;
      import org.springframework.web.bind.annotation.RequestMapping;
      import org.springframework.web.bind.annotation.RestController;
      @RestController
      public class HelloController {
          @RequestMapping("/hello")
          public String hello01(){
              return "第一个springboot hello   ";
              System.out.println("Springboot程序启动成功");
          }
      }

      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      package org.example.boot.Controller;

      import org.springframework.stereotype.Controller;
      import org.springframework.web.bind.annotation.RequestMapping;
      import org.springframework.web.bind.annotation.RestController;
      @RestController
      public class HelloController {
          @RequestMapping("/hello")
          public String hello01(){
              return "第一个springboot hello   ";
              System.out.println("Springboot程序启动成功");
          }
      }

      点击启动MainApplication

      @@ -1018,7 +1018,7 @@

      最近遇见了ip+端口转换为域名的问题

      本来我用境外服务器可以直接用80端口 用起来也很方便 不用备案啥的 但是就是太容易挂了

      所以下定决心撸了个腾讯云的服务器

      -
      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
      # For more information on configuration, see:
      #   * Official English Documentation: http://nginx.org/en/docs/
      #   * Official Russian Documentation: http://nginx.org/ru/docs/

      user root;
      worker_processes auto;
      error_log /var/log/nginx/error.log;
      pid /run/nginx.pid;

      # Load dynamic modules. See /usr/share/nginx/README.dynamic.
      include /usr/share/nginx/modules/*.conf;

      events {
          worker_connections 1024;
      }

      http {
          log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                            '$status $body_bytes_sent "$http_referer" '
                            '"$http_user_agent" "$http_x_forwarded_for"';

          access_log  /var/log/nginx/access.log  main;

          sendfile            on;
          tcp_nopush          on;
          tcp_nodelay         on;
          keepalive_timeout   65;
          types_hash_max_size 2048;

          include             /etc/nginx/mime.types;
          default_type        application/octet-stream;

          # Load modular configuration files from the /etc/nginx/conf.d directory.
          # See http://nginx.org/en/docs/ngx_core_module.html#include
          # for more information.
          include /etc/nginx/conf.d/*.conf;
        
          server {
              listen       8080 default_server;
              listen       [::]:8080 default_server;
              server_name  www.sy.huttop.top;
              
              root         /root/java/;        #修改为root         /data/www;
              
              include /etc/nginx/default.d/*.conf;

               location / {
              }

              error_page 404 /404.html;
                  location = /40x.html {
              }
              
              error_page 500 502 503 504 /50x.html;
                  location = /50x.html {
              }
          }
        server {
              listen       8888 default_server;
              listen       [::]:8888 default_server;
              server_name www.huttop.top;
              
              root         /root/zhuye/;        #修改为root         /data/www;
              
              include /etc/nginx/default.d/*.conf;

              location / {
              }

              error_page 404 /404.html;
                  location = /40x.html {
              }
              
              error_page 500 502 503 504 /50x.html;
                  location = /50x.html {
              }
          }
      }
      +
      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
      # For more information on configuration, see:
      #   * Official English Documentation: http://nginx.org/en/docs/
      #   * Official Russian Documentation: http://nginx.org/ru/docs/

      user root;
      worker_processes auto;
      error_log /var/log/nginx/error.log;
      pid /run/nginx.pid;

      # Load dynamic modules. See /usr/share/nginx/README.dynamic.
      include /usr/share/nginx/modules/*.conf;

      events {
          worker_connections 1024;
      }

      http {
          log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                            '$status $body_bytes_sent "$http_referer" '
                            '"$http_user_agent" "$http_x_forwarded_for"';

          access_log  /var/log/nginx/access.log  main;

          sendfile            on;
          tcp_nopush          on;
          tcp_nodelay         on;
          keepalive_timeout   65;
          types_hash_max_size 2048;

          include             /etc/nginx/mime.types;
          default_type        application/octet-stream;

          # Load modular configuration files from the /etc/nginx/conf.d directory.
          # See http://nginx.org/en/docs/ngx_core_module.html#include
          # for more information.
          include /etc/nginx/conf.d/*.conf;
        
          server {
              listen       8080 default_server;
              listen       [::]:8080 default_server;
              server_name  www.sy.huttop.top;
              
              root         /root/java/;        #修改为root         /data/www;
              
              include /etc/nginx/default.d/*.conf;

               location / {
              }

              error_page 404 /404.html;
                  location = /40x.html {
              }
              
              error_page 500 502 503 504 /50x.html;
                  location = /50x.html {
              }
          }
        server {
              listen       8888 default_server;
              listen       [::]:8888 default_server;
              server_name www.huttop.top;
              
              root         /root/zhuye/;        #修改为root         /data/www;
              
              include /etc/nginx/default.d/*.conf;

              location / {
              }

              error_page 404 /404.html;
                  location = /40x.html {
              }
              
              error_page 500 502 503 504 /50x.html;
                  location = /50x.html {
              }
          }
      }

      这是配置文件

      @@ -1102,17 +1102,17 @@

      所需要的工具 一台服务器 一个可以编译jar的java环境 nginx用来正向代理

      xshell连接服务器

      安装java环境

      -
      1
      yum install java-1.8.0-openjdk
      +
      1
      yum install java-1.8.0-openjdk

      查看java是否安装好

      -
      1
      java -version
      +
      1
      java -version

      创建自己项目的路径并且cd到该路径

      -
      1
      2
      mkdir java
      cd java
      +
      1
      2
      mkdir java
      cd java

      用命令让他跑起来

      Linux启动

      -
      1
      2
      3
      4
      5
      6
      nohup java -jar pdf-service-0.0.1-SNAPSHOT.jar  
      --host=http://161.117.229.248/
      --pdfPassword=2021 --footerDesc=\u9875\u811a\u6587\u5b57  
      --watermarkPic=https://www.wwei.cn/yasuotu/images/logo.png  
      --basicUrl=tmp/resources/static/pdf/    
      --location=10,10,30,30 > nohup.out 2>&1 &
      +
      1
      2
      3
      4
      5
      6
      nohup java -jar pdf-service-0.0.1-SNAPSHOT.jar  
      --host=http://161.117.229.248/
      --pdfPassword=2021 --footerDesc=\u9875\u811a\u6587\u5b57  
      --watermarkPic=https://www.wwei.cn/yasuotu/images/logo.png  
      --basicUrl=tmp/resources/static/pdf/    
      --location=10,10,30,30 > nohup.out 2>&1 &

      这里注意把它copy去浏览器 变成一行去粘贴 这里只是方便看的参数的意义

      Linux查看日志
      tail -f nohup.out

      @@ -1195,10 +1195,10 @@

      首先导入依赖

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      <!-- https://mvnrepository.com/artifact/com.itextpdf/itextpdf -->
           <dependency>
               <groupId>com.itextpdf</groupId>
               <artifactId>itextpdf</artifactId>
               <version>5.5.13</version>
           </dependency>
           <!-- https://mvnrepository.com/artifact/com.lowagie/itext -->
           <dependency>
               <groupId>com.lowagie</groupId>
               <artifactId>itext</artifactId>
               <version>2.1.7</version>
           </dependency>
      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      <!-- https://mvnrepository.com/artifact/com.itextpdf/itextpdf -->
           <dependency>
               <groupId>com.itextpdf</groupId>
               <artifactId>itextpdf</artifactId>
               <version>5.5.13</version>
           </dependency>
           <!-- https://mvnrepository.com/artifact/com.lowagie/itext -->
           <dependency>
               <groupId>com.lowagie</groupId>
               <artifactId>itext</artifactId>
               <version>2.1.7</version>
           </dependency>

      代码如下

      -
      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
      147
      148
      149
      150
      151
      152
      153
      154
      155
      156
      157
      158
      159
      160
      161
      162
      163
      164
      165
      166
      167
      168
      169
      170
      171
      172
      173
      174
      175
      176
      177
      178
      179
      180
      181
      182
      183
      184
      185
      186
      187
      188
      189
      190
      191
      192
      193
      194
      195
      196
      197
      198
      199
      200
      201
      202
      203
      204
      205
      206
      207
      208
      209
      210
      211
      212
      213
      214
      215
      216
      217
      218
      219
      220
      221
      222
      223
      224
      225
      226
      227
      228
      229
      230
      231
      232
      233
      234
      235
      236
      237
      238
      239
      240
      241
      242
      243
      244
      245
      246
      247
      248
      249
      250
      251
      252
      253
      254
      255
      256
      257
      258
      259
      260
      261
      262
      263
      264
      265
      266
      267
      import java.awt.AlphaComposite;
      import java.awt.Color;
      import java.awt.Font;
      import java.awt.Graphics2D;
      import java.awt.Image;
      import java.awt.RenderingHints;
      import java.awt.image.BufferedImage;
      import java.io.File;
      import java.io.FileOutputStream;
      import java.io.InputStream;
      import java.io.OutputStream;

      import javax.imageio.ImageIO;
      import javax.swing.ImageIcon;

      /*******************************************************************************
       * Description: 图片水印工具类
       * @author zengshunyao
       * @version 1.0
       */
      public class ImageRemarkUtil {

          // 水印透明度
          private static float alpha = 0.5f;
          // 水印横向位置
          private static int positionWidth = 150;
          // 水印纵向位置
          private static int positionHeight = 300;
          // 水印文字字体
          private static Font font = new Font("宋体", Font.BOLD, 100);
          // 水印文字颜色
          private static Color color = Color.red;

          /**
           *
           * @param alpha
           *            水印透明度
           * @param positionWidth
           *            水印横向位置
           * @param positionHeight
           *            水印纵向位置
           * @param font
           *            水印文字字体
           * @param color
           *            水印文字颜色
           */
          public static void setImageMarkOptions(float alpha, int positionWidth,
                                                 int positionHeight, Font font, Color color) {
              if (alpha != 0.0f)
                  ImageRemarkUtil.alpha = alpha;
              if (positionWidth != 0)
                  ImageRemarkUtil.positionWidth = positionWidth;
              if (positionHeight != 0)
                  ImageRemarkUtil.positionHeight = positionHeight;
              if (font != null)
                  ImageRemarkUtil.font = font;
              if (color != null)
                  ImageRemarkUtil.color = color;
          }

          /**
           * 给图片添加水印图片
           *
           * @param iconPath
           *            水印图片路径
           * @param srcImgPath
           *            源图片路径
           * @param targerPath
           *            目标图片路径
           */
          public static void markImageByIcon(String iconPath, String srcImgPath,
                                             String targerPath) {
              markImageByIcon(iconPath, srcImgPath, targerPath, null);
          }

          /**
           * 给图片添加水印图片、可设置水印图片旋转角度
           *
           * @param iconPath
           *            水印图片路径
           * @param srcImgPath
           *            源图片路径
           * @param targerPath
           *            目标图片路径
           * @param degree
           *            水印图片旋转角度
           */
          public static void markImageByIcon(String iconPath, String srcImgPath,
                                             String targerPath, Integer degree) {
              OutputStream os = null;
              try {

                  Image srcImg = ImageIO.read(new File(srcImgPath));

                  BufferedImage buffImg = new BufferedImage(srcImg.getWidth(null),
                          srcImg.getHeight(null), BufferedImage.TYPE_INT_RGB);

                  // 1、得到画笔对象
                  Graphics2D g = buffImg.createGraphics();

                  // 2、设置对线段的锯齿状边缘处理
                  g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
                          RenderingHints.VALUE_INTERPOLATION_BILINEAR);

                  g.drawImage(
                          srcImg.getScaledInstance(srcImg.getWidth(null),
                                  srcImg.getHeight(null), Image.SCALE_SMOOTH), 0, 0,
                          null);
                  // 3、设置水印旋转
                  if (null != degree) {
                      g.rotate(Math.toRadians(degree),
                              (double) buffImg.getWidth() / 2,
                              (double) buffImg.getHeight() / 2);
                  }

                  // 4、水印图片的路径 水印图片一般为gif或者png的，这样可设置透明度
                  ImageIcon imgIcon = new ImageIcon(iconPath);

                  // 5、得到Image对象。
                  Image img = imgIcon.getImage();

                  g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP,
                          alpha));

                  // 6、水印图片的位置
                  g.drawImage(img, positionWidth, positionHeight, null);
                  g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER));
                  // 7、释放资源
                  g.dispose();

                  // 8、生成图片
                  os = new FileOutputStream(targerPath);
                  ImageIO.write(buffImg, "JPG", os);

                  System.out.println("图片完成添加水印图片");

              } catch (Exception e) {
                  e.printStackTrace();
              } finally {
                  try {
                      if (null != os)
                          os.close();
                  } catch (Exception e) {
                      e.printStackTrace();
                  }
              }
          }

          /**
           * 给图片添加水印文字
           *
           * @param logoText
           *            水印文字
           * @param srcImgPath
           *            源图片路径
           * @param targerPath
           *            目标图片路径
           */
          public static void markImageByText(String logoText, String srcImgPath,
                                             String targerPath) {
              markImageByText(logoText, srcImgPath, targerPath, null);
          }

          /**
           * 给图片添加水印文字、可设置水印文字的旋转角度
           *
           * @param logoText
           * @param srcImgPath
           * @param targerPath
           * @param degree
           */
          public static void markImageByText(String logoText, String srcImgPath,
                                             String targerPath, Integer degree) {

              InputStream is = null;
              OutputStream os = null;
              try {
                  // 1、源图片
                  Image srcImg = ImageIO.read(new File(srcImgPath));
                  BufferedImage buffImg = new BufferedImage(srcImg.getWidth(null),
                          srcImg.getHeight(null), BufferedImage.TYPE_INT_RGB);

                  // 2、得到画笔对象
                  Graphics2D g = buffImg.createGraphics();
                  // 3、设置对线段的锯齿状边缘处理
                  g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
                          RenderingHints.VALUE_INTERPOLATION_BILINEAR);
                  g.drawImage(
                          srcImg.getScaledInstance(srcImg.getWidth(null),
                                  srcImg.getHeight(null), Image.SCALE_SMOOTH), 0, 0,
                          null);
                  // 4、设置水印旋转
                  if (null != degree) {
                      g.rotate(Math.toRadians(degree),
                              (double) buffImg.getWidth() / 2,
                              (double) buffImg.getHeight() / 2);
                  }
                  // 5、设置水印文字颜色
                  g.setColor(color);
                  // 6、设置水印文字Font
                  g.setFont(font);
                  // 7、设置水印文字透明度
                  g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP,
                          alpha));
                  // 8、第一参数->设置的内容，后面两个参数->文字在图片上的坐标位置(x,y)
                  g.drawString(logoText, positionWidth, positionHeight);
                  // 9、释放资源
                  g.dispose();
                  // 10、生成图片
                  os = new FileOutputStream(targerPath);
                  ImageIO.write(buffImg, "JPG", os);

                  System.out.println("图片完成添加水印文字");

              } catch (Exception e) {
                  e.printStackTrace();
              } finally {
                  try {
                      if (null != is)
                          is.close();
                  } catch (Exception e) {
                      e.printStackTrace();
                  }
                  try {
                      if (null != os)
                          os.close();
                  } catch (Exception e) {
                      e.printStackTrace();
                  }
              }
          }

          public static void main(String[] args) {

              String logoText = "三 年 一 梦";
              String iconPath = "D:/pdf/dp/dp_1.png";

              String targerTextPath2 = "d:/qie_text_rotate.jpg";

              String targerIconPath = "d:/qie_icon.jpg";
              String targerIconPath2 = "d:/qie_icon_rotate.jpg";
              System.out.println("给图片添加水印文字开始...");

              for (int i = 1; i < 10; i++) {
                  String srcImgPath = "D:/pdf/1/1_"+i+".png";
                  String targerTextPath = "d:/水印/qie_text"+i+".jpg";
                  // 给图片添加水印文字
                  markImageByText(logoText, srcImgPath, targerTextPath);
                  // 给图片添加水印文字,水印文字旋转-45
                  //markImageByText(logoText, srcImgPath, targerTextPath2, -45);
              }
              System.out.println("给图片添加水印文字结束...");



              //System.out.println("给图片添加水印图片开始...");
              //setImageMarkOptions(0.3f, 1, 1, null, null);
              // 给图片添加水印图片
              //markImageByIcon(iconPath, srcImgPath, targerIconPath);
              // 给图片添加水印图片,水印图片旋转-45
              //markImageByIcon(iconPath, srcImgPath, targerIconPath2, -45);
              //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
      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
      147
      148
      149
      150
      151
      152
      153
      154
      155
      156
      157
      158
      159
      160
      161
      162
      163
      164
      165
      166
      167
      168
      169
      170
      171
      172
      173
      174
      175
      176
      177
      178
      179
      180
      181
      182
      183
      184
      185
      186
      187
      188
      189
      190
      191
      192
      193
      194
      195
      196
      197
      198
      199
      200
      201
      202
      203
      204
      205
      206
      207
      208
      209
      210
      211
      212
      213
      214
      215
      216
      217
      218
      219
      220
      221
      222
      223
      224
      225
      226
      227
      228
      229
      230
      231
      232
      233
      234
      235
      236
      237
      238
      239
      240
      241
      242
      243
      244
      245
      246
      247
      248
      249
      250
      251
      252
      253
      254
      255
      256
      257
      258
      259
      260
      261
      262
      263
      264
      265
      266
      267
      import java.awt.AlphaComposite;
      import java.awt.Color;
      import java.awt.Font;
      import java.awt.Graphics2D;
      import java.awt.Image;
      import java.awt.RenderingHints;
      import java.awt.image.BufferedImage;
      import java.io.File;
      import java.io.FileOutputStream;
      import java.io.InputStream;
      import java.io.OutputStream;

      import javax.imageio.ImageIO;
      import javax.swing.ImageIcon;

      /*******************************************************************************
       * Description: 图片水印工具类
       * @author zengshunyao
       * @version 1.0
       */
      public class ImageRemarkUtil {

          // 水印透明度
          private static float alpha = 0.5f;
          // 水印横向位置
          private static int positionWidth = 150;
          // 水印纵向位置
          private static int positionHeight = 300;
          // 水印文字字体
          private static Font font = new Font("宋体", Font.BOLD, 100);
          // 水印文字颜色
          private static Color color = Color.red;

          /**
           *
           * @param alpha
           *            水印透明度
           * @param positionWidth
           *            水印横向位置
           * @param positionHeight
           *            水印纵向位置
           * @param font
           *            水印文字字体
           * @param color
           *            水印文字颜色
           */
          public static void setImageMarkOptions(float alpha, int positionWidth,
                                                 int positionHeight, Font font, Color color) {
              if (alpha != 0.0f)
                  ImageRemarkUtil.alpha = alpha;
              if (positionWidth != 0)
                  ImageRemarkUtil.positionWidth = positionWidth;
              if (positionHeight != 0)
                  ImageRemarkUtil.positionHeight = positionHeight;
              if (font != null)
                  ImageRemarkUtil.font = font;
              if (color != null)
                  ImageRemarkUtil.color = color;
          }

          /**
           * 给图片添加水印图片
           *
           * @param iconPath
           *            水印图片路径
           * @param srcImgPath
           *            源图片路径
           * @param targerPath
           *            目标图片路径
           */
          public static void markImageByIcon(String iconPath, String srcImgPath,
                                             String targerPath) {
              markImageByIcon(iconPath, srcImgPath, targerPath, null);
          }

          /**
           * 给图片添加水印图片、可设置水印图片旋转角度
           *
           * @param iconPath
           *            水印图片路径
           * @param srcImgPath
           *            源图片路径
           * @param targerPath
           *            目标图片路径
           * @param degree
           *            水印图片旋转角度
           */
          public static void markImageByIcon(String iconPath, String srcImgPath,
                                             String targerPath, Integer degree) {
              OutputStream os = null;
              try {

                  Image srcImg = ImageIO.read(new File(srcImgPath));

                  BufferedImage buffImg = new BufferedImage(srcImg.getWidth(null),
                          srcImg.getHeight(null), BufferedImage.TYPE_INT_RGB);

                  // 1、得到画笔对象
                  Graphics2D g = buffImg.createGraphics();

                  // 2、设置对线段的锯齿状边缘处理
                  g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
                          RenderingHints.VALUE_INTERPOLATION_BILINEAR);

                  g.drawImage(
                          srcImg.getScaledInstance(srcImg.getWidth(null),
                                  srcImg.getHeight(null), Image.SCALE_SMOOTH), 0, 0,
                          null);
                  // 3、设置水印旋转
                  if (null != degree) {
                      g.rotate(Math.toRadians(degree),
                              (double) buffImg.getWidth() / 2,
                              (double) buffImg.getHeight() / 2);
                  }

                  // 4、水印图片的路径 水印图片一般为gif或者png的，这样可设置透明度
                  ImageIcon imgIcon = new ImageIcon(iconPath);

                  // 5、得到Image对象。
                  Image img = imgIcon.getImage();

                  g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP,
                          alpha));

                  // 6、水印图片的位置
                  g.drawImage(img, positionWidth, positionHeight, null);
                  g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER));
                  // 7、释放资源
                  g.dispose();

                  // 8、生成图片
                  os = new FileOutputStream(targerPath);
                  ImageIO.write(buffImg, "JPG", os);

                  System.out.println("图片完成添加水印图片");

              } catch (Exception e) {
                  e.printStackTrace();
              } finally {
                  try {
                      if (null != os)
                          os.close();
                  } catch (Exception e) {
                      e.printStackTrace();
                  }
              }
          }

          /**
           * 给图片添加水印文字
           *
           * @param logoText
           *            水印文字
           * @param srcImgPath
           *            源图片路径
           * @param targerPath
           *            目标图片路径
           */
          public static void markImageByText(String logoText, String srcImgPath,
                                             String targerPath) {
              markImageByText(logoText, srcImgPath, targerPath, null);
          }

          /**
           * 给图片添加水印文字、可设置水印文字的旋转角度
           *
           * @param logoText
           * @param srcImgPath
           * @param targerPath
           * @param degree
           */
          public static void markImageByText(String logoText, String srcImgPath,
                                             String targerPath, Integer degree) {

              InputStream is = null;
              OutputStream os = null;
              try {
                  // 1、源图片
                  Image srcImg = ImageIO.read(new File(srcImgPath));
                  BufferedImage buffImg = new BufferedImage(srcImg.getWidth(null),
                          srcImg.getHeight(null), BufferedImage.TYPE_INT_RGB);

                  // 2、得到画笔对象
                  Graphics2D g = buffImg.createGraphics();
                  // 3、设置对线段的锯齿状边缘处理
                  g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
                          RenderingHints.VALUE_INTERPOLATION_BILINEAR);
                  g.drawImage(
                          srcImg.getScaledInstance(srcImg.getWidth(null),
                                  srcImg.getHeight(null), Image.SCALE_SMOOTH), 0, 0,
                          null);
                  // 4、设置水印旋转
                  if (null != degree) {
                      g.rotate(Math.toRadians(degree),
                              (double) buffImg.getWidth() / 2,
                              (double) buffImg.getHeight() / 2);
                  }
                  // 5、设置水印文字颜色
                  g.setColor(color);
                  // 6、设置水印文字Font
                  g.setFont(font);
                  // 7、设置水印文字透明度
                  g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP,
                          alpha));
                  // 8、第一参数->设置的内容，后面两个参数->文字在图片上的坐标位置(x,y)
                  g.drawString(logoText, positionWidth, positionHeight);
                  // 9、释放资源
                  g.dispose();
                  // 10、生成图片
                  os = new FileOutputStream(targerPath);
                  ImageIO.write(buffImg, "JPG", os);

                  System.out.println("图片完成添加水印文字");

              } catch (Exception e) {
                  e.printStackTrace();
              } finally {
                  try {
                      if (null != is)
                          is.close();
                  } catch (Exception e) {
                      e.printStackTrace();
                  }
                  try {
                      if (null != os)
                          os.close();
                  } catch (Exception e) {
                      e.printStackTrace();
                  }
              }
          }

          public static void main(String[] args) {

              String logoText = "三 年 一 梦";
              String iconPath = "D:/pdf/dp/dp_1.png";

              String targerTextPath2 = "d:/qie_text_rotate.jpg";

              String targerIconPath = "d:/qie_icon.jpg";
              String targerIconPath2 = "d:/qie_icon_rotate.jpg";
              System.out.println("给图片添加水印文字开始...");

              for (int i = 1; i < 10; i++) {
                  String srcImgPath = "D:/pdf/1/1_"+i+".png";
                  String targerTextPath = "d:/水印/qie_text"+i+".jpg";
                  // 给图片添加水印文字
                  markImageByText(logoText, srcImgPath, targerTextPath);
                  // 给图片添加水印文字,水印文字旋转-45
                  //markImageByText(logoText, srcImgPath, targerTextPath2, -45);
              }
              System.out.println("给图片添加水印文字结束...");



              //System.out.println("给图片添加水印图片开始...");
              //setImageMarkOptions(0.3f, 1, 1, null, null);
              // 给图片添加水印图片
              //markImageByIcon(iconPath, srcImgPath, targerIconPath);
              // 给图片添加水印图片,水印图片旋转-45
              //markImageByIcon(iconPath, srcImgPath, targerIconPath2, -45);
              //System.out.println("给图片添加水印图片结束...");

          }

      }

      diff --git a/page/6/index.html b/page/6/index.html index 70e2b8d91..59f34e2d7 100644 --- a/page/6/index.html +++ b/page/6/index.html @@ -205,11 +205,11 @@

      双指针

      26. 删除有序数组中的重复项

      这题典型的双指针 一个指针是用来遍历 另外一个用来存储

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      class Solution {
          public int removeDuplicates(int[] nums) {
              int t = 0;
              for (int i = 0; i < nums.length; i ++ ) {
                  if (i == 0 || nums[i] != nums[i - 1]) 
                  {
                      nums[t] = nums[i];
                      t++;
                  }
              }
              return t;
          }
      }
      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      class Solution {
          public int removeDuplicates(int[] nums) {
              int t = 0;
              for (int i = 0; i < nums.length; i ++ ) {
                  if (i == 0 || nums[i] != nums[i - 1]) 
                  {
                      nums[t] = nums[i];
                      t++;
                  }
              }
              return t;
          }
      }

      ​ i用来遍历数组 而t用来存储新的数组

      通用解法拓展

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      class Solution {
          public int removeDuplicates(int[] nums) {
              int n = nums.length;
              if (n <= 1) return n;   
              return process(nums, 1, nums[n - 1]);
          }
          int process(int[] nums, int k, int max) {
              int idx = 0; 
              for (int x : nums) {
                  if (idx < k || nums[idx - k] != x) nums[idx++] = x;
                  if (idx - k >= 0 && nums[idx - k] == max) break;
              }
              return idx;
          }
      }

      作者：AC_OIer
      链接：https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/solution/shua-chuan-lc-jian-ji-shuang-zhi-zhen-ji-2eg8/
      来源：力扣（LeetCode）
      著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      class Solution {
          public int removeDuplicates(int[] nums) {
              int n = nums.length;
              if (n <= 1) return n;   
              return process(nums, 1, nums[n - 1]);
          }
          int process(int[] nums, int k, int max) {
              int idx = 0; 
              for (int x : nums) {
                  if (idx < k || nums[idx - k] != x) nums[idx++] = x;
                  if (idx - k >= 0 && nums[idx - k] == max) break;
              }
              return idx;
          }
      }

      作者：AC_OIer
      链接：https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/solution/shua-chuan-lc-jian-ji-shuang-zhi-zhen-ji-2eg8/
      来源：力扣（LeetCode）
      著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
      @@ -382,7 +382,7 @@ 

      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
      // 1. 创建一个继承于Thread类的子类
      class MyThread1 extends Thread {
          // 2. 重写Thread类的run()
          @Override
          public void run() {
              for (int i = 0; i <= 100; i++) {
                  if (i % 2 == 0) {
                      System.out.println(Thread.currentThread().getName() + ": " + i);
                  }
              }
          }
      }

      public class ThreadTest1 {
          public static void main(String[] args) {
              // 3. 创建Thread类的子类的对象
              MyThread1 t1 = new MyThread1();
              t1.setName("线程1");
              // 4.通过此对象调用start():
              // ①启动当前线程 ② 调用当前线程的run()
              t1.start();

              // 再启动一个线程
              MyThread1 t2 = new MyThread1();
              t2.setName("线程2");
              t2.start();
          }
      }
      +
      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
      // 1. 创建一个继承于Thread类的子类
      class MyThread1 extends Thread {
          // 2. 重写Thread类的run()
          @Override
          public void run() {
              for (int i = 0; i <= 100; i++) {
                  if (i % 2 == 0) {
                      System.out.println(Thread.currentThread().getName() + ": " + i);
                  }
              }
          }
      }

      public class ThreadTest1 {
          public static void main(String[] args) {
              // 3. 创建Thread类的子类的对象
              MyThread1 t1 = new MyThread1();
              t1.setName("线程1");
              // 4.通过此对象调用start():
              // ①启动当前线程 ② 调用当前线程的run()
              t1.start();

              // 再启动一个线程
              MyThread1 t2 = new MyThread1();
              t2.setName("线程2");
              t2.start();
          }
      }

      方式2：实现 Runnable 接口

      创建步骤

      1、创建一个实现了 Runnable 接口的类；

      @@ -390,7 +390,7 @@ 

      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
      // 1. 创建一个实现了Runnable接口的类
      class MyThread implements Runnable {
          // 2. 实现类去实现Runnable中的抽象方法：run()
          @Override
          public void run() {
              for (int i = 0; i < 100; i++) {
                  if (i % 2 == 0) {
                      System.out.println(Thread.currentThread().getName() + ": " +i);
                  }
              }
          }
      }

      public class ThreadTest {
          public static void main(String[] args) {
              // 3. 创建实现类的对象
              MyThread myThread = new MyThread();
              // 4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
              Thread t1 = new Thread(myThread);
              t1.setName("线程1");
              // 5. 通过Thread类的对象调用start():
              // ① 启动线程 ②调用当前线程的run()-->调用了Runnable类型的target的run()
              t1.start();

              // 再启动一个线程：
              Thread t2 = new Thread(myThread);
              t2.setName("线程2");
              t2.start();
          }
      }
      +
      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
      // 1. 创建一个实现了Runnable接口的类
      class MyThread implements Runnable {
          // 2. 实现类去实现Runnable中的抽象方法：run()
          @Override
          public void run() {
              for (int i = 0; i < 100; i++) {
                  if (i % 2 == 0) {
                      System.out.println(Thread.currentThread().getName() + ": " +i);
                  }
              }
          }
      }

      public class ThreadTest {
          public static void main(String[] args) {
              // 3. 创建实现类的对象
              MyThread myThread = new MyThread();
              // 4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
              Thread t1 = new Thread(myThread);
              t1.setName("线程1");
              // 5. 通过Thread类的对象调用start():
              // ① 启动线程 ②调用当前线程的run()-->调用了Runnable类型的target的run()
              t1.start();

              // 再启动一个线程：
              Thread t2 = new Thread(myThread);
              t2.setName("线程2");
              t2.start();
          }
      }

      方式3：实现 Callable 接口

      创建步骤

      1、创建一个实现Callable接口的实现类；

      @@ -398,14 +398,14 @@ 

      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
      // 1.创建一个实现Callable的实现类
      class NumThread implements Callable<Integer> {
          // 2.实现call方法，将此线程需要执行的操作声明在call()中
          @Override
          public Integer call() throws Exception {
              int sum = 0;
              for (int i = 0; i <=100; i++) {
                  if (i % 2 == 0) {
                      System.out.println(i);
                      sum += i;
                  }
              }
              return sum;
          }
      }

      public class ThreadNew {
          public static void main(String[] args) {
              // 3.创建Callable接口实现类的对象
              NumThread numThread = new NumThread();

              // 4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
              FutureTask<Integer> futureTask = new FutureTask<Integer>(numThread);

              // 5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
              new Thread(futureTask).start();

              try {
                  // 6.获取Callable中call方法的返回值
                  // get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
                  Integer sum = futureTask.get();
                  System.out.println("总和为：" + sum);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              } catch (ExecutionException e) {
                  e.printStackTrace();
              }
          }
      }
      +
      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
      // 1.创建一个实现Callable的实现类
      class NumThread implements Callable<Integer> {
          // 2.实现call方法，将此线程需要执行的操作声明在call()中
          @Override
          public Integer call() throws Exception {
              int sum = 0;
              for (int i = 0; i <=100; i++) {
                  if (i % 2 == 0) {
                      System.out.println(i);
                      sum += i;
                  }
              }
              return sum;
          }
      }

      public class ThreadNew {
          public static void main(String[] args) {
              // 3.创建Callable接口实现类的对象
              NumThread numThread = new NumThread();

              // 4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
              FutureTask<Integer> futureTask = new FutureTask<Integer>(numThread);

              // 5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
              new Thread(futureTask).start();

              try {
                  // 6.获取Callable中call方法的返回值
                  // get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
                  Integer sum = futureTask.get();
                  System.out.println("总和为：" + sum);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              } catch (ExecutionException e) {
                  e.printStackTrace();
              }
          }
      }

      方式4：使用线程池

      创建步骤

      1、提供指定线程数量的线程池；

      2、设置线程池的属性；

      3、执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象；

      4、关闭连接池。

      -
      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
      class NumberThread1 implements Runnable {
          @Override
          public void run() {
              for (int i = 0; i <= 100; i++) {
                  if (i % 2 == 0) {
                      System.out.println(Thread.currentThread().getName() + ": " + i);
                  }
              }
          }
      }
      class NumberThread2 implements Runnable {
          @Override
          public void run() {
              for (int i = 0; i <= 100; i++) {
                  if (i % 2 != 0) {
                      System.out.println(Thread.currentThread().getName() + ": " + i);
                  }
              }
          }
      }
      public class ThreadPoolTest {
          public static void main(String[] args) {
              //1.提供指定线程数量的线程池
              ExecutorService service = Executors.newFixedThreadPool(10);
              ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
              //设置线程池的属性
      //        System.out.println(service.getClass());
      //        service1.setCorePoolSize(15);
      //        service1.setKeepAliveTime();
              //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
              service.execute(new NumberThread1());
              service.execute(new NumberThread2());
              //3.关闭连接池
              service.shutdown();
      +
      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
      class NumberThread1 implements Runnable {
          @Override
          public void run() {
              for (int i = 0; i <= 100; i++) {
                  if (i % 2 == 0) {
                      System.out.println(Thread.currentThread().getName() + ": " + i);
                  }
              }
          }
      }
      class NumberThread2 implements Runnable {
          @Override
          public void run() {
              for (int i = 0; i <= 100; i++) {
                  if (i % 2 != 0) {
                      System.out.println(Thread.currentThread().getName() + ": " + i);
                  }
              }
          }
      }
      public class ThreadPoolTest {
          public static void main(String[] args) {
              //1.提供指定线程数量的线程池
              ExecutorService service = Executors.newFixedThreadPool(10);
              ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
              //设置线程池的属性
      //        System.out.println(service.getClass());
      //        service1.setCorePoolSize(15);
      //        service1.setKeepAliveTime();
              //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
              service.execute(new NumberThread1());
              service.execute(new NumberThread2());
              //3.关闭连接池
              service.shutdown();
      @@ -481,13 +481,13 @@

      String类中equals和==的区别

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      package com.leetcode;

      public class StringTest {
          public static void main(String[] args) {
              String abc = "abc";
              String cde = "abc";
              String cda = new String("abc");
              System.out.println(abc.equals(cde));
              System.out.println(abc.equals(cda));
              System.out.println(abc == cda);
              System.out.println(abc==cde);

          }
      }
      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      package com.leetcode;

      public class StringTest {
          public static void main(String[] args) {
              String abc = "abc";
              String cde = "abc";
              String cda = new String("abc");
              System.out.println(abc.equals(cde));
              System.out.println(abc.equals(cda));
              System.out.println(abc == cda);
              System.out.println(abc==cde);

          }
      }

      想一下答案

      为什么呢

      使用new对象的一定会在堆内存中开辟空间

      -
      1
      String abc = "abc";
      +
      1
      String abc = "abc";

      使用这种方法会放入字符串池中

      当已经存在时,不在开辟空间

      @@ -570,7 +570,7 @@

      Arrays.sort(arr)

      给数组arr排序

      二分法查找的使用

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      package com.leetcode;

      import java.util.Arrays;

      public class ArraysTest {
          public static void main(String[] args) {
              int [] arr = {1,11,22,33,45,35};
              Arrays.sort(arr);
              for (int i = 0; i < arr.length; i++) {
                  System.out.println(arr[i]);
              }
              int index = Arrays.binarySearch(arr,333);
              System.out.println(index);
          }
      }

      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      package com.leetcode;

      import java.util.Arrays;

      public class ArraysTest {
          public static void main(String[] args) {
              int [] arr = {1,11,22,33,45,35};
              Arrays.sort(arr);
              for (int i = 0; i < arr.length; i++) {
                  System.out.println(arr[i]);
              }
              int index = Arrays.binarySearch(arr,333);
              System.out.println(index);
          }
      }

      @@ -731,24 +731,24 @@

      367. 有效的完全平方数

      第一次直接想的就是暴力遍历

      ​

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      class Solution {
          public boolean isPerfectSquare(int num) {
              for(int i = 1 ;i <= num/2 ; i++)
              {
                  if(i*i == num)
                  return true;
              } 
              if(num == 1)
              return true;
              else
              return false;
          }
      }
      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      class Solution {
          public boolean isPerfectSquare(int num) {
              for(int i = 1 ;i <= num/2 ; i++)
              {
                  if(i*i == num)
                  return true;
              } 
              if(num == 1)
              return true;
              else
              return false;
          }
      }

      样例是全过了 但是超时了

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      class Solution {
          public boolean isPerfectSquare(int num) {
              for(int i = 1 ;i <= num/2 ; i++)
              {
                  if(num / i == i && num % i == 0) 
                  return true;
                   if (num / i < i) return false;
              } 
              if(num == 1 ||num==4)
              return true;
              else
              return false;
          }
      }
      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      class Solution {
          public boolean isPerfectSquare(int num) {
              for(int i = 1 ;i <= num/2 ; i++)
              {
                  if(num / i == i && num % i == 0) 
                  return true;
                   if (num / i < i) return false;
              } 
              if(num == 1 ||num==4)
              return true;
              else
              return false;
          }
      }

      后面参考评论区

      速度是以除代乘 速度大大提升。

      -
      1
      2
      3
      4
      5
      6
      7
      8
      class Solution {
          public boolean isPerfectSquare(int num) {
              for(int i = num / 2 + 1;i >= 1; i--){
                  if(num == i * i) return  true;
              }
              return false;
          }
      }
      +
      1
      2
      3
      4
      5
      6
      7
      8
      class Solution {
          public boolean isPerfectSquare(int num) {
              for(int i = num / 2 + 1;i >= 1; i--){
                  if(num == i * i) return  true;
              }
              return false;
          }
      }

      这是第一版的改进 从后面开始遍历 提升下速率 数越大越明显

      二分法

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      class Solution {
          public boolean isPerfectSquare(int num) {
            int low = 1;
            int high = num;
            while(low <= high){
                int mid = low + (high - low) / 2;
                int t = num / mid;
                if(t == mid){
                    if(num % mid==0) return true;
                    low = mid+1;}
                else if(t<mid)
                {
                    high = mid-1;
                }
                else{
                    low = mid+1;
                }
                }
            return false;
          }
      }
      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      class Solution {
          public boolean isPerfectSquare(int num) {
            int low = 1;
            int high = num;
            while(low <= high){
                int mid = low + (high - low) / 2;
                int t = num / mid;
                if(t == mid){
                    if(num % mid==0) return true;
                    low = mid+1;}
                else if(t<mid)
                {
                    high = mid-1;
                }
                else{
                    low = mid+1;
                }
                }
            return false;
          }
      }

      数学方法

      所有平方数都是可以由奇数和构成的

      1=1 4=1+3 9=1+3+5

      则只需要每次从1开始减 每次加2 以num>0为判断条件

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      class Solution {
          public boolean isPerfectSquare(int num) {
             int ans=1;
             while(num > 0)
             {
                 num -= ans;
                 ans += 2;
             }
             return num==0;
          }
      }
      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      class Solution {
          public boolean isPerfectSquare(int num) {
             int ans=1;
             while(num > 0)
             {
                 num -= ans;
                 ans += 2;
             }
             return num==0;
          }
      }
      @@ -830,18 +830,18 @@

      [toc]Java实现pdf转为图片

      首先创建一个maven工程 在pom.xml文件导入包的依赖

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      <dependencies>
             <dependency>
                 <groupId>org.apache.pdfbox</groupId>
                 <artifactId>fontbox</artifactId>
                 <version>2.0.1</version>
             </dependency>
             <dependency>
                 <groupId>org.apache.pdfbox</groupId>
                 <artifactId>pdfbox</artifactId>
                 <version>2.0.1</version>
             </dependency>
             <!-- https://mvnrepository.com/artifact/com.develouz.view/pdfreader -->
             <!-- pdf水印 -->
             <dependency>
                 <groupId>com.lowagie</groupId>
                 <artifactId>itext</artifactId>
                 <version>2.1.7</version>
             </dependency>
         </dependencies>>
      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      <dependencies>
             <dependency>
                 <groupId>org.apache.pdfbox</groupId>
                 <artifactId>fontbox</artifactId>
                 <version>2.0.1</version>
             </dependency>
             <dependency>
                 <groupId>org.apache.pdfbox</groupId>
                 <artifactId>pdfbox</artifactId>
                 <version>2.0.1</version>
             </dependency>
             <!-- https://mvnrepository.com/artifact/com.develouz.view/pdfreader -->
             <!-- pdf水印 -->
             <dependency>
                 <groupId>com.lowagie</groupId>
                 <artifactId>itext</artifactId>
                 <version>2.1.7</version>
             </dependency>
         </dependencies>>

      第二步 在Java路径下创建一个子类PDF2IMAGE

      然后导入包

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      import java.awt.image.BufferedImage;
      import java.io.File;
      import java.io.IOException;

      import javax.imageio.ImageIO;

      import org.apache.pdfbox.pdmodel.PDDocument;
      import org.apache.pdfbox.rendering.PDFRenderer;

      import com.lowagie.text.pdf.PdfReader;
      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      import java.awt.image.BufferedImage;
      import java.io.File;
      import java.io.IOException;

      import javax.imageio.ImageIO;

      import org.apache.pdfbox.pdmodel.PDDocument;
      import org.apache.pdfbox.rendering.PDFRenderer;

      import com.lowagie.text.pdf.PdfReader;

      主体结构

      -
      1
      2
      3
      4
      public class PDF2IMAGE {
          public static void main(String[] args) {
              pdf2Image("C:/Users/peng/Downloads/1.pdf", "D:/pdf2", 300);
          }
      +
      1
      2
      3
      4
      public class PDF2IMAGE {
          public static void main(String[] args) {
              pdf2Image("C:/Users/peng/Downloads/1.pdf", "D:/pdf2", 300);
          }

      主要利用pdf2Image方法

      代码见下

      -
      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
      public static void pdf2Image(String PdfFilePath, String dstImgFolder, int dpi) {
          File file = new File(PdfFilePath);
          PDDocument pdDocument;
          try {
              String imgPDFPath = file.getParent();
              int dot = file.getName().lastIndexOf('.');
              String imagePDFName = file.getName().substring(0, dot); // 获取图片文件名
              String imgFolderPath = null;
              if (dstImgFolder.equals("")) {
                  imgFolderPath = imgPDFPath + File.separator + imagePDFName;// 获取图片存放的文件夹路径
              } else {
                  imgFolderPath = dstImgFolder + File.separator + imagePDFName;
              }

              if (createDirectory(imgFolderPath)) {

                  pdDocument = PDDocument.load(file);
                  PDFRenderer renderer = new PDFRenderer(pdDocument);
                  /* dpi越大转换后越清晰，相对转换速度越慢 */
                  PdfReader reader = new PdfReader(PdfFilePath);
                  int pages = reader.getNumberOfPages();
                  StringBuffer imgFilePath = null;
                  for (int i = 0; i < pages; i++) {
                      String imgFilePathPrefix = imgFolderPath + File.separator + imagePDFName;
                      imgFilePath = new StringBuffer();
                      imgFilePath.append(imgFilePathPrefix);
                      imgFilePath.append("_");
                      imgFilePath.append(String.valueOf(i + 1));
                      imgFilePath.append(".png");
                      File dstFile = new File(imgFilePath.toString());
                      BufferedImage image = renderer.renderImageWithDPI(i, dpi);
                      ImageIO.write(image, "png", dstFile);
                  }
                  System.out.println("PDF文档转PNG图片成功！");

              } else {
                  System.out.println("PDF文档转PNG图片失败：" + "创建" + imgFolderPath + "失败");
              }

          } catch (IOException e) {
              e.printStackTrace();
          }
      }
      +
      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
      public static void pdf2Image(String PdfFilePath, String dstImgFolder, int dpi) {
          File file = new File(PdfFilePath);
          PDDocument pdDocument;
          try {
              String imgPDFPath = file.getParent();
              int dot = file.getName().lastIndexOf('.');
              String imagePDFName = file.getName().substring(0, dot); // 获取图片文件名
              String imgFolderPath = null;
              if (dstImgFolder.equals("")) {
                  imgFolderPath = imgPDFPath + File.separator + imagePDFName;// 获取图片存放的文件夹路径
              } else {
                  imgFolderPath = dstImgFolder + File.separator + imagePDFName;
              }

              if (createDirectory(imgFolderPath)) {

                  pdDocument = PDDocument.load(file);
                  PDFRenderer renderer = new PDFRenderer(pdDocument);
                  /* dpi越大转换后越清晰，相对转换速度越慢 */
                  PdfReader reader = new PdfReader(PdfFilePath);
                  int pages = reader.getNumberOfPages();
                  StringBuffer imgFilePath = null;
                  for (int i = 0; i < pages; i++) {
                      String imgFilePathPrefix = imgFolderPath + File.separator + imagePDFName;
                      imgFilePath = new StringBuffer();
                      imgFilePath.append(imgFilePathPrefix);
                      imgFilePath.append("_");
                      imgFilePath.append(String.valueOf(i + 1));
                      imgFilePath.append(".png");
                      File dstFile = new File(imgFilePath.toString());
                      BufferedImage image = renderer.renderImageWithDPI(i, dpi);
                      ImageIO.write(image, "png", dstFile);
                  }
                  System.out.println("PDF文档转PNG图片成功！");

              } else {
                  System.out.println("PDF文档转PNG图片失败：" + "创建" + imgFolderPath + "失败");
              }

          } catch (IOException e) {
              e.printStackTrace();
          }
      }
      @@ -940,10 +940,10 @@

      第一步

      先导包

      -
      1
      2
      3
      import pyautogui

      import time
      +
      1
      2
      3
      import pyautogui

      import time

      第二部写个for循环

      -
      1
      2
      3
      4
      for i in range(0,100):
          print(i)
          pyautogui.click(1113,209, clicks=5,interval=1,duration=0.5)
          time.sleep(298)
      +
      1
      2
      3
      4
      for i in range(0,100):
          print(i)
          pyautogui.click(1113,209, clicks=5,interval=1,duration=0.5)
          time.sleep(298)

      github仓库源代码 https://github.com/fengxiaop/pyautogui

      有用的话记得点个 star

      @@ -1019,10 +1019,10 @@

      -

      1221. 分割平衡字符串

      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
      在一个 平衡字符串 中，'L' 和 'R' 字符的数量是相同的。

      给你一个平衡字符串 s，请你将它分割成尽可能多的平衡字符串。

      注意：分割得到的每个字符串都必须是平衡字符串，且分割得到的平衡字符串是原平衡字符串的连续子串。

      返回可以通过分割得到的平衡字符串的 最大数量 。

       

      示例 1：

      输入：s = "RLRRLLRLRL"
      输出：4
      解释：s 可以分割为 "RL"、"RRLL"、"RL"、"RL" ，每个子字符串中都包含相同数量的 'L' 和 'R' 。
      示例 2：

      输入：s = "RLLLLRRRLR"
      输出：3
      解释：s 可以分割为 "RL"、"LLLRRR"、"LR" ，每个子字符串中都包含相同数量的 'L' 和 'R' 。
      示例 3：

      输入：s = "LLLLRRRR"
      输出：1
      解释：s 只能保持原样 "LLLLRRRR".
      示例 4：

      输入：s = "RLRRRLLRLL"
      输出：2
      解释：s 可以分割为 "RL"、"RRRLLRLL" ，每个子字符串中都包含相同数量的 'L' 和 'R' 。
       

      提示：

      1 <= s.length <= 1000
      s[i] = 'L' 或 'R'
      s 是一个 平衡 字符串
      +

      1221. 分割平衡字符串

      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
      在一个 平衡字符串 中，'L' 和 'R' 字符的数量是相同的。

      给你一个平衡字符串 s，请你将它分割成尽可能多的平衡字符串。

      注意：分割得到的每个字符串都必须是平衡字符串，且分割得到的平衡字符串是原平衡字符串的连续子串。

      返回可以通过分割得到的平衡字符串的 最大数量 。

       

      示例 1：

      输入：s = "RLRRLLRLRL"
      输出：4
      解释：s 可以分割为 "RL"、"RRLL"、"RL"、"RL" ，每个子字符串中都包含相同数量的 'L' 和 'R' 。
      示例 2：

      输入：s = "RLLLLRRRLR"
      输出：3
      解释：s 可以分割为 "RL"、"LLLRRR"、"LR" ，每个子字符串中都包含相同数量的 'L' 和 'R' 。
      示例 3：

      输入：s = "LLLLRRRR"
      输出：1
      解释：s 只能保持原样 "LLLLRRRR".
      示例 4：

      输入：s = "RLRRRLLRLL"
      输出：2
      解释：s 可以分割为 "RL"、"RRRLLRLL" ，每个子字符串中都包含相同数量的 'L' 和 'R' 。
       

      提示：

      1 <= s.length <= 1000
      s[i] = 'L' 或 'R'
      s 是一个 平衡 字符串

      题解

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      class Solution {
          public int balancedStringSplit(String s) {
              int n = s.length();
              int j=0,ans=0;
              for(int i = 0 ; i < n ; i++ )
              {
                  if (s.charAt(i)=='R')
                  {
                      j++;
                  }
                  if (s.charAt(i)=='L')
                  {
                      j--;
                  }
                  if(j==0)
                  {
                      ans++;
                      }
              }
          return ans;
          }
      }
      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      class Solution {
          public int balancedStringSplit(String s) {
              int n = s.length();
              int j=0,ans=0;
              for(int i = 0 ; i < n ; i++ )
              {
                  if (s.charAt(i)=='R')
                  {
                      j++;
                  }
                  if (s.charAt(i)=='L')
                  {
                      j--;
                  }
                  if(j==0)
                  {
                      ans++;
                      }
              }
          return ans;
          }
      }
      diff --git a/page/7/index.html b/page/7/index.html index ab1e732a8..9f0e68d6a 100644 --- a/page/7/index.html +++ b/page/7/index.html @@ -204,10 +204,10 @@

      -

      561. 数组拆分 I

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      给定长度为 2n 的整数数组 nums ，你的任务是将这些数分成 n 对, 例如 (a1, b1), (a2, b2), ..., (an, bn) ，使得从 1 到 n 的 min(ai, bi) 总和最大。

      返回该 最大总和 。

       

      示例 1：

      输入：nums = [1,4,3,2]
      输出：4
      解释：所有可能的分法（忽略元素顺序）为：
      1. (1, 4), (2, 3) -> min(1, 4) + min(2, 3) = 1 + 2 = 3
      2. (1, 3), (2, 4) -> min(1, 3) + min(2, 4) = 1 + 2 = 3
      3. (1, 2), (3, 4) -> min(1, 2) + min(3, 4) = 1 + 3 = 4
      所以最大总和为 4
      示例 2：

      输入：nums = [6,2,6,5,1,2]
      输出：9
      解释：最优的分法为 (2, 1), (2, 5), (6, 6). min(2, 1) + min(2, 5) + min(6, 6) = 1 + 2 + 6 = 9
      +

      561. 数组拆分 I

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      给定长度为 2n 的整数数组 nums ，你的任务是将这些数分成 n 对, 例如 (a1, b1), (a2, b2), ..., (an, bn) ，使得从 1 到 n 的 min(ai, bi) 总和最大。

      返回该 最大总和 。

       

      示例 1：

      输入：nums = [1,4,3,2]
      输出：4
      解释：所有可能的分法（忽略元素顺序）为：
      1. (1, 4), (2, 3) -> min(1, 4) + min(2, 3) = 1 + 2 = 3
      2. (1, 3), (2, 4) -> min(1, 3) + min(2, 4) = 1 + 2 = 3
      3. (1, 2), (3, 4) -> min(1, 2) + min(3, 4) = 1 + 3 = 4
      所以最大总和为 4
      示例 2：

      输入：nums = [6,2,6,5,1,2]
      输出：9
      解释：最优的分法为 (2, 1), (2, 5), (6, 6). min(2, 1) + min(2, 5) + min(6, 6) = 1 + 2 + 6 = 9

      题解

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      class Solution {
          public int arrayPairSum(int[] nums) {
              Arrays.sort(nums);
              int n = nums.length;
              int ans = 0;
              for(int i = 0 ; i < n ; i+=2)
              {
                  ans+=nums[i];
              }
              return ans;
          }
      }
      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      class Solution {
          public int arrayPairSum(int[] nums) {
              Arrays.sort(nums);
              int n = nums.length;
              int ans = 0;
              for(int i = 0 ; i < n ; i+=2)
              {
                  ans+=nums[i];
              }
              return ans;
          }
      }
      @@ -281,17 +281,17 @@

      -

      575. 分糖果

      1
      2
      3
      4
      5
      6
      Alice 有 n 枚糖，其中第 i 枚糖的类型为 candyType[i] 。Alice 注意到她的体重正在增长，所以前去拜访了一位医生。

      医生建议 Alice 要少摄入糖分，只吃掉她所有糖的 n / 2 即可（n 是一个偶数）。Alice 非常喜欢这些糖，她想要在遵循医生建议的情况下，尽可能吃到最多不同种类的糖。

      给你一个长度为 n 的整数数组 candyType ，返回： Alice 在仅吃掉 n / 2 枚糖的情况下，可以吃到糖的最多种类数。

      +

      575. 分糖果

      1
      2
      3
      4
      5
      6
      Alice 有 n 枚糖，其中第 i 枚糖的类型为 candyType[i] 。Alice 注意到她的体重正在增长，所以前去拜访了一位医生。

      医生建议 Alice 要少摄入糖分，只吃掉她所有糖的 n / 2 即可（n 是一个偶数）。Alice 非常喜欢这些糖，她想要在遵循医生建议的情况下，尽可能吃到最多不同种类的糖。

      给你一个长度为 n 的整数数组 candyType ，返回： Alice 在仅吃掉 n / 2 枚糖的情况下，可以吃到糖的最多种类数。

      示例 1：

      -
      1
      2
      3
      输入：candyType = [1,1,2,2,3,3]
      输出：3
      解释：Alice 只能吃 6 / 2 = 3 枚糖，由于只有 3 种糖，她可以每种吃一枚。
      +
      1
      2
      3
      输入：candyType = [1,1,2,2,3,3]
      输出：3
      解释：Alice 只能吃 6 / 2 = 3 枚糖，由于只有 3 种糖，她可以每种吃一枚。

      示例 2：

      -
      1
      2
      3
      输入：candyType = [1,1,2,3]
      输出：2
      解释：Alice 只能吃 4 / 2 = 2 枚糖，不管她选择吃的种类是 [1,2]、[1,3] 还是 [2,3]，她只能吃到两种不同类的糖。
      +
      1
      2
      3
      输入：candyType = [1,1,2,3]
      输出：2
      解释：Alice 只能吃 4 / 2 = 2 枚糖，不管她选择吃的种类是 [1,2]、[1,3] 还是 [2,3]，她只能吃到两种不同类的糖。
      -
      1
      2
      3
      4
      5
      示例 3：

      输入：candyType = [6,6,6,6]
      输出：1
      解释：Alice 只能吃 4 / 2 = 2 枚糖，尽管她能吃 2 枚，但只能吃到 1 种糖。
      +
      1
      2
      3
      4
      5
      示例 3：

      输入：candyType = [6,6,6,6]
      输出：1
      解释：Alice 只能吃 4 / 2 = 2 枚糖，尽管她能吃 2 枚，但只能吃到 1 种糖。
      -
      1
      2
      3
      4
      5
      6
      7
      class Solution {
          public int distributeCandies(int[] candyType) {
              Set<Integer> set = new HashSet<>();
              for (int i : candyType) set.add(i);
              return Math.min(candyType.length / 2, set.size());
          }
      }
      +
      1
      2
      3
      4
      5
      6
      7
      class Solution {
          public int distributeCandies(int[] candyType) {
              Set<Integer> set = new HashSet<>();
              for (int i : candyType) set.add(i);
              return Math.min(candyType.length / 2, set.size());
          }
      }
      @@ -379,7 +379,7 @@

      ArrayList与Hashset

      Hashset 具有去重的功能 利用size()方法可以得到里面元素的种类

      ArrayList是有序的 元素可以重复

      HashSet是无序不重复的

      -

      575. 分糖果

      1
      2
      3
      4
      5
      6
      7
      class Solution {
          public int distributeCandies(int[] candyType) {
              Set<Integer> set = new HashSet<>();
              for (int i : candyType) set.add(i);
              return Math.min(candyType.length / 2, set.size());
          }
      }
      +

      575. 分糖果

      1
      2
      3
      4
      5
      6
      7
      class Solution {
          public int distributeCandies(int[] candyType) {
              Set<Integer> set = new HashSet<>();
              for (int i : candyType) set.add(i);
              return Math.min(candyType.length / 2, set.size());
          }
      }

      利用set去重,再用set.size()得到糖果的种类

      创建ArrayList表

      @@ -463,29 +463,29 @@

      496. 下一个更大元素 I

      难度 :简单

      -
      1
      2
      3
      4
      5
      给你两个 没有重复元素 的数组 nums1 和 nums2 ，其中nums1 是 nums2 的子集。

      请你找出 nums1 中每个元素在 nums2 中的下一个比其大的值。

      nums1 中数字 x 的下一个更大元素是指 x 在 nums2 中对应位置的右边的第一个比 x 大的元素。如果不存在，对应位置输出 -1 。
      +
      1
      2
      3
      4
      5
      给你两个 没有重复元素 的数组 nums1 和 nums2 ，其中nums1 是 nums2 的子集。

      请你找出 nums1 中每个元素在 nums2 中的下一个比其大的值。

      nums1 中数字 x 的下一个更大元素是指 x 在 nums2 中对应位置的右边的第一个比 x 大的元素。如果不存在，对应位置输出 -1 。

      示例 1:

      -
      1
      2
      3
      4
      5
      6
      输入: nums1 = [4,1,2], nums2 = [1,3,4,2].
      输出: [-1,3,-1]
      解释:
          对于 num1 中的数字 4 ，你无法在第二个数组中找到下一个更大的数字，因此输出 -1 。
          对于 num1 中的数字 1 ，第二个数组中数字1右边的下一个较大数字是 3 。
          对于 num1 中的数字 2 ，第二个数组中没有下一个更大的数字，因此输出 -1 。
      +
      1
      2
      3
      4
      5
      6
      输入: nums1 = [4,1,2], nums2 = [1,3,4,2].
      输出: [-1,3,-1]
      解释:
          对于 num1 中的数字 4 ，你无法在第二个数组中找到下一个更大的数字，因此输出 -1 。
          对于 num1 中的数字 1 ，第二个数组中数字1右边的下一个较大数字是 3 。
          对于 num1 中的数字 2 ，第二个数组中没有下一个更大的数字，因此输出 -1 。

      示例 2:

      -
      1
      2
      3
      4
      5
      6
      输入: nums1 = [2,4], nums2 = [1,2,3,4].
      输出: [3,-1]
      解释:
          对于 num1 中的数字 2 ，第二个数组中的下一个较大数字是 3 。
          对于 num1 中的数字 4 ，第二个数组中没有下一个更大的数字，因此输出 -1 。

      +
      1
      2
      3
      4
      5
      6
      输入: nums1 = [2,4], nums2 = [1,2,3,4].
      输出: [3,-1]
      解释:
          对于 num1 中的数字 2 ，第二个数组中的下一个较大数字是 3 。
          对于 num1 中的数字 4 ，第二个数组中没有下一个更大的数字，因此输出 -1 。

      提示：

      -
      1
      2
      3
      4
      1 <= nums1.length <= nums2.length <= 1000
      0 <= nums1[i], nums2[i] <= 104
      nums1和nums2中所有整数 互不相同
      nums1 中的所有整数同样出现在 nums2 中
      +
      1
      2
      3
      4
      1 <= nums1.length <= nums2.length <= 1000
      0 <= nums1[i], nums2[i] <= 104
      nums1和nums2中所有整数 互不相同
      nums1 中的所有整数同样出现在 nums2 中

      看到题目第一时间就想的遍历然后匹配 虽然写的很垃圾 但是是自己独立debug写出来的还是很高兴

      -

      方法一 ：暴力

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      class Solution {
          public int[] nextGreaterElement(int[] nums1, int[] nums2) {
              int n = nums1.length;
              int nums3[] = new int[n];
              for(int i = 0 ; i < n ; i++ )
                  for(int j = 0 ; j < nums2.length ; j++ )
                      if(nums1[i] == nums2[j])
                          for(int k = j;k<nums2.length;k++)
                              if( nums2[k] > nums1[i])
                                {
                                nums3[i] = nums2[k];
                                break;
                                }
                              else
                                nums3[i] = -1;
          return nums3;
          }
      }
      +

      方法一 ：暴力

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      class Solution {
          public int[] nextGreaterElement(int[] nums1, int[] nums2) {
              int n = nums1.length;
              int nums3[] = new int[n];
              for(int i = 0 ; i < n ; i++ )
                  for(int j = 0 ; j < nums2.length ; j++ )
                      if(nums1[i] == nums2[j])
                          for(int k = j;k<nums2.length;k++)
                              if( nums2[k] > nums1[i])
                                {
                                nums3[i] = nums2[k];
                                break;
                                }
                              else
                                nums3[i] = -1;
          return nums3;
          }
      }

      有几个地方需要注意 就是当遇见一个数比他大的时候 需要赋值后立即跳出

      官方题解

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      class Solution {
          public int[] nextGreaterElement(int[] nums1, int[] nums2) {
              int m = nums1.length, n = nums2.length;
              int[] res = new int[m];
              for (int i = 0; i < m; ++i) {
                  int j = 0;
                  while (j < n && nums2[j] != nums1[i]) {
                      ++j;
                  }
                  int k = j + 1;
                  while (k < n && nums2[k] < nums2[j]) {
                      ++k;
                  }
                  res[i] = k < n ? nums2[k] : -1;
              }
              return res;
          }
      }
      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      class Solution {
          public int[] nextGreaterElement(int[] nums1, int[] nums2) {
              int m = nums1.length, n = nums2.length;
              int[] res = new int[m];
              for (int i = 0; i < m; ++i) {
                  int j = 0;
                  while (j < n && nums2[j] != nums1[i]) {
                      ++j;
                  }
                  int k = j + 1;
                  while (k < n && nums2[k] < nums2[j]) {
                      ++k;
                  }
                  res[i] = k < n ? nums2[k] : -1;
              }
              return res;
          }
      }

      不得不感叹一下 同样是暴力遍历 官方写的比我写的好得多

      -

      方法二：单调栈 + 哈希表

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      class Solution {
          public int[] nextGreaterElement(int[] nums1, int[] nums2) {
              Map<Integer, Integer> map = new HashMap<Integer, Integer>();
              Deque<Integer> stack = new ArrayDeque<Integer>();
              for (int i = nums2.length - 1; i >= 0; --i) {
                  int num = nums2[i];
                  while (!stack.isEmpty() && num >= stack.peek()) {
                      stack.pop();
                  }
                  map.put(num, stack.isEmpty() ? -1 : stack.peek());
                  stack.push(num);
              }
              int[] res = new int[nums1.length];
              for (int i = 0; i < nums1.length; ++i) {
                  res[i] = map.get(nums1[i]);
              }
              return res;
          }
      }
      +

      方法二：单调栈 + 哈希表

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      class Solution {
          public int[] nextGreaterElement(int[] nums1, int[] nums2) {
              Map<Integer, Integer> map = new HashMap<Integer, Integer>();
              Deque<Integer> stack = new ArrayDeque<Integer>();
              for (int i = nums2.length - 1; i >= 0; --i) {
                  int num = nums2[i];
                  while (!stack.isEmpty() && num >= stack.peek()) {
                      stack.pop();
                  }
                  map.put(num, stack.isEmpty() ? -1 : stack.peek());
                  stack.push(num);
              }
              int[] res = new int[nums1.length];
              for (int i = 0; i < nums1.length; ++i) {
                  res[i] = map.get(nums1[i]);
              }
              return res;
          }
      }

      三叶姐题解

      -
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      class Solution {
          public int[] nextGreaterElement(int[] nums1, int[] nums2) {
              int n = nums1.length, m = nums2.length;
              Deque<Integer> d = new ArrayDeque<>();
              Map<Integer, Integer> map = new HashMap<>();
              for (int i = m - 1; i >= 0; i--) {
                  int x = nums2[i];
                  while (!d.isEmpty() && d.peekLast() <= x) d.pollLast();
                  map.put(x, d.isEmpty() ? -1 : d.peekLast());
                  d.addLast(x);
              }
              int[] ans = new int[n];
              for (int i = 0; i < n; i++) ans[i] = map.get(nums1[i]);
              return ans;
          }
      }
      +
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      class Solution {
          public int[] nextGreaterElement(int[] nums1, int[] nums2) {
              int n = nums1.length, m = nums2.length;
              Deque<Integer> d = new ArrayDeque<>();
              Map<Integer, Integer> map = new HashMap<>();
              for (int i = m - 1; i >= 0; i--) {
                  int x = nums2[i];
                  while (!d.isEmpty() && d.peekLast() <= x) d.pollLast();
                  map.put(x, d.isEmpty() ? -1 : d.peekLast());
                  d.addLast(x);
              }
              int[] ans = new int[n];
              for (int i = 0; i < n; i++) ans[i] = map.get(nums1[i]);
              return ans;
          }
      }
      @@ -568,7 +568,7 @@

      被拉去参加财务大学生竞赛 让我当大数据分析师

      刷了几套题发现是考查找数据能力以及利用python tushare库做分析

      -
      1
      2
      3
      4
      5
      6
      import tushare as ts
      ts.set_token('41addd8c3955aea5623099855def5d5ae794632258ad289d8fd02fb6')
      ds = ts.pro_bar(ts_code='000425.SZ', start_date='20130101', end_date='20171231', freq='M', adj='hfq')
      ds = ds[['trade_date', 'close']]
      ds.to_excel('D:/bigdata/000425.xlsx')
      print(ds)
      +
      1
      2
      3
      4
      5
      6
      import tushare as ts
      ts.set_token('41addd8c3955aea5623099855def5d5ae794632258ad289d8fd02fb6')
      ds = ts.pro_bar(ts_code='000425.SZ', start_date='20130101', end_date='20171231', freq='M', adj='hfq')
      ds = ds[['trade_date', 'close']]
      ds.to_excel('D:/bigdata/000425.xlsx')
      print(ds)

      ​ 刚好在1024节这天参加了学校的校赛，讲讲这次作为大数据分析师的感受把 ，题目不难，但是有些题数据很多很费时间，我就是因为没有正确的选择以及没有得知大数据分析师考完后其他人能看到正确答案的要求，不然我也不会死耗在第一题第二题数据多分少但是对队友很重要的地方了。两个利用tushare库的问题，其实编程很简单，简单导个库，然后找到接口依葫芦画瓢就好了。

      ​ 虽然过程很曲折，但是结果还是比较符合人意的，队伍排名10/102 刚好拿到三等奖的最后一个名次 刚出来成绩的时候看到分数还是很自责的 因为要是我发挥稳定的话，可能我们就是第一了 或者没看错那个题 我们就是二等奖了 好在队友小雪 佳佳 子怡都挺好的 也很高兴经过四天训练之后能拿到这一个校奖。虽然自己的大数据分析师好像被别人拉爆了 已经被拉到10名开外了 有点丢我们计院的脸了hhh。但是好像也免了去拒绝停课去打这个几乎和我本专业无关的比赛了。

      @@ -654,7 +654,7 @@

      SpringMVC

      Spring+MVc(Model View Controller)

      Model :实体类Bean 专门做存储业务数据

      -
               业务处理Bean 指Servicw或Dao对象，专门用于处理业务逻辑和数据访问
+
               业务处理Bean 指Servicw或Dao对象，专门用于处理业务逻辑和数据访问
 
      
 
      View :视图层  指工程中的html+jsp等页面  
      
 
      Controller : 控制层 servelt 
      
@@ -741,27 +741,27 @@ 
      
       
           
      453. 最小操作次数使数组元素相等
      给你一个长度为 n 的整数数组，每次操作将会使 n - 1 个元素增加 1 。返回让数组所有元素相等的最小操作次数。
      
 
      示例 1：
      
-
      1
      2
      3
      4
      5
      6
      输入：nums = [1,2,3]
      输出：3
      解释：
      只需要3次操作（注意每次操作会增加两个元素的值）：
      [1,2,3]  =>  [2,3,3]  =>  [3,4,3]  =>  [4,4,4]

      
+
      1
      2
      3
      4
      5
      6
      输入：nums = [1,2,3]
      输出：3
      解释：
      只需要3次操作（注意每次操作会增加两个元素的值）：
      [1,2,3]  =>  [2,3,3]  =>  [3,4,3]  =>  [4,4,4]

      
 
 
      示例 2：
      
-
      1
      2
      输入：nums = [1,1,1]
      输出：0
      
+
      1
      2
      输入：nums = [1,1,1]
      输出：0
      
 
-
      1

      
+
      1

      
 
 
      解析
      
 
      每一步除了最大的那个数不加1  相等于最大的数减1 参考相对运动理解
      
 
      每一次操作总和都会-1
      
 
      那么最后的结果肯定是n个最小数
      
 
      那么
      
-
      1
      return sum - min * n;
      
+
      1
      return sum - min * n;
      
 
 
      即可得到结果
      
 
      利用for each语句遍历数组
      
 
      找出数组里面最小的数和总和sum
      
-
      1
      2
      3
      4
      for (int i : nums) {
                  min = Math.min(min, i);
                  sum += i;
              }
      
+
      1
      2
      3
      4
      for (int i : nums) {
                  min = Math.min(min, i);
                  sum += i;
              }
      
 
 
      题解
      
-
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      class Solution {
          public int minMoves(int[] nums) {
              int n = nums.length;
              int min = nums[0], sum = 0;
              for (int i : nums) {
                  min = Math.min(min, i);
                  sum += i;
              }
              return sum - min * n;
          }
      }
      
+
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      class Solution {
          public int minMoves(int[] nums) {
              int n = nums.length;
              int min = nums[0], sum = 0;
              for (int i : nums) {
                  min = Math.min(min, i);
                  sum += i;
              }
              return sum - min * n;
          }
      }
      
 
 
       
@@ -845,26 +845,26 @@ 
      有效字符串需满足：
      
 
      左括号必须用相同类型的右括号闭合。
      左括号必须以正确的顺序闭合。
      
 
      示例 1：
      
-
      1
      2
      输入：s = "()"
      输出：true
      
+
      1
      2
      输入：s = "()"
      输出：true
      
 
 
      示例 2：
      
-
      1
      2
      输入：s = "()[]{}"
      输出：true
      
+
      1
      2
      输入：s = "()[]{}"
      输出：true
      
 
 
      示例 3：
      
-
      1
      2
      输入：s = "(]"
      输出：false
      
+
      1
      2
      输入：s = "(]"
      输出：false
      
 
 
      示例 4：
      
-
      1
      2
      输入：s = "([)]"
      输出：false
      
+
      1
      2
      输入：s = "([)]"
      输出：false
      
 
 
      示例 5：
      
-
      1
      2
      输入：s = "{[]}"
      输出：true
      
+
      1
      2
      输入：s = "{[]}"
      输出：true
      
 
 
 
      提示：
      
-
      1
      2
      1 <= s.length <= 104
      s 仅由括号 '()[]{}' 组成
      
+
      1
      2
      1 <= s.length <= 104
      s 仅由括号 '()[]{}' 组成
      
 
 
      题解
      
-
      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
      class Solution {

        public boolean isValid(String s) {

      ​    int n = s.length();

      ​    if (n % 2 == 1) {

      ​      return false;

      ​    }



      ​    Map<Character, Character> pairs = new HashMap<Character, Character>() {{

      ​      put(')', '(');

      ​      put(']', '[');

      ​      put('}', '{');

      ​    }};

      ​    Deque<Character> stack = new LinkedList<Character>();

      ​    for (int i = 0; i < n; i++) {

      ​      char ch = s.charAt(i);

      ​      if (pairs.containsKey(ch)) {

      ​        if (stack.isEmpty() || stack.peek() != pairs.get(ch)) {

      ​          return false;

      ​        }

      ​        stack.pop();

      ​      } else {

      ​        stack.push(ch);

      ​      }

      ​    }

      ​    return stack.isEmpty();

        }

      }
      
+
      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
      class Solution {

        public boolean isValid(String s) {

      ​    int n = s.length();

      ​    if (n % 2 == 1) {

      ​      return false;

      ​    }



      ​    Map<Character, Character> pairs = new HashMap<Character, Character>() {{

      ​      put(')', '(');

      ​      put(']', '[');

      ​      put('}', '{');

      ​    }};

      ​    Deque<Character> stack = new LinkedList<Character>();

      ​    for (int i = 0; i < n; i++) {

      ​      char ch = s.charAt(i);

      ​      if (pairs.containsKey(ch)) {

      ​        if (stack.isEmpty() || stack.peek() != pairs.get(ch)) {

      ​          return false;

      ​        }

      ​        stack.pop();

      ​      } else {

      ​        stack.push(ch);

      ​      }

      ​    }

      ​    return stack.isEmpty();

        }

      }
      
 
 
      先就s字符串的长度奇数还是偶数进行判断
      
 
      如果长度是奇数 直接返回false 因为不满足闭合条件
      
@@ -947,42 +947,42 @@ 
      
 
       
           
      二分算法
      二分算法基本框架
      
-
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      class Solution {
          public int searchInsert(int[] nums, int target) {
              int left = 0,right=nums.length-1,ans=right+1;
              while(left<=right){
              int mid = (left + right)/2;
              if(nums[mid]>=target){
                ans=mid;
                right=mid-1;}
              else 
              left=mid+1;
              }
          return ans;
      }
      
+
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      class Solution {
          public int searchInsert(int[] nums, int target) {
              int left = 0,right=nums.length-1,ans=right+1;
              while(left<=right){
              int mid = (left + right)/2;
              if(nums[mid]>=target){
                ans=mid;
                right=mid-1;}
              else 
              left=mid+1;
              }
          return ans;
      }
      
 
 
      分析二分查找的一个技巧是：不要出现 else，而是把所有情况用 else if 写清楚，这样可以清楚地展现所有细节。本文都会使用 else if，旨在讲清楚，读者理解后可自行简化。
      
 
      其中 … 标记的部分，就是可能出现细节问题的地方，当你见到一个二分查找的代码时，首先注意这几个地方。后文用实例分析这些地方能有什么样的变化。
      
 
      另外声明一下，计算 mid 时需要技巧防止溢出，即 mid=left+(right-left)/2。本文暂时忽略这个问题。
      
 
      一、寻找一个数（基本的二分搜索）
      
 
      这个场景是最简单的，可能也是大家最熟悉的，即搜索一个数，如果存在，返回其索引，否则返回 -1。
      
-
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      int binarySearch(int[] nums, int target) {
          int left = 0;
          int right = nums.length - 1; // 注意

          while(left <= right) {
              int mid = (right + left) / 2;
              if(nums[mid] == target)
                  return mid;
              else if (nums[mid] < target)
                  left = mid + 1; // 注意
              else if (nums[mid] > target)
                  right = mid - 1; // 注意
              }
          return -1;
      }
      
+
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      int binarySearch(int[] nums, int target) {
          int left = 0;
          int right = nums.length - 1; // 注意

          while(left <= right) {
              int mid = (right + left) / 2;
              if(nums[mid] == target)
                  return mid;
              else if (nums[mid] < target)
                  left = mid + 1; // 注意
              else if (nums[mid] > target)
                  right = mid - 1; // 注意
              }
          return -1;
      }
      
 
 
      1. 为什么 while 循环的条件中是 <=，而不是 < ？
      
 
      答：因为初始化 right 的赋值是 nums.length-1，即最后一个元素的索引，而不是 nums.length。
      
 
      这二者可能出现在不同功能的二分查找中，区别是：前者相当于两端都闭区间 [left, right]，后者相当于左闭右开区间 [left, right)，因为索引大小为 nums.length 是越界的。
      
 
      我们这个算法中使用的是前者 [left, right] 两端都闭的区间。这个区间其实就是每次进行搜索的区间，我们不妨称为「搜索区间」。
      
 
      什么时候应该停止搜索呢？当然，找到了目标值的时候可以终止：
      
-
      1
      2
      if(nums[mid] == target)
             return mid;
      
+
      1
      2
      if(nums[mid] == target)
             return mid;
      
 
 
      但如果没找到，就需要 while 循环终止，然后返回 -1。那 while 循环什么时候应该终止？搜索区间为空的时候应该终止，意味着你没得找了，就等于没找到嘛。
      
 
      while(left <= right) 的终止条件是 left == right + 1，写成区间的形式就是 [right + 1, right]，或者带个具体的数字进去 [3, 2]，可见这时候搜索区间为空，因为没有数字既大于等于 3 又小于等于 2 的吧。所以这时候 while 循环终止是正确的，直接返回 -1 即可。
      
 
      while(left < right) 的终止条件是 left == right，写成区间的形式就是 [left, right]，或者带个具体的数字进去 [2, 2]，这时候搜索区间非空，还有一个数 2，但此时 while 循环终止了。也就是说这区间 [2, 2] 被漏掉了，索引 2 没有被搜索，如果这时候直接返回 -1 就是错误的。
      
 
      当然，如果你非要用 while(left < right) 也可以，我们已经知道了出错的原因，就打个补丁好了：
      
-
      1
      2
      3
      4
      5
      //...
      while(left < right) {
          // ...
      }
      return nums[left] == target ? left : -1;
      
+
      1
      2
      3
      4
      5
      //...
      while(left < right) {
          // ...
      }
      return nums[left] == target ? left : -1;
      
 
 
      详解解析看 [https://www.cnblogs.com/mxj961116/p/11945444.html]
      
 
      leetcode_剑指 Offer II 069. 山峰数组的顶部
      
 
      山峰数组
      
 
      二分题解
      
-
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      class Solution {
          public int peakIndexInMountainArray(int[] arr) {
          int left = 0 , rigth = arr.length-1,ans = 0;
          while(left<=rigth)
          {
              int mid = (left+rigth)/2;
              if(arr[mid]>arr[mid+1])
              {ans = mid;
              rigth = mid-1;}
              else
              left = mid+1;

          }
          return ans;
          }
      }
      
+
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      class Solution {
          public int peakIndexInMountainArray(int[] arr) {
          int left = 0 , rigth = arr.length-1,ans = 0;
          while(left<=rigth)
          {
              int mid = (left+rigth)/2;
              if(arr[mid]>arr[mid+1])
              {ans = mid;
              rigth = mid-1;}
              else
              left = mid+1;

          }
          return ans;
          }
      }
      
 
 
      leetcode_35
      
 
      35. 搜索插入位置
      插入位置
      
 
      题解
      
-
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      class Solution {
          public int searchInsert(int[] nums, int target) {
              int left = 0,right=nums.length-1,ans=right+1;
              while(left<=right){
              int mid = (left + right)/2;
              if(nums[mid]>=target){
                ans=mid;
                right=mid-1;}
              else 
              left=mid+1;
              }
          return ans;
              }
      }
      
+
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      class Solution {
          public int searchInsert(int[] nums, int target) {
              int left = 0,right=nums.length-1,ans=right+1;
              while(left<=right){
              int mid = (left + right)/2;
              if(nums[mid]>=target){
                ans=mid;
                right=mid-1;}
              else 
              left=mid+1;
              }
          return ans;
              }
      }
      
 
 
      33. 搜索旋转排序数组
      
 
      题解
      
-
      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
      class Solution {
          public int search(int[] nums, int target) {
              int left = 0, right = nums.length - 1,ans = 0;
              while(left <= right)
              {
                  int mid=(left+right);
                  if(nums[mid] > nums[right]){
                      if(target > nums[mid])
                      {
                          left = mid+1;
                      }
                      else if(target < nums[mid])
                      {
                          right = mid-1;
                      }
                      else 
                          ans = mid;
                  }
                  if(nums[mid] <nums[right]){
                      if(target<nums[mid])
                      {
                          left=mid+1;
                      }
                      else if(target > nums[mid])
                      {
                          right=mid-1;
                      }
                      else
                          ans=mid;
                  }
          }
          return ans;
      }
      }
      
+
      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
      class Solution {
          public int search(int[] nums, int target) {
              int left = 0, right = nums.length - 1,ans = 0;
              while(left <= right)
              {
                  int mid=(left+right);
                  if(nums[mid] > nums[right]){
                      if(target > nums[mid])
                      {
                          left = mid+1;
                      }
                      else if(target < nums[mid])
                      {
                          right = mid-1;
                      }
                      else 
                          ans = mid;
                  }
                  if(nums[mid] <nums[right]){
                      if(target<nums[mid])
                      {
                          left=mid+1;
                      }
                      else if(target > nums[mid])
                      {
                          right=mid-1;
                      }
                      else
                          ans=mid;
                  }
          }
          return ans;
      }
      }
      
 
 
       
@@ -1062,7 +1062,7 @@ 
      
     
      
 
       
-          
      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
      package testthread41;

      import org.apache.commons.io.FileUtils;

      import java.io.File;
      import java.io.IOException;
      import java.net.URL;

      //练习Thread 实现多线程同步下载
      public class TestThread2 extends Thread {
          private String url;//图片地址
          private String name;
          public TestThread2 (String url,String name){
           this.url = url;
           this.name = name;
          }
          @Override
          public void run() {
              WebDownload webDownload = new WebDownload();
              webDownload.downloader(url,name);
              System.out.println("下载了文件名："+name);
          }

          public static void main(String[] args) {
              TestThread2 t1 = new TestThread2("https://img.lianzhixiu.com/uploads/allimg/150827/9-150RH11Z00-L.jpg","美女1.jpg");
              TestThread2 t2 = new TestThread2("https://img.lianzhixiu.com/uploads/allimg/202105/9999/rnf45aa76447.jpg","美女2.jpg");
              TestThread2 t3 = new TestThread2("https://img.lianzhixiu.com/uploads/allimg/202104/9999/rndb598b8b76.jpg","美女3.jpg");

              t1.start();
              t2.start();
              t3.start();
          }
      }

       class WebDownload{
          public void downloader(String url,String name){
              try {
                  FileUtils.copyURLToFile(new URL(url),new File(name));
              } catch (IOException e) {
                  e.printStackTrace();
                  System.out.println("IO异常,downloader方法出现问题");
              }

          }

       }


      
+          
      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
      package testthread41;

      import org.apache.commons.io.FileUtils;

      import java.io.File;
      import java.io.IOException;
      import java.net.URL;

      //练习Thread 实现多线程同步下载
      public class TestThread2 extends Thread {
          private String url;//图片地址
          private String name;
          public TestThread2 (String url,String name){
           this.url = url;
           this.name = name;
          }
          @Override
          public void run() {
              WebDownload webDownload = new WebDownload();
              webDownload.downloader(url,name);
              System.out.println("下载了文件名："+name);
          }

          public static void main(String[] args) {
              TestThread2 t1 = new TestThread2("https://img.lianzhixiu.com/uploads/allimg/150827/9-150RH11Z00-L.jpg","美女1.jpg");
              TestThread2 t2 = new TestThread2("https://img.lianzhixiu.com/uploads/allimg/202105/9999/rnf45aa76447.jpg","美女2.jpg");
              TestThread2 t3 = new TestThread2("https://img.lianzhixiu.com/uploads/allimg/202104/9999/rndb598b8b76.jpg","美女3.jpg");

              t1.start();
              t2.start();
              t3.start();
          }
      }

       class WebDownload{
          public void downloader(String url,String name){
              try {
                  FileUtils.copyURLToFile(new URL(url),new File(name));
              } catch (IOException e) {
                  e.printStackTrace();
                  System.out.println("IO异常,downloader方法出现问题");
              }

          }

       }


      
 
 
       
diff --git a/page/8/index.html b/page/8/index.html
index 42a5a4ab8..0faaa0418 100644
--- a/page/8/index.html
+++ b/page/8/index.html
@@ -211,10 +211,10 @@ 
      
 
       
           
      剑指 Offer II 069. 山峰数组的顶部
      题目
      
-
      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
      符合下列属性的数组 arr 称为 山峰数组（山脉数组） ：

      arr.length >= 3
      存在 i（0 < i < arr.length - 1）使得：
      arr[0] < arr[1] < ... arr[i-1] < arr[i]
      arr[i] > arr[i+1] > ... > arr[arr.length - 1]
      给定由整数组成的山峰数组 arr ，返回任何满足 arr[0] < arr[1] < ... arr[i - 1] < arr[i] > arr[i + 1] > ... > arr[arr.length - 1] 的下标 i ，即山峰顶部。

       

      示例 1：

      输入：arr = [0,1,0]
      输出：1
      示例 2：

      输入：arr = [1,3,5,4,2]
      输出：2
      示例 3：

      输入：arr = [0,10,5,2]
      输出：1
      示例 4：

      输入：arr = [3,4,5,1]
      输出：2
      示例 5：

      输入：arr = [24,69,100,99,79,78,67,36,26,19]
      输出：2
       

      提示：

      3 <= arr.length <= 104
      0 <= arr[i] <= 106
      题目数据保证 arr 是一个山脉数组
       

      进阶：很容易想到时间复杂度 O(n) 的解决方案，你可以设计一个 O(log(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
      37
      38
      39
      40
      符合下列属性的数组 arr 称为 山峰数组（山脉数组） ：

      arr.length >= 3
      存在 i（0 < i < arr.length - 1）使得：
      arr[0] < arr[1] < ... arr[i-1] < arr[i]
      arr[i] > arr[i+1] > ... > arr[arr.length - 1]
      给定由整数组成的山峰数组 arr ，返回任何满足 arr[0] < arr[1] < ... arr[i - 1] < arr[i] > arr[i + 1] > ... > arr[arr.length - 1] 的下标 i ，即山峰顶部。

       

      示例 1：

      输入：arr = [0,1,0]
      输出：1
      示例 2：

      输入：arr = [1,3,5,4,2]
      输出：2
      示例 3：

      输入：arr = [0,10,5,2]
      输出：1
      示例 4：

      输入：arr = [3,4,5,1]
      输出：2
      示例 5：

      输入：arr = [24,69,100,99,79,78,67,36,26,19]
      输出：2
       

      提示：

      3 <= arr.length <= 104
      0 <= arr[i] <= 106
      题目数据保证 arr 是一个山脉数组
       

      进阶：很容易想到时间复杂度 O(n) 的解决方案，你可以设计一个 O(log(n)) 的解决方案吗？
      
 
 
      我写的想法 第一次就想到for循环遍历  写出了O（n）的学法
      
-
      1
      2
      3
      4
      5
      6
      7
      8
      int peakIndexInMountainArray(int* arr, int arrSize){
          int temp=0;
          for(;temp<arrSize-1;temp++){
              if(arr[temp]>arr[temp+1])
              break;
          }
          return temp;
      }
      
+
      1
      2
      3
      4
      5
      6
      7
      8
      int peakIndexInMountainArray(int* arr, int arrSize){
          int temp=0;
          for(;temp<arrSize-1;temp++){
              if(arr[temp]>arr[temp+1])
              break;
          }
          return temp;
      }
      
 
 
      三叶姐姐的解法
      
 
      二分
      往常我们使用「二分」进行查值，需要确保序列本身满足「二段性」：当选定一个端点（基准值）后，结合「一段满足 & 另一段不满足」的特性来实现“折半”的查找效果。
      
@@ -223,7 +223,7 @@ 
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      class Solution {
          // 根据 arr[i-1] < arr[i] 在 [1,n-1] 范围内找值
          // 峰顶元素为符合条件的最靠近中心的元素
          public int peakIndexInMountainArray(int[] arr) {
              int n = arr.length;
              int l = 1, r = n - 1;
              while (l < r) {
                  int mid = l + r + 1 >> 1;
                  if (arr[mid - 1] < arr[mid]) l = mid;
                  else r = mid - 1;
              }
              return r;
          }
      }
      
+
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      class Solution {
          // 根据 arr[i-1] < arr[i] 在 [1,n-1] 范围内找值
          // 峰顶元素为符合条件的最靠近中心的元素
          public int peakIndexInMountainArray(int[] arr) {
              int n = arr.length;
              int l = 1, r = n - 1;
              while (l < r) {
                  int mid = l + r + 1 >> 1;
                  if (arr[mid - 1] < arr[mid]) l = mid;
                  else r = mid - 1;
              }
              return r;
          }
      }
      
 
 
        
 
      • 时间复杂度：O(\log{n})O(logn)
        
@@ -336,7 +336,7 @@ 
        
 
        所以自己想了一下自己可以写一个绩点计算器出来吗  好像也不是很难的样子
        
 
        所以自己用了差不多20分钟帮这个写出来了
        
 
        下面是源码
        
-
        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
        #include<stdio.h>

        int main()

        {

        	int number;

        	float score;

        	float credit,creditsum=0; 

        	float gpasum=0.0,GPA=0.0;

        	printf("请输入需要计算的科目数量");

        	scanf("%d",&number);

        		int count=1;

        	for(int i=0;i<number;i++)

        	{

        	printf("请输入第%d科的成绩和学分",count); 

        	scanf("%f %f",&score,&credit);

        	creditsum+=credit;

        //	printf("%.1f",(score/10-5)*credit);

        	gpasum+=(score/10-5)*credit;

        	GPA=gpasum/creditsum;

        		count++;

        	}

        //	printf("学分总和：%.1f",creditsum);

        //	printf("总分：%.1f",gpasum);

        	printf("您的GPA是%.1f",GPA);

        	

        } 
        
+
        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
        #include<stdio.h>

        int main()

        {

        	int number;

        	float score;

        	float credit,creditsum=0; 

        	float gpasum=0.0,GPA=0.0;

        	printf("请输入需要计算的科目数量");

        	scanf("%d",&number);

        		int count=1;

        	for(int i=0;i<number;i++)

        	{

        	printf("请输入第%d科的成绩和学分",count); 

        	scanf("%f %f",&score,&credit);

        	creditsum+=credit;

        //	printf("%.1f",(score/10-5)*credit);

        	gpasum+=(score/10-5)*credit;

        	GPA=gpasum/creditsum;

        		count++;

        	}

        //	printf("学分总和：%.1f",creditsum);

        //	printf("总分：%.1f",gpasum);

        	printf("您的GPA是%.1f",GPA);

        	

        } 
        
 
 
        功能样图
        在这里插入图片描述
        欢迎关注微信公众号  ：打码少年风萧
        程序链接
        链接：        https://pan.baidu.com/s/1MzkRQ3XCtWadlWFxFDef4g
        提取码：30qf 
        
 
@@ -424,7 +424,7 @@ 
        
 
        输入：n = 3
        输出：[“1”,”2”,”Fizz”]
        示例 2：
        
 
        输入：n = 5
        输出：[“1”,”2”,”Fizz”,”4”,”Buzz”]
        示例 3：
        
 
        输入：n = 15
        输出：[“1”,”2”,”Fizz”,”4”,”Buzz”,”Fizz”,”7”,”8”,”Fizz”,”Buzz”,”11”,”Fizz”,”13”,”14”,”FizzBuzz”]
        
-
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        class Solution {
            public List<String> fizzBuzz(int n) {
                List<String> li = new ArrayList<>();
                for(Integer i=1;i<=n;i++)
              {  
                if(i % 3 == 0 && i % 5 == 0) li.add("FizzBuzz");
                else if(i%3==0)li.add("Fizz");
                else if(i%5==0)li.add("Buzz");
                else li.add(i.toString());
            }
            return li;
            }
        }
        
+
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        class Solution {
            public List<String> fizzBuzz(int n) {
                List<String> li = new ArrayList<>();
                for(Integer i=1;i<=n;i++)
              {  
                if(i % 3 == 0 && i % 5 == 0) li.add("FizzBuzz");
                else if(i%3==0)li.add("Fizz");
                else if(i%5==0)li.add("Buzz");
                else li.add(i.toString());
            }
            return li;
            }
        }
        
 
 
       
@@ -511,18 +511,18 @@ 
        
 
        image-20211012100409206
        
 
        xtfp这软件上手很容易
        
 
        只需要左右拖拽文件即刻互相传输
        
-
        1.首先在Xshell上利用yum工具下载nginx
        1
        yum install nginx -y
        
+
        1.首先在Xshell上利用yum工具下载nginx
        1
        yum install nginx -y
        
 
-
        2.测试启动nginx
        1
        nginx
        
+
        2.测试启动nginx
        1
        nginx
        
 
-
        3.配置nginx配置文件
        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
        1.进入/etc/nginx文件夹
        cd /etc/nginx
        2.编辑nginx.conf
        vim nginx.conf
        3.添加一个server
        server实例：
        server {
                listen       80 default_server;
                listen       [::]:80 default_server;
                server_name  _;
                
                root         /usr/share/nginx/html;        #修改为root         /data/www;
                
                include /etc/nginx/default.d/*.conf;

                location / {
                }

                error_page 404 /404.html;
                    location = /40x.html {
                }
                
                error_page 500 502 503 504 /50x.html;
                    location = /50x.html {
                }
            }

        
+
        3.配置nginx配置文件
        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
        1.进入/etc/nginx文件夹
        cd /etc/nginx
        2.编辑nginx.conf
        vim nginx.conf
        3.添加一个server
        server实例：
        server {
                listen       80 default_server;
                listen       [::]:80 default_server;
                server_name  _;
                
                root         /usr/share/nginx/html;        #修改为root         /data/www;
                
                include /etc/nginx/default.d/*.conf;

                location / {
                }

                error_page 404 /404.html;
                    location = /40x.html {
                }
                
                error_page 500 502 503 504 /50x.html;
                    location = /50x.html {
                }
            }

        
 
-
        4.贴上我自己的nginx.conf完整配置
        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
        # For more information on configuration, see:
        #   * Official English Documentation: http://nginx.org/en/docs/
        #   * Official Russian Documentation: http://nginx.org/ru/docs/

        user nginx;
        worker_processes auto;
        error_log /var/log/nginx/error.log;
        pid /run/nginx.pid;

        # Load dynamic modules. See /usr/share/nginx/README.dynamic.
        include /usr/share/nginx/modules/*.conf;

        events {
            worker_connections 1024;
        }

        http {
            log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                              '$status $body_bytes_sent "$http_referer" '
                              '"$http_user_agent" "$http_x_forwarded_for"';

            access_log  /var/log/nginx/access.log  main;

            sendfile            on;
            tcp_nopush          on;
            tcp_nodelay         on;
            keepalive_timeout   65;
            types_hash_max_size 2048;

            include             /etc/nginx/mime.types;
            default_type        application/octet-stream;

            # Load modular configuration files from the /etc/nginx/conf.d directory.
            # See http://nginx.org/en/docs/ngx_core_module.html#include
            # for more information.
            include /etc/nginx/conf.d/*.conf;

            server {
                listen       80 default_server;
                listen       [::]:80 default_server;
                server_name  _;
                root         /usr/share/nginx/html;

                # Load configuration files for the default server block.
                include /etc/nginx/default.d/*.conf;

                location / {
                }

                error_page 404 /404.html;
                    location = /40x.html {
                }

                error_page 500 502 503 504 /50x.html;
                    location = /50x.html {
                }
            }
            
            server {
                listen       8001 default_server;
                listen       [::]:8001 default_server;
                server_name  _;
                
                root         /usr/local/java/resources;        #修改为root         /data/www;
                
                include /etc/nginx/default.d/*.conf;

                location / {
                }

                error_page 404 /404.html;
                    location = /40x.html {
                }
                
                error_page 500 502 503 504 /50x.html;
                    location = /50x.html {
                }
            }

        # Settings for a TLS enabled server.
        #
        #    server {
        #        listen       443 ssl http2 default_server;
        #        listen       [::]:443 ssl http2 default_server;
        #        server_name  _;
        #        root         /usr/share/nginx/html;
        #
        #        ssl_certificate "/etc/pki/nginx/server.crt";
        #        ssl_certificate_key "/etc/pki/nginx/private/server.key";
        #        ssl_session_cache shared:SSL:1m;
        #        ssl_session_timeout  10m;
        #        ssl_ciphers HIGH:!aNULL:!MD5;
        #        ssl_prefer_server_ciphers on;
        #
        #        # Load configuration files for the default server block.
        #        include /etc/nginx/default.d/*.conf;
        #
        #        location / {
        #        }
        #
        #        error_page 404 /404.html;
        #            location = /40x.html {
        #        }
        #
        #        error_page 500 502 503 504 /50x.html;
        #            location = /50x.html {
        #        }
        #    }

        }
        
+
        4.贴上我自己的nginx.conf完整配置
        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
        # For more information on configuration, see:
        #   * Official English Documentation: http://nginx.org/en/docs/
        #   * Official Russian Documentation: http://nginx.org/ru/docs/

        user nginx;
        worker_processes auto;
        error_log /var/log/nginx/error.log;
        pid /run/nginx.pid;

        # Load dynamic modules. See /usr/share/nginx/README.dynamic.
        include /usr/share/nginx/modules/*.conf;

        events {
            worker_connections 1024;
        }

        http {
            log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                              '$status $body_bytes_sent "$http_referer" '
                              '"$http_user_agent" "$http_x_forwarded_for"';

            access_log  /var/log/nginx/access.log  main;

            sendfile            on;
            tcp_nopush          on;
            tcp_nodelay         on;
            keepalive_timeout   65;
            types_hash_max_size 2048;

            include             /etc/nginx/mime.types;
            default_type        application/octet-stream;

            # Load modular configuration files from the /etc/nginx/conf.d directory.
            # See http://nginx.org/en/docs/ngx_core_module.html#include
            # for more information.
            include /etc/nginx/conf.d/*.conf;

            server {
                listen       80 default_server;
                listen       [::]:80 default_server;
                server_name  _;
                root         /usr/share/nginx/html;

                # Load configuration files for the default server block.
                include /etc/nginx/default.d/*.conf;

                location / {
                }

                error_page 404 /404.html;
                    location = /40x.html {
                }

                error_page 500 502 503 504 /50x.html;
                    location = /50x.html {
                }
            }
            
            server {
                listen       8001 default_server;
                listen       [::]:8001 default_server;
                server_name  _;
                
                root         /usr/local/java/resources;        #修改为root         /data/www;
                
                include /etc/nginx/default.d/*.conf;

                location / {
                }

                error_page 404 /404.html;
                    location = /40x.html {
                }
                
                error_page 500 502 503 504 /50x.html;
                    location = /50x.html {
                }
            }

        # Settings for a TLS enabled server.
        #
        #    server {
        #        listen       443 ssl http2 default_server;
        #        listen       [::]:443 ssl http2 default_server;
        #        server_name  _;
        #        root         /usr/share/nginx/html;
        #
        #        ssl_certificate "/etc/pki/nginx/server.crt";
        #        ssl_certificate_key "/etc/pki/nginx/private/server.key";
        #        ssl_session_cache shared:SSL:1m;
        #        ssl_session_timeout  10m;
        #        ssl_ciphers HIGH:!aNULL:!MD5;
        #        ssl_prefer_server_ciphers on;
        #
        #        # Load configuration files for the default server block.
        #        include /etc/nginx/default.d/*.conf;
        #
        #        location / {
        #        }
        #
        #        error_page 404 /404.html;
        #            location = /40x.html {
        #        }
        #
        #        error_page 500 502 503 504 /50x.html;
        #            location = /50x.html {
        #        }
        #    }

        }
        
 
 
        其中8001端口为我的静态资源访问端口
        /usr/local/java/resources 为我的静态资源存放位置
        
-
        5.重启nginx
        1
        nginx -s reload
        
+
        5.重启nginx
        1
        nginx -s reload
        
 
-
        6.测试nginx静态资源访问是否成功
        1
        2
        例如：/usr/local/java/resources下有一个index.html文件
        访问则是：www.huhdcc.top:8001/index.html
        
+
        6.测试nginx静态资源访问是否成功
        1
        2
        例如：/usr/local/java/resources下有一个index.html文件
        访问则是：www.huhdcc.top:8001/index.html
        
 
 
        如果还不能使用的话 是服务器没有开放端口问题  
        
 
        进入阿里云
        
diff --git a/sitemap.xml b/sitemap.xml
index dc65946c8..7402d33e8 100644
--- a/sitemap.xml
+++ b/sitemap.xml
@@ -662,14 +662,14 @@
   
   
   
-    http://example.com/tags/%E6%95%B0%E6%8D%AE%E5%BA%93/
+    http://example.com/tags/Thread/
     2023-09-24
     daily
     0.6
   
   
   
-    http://example.com/tags/Thread/
+    http://example.com/tags/%E6%95%B0%E6%8D%AE%E5%BA%93/
     2023-09-24
     daily
     0.6
@@ -731,6 +731,13 @@
     0.6
   
   
+  
+    http://example.com/tags/%E6%89%80%E6%83%B3/
+    2023-09-24
+    daily
+    0.6
+  
+  
   
     http://example.com/tags/nginx/
     2023-09-24
@@ -753,21 +760,21 @@
   
   
   
-    http://example.com/tags/linux/
+    http://example.com/tags/pdf/
     2023-09-24
     daily
     0.6
   
   
   
-    http://example.com/tags/pdf/
+    http://example.com/tags/%E5%B0%8F%E4%BD%9C%E4%B8%9A/
     2023-09-24
     daily
     0.6
   
   
   
-    http://example.com/tags/%E5%B0%8F%E4%BD%9C%E4%B8%9A/
+    http://example.com/tags/linux/
     2023-09-24
     daily
     0.6
@@ -787,6 +794,13 @@
     0.6
   
   
+  
+    http://example.com/tags/%E5%AE%9E%E4%B9%A0/
+    2023-09-24
+    daily
+    0.6
+  
+  
   
     http://example.com/tags/leetcode-507-%E5%AE%8C%E7%BE%8E%E6%95%B0/
     2023-09-24
@@ -864,20 +878,6 @@
     0.6
   
   
-  
-    http://example.com/tags/%E5%AE%9E%E4%B9%A0/
-    2023-09-24
-    daily
-    0.6
-  
-  
-  
-    http://example.com/tags/%E6%89%80%E6%83%B3/
-    2023-09-24
-    daily
-    0.6
-  
-  
 
   
 
diff --git a/tags/java/index.html b/tags/java/index.html
index d52192edf..80de3d282 100644
--- a/tags/java/index.html
+++ b/tags/java/index.html
@@ -475,6 +475,107 @@ 
        Java
 
 
 
+  
+
+  
+
+
+
+
+
+
+
+    
        
+      
        
+        
+
+        
+
+
        
+  
+  © 2020 – 
+  2023
+  
+    
+  
+  fengxiao
+
        
+  
        由 Hexo & NexT.Pisces 强力驱动
+  
        
+
+        
+
+
+
+
+
+
+
+
+      
        
+    
        
+  
      
+
+  
+  
+  
+  
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+  
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
   
 
   
diff --git a/xml/local-search.xml b/xml/local-search.xml
deleted file mode 100644
index d7d0c01cf..000000000
--- a/xml/local-search.xml
+++ /dev/null
@@ -1,45 +0,0 @@
-
-
-  {% if posts %}
-  {% for post in posts.toArray() %}
-  {% if post.indexing == undefined or post.indexing %}
-  
-    {{ post.title }}
-    
-    {{ [url, post.path] | urlJoin | uriencode }}
-    {% if content %}
-    
-    {% endif %}
-    {% if post.categories and post.categories.length>0 %}
-    
-      {% for cate in post.categories.toArray() %}
-      {{ cate.name }}
-      {% endfor %}
-    
-    {% endif %}
-    {% if post.tags and post.tags.length>0 %}
-    
-      {% for tag in post.tags.toArray() %}
-      {{ tag.name }}
-      {% endfor %}
-    
-    {% endif %}
-  
-  {% endif %}
-  {% endfor %}
-  {% endif %}
-  {% if pages %}
-  {% for page in pages.toArray() %}
-  {% if post.indexing == undefined or post.indexing %}
-  
-    {{ page.title }}
-    
-    {{ [url, post.path] | urlJoin | uriencode }}
-    {% if content %}
-    
-    {% endif %}
-  
-  {% endif %}
-  {% endfor %}
-  {% endif %}
-