JAVA知識大考察

兄弟們，今天咱們主動出擊！干掉禿頭老！然后帶他植發去！（若不知道禿頭老是啥玩意，請看這篇文章！，打波小廣告）

旁白：默默的走向禿頭老工位，拍了一下老禿的小腦袋瓜，

我：禿頭哥，咱們今天再戰一下？

老禿頭：誰TM叫禿頭哥，叫我技術佬！行啊，那今天我們玩點不一樣的，不單干某個知識點了，來一個知識點隨機考察！來看看小兔崽子有多少墨水！

我：好啊，來吧誰慫誰是小王八！（呦呦呦，還技術佬，啊…呸！）

禿子：咱們都知道HTTP請求是無狀態的，那他是如果解決無狀態問題的那？（搞個無厘頭的，試試水，雖然我也不會）

我：（wc，什么鬼！但是老子知道一點！）這個主要是通過Cookie來實作無狀態存盤的，程序是這樣的：

1：Cookie通過HTTP向Server發送請求

2：Server收到請求后，設定Cookie頭部資訊，回傳給客戶端

3：客戶端收到后保存Cookie頭資訊，然后每次請求都帶上

4：Server通過Cookie就知道是哪個Client了，然后會做出相應的反應！

禿子：（這…有點意思哦！）那ArrayList 如何實作動態增長的？

我：（您可是真隨機呀！）這不是我前兩天發的那個Arraylist原始碼分析里面的嘛，那我就簡單的說一下，先看add()方法，里面呼叫了ensureCapacityInternal()方法，這個方法會計算最小擴容量minCapacity,然后在呼叫ensureExplicitCapacity()方法判斷是否需要進行擴容，也就是grow()方法，此方法主要是先獲取老陣列容量大小，然后擴容1.5倍，最后利用Arrays.copyOf()進行陣列遷移

禿子：（哎呦，記憶力可以哦，這只是小試牛刀）那既然說到了ArrayList，那肯定知道LinkedList把，什么時候會用到那？

我：那必須知道嘛，老熟悉了！ArrayList每次容量快滿的時候就會進行1.5倍擴容，如果資料量很大的話就會造成空間的極大浪費！而LinkedList可以做到用多少申請多少！場景的話，如下：

1、當頻繁的在尾部添加，洗掉元素，動態陣列，雙向鏈表都可以

2、頻繁的頭部添加，洗掉元素，建議雙向鏈表

3、頻繁的在任意位置添加，洗掉元素，建議雙向鏈表

4、頻繁的查詢任意位置元素，建議使用動態陣列

禿子：（哎呦，答得湊乎，我在隨機一個！）慢查詢知道吧，一般如何進行sql優化那？

我：（哎呦，知道我對集合還是了解一點的哦，不過目前只有List的，陸續推出Map等等，莫慌哦兄弟們！）一般我們會在where，group by，order by后面的欄位建立索引來解決，但是建立索引的時候需要注意這幾點，否則就會發生索引失效的情況，從而導致全表檢查！比如：

1、where條件中不要用<>或者!=不等于號

2、where條件中不要用is null

3、where條件中不要用%abc%

4、where條件中謹慎使用in和not in

5、where條件中盡量不要對欄位使用運算式或者函式，eg:num / 2 = 100,left(time,4) = '2021'

等等！

禿子：那復合索參考過嗎，什么時候會引起失效那？

我：一般多個欄位條件的時候會用到，它是遵循最左匹配原則的，比如給key index (a,b,c)三個欄位建立索引，一般索引生效的情況就是a|ab|abc三種情況！

禿子：那你知道索引的底層實作嘛？（既然說起了索引，那不得把你問的跪地求饒嘛！）

我：（這這這…，索引這塊還是有所欠缺，大家持續關注一波哦，陸續會發出來詳細決議，挖個坑，哈哈哈哈）嗯…索引的就是為了提高查詢效率的資料結構，并且存盤在檔案中，底層實作是B/B+樹，而B/B+其實就是平衡的M階的樹，而他兩個區別就是B樹每個節點都存盤關鍵字和地址，而B+非葉子節點存盤關鍵字，葉子節點存盤資料，并且每個葉子節點構成了有序的鏈表比較適合區間查找！

旁白：此時，有一個精神小妹走到禿頭老的身邊，悄咪咪的說了幾句話，說完禿頭老色迷迷的笑起來了！

禿子：今天先到這，我這還有點事情，我給你來三道演算法題，你嘗試一下，都很簡單！

我：（老禿子，去約會了吧，還有點事情，就你那色迷迷的眼神出賣你了！）哦…這樣啊，沒事，那你出幾道題，就走吧！

第一題：二分查找

public int search(int[] nums, int target) {
    int l = 0;
    int r = nums.length - 1;
    while (l <= r){
        int m = l + ((r - l) >> 2);
        if (nums[m] == target) return m;
        else if (nums[m] > target) r = m - 1;
        else if (nums[m] < target) l = m + 1;
    }
    return -1;
}

第三題：奇升偶降

/**
 * @author: tianjx
 * @date: 2021/12/19 16:21
 * @description: 奇偶排序
 * 輸入：1->8->3->6->5->4->7->2->NULL
 * 輸出：1->2->3->4->5->6->7->8->NULL
 * 思路：
 *    1、拆分成奇偶鏈表
 *    2、反轉偶鏈表
 *    3、合并輸出
 *
 */
public class OddEvenLinkedSort {
    static class ListNode{
        int val;
        ListNode next;
        public ListNode(int val){
            this.val = val;
        }
        public ListNode(int val, ListNode next){
            this.val = val;
            this.next = next;
        }
    }

    /**
     * 鏈表反轉
     * @param head
     * @return
     */
    public static ListNode reverse(ListNode head){
        if (head == null) return null;
        ListNode pre = null;
        ListNode curr = head;

        while (curr != null){
            ListNode tmp = curr.next;
            curr.next = pre;
            pre = curr;
            curr = tmp;
        }

        return pre;
    }

    /**
     * 鏈表合并
     * @param h1
     * @param h2
     * @return
     */
    public static ListNode merge(ListNode h1, ListNode h2){
        ListNode dummy = new ListNode(-1);
        ListNode p = dummy;
        while (h1 != null && h2 != null){
            if (h1.val <= h2.val){
                p.next = h1;
                p = p.next;
                h1 = h1.next;
            }else{
                p.next = h2;
                p = p.next;
                h2 = h2.next;
            }
        }

        p.next = h1 == null ? h2 : h1;

        return dummy.next;
    }


    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        String str= scan.next();
        String[] split = str.split("->");

        int oddIndex = 0;
        int evenIndex = 0;
        ListNode[] oddNodes = new ListNode[split.length - 1];
        ListNode[] evenNodes = new ListNode[split.length - 1];

        for (int i = 1; i <= split.length - 1; i++) {
            if (i % 2 == 1) oddNodes[oddIndex++] = new ListNode(Integer.valueOf(split[i - 1]));
            else evenNodes[evenIndex++] = new ListNode(Integer.valueOf(split[i - 1]));
        }

        for (int i = 0; i < oddIndex - 1; i++) {
            oddNodes[i].next = oddNodes[i + 1];
        }

        for (int i = 0; i < evenIndex - 1; i++) {
            evenNodes[i].next = evenNodes[i + 1];
        }

        ListNode evenReverse = reverse(evenNodes[0]);
        ListNode merge = merge(oddNodes[0], evenReverse);

        String result = "";
        while (merge != null){
            result += merge.val;
            result += "->";
            merge = merge.next;
        }
        System.out.println(result += "NULL");
    }
}

最后的最后：

兄弟們，今天的隨機考察到此結束，記得關注一下，后續陸續推出HashMap，ConcurrentHashMap，索引等等知識點，終極篇的話是禿頭老植發，兄弟們持續關注一波哦！