이 질문을 읽을 때 Iterable#forEach람다 식과 함께 전통적인 for-each 루프를 작성하는 지름길 / 대체 라는 인상을 얻을 수 있습니다 . 이것은 단순히 사실이 아닙니다. OP 의이 코드 :

joins.forEach(join -> mIrc.join(mSession, join));

작문의 지름길 이 아닙니다

for (String join : joins) {
    mIrc.join(mSession, join);
}

확실히 이런 식으로 사용해서는 안됩니다. 대신 쓰기를위한 지름길 ( 정확히 같지는 않지만 )

joins.forEach(new Consumer<T>() {
    @Override
    public void accept(T join) {
        mIrc.join(mSession, join);
    }
});

그리고 다음 Java 7 코드를 대체합니다.

final Consumer<T> c = new Consumer<T>() {
    @Override
    public void accept(T join) {
        mIrc.join(mSession, join);
    }
};
for (T t : joins) {
    c.accept(t);
}

위의 예와 같이 루프 본문을 기능적 인터페이스로 바꾸면 코드가보다 명확 해집니다. (1) 루프 본문은 주변 코드 및 제어 흐름에 영향을 미치지 않으며 (2) 루프의 본문은 주변 코드에 영향을주지 않으면 서 다른 기능 구현으로 대체 될 수 있습니다. 외부 스코프의 비 최종 변수에 액세스 할 수없는 것은 함수 / 람다의 결함이 아니며 , 전통적인 for-each 루프의 의미와 의미를 구별 하는 기능 입니다 Iterable#forEach. 의 구문에 Iterable#forEach익숙해지면 코드에 대한 추가 정보를 즉시 얻으므로 코드를 더 읽기 쉽게 만듭니다.

전통적인 for-each 루프는 자바에서 좋은 습관을 유지할 것입니다 (과도한 용어 ” 모범 사례 ” 를 피하기 위해 ). 그러나 이것이 Iterable#forEach나쁜 습관이나 나쁜 스타일로 간주되어야 한다는 것을 의미하지는 않습니다 . 작업을 수행하기 위해 올바른 도구를 사용하는 것은 항상 모범 사례이며, 여기에는 전통적인 for-each 루프와을 혼합하는 것이 포함됩니다 Iterable#forEach.

Iterable#forEach이 스레드에서 이미 단점을 논의 했으므로 다음과 같은 이유가 있습니다 Iterable#forEach.

• 코드가 더 명확하게하려면 다음과 같이, 위에서 설명한 Iterable#forEach 수 있습니다 어떤 상황에서 당신의 코드가 더 명확하고 쉽게 읽을 수 있도록.

• 코드를보다 확장 가능하고 유지 보수 가능하게하려면 : 함수를 루프 본문으로 사용하면이 기능을 다른 구현으로 대체 할 수 있습니다 ( 전략 패턴 참조 ). 예를 들어 람다 식을 메서드 호출로 쉽게 대체 할 수 있습니다.이 메서드는 하위 클래스로 덮어 쓸 수 있습니다.

  joins.forEach(getJoinStrategy());

  그런 다음 기능 인터페이스를 구현하는 열거 형을 사용하여 기본 전략을 제공 할 수 있습니다. 이를 통해 코드를 확장 할 수있을뿐만 아니라 루프 구현에서 루프 구현을 분리하므로 유지 관리 성이 향상됩니다.

• 코드를 더 디버깅 가능하게 만들려면 : 선언에서 루프 구현을 분리하면 디버깅이 더 쉬워 질 수 있습니다. 특수 디버그 구현을 통해 메인 코드를 복잡하게 만들 필요없이 디버그 메시지를 인쇄 할 수 있기 때문입니다 if(DEBUG)System.out.println(). 디버그 구현은 실제 함수 구현 을 장식 하는 delegate 일 수 있습니다 .

• 최적화 성능이 중요한 코드 : 어설의 일부는 반대로이 스레드, Iterable#forEach 않습니다 이미보다 더 나은 성능을 제공하는 전통에 대한-각 루프, 최소한의 ArrayList를 사용하여 “-client”모드에서 핫스팟을 실행할 때. 이 성능 향상은 작고 대부분의 사용 사례에서 무시할 만하지 만이 추가 성능으로 인해 차이가 발생할 수 있습니다. 예를 들어 라이브러리 유지 관리자는 기존 루프 구현 중 일부를로 대체해야하는 경우 확실히 평가하려고합니다 Iterable#forEach.

  이 진술을 사실로 뒷받침하기 위해 Caliper를 사용 하여 마이크로 벤치 마크를 수행했습니다 . 테스트 코드는 다음과 같습니다 (git의 최신 Caliper가 필요합니다).

  @VmOptions("-server")
  public class Java8IterationBenchmarks {
  
      public static class TestObject {
          public int result;
      }
  
      public @Param({"100", "10000"}) int elementCount;
  
      ArrayList<TestObject> list;
      TestObject[] array;
  
      @BeforeExperiment
      public void setup(){
          list = new ArrayList<>(elementCount);
          for (int i = 0; i < elementCount; i++) {
              list.add(new TestObject());
          }
          array = list.toArray(new TestObject[list.size()]);
      }
  
      @Benchmark
      public void timeTraditionalForEach(int reps){
          for (int i = 0; i < reps; i++) {
              for (TestObject t : list) {
                  t.result++;
              }
          }
          return;
      }
  
      @Benchmark
      public void timeForEachAnonymousClass(int reps){
          for (int i = 0; i < reps; i++) {
              list.forEach(new Consumer<TestObject>() {
                  @Override
                  public void accept(TestObject t) {
                      t.result++;
                  }
              });
          }
          return;
      }
  
      @Benchmark
      public void timeForEachLambda(int reps){
          for (int i = 0; i < reps; i++) {
              list.forEach(t -> t.result++);
          }
          return;
      }
  
      @Benchmark
      public void timeForEachOverArray(int reps){
          for (int i = 0; i < reps; i++) {
              for (TestObject t : array) {
                  t.result++;
              }
          }
      }
  }

  결과는 다음과 같습니다.

  • -client에 대한 결과
  • -server에 대한 결과

  “-client”로 실행 Iterable#forEach하면 ArrayList보다 전통적인 for 루프보다 성능이 뛰어나지 만 어레이를 직접 반복하는 것보다 여전히 느립니다. “-server”로 실행할 때 모든 접근 방식의 성능은 거의 같습니다.

• 병렬 실행에 대한 선택적 지원을 제공하려면 다음과 같이 이미 스트림을Iterable#forEach 사용하여 기능 인터페이스를 병렬 로 실행할 수있는 가능성이 중요한 측면이라고합니다. 루프가 실제로 병렬로 실행되는 것을 보장하지는 않기 때문에 이를 선택적 기능으로 고려해야 합니다. 를 사용하여 목록을 반복하면 다음과 같이 명시 적으로 말할 수 있습니다.이 루프 는 병렬 실행을 지원 하지만 그에 의존하지는 않습니다. 다시 말하지만 이것은 기능이며 결함이 아닙니다!Collection#parallelStream()list.parallelStream().forEach(...);

  병렬 실행에 대한 의사 결정을 실제 루프 구현에서 멀어지게하면 코드 자체에 영향을주지 않고 코드를 선택적으로 최적화 할 수 있습니다. 또한 기본 병렬 스트림 구현이 요구 사항에 맞지 않으면 아무도 자신의 구현을 제공하지 못합니다. 예를 들어 기본 운영 체제, 컬렉션 크기, 코어 수 및 일부 기본 설정에 따라 최적화 된 컬렉션을 제공 할 수 있습니다.

  public abstract class MyOptimizedCollection<E> implements Collection<E>{
      private enum OperatingSystem{
          LINUX, WINDOWS, ANDROID
      }
      private OperatingSystem operatingSystem = OperatingSystem.WINDOWS;
      private int numberOfCores = Runtime.getRuntime().availableProcessors();
      private Collection<E> delegate;
  
      @Override
      public Stream<E> parallelStream() {
          if (!System.getProperty("parallelSupport").equals("true")) {
              return this.delegate.stream();
          }
          switch (operatingSystem) {
              case WINDOWS:
                  if (numberOfCores > 3 && delegate.size() > 10000) {
                      return this.delegate.parallelStream();
                  }else{
                      return this.delegate.stream();
                  }
              case LINUX:
                  return SomeVerySpecialStreamImplementation.stream(this.delegate.spliterator());
              case ANDROID:
              default:
                  return this.delegate.stream();
          }
      }
  }

  여기서 좋은 점은 루프 구현이 이러한 세부 사항을 알거나 신경 쓸 필요가 없다는 것입니다.

답변

for(int i=0; i<size; i++)
    action.accept(elements[i])

Iterator iter = list.iterator();
while(iter.hasNext())
    Object next = iter.next();
    do something with `next`

private List<Integer> list;
private final int size = 1_000_000;

public MyClass(){
    list = new ArrayList<>();
    Random rand = new Random();
    for (int i = 0; i < size; ++i) {
        list.add(rand.nextInt(size * 50));
    }
}
private void doIt(Integer i) {
    i *= 2; //so it won't get JITed out
}

myClass.fored();
myClass.fored();
myClass.fored();
for (int i = 0; i < reps; ++i) {
    begin = System.nanoTime();
    myClass.fored();
    end = System.nanoTime();
    nanoSum += end - begin;
}
System.out.println(nanoSum / reps);

for(int i = 0, l = list.size(); i < l; ++i) {
    doIt(list.get(i));
}

for(Integer i : list) {
    doIt(i);
}

list.forEach((i) -> doIt(i));

list.stream().forEach((i) -> doIt(i));

list.parallelStream().forEach((i) -> doIt(i));

    Stream<String> stream = Stream.of("", "1", "2", "3").filter(s -> !s.isEmpty());
    Iterable<String> iterable = stream::iterator;
    for (String s : iterable) {
        fileWriter.append(s);
    }