居家、公司行號垃圾清運、廢棄物處理、大型家具回收，服務快速，包月及計重或計桶供客戶選擇，合法登記的清潔公司、廢棄物清除許可，專業技術人員及專業廢棄物清運車輛
摘錄自2019年10月16日自由時報報導
台塑集團德州廠遭居民指控排放塑膠顆粒、污染水資源，聯邦地區法院法官在今年6月裁定，台塑違反廢棄物排放許可證和聯邦淨水法，恐面臨鉅額罰款；台塑當時否認非法傾倒，聲稱排放的塑膠顆粒並未超過許可證允許數量。
《美聯社》15日報導，非營利組織Texas RioGrande Legal Aid（TRLA）週二宣布與台塑達成和解協議，並表示基於雙方同意的判決，台塑同意實行「零排放」並清理既有的汙染；協議還需要經過法官批准，通過後，5000萬美元將在5年內用於改善當地河川的水質。
本站聲明:網站內容來源環境資訊中心https://e-info.org.tw/,如有侵權,請聯繫我們,我們將及時處理
【其他文章推薦】
※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!
※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線
※Google地圖已可更新顯示潭子電動車充電站設置地點!!
※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益
※別再煩惱如何寫文案,掌握八大原則!
摘錄自2019年10月23日中央通訊社馬來西亞報導
科學家警告說，全球大規模植樹遏止氣候變遷風險的可能成效被高估。今年7月，蘇黎世聯邦理工學院（ETH Zurich）柯勞瑟實驗室（Crowther Lab）的研究人員發布研究報告，提出控制氣候變化的最好方法，就是在面積與美國相當的被毀森林重新植樹。
但德國波昂大學（University of Bonn）和位於奈洛比的世界農林複合研究中心「世界混農林業中心」（World Agroforestry Center）的科學家，18日在期刊「科學」（Science）發表回應文指出，在原先研究中可以在土地上種植的樹木數量有限。
波昂大學作物科學與資源保育研究所（Institute of Crop Sciences and Resource Conservation）教授魯德林（Eike Luedeling）表示，植樹造林不應被視為減少使用化石燃料排放的替代方案。
本站聲明:網站內容來源環境資訊中心https://e-info.org.tw/,如有侵權,請聯繫我們,我們將及時處理
【其他文章推薦】
※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面
※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!
※想知道最厲害的網頁設計公司"嚨底家"!
※幫你省時又省力,新北清潔一流服務好口碑
※別再煩惱如何寫文案,掌握八大原則!
摘錄自2019年10月22日中央通訊社印度報導
印度國家首都區這幾天空氣污染持續在「不佳」（poor）狀態，為避免排燈節燃放鞭炮惡化空氣品質，印度最高法院今天（22日）宣布，只有兩種綠色環保、被稱為anar和phuljhari的無聲鞭炮，可以在27日排燈節（Diwali）燃放，其他吵雜的鞭炮和煙火都被禁止。
被允許在印度宗教節日排燈節燃放的鞭炮將有印度政府認證標章和快速響應矩陣圖碼（QR code），警方呼籲消費者在購買鞭炮時要認明標章和QR code。新德里電視台（NDTV）引述德里警察局發言人藍大瓦（MS Randhawa）說，警方已組成檢查小組，如果有商家販售其他類型的鞭炮和煙火，警方將會採取法律行動。
主管環保的印度中央政府部長瓦德漢（Harsh Vardhan）表示，綠色環保鞭炮的懸浮粒子含量減少25%到30%，二氧化碳排放減少50%，有助降低鞭炮燃放對空氣品質的影響。
本站聲明:網站內容來源環境資訊中心https://e-info.org.tw/,如有侵權,請聯繫我們,我們將及時處理
【其他文章推薦】
※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益
※新北清潔公司,居家、辦公、裝潢細清專業服務
※別再煩惱如何寫文案,掌握八大原則!
※教你寫出一流的銷售文案?
※超省錢租車方案
CS-LogN思維導圖：記錄CS基礎 面試題
開源地址：https://github.com/FISHers6/CS-LogN
線程池相關類
能獲取子線程的運行結果
互斥同步(鎖)
非互斥同(原子類)
併發容器
無同步與不可變方案
降低資源消耗
提高響應速度
提高線程的可管理性
corePoolSize、maximumPoolSize、keepAliveTime、workQueue、threadFactory、handler
圖示
線程添加規則
1.如果線程數量小於corePoolSize，即使工作線程處於空閑狀態，也會創建一個新線程來運行新任務，創建方法是使用threadFactory
2.如果線程數量大於corePoolSize但小於maximumPoolSize，則將任務放入隊列
3.如果workQueue隊列已滿，並且線程數量小於maxPoolSize，則開闢一個非核心新線程來運行任務
4.如果隊列已滿，並且線程數大於或等於maxPoolSize，則拒絕該任務，執行handler
圖示(分別與3個參數比較)
常用線程池
newFixedThreadPool
newSingleThreadExecutor
newCachedThreadPool
newScheduledThreadPool
如何設置初始化線程池的大小？
可根據線程池中的線程
處理任務的不同進行分別估計
CPU 密集型任務
IO 密集型任務
使用線程池的注意事項
線程池的狀態
線程池停止
shutdown
shutdownNow
線程池的組成
1.線程池管理器
2.工作線程
3.任務隊列：無界、有界、直接交付隊列
4.任務接口Task
圖示
Executor家族
Executor頂層接口，只有一個execute方法
ExecutorService繼承了Executor，增加了一些新的方法，比如shutdown擁有了初步管理線程池的功能方法
Executors工具類，來創建，類似Collections
圖示
線程池實現任務復用的原理
線程池對線程作了包裝，不需要啟動線程，不需要重複start線程，只是調用已有線程固定數量的線程來跑傳進來的任務run方法
添加工作線程
重複利用線程執行不同的任務
每個 Thread 維護着一個 ThreadLocalMap 的引用；ThreadLocalMap 是 ThreadLocal 的內部類，用 Entry 來進行存儲；key就對應一個個ThreadLocal
get方法：取出當前線程的ThreadLocalMap，然後調用map.getEntry方法，把ThreadLocal作為key參數傳入，取出對應的value
set方法：往 ThreadLocalMap 設置ThreadLocal對應值
initalValue方法：延遲加載，get的時候設置初始化
圖示
value內存泄漏
原因：ThreadLocal 被 ThreadLocalMap 中的 entry 的 key 弱引用。如果 ThreadLocal 沒有被強引用， 那麼 GC 時 Entry 的 key 就會被回收，但是對應的 value 卻不會回收，就會造成內存泄漏
解決方案：每次使用完 ThreadLocal，都調用它的 remove () 方法，清除value數據。
源碼圖示
引入目的
解決Runnable的缺陷
是什麼如何使用
引入目的
常用方法
使用場景
注意點
Callable和Future的關係
Future相當於一個存儲器，它存儲未來call()任務方法的返回值結果
可以用Future.get方法來獲取Callable接口的執行結果，在call()未執行完畢之前沒調用get的線程會被阻塞
線程池傳入Callable，submit返回Future，get獲取值
FutureTask
FutureTask是一種包裝器，可以把Callable轉化成Future和Runnable，它同時實現了二者的接口。所以既可以作為Runnable任務被線程執行，又可以作為Future得到Callable的返回值
圖示
final修飾變量
被final修飾的變量，意味着值不能被修改。
如果變量是對象，那麼對象的引用不能變，但是對象自身的內容依然可以變化。
賦值時機
屬性被聲明為final后，該變量則只能被賦值一次。且一旦被賦值，final的變量就不能再被改變，如論如何也不會變。
區分為3種
final instance variable（類中的final屬性）
final static variable（類中的static final屬性）
final local variable（方法中的final變量）
為什麼規定時機
final修飾方法（構造方法除外）
final修飾類
ABA問題
CAS+自旋，導致自旋時間過長
改進：通過版本號的機制來解決。每次變量更新的時候，版本號加 1，如AtomicStampedReference的compareAndSet ()
簡介
Lock和Synchronized的異同點
相同點
不同點
Lock 有比 synchronized 更精確的線程語義和更好的性能；高級功能
1 實現原理不同
2 靈活性不同
3 等待時是否可以中斷
可見性
悲觀鎖(互斥同步鎖)
思想
實例
缺點
樂觀鎖
思想
實例
優缺點對比
對比
什麼是可重入
可重入的好處
可重入鎖ReentrantLock與非可重入鎖ThreadPoolExecutor的Worker類對比
公平鎖
介紹
優點
缺點
非公平鎖
介紹
優點
缺點
優缺點對比
源碼分析
排他鎖
介紹
共享鎖
介紹
ReentrantReadWriteLock
讀寫鎖的作用
讀寫鎖的規則
一把鎖兩種方式鎖定
讀線程插隊策略(非公平下)
鎖升級
引入場景
策略
適合場景
阻塞鎖
思想
開銷缺陷
自旋鎖
思想
開銷缺陷
源碼分析
atomic包下的類基本都是自旋鎖的實現
AtomicInteger的實現：自旋鎖實現原理是CAS，Atomic調用Unsafe進行自增add的源碼中的do-while循環就是一個自旋操作，使用CAS如果修改過程中遇到其它線程修改導致沒有秀嘎四成功，就在while里死循環，直至修改成功
圖示
適用場景
介紹
使用場景
JDK1.6 后對synchronized鎖的優化
JDK1.6 對鎖的實現引入了大量的優化，如偏向鎖、輕量級鎖、自旋鎖、適應性自旋鎖、鎖消除、鎖粗化等技術來減少鎖操作的開銷。
偏向鎖
輕量級鎖
重量級鎖
自旋鎖
自適應自旋鎖
鎖消除
鎖粗化
寫代碼時的優化
常用方法
實現原理
缺點
引入目的/改進思想
設計思想
集合類歷史
為什麼需要
為什麼不用HashMap
為什麼不用Collection.synchronizedMap
數據結構與併發策略
JDK1.7
JDK1.8
1.7到1.8改變後有哪些優點
注意事項
引入目的
適合場景
讀寫規則
實現原理
缺點
為什麼使用隊列
併發隊列關係圖示
BlockingQueue阻塞隊列
阻塞隊列是局由自動阻塞功能的隊列，線程安全；take方法移除隊頭，若隊列無數據則阻塞直到有數據；put方法插入元素，如果隊列已滿就無法繼續插入則阻塞直到隊列里有了空閑空間
ArrayBlockQueue
LinkedBlockingQueue
PriorityBlockingQueue
SynchronousQueue
DelayQueue
非阻塞隊列
ConcurrentLinkedQueue
選擇合適的隊列
邊界上看
內存上看
吞吐量上看
控制併發流程的工具類，作用是幫助程序員更容易讓線程之間相互配合，來滿足業務邏輯
併發工具類圖示
作用(事件)
常用方法
作用
常用方法
作用
常用方法
作用(線程)
常用方法
Exclusive(獨佔)
Share(共享)
核心三要素
1.sate
2.控制線程搶鎖和配合的FIFO隊列
3.期望協作工具類去實現的“獲取/釋放”等喚醒分配的方法策略
AQS的用法
AQS在CountDownLatch的應用
內部類Sync繼承AQS
1.state表示門閂倒數的count數量，對應getCount方法獲取
2.釋放方法，countDown方法會讓state減1，直到減為0時就喚醒所有線程。countDown方法調用releaseShared，它調用sync實現的tryReleaseShared，其使用CAS+自旋鎖，來實現安全的計數-1
3.阻塞方法，await會調用sync提供的aquireSharedInterruptly方法，當state不等於0時，最終調用LockUpport的park，它利用Unsafe的park，native方法，把線程加入阻塞隊列
總結
AQS在Semphore的應用
state表示信號量允許的剩餘許可數量
tryAcquire方法，判斷信號量大於0就成功獲取，使用CAS+自旋改變state狀態。如果信號量小於0了，再請求時tryAcquireShared返回負數，調用aquireSharedInterruptly方法就進入阻塞隊列
release方法，調用sync實現的releaseShared，會利用AQS去阻塞隊列喚醒一個線程
總結
AQS在ReentrantLock的應用
本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理
【其他文章推薦】
※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!
※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線
※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整
※南投搬家公司費用,距離,噸數怎麼算?達人教你簡易估價知識!
※教你寫出一流的銷售文案?
※超省錢租車方案
生產者與消費者問題是個非常典型的多線程問題，涉及到的對象包括“生產者”、“消費者”、“倉庫”和“產品”。他們之間的關係如下：
①、生產者僅僅在倉儲未滿時候生產，倉滿則停止生產。
②、消費者僅僅在倉儲有產品時候才能消費，倉空則等待。
③、當消費者發現倉儲沒產品可消費時候會通知生產者生產。
④、生產者在生產出可消費產品時候，應該通知等待的消費者去消費。
生產者消費者模型具體來講，就是在一個系統中，存在生產者和消費者兩種角色，他們通過內存緩衝區進行通信，生產者生產消費者需要的資料，消費者把資料做成產品。生產消費者模式如下圖。
在日益發展的服務類型中，譬如註冊用戶這種服務，它可能解耦成好幾種獨立的服務（賬號驗證，郵箱驗證碼，手機短信碼等）。它們作為消費者，等待用戶輸入數據，在前台數據提交之後會經過分解併發送到各個服務所在的url，分發的那個角色就相當於生產者。消費者在獲取數據時候有可能一次不能處理完，那麼它們各自有一個請求隊列，那就是內存緩衝區了。做這項工作的框架叫做消息隊列。
下面通過生產包子的例子及wait()/notify()方式實現該模型(後面學習線程池相關內容之後，再通過其它方式實現生產/者消費者模型)。
public class Bread { private int capacity; // 麵包的容量 private int size; // 麵包的實際數量 public Bread(int capacity) { this.capacity = capacity; this.size = 0; } // 生產麵包 public synchronized void produce(int val) { try { // left 表示“想要生產的數量”(有可能生產量太多，需多此生產) int left = val; while (left > 0) { // 庫存已滿時，等待“消費者”消費產品。 while (size >= capacity) wait(); // 獲取“實際生產的數量”(即庫存中新增的數量) // 如果“庫存”+“想要生產的數量”>“總的容量”，則“實際增量”=“總的容量”-“當前容量”。(此時填滿倉庫) // 否則“實際增量”=“想要生產的數量” int inc = (size+left)>capacity ? (capacity-size) : left; size += inc; left -= inc; System.out.printf("%s produce(%3d) --> left=%3d, inc=%3d, size=%3d\n", Thread.currentThread().getName(), val, left, inc, size); // 通知“消費者”可以消費了。 notifyAll(); } }catch(InterruptedException e) { e.printStackTrace(); } } // 消費麵包 public synchronized void consume(int val) { try { // left 表示“客戶要消費數量”(有可能消費量太大，庫存不夠，需多此消費) int left = val; while (left > 0) { // 庫存為0時，等待“生產者”生產產品。 while (size <= 0) wait(); // 獲取“實際消費的數量”(即庫存中實際減少的數量) // 如果“庫存”<“客戶要消費的數量”，則“實際消費量”=“庫存”； // 否則，“實際消費量”=“客戶要消費的數量”。 int dec = (size<left) ? size : left; size -= dec; left -= dec; System.out.printf("%s consume(%3d) <-- left=%3d, dec=%3d, size=%3d\n", Thread.currentThread().getName(), val, left, dec, size); notifyAll(); } } catch (InterruptedException e) { e.printStackTrace(); } } }
public class Producer{ Bread bread; public Producer(Bread bread) { this.bread = bread; } public void produce(final int val) { new Thread(() -> { bread.produce(val); }).start();; } }
public class Customer { private Bread bread; public Customer(Bread bread) { this.bread = bread; } public void consume(final int val) { new Thread(() -> { bread.consume(val); }).start();; } }
public class Demo { public static void main(String[] args) { Bread bread = new Bread(100); Producer producer = new Producer(bread); Cunstomer customer = new Customer(bread); producer.produce(60); producer.produce(120); consumer.consume(90); consumer.consume(150); producer.produce(110); } }
// 運行結果 Thread-1 produce( 60) --> left= 0, inc= 60, size= 60 Thread-5 produce(110) --> left= 70, inc= 40, size=100 Thread-4 consume(150) <-- left= 50, dec=100, size= 0 Thread-2 produce(120) --> left= 20, inc=100, size=100 Thread-3 consume( 90) <-- left= 0, dec= 90, size= 10 Thread-4 consume(150) <-- left= 40, dec= 10, size= 0 Thread-5 produce(110) --> left= 0, inc= 70, size= 70 Thread-4 consume(150) <-- left= 0, dec= 40, size= 30 Thread-2 produce(120) --> left= 0, inc= 20, size= 50
說明：
①、Producer是“生產者”類，它與“麵包(bread)”關聯。當調用“生產者”的produce()方法時，它會新建一個線程並向“麵包類”中生產產品。
②、Customer是“消費者”類，它與“麵包(bread)”關聯。當調用“消費者”的consume()方法時，它會新建一個線程並消費“麵包類”中的產品。
③、Bread是麵包類，記錄“麵包的產量(capacity)”以及麵包當前實際數目(size)”。
麵包類的生產方法produce()和消費方法consume()方法都是synchronized方法，進入synchronized方法體，意味着這個線程獲取到了該“麵包”對象的同步鎖。這也就是說，同一時間，生產者和消費者線程只能有一個能運行。通過同步鎖，實現了對“殘酷”的互斥訪問。
對於生產方法 produce() 而言：當麵包量滿時，生產者線程等待，需要等待消費者消費產品之後，生產線程才能生產；生產者線程生產完麵包之後，會通過 notifyAll() 喚醒同步鎖上的所有線程，包括“消費者線程”，即我們所說的“通知消費者進行消費”。
對於消費方法consume()而言：當倉庫為空時，消費者線程等待，需要等待生產者生產產品之後，消費者線程才能消費；消費者線程消費完產品之後，會通過 notifyAll() 喚醒同步鎖上的所有線程，包括“生產者線程”，即我們所說的“通知生產者進行生產”。
本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理
【其他文章推薦】
※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線
※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益
※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面
※南投搬家公司費用需注意的眉眉角角，別等搬了再說!
※新北清潔公司,居家、辦公、裝潢細清專業服務
※教你寫出一流的銷售文案?
二哥，最近我剛進了一家公司，之前跟你說過，培訓出身剛剛畢業，打算在北京打拚。最近進公司，給安排了工作，今天第一次沒人帶，自己上手搞代碼，搞不出，明明挺簡單的功能，自己還是做不出，不知道從哪裡學習，想趕快熟悉工作，可是自己的能力不行，在地鐵上常看二哥原創的作品，平常积極在看，超級希望能自己學到本事，但自己的能力真的有點問題，工作搞不完，害怕被問，害怕任務完不成被辭退。
以上是讀者西瓜向我提的一個問題，我覺得挺具有代表性的，所以決定拉出來單獨寫一篇文章答疑解惑一下。
可以肯定的一點是，任何時候都要說自己不行啊，尤其是男性同胞，可以認慫，但是“不行”這個兩個字千萬不要輕易說出口，為什麼？你懂吧？
人的能力各有不同，但如果你自己都不自信，那又能做好什麼事情呢？心理建設非常重要。
記得之前看一個短片，一個小男孩跳了無數次，都無法越過障礙物，但是呢，他身邊的同學一直為他加油吶喊，小男孩呢，也從來沒有放棄的打算，最後的結果我都快看哭了，他真的跳過去了，他出色地完成了自我挑戰。
他的成功，離不開同學們的鼓勵，但更重要的是他鍥而不舍的精神，心裏素質比一般的成年人都要強大。
我現在已經為人父了，雖然我一直標榜自己只有 18 歲，但叫二叔的讀者真的越來越多，我已經逆來順受了。在我的教育觀念里，我覺得我家女兒最優秀的一點品質，就是，如果她喜歡一件事，她就會主動去鑽研，去摸索，在沒有任何外人的幫助下。
你比如說，現在比較流行的平衡車，就是不帶腳踏板和鏈條的自行車。一開始，我想給她報個班，至少有個老師教教，對吧？
但是，她的表現完全出乎我的意料，我只要把車買回來，放到她的面前，怎麼騎，完全靠她自己去體驗。一開始小心翼翼，很保本，但她不滿足於現狀，就找一些小坡騎，然後是再大一點的坡，就這樣，挑戰一次又一次，自己就完全掌握了騎行的技術。
對於我來說，我沒有騎平衡車的經驗，小時候也沒有這玩意。我能做的除了買車，就是給她鼓勵，摔倒了沒事，哭了也沒事，有些事情，痛苦的同時，伴隨着挑戰和突破。
對於我們成年人來說，其實道理都懂的，但人與人之間的差距之所以拉開，除了選擇的正確有否，最大的因素我想就是，你有沒有自己主動去做。
西瓜說自己明明很簡單的功能，就是做不出來。這種感覺我也有過，即便是現在有了十年多的編程經驗，仍然在某些時刻感到举手無措，無從下手。
對，這就是為什麼人要終身學習的原因啊。我們做不出來，除了思維上、認知上的局限性，另外一個重要的點就在於，你有沒有經驗。
對於新人來說，經驗肯定是欠缺的，這點毫無疑問，對吧？但是只要公司招你進去了，無論是不是培訓班出身，負責任的公司都會給你充足的時間和空間去進步，就看你自己有沒有主動。
我大三出去實習的時候，公司要求我做一個計算器，那時候覺得好難啊，因為加減乘除，再帶上小括號，運算是有優先級的，還要考慮到小括號的自動補齊，對於那時候菜得一筆的我來說，真特么難啊。
但能怎麼辦？做不出來就意味着要被辭退，那只有一個辦法，就是上網搜，找別人的例子模仿，拆分，融化，把它變成是自己的。
那時候，我還不會玩 GitHub、碼雲和開源中國，私下里主動學習的地方只有一個，好像是叫編程入門網，現在已經沒有了。我就是照着上面的例子，一個個手敲，當你例子敲多了，很多編程知識就融會貫通了。
現在好了，優秀的案例數不勝數。我的兩個好朋友，macrozheng 開源了他的電商平台 mall，江南一點雨開源了他的微人事系統 vhr，這兩個開源項目我一直強烈推薦新手去下載到本地，去學習。
很多時候，對於編程天賦一般的我們來說，不需要主動去造輪子，我們只需要去發現輪子，對吧？
我在一開始做 Web 管理系統的時候，找了一個企業級的開源系統，叫做 DWZ，不知道有沒有讀者朋友用過，當年非常火，我們公司的後台管理系統現在還在用，雖然說界面已經很古董了，但對於我們公司來說，足夠用了。
這套 DWZ 就封裝了很多前端組件，對於我一個 Java 程序員來說，非常友好，直接可以上手操作，如果一些組件不滿足，我就去改造。改造的過程中，就積攢了大把解決問題的實戰經驗，這是彌足珍貴的。
我在《Web全棧開發進階之路》這本書里，就借鑒了不少 DWZ 的優秀思想。不要覺得不會造輪子是可恥的，會用輪子也是真本領啊。
就西瓜來說，平常喜歡看我的原創文，那我文章涉及到的例子有沒有去敲呢？如果你敲了，你就會發現，文章里涉及到的例子能解決大部分新人在工作中遇到的問題，直接把這些作為自己的工具包，下次遇到拿來即用就可以了。
對於 Java 程序員來說，JDK 的原生 API 不能滿足需求的話，還有很多第三方的類庫，比如說 Apache 的，封裝了大量常用的工具類和方法。前提條件是，你必須得知道有這些東西，如果不知道的話，那就無從下手了，對吧？
那怎麼見多識廣呢？這就回到了之前所說的，你得去練，動手去練，無論是書本里的，還是文章里的，還是開源項目里的，你得去手操一遍，不要眼高手低，敲多了，自然就形成了自己解決問題的思路和方法。
擔心自己被辭退是一件好事，這會督促我們前進，對吧？有的人，有自驅力，不需要外力的干預就能奮發圖強，有的人，就需要一條看不見的鞭子抽打着，才會有前進的動力。
別懷疑自己，真的，人嘛，總是有能力強弱之分的，要學會接納自己，像二哥一樣自信點，腳踏實地，一點一點去進步，當你取得一點成績的時候就把這些當做是里程碑，隨着時間的推移，你就會發現，自己變禿了，不不不，變強了。
加油，西瓜！
如果覺得文章對你有點幫助，請微信搜索「 沉默王二 」第一時間閱讀。
本文已收錄 GitHub，傳送門~ ，裏面更有大廠面試完整考點，歡迎 Star。
我是沉默王二，一枚有顏值卻靠才華苟且的程序員。關注即可提升學習效率，別忘了三連啊，點贊、收藏、留言，我不挑，嘻嘻。
本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理
【其他文章推薦】
※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益
※新北清潔公司,居家、辦公、裝潢細清專業服務
※別再煩惱如何寫文案,掌握八大原則!
※教你寫出一流的銷售文案?
※超省錢租車方案
我們都知道，線性表的存儲結構分為兩種，順序存儲結構和鏈式存儲結構，線性表的分類可以參考下圖來學習記憶。今天我們主要來學習一下鏈式存儲結構。
“鏈式存儲結構，地址可以連續也可以不連續的存儲單元存儲數據元素”——來自定義。
其實，你可以想象這樣一個場景，你想找一個人（他的名字叫小譚）,於是你首先去問 A ， A 說他不知道，但是他說 B 可能知道，並告訴了你 B 在哪裡，於是你找到 B ，B 說他不知道，但是他說 C 可能知道，並告訴了你 C 的地址，於是你去找到 C ，C 真的知道小譚在何處。
上面場景其實可以幫助我們去理解鏈表，其實每一個鏈表都包含多個節點，節點又包含兩個部分，一個是數據域（儲存節點含有的信息），一個是指針域（儲存下一個節點或者上一個節點的地址），而這個指針域就相當於你去問B，B知道C的地址，這個指針域就是存放的 C 的地址。
鏈表下面其實又細分了3種：單鏈表、雙向鏈表和循環鏈表。今天我們先講單鏈表。
什麼是單鏈表呢？單鏈表就是每一個節點只有一個指針域的鏈表。如下圖所示，就是一個帶頭節點的單鏈表。下面我們需要知道什麼是頭指針，頭節點和首元節點。
頭指針：指向鏈表節點的第一個節點的指針
頭節點：指在鏈表的首元節點之前附設的一個節點
首元節點：指在鏈表中存儲第一個實際數據元素的節點（比如上圖的 a1 節點）
單鏈表的創建有兩種方式，分別是頭插法和尾插法。
頭插法，顧名思義就是把新元素插入到頭部的位置，每次新加的元素都作為鏈表的第一個節點。那麼頭插入法在Java中怎麼實現呢。首先我們需要定義一個節點，如下
public class ListNode {
public int val; //數據域
public ListNode next;//指針域
}
然後我們就創建一個頭指針（不帶頭節點）
//元素個數
int n = 5;
//創建一個頭指針
ListNode headNode = new ListNode();
//頭插入法
headNode= createHead(headNode, n);
然後創建一個私有方法去實現頭插法，這裏我們插入5個新元素，頭插入的核心是要先斷開首元節點和頭指針的連接，也就是需要先將原來首元節點的地址存放到新節點的指針域里，也就是 newNode.next = headNode.next，然後再讓頭指針指向新的節點 headNode.next = newNode，這兩步是頭插入的核心，一定要理解。
/**
* 頭插法
* 新的節點放在頭節點的後面，之前的就放在新節點的後面
* @param headNode 頭指針
* @return
*/
private static ListNode createHead(ListNode headNode, int n) {
//插入5個新節點
for (int i = 1; i <= n; i++) {
ListNode newNode = new ListNode();
newNode.val = i;
//將之前的所有節點指向新的節點（也就是新節點指向之前的所有節點）
newNode.next = headNode.next;
//將頭指針指向新的節點
headNode.next = newNode;
}
return headNode;
}
最後我把鏈表打印輸出一下（其實也是單鏈表的遍歷），判斷條件就是只有當指針域為空的時候才是最後一個節點。
private static void printLinkedList(ListNode headNode) {
int countNode = 0;
while (headNode.next != null){
countNode++;
System.out.println(headNode.next.val);
headNode = headNode.next;
}
System.out.println("該單鏈表的節點總數：" +countNode);
}
最後的輸出結果顯然是逆序，因為沒一個新的元素都是從頭部插入的，自然第一個就是最後一個，最後一個就是第一個：
尾插法，顧名思義就是把新元素插入到尾部的位置（也就是最後一個位置），每次新加的元素都作為鏈表的第最後節點。那麼尾插法在 Java 中怎麼實現呢，這裏還是採用不帶頭節點的實現方式，頭節點和頭指針和頭插入的實現方式一樣，這裏我就直接將如何實現：
/**
* 尾插法
* 找到鏈表的末尾結點，把新添加的數據作為末尾結點的後續結點
* @param headNode
*/
private static ListNode createByTail(ListNode headNode, int n) {
//讓尾指針也指向頭指針
ListNode tailNode = headNode;
for (int i = 1; i <= n; i++) {
ListNode newNode = new ListNode();
newNode.val = i;
newNode.next = null;
//插入到鏈表尾部
tailNode.next = newNode;
//指向新的尾節點，tailer永遠存儲最後一個節點的地址
tailNode = newNode;
}
return headNode;
}
和頭插入不同的是，我們需要聲明一個尾指針來輔助我們實現，最開始，尾指針指向頭指針，每插入一個元素，尾指針就后移一下，這裏我們來講一下原理：每次往末尾新加一個節點，我們就需要把原來的連接斷開，那怎麼斷開呢，我們首先需要讓尾指針指向新的節點，也就是 tailNode.next = newNode; 然後再讓尾指針后移一個位置，讓尾指針指向最後一個節點。也就是尾指針始終指向最後一個節點，最後將頭指針返回，輸出最後結果：
既然單鏈表創建好了，怎麼在鏈表裡面刪除元素呢，單鏈表的刪除，我分為了兩種情況刪除，分別是刪除第i個節點和刪除指定元素的節點。
我們可以先來理一下思路：在單鏈表裡，節點與節點之間都是通過指針域鏈接起來的，所以如果我們想實現刪除的操作，實際上是需要我們去改變相應指針域對應得地址的。當想去刪除第i個元素的時候，比如要刪除上圖的第3個元素（也就是3），實際上我們要做的就是要讓2號元素指向4號元素（其實就是需要修改2號元素的指針域，讓2號元素的指針域存儲4號元素）。那麼怎麼做才能實現這一步呢？很顯然，要實現這個步驟，我們必須要找到4號元素和2號元素，但是再仔細想一下，其實我們只需要找到2號元素就可以了，因為4號元素的地址存儲再2號的下一個元素的指針域裏面。
所以綜上所述分析我們可以得出刪除的兩個核心步驟：
1.刪除第i個節點，需要先找到第 i-1 個個節點，也就是第i個節點的前一個節點；
2.然後讓第 i-1 個節點指向第 i-1 個節點的下下個節點
下面的代碼具體實現了怎麼刪除第i個元素。
/**
* 刪除第i個節點
* 1,2 4,4,5
* 刪除之後應該是1,2,4,5
* @param headNode
* @param index
* @return
*/
public static ListNode deleteNodeByIndex(ListNode headNode, int index) {
int count = 1;
//將引用給它
ListNode preNode = headNode;
//看計數器是不是到了i-1，如果到了i-1,就找到了第i-1個節點
while (preNode.next != null && count <= index -1){
//尋找要刪除的當前節點的前一個節點
count++;
preNode = preNode.next;
}
if (preNode != null){
preNode.next = preNode.next.next;
}
return headNode;
}
刪除指定元素節點的實現方法有兩種，第一種就是先找到指定元素對應的鏈表的位置（ index ），然後再按照刪除第 i 個節點的思路刪除即可。實現方法如下圖所示：
/**
* 刪除鏈表指定數值的節點
* @param headNode
* @param val
* @return
*/
private static ListNode deleteNodeByNum(ListNode headNode, int val) {
ListNode deleteOne = headNode;
int countByDeleteOne = 1;
while (deleteOne.next != null){
if (deleteOne.next.val == val){
deleteOne = deleteOne.next;
break;
}
countByDeleteOne ++;
deleteOne = deleteOne.next;
}
return deleteNodeByIndex(headNode, countByDeleteOne);
}
第二種方法的實現就很精妙（前提是此節點不是尾節點）
public void deleteNode(ListNode node) {
//刪除node即通過將後面的值賦給node，然後更改node的指針指向下下一個結點即可
node.val = node.next.val;
node.next = node.next.next;
}
單鏈表的查詢實現很簡單，就是遍歷當前單鏈表，然後用一個計數器累加到當前下標，那麼當前的這個節點就是要查詢的那個節點，然後再返回即可，當然需要判斷傳過來的這個下標是否合法。當然如果需要修改，就需要把當前找到的節點的數據域重新賦上需要修改的值即可，這裏就不上代碼了。具體實現如下：
private static ListNode searchLinkedList(ListNode headNode, int index) {
//如果下標是不合法的下標就表示找不到
if (index < 1 || index > getLinkedListLength(headNode)){
return null;
}
for (int i = 0; i < index; i++) {
headNode = headNode.next;
}
return headNode;
}
獲取單鏈表的長度（注意我這裏定義的 headNode 是頭指針不是頭節點）
/**
* 求單鏈表長度
* @param headNode
* @return
*/
private static int getLinkedListLength(ListNode headNode) {
int countNode = 0;
while (headNode.next != null){
countNode++;
headNode = headNode.next;
}
return countNode;
}
單鏈表的相關操作就講解完了，其實通過上面對單鏈表的相關操作，我們不難發現，單鏈表的刪除和插入其實很方便，只需要改變指針的指向就可以完成，但是查找元素的時候就比較麻煩，因為在查找的時候，需要把整個鏈表從頭到尾遍歷一次。
公眾號：良許Linux
本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理
【其他文章推薦】
※新北清潔公司,居家、辦公、裝潢細清專業服務
※別再煩惱如何寫文案,掌握八大原則!
※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!
※超省錢租車方案
※教你寫出一流的銷售文案?