Java基础修改完毕

frank-lam · frank-lam · commit 69685caf5516 · 2018-07-25T18:00:06.000+08:00
diff --git a/OVERVIEW.md b/OVERVIEW.md
@@ -6,7 +6,7 @@
 
 #### 二、Java基础
 
-- [[under editing] Java基础](notes/JavaArchitecture/01%20Java%20基础.md)
+- [Java基础](notes/JavaArchitecture/01%20Java%20基础.md)
 - [集合框架](notes/JavaArchitecture/02%20Java%20集合框架.md)
 - [并发编程](notes/JavaArchitecture/03%20Java%20并发编程.md)
 - [IO流](notes/JavaArchitecture/04%20Java%20IO.md)
diff --git a/notes/JavaArchitecture/01 Java 基础.md b/notes/JavaArchitecture/01 Java 基础.md
@@ -376,6 +376,8 @@ Java面向对象的基本思想之一是封装细节并且公开接口。Java语
 
 
 
+## 
+
 
 
 # 二、面向对象
@@ -384,7 +386,7 @@ Java面向对象的基本思想之一是封装细节并且公开接口。Java语
 
 - **Java的四个基本特性** 
   - **抽象**：抽象是将一类对象的共同特征总结出来构造类的过程，包括<u>数据抽象</u>和<u>行为抽象</u>两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。  
-  - ## **继承**：继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。继承让变化中的软件系统有了一定的延续性，同时继承也是封装程序中可变因素的重要手段。 
+  - **继承**：继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。继承让变化中的软件系统有了一定的延续性，同时继承也是封装程序中可变因素的重要手段。
   - **封装**：通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口。面向对象的本质就是将现实世界描绘成一系列完全自治、封闭的对象。我们在类中编写的方法就是对实现细节的一种封装；我们编写一个类就是对数据和数据操作的封装。可以说，封装就是隐藏一切可隐藏的东西，只向外界提供最简单的编程接口。 
   - **多态**：多态性是指允许不同子类型的对象对同一消息作出不同的响应。 
 - **多态的理解(多态的实现方式)** 
@@ -1154,7 +1156,7 @@ strictfp 关键字可应用于类、接口或方法。使用 strictfp 关键字
   - **装箱**：从<u>基本数据类型</u>到<u>封装类型</u>叫做装箱
   - **拆箱**：从<u>封装类型</u>到<u>基本数据类型</u>叫拆箱
 
-```
+```java
 jdk 1.5
 public class TestDemo {
     public static void main(String[] args) {
@@ -1166,7 +1168,7 @@ public class TestDemo {
 
 ​	上面的代码在jdk1.4以后的版本都不会报错，它实现了自动拆装箱的功能，如果是jdk1.4，就得这样写了
 
-```
+```java
 jdk 1.4
 public class TestDemo {
     public static void main(String[] args) {
@@ -1178,7 +1180,7 @@ public class TestDemo {
 
 
 
-## 2. 缓存池
+## 2. ValueOf缓存池
 
 `new Integer(123) `与` Integer.valueOf(123) `的区别在于，new Integer(123) 每次都会新建一个对象，而 Integer.valueOf(123) 可能会使用缓存对象，因此多次使用 Integer.valueOf(123) 会取得同一个对象的引用。
 
@@ -1253,10 +1255,201 @@ Java 还将一些其它基本类型的值放在缓冲池中，包含以下这些
 
 因此在使用这些基本类型对应的包装类型时，就可以直接使用缓冲池中的对象。
 
-[StackOverflow : Differences between new Integer(123), Integer.valueOf(123) and just 123
-](https://stackoverflow.com/questions/9030817/differences-between-new-integer123-integer-valueof123-and-just-123)
+[StackOverflow : Differences between new Integer(123), Integer.valueOf(123) and just 123](https://stackoverflow.com/questions/9030817/differences-between-new-integer123-integer-valueof123-and-just-123)
+
+
+
+## 3. i++和++i有什么区别【B97】
+
+i++是在程序执行完毕后进行自增，而++i是在程序开始执行前进行自增。
+
+**i++的操作分三步**
+
+1. 栈中取出i
+2. i自增1
+3. 将i存到栈
+
+所以i++不是原子操作，上面的三个步骤中任何一个步骤同时操作，都可能导致i的值不正确自增
+
+**++i**
+
+在多核的机器上，cpu在读取内存i时也会可能发生同时读取到同一值，这就导致两次自增，实际只增加了一次。
+
+i++和++i都不是原子操作
+
+
+
+**原子性，**指的是一个操作是不可中断的。即使是在多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程打断。
+
+
+
+## 4. 位运算符
+
+Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。
+
+下表列出了位运算符的基本运算,假设整数变量A的值为60和变量B的值为13
+
+A：0011 1100
+
+B：0000 1101
+
+| 操作符 | 描述                                                         | 例子                         |
+| ------ | ------------------------------------------------------------ | ---------------------------- |
+| ＆     | 如果相对应位都是1，则结果为1，否则为0                        | （A＆B）得到12，即0000 1100  |
+| \|     | 如果相对应位都是0，则结果为0，否则为1                        | （A\|B）得到61，即 0011 1101 |
+| ^      | 如果相对应位值相同，则结果为0，否则为1                       | （A^B）得到49，即 0011 0001  |
+| 〜     | 按位取反运算符翻转操作数的每一位，即0变成1，1变成0。         | （〜A）得到-61，即1100 0011  |
+| <<     | 按位左移运算符。左操作数按位左移右操作数指定的位数。左移n位表示原来的值乘2<sup>n<sup>，左移一位乘2 | A << 2得到240，即 1111 0000  |
+| >>     | 有符号右移，按位右移运算符。左操作数按位右移右操作数指定的位数。右移一位除2 | A >> 2得到15即 1111          |
+| >>>    | 无符号右移，按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。 | A>>>2得到15即0000 1111       |
+
 
-## 3. ++i和i++有什么区别
+
+## 5. 原码、补码、反码是什么
+
+### 机器数
+
+一个数在计算机中的二进制表示形式, 叫做这个数的机器数。机器数是带符号的，在计算机用一个数的最高位存放符号, 正数为0, 负数为1.
+
+比如，十进制中的数 +3 ，计算机字长为8位，转换成二进制就是00000011。如果是 -3 ，就是 10000011 。那么，这里的 00000011 和 10000011 就是机器数。
+
+### 真值
+
+因为第一位是符号位，所以机器数的形式值就不等于真正的数值。例如上面的有符号数 10000011，其最高位1代表负，其真正数值是 -3 而不是形式值131（10000011转换成十进制等于131）。所以，为区别起见，将带符号位的机器数对应的真正数值称为机器数的真值。
+
+例：0000 0001的真值 = +000 0001 = +1，1000 0001的真值 = –000 0001 = –1
+
+### 原码
+
+原码就是符号位加上真值的绝对值, 即用第一位表示符号, 其余位表示值. 比如如果是8位二进制:
+
+[+1]原 = 0000 0001
+
+[-1]原 = 1000 0001
+
+第一位是符号位. 因为第一位是符号位, 所以8位二进制数的取值范围就是:
+
+[1111 1111 , 0111 1111]，即：
+
+[-127 , 127]
+
+原码是人脑最容易理解和计算的表示方式.
+
+### 反码
+
+反码的表示方法是：正数的反码是其本身；负数的反码是在其原码的基础上, **符号位不变，其余各个位取反**。
+
+[+1] = [00000001]原 = [00000001]反
+
+[-1] = [10000001]原 = [11111110]反
+
+可见如果一个反码表示的是负数, 人脑无法直观的看出来它的数值. 通常要将其转换成原码再计算。
+
+### 补码
+
+补码的表示方法是：正数的补码就是其本身；负数的补码是在其原码的基础上, 符号位不变, 其余各位取反, 最后+1. (即在反码的基础上+1)
+
+[+1] = [00000001]原 = [00000001]反 = [00000001]补
+
+[-1] = [10000001]原 = [11111110]反 = [11111111]补
+
+对于负数, 补码表示方式也是人脑无法直观看出其数值的。 通常也需要转换成原码在计算其数值。
+
+
+
+参考资料：
+
+- [原码, 反码, 补码 详解 - ziqiu.zhang - 博客园](http://www.cnblogs.com/zhangziqiu/archive/2011/03/30/ComputerCode.html)
+
+
+
+## 6. 不用额外变量交换两个整数的值
+
+如果给定整数a和b，用以下三行代码即可交换a和b的值
+
+```
+a = a ^ b;
+b = a ^ b;
+a = a ^ b;
+```
+
+- 假设a异或b的结果记为c，**c就是a整数位信息和b整数位信息的所有不同信息**。比如：a=4=100，b=3=011，ab=c=111
+- a异或c的结果就是b，比如：a=4=100，c=111，a^c=011=3=b
+- b异或c的结果就是a，比如：b=3=011，c=111，b^c=100=4=a
+
+说明：位运算的题目基本上都带有靠经验积累才会做的特征，也就是准备阶段需要做足够多的题，面试时才会有良好的感觉。
+
+
+
+## 7. 不使用运算符进行a+b操作
+
+- a^b; 得到不含进位之和
+- (a&b)<<1; 进位
+- 只要进位不为零，则迭代；否则返回
+
+```java
+public class Solution {
+    /*
+     * @param : An integer
+     * @param : An integer
+     * @return: The sum of a and b
+     */
+    public int aplusb(int a, int b) {
+
+        int sum_without_carry, carry;
+        sum_without_carry = a^b; //没有进位的和
+        carry = (a&b)<<1; //进位
+        if(carry==0)
+            return sum_without_carry;
+        else 
+            return aplusb(sum_without_carry, carry);   
+    }
+};
+```
+
+
+
+## 8. &和&& 、|和||的区别？【阿里实习生面试】
+
+
+​	（1）&&和&都是表示与，区别是&&只要第一个条件不满足，后面条件就不再判断。而&要对所有的条件都进行判断。
+
+```java
+// 例如：
+public static void main(String[] args) {  
+    if((23!=23)&&(100/0==0)){  
+    	System.out.println("运算没有问题。");  
+    }else{  
+    	System.out.println("没有报错");  
+    }  
+}  
+// 输出的是“没有报错”。而将&&改为&就会如下错误：
+// Exception in thread "main" java.lang.ArithmeticException: / by zero
+```
+
+- 原因：
+  - &&时判断第一个条件为false，后面的100/0==0这个条件就没有进行判断。
+
+  - &时要对所有的条件进行判断，所以会对后面的条件进行判断，所以会报错。
+
+    
+
+  （2）||和|都是表示“或”，区别是||只要满足第一个条件，后面的条件就不再判断，而|要对所有的条件进行判断。 看下面的程序： 
+
+```java
+public static void main(String[] args) {  
+    if((23==23)||(100/0==0)){  
+    	System.out.println("运算没有问题。");  
+    }else{  
+    	System.out.println("没有报错");  
+    }  
+}
+// 此时输出“运算没有问题”。若将||改为|则会报错。
+```
+
+ - 原因
+    - ||判断第一个条件为true，后面的条件就没有进行判断就执行了括号中的代码
+    - 而|要对所有的条件进行判断， 所以会报错
 
 
 
@@ -1304,11 +1497,40 @@ Java 还将一些其它基本类型的值放在缓冲池中，包含以下这些
 
 
 
-## 4. 字符串字面量
+## 4. 字面量
+
+在编程语言中，字面量（literal）指的是在源代码中直接表示的一个固定的值。 
 
+八进制是用在整数字面量之前添加“0”来表示的。 
 
+十六进制用在整数字面量之前添加“0x”或者“0X”来表示的
 
+ Java 7中新增了二进制：用在整数字面量之前添加“0b”或者“0B”来表示的。  
 
+**在数值字面量中使用下划线**
+在Java7中，数值字面量，不管是证书还是浮点数都允许在数字之间插入任意多个下划线。并且不会对数值产生影响，目的是方便阅读，规则只能在数字之间使用。
+
+```java
+public class BinaryIntegralLiteral {
+    public static void main(String[] args) {
+        System.out.println(0b010101);
+        System.out.println(0B010101);
+        System.out.println(0x15A);
+        System.out.println(0X15A);
+        System.out.println(077);
+        System.out.println(5_000);
+        /**
+         * 输出结果
+         * 21 
+         * 21 
+         * 346 
+         * 346 
+         * 63
+         * 5000
+         */
+    }
+}
+```
 
 
 
@@ -1336,9 +1558,11 @@ Java 还将一些其它基本类型的值放在缓冲池中，包含以下这些
 
 
 
+
+
 # 七、Object 通用方法
 
-## 1.概述
+## 概述
 
 ```java
 public final native Class<?> getClass()
@@ -1589,10 +1813,6 @@ public class CloneExample implements Cloneable {
 
 
 
-## &和&& 、|和||的区别？【阿里实习生面试】
-
-
-
 
 
 
diff --git a/notes/JavaArchitecture/03 Java 并发编程.md b/notes/JavaArchitecture/03 Java 并发编程.md
@@ -1228,12 +1228,25 @@ public void register(Object o)
 
 
 
+## -----------------------------分割线-----------------------
 
 
 
 
 
 
+
+## 从volatile说到,i++原子操作,线程安全问题
+
+
+
+从volatile说到,i++原子操作,线程安全问题 - CSDN博客
+https://blog.csdn.net/zbw18297786698/article/details/53420780
+
+
+
+
+
 ## 附录：参考资料
 
 - [Interview-Notebook/Java 并发.md at master · CyC2018/Interview-Notebook](https://github.com/CyC2018/Interview-Notebook/blob/master/notes/Java%20%E5%B9%B6%E5%8F%91.md)
diff --git a/notes/JavaArchitecture/08 系统架构.md b/notes/JavaArchitecture/08 系统架构.md
@@ -1 +1,7 @@
-### tomcat集群怎么保证同步 
+## tomcat集群怎么保证同步 
+
+
+
+
+
+## 布隆过滤器
