一、標識符
1、定義合法標識符規則
1）數字不可以開頭；2）不可以使用關鍵字 （注意：Java嚴格區分大小寫！）
2、Java中的名稱規範
1）包名：多單詞組成時所有字母都小寫 ；如：xxxyyyzzz
2）類名接口名：多單詞組成時，所有單詞首字母大寫； 如：XxxYyyZzz
3）變量名和函數名：多單詞組成時，第一個單詞字母小寫，第二個開始首字母大寫；如 ： xxxYyyZzz
4）常量名：所有字母都大寫，多單詞時每個單詞用下劃線連接
二、進制轉換
1、負數的二進制表現形式：這個數的正數的二進制取反+1；
如：6 --> 二進制： 0000-0000 0000-0000 0000-0000 0000-0110；
取反的： 1111-1111 1111-1111 1111-1111 1111-1001 + 1 得：
-6 --> 二進制：1111-1111 1111-1111 1111-1111 1111-1010
負數的最高位是1
計算機處理各種計算時是將數據轉化成二進制的數，計算完成後轉換回去的；
各個進制中間轉換時先將數轉換成二進制再轉換成目標進制
三、常量與變量
1、數據類型： java是強類型語言，對於每一種數據都定義了明確的具體類型，在內存中分配了大小不同大小的內存空間
1）基本數據類型
A、數值型
a、整數類型
byte（0） 1個字節（八位） 負2的7次冪 - 正2的7次冪減1 包裝類 Byte
short（0） 2個字節 15 15 Short
int（0） 4個字節 31 31 Integer
long（0L） 8個字節 63 63 Long
b、浮點類型
float（0.0F） 4個字節 Float
double（0.0D）8個字節 Double
B、字符型（char（'\u0000'）） Character
C、布爾型（boolean（false）） Boolean
2）引用數據類型
A、類（class）
B、接口（interface）
C、數組（[ ]）
整數默認：int 小數默認：double
面試題： Integer i1 = 2017，i2 = 2017；System.out.println(i1 == i2）；輸出false，原因是Cache to support the object identity semantics of autoboxing for values between -128 and 127 (inclusive) as required by JLS.這是在源碼中的註釋，意思是說緩存支持值之間的-128和127的自動裝箱的對象標識的語義（含）按JLS；
首先，i1,i2是Integer類的實例，因此“==”比較的是兩個實例的內存地址。
因爲整型的包裝類存在常量池,一次性把從-128到127之間的所有數都初始化了.當你使用這些數的時候不是創建新對象而是直接從這個常量池裏面取值.所以當你賦值100的時候是取的常量池裏的100,因此兩個對象內存地址一樣.而賦值200的時候兩個對象分別new對象,因此內存地址不同.
四、算術運算符
引用一位大牛寫的：Study Notes 寫的： Java的算數運算符、關係運算符、邏輯運算符、位運算符
注意： b = ++a ； 爲先自增再賦值給b，b = a ++ ； 先賦值給b，再自增
位運算符：
二進制數據左移右邊補0，右移左邊補最高位數的數。無符號右移左邊補0
&、^、|運算符
練習題：
1、計算2乘以8最有效的方式是什麼？
在計算機中低層運算都是二進制做運算的，所以最有效的方式是 ： 2 << 3
2、對兩個整數變量的值進行互換（不需要第三方變量）
1）第三方變量（temp = n;n = m;m = temp;）
2）n = n + m;//這種方法優缺點。如果n 和 m 值比較大就容易超出int範圍
m = n - m;
n = n - m;
3）n = n ^ m;
m = n ^ m; // (n ^ m) ^ m;
n = n ^m; // n ^ (n ^ m);
五、流程控制語句
if、簡化if語句（判斷條件？結果1：結果2；）、if else if else、switch（數據非常小的情況下效率比if語句高點點）、while、do while、for
do while和while的區別：
while： 先判斷條件，條件滿足才執行循環體
do while ：先執行循環體，再判斷條件，無論條件是否滿足循環體至少執行一次；
for 和 while的區別：變量的作用域不同，while語句結束後變量仍然在棧內存中存在引用，而for循環結束後沒有多餘的變量存在，效率而言for稍高
break和continue：
break： 用於選擇結構和循環結構（跳出的意思），多重嵌套循環的時候可以給循環取名字；
例：
w:for(int x=0;x<3;x++){
q:for(int y=0;y<4;y++){
sop("x="+x);
break w;//此處跳出外面的for循環
}
} continue：應用於循環結構（繼續的意思）,continue後面的語句不執行
六、函數
格式：
修飾符 返回值類型 函數名（參數類型 形式參數1，參數類型 形式參數2，...）{
執行語句；
return 返回值；
}
1、重載：在同一個類中，允許存在一個以上的同名函數，只要他們的參數個數或者參數類型不同
特點：與返回值類型無關，只看方法名和參數列表。
好處：方便閱讀，優化程序設計。
如：同類中
int add(int x,int y){
return x+y;
}
void add(int x,int y,int z){
sop(x+y+z);
}double add(double x,double y){
return x+y;
}七、數組
1、概念：同一種類型數據的集合。是一個容器。
2、格式：
2.1、元素類型[ ] 數組名 = new 元素類型[元素個數或者數組長度];
2.2、元素類型[ ] 數組名 = new 元素類型[ ]{元素，元素，元素，...};
3、內存結構：
棧內存：用於存儲局部變量，當數據使用完，所佔內存會自動釋放
堆內存：數組和對象，通過new關鍵字建立的實例都存放在堆內存中
每一個實體都有內存地址值
實體中的變量都有默認初始化值
實體不在被使用，會在不確定的時間內被垃圾回收器回收
方法區，本地方法區，寄存器。
當執行：int[] x = new int [3];時，在堆內存中開闢空間，並且給x指向的數組初始化賦值0
4、數組的操作（存取數據）
4.1、length：數組的屬性，獲取數組的長度（個數）。使用方式：int size = 數組名稱.length；
4.2、獲取最值
//通過比較角標對應的值並記錄最大值來獲取最大值
public static int getMax(int[] arr) {
int max = arr[0];
for (int x=1;x<arr.length;x++) {
if (arr[x] > max) {
max = arr[x];
}
}
return max;
}
//通過比較角標對應的值並記錄最大值角標來獲取最大值
public static int getMax_1(int[] arr) {
int max = 0;
for (int x=1;x<arr.length;x++) {
if (arr[x] > arr[max]) {
max = x;
}
}
return arr[max];
}4.3、數組排序
4.3.1、選擇排序
排序原理：
先拿0角標元素與0角標之後的元素比較，當0角標元素小則不動，0角標元素大則和0角標後元素小的換位置
一輪完成後得到0角標最小的元素，然後用1角標元素一次和後面的元素比較。。。
public static void selectSort(int[] arr) {
for (int x=0;x<arr.length-1;x++) {
for (int y=x+1;y<arr.length;y++) {
if (arr[x] > arr[y]) {
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
}
}4.3.2、冒泡排序
排序原理
相鄰的兩個元素進行比較，如果符合條件就換位。
特點：最值出現在最後
public static void bubbleSort(int[] arr) {
for (int x=0;x<arr.length-1;x++) {
//-x：爲了讓每次比較的元素減少，-1：避免角標越界
for (int y=0;y<arr.length-x-1;y++) {
if (arr[y] > arr[y+1]) {
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
}
}
}
}排序算法最快，效率最高的是：希爾排序（三層循環+位運算）
要了解希爾排序的話最好先搞定：直接插入排序
public static void insertSort(int[] a) {
// 第0位獨自作爲有序數列，從第1位開始向後遍歷
for (int i = 1; i < a.length; i++) {
// 0~i-1位爲有序，若第i位小於i-1位，繼續尋位並插入，
// 否則認爲0~i位也是有序的，忽略此次循環，相當於continue
//{2,1,5,3,9,8,6,4,7}
if (a[i - 1] > a[i]) {
System.out.println(1);// 6
int temp = a[i];// 保存第i位的值
int k;
// 從第i-1位向前遍歷並移位，直至找到小於第i位值停止
// a[k] > temp ： 判斷i角標的值和i前面的角標的值
for (k = i - 1; k >= 0 && a[k] > temp; k--) {
//如果 a[k] > temp成立，則將k角標的值向後移動一位
a[k + 1] = a[k];
}
// 插入第i位的值
a[k + 1] = temp;
}
}
}
public static void shellSort(int[] a) {//希爾排序
for (int d = a.length / 2; d > 0; d = d / 2) {
System.out.println("d=" + d);
for (int i = d; i < a.length; i++) {
int temp = a[i];
int j;
for (j = i - d; j >= 0 && temp < a[j]; j = j - d) {
a[j + d] = a[j];
}
a[j + d] = temp;
}
for (int z : a)
System.out.println(z);
}
}希爾排序轉自：“深入理解”—插入排序算法
選擇排序和冒泡排序可以優化：將需要換位置的角標記錄下來，然後再最後換，只換一次
將在堆內存中的頻繁位置置換優化
真實開發中用：Arrays.sort(arr);
選擇排序優化（把頻繁的堆內存換位轉換成棧內存變量記錄，最終只有需要換位時在堆內存中換位）：
public static void selectSort_2(int[] arr) {
for (int x = 0; x < arr.length - 1; x++) {
int num = arr[x];//定義兩個變量記錄起始值
int index = x;
for (int y = x + 1; y < arr.length; y++) {
if (num > arr[y]) {
num = arr[y];
index = y;
}
}
if (index != x){//當定義的初始量變化後換位，不變化則說明x角標代表的當前值是最值
int temp = arr[x];
arr[x] = arr[index];
arr[index] = temp;
}
}
}折半查找：
public static int halfSearch(int[] a,int key) {
int min = 0, max = a.length -1, mid;
while(min <= max) {
mid = (max + min) >> 1;
if (key > a[mid]) {
min = mid + 1;
} else if (key > a[mid]) {
max = mid -1;
} else {
return mid;
}
}
return -1;
}折半查找聯繫：有序數組，插入一個數還保持有序，獲取插入元素在數組中的位置
public static int getIndex(int[] a,int key) {
int min = 0, max = a.length -1, mid;
while(min <= max) {
mid = (max + min) >> 1;
if (key > a[mid]) {
min = mid + 1;
} else if (key > a[mid]) {
max = mid -1;
} else {
return mid;
}
}
return min;
}4.4、進制轉換應用
public static String toBin(int num) {
return trans(num,1,1);
}
public static String toOct(int num) {
return trans(num,7,3);
}
public static String toHex(int num) {
return trans(num,15,4);
}
public static String trans(int num,int base,int offset) {
char[] arr = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F',};
StringBuffer sb = new StringBuffer();
while (num != 0) {
int a = num&base;
sb.append(arr[a]);
num = num >>> offset;
}
return sb.reverse().toString();
}