|
该用户从未签到
|
昨天一位项目组同事需要在ArrayList中删除所有不等于指定值的元素,但是她弄了很久,发现总是删得不完全。刚好我以前做过类似的功能,就告诉她是因为ArrayList删除元素后长度变小了,元素的索引也会跟着改变,但是迭代的下标没有跟着相应的改变的缘故。5 m5 K4 r, c% G1 x: C9 L( b' @: A
AD:4 w3 s0 |( I o3 J W, u
昨天一位项目组同事需要在ArrayList中删除所有不等于指定值的元素,但是她弄了很久,发现总是删得不完全。刚好我以前做过类似的功能,就告诉她是因为ArrayList删除元素后长度变小了,元素的索引也会跟着改变,但是迭代的下标没有跟着相应的改变的缘故。
8 S T% Y H: o1 a O/ R( H$ s
- z+ |* n( Q& }% h' _0 c: r将一些删除方法做一些总结:
! w2 K+ X/ ~; [3 ?' F% C5 x, e6 N# F1 f- U; A1 A& s
/** 2 H Y* ?1 o' B$ ]
* 删除Arraylist中值为"c"的元素 ) x: o. g; [# B
*/ 2 [7 L2 f x) q
public static void main(String[] args) { ' o; G' _# M$ z) S ]
6 ^7 l5 w# q4 e( `& t& y List<String> list = new ArrayList<String>(); : f$ U6 N5 G9 K( r3 [2 E' B6 K
$ j7 O* q b) e$ R8 l" P, A* X1 V! I //"c"在Arraylist不连续存储 4 ^/ U8 m; ]4 @* X
/* 0 @/ b; c* W2 g* j8 ~
list.add("c");
" S) K2 b( Q& ~5 N; P list.add("a"); ' g+ P9 g1 D; l0 ?- u9 K
list.add("c");
; e M: G% l# |7 z list.add("b"); * B0 Q5 O7 j& B
list.add("c");
/ X+ \ x, t7 `0 F6 z6 ?1 L list.add("d"); , K8 j: ]* h0 L9 R! N: ]) k3 @
list.add("c");
! Q. B" T0 r4 m: `, ]4 t/ A4 k */ # o( K& T5 w; w: c! [" S& [
/ F" H8 [! c4 \% ^9 E //"c"在Arraylist有连续存储 2 p! N6 O4 R9 o4 T1 U4 x
list.add("a");
% P# o( {' f. }0 Q# U7 @% A0 W# C list.add("c");
& @+ E% U- W$ o. }4 ^3 m3 N( h list.add("c");
+ K' e9 M- W- e, A5 d list.add("b");
( K- K' u3 D: Z7 @1 [2 l list.add("c"); 3 S& `& u- `! ~5 |6 A( l
list.add("c"); `! C. u9 Z) o7 ^- t
list.add("d"); + ~5 U0 t% G+ B8 ~
list.add("c");
; l; ?8 _; \" N( M8 \" P3 r
9 z0 f. N$ o6 c- X" A
# l, D+ |8 d" v. @( f; D% g //删除Arraylist中值为"c"的元素 8 t; u$ g* D' [* y' x! f2 B1 ~$ k5 ~0 Y
' I' x# n8 Z1 M: M2 {# V' k9 k: N% [3 |
//有可能不能全部删除
1 v8 D. C% v; B //removeListElement1(list); & o K) j3 }4 j" u* p# @; R
1 T# R4 G1 b) O1 L; l. A" n
//能够正确删除 + Q. G9 O( V7 K" s/ f
//removeListElement2(list);
, E4 c" L+ X: H* G& i ]& S: H) ]; Z4 U8 d K
//能够正确删除 ) Q, g1 J) n, A' M! v" D
//removeListElement3(list);
% Q9 R1 Z* B) O3 T0 \% O$ t6 L: f }
' T& Y6 p1 [8 p2 R! P" a' f7 m! f5 L9 b
* Q* @/ ]' _* C8 v /**
- F' ~& j, y+ S5 g8 I& ?$ V * 删除list中值为"c"的元素 0 }/ v1 ^1 f+ L$ {0 W# c& ]+ z
* , A1 u' Q- Q I0 \
* 这种方式:
% @* t9 q" C5 x. m& C* v * , m7 B! O) H" H+ N! T
* 当值为"c"的元素在Arraylist中不连续存储的时候,是可以把值为"c"的元素全部删掉
/ d% S0 ?4 [& [+ d ~3 k) z *
5 W1 [1 v% S0 C# F * 但是当值为"c"的元素在Arraylist中有连续存储的时候,就没有把值为"c"的元素全部删除
$ N2 b* r0 B1 V' n8 x' t * 因为删除了元素,Arraylist的长度变小了,索引也会改变,但是迭代的下标没有跟着变小 : m2 C) E. u: K4 y A/ T- x. o
*/
' a- O" [5 X: S3 ?4 J public static void removeListElement1(List<String> list) {
) s0 K3 z8 {% @! ^ for(int i=0;i<list.size();i++) {
. J+ Q8 ~! _: s if("c".equals(list.get(i))) {
8 C8 C5 A% a' S& w. u- T/ ?0 @7 \7 y6 Q list.remove(i);
' s- g7 B; l3 L* b+ u, w+ L }
' M: l3 g ? v3 Q }
! Q' j8 g- Z! `8 Y- v4 c0 x) K z1 r3 {0 H! q2 ^ }$ P9 y; {
} 5 f" p' f4 c+ C' H4 W9 a& u$ v
4 h4 p. d/ `, l( i8 y /**
, o0 d7 o2 X) f) d6 ^/ @ * 删除Arraylist中值为"c"的元素 4 X0 p, I9 v2 L% x- D9 D4 `/ L
*
2 [/ E: o# ` j4 ]# M G" V; p * 这种方式:
1 X: Y0 n6 i. g% x7 M ^' Y( x * 1 w+ `* S8 |6 I' m) G
* 不管值为"c"的元素在Arraylist中是否连续,都可以把值为"c"的元素全部删除 " d- _1 r- x% b" [* K6 ?
*/
0 m, X, H4 `+ o1 j1 `- G public static void removeListElement2(List<String> list) {
8 F% P" R1 d4 V$ X for(int i=0;i<list.size();i++) { ! g8 K7 c, ~* e' Q
if("c".equals(list.get(i))) {
2 H9 i/ T- I9 G3 U: }. Z# m: x list.remove(i);
X& s( K- z) u: {9 K; ]) a' M9 b --i;//删除了元素,迭代的下标也跟着改变 . g* ]! Y- Z* [
} . d1 Q5 }& C1 p* y7 J" f. I9 G
}
% D% y1 J1 h8 ~3 J8 o6 h. G } , |; }5 S/ A7 B- u/ F3 I
- k6 E- t) f( T6 d; q8 j U /** + S. j8 o, l& \$ X% G
* 删除Arraylist中值为"c"的元素 : a% R! @; N c2 P
* + J, q+ Z3 w: j; c; l3 J
* 这种方式:
7 q8 ?0 `' N) q3 f! ~$ _/ h8 @ *
0 _5 z& F; N3 U) L0 O * 不管值为"c"的元素在list中是否连续,都可以把值为"c"的元素全部删除
# O) z+ h4 V, v3 ` *
% T! u6 w& H# o4 J! p3 \6 B& Y/ H * 需保证没有其他线程同时在修改
! S) w0 N R8 U/ \1 V& R */
w2 Q- P: Z# @6 w7 | public static void removeListElement3(List<String> list) { 0 _1 w9 N" m3 }! ]& ]; a t. _- }& A
Iterator<String> iterator = list.iterator(); 8 Y- H: a3 W3 i- A% I! C2 G. ]
while(iterator.hasNext()) { 3 {7 x8 R' m% p B6 K0 m r8 v
String str = iterator.next(); $ d f$ d5 ~5 G" Y
if("c".equals(str)) { 0 [( c; i( E- i3 E
iterator.remove();
0 a& }% k5 z5 |: k2 F5 C }
1 z' R4 N' G% x0 j6 T7 M: m% e4 d. {5 ]4 n$ }
}
* _# N# o& |, _0 l }
( `3 \3 W. O9 D, l" R: v; ?( A' s/ o# S
|
|