file_id stringlengths 3 9 | content stringlengths 24 53.5k | repo stringlengths 6 89 | path stringlengths 5 169 | token_length int64 18 8.19k | original_comment stringlengths 5 9.64k | comment_type stringclasses 2
values | detected_lang stringclasses 1
value | masked_comment stringlengths 11 53.4k |
|---|---|---|---|---|---|---|---|---|
27_0 | package org.ansj.library;
import org.ansj.domain.Nature;
import org.ansj.domain.Term;
import org.ansj.util.MyStaticValue;
import org.nlpcn.commons.lang.util.StringUtil;
import org.nlpcn.commons.lang.util.logging.Log;
import org.nlpcn.commons.lang.util.logging.LogFactory;
import java.io.BufferedReader;
impor... | NLPchina/ansj_seg | src/main/java/org/ansj/library/NatureLibrary.java | 1,108 | /**
* 这里封装了词性和词性之间的关系.以及词性的索引.这是个好东西. 里面数组是从ict里面找来的. 不是很新.没有语料无法训练
*
* @author ansj
*
*/ | block_comment | zh-cn | package org.ansj.library;
import org.ansj.domain.Nature;
import org.ansj.domain.Term;
import org.ansj.util.MyStaticValue;
import org.nlpcn.commons.lang.util.StringUtil;
import org.nlpcn.commons.lang.util.logging.Log;
import org.nlpcn.commons.lang.util.logging.LogFactory;
import java.io.BufferedReader;
impor... |
27_1 | package org.ansj.library;
import org.ansj.domain.Nature;
import org.ansj.domain.Term;
import org.ansj.util.MyStaticValue;
import org.nlpcn.commons.lang.util.StringUtil;
import org.nlpcn.commons.lang.util.logging.Log;
import org.nlpcn.commons.lang.util.logging.LogFactory;
import java.io.BufferedReader;
impor... | NLPchina/ansj_seg | src/main/java/org/ansj/library/NatureLibrary.java | 1,108 | /**
* 词性的字符串对照索引位的hashmap(我发现我又效率狂了.不能这样啊)
*/ | block_comment | zh-cn | package org.ansj.library;
import org.ansj.domain.Nature;
import org.ansj.domain.Term;
import org.ansj.util.MyStaticValue;
import org.nlpcn.commons.lang.util.StringUtil;
import org.nlpcn.commons.lang.util.logging.Log;
import org.nlpcn.commons.lang.util.logging.LogFactory;
import java.io.BufferedReader;
impor... |
29_0 | package org.nutz.el;
import java.lang.reflect.Method;
import java.util.Map;
import java.util.Queue;
import org.nutz.el.arithmetic.RPN;
import org.nutz.el.arithmetic.ShuntingYard;
import org.nutz.el.opt.RunMethod;
import org.nutz.el.opt.custom.CustomMake;
import org.nutz.lang.Lang;
import org.nutz.lang.segment.CharSeg... | nutzam/nutz | src/org/nutz/el/El.java | 794 | /**
* 预编译
*/ | block_comment | zh-cn | package org.nutz.el;
import java.lang.reflect.Method;
import java.util.Map;
import java.util.Queue;
import org.nutz.el.arithmetic.RPN;
import org.nutz.el.arithmetic.ShuntingYard;
import org.nutz.el.opt.RunMethod;
import org.nutz.el.opt.custom.CustomMake;
import org.nutz.lang.Lang;
import org.nutz.lang.segment.CharSeg... |
29_1 | package org.nutz.el;
import java.lang.reflect.Method;
import java.util.Map;
import java.util.Queue;
import org.nutz.el.arithmetic.RPN;
import org.nutz.el.arithmetic.ShuntingYard;
import org.nutz.el.opt.RunMethod;
import org.nutz.el.opt.custom.CustomMake;
import org.nutz.lang.Lang;
import org.nutz.lang.segment.CharSeg... | nutzam/nutz | src/org/nutz/el/El.java | 794 | /**
* 解析预编译后的EL表达式
*/ | block_comment | zh-cn | package org.nutz.el;
import java.lang.reflect.Method;
import java.util.Map;
import java.util.Queue;
import org.nutz.el.arithmetic.RPN;
import org.nutz.el.arithmetic.ShuntingYard;
import org.nutz.el.opt.RunMethod;
import org.nutz.el.opt.custom.CustomMake;
import org.nutz.lang.Lang;
import org.nutz.lang.segment.CharSeg... |
29_2 | package org.nutz.el;
import java.lang.reflect.Method;
import java.util.Map;
import java.util.Queue;
import org.nutz.el.arithmetic.RPN;
import org.nutz.el.arithmetic.ShuntingYard;
import org.nutz.el.opt.RunMethod;
import org.nutz.el.opt.custom.CustomMake;
import org.nutz.lang.Lang;
import org.nutz.lang.segment.CharSeg... | nutzam/nutz | src/org/nutz/el/El.java | 794 | /**
* 对参数代表的表达式进行运算
*/ | block_comment | zh-cn | package org.nutz.el;
import java.lang.reflect.Method;
import java.util.Map;
import java.util.Queue;
import org.nutz.el.arithmetic.RPN;
import org.nutz.el.arithmetic.ShuntingYard;
import org.nutz.el.opt.RunMethod;
import org.nutz.el.opt.custom.CustomMake;
import org.nutz.lang.Lang;
import org.nutz.lang.segment.CharSeg... |
29_5 | package org.nutz.el;
import java.lang.reflect.Method;
import java.util.Map;
import java.util.Queue;
import org.nutz.el.arithmetic.RPN;
import org.nutz.el.arithmetic.ShuntingYard;
import org.nutz.el.opt.RunMethod;
import org.nutz.el.opt.custom.CustomMake;
import org.nutz.lang.Lang;
import org.nutz.lang.segment.CharSeg... | nutzam/nutz | src/org/nutz/el/El.java | 794 | //@ JKTODO 删除原来的EL包,并修改当前为EL | line_comment | zh-cn | package org.nutz.el;
import java.lang.reflect.Method;
import java.util.Map;
import java.util.Queue;
import org.nutz.el.arithmetic.RPN;
import org.nutz.el.arithmetic.ShuntingYard;
import org.nutz.el.opt.RunMethod;
import org.nutz.el.opt.custom.CustomMake;
import org.nutz.lang.Lang;
import org.nutz.lang.segment.CharSeg... |
29_6 | package org.nutz.el;
import java.lang.reflect.Method;
import java.util.Map;
import java.util.Queue;
import org.nutz.el.arithmetic.RPN;
import org.nutz.el.arithmetic.ShuntingYard;
import org.nutz.el.opt.RunMethod;
import org.nutz.el.opt.custom.CustomMake;
import org.nutz.lang.Lang;
import org.nutz.lang.segment.CharSeg... | nutzam/nutz | src/org/nutz/el/El.java | 794 | //@ JKTODO 自己实现一个QUEUE接口, 主要是实现队列,头部检测,头部第几个元素检测 | line_comment | zh-cn | package org.nutz.el;
import java.lang.reflect.Method;
import java.util.Map;
import java.util.Queue;
import org.nutz.el.arithmetic.RPN;
import org.nutz.el.arithmetic.ShuntingYard;
import org.nutz.el.opt.RunMethod;
import org.nutz.el.opt.custom.CustomMake;
import org.nutz.lang.Lang;
import org.nutz.lang.segment.CharSeg... |
30_0 | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... | wangzheng0822/algo | java/17_skiplist/SkipList2.java | 2,738 | /**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/ | block_comment | zh-cn | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳 <SUF>*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头链表
*/
private Node head = new Node(MAX_LEVEL);
private Random r = new Random();
public Node find(int value)... |
30_1 | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... | wangzheng0822/algo | java/17_skiplist/SkipList2.java | 2,738 | /**
* 带头链表
*/ | block_comment | zh-cn | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... |
30_2 | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... | wangzheng0822/algo | java/17_skiplist/SkipList2.java | 2,738 | // 从最大层开始查找，找到前一节点，通过--i，移动到下层再开始查找 | line_comment | zh-cn | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... |
30_3 | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... | wangzheng0822/algo | java/17_skiplist/SkipList2.java | 2,738 | // 找到前一节点 | line_comment | zh-cn | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... |
30_5 | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... | wangzheng0822/algo | java/17_skiplist/SkipList2.java | 2,738 | // 每次只增加一层，如果条件满足 | line_comment | zh-cn | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... |
30_6 | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... | wangzheng0822/algo | java/17_skiplist/SkipList2.java | 2,738 | // 从最大层开始查找，找到前一节点，通过--i，移动到下层再开始查找 | line_comment | zh-cn | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... |
30_7 | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... | wangzheng0822/algo | java/17_skiplist/SkipList2.java | 2,738 | // 找到前一节点 | line_comment | zh-cn | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... |
30_10 | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... | wangzheng0822/algo | java/17_skiplist/SkipList2.java | 2,738 | // 每次只增加一层，如果条件满足 | line_comment | zh-cn | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... |
30_11 | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... | wangzheng0822/algo | java/17_skiplist/SkipList2.java | 2,738 | // 从最大层开始查找，找到前一节点，通过--i，移动到下层再开始查找 | line_comment | zh-cn | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... |
30_12 | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... | wangzheng0822/algo | java/17_skiplist/SkipList2.java | 2,738 | // 找到前一节点 | line_comment | zh-cn | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... |
30_14 | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... | wangzheng0822/algo | java/17_skiplist/SkipList2.java | 2,738 | /**
* 作者zheng的插入方法，未优化前，优化后参见上面insert()
*
* @param value
* @param level 0 表示随机层数，不为0，表示指定层数，指定层数
* 可以让每次打印结果不变动，这里是为了便于学习理解
*/ | block_comment | zh-cn | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... |
30_15 | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... | wangzheng0822/algo | java/17_skiplist/SkipList2.java | 2,738 | // 随机一个层数 | line_comment | zh-cn | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... |
30_16 | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... | wangzheng0822/algo | java/17_skiplist/SkipList2.java | 2,738 | // 创建新节点 | line_comment | zh-cn | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... |
30_17 | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... | wangzheng0822/algo | java/17_skiplist/SkipList2.java | 2,738 | // 表示从最大层到低层，都要有节点数据 | line_comment | zh-cn | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... |
30_18 | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... | wangzheng0822/algo | java/17_skiplist/SkipList2.java | 2,738 | // 记录要更新的层数，表示新节点要更新到哪几层 | line_comment | zh-cn | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... |
30_19 | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... | wangzheng0822/algo | java/17_skiplist/SkipList2.java | 2,738 | /**
*
* 1，说明：层是从下到上的，这里最下层编号是0，最上层编号是15
* 2，这里没有从已有数据最大层（编号最大）开始找，（而是随机层的最大层）导致有些问题。
* 如果数据量为1亿，随机level=1 ，那么插入时间复杂度为O（n）
*/ | block_comment | zh-cn | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... |
30_20 | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... | wangzheng0822/algo | java/17_skiplist/SkipList2.java | 2,738 | // 这里update[i]表示当前层节点的前一节点，因为要找到前一节点，才好插入数据 | line_comment | zh-cn | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... |
30_21 | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... | wangzheng0822/algo | java/17_skiplist/SkipList2.java | 2,738 | // 将每一层节点和后面节点关联 | line_comment | zh-cn | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... |
30_22 | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... | wangzheng0822/algo | java/17_skiplist/SkipList2.java | 2,738 | // 记录当前层节点后面节点指针 | line_comment | zh-cn | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... |
30_23 | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... | wangzheng0822/algo | java/17_skiplist/SkipList2.java | 2,738 | // 前一个节点的指针，指向当前节点 | line_comment | zh-cn | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... |
30_24 | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... | wangzheng0822/algo | java/17_skiplist/SkipList2.java | 2,738 | // 更新层高 | line_comment | zh-cn | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... |
30_26 | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... | wangzheng0822/algo | java/17_skiplist/SkipList2.java | 2,738 | /**
* 打印每个节点数据和最大层数
*/ | block_comment | zh-cn | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... |
30_27 | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... | wangzheng0822/algo | java/17_skiplist/SkipList2.java | 2,738 | /**
* 打印所有数据
*/ | block_comment | zh-cn | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... |
30_28 | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... | wangzheng0822/algo | java/17_skiplist/SkipList2.java | 2,738 | /**
* 跳表的节点，每个节点记录了当前节点数据和所在层数数据
*/ | block_comment | zh-cn | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... |
30_29 | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... | wangzheng0822/algo | java/17_skiplist/SkipList2.java | 2,738 | /**
* 表示当前节点位置的下一个节点所有层的数据，从上层切换到下层，就是数组下标-1，
* forwards[3]表示当前节点在第三层的下一个节点。
*/ | block_comment | zh-cn | package com.study.skiplist;
import java.util.Random;
/**
* 1，跳表的一种实现方法，用于练习。跳表中存储的是正整数，并且存储的是不重复的。
* 2，本类是参考作者zheng ，自己学习，优化了添加方法
* 3，看完这个，我觉得再看ConcurrentSkipListMap 源码，会有很大收获
* Author：ldb
*/
public class SkipList2 {
private static final int MAX_LEVEL = 16;
private int levelCount = 1;
/**
* 带头... |
31_1 | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... | crossoverJie/JCSprout | src/main/java/com/crossoverjie/actual/LRUAbstractMap.java | 1,963 | /**
* 检查是否超期线程
*/ | block_comment | zh-cn | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... |
31_3 | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... | crossoverJie/JCSprout | src/main/java/com/crossoverjie/actual/LRUAbstractMap.java | 1,963 | /**
* 默认大小
*/ | block_comment | zh-cn | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... |
31_4 | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... | crossoverJie/JCSprout | src/main/java/com/crossoverjie/actual/LRUAbstractMap.java | 1,963 | /**
* 数组长度
*/ | block_comment | zh-cn | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... |
31_5 | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... | crossoverJie/JCSprout | src/main/java/com/crossoverjie/actual/LRUAbstractMap.java | 1,963 | /**
* 数组
*/ | block_comment | zh-cn | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... |
31_7 | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... | crossoverJie/JCSprout | src/main/java/com/crossoverjie/actual/LRUAbstractMap.java | 1,963 | /**
* 超时时间
*/ | block_comment | zh-cn | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... |
31_9 | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... | crossoverJie/JCSprout | src/main/java/com/crossoverjie/actual/LRUAbstractMap.java | 1,963 | //开启一个线程检查最先放入队列的值是否超期 | line_comment | zh-cn | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... |
31_10 | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... | crossoverJie/JCSprout | src/main/java/com/crossoverjie/actual/LRUAbstractMap.java | 1,963 | /**
* 开启一个线程检查最先放入队列的值是否超期 设置为守护线程
*/ | block_comment | zh-cn | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... |
31_11 | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... | crossoverJie/JCSprout | src/main/java/com/crossoverjie/actual/LRUAbstractMap.java | 1,963 | //写入队列 | line_comment | zh-cn | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... |
31_12 | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... | crossoverJie/JCSprout | src/main/java/com/crossoverjie/actual/LRUAbstractMap.java | 1,963 | //存在就覆盖 | line_comment | zh-cn | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... |
31_13 | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... | crossoverJie/JCSprout | src/main/java/com/crossoverjie/actual/LRUAbstractMap.java | 1,963 | //key 存在 就覆盖 简单判断 | line_comment | zh-cn | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... |
31_14 | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... | crossoverJie/JCSprout | src/main/java/com/crossoverjie/actual/LRUAbstractMap.java | 1,963 | //不存在就新增链表 | line_comment | zh-cn | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... |
31_15 | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... | crossoverJie/JCSprout | src/main/java/com/crossoverjie/actual/LRUAbstractMap.java | 1,963 | //写入队列 | line_comment | zh-cn | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... |
31_16 | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... | crossoverJie/JCSprout | src/main/java/com/crossoverjie/actual/LRUAbstractMap.java | 1,963 | //更新时间 | line_comment | zh-cn | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... |
31_17 | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... | crossoverJie/JCSprout | src/main/java/com/crossoverjie/actual/LRUAbstractMap.java | 1,963 | //没有冲突 | line_comment | zh-cn | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... |
31_18 | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... | crossoverJie/JCSprout | src/main/java/com/crossoverjie/actual/LRUAbstractMap.java | 1,963 | //更新时间 | line_comment | zh-cn | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... |
31_19 | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... | crossoverJie/JCSprout | src/main/java/com/crossoverjie/actual/LRUAbstractMap.java | 1,963 | //移除队列 | line_comment | zh-cn | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... |
31_20 | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... | crossoverJie/JCSprout | src/main/java/com/crossoverjie/actual/LRUAbstractMap.java | 1,963 | //在链表中找到了 把上一个节点的 next 指向当前节点的下一个节点 | line_comment | zh-cn | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... |
31_21 | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... | crossoverJie/JCSprout | src/main/java/com/crossoverjie/actual/LRUAbstractMap.java | 1,963 | //移除队列 | line_comment | zh-cn | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... |
31_23 | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... | crossoverJie/JCSprout | src/main/java/com/crossoverjie/actual/LRUAbstractMap.java | 1,963 | //在put值时候认为里边已经有数据了 | line_comment | zh-cn | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... |
31_24 | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... | crossoverJie/JCSprout | src/main/java/com/crossoverjie/actual/LRUAbstractMap.java | 1,963 | //找到队列头的数据 | line_comment | zh-cn | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... |
31_26 | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... | crossoverJie/JCSprout | src/main/java/com/crossoverjie/actual/LRUAbstractMap.java | 1,963 | /**
* 数量减小
*/ | block_comment | zh-cn | package com.crossoverjie.actual;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Function:
*
* 1.在做 key 生成 hashcode 时是用的 HashMap 的 ha... |
33_6 | package cn.hutool.core.lang;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.util.StrUtil;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Random;
/**
* 提供通用唯一识别码（universally unique identifier）（UUID）实现，UUID表示一个128位的值... | dromara/hutool | hutool-core/src/main/java/cn/hutool/core/lang/UUID.java | 4,525 | /**
* 获取类型 4（伪随机生成的）UUID 的静态工厂。 使用加密的本地线程伪随机数生成器生成该 UUID。
*
* @return 随机生成的 {@code UUID}
*/ | block_comment | zh-cn | package cn.hutool.core.lang;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.util.StrUtil;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Random;
/**
* 提供通用唯一识别码（universally unique identifier）（UUID）实现，UUID表示一个128位的值... |
33_7 | package cn.hutool.core.lang;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.util.StrUtil;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Random;
/**
* 提供通用唯一识别码（universally unique identifier）（UUID）实现，UUID表示一个128位的值... | dromara/hutool | hutool-core/src/main/java/cn/hutool/core/lang/UUID.java | 4,525 | /**
* 获取类型 4（伪随机生成的）UUID 的静态工厂。 使用加密的强伪随机数生成器生成该 UUID。
*
* @return 随机生成的 {@code UUID}
*/ | block_comment | zh-cn | package cn.hutool.core.lang;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.util.StrUtil;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Random;
/**
* 提供通用唯一识别码（universally unique identifier）（UUID）实现，UUID表示一个128位的值... |
33_19 | package cn.hutool.core.lang;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.util.StrUtil;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Random;
/**
* 提供通用唯一识别码（universally unique identifier）（UUID）实现，UUID表示一个128位的值... | dromara/hutool | hutool-core/src/main/java/cn/hutool/core/lang/UUID.java | 4,525 | /**
* 返回此 UUID 的 128 位值中的最低有效 64 位。
*
* @return 此 UUID 的 128 位值中的最低有效 64 位。
*/ | block_comment | zh-cn | package cn.hutool.core.lang;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.util.StrUtil;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Random;
/**
* 提供通用唯一识别码（universally unique identifier）（UUID）实现，UUID表示一个128位的值... |
33_20 | package cn.hutool.core.lang;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.util.StrUtil;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Random;
/**
* 提供通用唯一识别码（universally unique identifier）（UUID）实现，UUID表示一个128位的值... | dromara/hutool | hutool-core/src/main/java/cn/hutool/core/lang/UUID.java | 4,525 | /**
* 返回此 UUID 的 128 位值中的最高有效 64 位。
*
* @return 此 UUID 的 128 位值中最高有效 64 位。
*/ | block_comment | zh-cn | package cn.hutool.core.lang;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.util.StrUtil;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Random;
/**
* 提供通用唯一识别码（universally unique identifier）（UUID）实现，UUID表示一个128位的值... |
33_43 | package cn.hutool.core.lang;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.util.StrUtil;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Random;
/**
* 提供通用唯一识别码（universally unique identifier）（UUID）实现，UUID表示一个128位的值... | dromara/hutool | hutool-core/src/main/java/cn/hutool/core/lang/UUID.java | 4,525 | /**
* 将此 UUID 与指定的 UUID 比较。
*
* <p>
* 如果两个 UUID 不同，且第一个 UUID 的最高有效字段大于第二个 UUID 的对应字段，则第一个 UUID 大于第二个 UUID。
*
* @param val 与此 UUID 比较的 UUID
* @return 在此 UUID 小于、等于或大于 val 时，分别返回 -1、0 或 1。
*/ | block_comment | zh-cn | package cn.hutool.core.lang;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.util.StrUtil;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Random;
/**
* 提供通用唯一识别码（universally unique identifier）（UUID）实现，UUID表示一个128位的值... |
35_4 | package io.mycat.catlets;
import java.util.LinkedHashMap;
import java.util.List;
import org.slf4j.Logger; import org.slf4j.LoggerFactory;
import com.alibaba.druid.sql.SQLUtils;
import com.alibaba.druid.sql.ast.SQLExpr;
import com.alibaba.druid.sql.ast.SQLOrderBy;
import com.alibaba.druid.sql.ast.SQLOrder... | MyCATApache/Mycat-Server | src/main/java/io/mycat/catlets/JoinParser.java | 3,677 | // 组成链表
| line_comment | zh-cn | package io.mycat.catlets;
import java.util.LinkedHashMap;
import java.util.List;
import org.slf4j.Logger; import org.slf4j.LoggerFactory;
import com.alibaba.druid.sql.SQLUtils;
import com.alibaba.druid.sql.ast.SQLExpr;
import com.alibaba.druid.sql.ast.SQLOrderBy;
import com.alibaba.druid.sql.ast.SQLOrder... |
35_5 | package io.mycat.catlets;
import java.util.LinkedHashMap;
import java.util.List;
import org.slf4j.Logger; import org.slf4j.LoggerFactory;
import com.alibaba.druid.sql.SQLUtils;
import com.alibaba.druid.sql.ast.SQLExpr;
import com.alibaba.druid.sql.ast.SQLOrderBy;
import com.alibaba.druid.sql.ast.SQLOrder... | MyCATApache/Mycat-Server | src/main/java/io/mycat/catlets/JoinParser.java | 3,677 | //查询字段放到各个查询表中。
| line_comment | zh-cn | package io.mycat.catlets;
import java.util.LinkedHashMap;
import java.util.List;
import org.slf4j.Logger; import org.slf4j.LoggerFactory;
import com.alibaba.druid.sql.SQLUtils;
import com.alibaba.druid.sql.ast.SQLExpr;
import com.alibaba.druid.sql.ast.SQLOrderBy;
import com.alibaba.druid.sql.ast.SQLOrder... |
35_7 | package io.mycat.catlets;
import java.util.LinkedHashMap;
import java.util.List;
import org.slf4j.Logger; import org.slf4j.LoggerFactory;
import com.alibaba.druid.sql.SQLUtils;
import com.alibaba.druid.sql.ast.SQLExpr;
import com.alibaba.druid.sql.ast.SQLOrderBy;
import com.alibaba.druid.sql.ast.SQLOrder... | MyCATApache/Mycat-Server | src/main/java/io/mycat/catlets/JoinParser.java | 3,677 | // where 条件放到各个查询表中。
| line_comment | zh-cn | package io.mycat.catlets;
import java.util.LinkedHashMap;
import java.util.List;
import org.slf4j.Logger; import org.slf4j.LoggerFactory;
import com.alibaba.druid.sql.SQLUtils;
import com.alibaba.druid.sql.ast.SQLExpr;
import com.alibaba.druid.sql.ast.SQLOrderBy;
import com.alibaba.druid.sql.ast.SQLOrder... |
35_9 | package io.mycat.catlets;
import java.util.LinkedHashMap;
import java.util.List;
import org.slf4j.Logger; import org.slf4j.LoggerFactory;
import com.alibaba.druid.sql.SQLUtils;
import com.alibaba.druid.sql.ast.SQLExpr;
import com.alibaba.druid.sql.ast.SQLOrderBy;
import com.alibaba.druid.sql.ast.SQLOrder... | MyCATApache/Mycat-Server | src/main/java/io/mycat/catlets/JoinParser.java | 3,677 | // order 条件放到各个查询表中。
| line_comment | zh-cn | package io.mycat.catlets;
import java.util.LinkedHashMap;
import java.util.List;
import org.slf4j.Logger; import org.slf4j.LoggerFactory;
import com.alibaba.druid.sql.SQLUtils;
import com.alibaba.druid.sql.ast.SQLExpr;
import com.alibaba.druid.sql.ast.SQLOrderBy;
import com.alibaba.druid.sql.ast.SQLOrder... |
35_19 | package io.mycat.catlets;
import java.util.LinkedHashMap;
import java.util.List;
import org.slf4j.Logger; import org.slf4j.LoggerFactory;
import com.alibaba.druid.sql.SQLUtils;
import com.alibaba.druid.sql.ast.SQLExpr;
import com.alibaba.druid.sql.ast.SQLOrderBy;
import com.alibaba.druid.sql.ast.SQLOrder... | MyCATApache/Mycat-Server | src/main/java/io/mycat/catlets/JoinParser.java | 3,677 | //显示的字段
| line_comment | zh-cn | package io.mycat.catlets;
import java.util.LinkedHashMap;
import java.util.List;
import org.slf4j.Logger; import org.slf4j.LoggerFactory;
import com.alibaba.druid.sql.SQLUtils;
import com.alibaba.druid.sql.ast.SQLExpr;
import com.alibaba.druid.sql.ast.SQLOrderBy;
import com.alibaba.druid.sql.ast.SQLOrder... |
35_30 | package io.mycat.catlets;
import java.util.LinkedHashMap;
import java.util.List;
import org.slf4j.Logger; import org.slf4j.LoggerFactory;
import com.alibaba.druid.sql.SQLUtils;
import com.alibaba.druid.sql.ast.SQLExpr;
import com.alibaba.druid.sql.ast.SQLOrderBy;
import com.alibaba.druid.sql.ast.SQLOrder... | MyCATApache/Mycat-Server | src/main/java/io/mycat/catlets/JoinParser.java | 3,677 | //获取表达式 左边的值
| line_comment | zh-cn | package io.mycat.catlets;
import java.util.LinkedHashMap;
import java.util.List;
import org.slf4j.Logger; import org.slf4j.LoggerFactory;
import com.alibaba.druid.sql.SQLUtils;
import com.alibaba.druid.sql.ast.SQLExpr;
import com.alibaba.druid.sql.ast.SQLOrderBy;
import com.alibaba.druid.sql.ast.SQLOrder... |
35_31 | package io.mycat.catlets;
import java.util.LinkedHashMap;
import java.util.List;
import org.slf4j.Logger; import org.slf4j.LoggerFactory;
import com.alibaba.druid.sql.SQLUtils;
import com.alibaba.druid.sql.ast.SQLExpr;
import com.alibaba.druid.sql.ast.SQLOrderBy;
import com.alibaba.druid.sql.ast.SQLOrder... | MyCATApache/Mycat-Server | src/main/java/io/mycat/catlets/JoinParser.java | 3,677 | //获取表达式右边的值
| line_comment | zh-cn | package io.mycat.catlets;
import java.util.LinkedHashMap;
import java.util.List;
import org.slf4j.Logger; import org.slf4j.LoggerFactory;
import com.alibaba.druid.sql.SQLUtils;
import com.alibaba.druid.sql.ast.SQLExpr;
import com.alibaba.druid.sql.ast.SQLOrderBy;
import com.alibaba.druid.sql.ast.SQLOrder... |
35_37 | package io.mycat.catlets;
import java.util.LinkedHashMap;
import java.util.List;
import org.slf4j.Logger; import org.slf4j.LoggerFactory;
import com.alibaba.druid.sql.SQLUtils;
import com.alibaba.druid.sql.ast.SQLExpr;
import com.alibaba.druid.sql.ast.SQLOrderBy;
import com.alibaba.druid.sql.ast.SQLOrder... | MyCATApache/Mycat-Server | src/main/java/io/mycat/catlets/JoinParser.java | 3,677 | //返回a表排序的字段
| line_comment | zh-cn | package io.mycat.catlets;
import java.util.LinkedHashMap;
import java.util.List;
import org.slf4j.Logger; import org.slf4j.LoggerFactory;
import com.alibaba.druid.sql.SQLUtils;
import com.alibaba.druid.sql.ast.SQLExpr;
import com.alibaba.druid.sql.ast.SQLOrderBy;
import com.alibaba.druid.sql.ast.SQLOrder... |
35_38 | package io.mycat.catlets;
import java.util.LinkedHashMap;
import java.util.List;
import org.slf4j.Logger; import org.slf4j.LoggerFactory;
import com.alibaba.druid.sql.SQLUtils;
import com.alibaba.druid.sql.ast.SQLExpr;
import com.alibaba.druid.sql.ast.SQLOrderBy;
import com.alibaba.druid.sql.ast.SQLOrder... | MyCATApache/Mycat-Server | src/main/java/io/mycat/catlets/JoinParser.java | 3,677 | //返回b表排序的字段
| line_comment | zh-cn | package io.mycat.catlets;
import java.util.LinkedHashMap;
import java.util.List;
import org.slf4j.Logger; import org.slf4j.LoggerFactory;
import com.alibaba.druid.sql.SQLUtils;
import com.alibaba.druid.sql.ast.SQLExpr;
import com.alibaba.druid.sql.ast.SQLOrderBy;
import com.alibaba.druid.sql.ast.SQLOrder... |
36_16 | /*Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
This source code is licensed under the Apache License Version 2.0.*/
package apijson;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**use this class instead of com.alibaba.fast... | Tencent/APIJSON | APIJSONORM/src/main/java/apijson/JSONObject.java | 5,204 | //@key关键字都放这个类 <<<<<<<<<<<<<<<<<<<<<< | line_comment | zh-cn | /*Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
This source code is licensed under the Apache License Version 2.0.*/
package apijson;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**use this class instead of com.alibaba.fast... |
36_17 | /*Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
This source code is licensed under the Apache License Version 2.0.*/
package apijson;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**use this class instead of com.alibaba.fast... | Tencent/APIJSON | APIJSONORM/src/main/java/apijson/JSONObject.java | 5,204 | //尝试，忽略异常 | line_comment | zh-cn | /*Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
This source code is licensed under the Apache License Version 2.0.*/
package apijson;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**use this class instead of com.alibaba.fast... |
36_24 | /*Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
This source code is licensed under the Apache License Version 2.0.*/
package apijson;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**use this class instead of com.alibaba.fast... | Tencent/APIJSON | APIJSONORM/src/main/java/apijson/JSONObject.java | 5,204 | //角色，拥有对某些数据的某些操作的权限 | line_comment | zh-cn | /*Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
This source code is licensed under the Apache License Version 2.0.*/
package apijson;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**use this class instead of com.alibaba.fast... |
36_25 | /*Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
This source code is licensed under the Apache License Version 2.0.*/
package apijson;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**use this class instead of com.alibaba.fast... | Tencent/APIJSON | APIJSONORM/src/main/java/apijson/JSONObject.java | 5,204 | //数据库类型，默认为MySQL | line_comment | zh-cn | /*Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
This source code is licensed under the Apache License Version 2.0.*/
package apijson;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**use this class instead of com.alibaba.fast... |
36_27 | /*Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
This source code is licensed under the Apache License Version 2.0.*/
package apijson;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**use this class instead of com.alibaba.fast... | Tencent/APIJSON | APIJSONORM/src/main/java/apijson/JSONObject.java | 5,204 | //数据源 | line_comment | zh-cn | /*Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
This source code is licensed under the Apache License Version 2.0.*/
package apijson;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**use this class instead of com.alibaba.fast... |
36_34 | /*Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
This source code is licensed under the Apache License Version 2.0.*/
package apijson;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**use this class instead of com.alibaba.fast... | Tencent/APIJSON | APIJSONORM/src/main/java/apijson/JSONObject.java | 5,204 | //聚合函数条件，一般和@group一起用 | line_comment | zh-cn | /*Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
This source code is licensed under the Apache License Version 2.0.*/
package apijson;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**use this class instead of com.alibaba.fast... |
36_35 | /*Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
This source code is licensed under the Apache License Version 2.0.*/
package apijson;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**use this class instead of com.alibaba.fast... | Tencent/APIJSON | APIJSONORM/src/main/java/apijson/JSONObject.java | 5,204 | //聚合函数条件，一般和@group一起用 | line_comment | zh-cn | /*Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
This source code is licensed under the Apache License Version 2.0.*/
package apijson;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**use this class instead of com.alibaba.fast... |
36_36 | /*Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
This source code is licensed under the Apache License Version 2.0.*/
package apijson;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**use this class instead of com.alibaba.fast... | Tencent/APIJSON | APIJSONORM/src/main/java/apijson/JSONObject.java | 5,204 | //排序方式 | line_comment | zh-cn | /*Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
This source code is licensed under the Apache License Version 2.0.*/
package apijson;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**use this class instead of com.alibaba.fast... |
36_48 | /*Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
This source code is licensed under the Apache License Version 2.0.*/
package apijson;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**use this class instead of com.alibaba.fast... | Tencent/APIJSON | APIJSONORM/src/main/java/apijson/JSONObject.java | 5,204 | //@key关键字都放这个类 >>>>>>>>>>>>>>>>>>>>>> | line_comment | zh-cn | /*Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
This source code is licensed under the Apache License Version 2.0.*/
package apijson;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**use this class instead of com.alibaba.fast... |
37_1 | package Stack;
/**
* 顺序栈(基于数组实现)
* Author: PeiJiaNi
*/
public class StackBaseArray {
private int[] items; // 数组
private int count; // 栈中元素个数
private int length; // 栈空间大小
public StackBaseArray(int capactiy) {
this.items = new int[capactiy];
this.count = 0;
this.leng... | wangzheng0822/algo | StackBaseArray.java | 442 | // 栈中元素个数 | line_comment | zh-cn | package Stack;
/**
* 顺序栈(基于数组实现)
* Author: PeiJiaNi
*/
public class StackBaseArray {
private int[] items; // 数组
private int count; // 栈中 <SUF>
private int length; // 栈空间大小
public StackBaseArray(int capactiy) {
this.items = new int[capactiy];
this.count = 0;
this.le... |
37_2 | package Stack;
/**
* 顺序栈(基于数组实现)
* Author: PeiJiaNi
*/
public class StackBaseArray {
private int[] items; // 数组
private int count; // 栈中元素个数
private int length; // 栈空间大小
public StackBaseArray(int capactiy) {
this.items = new int[capactiy];
this.count = 0;
this.leng... | wangzheng0822/algo | StackBaseArray.java | 442 | // 栈空间大小 | line_comment | zh-cn | package Stack;
/**
* 顺序栈(基于数组实现)
* Author: PeiJiaNi
*/
public class StackBaseArray {
private int[] items; // 数组
private int count; // 栈中元素个数
private int length; // 栈空 <SUF>
public StackBaseArray(int capactiy) {
this.items = new int[capactiy];
this.count = 0;
this.l... |
39_1 | /**
* File: top_k.java
* Created Time: 2023-06-12
* Author: krahets (krahets@163.com)
*/
package chapter_heap;
import utils.*;
import java.util.*;
public class top_k {
/* 基于堆查找数组中最大的 k 个元素 */
static Queue<Integer> topKHeap(int[] nums, int k) {
// 初始化小顶堆
Queue<Integer> heap = new PriorityQ... | krahets/hello-algo | codes/java/chapter_heap/top_k.java | 341 | /* 基于堆查找数组中最大的 k 个元素 */ | block_comment | zh-cn | /**
* File: top_k.java
* Created Time: 2023-06-12
* Author: krahets (krahets@163.com)
*/
package chapter_heap;
import utils.*;
import java.util.*;
public class top_k {
/* 基于堆 <SUF>*/
static Queue<Integer> topKHeap(int[] nums, int k) {
// 初始化小顶堆
Queue<Integer> heap = new PriorityQueue<Inte... |
39_3 | /**
* File: top_k.java
* Created Time: 2023-06-12
* Author: krahets (krahets@163.com)
*/
package chapter_heap;
import utils.*;
import java.util.*;
public class top_k {
/* 基于堆查找数组中最大的 k 个元素 */
static Queue<Integer> topKHeap(int[] nums, int k) {
// 初始化小顶堆
Queue<Integer> heap = new PriorityQ... | krahets/hello-algo | codes/java/chapter_heap/top_k.java | 341 | // 将数组的前 k 个元素入堆 | line_comment | zh-cn | /**
* File: top_k.java
* Created Time: 2023-06-12
* Author: krahets (krahets@163.com)
*/
package chapter_heap;
import utils.*;
import java.util.*;
public class top_k {
/* 基于堆查找数组中最大的 k 个元素 */
static Queue<Integer> topKHeap(int[] nums, int k) {
// 初始化小顶堆
Queue<Integer> heap = new PriorityQ... |
39_4 | /**
* File: top_k.java
* Created Time: 2023-06-12
* Author: krahets (krahets@163.com)
*/
package chapter_heap;
import utils.*;
import java.util.*;
public class top_k {
/* 基于堆查找数组中最大的 k 个元素 */
static Queue<Integer> topKHeap(int[] nums, int k) {
// 初始化小顶堆
Queue<Integer> heap = new PriorityQ... | krahets/hello-algo | codes/java/chapter_heap/top_k.java | 341 | // 从第 k+1 个元素开始，保持堆的长度为 k | line_comment | zh-cn | /**
* File: top_k.java
* Created Time: 2023-06-12
* Author: krahets (krahets@163.com)
*/
package chapter_heap;
import utils.*;
import java.util.*;
public class top_k {
/* 基于堆查找数组中最大的 k 个元素 */
static Queue<Integer> topKHeap(int[] nums, int k) {
// 初始化小顶堆
Queue<Integer> heap = new PriorityQ... |
39_5 | /**
* File: top_k.java
* Created Time: 2023-06-12
* Author: krahets (krahets@163.com)
*/
package chapter_heap;
import utils.*;
import java.util.*;
public class top_k {
/* 基于堆查找数组中最大的 k 个元素 */
static Queue<Integer> topKHeap(int[] nums, int k) {
// 初始化小顶堆
Queue<Integer> heap = new PriorityQ... | krahets/hello-algo | codes/java/chapter_heap/top_k.java | 341 | // 若当前元素大于堆顶元素，则将堆顶元素出堆、当前元素入堆 | line_comment | zh-cn | /**
* File: top_k.java
* Created Time: 2023-06-12
* Author: krahets (krahets@163.com)
*/
package chapter_heap;
import utils.*;
import java.util.*;
public class top_k {
/* 基于堆查找数组中最大的 k 个元素 */
static Queue<Integer> topKHeap(int[] nums, int k) {
// 初始化小顶堆
Queue<Integer> heap = new PriorityQ... |
41_1 | package org.yousharp.julycoding.string;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.yousharp.common.ListNode;
/**
* 1.1 旋转字符串
* (github链接：https://github.com/julycoding/The-Art-Of-Programming-By-July/blob/master/ebook/zh/01.01.md)
*
* Created by lingguo on 14-6-26.
*/
public class RotateSt... | julycoding/The-Art-Of-Programming-By-July-2nd | ebook/code/java/chapter1/1.1：左旋转字符串.java | 1,548 | /**
* 问题描述：
* 给定一个字符串，要求把字符串前面的若干个字符移动到字符串的尾部，如把字符串“abcdef”前面的2个字符'a'和'b'移动到字符串
* 的尾部，使得原字符串变成字符串“cdefab”。请写一个函数完成此功能，要求对长度为n的字符串操作的时间复杂度为 O(n)，空间
* 复杂度为 O(1)。
*
* 思路：
* 三步旋转法：(X^TY^T)^T=YX
*
* @param str 输入串
* @param n 前n个字符移到串的最后
* @return 翻转后的串
... | block_comment | zh-cn | package org.yousharp.julycoding.string;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.yousharp.common.ListNode;
/**
* 1.1 旋转字符串
* (github链接：https://github.com/julycoding/The-Art-Of-Programming-By-July/blob/master/ebook/zh/01.01.md)
*
* Created by lingguo on 14-6-26.
*/
public class RotateSt... |
41_3 | package org.yousharp.julycoding.string;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.yousharp.common.ListNode;
/**
* 1.1 旋转字符串
* (github链接：https://github.com/julycoding/The-Art-Of-Programming-By-July/blob/master/ebook/zh/01.01.md)
*
* Created by lingguo on 14-6-26.
*/
public class RotateSt... | julycoding/The-Art-Of-Programming-By-July-2nd | ebook/code/java/chapter1/1.1：左旋转字符串.java | 1,548 | /**
* 问题描述：
* 链表翻转。给出一个链表和一个数k，比如，链表为1→2→3→4→5→6，k=2，则翻转后2→1→6→5→4→3，若k=3，翻转后
* 3→2→1→6→5→4，若k=4，翻转后4→3→2→1→6→5，用程序实现。
*
* 思路：
* 使用反转链表的思路，将链表的前部分反转，然后将链表的后部分反转，最后将前部分链表的尾节点指向后部分链表的头节点。
*
* @param head 链表的头节点
* @param n 将前n个节点反转，剩下的节点反转
* @return 翻转后链表的头节点
... | block_comment | zh-cn | package org.yousharp.julycoding.string;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.yousharp.common.ListNode;
/**
* 1.1 旋转字符串
* (github链接：https://github.com/julycoding/The-Art-Of-Programming-By-July/blob/master/ebook/zh/01.01.md)
*
* Created by lingguo on 14-6-26.
*/
public class RotateSt... |
41_4 | package org.yousharp.julycoding.string;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.yousharp.common.ListNode;
/**
* 1.1 旋转字符串
* (github链接：https://github.com/julycoding/The-Art-Of-Programming-By-July/blob/master/ebook/zh/01.01.md)
*
* Created by lingguo on 14-6-26.
*/
public class RotateSt... | julycoding/The-Art-Of-Programming-By-July-2nd | ebook/code/java/chapter1/1.1：左旋转字符串.java | 1,548 | // 左链表的终点 | line_comment | zh-cn | package org.yousharp.julycoding.string;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.yousharp.common.ListNode;
/**
* 1.1 旋转字符串
* (github链接：https://github.com/julycoding/The-Art-Of-Programming-By-July/blob/master/ebook/zh/01.01.md)
*
* Created by lingguo on 14-6-26.
*/
public class RotateSt... |
41_7 | package org.yousharp.julycoding.string;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.yousharp.common.ListNode;
/**
* 1.1 旋转字符串
* (github链接：https://github.com/julycoding/The-Art-Of-Programming-By-July/blob/master/ebook/zh/01.01.md)
*
* Created by lingguo on 14-6-26.
*/
public class RotateSt... | julycoding/The-Art-Of-Programming-By-July-2nd | ebook/code/java/chapter1/1.1：左旋转字符串.java | 1,548 | // 左右部分连接起来 | line_comment | zh-cn | package org.yousharp.julycoding.string;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.yousharp.common.ListNode;
/**
* 1.1 旋转字符串
* (github链接：https://github.com/julycoding/The-Art-Of-Programming-By-July/blob/master/ebook/zh/01.01.md)
*
* Created by lingguo on 14-6-26.
*/
public class RotateSt... |
41_9 | package org.yousharp.julycoding.string;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.yousharp.common.ListNode;
/**
* 1.1 旋转字符串
* (github链接：https://github.com/julycoding/The-Art-Of-Programming-By-July/blob/master/ebook/zh/01.01.md)
*
* Created by lingguo on 14-6-26.
*/
public class RotateSt... | julycoding/The-Art-Of-Programming-By-July-2nd | ebook/code/java/chapter1/1.1：左旋转字符串.java | 1,548 | /**
* 问题描述：
* 编写程序，在原字符串中把字符串尾部的m个字符移动到字符串的头部，要求：长度为n的字符串操作时间复杂度为O(n)，空间复杂度
* 为O(1)。 例如，原字符串为”Ilovebaofeng”，m=7，输出结果为：”baofengIlove”。
*
* 思路：
* 与左旋转字符串的思路是一样的；
*
* @param str 输入串
* @param n 将最后n个字符移到串的最前面
* @return 翻转后的串
*/ | block_comment | zh-cn | package org.yousharp.julycoding.string;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.yousharp.common.ListNode;
/**
* 1.1 旋转字符串
* (github链接：https://github.com/julycoding/The-Art-Of-Programming-By-July/blob/master/ebook/zh/01.01.md)
*
* Created by lingguo on 14-6-26.
*/
public class RotateSt... |
41_10 | package org.yousharp.julycoding.string;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.yousharp.common.ListNode;
/**
* 1.1 旋转字符串
* (github链接：https://github.com/julycoding/The-Art-Of-Programming-By-July/blob/master/ebook/zh/01.01.md)
*
* Created by lingguo on 14-6-26.
*/
public class RotateSt... | julycoding/The-Art-Of-Programming-By-July-2nd | ebook/code/java/chapter1/1.1：左旋转字符串.java | 1,548 | /**
* 问题描述：
* 单词翻转。输入一个英文句子，翻转句子中单词的顺序，但单词内字符的顺序不变，句子中单词以空格符隔开。为简单起见，标点符
* 号和普通字母一样处理。例如，输入“I am a student.”，则输出“student. a am I”。
*
* 思路：
* 先将每个单词反转，然后将整个句子反转；
*
* @param sentence 输入的句子
* @return 翻转后的句子
*/ | block_comment | zh-cn | package org.yousharp.julycoding.string;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.yousharp.common.ListNode;
/**
* 1.1 旋转字符串
* (github链接：https://github.com/julycoding/The-Art-Of-Programming-By-July/blob/master/ebook/zh/01.01.md)
*
* Created by lingguo on 14-6-26.
*/
public class RotateSt... |
41_11 | package org.yousharp.julycoding.string;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.yousharp.common.ListNode;
/**
* 1.1 旋转字符串
* (github链接：https://github.com/julycoding/The-Art-Of-Programming-By-July/blob/master/ebook/zh/01.01.md)
*
* Created by lingguo on 14-6-26.
*/
public class RotateSt... | julycoding/The-Art-Of-Programming-By-July-2nd | ebook/code/java/chapter1/1.1：左旋转字符串.java | 1,548 | // 空格是单词的分隔符 | line_comment | zh-cn | package org.yousharp.julycoding.string;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.yousharp.common.ListNode;
/**
* 1.1 旋转字符串
* (github链接：https://github.com/julycoding/The-Art-Of-Programming-By-July/blob/master/ebook/zh/01.01.md)
*
* Created by lingguo on 14-6-26.
*/
public class RotateSt... |
41_12 | package org.yousharp.julycoding.string;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.yousharp.common.ListNode;
/**
* 1.1 旋转字符串
* (github链接：https://github.com/julycoding/The-Art-Of-Programming-By-July/blob/master/ebook/zh/01.01.md)
*
* Created by lingguo on 14-6-26.
*/
public class RotateSt... | julycoding/The-Art-Of-Programming-By-July-2nd | ebook/code/java/chapter1/1.1：左旋转字符串.java | 1,548 | // 旋转一个单词 | line_comment | zh-cn | package org.yousharp.julycoding.string;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.yousharp.common.ListNode;
/**
* 1.1 旋转字符串
* (github链接：https://github.com/julycoding/The-Art-Of-Programming-By-July/blob/master/ebook/zh/01.01.md)
*
* Created by lingguo on 14-6-26.
*/
public class RotateSt... |
43_1 | package com.scwang.refreshlayout;
import android.app.Application;
import android.content.Context;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatDelegate;
import com.scwang.refreshlayout.util.DynamicTimeFormat;
import com.scwang.smartrefresh.layout.SmartRefreshLayout;
import com.scwang.sm... | scwang90/SmartRefreshLayout | app/src/main/java/com/scwang/refreshlayout/App.java | 636 | //启用矢量图兼容 | line_comment | zh-cn | package com.scwang.refreshlayout;
import android.app.Application;
import android.content.Context;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatDelegate;
import com.scwang.refreshlayout.util.DynamicTimeFormat;
import com.scwang.smartrefresh.layout.SmartRefreshLayout;
import com.scwang.sm... |
43_2 | package com.scwang.refreshlayout;
import android.app.Application;
import android.content.Context;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatDelegate;
import com.scwang.refreshlayout.util.DynamicTimeFormat;
import com.scwang.smartrefresh.layout.SmartRefreshLayout;
import com.scwang.sm... | scwang90/SmartRefreshLayout | app/src/main/java/com/scwang/refreshlayout/App.java | 636 | //设置全局默认配置（优先级最低，会被其他设置覆盖） | line_comment | zh-cn | package com.scwang.refreshlayout;
import android.app.Application;
import android.content.Context;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatDelegate;
import com.scwang.refreshlayout.util.DynamicTimeFormat;
import com.scwang.smartrefresh.layout.SmartRefreshLayout;
import com.scwang.sm... |
43_3 | package com.scwang.refreshlayout;
import android.app.Application;
import android.content.Context;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatDelegate;
import com.scwang.refreshlayout.util.DynamicTimeFormat;
import com.scwang.smartrefresh.layout.SmartRefreshLayout;
import com.scwang.sm... | scwang90/SmartRefreshLayout | app/src/main/java/com/scwang/refreshlayout/App.java | 636 | //全局设置（优先级最低） | line_comment | zh-cn | package com.scwang.refreshlayout;
import android.app.Application;
import android.content.Context;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatDelegate;
import com.scwang.refreshlayout.util.DynamicTimeFormat;
import com.scwang.smartrefresh.layout.SmartRefreshLayout;
import com.scwang.sm... |
44_1 | package com.zheng.common.util;
import java.security.MessageDigest;
import java.util.UUID;
/**
* Created by shuzheng on 2017/1/19.
*/
public class MD5Util {
public final static String md5(String content) {
//用于加密的字符
char[] md5String = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
... | shuzheng/zheng | zheng-common/src/main/java/com/zheng/common/util/MD5Util.java | 439 | //用于加密的字符 | line_comment | zh-cn | package com.zheng.common.util;
import java.security.MessageDigest;
import java.util.UUID;
/**
* Created by shuzheng on 2017/1/19.
*/
public class MD5Util {
public final static String md5(String content) {
//用于 <SUF>
char[] md5String = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
... |
44_2 | package com.zheng.common.util;
import java.security.MessageDigest;
import java.util.UUID;
/**
* Created by shuzheng on 2017/1/19.
*/
public class MD5Util {
public final static String md5(String content) {
//用于加密的字符
char[] md5String = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
... | shuzheng/zheng | zheng-common/src/main/java/com/zheng/common/util/MD5Util.java | 439 | //使用平台的默认字符集将此 String 编码为 byte序列，并将结果存储到一个新的 byte数组中 | line_comment | zh-cn | package com.zheng.common.util;
import java.security.MessageDigest;
import java.util.UUID;
/**
* Created by shuzheng on 2017/1/19.
*/
public class MD5Util {
public final static String md5(String content) {
//用于加密的字符
char[] md5String = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
... |
44_3 | package com.zheng.common.util;
import java.security.MessageDigest;
import java.util.UUID;
/**
* Created by shuzheng on 2017/1/19.
*/
public class MD5Util {
public final static String md5(String content) {
//用于加密的字符
char[] md5String = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
... | shuzheng/zheng | zheng-common/src/main/java/com/zheng/common/util/MD5Util.java | 439 | //信息摘要是安全的单向哈希函数，它接收任意大小的数据，并输出固定长度的哈希值。 | line_comment | zh-cn | package com.zheng.common.util;
import java.security.MessageDigest;
import java.util.UUID;
/**
* Created by shuzheng on 2017/1/19.
*/
public class MD5Util {
public final static String md5(String content) {
//用于加密的字符
char[] md5String = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
... |
44_5 | package com.zheng.common.util;
import java.security.MessageDigest;
import java.util.UUID;
/**
* Created by shuzheng on 2017/1/19.
*/
public class MD5Util {
public final static String md5(String content) {
//用于加密的字符
char[] md5String = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
... | shuzheng/zheng | zheng-common/src/main/java/com/zheng/common/util/MD5Util.java | 439 | // 摘要更新之后，通过调用digest（）执行哈希计算，获得密文 | line_comment | zh-cn | package com.zheng.common.util;
import java.security.MessageDigest;
import java.util.UUID;
/**
* Created by shuzheng on 2017/1/19.
*/
public class MD5Util {
public final static String md5(String content) {
//用于加密的字符
char[] md5String = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
... |
45_3 | /*
* The MIT License (MIT)
*
* Copyright (c) 2014-2023 abel533@gmail.com
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
... | pagehelper/Mybatis-PageHelper | src/main/java/com/github/pagehelper/Page.java | 4,167 | /**
* 页码，从1开始
*/ | block_comment | zh-cn | /*
* The MIT License (MIT)
*
* Copyright (c) 2014-2023 abel533@gmail.com
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
... |
45_7 | /*
* The MIT License (MIT)
*
* Copyright (c) 2014-2023 abel533@gmail.com
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
... | pagehelper/Mybatis-PageHelper | src/main/java/com/github/pagehelper/Page.java | 4,167 | /**
* 总数
*/ | block_comment | zh-cn | /*
* The MIT License (MIT)
*
* Copyright (c) 2014-2023 abel533@gmail.com
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
... |
45_8 | /*
* The MIT License (MIT)
*
* Copyright (c) 2014-2023 abel533@gmail.com
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
... | pagehelper/Mybatis-PageHelper | src/main/java/com/github/pagehelper/Page.java | 4,167 | /**
* 总页数
*/ | block_comment | zh-cn | /*
* The MIT License (MIT)
*
* Copyright (c) 2014-2023 abel533@gmail.com
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.