logo头像
Snippet 博客主题

000_temp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
icql-code
icql-archive
icql-api
icql-java

icql-script
icql-docker
icql-jenkins
icql-static


Asciidoc 2 pdf
## 下载工具:
* AsciidocFX(https://github.com/asciidocfx/AsciidocFX)
* wkhtmltopdf (https://github.com/wkhtmltopdf/wkhtmltopdf)

## 使用步骤
* 利用AsciidocFX打开仓库目录
* 双击打开book.asciidoc
* 点击右上角转换为html
* 将生成的"html文件"和"images文件夹"复制到 wkhtmltopdf 软件的 bin 目录下
* 执行命令 wkhtmltopdf book.html book.pdf 即可转换



chown 1000 -R 文件夹目录给所有用户

jenkins下载插件慢
1)系统管理-插件管理-升级地址
https://mirrors.tuna.tsinghua.edu.cn/jenkins/updates/update-center.json

2)修改var/jenkins_home\updates\default.json

updates.jenkins-ci.org/download 替换为 mirrors.tuna.tsinghua.edu.cn/jenkins




## mybatis打印sql
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl


## 大话设计模式笔记

通过面向对象的3大特征(封装,继承,多态)将程序的耦合度降低,实现 易维护/易扩展/易复用

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


## git搭建hexo博客
``` csharp
安装feed插件
hexo博客有一个专门生成RSS xml文件的插件hexo-generator-feed
我们来安装它

$ npm install hexo-generator-feed
added 3 packages in 30.155s
看到added 3 packages说明安装成功了。

启用插件
在博客工程文件根目录下_config.yml文件中添加如下内容

# Extensions
plugins:
hexo-generator-feed
#Feed Atom
feed:
type: atom
path: atom.xml
limit: 20




* 系统环境配置
* 安装Node.js(http://nodejs.cn/download/)
* 安装Git(https://git-scm.com/download/)
* 安装Hexo
* 桌面右键 Git Bash Here
* 输入:npm install -g hexo-cli (成功后返回的提示最后面会出现Start blogging with Hexo!)
* 手动新建目录作为博客主文件夹(例如e:/Github/myblog)
* 输入命令进入myblog文件夹或者手动进入右键Git Bash Here
* 输入:hexo init (初始化Hexo)
* 输入:npm install (系统会可以根据package.json文件中dependencies的配置安装所有依赖包)
* 输入:npm install hexo-fs --save (更新hexo-fs库,避免 (node:2416) [DEP0061] DeprecationWarning: fs.SyncWriteStream is deprecated.)
* 输入:hexo3.0 必须输入 npm install hexo-deployer-git --save
* 输入:hexo g (# 或者hexo generate)
* 输入:hexo s (# 或者hexo server,可以在http://localhost:4000/ 查看默认博客)

架构演变

  • 单机–分布式

  • 集群和分布式:集群是部署同一业务到多台机器,分布式是拆分业务部署到多台服务器

  • tps:Transactions Per Second(每秒传输的事物处理个数)

  • qps:

  • OSI分层模型(已过时):

    • 物理层
    • 链路层
    • 网络层ip
    • 传输层tcp,udp
    • 会话层
    • 表示层
    • 应用层http/https/ftp/pop3等
  • TCP/IP分层模型

    • 物理层
    • 链路层
    • 网络层
    • 传输层
    • 应用层
  • TCP

    • 3次握手协议
    • 4次挥手协议
    • 滑动窗口协议
  • UDP

  • http/https原理

  • 全双工、半双工

  • bio/nio/aio

  • 序列化和反序列化

    • serialVersionUID
    • 默认是java二进制序列化,需要实现Serialize接口
    • json
    • xml
    • transient
    • 浅度克隆/深度克隆:引用类型字段的区别
  • 1.文本文件(ASCII码文件)和二进制文件

    • 存储在磁盘上都是二进制文件
    • 文本文件是某种特殊的二进制文件,只是打开程序用的解码方式不同
    • 常用文本文件编码(基于字符)
      • ASCII 码表:用1个字节表示,2^7=128种符号,最高位是符号位,只有英文字母,英文符号,阿拉伯数字等
      • GB2312 码表:兼容ASCII码表;英文1个字节,中文2个字节,判断符号位为+则是英文字节,第1个字节符号位为-第2个字节符号位为-则这2个字节加起来是中文字符;(2^7-1)*(2^7-1)=16129种符号
      • GBK 码表:兼容GB2312码表,英文1个字节,中文2个字节;判断符号位为+则是英文字节,第1个字节符号位为-第2个字节符号位不限则这2个字节加起来是中文字符;(2^7-1)*(2^8)=32512种符号
      • Big5 码表:台湾
      • Unicode 国际码表;中英文全2个字节
      • UTF8 国际码表;英文1个,中文3个字节

数据结构与算法

数据结构的基本概念

  • 数据:描述客观事物的符号,是计算机中可以操作的对象,是能被计算机识别和处理的符号集合
  • 数据元素:是组成数据的、有一定意义的基本单位,也被称为记录
  • 数据项:一个数据元素可以由若干个数据项组成,数据项是数据不可分割的最小单位
  • 数据对象:是性质相同的euuj元素的集合,是数据的子集
  • 数据结构:是相互关系之间存在的一种或多种特定关系的数据元素的集合
  • ADT:abstract data type

数据结构分类

  • 1、逻辑结构:数据对象中的数据元素之间的相互关系
    • 集合结构:各个数据元素是平等的
    • 线性结构:1对1
    • 树形结构:1对多
    • 图形结构:多对多
  • 2、物理结构:数据的逻辑结构在计算机中的存储形式
    • 顺序存储结构:把数据元素存放在地址连续的存储单元里
    • 链式存储结构:把数据元素存放在任意的存储单元里,这些存储单元可以是连续的,也可以是不连续的

线性表

  • 1、定义:0个或多个数据元素的有限序列
  • 2、线性表特点:
    • 1)是一个序列,元素之间是有顺序的
    • 2)第一个元素无前驱,最后一个元素无后继
    • 3)中间的元素有且只有一个直接前驱和一个直接后继
  • 3、线性表的顺序存储:顺序表,利用数组实现
    • 读取数据速度快O(1)
    • 插入和删除速度较慢,需要移动大量元素,均为 O(n)
  • 4、线性表的链式存储:链表,采用Node结构存储各个元素,灵活,不需要连续的内存
    • 1)静态链表:类似于数组方法实现的,是顺序的存储结构,在物理地址上是连续的,便于在没有指针类型的高级程序设计语言中使用链表结构,数组存储一个Node对象(数据 | next节点的数组索引)
    • 2)动态链表:直接申请内存,所以在链表的长度上没有限制
      • (1)单链表:头节点-节点(数据 | next节点指针)-。。。-尾节点(数据 | null)
      • (2)双向链表:头节点-节点(prev节点指针 | 数据 | next节点指针)-。。。-尾节点(数据 | null)
      • (3)循环链表:头节点-节点(数据 | next节点指针)-。。。-尾节点(数据 | 头节点指针)
    • 3)特点:每次读取数据都需要遍历一遍,O(n),插入和删除不需要移动元素,单个插入为O(n),批量插入时只需要先找到需要插入的Node(只需遍历1次),再处理数据

线性表:栈

  • 1、定义:限定仅在表尾进行插入和删除的线性表,FILO(first in last out)
  • 2、主要功能:入栈push,出栈pop
  • 3、栈的顺序存储、链式存储:和通用线性表一样
  • 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
    34
    35
    @Test
    public void test() {
    Object[] values = new Object[3];
    values[0] = 2;
    values[1] = 5;
    values[2] = "/";
    Stack<Integer> stack = new SingleLinkedStack<>();
    for (int i = 0; i < values.length; i++) {
    if (values[i] instanceof String) {
    Integer pop1 = stack.pop();
    Integer pop2 = stack.pop();
    caculate(values[i].toString(), pop2, pop1);
    continue;
    }
    stack.push((Integer) values[i]);
    }
    }
    private void caculate(String mark, Integer num1, Integer num2) {
    Integer result = null;
    switch (mark) {
    case "+":
    result = num1 + num2;
    break;
    case "-":
    result = num1 - num2;
    break;
    case "*":
    result = num1 * num2;
    break;
    case "/":
    result = num1 / num2;
    break;
    }
    System.out.println(result);
    }

线性表:队列

  • 1、定义:只允许在一端(队尾)进行插入操作,在另一端(队头)进行删除操作的线性表,FIFO(first in first out)
  • 2、主要功能:入队,出队

线性表:串

  • 1、定义:由0个或多个字符组成的有限序列
  • 2、字符串的一些常用操作
  • 3、匹配算法(见algorithm文)
    • 1)基本模式匹配算法
    • 2)KMP模式匹配算法

  • 1、定义:树是n个结点的有限集
  • 2、基本概念:
    • 1)结点的度:结点的子项个数
    • 2)树的度:结点度中的最大值
    • 3)祖先
    • 4)双亲(父结点)
    • 5)孩子
    • 6)树的深度:树的最大层次
    • 7)森林:m个互不相交的树的集合
  • 3、特点:
    • 1)根结点:无双亲,唯一
    • 2)叶结点:无孩子
    • 3)中间结点:一个双亲,多个孩子
  • 4、树的存储结构
    • 1)双亲表示法:数据项(data | parent)
      • (1)求结点的双亲:直接可以找到
      • (2)求结点的孩子:遍历整个结构
    • 2)孩子表示法:n个结点的树用1个顺序数组和n个单链表来存储。顺序数组存储所有结点,数据结构(结点数据data | firstchild指针),n个单链表数据项结构(结点数据data | next结点指针)
      • 1)求结点的双亲:遍历整个结构
      • 2)求结点的孩子:直接可以得到
    • 3)双亲孩子表示法:结合双亲表示法和孩子表示法。在孩子表示法的基础上,在数组的数据结构增加 parent指针
      • 案例:数据库表设计,菜单(id,parentid, childernid)
    • 4)孩子兄弟表示法:任意一颗树,它的结点的第一个孩子如果存在就是的,它的右兄弟如果存在也是唯一的。因此,我们设置两个指针,分别指向该结点的第一个孩子和此结点的右兄弟

树:二叉树

  • 1、定义:每个结点最多有两棵子树,所以二叉树中不存在度大于2的结点;左右子树是有顺序的,即使只有一棵子树
  • 2、特殊二叉树:
    • 1)满二叉树:除了叶子之外所有子树都有左右孩子,且叶子均在同一层次上
    • 2)完全二叉树:一棵二叉树,除了最后一层之外都是完全填充的,并且最后一层的叶子结点要么都有要么只有左边
  • 3、二叉树的性质:
    • 1)第i层上最多有 2^(i-1)个结点
    • 2)深度为k的二叉树最多有(2^k - 1)个结点
    • 3)终端结点数为n0,度数为2的结点数n2,则 n0 = n2 + 1
    • 4)具有n个节点的完全二叉树深度为 log2 n +1
    • 5)具有n个节点的完全二叉树深度为 log2 n +1,1 <= i <= n
      • (1)i=1,结点i是二叉树的根,无双亲
      • (2)i>1,其双亲是结点 i/2
      • (3)i>n/2,则结点i无左孩子,否则左孩子是结点 2i
      • (4)2i+1>n,则结点i无右孩子,否则其右孩子是结点 2i+1
  • 4、二叉树的存储结构:
    • 1)顺序存储:从根开始,按照每层从左到右依次存储,普通的二叉树若结点不是2个孩子,则以null代替,但这样比较浪费空间,所以一般只有完全二叉树使用顺序存储(数组)
    • 2)二叉链表:结点数据结构(data数据项 | lchild | rchild)
      • 线索二叉树:利用二叉链表中的空指针域,存放指向结点在某种遍历次序下的前驱和后继结点的指针(这种附加的指针称为”线索”)
        • 数据结构(data数据项 | lchild | ltag | rchild | rtag)
        • ltag为0表示左孩子,为1表示前驱;rtag为0表示右孩子,为1表示后继
    • 3)三叉链表:结点数据结构(data数据项 | parent | lchild | rchild)
  • 5、遍历二叉树
    • 1)前序遍历:从根结点开始,先一直从左孩子向下遍历,再右孩子向上遍历,再左孩子向下遍历,依次进行,类似斜着遍历
    • 2)中序遍历:从最后一层开始,先左孩子,再双亲结点,再右孩子,依次遍历
    • 3)后序遍历:从最后一层开始,先左孩子,再右孩子,再双亲结点,依次遍历
    • 4)层序遍历:从根节点开始,每层从左到右依次遍历

  • 1、定义:实现多对多的有限顶点之间关系的结构

算法的基本概念

  • 算法:是解决特点问题求解步骤的描述,在计算机中表现为指令的有限序列。并且每条指令标识一个或多个操作
  • 算法的特征
    • 1)输入
    • 2)输出
    • 3)有穷性
    • 4)确定性
    • 5)可行性
  • 算法时间复杂度:语句总的执行次数 T(n) 是关于问题规模 n 的函数,进而分析 T(n) 随 n 的变化情况并确定 T(n) 的数量级。算法的时间复杂度,也是算法的时间量度,记作:T(n)=O(f(n))。表示随问题的规模 n 的增大,算法执行的时间增长率和 f(n) 的增长率相同,称作算法的渐进时间复杂度,简称时间复杂度。其中 f(n) 是问题规模 n 的某个函数。
    • 简单来讲就是代码段中 所有循环体的执行次数与循环体的变量之间的函数关系
    • 大O记法:T(n)=O(f(n)),O(1)常数阶,O(n)线性阶,O(n^2)平方阶
    • 推导大O阶的方法:
      • 1)用常数 1 取代运行时间中的所有加法常数
      • 2)在修改后的运行次数函数中,只保留最高阶项
      • 3)如果最高阶项存在且不是1,则去除与这个项相乘的常数
      • 4)分支结构和普通语句都是 O(1),因此分析算法的复杂度,关键是要分析循环结构的运行情况
  • 常见的算法时间复杂度耗费时间排序:
    • O(1)常数阶 < O(logn)对数阶 > < O(n)线性阶 < O(nlogn) < O(n^2)平方阶 < O(n^3)立方阶 < O(n^n)指数阶
  • 最坏情况和平均情况:一般默认是指最坏时间复杂度
  • 算法的空间复杂度:以空间换取时间,例如用一个数组存储很多年份,直接就可以找出闰年
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    //1、常数阶,f(n) = 3,O(3) => O(1)
    int sum = 0, n = 0;//执行 1 次
    sum = (1 + n) * n / 2;//执行 1 次
    System.out.println(sum);//执行 1 次

    //2、线性阶,f(n) = c*n,O(c*n) => O(n)
    for (int i = 0; i < n; i++) {
    //O(1)的语句;
    }

    //3、对数阶,10^f(n) = n,f(n) = lgn,O(lgn)
    int count = 1;
    while (count < n) {
    count = count * 10;
    //O(1)语句;
    }

    //4、平方阶,f(n) = n*n,O(n^2)
    for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
    //O(1)语句;
    }
    }

查找算法 work.icql.java.algorithm.search包

  • 顺序查找
  • 有序表查找
    • 二分查找
    • 插值查找
    • 斐波那契查找
  • 索引查找
  • AVL树(平衡二叉树),B树(多路查找树),红黑树

排序算法

  • 应用:哈夫曼树(最优二叉树)
    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
    //冒泡排序
    public class Test{
    public static void main(String args[]){
    int[] data = new int[]{1,3,2,6,10,0,5,8};
    for(int x = 0;x < data.length;x++){
    for(int y = 0;y<data.length - 1;y++){
    if(data[y] > data[y+1]){
    int temp = data[y];
    data[y] = data[y+1];
    data[y+1] = temp;
    }
    }
    }

    for(int i = 0;i<data.length;i++){
    System.out.println(data[i]);
    }
    }
    }

    //快速排序
    //选择第一个数为p,小于p的数放在左边,大于p的数放在右边。
    //递归的将p左边和右边的数都按照第一步进行,直到不能递归
    public void quickSort(int[] numbers, int start, int end) {
    if (start > end) {
    return;
    }

    int base = numbers[start]; // 选定的基准值(第一个数值作为基准值)
    int temp; // 记录临时中间值
    int i = start;
    int j = end;
    while (i <= j) {
    while ((numbers[i] < base) && (i < end))
    i++;
    while ((numbers[j] > base) && (j > start))
    j--;

    if (i <= j) {
    temp = numbers[i];
    numbers[i] = numbers[j];
    numbers[j] = temp;
    i++;
    j--;
    }
    }

    if (start < j)
    quickSort(numbers, start, j);
    if (end > i)
    quickSort(numbers, i, end);
    }
微信打赏

赞赏是不耍流氓的鼓励