는 방법 자바의 QuickTools목록을 반복할.

는 방법 자바의 QuickTools목록을 반복할.

좀 모든 사람 목록(혹은 아마도 다른 모음)고, 각각의 장점 또는 단점을 통해 반복 처리할 수 있(혹은 최소한non-pathological 것)들에 익숙해지려고 노력하고 있어요는 자바 언어에 새로운.

를 감안할 때List<E> listObject, 나는 다음과 같은 방법 모든 요소들을 통해서 음악에 다의: 알고 있다.

기본 forloop(물론 동등합니다.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 지적했다, 이 형태는 가난한 선택이다.ListS, 실제 구현.get법 때처럼을 사용하여 효율적이 아닐 수 있다.Iterator.예를들면,LinkedList이 메서드를 구현하면 모든 요소를 나는i-th 요소를 얻기 위해 앞 횡단해야 한다.

위의 예에 있는을 위한 방법도 없습니다.List향후의 반복을 보다 효율적으로 실시할 수 있도록, 「제자리 보존」을 실시합니다.한 동안ArrayList그 반대의 complexity/cost 정말은 문제 되지 않는다.get있나 일정 시간(O(1))반면 의 aLinkedList리스트(O(n)의 크기에 비례합니다.

빌트인의 계산 복잡성에 대한 자세한 내용은Collections이 질문을 확인해 주십시오.

루프에 대한 확장(이 질문에서 자세히 설명)

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에서 맵 메서드(@i_am_zero의 답변 참조)

를 구현하는 Java 8 컬렉션 클래스Iterable(예를 들어 모두Lists) 현재,forEach위에서 설명한 for loop 스테이트먼트 대신 사용할 수 있는 메서드입니다(다음은 적절한 비교를 제공하는 다른 질문입니다).

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).

다른 방법이 있다면 어떤 방법이 있을까요?

(그런데 제 관심은 퍼포먼스를 최적화하려는 욕구 때문이 아닙니다.개발자로서 어떤 폼을 사용할 수 있는지 알고 싶을 뿐입니다.)

루프의 3가지 형태는 거의 동일합니다.강화된for루프:

for (E element : list) {
    . . .
}

Java Language Specification(Java Language Specification)에 따르면 기존의 반복자를 명시적으로 사용하는 것과 사실상 동일합니다.for세 번째 경우, 목록 내용을 수정할 수 있는 것은 현재 요소를 삭제한 다음, 그 다음, 를 통해 이 작업을 수행하는 경우뿐입니다.remove반복기 자체의 메서드.인덱스 기반 반복을 사용하면 목록을 자유롭게 수정할 수 있습니다.단, 현재 인덱스보다 앞에 있는 요소를 추가하거나 삭제하면 루프를 건너뛰거나 동일한 요소를 여러 번 처리할 위험이 있습니다.이러한 변경을 할 때는 루프 인덱스를 적절히 조정해야 합니다.

「」는,element는 실제 목록 요소에 대한 참조입니다.어떤 반복 방식도 목록에 있는 어떤 것도 복사하지 않습니다. ( 「 」 )element 표시됩니다.

기본적으로 목록에 대해 반복하는 방법은 인덱스를 사용하는 방법과 반복기를 사용하는 방법 두 가지뿐입니다.확장 for 루프는 반복자를 명시적으로 정의하는 번거로움을 피하기 위해 Java 5에서 도입된 구문 단축키일 뿐입니다. 모두 기본적으로 낼수.for,while ★★★★★★★★★★★★★★★★★」do while블록은 모두 같은 것(혹은 두 가지)으로 귀결됩니다.

에서 @와 같이 @iX3를 할 수 .ListIterator반복할 때 목록의 현재 요소를 설정합니다.루프 변수를 초기화하는 대신 를 사용해야 합니다(분명히 이 변수는 new-loop variable로 선언되어야 함).ListIterator가 an an Iterator를 참조해 주세요.

질문에 기재되어 있는 각 종류의 예:

ListIterationExample.java

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());
     }
}

리스트의 실장을 모르기 때문에 기본 루프는 권장하지 않습니다.

그것이 LinkedList일 경우 각 콜은

list.get(i)

N^2 시간 복잡도를 초래하는 반복적인 반복이다.

JDK8 스타일의 반복:

public class IterationDemo {

    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3);
        list.stream().forEach(elem -> System.out.println("element " + elem));
    }
}

Java 8에서는 컬렉션 클래스에 대해 여러 가지 방법을 반복할 수 있습니다.

각각에 대해 Itable 사용

「」를 실장하는 .Iterable를 들어 목록에는 ('모든 목록')이 있습니다.forEach방법.Java 8에서 도입된 메서드 레퍼런스를 사용할 수 있습니다.

Arrays.asList(1,2,3,4).forEach(System.out::println);

각 및 각 주문에 대한 스트림 사용

Stream을 사용하여 목록에 대해 다음과 같이 반복할 수도 있습니다.

Arrays.asList(1,2,3,4).stream().forEach(System.out::println);
Arrays.asList(1,2,3,4).stream().forEachOrdered(System.out::println);

우리는 더 좋아해야 한다.forEachOrdered에 걸쳐서forEach 동 because의 forEach명백하게 확정적이지 않다.forEachOrdered는 스트림에 만남 순서가 정의된 경우 스트림의 만남 순서로 이 스트림의 각 요소에 대해 액션을 수행합니다.따라서 각각에 대해 주문이 유지된다는 보장은 없습니다.

스트림의 장점은 필요에 따라 병렬 스트림을 사용할 수도 있다는 것입니다.주문에 관계없이 아이템을 인쇄하는 것이 목적이라면 다음과 같이 병행 스트림을 사용할 수 있습니다.

Arrays.asList(1,2,3,4).parallelStream().forEach(System.out::println);

당신이 병적으로 생각하는 것이 무엇인지는 모르겠지만, 당신이 이전에 보지 못했던 몇 가지 대안을 제시하겠습니다.

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를 처음 접하는 사람"이기 때문에 제가 그것들을 언급하는 것은 흥미로울 수도 있습니다.

Java 8부터 각 for Each를 사용할 수 있습니다.

 List<String> nameList   = new ArrayList<>(
            Arrays.asList("USA", "USSR", "UK"));

 nameList.forEach((v) -> System.out.println(v));

»java 8 하면 .List.forEach() 사용한 방법lambda expression목록을 반복해서 읽다.

import java.util.ArrayList;
import java.util.List;

public class TestA {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("Apple");
        list.add("Orange");
        list.add("Banana");
        list.forEach(
                (name) -> {
                    System.out.println(name);
                }
        );
    }
}

역방향 검색의 경우 다음을 사용해야 합니다.

for (ListIterator<SomeClass> iterator = list.listIterator(list.size()); iterator.hasPrevious();) {
    SomeClass item = iterator.previous();
    ...
    item.remove(); // For instance.
}

위치를 알고 싶다면 반복기를 사용하십시오.이전인덱스().또, 리스트내의 2개의 위치를 비교하는 내부 루프를 기술하는 데도 도움이 됩니다(반복자는 동일하지 않습니다).

아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 맞다.가장 쉽고 깔끔한 방법은 확장 기능을 사용하는 것입니다.for아래와 같이 기재합니다.Expression이치노

for ( FormalParameter : Expression ) Statement

예를 들어, List <String> ID 를 반복하는 경우는, 간단하게 다음과 같이 할 수 있습니다.

for (String str : ids) {
    // Do something
}

Java 8 이상에서는 Each() 메서드를 사용하여 해시 세트를 반복할 수 있습니다.

import java.util.HashSet;

public class HashSetTest {
    public static void main(String[] args) {
        
         HashSet<String> hSet = new HashSet<String>();
          
         // Adding elements into your HashSet usind add()
         hSet.add("test1");
         hSet.add("test2");
         hSet.add("test3");
      
         // Iterating over hash set items
         hSet.forEach(x -> System.out.println(x));
         // Or you can write shorter:
         hSet.forEach(System.out::println);
    }
}

위에는 목록에 대해 반복하는 모든 다양한 방법이 있습니다.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class test1 {

public static void main(String[] args) {
    //******* Exercise 1 : Write a Java program to create a new array list, add some colors (string) and print out the collection.
    List<String> colors = new ArrayList<String>();
    colors.add("Black");
    colors.add("Red");
    colors.add("Green");
    colors.add("Blue");
    System.out.println(colors);
    
    
    //******* Exercise 2 : Write a Java program to iterate through all elements in a array list. 
    System.out.println("//******* Exercise 2");
    List<Integer> list2 = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
    
    // iteration type 1 : using FOR loop
    System.out.println("// iteration type 1");
    for(Integer nb : list2) {
        System.out.print(nb + ", ");
    }
    System.out.println("\n");
    
    // iteration type 2 : using FOR loop
    System.out.println("// iteration type 2");
    for(int i=0; i < list2.size(); i++) {
        System.out.print(list2.get(i) + ", ");
    }System.out.println("\n");
    
    // iteration type 3  : using Do-While loop
    System.out.println("// iteration type 3");
    int index21 = 0;
    
    do {
        System.out.print(list2.get(index21) + ", ");
        index21++;
    }while(index21<list2.size());
    System.out.println("\n");
    
    
    // iteration type 4  : using While loop
    System.out.println("// iteration type 4");
    int index22 = 0;
    while(index22<list2.size()) {
        System.out.print(list2.get(index22) + ", ");
        index22++;
    }

    System.out.println("\n");
    
    
    // iteration type 5  : using  Iterable forEach loop 
    System.out.println("// iteration type 5");
     list2.forEach(elt -> {
         System.out.print(elt + ", ");
     });

    System.out.println("\n");
    
    
    // iteration type 6  : using  Iterator
    System.out.println("// iteration type 6");
    Iterator<Integer> listIterator = list2.iterator();
    while(listIterator.hasNext()) {
        System.out.print( listIterator.next() + ", ");
    }
    
    System.out.println("\n");
    
    // iteration type 7  : using  Iterator (From the beginning)
    System.out.println("// iteration type 7");
    ListIterator<Integer> listIterator21 = list2.listIterator(list2.size());
    while(listIterator21.hasPrevious()) {
        System.out.print( listIterator21.previous() + ", ");
    }

    System.out.println("\n");   
    
    // iteration type 8  : using  Iterator (From the End)
    System.out.println("// iteration type 8");
    ListIterator<Integer> listIterator22 = list2.listIterator();
    while(listIterator22.hasNext()) {
        System.out.print( listIterator22.next() + ", ");
    }

    System.out.println("\n");   
}

}

첫 번째와 세 번째 예는 약간의 루프와 조금 더 많은 코드를 사용하여 언제든지 전환할 수 있습니다.이를 통해 실행 시간을 사용할 수 있는 이점이 있습니다.

int i = 0;
do{
 E element = list.get(i);
 i++;
}
while (i < list.size());

물론 이런 종류의 문제로 인해 Null Pointer가 발생할 수 있습니다.list.size()가 0을 반환하는 경우는 예외입니다.이는 항상 1회 이상 실행되기 때문입니다.이 문제는 해당 속성/메서드를 사용하기 전에 요소가 늘인지 테스트하여 해결할 수 있습니다.그래도 for loop을 사용하는 것이 훨씬 간단하고 쉽습니다.

언급URL : https://stackoverflow.com/questions/18410035/ways-to-iterate-over-a-list-in-java