javascript复制代码require('make-promises-safe')
const {default: agent} = require('skywalking-backend-js');
agent.start({              //引用
    serviceName: 'my-service-name',
    serviceInstance: 'my-service-instance-name',
    // collectorAddress: 'http://localhost:8080',
})

var express = require('express')
var app = express();
var port = process.env.PORT || 3001;

var routes = require('./api/routes');
routes(app);
app.listen(port, function() {
    console.log('Server started on port: ' + port);
});

python复制代码import time
import requests
import proxy2808
from bs4 import BeautifulSoup

USERNAME = '用户名'
PASSWORD = '密码'

headers = {
    'Cookie': '你的Cookie值',
    'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36'
}


def get_comments(page, proxy_url_secured):
    """
    评论获取
    """
    # 热门评论获取
    url = 'https://movie.douban.com/subject/26797690/comments?start=' + str(page) + '&limit=20&sort=new_score&status=P'
    # 好评获取
    # url = 'https://movie.douban.com/subject/26797690/comments?start=' + str(page) + '&limit=20&sort=new_score&status=P&percent_type=h'
    # 一般评论获取
    # url = 'https://movie.douban.com/subject/26797690/comments?start=' + str(page) + '&limit=20&sort=new_score&status=P&percent_type=m'
    # 差评获取
    # url = 'https://movie.douban.com/subject/26797690/comments?start=' + str(page) + '&limit=20&sort=new_score&status=P&percent_type=l'
    # 使用2808proxy代理
    response = requests.get(url=url, headers=headers, proxies={'http': proxy_url_secured, 'https': proxy_url_secured})
    soup = BeautifulSoup(response.text, 'html.parser')
    for div in soup.find_all(class_='comment-item'):
        time.sleep(3)

python复制代码import urllib.request
import pandas
import json
import time


def get_access_token():
    """
    获取百度AI平台的Access Token
    """
    # 使用你的API Key及Secret Key
    host = 'https://aip.baidubce.com/oauth/2.0/token?grant_type=client_credentials&client_id=[API Key]&client_secret=[Secret Key]'
    request = urllib.request.Request(host)
    request.add_header('Content-Type', 'application/json; charset=UTF-8')
    response = urllib.request.urlopen(request)
    content = response.read().decode('utf-8')
    rdata = json.loads(content)
    return rdata['access_token']


def sentiment_classify(text, acc):
    """
    获取文本的感情偏向（消极 or 积极 or 中立）
    参数：
    text:str 本文
    """
    raw = {"text":"内容"}
    raw['text'] = text
    data = json.dumps(raw).encode('utf-8')
    # 情感倾向分析接口
    host = "https://aip.baidubce.com/rpc/2.0/nlp/v1/sentiment_classify?charset=UTF-8&access_token=" + acc
    request = urllib.request.Request(url=host, data=data)
    request.add_header('Content-Type', 'application/json')
    response = urllib.request.urlopen(request)
    content = response.read().decode('utf-8')
    rdata = json.loads(content)
    return rdata

java复制代码static <E> List<E> of(E e1,E e2,E e3);
static <E> Set<E> of(E e1,E e2,E e3);
static <K,V> Map<K,V> of(K k1,V v1,K k2,V v2,K k3,V v3);

java复制代码default Stream<T> takeWhile(Predicate<? super T>predicate)

java复制代码import java.util.stream.Stream;

public class Test{
    public static void main(String[] args){
        Stream.of("1","2","3","","5").takeWhile(s->!s.isEmpty()).forEach(System.out::print);
    }
}

java复制代码default Stream<T> dropWhile(Predicate<? super T>predicate)

java复制代码static <T> Stream<T> iterate(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next)

java复制代码java.util.stream.IntStream;
public class Test {
    public static void main(String[] args) { 
        IntStream.iterate(3, x -> x < 10, x -> x+ 3).forEach(System.out::println); 
    }
}

java复制代码static <T> Stream<T> ofNullable(T t)

arduino复制代码void addWord(word)
bool search(word)

erlang复制代码addWord("bad")
addWord("dad")
addWord("mad")
search("pad") -> false
search("bad") -> true
search(".ad") -> true
search("b..") -> true

java复制代码class WordDictionary {

    Map<Integer,Set<String>> map = new HashMap<>();//根据字符串长度分开存放
    public WordDictionary() {
        
    }
    public void addWord(String word) {
        int length = word.length();
        if(map.get(length)!=null){
            map.get(length).add(word);
        }else{
            Set<String> set = new HashSet<>();
            set.add(word);
            map.put(length, set);
        }
    }
    public boolean search(String word) {
        Set<String> set = map.get(word.length());
        if(set==null){  //不存在该长度的字符串，直接返回false；
            return false;
        }
        if(set.contains(word)) return true;
        char[] chars = word.toCharArray();
        P:for(String s : set){
            if(word.length()!=s.length()){
                continue;
            }
            char[] cs = s.toCharArray();
            for(int i = 0; i< cs.length; i++){//逐个字符对比
                if(chars[i] != '.' && chars[i] != cs[i]){
                    continue P;
                }
            }
            set.add(word);
            return true;
        }
        return false;
    }
}

/**
 * Your WordDictionary object will be instantiated and called as such:
 * WordDictionary obj = new WordDictionary();
 * obj.addWord(word);
 * boolean param_2 = obj.search(word);
 */

css复制代码words = ["oath","pea","eat","rain"] and board =
[  ['o','a','a','n'],
  ['e','t','a','e'],
  ['i','h','k','r'],
  ['i','f','l','v']
]

go复制代码	首先构建一个字典树，然后在dfs的时候加入字典树，以某个字符串结尾的可以减少搜索次数
	这里为什么不用开头用结尾呢，  `(●ˇ∀ˇ●)`	
结尾在这里就是我搜索完一个，我可以直接比较，如果没有的话，我再返回上一个，

java复制代码class TrieNode {
    private static final int ALPHABET_SIZE = 26;

    TrieNode[] children = new TrieNode[ALPHABET_SIZE];
    // 判断这个前缀是不是某个字符串的结尾
    boolean isEndOfWord = false;
    TrieNode() {
        isEndOfWord = false;
        for (int i = 0; i < ALPHABET_SIZE; i++)
            children[i] = null;
    }
}

class Trie {
    public TrieNode root;
    /** Initialize your data structure here. */
    public Trie() {
        root = new TrieNode();
    }
    /** Inserts a word into the trie. */
    public void insert(String word) {
        TrieNode curNode = root;
        int index;
        for (int i = 0; i < word.length(); i++) {
            index = word.charAt(i) - 'a';
            if (curNode.children[index] == null) {
                curNode.children[index] = new TrieNode();
            }
            curNode = curNode.children[index];
        }
        curNode.isEndOfWord = true;
    }
}
class Solution {
    public List<String> findWords(char[][] board, String[] words) {
        List<String> result = new ArrayList<>();
        if (words == null || words.length == 0 || board == null || board.length == 0 || board[0].length == 0)
            return result;

        Trie trie = new Trie();
        for (String temp : words)
            trie.insert(temp);

        TrieNode root = trie.root;
        boolean[][] visited = new boolean[board.length][board[0].length];
        Set<String> tempResult = new HashSet<>();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < board.length; i++) {
            for (int j = 0; j < board[0].length; j++) {
                if (root.children[board[i][j] - 'a'] != null ) {
                    dfs(board, visited, i, j, root.children[board[i][j] - 'a'], tempResult, sb);
                }
            }
        }

        // 需要把tempResult这个set拷贝到真正的result List中进行返回
        Iterator<String> iterator = tempResult.iterator();
        while (iterator.hasNext()) {
            result.add(iterator.next());
        }
        return result;
    }

    private void dfs(char[][] board, boolean[][] visited, int startIInBoard, int startJInBoard
            , TrieNode curNode, Set<String> resultSet, StringBuilder curStrBuilder) {
        curStrBuilder.append(board[startIInBoard][startJInBoard]);
        visited[startIInBoard][startJInBoard] = true;
        if (curNode.isEndOfWord) {
            resultSet.add(curStrBuilder.toString());
        }
        // 向上搜索, 如果上面的格子没有被搜索过的话
        if (startIInBoard > 0 && !visited[startIInBoard - 1][startJInBoard]
                && curNode.children[board[startIInBoard - 1][startJInBoard] - 'a'] != null) {
            dfs(board, visited,startIInBoard - 1, startJInBoard
                    , curNode.children[board[startIInBoard - 1][startJInBoard] - 'a'], resultSet, curStrBuilder);
        }
        // 向下搜索
        if (startIInBoard < board.length - 1 && !visited[startIInBoard + 1][startJInBoard]
                && curNode.children[board[startIInBoard + 1][startJInBoard] - 'a'] != null) {
            dfs(board, visited,startIInBoard + 1, startJInBoard
                    , curNode.children[board[startIInBoard + 1][startJInBoard] - 'a'], resultSet, curStrBuilder);
        }
        // 向左搜索
        if (startJInBoard > 0 && !visited[startIInBoard][startJInBoard - 1]
                && curNode.children[board[startIInBoard][startJInBoard - 1] - 'a'] != null) {
            dfs(board, visited, startIInBoard, startJInBoard - 1
                    , curNode.children[board[startIInBoard][startJInBoard - 1] - 'a'], resultSet, curStrBuilder);
        }
        // 向右搜索
        if (startJInBoard < board[0].length - 1 && !visited[startIInBoard][startJInBoard + 1]
                && curNode.children[board[startIInBoard][startJInBoard + 1] - 'a'] != null) {
            dfs(board, visited, startIInBoard, startJInBoard + 1
                    , curNode.children[board[startIInBoard][startJInBoard + 1] - 'a'], resultSet, curStrBuilder);
        }
        // 恢复现场
        curStrBuilder.setLength(curStrBuilder.length() - 1);
        visited[startIInBoard][startJInBoard] = false;
    }
}

java复制代码class Solution {
    public static String shortestPalindrome(String s) {
		StringBuilder r = new StringBuilder(s).reverse();
		String str = s + "#" + r;
		int[] next = next(str);
		  //如果是回文串  1234321		#		1234321
			//next[str.length]=7,r.substring(0,0)=""输出原字符串
			//如果  123432    #   234321	next[str.length]=5	
			//r.substring(0,6-5),只需要第一位
		String prefix = r.substring(0, r.length() - next[str.length()]);
		return prefix + s;
	}

	// next数组
	  //KMP的next[j]=x就是0~x-1与 j-x~j-1 的元素是相同的
	  //大概是这样
	private static int[] next(String P) {
		int[] next = new int[P.length() + 1];
		next[0] = -1;
		int k = -1;
		int i = 1;
		//next【k】保存的是我上次相等的时候
				//不相等的时候我就从我上一次相等的时候就行匹配
				//i是快指针，k是慢指针
		while (i < next.length) {
			if (k == -1 || P.charAt(k) == P.charAt(i - 1)) {
				next[i++] = ++k;
			} else {
				k = next[k];
			}
		}
		return next;
	}
}

java复制代码class Solution {
    public int findKthLargest(int[] nums, int k) {
        if(nums.length < 2){
            return nums.length == 1 ? nums[0] : -1;
        }
        return countingSort(nums, k);
    }
    
    private int countingSort(int[] nums, int k){
        int max = 0;
        int min = 0;
        for(int i = 0; i < nums.length; i++){
            if(nums[i] > max){
                max = nums[i];
            }
            
            if(nums[i] < min){
                min = nums[i];
            }
        }
        
        int length = (max - min) + 1;
        int[] newArray = new int[length];
        //这个数组记录的是与最小的值相差的某位的数量
        for(int i = 0; i < nums.length; i++){
            newArray[nums[i] - min]++;
        }
        
        int j = 0;
        for(int i = newArray.length - 1; i >= 0; i--){
            //这样最大值就出来了，先从最大值开始
            if(newArray[i] > 0){
                j = newArray[i] + j;
                if(j >= k){
                    return i + min;
                }
            }
        }
        return -1;
    }
}

java复制代码class Solution {
    //结果集
    public List<List<Integer>> lists = new ArrayList<>();
    //临时集
    public List<Integer> list = new ArrayList<>();
    public List<List<Integer>> combinationSum3(int k, int n) {
        //回溯入口
        backTracking(list, 0, 1, k, n, 0);
        return lists;
    }
    public void backTracking(List<Integer> list, int index, int c, int k, int n, int sum){
        //回溯出口
        //保证是k个数字的累加，且，和为指定值
        if(index == k && sum == n){
            //满足添加入集合
            List<Integer> currentList = new ArrayList<>();
            currentList.addAll(list);
            lists.add(currentList);
            return;
        }
        //剪枝操作
        if(sum > n){
            return;
        }
        //回溯条件
        for(int i = c; i <= 9; ++i){
            list.add(i);
            sum += i;
            backTracking(list, index + 1, i + 1, k, n, sum);
            list.remove(list.size() - 1);
            sum -= i;
        }
    }
}

arduino复制代码Java自带集合，set不存放相同元素的内容，如果添加相同内容会返回false，并且不会添加进去

java复制代码class Solution {
    public boolean containsDuplicate(int[] nums) {
          Set<Integer> res = new HashSet<Integer>();
        for(int i:nums)
            res.add(i);
        return res.size()<nums.length?true:false;
    }
}

java复制代码class Solution {
   // 线段树 
    public List<List<Integer>> getSkyline(int[][] buildings) {
        int len = buildings.length;
        if (len == 0) return new ArrayList<>();
        return segment(buildings, 0, len - 1);
    }

    private List<List<Integer>> segment(int[][] buildings, int l, int r) {
        // 创建返回值
        List<List<Integer>> res = new ArrayList<>();

        // 找到树底下的结束条件 -> 一个建筑物
        if (l == r) {
            res.add(Arrays.asList(buildings[l][0], buildings[l][2])); // 左上端坐标
            res.add(Arrays.asList(buildings[l][1], 0)); // 右下端坐标
            return res;
        }

        int mid = l + (r - l) / 2; // 取中间值

        // 左边递归
        List<List<Integer>> left = segment(buildings, l, mid);

        // 右边递归
        List<List<Integer>> right = segment(buildings, mid + 1, r);

        // 左右合并

        // 创建left 和 right 的索引位置
        int m = 0, n = 0;
        // 创建left 和 right 目前的高度
        int lpreH = 0, rpreH = 0;
        // 两个坐标
        int leftX, leftY, rightX, rightY;
        while (m < left.size() || n < right.size()) {

            // 当有一边完全加入到res时，则加入剩余的那部分
            if (m >= left.size()) res.add(right.get(n++));
            else if (n >= right.size()) res.add(left.get(m++));

            else { // 开始判断left 和 right
                leftX = left.get(m).get(0); // 不会出现null，可以直接用int类型
                leftY = left.get(m).get(1);
                rightX = right.get(n).get(0);
                rightY = right.get(n).get(1);
                //看我这两个矩形谁靠左
                if (leftX < rightX) {
                    //左面还比以前高，就加左面
                   if (leftY > rpreH) res.add(left.get(m));
                   //左面比右面高，我要加入左面点的以及以前右面的的高度，因为我马上就有新高度了2，10
                   else if (lpreH > rpreH) res.add(Arrays.asList(leftX, rpreH));
                 //  用我左面的高替换我以前右面的高
                    lpreH = leftY;
                    m++;
                } else if (leftX > rightX) {
                   if (rightY > lpreH) res.add(right.get(n));
                   else if (rpreH > lpreH) res.add(Arrays.asList(rightX, lpreH));
                    rpreH = rightY;
                    n++;
                } else { // left 和 right 的横坐标相等
                  if (leftY >= rightY && leftY != (lpreH > rpreH ? lpreH : rpreH)) res.add(left.get(m));
                    else if (leftY <= rightY && rightY != (lpreH > rpreH ? lpreH : rpreH)) res.add(right.get(n));
                    lpreH = leftY;
                    rpreH = rightY;
                    m++;
                    n++;
                }
            }
        }
        return res;
    }

}

markdown复制代码	滑动窗口

java复制代码class Solution {
       public boolean containsNearbyDuplicate(int[] nums, int k) {
        Set<Integer> set = new HashSet<>();

        for (int i = 0; i < nums.length; i++) {
            if(set.contains(nums[i])){
                return true;
            }
            set.add(nums[i]);
            if(set.size() == k+1){
                set.remove(nums[i - k]);
            }

        }

        return false;
    }
}

java复制代码class Solution {
    public boolean containsNearbyAlmostDuplicate(int[] nums, int k, int t) {
   // 滑动窗口结合查找表，此时滑动窗口即为查找表本身（控制查找表的大小即可控制窗口大小）
    TreeSet<Long> set = new TreeSet<>();
    for (int i = 0; i < nums.length; i++) {
        // 边添加边查找
        // 查找表中是否有大于等于 nums[i] - t 且小于等于 nums[i] + t 的值
        Long ceiling = set.ceiling((long) nums[i] - (long) t);
        if (ceiling != null && ceiling <= ((long) nums[i] + (long) t)) {
            return true;
        }
        // 添加后，控制查找表（窗口）大小，移除窗口最左边元素
        set.add((long) nums[i]);
        if (set.size() == k + 1) {
            set.remove((long) nums[i - k]);
        }
    }
    return false;
    }
}

rust复制代码输入: 1->2->3->4->5->NULL
输出: 1->3->5->2->4->NULL

rust复制代码输入: 2->1->3->5->6->4->7->NULL 
输出: 2->3->6->7->1->5->4->NULL

c复制代码oddTail->next  = evenHead;  //将偶数链表头结点插在奇数链表尾节点后面
evenTail->next = nullptr;   //偶数链表尾节点指向null

c复制代码/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* oddEvenList(ListNode* head) {
        if(!head || !head->next) return head;
        auto oddHead  = head, oddTail = oddHead;  //定义4个链表指针
        auto evenHead = head->next, evenTail = evenHead;

        for(ListNode* p = head->next->next; p;)
        {
            oddTail = oddTail->next = p;
            p = p->next;
            if(p) //当前节点不为空
            {
                evenTail = evenTail->next = p;
                p = p->next;
            }
        }
        oddTail->next  = evenHead; //将偶数链表头结点插在奇数链表尾节点后面
        evenTail->next = nullptr;
        return oddHead;
    }
};

java复制代码/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode oddEvenList(ListNode head) {
        if(head == null|| head.next == null) return head;
        ListNode oddHead  = head, oddTail = oddHead;  //定义4个链表指针
        ListNode evenHead = head.next, evenTail = evenHead;

        for(ListNode p = head.next.next; p!=null;)
        {
            oddTail = oddTail.next = p;
            p = p.next;
            if(p != null)
            {
                evenTail = evenTail.next = p;
                p = p.next;
            }
        }
        oddTail.next  = evenHead; //将偶数链表头结点插在奇数链表尾节点后面
        evenTail.next = null;
        return oddHead;
    }
}

markdown复制代码 - 原子性: 原子性是事务的最小执行单位，事务的原子性确保动作要么全部执行完毕，要么就都不执行
 - 一致性：确保数据的一致性，一致性其实就是原子性的升华，逻辑差不多，但又不完全相同
 - 隔离性：并发访问下，事务之间互不干预，每个事务的独立的
 - 持久性：一个事务被提交之后，在数据库中是持久的，并不会因为数据库故障等原因丢失

markdown复制代码 - PlatformTransactionManager 平台事务管理器
 - TransactionDefinition 事务定义信息（传播行为、事务隔离级别、只读、超时、回滚规则）
 - TransactionStatus 事务状态

java复制代码public interface PlatformTransactionManager {

//根据传播行为返回当前活动的事务或者创建一个新的事务返回
TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException;

//提交目前事务的状态
void commit(TransactionStatus status) throws TransactionException;


//对执行的事务进行回滚
void rollback(TransactionStatus status) throws TransactionException;

}

ini复制代码public interface TransactionDefinition {

//事务的传播行为常量
int PROPAGATION_REQUIRED = 0;
int PROPAGATION_SUPPORTS = 1;
int PROPAGATION_MANDATORY = 2;
int PROPAGATION_REQUIRES_NEW = 3;
int PROPAGATION_NOT_SUPPORTED = 4;
int PROPAGATION_NEVER = 5;
int PROPAGATION_NESTED = 6;
//事务的隔离级别
int ISOLATION_DEFAULT = -1;
int ISOLATION_READ_UNCOMMITTED = Connection.TRANSACTION_READ_UNCOMMITTED;
int ISOLATION_READ_COMMITTED = Connection.TRANSACTION_READ_COMMITTED;
int ISOLATION_REPEATABLE_READ = Connection.TRANSACTION_REPEATABLE_READ;
int ISOLATION_SERIALIZABLE = Connection.TRANSACTION_SERIALIZABLE;

//事务默认超时时间
int TIMEOUT_DEFAULT = -1;


//返回事务的传播行为
int getPropagationBehavior();

//事务的隔离级别
int getIsolationLevel();

//获取事务的超时时间
int getTimeout();

//事务是否只读
boolean isReadOnly();

//返回事务的名称
@Nullable
String getName();

}

csharp复制代码public interface TransactionStatus extends SavepointManager, Flushable {

  //是否是一个新的事务
   boolean isNewTransaction();

  //是否有恢复点
   boolean hasSavepoint();

  //设置为只回滚
   void setRollbackOnly();

  //是否为只回滚
   boolean isRollbackOnly();

  //是否已完成
   boolean isCompleted();

}

typescript复制代码@Resource
private TransactionTemplate transactionTemplate;

@PostMapping("test1")
public Object test1() {
   transactionTemplate.execute(new TransactionCallbackWithoutResult() {
       @Override
       protected void doInTransactionWithoutResult(TransactionStatus status) {
           try {
               userService.addException();  //业务代码
           } catch (Exception e) {
               status.setRollbackOnly();  //回滚
           }
       }
   });
   return "执行完毕";
}

typescript复制代码@Resource
private PlatformTransactionManager transactionManager;

@PostMapping("test2")
public Object test2() {
    TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionDefinition());

    try {
        userService.addException();
        transactionManager.commit(status);  //手动提交事务
    } catch (Exception e) {
        transactionManager.rollback(status); //回滚事务
    }
    return "执行完毕";
}

less复制代码@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
@Override
public void test() {
    add();
    try {
        addException();
    } catch (Exception e) {
        log.error("事务回滚了");
    }

}

yaml复制代码spring:
  profiles:
#    active: dev # 开发环境
    active: pro # 生产环境

yaml复制代码spring:
  profiles:
    active: @activatedProperties@ # 自动识别环境

xml复制代码<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
​
    <groupId>com.cc</groupId>
    <artifactId>autoPackageDemo</artifactId>
    <version>1.0.0</version>
​
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
    </parent>
​
    <dependencies>
        <!--springboot启动器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
​
    <profiles>
        <profile>
            <id>dev</id>
            <properties>
                <activatedProperties>dev</activatedProperties>
            </properties>
            <activation>
                <!--默认情况下使用dev开发配置-->
                <activeByDefault>true</activeByDefault>
            </activation>
        </profile>
        <!--指定可以用来打包的配置文件1-->
        <profile>
            <id>pro</id>
            <properties>
                <activatedProperties>pro</activatedProperties>
            </properties>
        </profile>
        <!--有其他环境的话就继续添加-->
        <!--...-->
    </profiles>
​
    <build>
        <!--指定打包的配置文件2-->
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
            </resource>
        </resources>
​
        <!--指定包名-->
        <finalName>app</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

yaml复制代码server:
  port: 8888
spring:
  profiles:
    active: @activatedProperties@ # 自动识别环境

makefile复制代码myvalue: dev

makefile复制代码myvalue: pro

kotlin复制代码package com.cc.controller;
​
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
​
@RestController
public class TestController {
    @Value("${myvalue}")
    private String myvalue;
​
    @GetMapping("/env")
    public String env() {
        return "当前的启动环境是：" + myvalue;
    }
}

go复制代码var a int8 = 1
var c int8 = 1
var b bool = false

if a == c {
    fmt.Println("条件成立1")
}

if b {
    fmt.Println("条件成立2")
}
/*
输出结果：
条件成立1
*/

go复制代码// 彩票中奖金额
var a int32 = 5000

if a == 5000 {
    // 中了5000 万，养猪
    fmt.Println("回家养猪")
} else if a == 500 {
    // 中了 500 万，养鱼
    fmt.Println("回家养鱼")
} else {
    // 以上都没有中，秃头
    fmt.Println("码代码搬砖秃头")
}

if a > 500 {
    fmt.Println("我是单独的if")
}
/*
输出结果：
回家养猪
我是单独的if
*/

go复制代码// 创建变量a，赋值0
var a int32 = 0

// 判断a是否小于10
for a < 10 {
    // 打印a变量的值(Print 不换行打印到控制台)
    fmt.Print(a)
    // a变量的值加1
    a = a + 1
}
// for 执行完毕后继续往下执行代码
fmt.Println()
fmt.Println("for结束了，执行了我")

/*
输出结果：
0123456789
for结束了，执行了我
*/

go复制代码// 初始化变量a赋值0 | 条件判断a小于10 | {...} 花括号代码执行后a变量累加1
for a:=0; a < 10; a++ {
    fmt.Print(a)
}

go复制代码for true {
    fmt.Println("我会一直输出这句话，知道内存不足程序崩掉")
}

go复制代码
// a == 5 时，那顿饭剩下的菜就不吃了，立马开始下一顿
for a:=0; a < 10; a++ {
    if a == 5 {
        fmt.Print("斗牛大陆")
        continue
    }
    fmt.Print(a)
}
/*
输出结果：
01234斗牛大陆6789
*/

// a == 5 时，剩下的菜会之后的每一顿饭都不吃了
for a:=0; a < 10; a++ {
    if a == 5 {
	break
    }
    fmt.Print(a)
}
/*
输出结果：
01234
*/

go复制代码// 第一种
a := 0
for a < 10 {
	fmt.Println(a)
	a++
} 

// 第二种
for b:=0; b<10; b++ {
	fmt.Println(b)
}

// 第三种 死循环
for true {
	fmt.Println("直到天荒地老")
}

go复制代码var a byte = 1

go复制代码// a → 0xc00000a0a0 → 0000 0001
var a byte = 1
// a → 0xc00000a0a0 → 0000 0010
a = 2

go复制代码a := "天一子"
// 输出变量的值
fmt.Println(a)
// 输出变量的内存地址(16进制内存地址)
fmt.Println(&a)
/*
输出结果：
天一子
0xc0000881e0
*/

go复制代码a := "天一子"
// 创建一个 存放string类型内存地址的指针类型
var ptr *string = a&
fmt.Println(ptr)
/*
输出结果：
0xc00003a1f0
*/

var b int8 = 1
// 报错
ptr = &b

go复制代码
var a string = "天一子"
var ptr *string = &a
// 创建 b 变量并赋值 *pta（b变量和内存地址绑定，就是b变量指向a变量的内存地址）
b := *ptr

// 输出指针的值
fmt.Println(ptr)
/*
输出结果：
0xc00008a040
*/

// 输出指针所指向内存地址的值（此处输出a变量的值）
fmt.Println(b)
/*
输出结果：
天一子
*/

go复制代码var a = "aaa"
var b = &a
var c = a
fmt.Println("变量a的地址：", &a)
fmt.Println("变量b的地址：", b)
fmt.Println("变量c的地址：", &c)
fmt.Println(a)
*b = "bbb"
fmt.Println(a)
/*
输出结果：
变量a的地址： 0xc00003a1f0
变量b的地址： 0xc00003a1f0
变量c的地址： 0xc00003a200
aaa
bbb
*/

go复制代码// 使用中括号[]，创建一个 byte 类型的数组，容量大小为3
var bArray [3]byte
// 变量名[下标] 给三个空间赋值
bArray[0] = 1
bArray[1] = 2
bArray[2] = 3
fmt.Println(bArray)
fmt.Println(&bArray[0])
fmt.Println(&bArray[1])
fmt.Println(&bArray[2])
/*
输出结果：
[1 2 3]
0xc0000a2058
0xc0000a2059
0xc0000a205a
*/

go复制代码// 创建byte类型数组定义3个空间大小，并分别为每个空间赋值
var bArray [3]byte
bArray[0] = 1
bArray[1] = 2
bArray[2] = 3
fmt.Println(bArray)
// 创建数组时并同时为每个空间赋值
rArray := [2]rune{'钟', '离'}
fmt.Println(rArray)
// 访问 bArray数组下标4（报错：Invalid array index 4 (out of bounds for 3-element array)）
fmt.Println(bArray[4])

go复制代码var status = [4]rune{'生', '老', '病', '死'}

go复制代码// 你不会这样做吧？
var bArray = [1000]int32{1, 2 ,...省略代码...,1000}

// 你不会这样做吧？
var bArray [1000]int32
bArray[0] = 1
bArray[1] = 2
...依次赋值 省略代码...
bArray[999] = 1000

// 我们使用上面学的for循环来完成这个场景，使用len函数获取数组长度1000
for int i = 0; i < len(bArray); i++ {
    bArray[i] = i + 1
}

go复制代码// 把 bArray数组的元素循环赋值到变量a中
for a := range bArray {
    fmt.Println(a)
}

go复制代码// 创建一个存储着两千字符的字典数组
func main() {
    var runeArray = [2000]string{"天","风"...省略1998个字符...} 
    printDictionaryStrByIndex(runeArray, 0)
    fmt.Println(runeArray[1])
    fmt.Println(&runeArray[1])
}

// 打印数组指定下标元素
func printDictionaryStrByIndex(strs [2000]string, index int) {
    fmt.Println(strs[index])
    fmt.Println(&strs[index])
}
/*
输出结果：
风
0xc000098430
风
0xc000098470
*/

go复制代码// 创建一个存储着两千字符的字典数组
func main() {
    var runeArray = [2000]string{"天","风"...省略1998个字符...} 
    printDictionaryStrByIndex(&runeArray, 0)
    fmt.Println(runeArray[1])
    fmt.Println(&runeArray[1])
}

// 打印数组指定下标元素
func printDictionaryStrByIndex(strs *[2000]string, index int) {
    fmt.Println(strs[index])
    fmt.Println(&strs[index])
}
/*
输出结果：
风
0xc000004490
风
0xc000004490
*/

perl复制代码# 指定分析器 
GET my-index-000001/_search
{
  "query": {
    "match": {
      "message": {
        "query": "Quick foxes",
        "analyzer": "stop"
      }
    }
  }
}

bash复制代码POST /_analyze?pretty
{
    "analyzer": "standard",
    "text": "测试搜索语句"
}

{
  "tokens" : [
    {
      "token" : "测",
      "start_offset" : 0,
      "end_offset" : 1,
      "type" : "<IDEOGRAPHIC>",
      "position" : 0
    },
    {
      "token" : "试",
      "start_offset" : 1,
      "end_offset" : 2,
      "type" : "<IDEOGRAPHIC>",
      "position" : 1
    },
    {
      "token" : "搜",
      "start_offset" : 2,
      "end_offset" : 3,
      "type" : "<IDEOGRAPHIC>",
      "position" : 2
    },
    {
      "token" : "索",
      "start_offset" : 3,
      "end_offset" : 4,
      "type" : "<IDEOGRAPHIC>",
      "position" : 3
    },
    {
      "token" : "语",
      "start_offset" : 4,
      "end_offset" : 5,
      "type" : "<IDEOGRAPHIC>",
      "position" : 4
    },
    {
      "token" : "句",
      "start_offset" : 5,
      "end_offset" : 6,
      "type" : "<IDEOGRAPHIC>",
      "position" : 5
    }
  ]
}

bash复制代码# 测试简单分析器

POST /_analyze?pretty
{
    "analyzer": "simple",
    "text": "测试搜索语句AAA"
}

{
  "tokens" : [
    {
      "token" : "测试搜索语句aaa",
      "start_offset" : 0,
      "end_offset" : 9,
      "type" : "word",
      "position" : 0
    }
  ]
}

bash复制代码# 测试空白分析器

POST /_analyze?pretty
{
    "analyzer": "whitespace",
    "text": "This is a text"
}

{
  "tokens" : [
    {
      "token" : "This",
      "start_offset" : 0,
      "end_offset" : 4,
      "type" : "word",
      "position" : 0
    },
    {
      "token" : "is",
      "start_offset" : 5,
      "end_offset" : 7,
      "type" : "word",
      "position" : 1
    },
    {
      "token" : "a",
      "start_offset" : 8,
      "end_offset" : 9,
      "type" : "word",
      "position" : 2
    },
    {
      "token" : "text",
      "start_offset" : 10,
      "end_offset" : 14,
      "type" : "word",
      "position" : 3
    }
  ]
}

bash复制代码# 测试stop分析器
POST /_analyze?pretty
{
    "analyzer": "stop",
    "text": "This is a TEXT"
}

{
  "tokens" : [
    {
      "token" : "text",
      "start_offset" : 10,
      "end_offset" : 14,
      "type" : "word",
      "position" : 3
    }
  ]
}

bash复制代码# 测试Keyword分析器
POST /_analyze?pretty
{
    "analyzer": "keyword",
    "text": "This is a TEXT"
}

{
  "tokens" : [
    {
      "token" : "This is a TEXT",
      "start_offset" : 0,
      "end_offset" : 14,
      "type" : "word",
      "position" : 0
    }
  ]
}

json复制代码POST _analyze
{
  "analyzer": "pattern",
  "text": "This is a TEXT."
}

{
  "tokens" : [
    {
      "token" : "this",
      "start_offset" : 0,
      "end_offset" : 4,
      "type" : "word",
      "position" : 0
    },
    {
      "token" : "is",
      "start_offset" : 5,
      "end_offset" : 7,
      "type" : "word",
      "position" : 1
    },
    {
      "token" : "a",
      "start_offset" : 8,
      "end_offset" : 9,
      "type" : "word",
      "position" : 2
    },
    {
      "token" : "text",
      "start_offset" : 10,
      "end_offset" : 14,
      "type" : "word",
      "position" : 3
    }
  ]
}