ืืืืืจ ืืื ืชืจืืื ืฉื ืืืืืจ
" 10 ืืฉืืืืช ืืืืืืืืช ืขื ืืืกืคื Java " . ืืืื ืืฉืืืืช ืืคืืคืืืจืืืช ืืืืชืจ ืขื ืืืกืคืื ื-Java, ืฉื ืฉืืื ืื ืืื ื ื-Stackowerflow. ืืคื ื ืฉืชืกืชืื ืขื ืืฉืืืืช ืืืื, ืืืื ืืื ืืืกืชืื ืขื ืืืืืจืืช ืืืืจืจืืื ืฉื ืืืืชื.
1. ืืชื ืืืฉืชืืฉ ื-LinkedList ืืืงืื ื-ArrayList?
ArrayList ืืื ืืืขืฉื ืืขืจื; ื ืืชื ืืืฉืช ืืฉืืจืืช ืืืืื ืืื ืฉืื ืืืืฆืขืืช ืืื ืืงืก. ืื ืืืขืจื ืขืืื ืขื ืืืืชืื, ืืืื ืฆืืจื ืืืขืจื ืืืฉ ืขื ืืืชืจ ืืงืื. ืืืงืื ืืืืื ืฉื ืื ืืืืื ืืื ืืืงื ืืื O(n). ืืื ืื, ืืืกืคื ืืืกืจื ืฉื ืืืื ืืื ื ืืืฆื ืืื ืืืขืืืจ ืืืื ืืื ืงืืืืื ืืืขืจื. ืื ืืืื ืื ืื ืืืืช ืืืืืื ืืืืชืจ ืืฉืืืืฉ ื- ArrayList. LinkedList ืืื ืจืฉืืื ืืคืืื ืฉื ืงืืฉืืจื ืืืื ืืื. ืืคืืื, ืืื ืืืฉืช ืืืืื ื ืฉืืืจืื, ืขืืื ืืืคืฉ ืืืืชืืื ืืขื ืืกืืฃ ืฉื ืืืืืืื. ืืฆื ืฉื ื, ืืืกืคื ืืืกืจื ืฉื ืืืื ื ื-LinkedList ืืื ืืืืจื ืืืชืจ ืืืืืื ืฉืคืขืืืืช ืืื ืจืง ืืฉื ืืช ืืช ืืจืฉืืื ืขืฆืื. ืืืื ืืฉืื ืืืื ืื ืืืจืืขืื ืืืืชืจ:
ืฉืืื |
ืจืฉืืืช ืืขืจื |
ืจืฉืืื ืืงืืฉืจืช |
get(index) |
O(1) |
ืขึทื) |
ืืืกืฃ (E) |
ืขึทื) |
O(1) |
add(E, index) |
ืขึทื) |
ืขึทื) |
ืืืกืืจ (ืืื ืืงืก) |
ืขึทื) |
ืขึทื) |
Iterator.remove() |
ืขึทื) |
O(1) |
Iterator.add(E) |
ืขึทื) |
O(1) |
ืืืจืืช ืืื ืืจืืฆื, ืืฉืืืืฉ ืืืืืจืื ืืืื ืืืืืฉื ืื ืคืจื ืขืืืจ ืจืฉืืืืช ืืืืืืช. ื-LinkedList, ืืื ืฆืืืช ืืืืืื ืืืืืช ืืคืืืช ืฉื ื ืืฆืืืขืื ื ืืกืคืื ืืื ืืงืฉืจ ืืช ืืฆืืชืื ืืงืืืืื ืืืืืื, ืืขืื ืฉื-ArrayList ืืฉ ืฆืืจื ืืืขืจื ืฉื ืืืื ืืื ืืืื.
ืืฉืืืืืช ื ืืกืคืืช ืฉื ืจืฉืืืืช ArrayList, LinkedList ื-Vector .
2. ืืงืืืื ืืขืืื ืืืกืจืช ืืืื ืืื ืืืืื ืืืืจืฆืื ืฉื ืืืกืฃ ืืืจื ืื ืืื ื ืืืืืื ืืฉื ืืช (ืืืกืืจ ืืืื ืืื) ืืืกืฃ ืืืืื ืืืืจืฆืื ืืื ืืืฉืชืืฉ
ื-Iterator.remove() . ืืืืืื: ืืฉืืืื ืื ืคืืฆื ืืืืชืจ ืืื: ืชืงืื
ConcurrentModificationException ืืืื ืืคืขืืช ืืงืื ืืืขืื. ืื ืงืืจื ืืืื ืฉืืืืืจืืืจ ื ืืฆืจ ืืื ืืขืืืจ ืืจืฉืืื ืืืื, ืืื ืืืืชื ืืื ืืืืืืื ืืฉืชื ื ืขื ืืื ืงืจืืื ื-Iterator.remove(). ืืคื ืฉื ืืชื ืืชืืขืื ืืืจืื ืื,
Iterator
itr = list.iterator(); while(itr.hasNext()) { // do something itr.remove(); }
for(Integer i: list) { list.remove(i); }
"ืื ืืืชืจ ืืืจื ืืื ืืฉืจืฉืืจ ืืื ืืฉื ืืช ืืืกืฃ ืืืื ืฉืจืฉืืจ ืืืจ ืืืืจ ืขืืื."
ืืืืคื ืืืื, ืื ืื ืืงืืื ืฉืฉืจืฉืืจ ืืื ืืฉื ื ืืืกืฃ ืืืื ืฉืจืฉืืจ ืืืจ ืืืฆื ืืืชื.
3. ืืืฆื ืืืืืจ ืจืฉืืื ืืืขืจื int[]? ืืืจื ืืงืื ืืืืชืจ ืืขืฉืืช ืืืช ืืื ืืืฉืชืืฉ
ื-ArrayUtils , ืืืืืงื ืืกืคืจืืืช
Apache Commons Lang .
int[] array = ArrayUtils.toPrimitive(list.toArray(new Integer[0]));
ืืื ืงืืฆืืจ ืืจื ืืืืืื ืื ื-JDK. ืืืืจ ืฉืืื ื ืืืื ืืืฉืชืืฉ ื- List.toArray() ืืืืืื ืฉืืืืืื ืืื ืืืืจ ืจืฉืืื ืืืกืคืจ ืฉืื[] (ืฉืืื ื ื
ืกืื ืคืจืืืืืืื). ืืืจื ืื ืืื ื ืชืืื ืืืคืฉืจืืช ืืืื:
int[] array = new int[list.size()]; for(int i=0; i < list.size(); i++) { array[i] = list.get(i); }
4. ืืืฆื ืืืืืจ ืืขืจื int[] ืืจืฉืืื? ืืืจื ืืงืื ืืืืชืจ ืืื ืื ืืืฉืชืืฉ
ื-ArrayUtils ืืกืคืจืืืช
Apache Commons Lang , ืืื ืืขืื.
List list = Arrays.asList(ArrayUtils.toObject(array));
ืืื ืื, ืืื ืงืืฆืืจ ืืจื ืืืืืื ืื ื-JDK.
5. ืืื ืืืจื ืืืืื ืืืืชืจ ืืกื ื ืืช ืืืืกืฃ? ืืชื ืืืื ืืืฉืชืืฉ ืืืืืืืช ืฉื ืฆื ืฉืืืฉื ืืืื
Guava ืื
Apache Commons Lang ืืื ืืืืืืจ ืืช ืืคืื ืงืฆืืื ืืืืช. ืืฉืชื ืืืืืืืช ืืืื ืืฉ ืฉืืืช filter() (ืืืืืงื
Collections2 ื-Guava ื-
CollectionUtils ื-Apache). ืฉืืืช filter() ืชืืืืจ ืืืื ืืื ืืชืืืืื ืืคืจืืืงื ืื ืชืื. ื-JDK ืืื ืืืชืจ ืืกืืื. ืืืืฉืืช ืืืืืืช ืื ืฉืืคืจืืืงืืื ืืชืืืกืคื ื-Java 8
, ืื ืืขืช ืขืชื ืขืืืื ืืืฉืชืืฉ ื-Iterator ืืื ืืืืืจ ืขื ืื ืืืืกืฃ. ืืืืื, ืืชื ืืืื ืืืงืืช ืืช ืื ืชืื ืฉืืืจืื ืขืืงืืื Guava ื- Apache ืขื ืืื ืืืืจืืช ืขื ืืืฉืง Predicate ืืืืฉ. ืืขืช ื ืืื ืืืฉืชืืฉ ืืงืื ืืื ืืื ืืกื ื ืืช ืืืืกืฃ:
6. ืืืฆื ืืืืืจ ืืงืืืช ืจืฉืืื ืืกื? ืืฉื ื ืฉืชื ืืจืืื ืืขืฉืืช ืืืช, ืชืืื ืืื ืืชื ืจืืฆื ืืืืืืจ ืฉืืืืื. ืงืืข ืืงืื ืืจืืฉืื ืืื ืืก ืืช ืืจืฉืืื ื-HashSet. ืืืคืืืืช ืืืงืจื ืื ื ืงืืขืช ืืขืืงืจ ืขื ืืื hashCode(). ืืืจื ืืื ืื ืืขืืื. ืืื ืื ืืชื ืฆืจืื ืืงืืช ืืืฉืืื ืืช ื ืชืื ืืืฉืืืื, ืื ืขืืืฃ ืืืฉืชืืฉ ืืืืง ืืฉื ื ืฉื ืืงืื, ืฉืื ืืชื ืืืื ืืืืืืจ ืืช ืืืฉืืื ืฉืื.
7. ืืืฆื ืืืื ืืืกืืจ ืจืืืืื ืืคืืืื ื-ArrayList? ืฉืืื ืื ืงืฉืืจื ืืืืื ืืกืืืืช ืืฉืืื ืฉืืืขืื. ืื ืกืืจ ืืืืื ืืื ื-ArrayList ืื ืืฉื ื ืื, ืฆืขื ืืื ืืืื ืืืงื ืืช ืืืืืืื ื-Set ืืื ืืืกืืจ ืืคืืืืืืช, ืืืืืจ ืืื ืืืืืืจ ืืืชื ื-List. ืืืื ืืืืื. ืื ืกืืจ ืืืืื ืืื ืืฉืื ืื, ืื ื ืืชื ืืืืืื ืืช ืืกืืจ ืขื ืืื ืืฆืืช ืืจืฉืืื ื-
LinkedHashSet , ืฉื ืืฆื ื-JDK ืืกืื ืืจืื.
8. ืืืกืฃ ืืืืื
int[] array = {1,2,3,4,5}; List
list = new ArrayList
(); for(int i: array) { list.add(i); }
Iterator
itr = list.iterator(); while(itr.hasNext()) { int i = itr.next(); if (i > 5) { // filter all ints bigger than 5 itr.remove(); } }
public interface Predicate
{ boolean test(T o); } public static
void filter(Collection
collection, Predicate
predicate) { if ((collection != null) && (predicate != null)) { Iterator
itr = collection.iterator(); while(itr.hasNext()) { T obj = itr.next(); if (!predicate.test(obj)) { itr.remove(); } } } }
filter(list, new Predicate
() { public boolean test(Integer i) { return i <= 5; } });
Set
set = new HashSet
(list);
Set
set = new TreeSet
(aComparator); set.addAll(list);
ArrayList** list = ... // initial a list with duplicate elements Set
set = new HashSet
(list); list.clear(); list.addAll(set);
ืืฉื ื ืืกืคืจ ืืจืืื ืืชืืื ืืืืกืฃ ืืืืื ื-Java. ืืืื ืืกืคืงืื ืืืกืฃ ืืกืืจ ืืืขื ืื ืืคื ืืฉืืื ืืืืืจ. ืืืงืจื ืฉื ืกืืจ ืืืขื, ืืชื ืื ืฆืจืื ืืืืฉื ืืช ืืืฉืง
Comparable ืขื ืืืืื ื.
- Collections.sort() ืืืื ืืืืื ืจืฉืืื. ืืคื ืฉืฆืืื ืืชืืขืื Java, ืืืื ืื ืืฆืื ืืืืืื ืืืฆืืขืื ืฉื n log(n).
- PriorityQueue ืืกืคืง ืชืืจ ืืกืืืจ. ืืืืื ืืื PriorityQueue ืืืื Collections.sort() ืืื ืฉ-PriorityQueue ืฉืืืจ ืขื ืกืืจ ืืชืืจ ืื ืืืื, ืืื ืืชื ืืืื ืืงืื ืจืง ืืช ืืืืื ื ืืจืืฉืื ืฉื ืืชืืจ. ืืชื ืื ืืืื ืืืฉืช ืืืืคื ืืงืจืื ืืจืืื ืืื PriorityQueue.get(4).
- ืื ืืื ืืคืืืืืืช ืืืืกืฃ, ืืชื ืืืื ืืืืืจ TreeSet . ืืื ืื, ืืื PriorityQueue, TreeSet ืฉืืืจ ืขื ืกื ืืกืืืจ ืืื ืขืช. ืืชื ืืืื ืืงืื ืืช ืืืืื ื ืืงืื ืื ืืืืื ืืืืชืจ ื-TreeSet, ืืื ืขืืืื ืื ืชืืื ืื ืืืฉื ืืงืจืืืช ืืืืื ืืื.
ืืืืืื ืคืฉืืืืช, Collections.sort() ืืกืคืง ืจืฉืืื ืืกืืืจืช ืื ืคืขืืืช. PriorityQueue ื-TreeSet ืฉืืืจืื ืขื ืืืกืฃ ืืกืืืจ ืืื ืขืช, ืืืืืจ ืฉื ืืืกืจ ืืืฉื ืืืื ืืงืก ืืืืื ืืื.
9. Collections.emptyList() ืื ืืืคืข ืืืฉ. ืืืชื ืฉืืื ืืื ืขื emptyMap() ื-emptySet(). ืฉืชื ืืฉืืืืช ืืืืืจืืช ืจืฉืืื ืจืืงื, ืืื Collections.emptyList() ืืื ืจืฉืืื ืืืชื ื ืืชื ืช ืืฉืื ืื. ืืฉืืขืืช ืืืืจ ืืื ืฉืืื ื
ืืืื ืืืืกืืฃ ืืืื ืืื ืืืฉืื ืืจืฉืืื "ืจืืงื". ืืจืงืข, ืื ืงืจืืื ืืืชืืื Collections.emptyList() ืื ืืืฆืจืช ืืืขืฉื ืืืคืข ืืืฉ ืฉื ืืจืฉืืื ืืจืืงื. ืืืงืื ืืืช, ืืื ืืขืฉื ืฉืืืืฉ ืืืืจ ืืืืคืข ืืจืืง ืฉืืืจ ืงืืื. ืื ืืชื ืืืืจืื ืืช Singleton ืืชืื ืืช
ืขืืฆืืืืช , ืืืื ืฉืชืืื ื ืืื ืืืืื ื. ืื ืืืืจ ืืชืช ืื ืืืฆืืขืื
ืืืืื ืืืชืจ ืื ืงืืจืืื ืื ืืขืชืื ืงืจืืืืช.
10 ืืขืชืงืช ืืืกืฃ, Collections.copy() ืงืืืืืช ืฉืชื ืืจืืื ืืืขืชืืง ืจืฉืืืช ืืงืืจืืช ืืจืฉืืืช ืืขืืื. ืืจื ืืืช ืืื ืืืฉืชืืฉ ืืื ืื ArrayList. ืืจื ื ืืกืคืช ืืื ืืืฉืชืืฉ ืืฉืืืช
Collections.copy() . ืฉืื ืื ืืฉืืจื ืืจืืฉืื ื: ืื ื ืืงืฆืื ืจืฉืืื ืฉืืืจืื ืืคืืืช ืืื ืืืืจืื ืฉื ืืจืฉืืื ืืืงืืจืืช, ืืืืืื ืฉืชืืขืื Java ืขื ืืืกืคืื ืืืืจ:
ArrayList
dstList = new ArrayList
(srcList);
ืจืฉืืืช ืืืขื ืืืืืช ืืืืืช ืืจืืื ืืคืืืช ืืื ืจืฉืืืช ืืืงืืจืืช.
ืื ืฉืืืืจ ืฉืืจืฉืืื ืืกืืคืืช ืืืืืช ืืืืืช ืื ืงืฆืจื ืืืจืฉืืื ืืืงืืจืืช. ืฉืชื ืืฉืืืืช ืื ืืขืชืงื ืจืืืื. ืื ืื ืืืืื ืืื ืฉืชื ืืฉืืืืช ืืืื? ืจืืฉืืช, Collections.copy() ืื ืืงืฆื ืืืืฉ ืืช ืงืืืืืช ืืืืกืืฃ ืฉื dstList, ืื ืื ื-dstList ืืื ืืกืคืืง ืืงืื ืืืืื ืืช ืื ืืืืื ืืื ืื-srcList. ืืืงืื ืืืช, ืืื ืืืจืืง
IndexOutOfBoundsException . ืืคืฉืจ ืืฉืืื ืื ืืฉ ืืื ืชืืขืืช. ืืกืืื ืืื ืฉืื ืืืืื ืฉืืฉืืื ืคืืขืืช ืืืืคื ืืื ืืืจื ืืืื. ืื ืืชืืื ืื ืืืฉืจ ืืชื ืจืืฆื ืืขืฉืืช ืฉืืืืฉ ืืืืจ ืืืขืจืืื ืืืงืื ืืืงืฆืืช ืืืืฉ ืืืืจืื ืืื ืื ArrayList.
ืืืงืื ืืกืงื ื ืื ืืืืจ ืงืจืืืช ืืืืืจ ืขืืืื ืืฉ ืื ืฉืืืืช, ืืชื ืืืืื ืืฉืืื ืืืชื ืืชืืืืืช. ืืื ืื, ืื ืชืืฆื ืื ืืืืง ืืชืจืืื ืื ืื ืืขืืช ืืืจืช, ืืชืื ืืจืืฉ ืืืืฉืื, ืื ืืชืืงื, ืืชืืื ืื.
ืึฐืงืึนืจึดื.
ArrayList
dstList = new ArrayList
(srcList.size()); Collections.copy(dstList, srcList);
GO TO FULL VERSION