ALTER TABLE issuelinktype CONVERT TO CHARACTER SET utf8;
创建jira module的命令：
atlas-create-jira-plugin-module
关闭tomcat
netstat -ano | findstr 8080
taskkill /F /PID 1234
eclipse的debug作用：
F5：跳入方法
F6：向下逐行调试
F7：跳出方法
F8：直接跳转到下一个断点
hashMap允许一个Key == null
private V getForNullKey() {
// 遍历table[0]里的所有桶
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
// 看看桶的key是不是null，是则返回相应值
if (e.key == null)
return e.value;
}
// 没找到返回null
return null;
}
public static void main(String[] args) {
HashMap hashMap = new HashMap<>();
hashMap.put(null,"i am null1!");
hashMap.put(null,"i am null2!");
System.out.println(hashMap.get(null));
}
result : i am null2!;
java中类型之间向上转型可以不用强制转换，而向下转型则要强制转换，如：
public static void main(String[] args) {
short s = 1;
int i = s+1;
}//不需要强制转换
public static void main(String[] args) {
short s = 1;
short i = (short)s+1;
}//需要强制转换
- 原始类型: boolean，char，byte，short，int，long，float，double
- 包装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double
class AutoUnboxingTest {
public static void main(String[] args) {
Integer a = new Integer(3);
Integer b = 3; // 将3自动装箱成Integer类型
int c = 3;
System.out.println(a == b); // false 两个引用没有引用同一对象
System.out.println(a == c); // true a自动拆箱成int类型再和c比较
}
}
public class Test03 {
public static void main(String[] args) {
Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150;
System.out.println(f1 == f2);//true
System.out.println(f3 == f4);//false
}
}
public static void main(String[] args) {
int i = 1;
int j = 1;
if((i<0)&&((i++)>0)){
}
System.out.println(i);
}
结果是：1
public static void main(String[] args) {
int i = 1;
int j = 1;
if((i<0)&((i++)>0)){
}
System.out.println(i);
}
结果是;2
String str = new String("hello");//str 是在栈中，new出来的对象是在堆中，而常量hello实在常量池中，而常量池又在方法区中
Math.round(11.5) 等于多少？Math.round(-11.5)等于多少？
答：Math.round(11.5)的返回值是12，Math.round(-11.5)的返回值是-11。四舍五入的原理是在参数上加0.5然后进行下取整。
switch不能作用于Long
用最有效率的方法计算2乘以8？
答： 2 << 3（左移3位相当于乘以2的3次方，右移3位相当于除以2的3次方）。
public static void main(String[] args) {
outer:while(true){
while(true){
break outer;
}
}
}//跳出多重循环
为什么在java中设置线程的优先级无效或者说效果不大，因为线程的java虽然有线程的优先级，但是是依赖于操作系统的优先级，主要还是由操作系统来调度，虽然在java中设置了10（最高的优先级）,但是假设在一些unix上面没有优先级一说，那么，所有的线程都将按照unix说的规则去调度，即使是window这种有优先级的系统，也不能确保一定是按java的优先级调度。
public static String reverse(String originStr) {
if(originStr == null || originStr.length() <= 1)
return originStr;
return reverse(originStr.substring(1)) + originStr.charAt(0);
}//反转字符串
String s = new String("hello");
String s2 = new String(s.getBytes("GB2312"),"ISO-8859-1");//转换字符串不同格式
LinkedList和ArrayList都用了transient
去处理，是为了不让容器里面的元素序列化：
transient Node<E> first;//源码
而Vector里面却没有一个transient，所以vector里面的元素在序列化时会被保存。有些人说用Vector的好处是因为线程安全，（以为Vector里面都是synchronized的方法）
但是，Collections.synchronizedList(list)这个可以让list也变成线程安全，实现方式是利用Collections（是用来操作collection的工具类）的静态内部类SynchronizedCollection（里面全是synchronized方法）来实现的。
sleep和yield的区别
① sleep()方法给其他线程运行机会时不考虑线程的优先级，因此会给低优先级的线程以运行的机会；yield()方法只会给相同优先级或更高优先级的线程以运行的机会；
② 线程执行sleep()方法后转入阻塞（blocked）状态，而执行yield()方法后转入就绪（ready）状态；
③ sleep()方法声明抛出InterruptedException，而yield()方法没有声明任何异常；
④ sleep()方法比yield()方法（跟操作系统CPU调度相关）具有更好的可移植性。
newSingleThreadExecutor：创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。
- newFixedThreadPool：创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。
- newCachedThreadPool：创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。
- newScheduledThreadPool：创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。
类加载分为三步：
1.加载类
2.连接（解析，准备（包括static修饰的变量），验证）
3.初始化
加载完毕后：使用->卸载
死锁四个必要条件：
1.互斥，资源是互斥的
2.请求和保持，一个进程请求其他资源的时候，对已有的资源依然保持
3.不可剥夺，另一个进程不可剥夺现在的进程
4.循环等待，各个资源头尾相连，形成环路
如何确保N个线程可以访问N个资源同时又不导致死锁？
使用多线程的时候，一种非常简单的避免死锁的方式就是：指定获取锁的顺序，并强制线程按照指定的顺序获取锁。因此，如果所有的线程都是以同样的顺序加锁和释放锁，就不会出现死锁了
平时所说的方法区，其实是指的理论上的JVM的划分，而实际上，不同的虚拟机实现过程都不一样，例如hotspot，其采用永久代去实现，用来存放类信息，静态变量，常量池等不易发生变化的信息，而在jdk1.8中，永生代被元数据代替。
String s = "abc";//在方法区中的常量池中创建abc常量
String s' = new String("abc");
//在堆中创建abc对象
所以s==s'返回false
浮点数用二进制表示：
可以这样:首先将一个小数如:235.725的小数部分取出，即：0.725,将其乘以进制数二进制就乘以2后得到1。45，取其整数部分1为二进制小数的第一项（十分位），在将小数部分0。45乘2得0。9，取其整数部分为二进制小数的第二位（百分位）0，在将其小数部分0。9乘2，得1。8，取其整数部分为二进制小数的第三位（千分位）1，取其小数部分0。8再乘2……以此类推，直到值为0或形成循环小数则停止。
为什么浮点数的运算很多时候会出现丢失精度，因为小数转化为二进制很多时候会出现即使超出了存储的位数，小数部分任然无法乘尽的时候，这个时候用二进制存储的就是个近似值，
而多个近似值进行运算，就会发生进度丢失的情况，所以，最好的方法是转换为BigDecimal去运算（查看源码得知内部用字符串的形式存储，然后转换为分数进行运算的）
Integer a = new Integer(10); Integer b = Integer.valueOf(10);//返回true，开始我以为会和string一样，结果出乎我的意料，因为在Jdk1.5以后，当基本数据类型和非基本数据类型做“==”的时候
非基本类型会自动拆箱，即Integer会自动变成integer.intValues()返回一个int的数据来比较地址，所以是true。
Integer a = new Integer(10);
Integer b = Integer.valueOf(10);
然而，上面a==b却返回false，因为b是调用了IntegerCache中之前创建的-127~127的缓存，是之前就已经创建了的对象，而a是现在才创建的对象，所以不相等
Lock和synchronized的区别：
1.Lock是跟随实例的，而synchronized是跟随类的
2.Lock可以更细微，可以拆分读写等操作
3.Lock的现实锁可以通过在构造方法中加入true来声明公平锁（等待锁的线程采用FIFO的顺序）,但是默认情况下也是非公平的锁。
总之，要灵活选择Lock,要安全使用synchronized。
如何避免死锁，主要是破坏上面四个条件之一。
可以采用：
1.减少资源的共享，让每个资源都只有一个线程可以使用，这样就不会出现争夺线程的情况
2.使用tryLock(),让线程去尝试获得资源，如果没有获得资源，自动结束线程，释放资源，让资源给其他线程使用。
CyclicBarrier
举个栗子：比如说线程1执行一个方法，线程2执行一个方法，线程1到达这个方法的某一条语句时，要等待线程2也到达某条语句，才能执行，可以采用这种方式。
几个不要：
1.不要在循环语句中计算：
while(i<count*2){
}
每次循环都会执行一遍计算，降低了效率，要改成
int j = count*2;
while(i<j){
}
十种基本算法：
数据结构：堆，栈，二叉树，链表，队列，
同一个对象的hashcode()一定相等，不同的对象hashcode()可能相等，这是因为hashcode（）是根据地址来计算的，如果地址相等，函数（也就是这里的hash）相等，结果当然相等啦，而不同的地址
通过同一个hash算法，可能会相等，这就相当于是 x = 2时，x^2 = 4,相同的地址相当于两者都取2，结果相等，当然如果x=-2，算出来的值也可能相当一个道理
转载请注明原文地址: https://ju.6miu.com/read-671567.html
