规则边缘的博客

你对str变量重新赋值了，str.length()的值也会变化。你把for循环去掉，if改成while应该就差不多了。

因为没加花括号，所以很容易看错，其实这段代码并没有在第二个for循环内。等效于如下代码：

#include<stdio.h>

void main()
{
    int a, b;
    for (a = 100; a <= 200; a++)
        //取100以内所有的数
    {
        for (b = 2; b < a; b++)
        {
            //穷举法判断是否有因子
            if (a % b == 0)//有则非质数
            {
                break;//跳出本次循环
            }
        }
        if (b >= a)//当条件为真则为质数
        {
            printf("%d\n", a);
        }
    }
}

养成好的习惯吧，不加花括号至少把缩进给弄好。

SELECT
  d.PID 
FROM 
  (SELECT 
    PID, COUNT(TID) as CNT 
  FROM 
    C 
  WHERE 
    TID IN('1','2','3')
  GROUP BY 
    PID) d
WHERE
  d.CNT=3  

思路大概是这样，语法不知道有没有问题。

先筛选出类型ID在参数列表中的所有记录，再进行分组计数，筛选出记录数为参数列表长度的组。

1. 这个循环会取下标+1的元素。

2. 第一次，取下标为0的元素，i为1，移除1。［2，3，4，5，6］

3.第二次，取下标为1的元素，i为3，移除3。［2，4，5，6］

4.第三次，取下标为2的元素，i为5，不进行remove操作。

5.第四次，取下标为3的元素，i为6，不进行remove操作。

1. 一个方法执行时，是以一个方法栈帧来表示的，方法栈帧中有一个局部变量表，存放方法的入参变量和方法中定义的变量。

2. 基本数据类型的变量作为入参，会将变量的值放在局部变量表中。如int a=1; deal(a); 局部变量表中放的就是1这个数值。

3. 引用类型的变量作为入参时，会将变量指向的对象的引用放在局部变量表中。如Map m = new HashMap();deal(m); 局部变量表中放的就是这个对象的引用。

4. 改变局部变量表中的值（包含数值和引用）都不会影响原来的变量（如 a=2;或 m=new HashMap()）。但是如果方法通过这个引用，改变引用指向的对象的属性，是会影响到原来的变量（如 m.put("a","A");）。

5. 所以是第二种说法正确。对其引用的改变不影响其值，但对其引用执行的对象的改变会影响其值。

PS：你可以理解有A和B两个学生，有个班长的变量指向A同学，将班长这个变量传入一个方法，你可以想象换一个班长和给班长一本笔记本的区别。

1. int a=b=2; 在编译器看来，等同 int a=(b=2);

2. 赋值运算符的返回值等于右值。

3. 执行时，会先执行 b=2；但此时b变量并没有声明。

4. 所以在int a=b=2;前加上int b;就行了。

1. for循环的代码最好用{}括起来。

2. 你的for循环含义就是当num不等于6时，循环读取整数放到num变量中。即读到6后结束循环。

直接减库存就行了吧。

另外肯定有一个订单表，跑个任务，定时检查过期未付款的订单，修改订单状态未失效之类的，库存表中再加一个库存就行。

1. \w包括字母和数字下划线。

2. \d表示数字。

3. +表示重复1次或多次，尽可能多重复。

4. +?表示重复1次或多次，但尽可能少重复。

5. 所以你如果需要懒惰匹配，可以用 re.match('\w+?(?=\d)', 'aap23').group()

是你stmt.execute(sql)返回的就是false吧.

1. 如上一个回答所言，parallelStream为并行流，会有多个线程并发执行forEach。

2. 并行流可以充分利用多CPU的优势，通常应用于大数据的处理。

1. 定义一个长度为48的布尔数组，记录48个区间的涵盖状态，初始值默认全为false。

2. 定义一个涵盖状态更新方法，传入一个数组，一个起始下标，一个结束下标。方法体为：将数组从起始下标到结束下标（不包含自身，起始和结束相等时不进行操作）间的元素值设为true。

3. 循环读取时间段，将时间段转换为数组下标。调用状态更新方法更新涵盖状态数组。

4. 遍历涵盖状态数组，全为true则表示涵盖了一整天的所有时间，否则有缺失。

PS：整体思路参考位图BitMap。

nohup 英文全称 no hang up（不挂起），用于在系统后台不挂断地运行命令，退出终端不会影响程序的运行。

nohup 命令，在默认情况下（非重定向时），会输出一个名叫 nohup.out 的文件到当前目录下

如果是有序的列表，可以采用跳表的思路来加快查找速度。

比如你在列表中平均取N个点（含起始元素）记录下来，就能降低logN倍的时间复杂度。

1. 假设三个文件为a.txt b.txt c.txt 。合并文件可以用cat a.txt b.txt c.txt。

2.排序可以用sort命令，-k选项是指定排序列，可以有多个，如果按字母排序（9大于10），不用加n,如果按数值排序（10大于9），需要加n。sort -k1 -k2n -k3n -k4n -k5n。

3.综合而言，可用如下命令(-k选项需不需要加n，视实际情况决定)：

cat a.txt b.txt c.txt |sort -k1 -k2 -k3n -k4n -k5n > sercerinfo.txt

你的zoo.cfg配置或者启动日志可以贴出来, 不然都看不出问题。

awk '(NR>0 && NR<200){print $1}' sw.txt

1. NR为内置变量，NumberOfRow。表示行号。

2. awk花括号前面可以加条件表达式，满足条件才会执行后面的代码块。

int main(void){
    int i;
    for (i=0;i<=5; i++)
    {
        if (i == 3){
            printf("%d\n",i);
            break;
        }
        printf("I will run forever !%d\n",i);
    }
    return 0;
 
}

1. 猜你想要的应该是这个效果。

2. 最好养成if代码块使用花括号包起来的习惯。

3. 代码缩进也要养成习惯。

function isByteArray(arr){
    return arr instanceof Array && arr.findIndex(item => item < -127 || item > 128) ==-1;
}

1. JavaScript数组的元素是不限定类型的，除非是TypeArray。

2. 所以思路就可以先判断入参是不是数组类型，再判断元素中是否有超出Byte范围的值。

1. 应该把报错信息（异常堆栈）和执行过程也贴出来。

2. 你这个代码就没啥意义，void readString(String s);你传个字串串进来的意义是啥？

1. 构造函数的声明不需要加返回值。

2. display不应该需要入参，输出自己的属性就行。

3. 成员变量不要用static修饰，不然所有对象用的就是同一个值。

4. 成员方法本来就可以使用静态变量。

turtle的RGB默认以0~1.0表示，先执行这个，就可以用0~255表示了。

turtle.colormode(255)

1. || 是或运算, 两边有一个为true,表达式就为true, 意为满足条件A或满足条件B。

2. &&是与运算，两边都为true，表达式才为true，意为满足条件A且满足条件B。

3. $3>1000 && $3<100 ，这个表达式肯定为false，不可能有一个值即大于1000，又小于100。

1、synchronized 简单点理解就是查询及修改一个对象实例的对象头中的标志位，两个线程要锁同一个对象才能实现同步。

2、生产者执行count++后，count变量实际上指向了另外一个对象，然而生产者线程并不持有新对象的锁，所以会在执行count.notifyAll时报IllegalMonitorStateException。

3、使用synchronized (count.toString().intern())报错原理也是一样，生产者执行count++后，count.toString().intern()或count实际上也会指向另外一个对象。所以会在执行count.toString().intern().notifyAll或count.notifyAll时报IllegalMonitorStateException。

4、如果先定义 private static String cintern = count.toString().intern(); 再锁cintern 对象就行可以。就是因为生产者执行count++后，cintern变量并不会改变，当前线程持有cintern指向的对象的锁，执行cintern.notifyAll自然不会报错。

	public static void main(String[] args) {
		String srcStr = "abcaabbccaaabbbcccddddaaad";
		countChar(srcStr).forEach((c, cnt) -> System.out.println(c + "---" + cnt));
		//如果只要取出现次数最大的字符和次数，再遍历一次map就行。注意一下是否存在多个字符出现次数一样就行。
	}

	public static Map<String, Integer> countChar(String srcStr) {
		//存放所有字符连续出现的最大次数
		Map<String, Integer> maxCntMap = new HashMap<>();
		//存放当前字符
		String workStr = "";
		//存放当前字符连续出现的次数
		int workCnt = 0;
		
		String[] srcList = srcStr.split("");
		for (String crt : srcList) {
			//如果遍历到的字符和上一个字符不同,重设当前字符和当前字符连续出现的次数
			if (! workStr.equals(crt)) {
				workStr = crt;
				workCnt = 0;
			}
			//当前字符连续出现的次数自增一
			workCnt++;
			//比较当前字符连续出现的次数和Map中记录的次数,决定是否更新Map中记录的次数
			if (maxCntMap.get(crt) == null || maxCntMap.get(crt) < workCnt) {
				maxCntMap.put(crt, workCnt);
			}
		}
		return maxCntMap;
	}

这样应该说很清晰了。

应该是encoding写成了encording报错了吧。你这截图截的不完整。

1. Thread.currentThread()返回当前线程对象;

2. 一个对象作为println方法的参数时，会调用该对象的toString()方法来获取需要打印的字符串。

3. 查看Thread类的toString方法, 可以看到打印的三个值分别为线程名，线程优先级，线程组名。

应该使用i2作为switch的条件,i1是第一个选择,i2才是第二个选择

原理和数据库连接差不多，你可以百度一下springboot整合redis，现成的API，调用就行。

你先了解一下方法栈帧的结构，方法栈帧中有局部变量表和操作数栈。（你画的图就不对，cat本身并不是一个栈帧）

局部变量表的slot中会存放两个字符数组的句柄（可以理解为内存地址）。

要取其中一个数组的元素时，从局部变量表中取出对应变量的句柄，然后通过数组下标，就知道cat[0]的地址了。

split函数的入参实际是一个正则表达式字符串，了解正则表达式的话，这个需求就不难做了。

先假设tok中不包含特殊字符，如果有的话，得先做一些转义处理。

public void mySplit(){
    String str = "asdfa1sdfadsf2sfaj ajf;la3fads";
    String tok = "12 3 1";
    String[] result=str.split("[" + tok + "]");
    System.out.println(Arrays.toString(result));
}

你可以维护一个US_MAP的字典结构，里面的key为userId，value为sessionId。

1. 用户登录成功后，先在US_MAP中通过当前userId获取原有sessionId，如果原有sessionId不为空且对应的原有Session有效，就删除这个原有Session。

2. US_MAP.put(当前userId, 当前sessionId);

参数传递的原理要先搞清楚。

你的exchange实现函数不对，入参应该是一个数组，和两个要互相交换的元素的下标。

另外，你贴代码可以使用代码段控件。

既然SQL注入的方式不行，后台又不能改动。

那就试试前端并发多个请求，每个请求带不同的condition，全查回来后在前端合并。

你第二个forward应该换为right或者left

turtle.forward(distance): 向当前画笔方向移动distance像素长度
turtle.backward(distance): 向当前画笔相反方向移动distance像素长度

turtle.right(degree): 顺时针移动degree°
turtle.left(degree): 逆时针移动degree°

你的isEmpty实现不对, 可以return ls->len == 0;

你说的JDK默认应该是没有的，在调用一个方法前后JVM就只有方法栈帧的进栈出栈，并不会将这个动作作为一个事件。

比较贴近你说的，像观察者模式、动态代理、过滤器和拦截器都需要自己去写代码或利用框架实现。

Pair<?>和Pair本质的不同在于:可以用任意Object对象调用原始的Pair类的setFirst方法.

这句话的意思是一个Object对象作为参数来调用Pair类的setFirst方法.

而不是使用一个Object类型的变量来接受Pair类的实例，再调用这个变量的setFirst方法。

要验证的话，应该这样来对比：
 

Pair e1 = new Pair(new Manager(12.4, 15, "ceo"), new Manager(12.4, 15, "ceo")); 

Pair<?> e2 = new Pair(new Manager(12.4, 15, "ceo"), new Manager(12.4, 15, "ceo")); 

e1.setFirst(new Manager(12.4, 15, "ceo"));

e2.setFirst(new Manager(12.4, 15, "ceo"));

数组下标从0开始

hashCode一般和equals一起重写，像你这种重写方式就是认为当两个对象的name和no都相同时，两个对象是等价的。如果这两个对象分别add到一个Set实例中，只会保留一个。可以用来去重。

SELECT
    a.userid 
FROM 
    tab  a
WHERE 
    a.word = 'A' 
    and a.userid in (SELECT b.userid FROM tab b WHERE word = 'B')

大概是这样的，没有验证，应该没什么大问题。

思路就是：

1. （查询一）先找出表中所有word为B的userid

2.再找出表中所有word为A，且userid在（查询一）的结果集中的userid

在Java中，数组作为形参，其实算是引用传递，局部变量表中存放的就是这个数组的引用。

如果对形参（数组变量）重新赋值，是改变了局部变量表中的值（这个值是引用，这个引用指向原数组，所以广义上也可以叫值传递），就不会影响到原来的对象。

如果对形参（数组变量）的某个元素重新赋值，是通过局部变量表中的值（引用），拿到原数组对象去修改。所以就影响到了原来的对象。

JAVA和HADDOP的HOME目录必须加到PATH中，bash遍历PATH中的所有目录，在这些目录下找你输入的命令。

你可以参考这个来设置。

#JAVA
export JAVA_HOME=/usr/java/jdk1.8.0_162
export PATH=$JAVA_HOME/bin:$PATH
#hadoop
export HADOOP_HOME=/home/wj/hadoop2.7.7
export PATH=$HADOOP_HOME/bin:$HADOOP_HOME/sbin:$PATH

改完配置文件后，记得重新加载一遍。

source /etc/profile

你这个employeeTable哪来的，应该是document.getElementById(employeeTable);返回null。

问题一：你每次循环都重新声明了一次数组，理论上来说，每次数组的起始地址都可能会变化，对应的值也会变化，如果不变，应该只是复用了上次循环中的数组变量的内存。所以你重新执行一次，效果应该又不一样。

问题二：还真没看出什么问题。。。。

这个就是二进制转十进制嘛。

sa=[0,1,0,1]
da=[0]*len(sa)

for i in range(0,len(sa)):
  da[i] = (sa[i]*2**(len(sa)-i-1))

print(da)

你这个入参也没说，不过看你的while条件就不对了，我传入一个8，经过一次循环后m为0，0/8为0，就陷入死循环一直往栈里面push，就会报stack full error了。

while条件应该改为(m/8 != 0)。

一般会交给应用程序去排，如果非要在SQL里面按自定义排序，那也是可以的。

假设排序字段是orderKey,可以在select中加上(CASE orderKey  WHEN '0' THEN '0' WHEN '4' THEN '1' WHEN '1' THEN '2' WHEN '2' THEN '3' WHEN '5' THEN '4' WHEN '3' THEN '5' ELSE '999' END) ordKey,最后 order by ordKey.

for循环表达式中用；分隔的三段分别是：

1.初始化段，开始时执行一次。

2.判断表达式段，每次循环前执行一次，如果表达式为false，则结束循环。

3.循环执行段，每次循环结束后执行一次。

三段皆为空，for(;;)等价于while(true);

1,3段为空，for(;expr;)等价于while(expr);

网上多找找，肯定不少。

开源精神可以用来要求自己，不能要求他人。就像捐款，你自己可以捐，但你要求其它人捐就不用了。

当然，你可以成立或加入一个慈善组织，和一群志同道合的人一起。

人人都支持开源只能是理想社会。

a=10这个赋值表达式的返回值就是10，所以会判断为true

比较运算符应该用==

另外，做比较运算时，变量最好放右边(10 == a)，这样写错的时候就会编译报错了。

子进程很正常的呀。正常你启动一个应用，会创建一个进程，这个进程可以再创建多个子进程作为工作进程。

比如谷歌浏览器，每个标签页都会占用一个子进程。

你这需求有点奇葩啊，说的还不清晰，我先梳理一下，就算不是改改就行。

1. 有一个数据源文件，里面是用逗号分隔的元素。

2. 有一个模板字符串，使用*作为占位符（有且只有一个占位符）。

3. 循环使用数据源中的元素填充模板得到目标字符串。

4. 循环使用【数据源中的元素.xml】作为文件名，目标字符串作为文本内容生成一个文件放到指定目录下。

#数据源
echo '123，124，125，126，127，128 ' > ds.txt
#数据源字符串
DS=$(cat ds.txt)
#模板
TMP='print("*")'
#输出文件夹
OUT='./out'
mkdir -p ${OUT}
#数据数组
DTA=(${DS//，/ })
#生成文件
for DT in ${DTA[@]}; do echo ${TMP//\*/${DT}} > ${OUT}/${DT}.xml; done;

嗯，我验证了一下，发现了一个有意思的事。

javac有可能自动编译依赖类的java文件，不过前提是目录结构和包结构要一致。

也就是说，编译TestMyClass1时，如果在类路径中没有找到MyClass这个class文件，就会以当前的工作目录（也就是你执行javac命令的目录）为基础路径，依赖类的【包名+类名+.java】为相对路径去找源文件一起编译，找不到肯定就报错了。

这就能解释如果两个类都不加包名就能一起编译。

如果想加了包名也起到同样的效果，javac就应该在起始包名的父目录下执行，即\javaTest目录下执行>javac -d . corejava\chp6\TestMyClass1.java

-d是指定编译结果的目录，可以另选一个目录，比如./out，Eclipse或IDEA的编译方式和这差不多。

你得先编译MyClass类吧。

1. 锁机制主要是针对读写操作的原子性。

2. 假设有两个事务执行同样的操作，读取数据、对数据进行处理、写入数据。事务A执行{读取数据}，切换为事务B执行{读取数据、对数据进行处理、写入数据}。再切回事务A执行{对数据进行处理、写入数据}。就会发现事务A把事务B的操作覆盖掉了。

3. 悲观锁就是悲观的认为上述冲突发生的概率较高，就是事务在执行{读取数据}操作时，就对【数据】进行{加锁}操作，不允许其它事务去执行{加锁，写入数据}的操作。{加锁}操作是需要耗费资源的，如果冲突发生的概率较低，是不划算的。MySQL的加锁{悲观锁}操作可以通过select .... for update语法实现。

4. 乐观锁是乐观的认为上述冲突发生的概率较低，就是在表中约定一个版本标志字段，每次变更时去修改这个版本标志（可以是一个递增版本号，也可以是时间戳）。每个事务执行{读取数据}操作时，会读取到这个字段，执行{写入数据}操作时，判断版本标志是否发生改变（通过where条件判断即可），如果有变更，应用程序就重新执行{读取数据、对数据进行处理、写入数据}操作或者退出。MySQL本事是没有乐观锁这个概念的，需要应用程序自己去实现。

var data = { oc: 17, uh: 9, uoc: 0, uc: 17 };
var km = { oc: "订单总数", uh: "使用时长", uoc: "使用中", uc: "使用量" };
var dest = [];
for (key in data) {
    dest.push({ name: km[key], value: data[key] });
}
console.log(dest);

1. 假设你10万条数据来源是一个文件，其实不存在什么直接写入，一般就是循环{读取一行，追加一条到List}，当然，数组实现的List可以直接声明容量，防止频繁扩容，链表实现的就不用了，采用哪个看实际情况。

2. 假设一条记录为1k，10万条就是100M，说大不大，说小不小。内存溢出就是不够用了嘛，如果这10万条数据是一直有用，那就只能留着呗。

3. 你是在Linux上的JVM上执行java程序，Java程序中>>只是个位移运算符。

1. ThreadPoolExecutor中有一个BlockingQueue类型的成员变量workQueue，当工作线程不够用时，任务会添加到该队列中，只有当workQueue满了之后，添加任务的线程才会阻塞。

2. 看newFixedThreadPool(int nThreads)的实现，这个workQueue使用的是new LinkedBlockingQueue() ,生成的LinkedBlockingQueue实例的容量（capacity）是很大的（21亿多），基本不会满。

3. 综合而言，不会等待。

只能说变量a和变量b指向同一个对象（print的是这个对象的地址，并不是变量本身所在的地址），通过a或者b修改的是同一个对象里的属性。

但是现在给b赋值为None，只是说b不再指向原来的对象了，但是a还是指向原来的对象。

int流的forEach方法的参数是IntConsumer类型。它的定义是void accept(int value)；

相当于把流中的每个元素（int作为参数时，为值传递）作为参数来调这个accept方法，所以不会修改原值。

1. 简单点说,就是cin.eof()不会阻塞等你输入(可以理解为缓冲区中不是EOF就返回false)，可以通过以下代码验证。

//不等你输入Ctrl+z，直输出两行0
int main()
{
    cout<<cin.eof()<<endl;
    cout<<cin.eof()<<endl;
    system("pause");
    
}

 2. 所以在cin.eof()之前，需要先调用一次读取操作。

//输入Ctrl+z，输出两行1
int main()
{
    int year;
    cin>>year;
    cout<<cin.eof()<<endl;
    cout<<cin.eof()<<endl;
    system("pause");
}

3. 结合问题，可以先执行cin>>time[0].year，再进行cin.eof()判断，不过cin>>time[0].year表达式会返回读取的内容，如果是EOF，返回的就是false（-1），就不需要加cin.eof()判断了。

while(cin>>time[0].year)
    {
        cin>>time[0].month>>time[0].day;
        cin>>time[1].year>>time[1].month>>time[1].day;
        time[0].total=tdays(time[0].year,time[0].month,time[0].day);
        time[1].total=tdays(time[1].year,time[1].month,time[1].day);
        cout<<time[0].total-time[1].total<<endl; 
    }

while循环的时候已经把整个文件流读完了。

for循环中的fgets没有读到任何内容。当fgets没有读到任何内容，第一个参数的值保持不变。

string类型的话这样写挺方便的，如果是number类型的话可以用最大最小值来校验。

    public static int[] rvsArr(int[] src) {
        int[] dest = new int[src.length];
        int midi = src.length / 2;
        int maxi = src.length - 1;
        int sign = -1;
        for (int si = maxi; si >= 0; si--, sign *= -1) {
            int di = midi + sign * ((si + 1) / 2);
            dest[di] = src[si];
        }
        return dest;
    }

第二个sequence转换没问题，不过你的第一个sequence转换的具体规则是什么没明白，为什么元素都变了。

history|awk '{print $2}'|sort|uniq -c|sort -nr|head -n5|awk '{print $2" "$1}'

大致思路是这样的，可以根据实际情况修改。

history：输出历史记录，我看了一下，连续输入同样的命令，history只会记录一条。若有更符合需求的历史数据源，可替换。

awk '{print $2}'：截取历史记录中的命令列。

sort：排序

uniq -c：去重并统计次数

sort -nr：排序，根据次数倒序

head -n5：取前5行

awk '{print $2" "$1}'：格式化，命令在前，次数在后。

可以将root替换为alias, 就不会带上规则路径了.

你这目录结构有点乱啊, 查找文件应该是通过工作目录来找的.

你可以new File("").getAbsolutePath() 或 System.getProperty("user.dir")来查看实际工作目录.

你的文件地址相对路径要基于这个工作目录来确定.

你这需求很不清晰，遍历第一个文本时，在什么条件下删除另一个文本的哪一行？

你是直接点击java.exe吗? 这样是不行的，因为会提示缺少参数，直接退出。

你用cmd测试时，应该是有带参数的吧。

是被加密了，因为不知道加密方式，就没办法解密了。看着像是哪个游戏的配置文件哦。

1. 生成证书时，要设置该证书的域名。

2. 服务端验证HTTPS请求时，会校验请求的域名和证书里的域名是否一致。

这个就是36进制。取十进制的0~1679615，转为36进制。再左补0就行咯。MySQL的进制转换函数为CONV(N,from_base,to_base)

应该是part初始值为0，导致一开始fabs(part) >= 1e-6为false，没有进入循环。可以初始化赋值为1

queryWrapper.ge(false && Objects.nonNull(list.get(0)), "name", list.get(0));

这个方法的第三个参数报的空指针呀。第一个参数&&后面的并没有执行。

大致思路是这样的，可以根据实际情况修改。

history：输出历史记录，我看了一下，连续输入同样的命令，history只会记录一条。若有更符合需求的历史数据源，可替换。

awk '{print $2}'：截取历史记录中的命令列。

sort：排序

uniq -c：去重并统计次数

sort -nr：排序，根据次数倒序

head -n5：取前5行

awk '{print $2" "$1}'：格式化，命令在前，次数在后。

history|awk '{print $2}'|sort|uniq -c|sort -nr|head -n5|awk '{print $2" "$1}'

<script src="js/echarts.js"></script>

你本地没有这个js文件，导致报文件找不到的异常，F12可以看到报错信息。

如果是http协议,一般在header中的content-type中能表明body的类型。

如果是socket通讯,没这些头信息,那就可以判断报文的起始字符，xml是<开头的，json是{开头的。

运算符优先级的问题，优先级比较如下：

除运算符 > 加运算符 > 位移运算符

检查一：如果已经创建过实例了就不用创建了。

加锁：保证只有一个线程去执行创建实例的代码。

检查二：防止线程A执行完检查一后，线程调度到线程B，这时候线程B可以创建完实例并释放锁。再切回线程A时，加完锁还需要再判断一次。

你用绝对路径试试。

void runThreaad(){
    new Thread( new Runnable(){
        public void run(){
            //do something
        }
    }).start();
}

new一个匿名内部类也需要加()，再再{}里面加接口方法的实现。如果是1.8及以上可以用lambda更简洁。

void runThreaad(){
    new Thread( () ->{
        //do something
    }).start();
}

看看日志里面有没有报错信息

i++放到arr[i]赋值后面，不然就从从arr[1]开始赋值。

而char arr[] = "";是将str数组的所有元素都初始化为'\0'.就会导致读到arr[0]时就认为结束了。

VSCode的安装目录没加到环境变量PATH里面吧。

你调用一下试试有没有划掉得标志

代码发一下呗，你两个线程是有不同的筛选条件吧。

你应该是用了spring的自动注入，声明一个接口类型的成员变量，spring能够自动注入该接口的实现类的实例Bean。

否则就得自己new一个实现类来调用了，spring的自动注入原理百度一大堆。

1. 服务器简单点说就是提供服务的机器，根据服务类型有web服务器，负载均衡服务器，加解密服务器等等。

2. 对于我们程序员来讲，最常见的就是web服务器了，也就是部署了web服务的机器。

3. web服务需要运行在操作系统上，操作系统可以是Linux，Windows，MacOS等等，部署web服务的机器一般用的是Linux操作系统。

4. 平常说把包上传到服务器上，一般指的是将web应用程序包通过sftp上传到web服务器上指定的目录中。

状态0: [7,8,6,5]

状态1: [8,5,7,6]

状态2: [5,6,8,7]

状态3: [6,7,5,8]

状态0: [7,8,6,5]

除去第一次优化达到状态0，四次优化为一个周期。

十年120次优化，(120-1)%4=3，就是状态3咯。

因为&是 URL 中指定的参数间的分隔符，需要进行转义，你试试

curl -X POST   'http://172.20.1.52:8082/hello'  -d 'a=we%26ccc'

+= 是一个复合赋值运算符，中间不能有空格。

位移运算的结果不应该收大小端表示法影响，而是不同表示法下通过不同方式去实现同样的位移运算逻辑。

右移一位的逻辑就是乘2（不考虑溢出的话）