|
该用户从未签到
|
昨天一位项目组同事需要在ArrayList中删除所有不等于指定值的元素,但是她弄了很久,发现总是删得不完全。刚好我以前做过类似的功能,就告诉她是因为ArrayList删除元素后长度变小了,元素的索引也会跟着改变,但是迭代的下标没有跟着相应的改变的缘故。5 [+ x# G/ O9 i8 k- J m5 Z
AD:
& G# u9 A' F. z4 l$ U& b, k昨天一位项目组同事需要在ArrayList中删除所有不等于指定值的元素,但是她弄了很久,发现总是删得不完全。刚好我以前做过类似的功能,就告诉她是因为ArrayList删除元素后长度变小了,元素的索引也会跟着改变,但是迭代的下标没有跟着相应的改变的缘故。
( q6 M# o9 q7 u2 s K! X; r: a! _ J7 a* C/ l( V: E
将一些删除方法做一些总结:; E! S8 I4 D/ R. n
- U6 Q6 I# X* P9 d; O4 J! t/** 8 ^; P( k( C4 @* w
* 删除Arraylist中值为"c"的元素
, B, ^& W% \. s4 H* v1 t8 w */ ( A0 O- a# q8 k* t( A
public static void main(String[] args) { ( ^* S- V9 G% O N9 y% [4 [! M4 ^
! r" E ?1 }6 x! Y$ m0 p List<String> list = new ArrayList<String>(); ' y, c+ |" z7 }* T3 k4 H
# O1 s! E( H4 [$ y! K! q
//"c"在Arraylist不连续存储
% L2 u+ C# N0 s( A8 u0 L* a /*
: B) |: Y' n5 e9 z, R list.add("c");
# u" t% ]. R* ~$ x$ y% N' l list.add("a"); $ h/ A+ x! I( B5 ^
list.add("c");
0 O0 m* B$ j1 b7 \/ l4 f list.add("b");
6 p4 y5 L$ Y6 b) j" _ list.add("c"); - j" e+ x( j( ~. y
list.add("d");
* k, w! l- ?1 z2 Z3 ` list.add("c");
6 A0 E: s3 y6 J6 S6 r% ?$ H */ $ t+ q& ~4 A: |* u( }6 J
7 L' p m( k2 D- |# Q3 o8 `0 Z
//"c"在Arraylist有连续存储 . K( N3 L3 E& s) F) s
list.add("a"); % }8 q* N, H0 Y" ]7 j. B
list.add("c"); 0 V6 p( F( I) j; B, n2 |3 c8 T
list.add("c"); $ Q! {8 g H1 Q: y) Q/ u1 G
list.add("b"); 7 s6 ^& ^8 K$ O0 E; T( c6 P# l
list.add("c"); 1 T) c- U2 a; |) z! e+ Z
list.add("c");
5 T3 ]8 o7 M# O/ ~1 R1 s1 ] list.add("d"); 1 g7 `' U4 h/ O# T0 Q
list.add("c");
4 T( g# E( E0 R4 c5 n# \ L! P' G9 m, z9 @' V) r) N
' U/ }- r. r, t1 Y0 d' s0 k3 k. F //删除Arraylist中值为"c"的元素
! A% j( G* Z ^7 a; O8 G" C/ W
Q; u2 d% w& Y) G$ Q/ L% ` //有可能不能全部删除
, ]- ?/ p6 n9 G7 X x //removeListElement1(list); 9 `4 k" B7 ~1 a
8 k* a' r9 k" d
//能够正确删除 . [. C9 o" C$ G7 y* N
//removeListElement2(list); ; n- w( B, }2 o' N* s
! p* O9 S$ m% S& f( j
//能够正确删除 9 M4 {; t; ]/ h) r
//removeListElement3(list);
/ T- u4 S; x) ~# z5 W }
1 K' z$ M/ P$ R; f7 X+ E
- _2 d- H1 }4 |0 @( f( D4 J4 }2 `. P$ r- |' \6 C7 O2 H5 }
/**
6 I7 U& E! @+ s7 R0 c- [$ R * 删除list中值为"c"的元素 5 m& |; W* {8 ]; e. A1 S' V) O
* 5 Q9 z5 r! v' K. p6 P
* 这种方式: C$ E$ [. k$ |5 `
* " O. \# ~& `2 M* n$ }
* 当值为"c"的元素在Arraylist中不连续存储的时候,是可以把值为"c"的元素全部删掉
- ?4 w2 ]; a j( P2 v. D *
9 `; k U" |1 }% Z) i * 但是当值为"c"的元素在Arraylist中有连续存储的时候,就没有把值为"c"的元素全部删除 ; |) Q. s' m- u9 T# ^6 \
* 因为删除了元素,Arraylist的长度变小了,索引也会改变,但是迭代的下标没有跟着变小
$ H& T& N5 T3 A& k, @( [# P */ # i6 z8 l9 q' C K' B. B
public static void removeListElement1(List<String> list) { % j/ S. Z/ T! Y0 e, q0 j5 S* M X
for(int i=0;i<list.size();i++) {
6 l: c8 }8 U: u% D* l$ z1 a8 z if("c".equals(list.get(i))) {
1 j+ |) t2 Y5 r4 X$ o+ K list.remove(i);
& \5 ?3 t2 i, e8 T }
5 U# C. O0 K8 ~+ q }
( O; g3 y4 c/ b5 x; K+ J
6 E R' [+ b2 l& b1 K. k" w }
7 W) z- q j/ p; E( w1 q
4 c: ^1 g1 \9 A4 C! p. z4 V /**
, n+ o/ B; z; @$ z/ ]/ t * 删除Arraylist中值为"c"的元素 * e7 e6 w! k' ]( G" i; W
*
$ m D4 E$ I" U* N" e * 这种方式: ( z8 X- ^4 [: H7 n8 G0 }8 r
* 5 k& W0 W# p3 y
* 不管值为"c"的元素在Arraylist中是否连续,都可以把值为"c"的元素全部删除
0 U2 X+ p" V/ M+ ?& N */
1 E" r5 O( d9 ^8 T; L public static void removeListElement2(List<String> list) {
) l: a7 X* U2 T/ ~* M0 } for(int i=0;i<list.size();i++) { # G6 I7 M* w: D0 i
if("c".equals(list.get(i))) {
3 @3 X: Y( |- ^; g0 }1 \. R list.remove(i);
{; d3 c$ V# P+ v --i;//删除了元素,迭代的下标也跟着改变 * v0 ?$ s) I; e, N- u" s$ y
} % r5 O$ J" O. p: }: R
}
! K% ~8 O# U: g) U/ Y! d1 e }
6 Z8 Y8 E% J! v9 a" A% T# M) v1 `& V- z* p: [+ ]+ e& j/ ?( t. q
/** 7 f2 u( _8 u6 B# U: c# S5 O; H1 \8 ~: P4 ]
* 删除Arraylist中值为"c"的元素
2 V9 P# U: ^) F, B% p9 x& P" V( ]! j * ) C S$ j; R9 Z" H! Z
* 这种方式:
( B1 _( ^/ g/ z Q9 l6 }' l& u& Z9 a *
2 q" s4 K4 I" z( l9 r4 Y6 y' y * 不管值为"c"的元素在list中是否连续,都可以把值为"c"的元素全部删除
8 V* H& o2 J( P *
I# ^0 f) I# E6 N" u8 M; n * 需保证没有其他线程同时在修改
x: ]. f: z8 H. ^- l */
7 g! i! r# z& k7 D public static void removeListElement3(List<String> list) {
?6 b0 } J0 D2 f8 V$ H' | Iterator<String> iterator = list.iterator(); D& O3 a* Y/ e- H( U
while(iterator.hasNext()) { 0 P$ }% ^) E6 v9 B* ^/ M7 F7 @/ s
String str = iterator.next(); 6 @; h" G0 P( @( Y3 J0 e# x0 [
if("c".equals(str)) { / w; |0 u+ b3 ]
iterator.remove();
1 E# P, p' y& j% S! D } $ x l8 o+ W& {
# K' C5 `% F* L& g; Z
} : Y/ k0 f) g7 ?, m2 n# P( g
}
6 ~2 R5 j# T9 A1 N9 a
4 p. s9 f( ^% w |
|