1.node
每个node,都包含前后两个,也被前后两个包含。(即
双向链表结构)
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
;
}
}
2.构造(new)--不像arraylist,没做什么
public
LinkedList() {
}
public
LinkedList(Collection<?
extends
E>
c
) {
this
();
addAll(
c
);
}
3.size()
public
int
size
() {
return
size
;
}
4.add()
当add第一个的时候,会把其当成first。
public
boolean
add(E
e
) {
linkLast(
e
);
return
true
;
}
void
linkLast
(E
e
) {
final
Node<E>
l
=
last
;
final
Node<E>
newNode
=
new
Node<>(
l
,
e
,
null
);
last
=
newNode
;
if
(
l
==
null
)
first
=
newNode
;
else
l
.
next
=
newNode
;
size
++;
modCount
++;
}
5.add(index,element) //从这个源码上来看,如果要在中间新增一个,要先找到当前node,查找起来不必arrylist快
public
void
add
(
int
index
, E
element
) {
checkPositionIndex(
index
);
if
(
index
==
size
)
linkLast(
element
);
else
linkBefore(
element
, node(
index
));
}
void
linkBefore
(E
e
, Node<E>
succ
) {
// assert succ != null;
final
Node<E>
pred
=
succ
.
prev
;
final
Node<E>
newNode
=
new
Node<>(
pred
,
e
,
succ
);
succ
.
prev
=
newNode
;
if
(
pred
==
null
)
first
=
newNode
;
else
pred
.
next
=
newNode
;
size
++;
modCount
++;
}
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
;
}
}
6.remove(index)
public
E
remove(
int
index
) {
checkElementIndex(
index
);
return
unlink(node(
index
));
}
E
unlink
(Node<E>
x
) {
// assert x != null;
final
E
element
=
x
.
item
;
final
Node<E>
next
=
x
.
next
;
final
Node<E>
prev
=
x
.
prev
;
if
(
prev
==
null
) {
first
=
next
;
}
else
{
prev
.
next
=
next
;
x
.
prev
=
null
;
}
if
(
next
==
null
) {
last
=
prev
;
}
else
{
next
.
prev
=
prev
;
x
.
next
=
null
;
}
x
.
item
=
null
;
size
--;
modCount
++;
return
element
;
}
7.get/set
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
;
}
8.indexOf/contains
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;
}
public
boolean
contains
(Object
o
) {
return
indexOf(
o
) != -1;
}
总结
LinkedList是基于双端链表的List,其内部的实现源于对链表的操作,所以适用于频繁增加、删除的情况;该类不是线程安全的;另外,由于LinkedList实现了Queue接口,所以LinkedList不止有队列的接口,还有栈的接口,可以使用LinkedList作为队列和栈的实现。