Java學習筆記之LinkedList基本用法
阿新 • • 發佈：2019-01-16
LinkedList簡介
LinkedList是一個繼承於AbstractSequentialList的雙向連結串列。它也可以被當作堆疊、佇列或雙端佇列進行操作。LinkedList實現List介面，能進行佇列操作。LinkedList實現Deque介面，即能將LinkedList當作雙端佇列使用。ArrayList底層是由陣列支援，而LinkedList是由雙向連結串列實現的，其中的每個物件包含資料的同時還包含指向連結串列中前一個與後一個元素的引用。
LinkedList遍歷方式
LinkedList有以下幾種遍歷方式：
迭代器遍歷
Iterator<Integer> iterator = linkedList.iterator();
while - 1
- 2
- 3
- 4
for迴圈get()遍歷
for(int i = 0; i < linkedList.size(); i++){
linkedList.get(i);
}- 1
- 2
- 3
Foreach迴圈遍歷
for(Integer i : linkedList);- 1
通過pollFirst()或pollLast()遍歷
while(linkedList.size() != 0){
linkedList.pollFirst();
}- 1
- 2
- 3
通過removeFirst()或removeLast()遍歷
while(linkedList.size() != 0 - 1
- 2
- 3
效率測試
測試以上幾種遍歷方式的效率，部分程式碼如下：
/************************** 遍歷操作 ************************/
System.out.println("-----------------------------------------");
linkedList.clear();
for(int i = 0; i < 100000; i++){
linkedList.add(i);
}
// 迭代器遍歷
long start = System.currentTimeMillis();
Iterator<Integer> iterator = linkedList.iterator();
while - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
輸出：
-----------------------------------------
Iterator：17 ms
for：8419 ms
for2：12 ms
pollFirst()或pollLast()：12 ms
removeFirst()或removeLast()：10 ms- 1
- 2
- 3
- 4
- 5
- 6
由測試結果可以看出，遍歷LinkedList時，使用removeFirst()或removeLast()效率最高，而for迴圈get()效率最低，應避免使用這種方式進行。應當注意的是，使用pollFirst()或pollLast()或removeFirst()或removeLast()遍歷時，會刪除原始資料，若只單純的讀取，應當選用第一種或第三種方式。
LinkedList示例
/**
* @author GongchuangSu
* @since 2016.05.11
*/
import java.util.Iterator;
import java.util.LinkedList;
public class LinkedListDemo {
public static void main(String[] srgs){
LinkedList<Integer> linkedList = new LinkedList<>();
/************************** 基本操作 ************************/
linkedList.addFirst(0); // 新增元素到列表開頭
linkedList.add(1); // 在列表結尾新增元素
linkedList.add(2,2); // 在指定位置新增元素
linkedList.addLast(3); // 新增元素到列表結尾
System.out.println("LinkedList: " + linkedList);
System.out.println("getFirst(): " + linkedList.getFirst()); // 返回此列表的第一個元素
System.out.println("getLast(): " + linkedList.getLast()); // 返回此列表的最後一個元素
System.out.println("removeFirst(): " + linkedList.removeFirst()); // 移除並返回此列表的第一個元素
System.out.println("removeLast(): " + linkedList.removeLast()); // 移除並返回此列表的最後一個元素
System.out.println("After remove:" + linkedList);
System.out.println("contains(1) is :" + linkedList.contains(1)); // 判斷此列表包含指定元素，如果是，則返回true
System.out.println("size is : " + linkedList.size()); // 返回此列表的元素個數
/************************** 位置訪問操作 ************************/
System.out.println("-----------------------------------------");
linkedList.set(1, 3); // 將此列表中指定位置的元素替換為指定的元素
System.out.println("After set(1, 3):" + linkedList);
System.out.println("get(1): " + linkedList.get(1)); // 返回此列表中指定位置處的元素
/************************** Search操作 ************************/
System.out.println("-----------------------------------------");
linkedList.add(3);
System.out.println("indexOf(3): " + linkedList.indexOf(3)); // 返回此列表中首次出現的指定元素的索引
System.out.println("lastIndexOf(3): " + linkedList.lastIndexOf(3));// 返回此列表中最後出現的指定元素的索引
/************************** Queue操作 ************************/
System.out.println("-----------------------------------------");
System.out.println("peek(): " + linkedList.peek()); // 獲取但不移除此列表的頭
System.out.println("element(): " + linkedList.element()); // 獲取但不移除此列表的頭
linkedList.poll(); // 獲取並移除此列表的頭
System.out.println("After poll():" + linkedList);
linkedList.remove();
System.out.println("After remove():" + linkedList); // 獲取並移除此列表的頭
linkedList.offer(4);
System.out.println("After offer(4):" + linkedList); // 將指定元素新增到此列表的末尾
/************************** Deque操作 ************************/
System.out.println("-----------------------------------------");
linkedList.offerFirst(2); // 在此列表的開頭插入指定的元素
System.out.println("After offerFirst(2):" + linkedList);
linkedList.offerLast(5); // 在此列表末尾插入指定的元素
System.out.println("After offerLast(5):" + linkedList);
System.out.println("peekFirst(): " + linkedList.peekFirst()); // 獲取但不移除此列表的第一個元素
System.out.println("peekLast(): " + linkedList.peekLast()); // 獲取但不移除此列表的第一個元素
linkedList.pollFirst(); // 獲取並移除此列表的第一個元素
System.out.println("After pollFirst():" + linkedList);
linkedList.pollLast(); // 獲取並移除此列表的最後一個元素
System.out.println("After pollLast():" + linkedList);
linkedList.push(2); // 將元素推入此列表所表示的堆疊（插入到列表的頭）
System.out.println("After push(2):" + linkedList);
linkedList.pop(); // 從此列表所表示的堆疊處彈出一個元素（獲取並移除列表第一個元素）
System.out.println("After pop():" + linkedList);
linkedList.add(3);
linkedList.removeFirstOccurrence(3); // 從此列表中移除第一次出現的指定元素（從頭部到尾部遍歷列表）
System.out.println("After removeFirstOccurrence(3):" + linkedList);
linkedList.removeLastOccurrence(3); // 從此列表中移除最後一次出現的指定元素（從頭部到尾部遍歷列表）
System.out.println("After removeFirstOccurrence(3):" + linkedList);
/************************** 遍歷操作 ************************/
System.out.println("-----------------------------------------");
linkedList.clear();
for(int i = 0; i < 100000; i++){
linkedList.add(i);
}
// 迭代器遍歷
long start = System.currentTimeMillis();
Iterator<Integer> iterator = linkedList.iterator();
while(iterator.hasNext()){
iterator.next();
}
long end = System.currentTimeMillis();
System.out.println("Iterator：" + (end - start) +" ms");
// 順序遍歷(隨機遍歷)
start = System.currentTimeMillis();
for(int i = 0; i < linkedList.size(); i++){
linkedList.get(i);
}
end = System.currentTimeMillis();
System.out.println("for：" + (end - start) +" ms");
// 另一種for迴圈遍歷
start = System.currentTimeMillis();
for(Integer i : linkedList);
end = System.currentTimeMillis();
System.out.println("for2：" + (end - start) +" ms");
// 通過pollFirst()或pollLast()來遍歷LinkedList
LinkedList<Integer> temp1 = new LinkedList<>();
temp1.addAll(linkedList);
start = System.currentTimeMillis();
while(temp1.size() != 0){
temp1.pollFirst();
}
end = System.currentTimeMillis();
System.out.println("pollFirst()或pollLast()：" + (end - start) +" ms");
// 通過removeFirst()或removeLast()來遍歷LinkedList
LinkedList<Integer> temp2 = new LinkedList<>();
temp2.addAll(linkedList);
start = System.currentTimeMillis();
while(temp2.size() != 0){
temp2.removeFirst();
}
end = System.currentTimeMillis();
System.out.println("removeFirst()或removeLast()：" + (end - start) +" ms");
}
}
/**Output
LinkedList: [0, 1, 2, 3]
getFirst(): 0
getLast(): 3
removeFirst(): 0
removeLast(): 3
After remove:[1, 2]
contains(1) is :true
size is : 2
-----------------------------------------
After set(1, 3):[1, 3]
get(1): 3
-----------------------------------------
indexOf(3): 1
lastIndexOf(3): 2
-----------------------------------------
peek(): 1
element(): 1
After poll():[3, 3]
After remove():[3]
After offer(4):[3, 4]
-----------------------------------------
After offerFirst(2):[2, 3, 4]
After offerLast(5):[2, 3, 4, 5]
peekFirst(): 2
peekLast(): 5
After pollFirst():[3, 4, 5]
After pollLast():[3, 4]
After push(2):[2, 3, 4]
After pop():[3, 4]
After removeFirstOccurrence(3):[4, 3]
After removeFirstOccurrence(3):[4]
-----------------------------------------
Iterator：17 ms
for：8419 ms
for2：12 ms
pollFirst()或pollLast()：12 ms
removeFirst()或removeLast()：10 ms
*/- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
- 158
- 159
- 160
- 161
LinkedList和ArrayList比較
LinkedList中插入元素很快，而ArrayList中插入元素很慢LinkedList中隨機訪問很慢，而ArrayList中隨機訪問很快
LinkedList原始碼解析
package java.util;
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
transient int size = 0;
// 第一個結點
transient Node<E> first;
// 最後一個結點
transient Node<E> last;
// 構造一個空列表
public LinkedList() {
}
// 構造一個包含指定 Collection 中的元素的列表，
// 這些元素按其 Collection 的迭代器返回的順序排列
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
// 返回此列表的第一個元素
public E getFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return f.item;
}
// 返回此列表的最後一個元素
public E getLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return l.item;
}
// 移除並返回此列表的第一個元素
public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
// 移除並返回此列表的最後一個元素
public E removeLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return unlinkLast(l);
}
// 將指定元素插入此列表的開頭
public void addFirst(E e) {
linkFirst(e);
}
// 將指定元素新增到此列表的結尾
public void addLast(E e) {
linkLast(e);
}
// 判斷此列表包含指定元素，如果是，則返回true
public boolean contains(Object o) {
return indexOf(o) != -1;
}
// 返回此列表的元素個數
public int size() {
return size;
}
// 將指定元素新增到此列表的結尾
public boolean add(E e) {
linkLast(e);
return true;
}
// 從此列表中移除首次出現的指定元素(如果存在返回true，否則返回false)
public boolean remove(Object o) {
if (o == null) {
for (Node<E> x = first; x != null; x = x.next) {
if (x.item == null) {
unlink(x);
return true;
}
}
} else {
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item)) {
unlink(x);
return true;
}
}
}
return false;
}
// 新增指定 collection 中的所有元素到此列表的結尾，
// 順序是指定 collection 的迭代器返回這些元素的順序
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
// 將指定 collection 中的所有元素從指定位置開始插入此列表
public boolean addAll(int index, Collection<? extends E> c) {
checkPositionIndex(index);// 檢查index的範圍
Object[] a = c.toArray();
int numNew = a.length;
if (numNew == 0) // 如果c為空，則返回false
return false;
Node<E> pred, succ;
if (index == size) { // 插入位置為列表末尾
succ = null;
pred = last;
} else {
succ = node(index); // 插入位置不是列表末尾
pred = succ.prev;
}
// 將元素新增到pred末尾
for (Object o : a) {
@SuppressWarnings("unchecked") E e = (E) o;
Node<E> newNode = new Node<>(pred, e, null);
if (pred == null)
first = newNode;
else
pred.next = newNode;
pred = newNode;
}
// 將剩餘元素整合一起
if (succ == null) {
last = pred;
} else {
pred.next = succ;
succ.prev = pred;
}
size += numNew;
modCount++;
return true;
}
// 從此列表中移除所有元素
public void clear() {
// Clearing all of the links between nodes is "unnecessary", but:
// - helps a generational GC if the discarded nodes inhabit
// more than one generation
// - is sure to free memory even if there is a reachable Iterator
for (Node<E> x = first; x != null; ) {
Node<E> next = x.next;
x.item = null;
x.next = null;
x.prev = null;
x = next;
}
first = last = null;
size = 0;
modCount++;
}
/********************** 位置訪問操作 **************************/
// 返回此列表中指定位置處的元素
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
// 將此列表中指定位置的元素替換為指定的元素
public E set(int index, E element) {
checkElementIndex(index);
Node<E> x = node(index);
E oldVal = x.item;
x.item = element;
return oldVal;
}
// 在此列表中指定的位置插入指定的元素
public void add(int index, E element) {
checkPositionIndex(index);
if (index == size) // 插入到末尾
linkLast(element);
else
linkBefore(element, node(index));
}
// 移除此列表中指定位置處的元素
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
// （包訪問許可權）返回指定位置上的結點（非空）
Node<E> node(int index) {
// assert isElementIndex(index);
// 根據指定位置是在左半邊還是在右半邊，
// 來決定是用正向尋找還是反向尋找
if (index < (size >> 1)) {
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
/********************** Search操作 **************************/
// 返回此列表中首次出現的指定元素的索引，
// 如果此列表中不包含該元素，則返回 -1
public int indexOf(Object o) {
int index = 0;
if (o == null) {
for (Node<E> x = first; x != null; x = x.next) {
if (x.item == null)
return index;
index++;
}
} else {
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item))
return index;
index++;
}
}
return -1;
}
// 返回此列表中最後出現的指定元素的索引，
// 如果此列表中不包含該元素，則返回 -1
public int lastIndexOf(Object o) {
int index = size;
if (o == null) {
for (Node<E> x = last; x != null; x = x.prev) {
index--;
if (x.item == null)
return index;
}
} else {
for (Node<E> x = last; x != null; x = x.prev) {
index--;
if (o.equals(x.item))
return index;
}
}
return -1;
}
/********************** Queue操作 **************************/
// 獲取但不移除此列表的頭（第一個元素）
public E peek() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
// 獲取但不移除此列表的頭（第一個元素）
public E element() {
return getFirst();
}
// 獲取並移除此列表的頭（第一個元素）
public E poll() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
// 獲取並移除此列表的頭（第一個元素）
public E remove() {
return removeFirst();
}
// 將指定元素新增到此列表的末尾（最後一個元素）
public boolean offer(E e) {
return add(e);
}
/********************** Deque操作 **************************/
// 在此列表的開頭插入指定的元素
public boolean offerFirst(E e) {
addFirst(e);
return true;
}
// 在此列表末尾插入指定的元素
public boolean offerLast(E e) {
addLast(e);
return true;
}
// 獲取但不移除此列表的第一個元素
public E peekFirst() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
// 獲取但不移除此列表的最後一個元素
public E peekLast() {
final Node<E> l = last;
return (l == null) ? null : l.item;
}
// 獲取並移除此列表的第一個元素
public E pollFirst() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
// 獲取並移除此列表的最後一個元素
public E pollLast() {
final Node<E> l = last;
return (l == null) ? null : unlinkLast(l);
}
// 將元素推入此列表所表示的堆疊（插入到列表的頭）
public void push(E e) {
addFirst(e);
}
// 從此列表所表示的堆疊處彈出一個元素（獲取並移除列表第一個元素）
public E pop() {
return removeFirst();
}
// 從此列表中移除第一次出現的指定元素（從頭部到尾部遍歷列表）
public boolean removeFirstOccurrence(Object o) {
return remove(o);
}
// 從此列表中移除最後一次出現的指定元素（從頭部到尾部遍歷列表）
public boolean removeLastOccurrence(Object o) {
if (o == null) {
for (Node<E> x = last; x != null; x = x.prev) {
if (x.item == null) {
unlink(x);
return true;
}
}
} else {
for (Node<E> x = last; x != null; x = x.prev) {
if (o.equals(x.item)) {
unlink(x);
return true;
}
}
}
return false;
}
// 返回此列表中的元素的列表迭代器（按適當順序），從列表中指定位置開始
public ListIterator<E> listIterator(int index) {
checkPositionIndex(index);
return new ListItr(index);
}
// （私有類）結點結構
private static class Node<E> {
E item;
Node<E> next;
Node<E> prev;
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
/**
* @since 1.6
*/
public Iterator<E> descendingIterator() {
return new DescendingIterator();
}
/**
* Adapter to provide descending iterators via ListItr.previous
*/
private class DescendingIterator implements Iterator<E> {
private final ListItr itr = new ListItr(size());
public boolean hasNext() {
return itr.hasPrevious();
}
public E next() {
return itr.previous();
}
public void remove() {
itr.remove();
}
}
@SuppressWarnings("unchecked")
private LinkedList<E> superClone() {
try {
return (LinkedList<E>) super.clone();
} catch (CloneNotSupportedException e) {
throw new InternalError();
}
}
// 返回此 LinkedList 的淺表副本
public Object clone() {
LinkedList<E> clone = superClone();
// Put clone into "virgin" state
clone.first = clone.last = null;
clone.size = 0;
clone.modCount = 0;
// Initialize clone with our elements
for (Node<E> x = first; x != null; x = x.next)
clone.add(x.item);
return clone;
}
// 返回以適當順序（從第一個元素到最後一個元素）包含此列表中所有元素的陣列
public Object[] toArray() {
Object[] result = new Object[size];
int i = 0;
for (Node<E> x = first; x != null; x = x.next)
result[i++] = x.item;
return result;
}
// 返回以適當順序（從第一個元素到最後一個元素）包含此列表中所有元素的陣列；
// 返回陣列的執行時型別為指定陣列的型別。
@SuppressWarnings("unchecked")
public <T> T[] toArray(T[] a) {
if (a.length < size)
a = (T[])java.lang.reflect.Array.newInstance(
a.getClass().getComponentType(), size);
int i = 0;
Object[] result = a;
for (Node<E> x = first; x != null; x = x.next)
result[i++] = x.item;
if (a.length > size)
a[size] = null;
return a;
}
// 版本序列號
private static final long serialVersionUID = 876323262645176354L;
// java.io.Serializable的寫入函式
// 將LinkedList的“容量，所有的元素值”都寫入到輸出流中
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
// Write out any hidden serialization magic
s.defaultWriteObject();
// Write out size
s.writeInt(size);
// Write out all elements in the proper order.
for (Node<E> x = first; x != null; x = x.next)
s.writeObject(x.item);
}
// java.io.Serializable的讀取函式：根據寫入方式反向讀出
// 先將LinkedList的“容量”讀出，然後將“所有的元素值”讀出
@SuppressWarnings("unchecked")
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in any hidden serialization magic
s.defaultReadObject();
// Read in size
int size = s.readInt();
// Read in all elements in the proper order.
for (int i = 0; i < size; i++)
linkLast((E)s.readObject());
}
}相關推薦
Java學習筆記之LinkedList基本用法
LinkedList簡介LinkedList 是一個繼承於AbstractSequentialList的雙向連結串列。它也可以被當作堆疊、佇列或雙端佇列進行操作。LinkedList 實現 List 介面，能進行佇列操作。LinkedList 實現 Deque 介面，即能將L
Java學習筆記之介面基本概念
1、基本概念 介面是Java中最重要的概念，介面可以理解為是一種特殊的類，裡面全部都是由全域性的公共常量和抽象方法組成。 換言之，如果一個類中完全是由全域性常量和抽象方法組成，那就可以定義為一個介面 介面定義格式： interface 介面名 { 全域性常量; 抽象方
【Java學習筆記之二十二】解析接口在Java繼承中的用法及實例分析
ani 復制代碼 ads compute 現在 target body 常量 實現接口 一、定義 Java接口（Interface），是一系列方法的聲明，是一些方法特征的集合，一個接口只有方法的特征沒有方法的實現，因此這些方法可以在不同的地方被不同的類實現，而這些實現可以具
Java學習筆記之--------執行緒基本資訊
執行緒常用的幾個方法如下： isAlive() ：測試執行緒是否處於活動狀態。 setName(String name) ：改變執行緒名稱，使之與引數 name 相同。 getName() ：返回該執行緒的名稱。 setPriority(int newP
Java學習筆記之抽象類基本概念（1）
1、基本概念 抽象類：包含一個抽象方法的類 抽象方法：用abstract關鍵字宣告，且只有方法名沒有方法體的方法。 1.1 抽象類的定義和使用規則 包含了一個抽象方法的類必須是抽象類 抽象類和抽象方法都要用abstract關鍵字宣告 抽象方法只需要宣告不用實現
Java學習筆記之Pattern類的用法詳解 (正則表示式)
Implements: Serializable 正則表示式的編譯表示形式。 指定為字串的正則表示式必須首先被編譯為此類的例項。然後，可將得到的模式用於建立 Matcher 物件，依照正則表示式，該物件可以與任意字元序列匹配。執行匹配所涉及的所有狀態都駐留在匹配器中，
【Java學習筆記之三十二】淺談Java中throw與throws的用法及異常拋出處理機制剖析
input auto void ref 淺談 .html ssa 不能 而是 異常處理機制 異常處理是對可能出現的異常進行處理，以防止程序遇到異常時被卡死，處於一直等待，或死循環。 異常有兩個過程，一個是拋出異常；一個是捕捉異常。 拋出異常 拋出異常有三種
ELK 學習筆記之 Logstash基本語法
技術 logs erl 定義 -s images cnblogs img ron Logstash基本語法： 處理輸入的input 處理過濾的filter 處理輸出的output 區域 數據類型 條件判斷 字段引用 區域： Logstash中，是用{}
Java 學習筆記之 Error和Exception的聯系
相關 runt ble 及其 捕獲 exce throw 繼承 編譯 Error和Exception的聯系: Error和Exception的聯系 繼承結構：Error和Exception都是繼承於Throwable，RuntimeException繼承自Excep
Java 學習筆記之 Sleep停止線程
run rgs ges xtend over exce http tac p s Sleep停止線程: 在Sleep狀態下被interrupt，interrupted 狀態會被擦除，返回false。 線程在Sleep狀態下被interrupt： public clas
Java 學習筆記之 線程安全
div ora mage 線程安全 cnblogs cor exception rup ron 線程安全: 線程安全的方法一定是排隊運行的。 public class SyncObject { synchronized public void met
java學習筆記之System類
系統 arr 操作系統 ring system tro separate rate java學習筆記 System類常用總結 System類概述 java.lang.System類，系統屬性信息工具類 常用靜態方法： 1. 1 public static long
java學習筆記之字符流文件復制
body file 文件 [] while gpo class spa char 字符文件復制 1 FileReader fr =new FileReader("b.txt");//綁定源文件 2 FileWriter fw= new FileWriter("a.
java學習筆記之面向對象static,final關鍵字
一次 static 變量 div nbsp 子類 方法 pan 抽取 java學習筆記之面向對象static,final關鍵字 一.static關鍵字 1.概述： static靜態的，被static修飾的成員屬於類，不屬於單個對象，被所有對象所共享，存在靜態區中，靜態的
java學習筆記之初識多線程
技術 運行 必須 dex ima this 認識 主線程 inf 初識多線程 一.進程的認識： 1.進程的理解： 進程可以理解成正在執行的任務，就是正在運行的程序，進程又分為兩種，一種是前臺進程，就是我們很直觀看見的，另一種是後臺進程，就是操作系統啟動就有的(系統級
effective java學習筆記之不可實例化的類
style 類的方法 div pan ava 我們 工具 靜態 class 在沒有顯式聲明一個類的構造方法時，編譯器會生成默認的無參構造方法，在設計工具類時，我們通常將方法設置成靜態方法，以類名.方法名的形式調用，此時這個類就沒有必要創建實例，我們知道抽象類不可以被實例化，
java學習筆記之網絡編程
col client 應用場景 err pri 多圖片 data oca 網絡 網絡編程 一.網絡通信協議 1.網絡協議 不同的操作系統，不同的硬件設備上都能夠聯網，是因為互聯網設計規定了一套標準，這套標準就被稱為網絡協議，網絡協議規定了網絡傳輸的格式，速率和方
java學習筆記之面向對象多態
成員變量 clas 創建 無法 復用 xtend 數據類型 需要 類重寫 面向對象三大特性之多態 一.多態的概念 多態是繼封裝，繼承之後，面向對象的三大特性。 現實事物經常會體現出多種形態，如學生，學生是人的一種，則一個具體的張三同學既是學生也是人，即出現兩種形態。
java學習筆記之xml
是什麽 read 文本標記 utf-8 轉義字符 本地緩存 system 進行 特殊 xml學習筆記 1:xml的概述 1.1 xml是什麽 標記語言:語言中出現了<a></a>的標簽 a:HTML 超文本標記語言
java學習筆記之mysql2
數值類型 個數 合並 category name 數值 ice const cname mysql #-----sql指令的查詢----------(重點) #1 排序(order by) ASC：升序 DESC：降序 #SELECT * FROM 表名 ORDER BY