tonglin0325的个人主页

Ubuntu16.04离线安装python3.8

tonglin0325

1.下载python3.8

1
2
3
cd ~/Download
wget https://www.python.org/ftp/python/3.8.11/Python-3.8.11.tgz

解压

1
2
tar -zxvf Python-3.8.11.tgz

2.创建目录

1
2
3
4
5
cd /usr/local
sudo mkdir python
cd ./python
sudo mkdir python3.8

3.编译安装

1
2
3
4
./configure prefix=/usr/local/python/python3.8 --enable-optimizations
make -j 2
make altinstall  >&1|tee make.log

4.配置环境变量

1
2
3
# python
export PATH=$PATH:/usr/local/python/python3.8/bin

全文 >>

Java排序算法——插入排序

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

class Arrays_Insert{
	private int[] arrays;
	private int curNum;

	public Arrays_Insert(int max) {			//建立一个max长度的空数组
		super();
		arrays = new int[max];
		curNum = 0;
	}
	
	public void insert(int value){					//往空的数组里面增加元素
		arrays[curNum] = value;
		curNum++;
	}
	
	public void display(){									//显示数组
		System.out.println(Arrays.toString(arrays));
	}
	
	private void swap(int one,int two){		//交换
		int temp = arrays[one];
		arrays[one] = arrays[two];
		arrays[two] = temp;
	}
	
	public void InsertSort(){
		int out,in;
		
		for(out=1;out<curNum;out++){						//从第2个开始，和第1个比较
			int temp = arrays[out];
			in = out;　　　　　　　　　　　　　　　　　　　　　　　　//in等于out，比较从in-1开始
			while(in>0 &amp;&amp; arrays[in-1] >= temp){		//如果大于temp，就往右移动
				arrays[in] = arrays[in-1];　　　　　　　　例如：2 3 1 temp=1 -> 2 3 3 temp=1 -> 2 2 3 temp=1 -> 1 2 3 temp=1
				--in;
			}
			arrays[in] = temp;
		}
	}
	
}

public class Insert_Sort {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		int maxSize = 100;
		Arrays_Insert arrays_demo = new Arrays_Insert(maxSize);
		arrays_demo.insert(58);
		arrays_demo.insert(57);
		arrays_demo.insert(56);
		arrays_demo.insert(60);
		arrays_demo.insert(59);
		arrays_demo.display();
		arrays_demo.InsertSort();
		arrays_demo.display();
	}

}

 

冒泡  　　N^2/2比较　　N^2/4交换

选择　　  N^2/2比较　　比冒泡少的交换

插入　　  N^2/4比较　　N^2/4复制

复制是交换的3倍

Java数据结构——优先级队列

tonglin0325
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
class PriorityQueue{
	private int maxSize;			//队列的长度
	private long[] queueArray;		//创建队列的数组的引用
	private int curNum;			//创建当前元素的个数
	
	public PriorityQueue(int s) {		//构造函数
		this.maxSize = s;
		queueArray = new long[maxSize]; //创建对象
		curNum = 0;			//当前的元素的个数是0
	}
	
	public void insert(long item){
		int j;
		if(curNum == 0){		//输入1个数，就是1个数
			queueArray[curNum++] = item;				
		}else{					//左边是rear，右边是front，左边总比右边大
			for(j=curNum-1;j>=0;j--){	//当有2个数时，若第2个数比第1个数大，则交换
				if(item>queueArray[j]){	//j在-1的时候停止，rear=0，front=curNum-1
					queueArray[j+1] = queueArray[j];	// 1 2 -> 1 1 -> 2 1 			
				}else{break;}					// 2 1 3 -> 2 1 1 -> 2 2 1 -> 3 2 1
			}																			
			queueArray[j+1] = item;
			curNum++;
		}

	}
	
	public long remove(){
		return queueArray[--curNum];
	}
	
	public long peekFront(){
		return queueArray[curNum-1];		
	}
	
	public boolean isEmpty(){
		return (curNum==0);
	}
	
	public boolean isFull(){
		return (curNum==maxSize);
	}
	
	
}

public class PriorityQueue_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		PriorityQueue queue_demo = new PriorityQueue(5);
		queue_demo.insert(30);
		queue_demo.insert(10);
		queue_demo.insert(50);
		queue_demo.insert(40);
		queue_demo.insert(20);
		while( !queue_demo.isEmpty()){
			long value = queue_demo.remove();
			System.out.println(value+"、");
		}
	}

}

 

Java数据结构——栈

tonglin0325

 

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
class Stack{
	private int maxSize;			//栈的长度
	private long[] stackArray;		//创建栈的数组的引用
	private int top;			//创建栈顶的引用
	
	public Stack(int s) {			//构造函数
		this.maxSize = s;
		stackArray = new long[maxSize]; //创建对象
		top = -1;			//栈顶等于-1
	}
	
	public void push(long j){		//入栈操作
		stackArray[++top] = j;		//先把top=-1自加成0,再入栈
	}
	
	public long pop(){
		return stackArray[top--];	//弹出当前栈顶的元素后，再自减
	}
	
	public long peek(){
		return stackArray[top];		//返回当前栈顶的元素
	}
	
	public boolean isEmpty(){	//栈顶为-1,即栈为空
		return (top == -1);
	}
	
	public boolean isFull(){		//栈顶为maxSize-1,即栈为满
		return (top == maxSize-1);
	}
	
}

public class Stack_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Stack stack_demo = new Stack(10);
		stack_demo.push(50);
		stack_demo.push(60);
		stack_demo.push(70);
		stack_demo.push(80);
		
		while(!stack_demo.isEmpty()){		//当栈不为空
			long value = stack_demo.pop();
			System.out.print(value+"、");
		}
	}

}

 

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
class Stack_Char{
	private int maxSize;			//栈的长度
	private char[] stackArray;		//创建栈的数组的引用
	private int top;			//创建栈顶的引用
	
	public Stack_Char(int s) {		//构造函数
		this.maxSize = s;
		stackArray = new char[maxSize]; 	//创建对象
		top = -1;				//栈顶等于-1
	}
	
	public void push(char j){		//入栈操作
		stackArray[++top] = j;		//先把top=-1自加成0,再入栈
	}
	
	public char pop(){
		return stackArray[top--];	//弹出当前栈顶的元素后，再自减
	}
	
	public char peek(){
		return stackArray[top];		//返回当前栈顶的元素
	}
	
	public boolean isEmpty(){	//栈顶为-1,即栈为空
		return (top == -1);
	}
	
	public boolean isFull(){		//栈顶为maxSize-1,即栈为满
		return (top == maxSize-1);
	}
	
}

class Reverse{
	private String input;
	private String output;
	
	public Reverse(String input) {		//构造函数
		super();
		this.input = input;
	}
	
	public String DoReverse(){
		int stackSize = input.length();
		Stack_Char stack_demo = new Stack_Char(stackSize);
		
		for(int i=0;i<stackSize;i++){		//把每一个字母入栈
			char ch = input.charAt(i);
			stack_demo.push(ch);
		}
		output = "";				//给output赋值，否则会变成nullXXX
		while( !stack_demo.isEmpty() ){		//把每一个字母出栈
			char ch = stack_demo.pop();
			this.output += ch;
		}
		return this.output;
	}
	
}

public class Word_Reverse {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		String input,output;
			input = "part";	
			System.out.println("输入的字符串："+input);
			Reverse rev = new Reverse(input);
			output = rev.DoReverse();
			System.out.println("输出的字符串："+output);
	}

}

 

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
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

class BracketsChecker{
	private String input;

	public BracketsChecker(String input) {		//构造函数
		super();
		this.input = input;
	}
	
	public void Check(){											
		int stackSize = input.length();
		Stack_Char stack_demo = new Stack_Char(stackSize);
		
		for(int i=0;i<input.length();i++){
			char ch = input.charAt(i);			//遍历每一个字符
			switch(ch){
				case '{':				
				case '[':				
				case '(':				
					stack_demo.push(ch);			//遇到'{[('就入栈
					break;
					
				case '}':
				case ']':
				case ')':
					if( !stack_demo.isEmpty()){
						 char chx = stack_demo.pop();		//遇到'}])'弹出堆栈
						 if(	(chx=='{' &amp;&amp; ch!='}')	||	(chx=='[' &amp;&amp; ch!=']')	||	(chx=='(' &amp;&amp; ch!=')')){
							 System.out.println("Error:右括号不应该是"+ch+" at "+i);
						 }
					}	 
					else{
						 System.out.println("Error:只有右括号"+ch+" at "+i);
					}
					break;
					default:break;
			}
		}
		if( !stack_demo.isEmpty()){				//如果栈不为空的话，证明缺少右括号
			System.out.println("Error:缺少右括号");
		}
	}
}

public class Brackets_demo {

	public static void main(String[] args) throws Exception{
		// TODO 自动生成的方法存根
		String input;
//		input = "{[(]}";
		System.out.print("输入字符串：");
		input = getString();
		System.out.println("输入的字符串为："+input);
		BracketsChecker che = new BracketsChecker(input);
		che.Check();
	}

	public static String getString() throws IOException{
		InputStreamReader isr = new InputStreamReader(System.in); //把输入的字节流转换成字符流
		BufferedReader br = new BufferedReader(isr); //只能接收字符输入流的实例
		String str = br.readLine();				//一次性从缓冲区中读取内容
		return str;
	}
	
}

 

Java数据结构——队列

tonglin0325
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
class Queue{
	private int maxSize;			//队列的长度
	private long[] queueArray;		//创建队列的数组的引用
	private int front;			//创建队头的引用
	private int rear;			//创建队尾的引用
	private int curNum;			//创建当前元素的个数
	
	public Queue(int s) {		//构造函数
		this.maxSize = s;
		queueArray = new long[maxSize]; //创建对象
		front = 0;			//队头等于0
		rear = -1;			//队尾等于-1
		curNum = 0;			//当前的元素的个数是0
	}
	
	public void insert(long j){
		if(rear == maxSize-1){		//如果队尾是队列的最大值-1,则队尾等于-1
			rear = -1;
		}
		queueArray[++rear] = j;		//先自加为0,然后给队尾的元素赋值
		curNum++;			//当前的元素的个数加1
	}
	
	public long remove(){
		long temp = queueArray[front++];	//取得队头的元素，然后自加
		if(front == maxSize){
			front =0;
		}
		curNum--;		//当前的元素的个数减1
		return temp;
	}
	
	public long peekFront(){
		return queueArray[front];		
	}
	
	public boolean isEmpty(){
		return (curNum==0);
	}
	
	public boolean isFull(){
		return (curNum==maxSize);
	}
	
	public int Size(){	//返回当前队列元素的个数
		return curNum;
	}
	
}

public class Queue_demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Queue queue_demo = new Queue(5);
		queue_demo.insert(50);
		queue_demo.insert(60);
		queue_demo.insert(70);
		queue_demo.insert(80);
		queue_demo.remove();
		queue_demo.insert(50);
		
		while( !queue_demo.isEmpty()){
			long value = queue_demo.remove();
			System.out.print(value+"、");
		}
	}
}

 

Java排序算法——冒泡排序

tonglin0325

 

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

import java.util.Arrays;

class ArraysBubble {
    private int[] arrays;
    private int curNum;

    public ArraysBubble(int max) {            //建立一个max长度的空数组
        super();
        arrays = new int[max];
        curNum = 0;
    }

    public void insert(int value) {                    //往空的数组里面增加元素
        arrays[curNum] = value;
        curNum++;
    }

    public void display() {                                    //显示数组
        System.out.println(Arrays.toString(arrays));
    }

    private void swap(int one, int two) {        //交换
        int temp = arrays[one];
        arrays[one] = arrays[two];
        arrays[two] = temp;
    }

    public void BubbleSort() {
        for (int i = 0; i < curNum; i++) {
            for (int j = i + 1; j < curNum; j++) {
                if (arrays[j] < arrays[i]) {
                    swap(i, j);
                }
            }
        }
    }

//    public void BubbleSort() {
//        int out, in;
//        for (out = curNum - 1; out > 0; out--) {        //curNum自加为下一次插入做做准备，在此应减去1
//            for (in = 0; in < out; in++) {                        //从最后一个数开始，和前面每一个数比较，把最大的移到最后
//                if (arrays[in] > arrays[out]) {
//                    swap(in, in + 1);
//                }
//            }
//        }
//
//
//    }
}

public class BubbleSort {

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        int maxSize = 100;
        ArraysBubble arrays_demo = new ArraysBubble(maxSize);
        arrays_demo.insert(58);
        arrays_demo.insert(57);
        arrays_demo.insert(56);
        arrays_demo.insert(60);
        arrays_demo.insert(59);
        arrays_demo.display();
        arrays_demo.BubbleSort();
        arrays_demo.display();
    }

}

 输出

1
2
3
[58, 57, 56, 60, 59, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[56, 57, 58, 59, 60, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

 

Java排序算法——选择排序

tonglin0325

 

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

class Arrays_Select{
	private int[] arrays;
	private int curNum;

	public Arrays_Select(int max) {			//建立一个max长度的空数组
		super();
		arrays = new int[max];
		curNum = 0;
	}
	
	public void insert(int value){					//往空的数组里面增加元素
		arrays[curNum] = value;
		curNum++;
	}
	
	public void display(){									//显示数组
		System.out.println(Arrays.toString(arrays));
	}
	
	private void swap(int one,int two){		//交换
		int temp = arrays[one];
		arrays[one] = arrays[two];
		arrays[two] = temp;
	}
	
	public void SelectSort(){
		int out,in,min;
		
		for(out=0;out<curNum-1;out++){
			min = out;					//out从0开始，设第一个为最小
			for(in=out+1;in<curNum;in++){　　　　　　　　　　　//搜索之后的元素，从1开始，如果有比第0个小，交换
				if(arrays[in]<arrays[min]){　　　　　　　//都是找到未排序中最小的数
					min = in;			//找到最小数的标号
				}
				swap(out,min);	//交换
			}
		}
	}
}

public class Select_Sort {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		int maxSize = 100;
		Arrays_Select arrays_demo = new Arrays_Select(maxSize);
		arrays_demo.insert(58);
		arrays_demo.insert(57);
		arrays_demo.insert(56);
		arrays_demo.insert(60);
		arrays_demo.insert(59);
		arrays_demo.display();
		arrays_demo.SelectSort();
		arrays_demo.display();
	}

}

 

Java查找算法——二分查找

tonglin0325

 

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
import java.lang.reflect.Array;
import java.nio.Buffer;
import java.util.Arrays;
import java.util.Random;

class BinarySearch_Find{
	private int[] temp;
	private int searchKey;
	private int lowerBound = 0;			//下界
	private int upperBound ;				//上界
	private int curNum;
	
	public int[] getTemp() {
		return temp;
	}

	public void setTemp(int[] temp) {
		this.temp = temp;
	}

	public BinarySearch_Find(int[] temp) {//构造函数
		this.temp = temp;
		this.upperBound = temp.length-1;
	}

	public int find(int searchKey){
		this.searchKey = searchKey;
		while(true){
			curNum = (lowerBound+upperBound)/2;
			if(temp[curNum]==this.searchKey){
				return curNum;							//find
			}
			else if(lowerBound>upperBound){
				return -1;										//没有find
			}
			else{
				if(temp[curNum]<this.searchKey){
					lowerBound = curNum+1;
				}
				else{
					upperBound = curNum-1;
				}
			}
		}
	}
	
}

class RandomArrays{					//生成随机数组，有Num个
	
	public int[] getArrays(int Num){
		int[] Arrays = new int[Num];
		Random r = new Random();
		
		for(int i=0;i<Num;i++){
			Arrays[i] = r.nextInt(1000);
//			System.out.print(Arrays[i]+"、");
		}
		return Arrays;
	}
}

class OrderedArrays{					//生成有序数组，从0开始到Num
	
	public int[] getArrays(int Num){
		int[] Arrays = new int[Num];
		
		for(int i=0;i<Num;i++){
			Arrays[i] = i;
//			System.out.print(Arrays[i]+"、");
		}
		return Arrays;
	}
}

public class Binary_Search {
	
	public static void main(String[] args) {
		// TODO 自动生成的方法存根

//		RandomArrays array_demo = new RandomArrays();
//		BinarySearch_Find arrays = new BinarySearch_Find(array_demo.getArrays(100));
		
		OrderedArrays array_demo = new OrderedArrays();
		BinarySearch_Find arrays = new BinarySearch_Find(array_demo.getArrays(100));
		System.out.println(Arrays.toString(arrays.getTemp()));
		System.out.println(arrays.find(1000));
		
	}
}

 

SpringBoot学习笔记——filter和interceptor

tonglin0325

Servlet API中提供了一个Filter接口，Filter接口在javax.servlet.Filter包下面。开发web应用时，如果编写的Java类实现了这个接口，则把这个java类称之为过滤器Filter。

通过Filter技术，开发人员可以实现用户在访问某个目标资源之前，对访问的请求和响应进行拦截，如下所示：

WEB开发人员通过Filter技术，对web服务器管理的所有web资源：例如Jsp, Servlet, 静态图片文件或静态 html 文件等进行拦截，从而实现一些特殊的功能。

例如实现URL级别的权限访问控制、乱码问题、过滤敏感词汇、压缩响应信息等一些高级功能。

filter在开发中的常见应用：
     　　 1.filter可以目标资源执行之前，进行权限检查，检查用户有无权限，如有权限则放行，如没有，则拒绝访问
     　　 2.filter可以放行之前，对request和response进行预处理，从而实现一些全局性的设置。
     　　 3.filter在放行之后，可以捕获到目标资源的输出，从而对输出作出类似于压缩这样的设置 

在filter中可以对request请求进行拦截，并对response进行修改

全文 >>

tonglin0325

标签

标签云

AWS Airbnb Android CDH Doris ELK Flink Git Grafana HAProxy HBase Hadoop Hive Hudi InfluxDB JDBC JMeter JVM Java LaTex Linkedin Linux ML ML Infra MPP Maven MySQL Nexus OpenTSDB Paper Play Prometheus Python React Redis RocksDB Scala Solr Spark SpringBoot SpringMVC Thrift YARN antlr arthas avro cassandra clickhouse confluent docker filebeat flume golang google gradle hexo impala jenkins k8s kafka kerberos kudu ldap mac mongo mybatis nginx nlp open-falcon openwrt parquet presto ranger rocketmq scyllaDB twitter zookeeper 刷题 前端 图存储及计算 多线程 广告系统 开发工具 数据结构 杂谈 算法 系统设计 计算机基础 设计模式

文章归档

最近文章