Java言語に慣れていないので、リスト(または他のコレクション)を反復処理する方法(少なくとも病的でないもの)と、それぞれの利点や欠点をよく理解しようとしています。
コード>List
while
/ do while
ループもあります)// Not recommended (see below)!
for (int i = 0; i < list.size(); i++) {
E element = list.get(i);
// 1 - can call methods of element
// 2 - can use 'i' to make index-based calls to methods of list
// ...
}
注: @amarseillan さんが指摘したように、この形式は List
を反復するには適していません。
なぜなら、get
メソッドの実際の実装は、List
のイテレートには適していないからです。
これは、get
メソッドの実際の実装が、Iterator
を使った場合ほど効率的ではないからです。
例えば、LinkedList
の実装では、iを得るためにiより前のすべての要素をトラバースする必要がある。
i番目の要素を得るためには,iより前のすべての要素を走査しなければならない。
上の例では、List
の実装では、次のような方法はありません。
上記の例では、List
の実装が、将来の反復処理をより効率的にするために、その場所を保存する方法がありません。
ArrayListでは、
getの複雑さやコストは一定時間(O(1))なので、実際には問題になりませんが、
LinkedList`では、リストのサイズに比例します(O(n))。
ビルトインのCollections
実装の計算の複雑さについては、this questionをご覧ください。
for (E element : list) {
// 1 - can call methods of element
// ...
}
for (Iterator<E> iter = list.iterator(); iter.hasNext(); ) {
E element = iter.next();
// 1 - can call methods of element
// 2 - can use iter.remove() to remove the current element from the list
// ...
}
for (ListIterator<E> iter = list.listIterator(); iter.hasNext(); ) {
E element = iter.next();
// 1 - can call methods of element
// 2 - can use iter.remove() to remove the current element from the list
// 3 - can use iter.add(...) to insert a new element into the list
// between element and iter->next()
// 4 - can use iter.set(...) to replace the current element
// ...
}
list.stream().map(e -> e + 1); // Can apply a transformation function for e
(Java 8'のStream APIのMapメソッドです(@i_am_zero'さんの回答参照)。
Java 8では、Iterable
を実装したコレクションクラス(たとえば、すべてのList
s)は、forEach
メソッドを持つようになり、上記で示したforループ文の代わりに使用することができます。(ここに別の質問があり、良い比較をしています)。
Arrays.asList(1,2,3,4).forEach(System.out::println);
// 1 - can call methods of an element
// 2 - would need reference to containing object to remove an item
// (TODO: someone please confirm / deny this)
// 3 - functionally separates iteration from the action
// being performed with each item.
Arrays.asList(1,2,3,4).stream().forEach(System.out::println);
// Same capabilities as above plus potentially greater
// utilization of parallelism
// (caution: consequently, order of execution is not guaranteed,
// see [Stream.forEachOrdered][stream-foreach-ordered] for more
// information about this).
他に方法があれば教えてください。
(ちなみに、私の興味は、[パフォーマンスの最適化][イテレータのパフォーマンスに関する質問]をしたいということでは全くなく、ただ、開発者としてどのような形があるのかを知りたいだけです)
質問に記載されている各種類の例
import java.util.*;
public class ListIterationExample {
public static void main(String []args){
List<Integer> numbers = new ArrayList<Integer>();
// populates list with initial values
for (Integer i : Arrays.asList(0,1,2,3,4,5,6,7))
numbers.add(i);
printList(numbers); // 0,1,2,3,4,5,6,7
// replaces each element with twice its value
for (int index=0; index < numbers.size(); index++) {
numbers.set(index, numbers.get(index)*2);
}
printList(numbers); // 0,2,4,6,8,10,12,14
// does nothing because list is not being changed
for (Integer number : numbers) {
number++; // number = new Integer(number+1);
}
printList(numbers); // 0,2,4,6,8,10,12,14
// same as above -- just different syntax
for (Iterator<Integer> iter = numbers.iterator(); iter.hasNext(); ) {
Integer number = iter.next();
number++;
}
printList(numbers); // 0,2,4,6,8,10,12,14
// ListIterator<?> provides an "add" method to insert elements
// between the current element and the cursor
for (ListIterator<Integer> iter = numbers.listIterator(); iter.hasNext(); ) {
Integer number = iter.next();
iter.add(number+1); // insert a number right before this
}
printList(numbers); // 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
// Iterator<?> provides a "remove" method to delete elements
// between the current element and the cursor
for (Iterator<Integer> iter = numbers.iterator(); iter.hasNext(); ) {
Integer number = iter.next();
if (number % 2 == 0) // if number is even
iter.remove(); // remove it from the collection
}
printList(numbers); // 1,3,5,7,9,11,13,15
// ListIterator<?> provides a "set" method to replace elements
for (ListIterator<Integer> iter = numbers.listIterator(); iter.hasNext(); ) {
Integer number = iter.next();
iter.set(number/2); // divide each element by 2
}
printList(numbers); // 0,1,2,3,4,5,6,7
}
public static void printList(List<Integer> numbers) {
StringBuilder sb = new StringBuilder();
for (Integer number : numbers) {
sb.append(number);
sb.append(",");
}
sb.deleteCharAt(sb.length()-1); // remove trailing comma
System.out.println(sb.toString());
}
}
あなたが何を病的だと考えているのかはわかりませんが、これまでに見たことのないような選択肢を提供しましょう。
List<E> sl= list ;
while( ! sl.empty() ) {
E element= sl.get(0) ;
.....
sl= sl.subList(1,sl.size());
}
またはその再帰バージョン。
void visit(List<E> list) {
if( list.isEmpty() ) return;
E element= list.get(0) ;
....
visit(list.subList(1,list.size()));
}
また、古典的なfor(int i=0...
)の再帰的バージョン。
void visit(List<E> list,int pos) {
if( pos >= list.size() ) return;
E element= list.get(pos) ;
....
visit(list,pos+1);
}
これらを紹介したのは、あなたが Java"の初心者であり、これが面白いかもしれないからです。
最初の例と3番目の例は、常にwhileループと少しのコードで切り替えることができます。これにより、do-whileを使用できるという利点があります。
int i = 0;
do{
E element = list.get(i);
i++;
}
while (i < list.size());
もちろん、list.size()が0を返した場合、常に最低1回は実行されるので、この種のものはNullPointerExceptionを引き起こすかもしれません。これは、要素の属性やメソッドを使用する前に、要素がNULLであるかどうかをテストすることで修正できます。それでも、forループを使った方がずっとシンプルで簡単です。