ini复制代码public void sort(Comparable[] data) {
    for (int i = 1; i < data.length; i++) {
        for (int j = i; j - 1 > 0 && less(data[j], data[j - 1]); j--) {
            exch(data, j, j - 1);
        }
    }
}

kotlin复制代码/**
 * 将data数组数据分成两部分，并返回划分位置j，使得左边部分小于data[j],右边部分大于data[j]
 * @param data
 * @param lo
 * @param hi
 * @return
 */
private int partition(Comparable[] data, int lo, int hi) {
    // 将第一个元素选为标定点
    Comparable pivot = data[lo];
    // 使用双指针遍历数组，使得数组左边部分小于pivot，右边部分大于pivot
    // i 表示 较小部分的最后一个元素（左侧）；j 表示  较大部分的第一个元素（右侧）。
    // 初始值设为lo和hi+1，即可表示未开始划分
    int i = lo;
    int j = hi + 1;
    while (true) {
        // 从左侧开始寻找第一个比pivot大或等于的元素
        while (less(data[++i], pivot)) {
            // 已遍历到右侧
            if (i >= hi) {
                break;
            }
        }
        // 从右侧开始寻找第一个比pivot小的元素
        while (less(pivot, data[--j])) {
            // 已遍历到右侧
            if (j <= lo) {
                break;
            }
        }
        if (j <= i) {
            break;
        }
        exch(data, i, j);
    }
    exch(data, lo, j);
    return j;
}

java复制代码/**
 * 对数组data[lo,hi]部分进行快速排序
 * @param data
 * @param lo
 * @param hi
 */
private void quickSort(Comparable[] data, int lo, int hi) {
    // 不需要再排了
    if (lo >= hi) {
        return;
    }
    int partition = partition(data, lo, hi);
    quickSort(data, lo, partition - 1);
    quickSort(data, partition + 1, hi);
}

ini复制代码/**
 * 归并data[lo, hi]数组，data[lo,mid]有序数据，data[mid+1,hi]有序
 * @param data 原始数据
 * @param lo
 * @param mid
 * @param hi
 */
private void merge(Comparable[] data, int lo, int mid, int hi) {
    for (int k = lo; k <= hi; k++) {
        aux[k] = data[k];
    }
    int i = lo;
    int j = mid + 1;
    for (int k = lo; k <= hi; k++) {
        if (i > mid) {
            data[k] = aux[j++];
        } else if (j > hi) {
            data[k] = aux[i++];
        } else if (less(aux[i], aux[j])) {
            data[k] = aux[i++];
        } else {
            data[k] = aux[j++];
        }
    }
}

scss复制代码/**
 * 将数组data[lo, hi]排序(递归方式)
 * @param data
 * @param lo
 * @param hi
 */
private void merge(Comparable[] data, int lo, int hi) {
    // 表示单个元素已有序
    if (lo >= hi) {
        return;
    }
    int mid = lo + (hi - lo) / 2;
    // 将data[lo,mid]部分排序
    merge(data, lo, mid);
    // 将data[mid+1, hi]部分排序
    merge(data, mid + 1, hi);
    // 将排好序部部分归并
    merge(data, lo, mid, hi);
}

css复制代码/**
 * 非递归的方式
 * @param data
 */
private void mergeBU(Comparable[] data) {
    for (int i = 1; i < data.length; i = i * 2) {
        for (int j = 0; j < data.length - i; j = j + i * 2) {
            merge(data, j, j + i - 1, Math.min(j + 2 * i - 1, data.length - 1));
        }
    }
}

ini复制代码/**
 * 元素上升，调整成堆
 * @param data
 * @param k
 */
private void swim(Comparable[] data, int k) {
    while (k > 0 && less(data[(k - 1) / 2], data[k])) {
        exch(data, (k - 1) / 2, k);
        k = (k - 1) / 2;
    }
}

/**
 * 元素下层，调整成堆
 * @param data
 * @param k
 * @param length
 */
private void sink(Comparable[] data, int k, int length) {
    while ((k + 1) * 2 <= length) {
        int j = (k + 1) * 2 - 1;
        if (length > j + 1 && less(data[j],data[j + 1])) {
            j++;
        }
        // 节点的最大子节点小于当前节点，则不需要
        if (less(data[j], data[k])) {
            break;
        }
        exch(data, k, j);
        k = j;
    }
}

scss复制代码public void sort(Comparable[] data) {
    // 将数据组装成堆
    for (int i = data.length / 2 - 1; i >= 0; i--) {
        sink(data, i, data.length);
    }
    for (int i = data.length - 1; i > 0; i--) {
        // 将堆顶元素与最后一个元素交换
        exch(data, 0, i);
        sink(data, 0, i);
    }
}

shell复制代码  > unzip rocketmq-all-4.9.2-source-release.zip
  > cd rocketmq-all-4.9.2/
  > mvn -Prelease-all -DskipTests clean install -U
  > cd distribution/target/rocketmq-4.9.2/rocketmq-4.9.2

bash复制代码nohup sh bin/mqnamesrv &

bash复制代码nohup sh bin/mqnamesrv  >  ~/logs/rocketmq/logs/namesrv.log &

bash复制代码nohup sh bin/mqshutdown namesrv

ini复制代码brokerIP1=XX.XXX.XXX.XXX

bash复制代码nohup sh bin/mqbroker -c conf/broker.conf  -n xxx.xx.xx.xx:9876 autoCreateTopicEnable=true  >  ~/logs/rocketmqlogs/broker.log &

bash复制代码nohup sh bin/mqshutdown broker

bash复制代码export NAMESRV_ADDR=localhost:9876
​
sh bin/tools.sh org.apache.rocketmq.example.quickstart.Producer

bash复制代码sh bin/tools.sh org.apache.rocketmq.example.quickstart.Consumer

ini复制代码
# vim /etc/my.cnf

[mysqld]  

server_id=51           //server_id

log-bin=master51        //日志名

:wq

ini复制代码
# vim /etc/my.cnf

[mysqld]  

server_id=52          //server_id

:wq

ini复制代码
数据库管理员root本机登录，指定主服务器信息，其中日志文件名和偏移量 写allbak.sql文件记录的。

# mysql -uroot –p密码     //管理员root 本机登录

mysql> show slave status;  //查看状态信息，还不是从服务器

Empty set (0.00 sec)

mysql> change   master  to //指定主服务器   

-> master_host=“192.168.4.51”,                 //主服务器ip地址 

-> master_user=“repluser”,                        //主服务器授权用户 

-> master_password=“123qqq…A”,            //主服务器授权用户密码   

-> master_log_file=“master51-bin.000001”,//主服务器日志文件   

-> master_log_pos=441;                  //主服务器日志偏移量

C复制代码main (){
extrn a,b,c;
putchar (a); putchar (b); putchar (c); putchar ('!*n');
}
a 'hell';
b 'o, w';
c 'orld';

c复制代码#include "stdio.h"

int main(){
    printf("Hello World");
    return 0;
}

java复制代码public class HelloWorld {  
    
  public static void main(String[] args){   
  	System.out.println("Hello,World");  
  }  
    
}

html复制代码<!DOCTYPE html>  
<html>
<title>我的第一个网页</title>  
<body>  
    <p>Hello World</p>  
</body>  
</html>

javascript复制代码<script>
	console.log('Hello World'); # 浏览器控制台打印

	alert("Hello World");	# 浏览器对话框形式显示
</script>

python复制代码print "Hello World"	 # python 2.x

print("Hello World") # python 3.x

sql复制代码mysql> select 'Hello World';
+-------------+
| Hello World |
+-------------+
| Hello World |
+-------------+
1 row in set (0.03 sec)

java复制代码/* 主要使用中类是: net.sourceforge.pinyin4j.PinyinHelper和net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat

 PinyinHelper对象处理汉语转拼音
 HanyuPinyinOutputFormat对象用于处理汉语拼音输出格式

 PinyinHelper对象相关方法
	toHanyuPinyinStringArray(char ch)
	toHanyuPinyinStringArray(char ch, HanyuPinyinOutputFormat outputFormat)

 HanyuPinyinOutputFormat对象
    setCaseType()方法  设置拼音大小写
   	    HanyuPinyinCaseType.UPPERCASE：大写
    	HanyuPinyinCaseType.LOWERCASE：小写

	setVCharType()方法  设置字符V的显示方式
        HanyuPinyinVCharType.WITH_U_AND_COLON：显示为u:(默认)
        HanyuPinyinVCharType.WITH_V ：显示为v
        HanyuPinyinVCharType.WITH_U_UNICODE：显示为ü
        
	setToneType()方法
        HanyuPinyinToneType.WITH_TONE_NUMBER：设置数字声调(默认)
        HanyuPinyinToneType.WITHOUT_TONE：设置不显示声调
        HanyuPinyinToneType.WITH_TONE_MARK：设置显示声调，前提必须设置V如何显示
*/

xml复制代码    <dependency>
      <groupId>com.belerweb</groupId>
      <artifactId>pinyin4j</artifactId>
      <version>2.5.1</version>
    </dependency>

java复制代码@Slf4j
public class PinYinUtils {


    public static void main(String[] args) {
        PinYinUtils pinYinUtils = new PinYinUtils();
        String str = "唐代诗人李白-libai";
        System.out.println(pinYinUtils.toHanyuPinyin(str));
        System.out.println(pinYinUtils.getFirstLetter(str));
    }
    
    /**
     * 汉字转拼音
     */
    public String toHanyuPinyin(String hanzi) {
        char[] chars = hanzi.trim().toCharArray();
        String hanyupinyin = "";

        //输出格式设置
        HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();
        /**
         * 输出大小写设置
         *
         * LOWERCASE:输出小写
         * UPPERCASE:输出大写
         */
        defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);

        /**
         * 输出音标设置
         *
         * WITH_TONE_MARK:直接用音标符（必须设置WITH_U_UNICODE，否则会抛出异常）
         * WITH_TONE_NUMBER：1-4数字表示音标
         * WITHOUT_TONE：没有音标
         */
//        defaultFormat.setToneType(HanyuPinyinToneType.WITH_TONE_MARK); //  必须设置WITH_U_UNICODE，否则会抛出异常
        defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);

        /**
         * 特殊音标ü设置
         *
         * WITH_V：用v表示ü
         * WITH_U_AND_COLON：用"u:"表示ü
         * WITH_U_UNICODE：直接用ü
         */
//        defaultFormat.setVCharType(HanyuPinyinVCharType.WITH_U_UNICODE);
        defaultFormat.setVCharType(HanyuPinyinVCharType.WITH_V);

        // 中文的正则表达式
        String hanziRegex = "[\\u4E00-\\u9FA5]+";

        try {
            for (int i = 0; i < chars.length; i++) {
                // 判断为中文,则转换为汉语拼音
                if (String.valueOf(chars[i]).matches(hanziRegex)) {
                    hanyupinyin += PinyinHelper
                            .toHanyuPinyinStringArray(chars[i], defaultFormat)[0];
                } else {
                    // 不为中文,则不转换
                    hanyupinyin += chars[i];
                }
            }
        } catch (BadHanyuPinyinOutputFormatCombination e) {
            log.error("字符不能转成汉语拼音");
        }

        return hanyupinyin;
    }
    /**
     * 取汉字的第一个字符
     */
    public String getFirstLetter(String hanzi) {
        char[] chars = hanzi.trim().toCharArray();
        StringBuilder firstPinyin = new StringBuilder();

        HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();
        // 拼音大写
        defaultFormat.setCaseType(HanyuPinyinCaseType.UPPERCASE);
        // 不带声调
        defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);

        try {
            String str = String.valueOf(chars[0]);
            // 中文的正则表达式
            String hanziRegex = "[\\u4E00-\\u9FA5]+";
            // 数字表达式
            String numberRegex = "[0-9]+";
            // 字母表达式
            String charRegex = "[a-zA-Z]+";

            for (int i = 0, len = chars.length; i < len; i++) {
                // 判断为汉字,则转为拼音,并取第一个字母
                if (Character.toString(chars[i]).matches("[\\u4E00-\\u9FA5]+")) {
                    // 如果是多音字,只取第一个
                    String[] pys = PinyinHelper.toHanyuPinyinStringArray(chars[i], defaultFormat);
                    firstPinyin.append(pys[0].charAt(0));
                } else {
                    firstPinyin.append(chars[i]);
                }
            }
        } catch (BadHanyuPinyinOutputFormatCombination e) {
            log.error("字符不能转为汉语拼音");
        }

        return firstPinyin.toString();
    }
}    

/*
	结果:
	tangdaishirenlibai-libai
	TDSRLB-libai

*/

csharp复制代码//build.gradle配置初识:https://blog.csdn.net/lw_power/article/details/51241720
//gradle默认属性：http://www.cnblogs.com/langtianya/p/5209515.html
plugins {
    id 'java'
}
​
//全局使用的值
ext {
    springBootVersion = '2.5.6'
}
​
//该项目与全部子项目的属性
allprojects {
    //指定编译.java文件的jdk版本
    sourceCompatibility = 1.8
    //确保class文件与targetCompatibility指定版本，或者更新的java虚拟机兼容
    targetCompatibility = 1.8
​
    //项目所属组，中间以.(英文逗号)隔开
    group 'com.yibenzhenjing'
    //项目版本号
    version '1.0.1-SNAPSHOT'
​
    //应用插件
    apply plugin: 'java'
    apply plugin: 'idea'
​
    // java编译的时候缺省状态下会因为中文字符而失败，设置字符集
    [compileJava, compileTestJava, javadoc]*.options*.encoding = 'UTF-8'
​
    //仓库,国内外仓库访问、下载速度会不同
    repositories {
        mavenLocal()
        maven { url "http://maven.aliyun.com/nexus/content/groups/public" } //国内仓库，下载会快一点
    }
​
    //依赖，testCompile表示依赖范围是test，其他依赖写compile
    dependencies {
        compile group: 'org.springframework.boot', name: 'spring-boot-starter-web', version: '2.5.6'
    }
}
​
subprojects {
​
}
​

ini复制代码// 如果单独构建，产物包名称可自定义
archivesBaseName = 'core-util'
​
dependencies {
​
}

typescript复制代码package com.yibenzhenjing.core.util;
​
/**
 * 字符拼接工具
 *
 * @author tangjialiang
 * @since 2021-10-20
 **/
public class JoinUtils {
    /**
     * 分隔符：短横杠
     */
    public static final String SEPARATOR_DASH = "-";
​
    /**
     * 用默认连接符拼接多个字符串
     *
     * @param key 待拼接的字符串
     * @return 拼接结果
     */
    public static String joinString(String... key) {
        return joinStringWithSeprator(SEPARATOR_DASH, key);
    }
​
    /**
     * 指定连接符拼接多个字符串
     *
     * @param separator 连接符
     * @param key       待拼接的字符串
     * @return 拼接结果
     */
    public static String joinStringWithSeprator(String separator, String... key) {
        StringBuilder sBuiler = new StringBuilder();
        int paramSize = key.length;
        int endKeyIndex = paramSize - 1;
        for (int i = 0; i < paramSize; i++) {
            sBuiler.append(key[i]);
            if (i > 0 && i < endKeyIndex) {
                sBuiler.append(separator);
            }
        }
        return sBuiler.toString();
    }
​
}

scss复制代码buildscript {
    repositories {
        mavenLocal()
        maven { url "http://maven.aliyun.com/nexus/content/groups/public" }
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
    }
}
apply plugin: 'org.springframework.boot'
​
archivesBaseName = 'site'
​
dependencies {
    compile project(':util')
}

typescript复制代码package com.yibenzhenjing.core.site;
​
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
​
/**
 * 项目启动类
 *
 * @author tangjialiang
 * @since 2021-10-27
 **/
@SpringBootApplication
public class SiteApplication {
    public static void main(String[] args) {
        SpringApplication.run(SiteApplication.class, args);
    }
}

kotlin复制代码package com.yibenzhenjing.core.site.controller;
​
import com.yibenzhenjing.core.util.JoinUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
​
/**
 * 验证项目正常启动的类
 *
 * @author tangjialiang
 * @since 2021-10-28
 **/
@RestController
public class HelloController {
​
    @GetMapping("hello")
    public String hello() {
        return "hello" + JoinUtils.joinString(",", "author");
    }
}
​