JAVA
java
java
  • README
  • Java
    • Basic
      • 변수와 타입
      • 연산자
      • 조건문과 반복문
      • 참조 타입
      • 클래스
      • 상속(Inheritance)
      • 인터페이스(Interface)
      • 중첩 클래스와 중첩 인터페이스
      • 예외 처리
      • API - Object, System, Class, Math, Wrapper
      • API - String, StringBuffer, StringBuilder
      • Thread
      • Generic
      • Lambda
      • Collection - List, Set
      • Collection - Map
      • Collection - Tree
      • Collection - Stack, Queue
      • Stream
      • Reflection
      • 정규표현식
      • GUI
      • UML
      • Serializable
    • Advanced
      • OutOfMemoryError
      • AutoValue
      • meta-annotation
        • @Retention
        • @Target
        • @Repeatable
    • Effective Java 3/E
      • ITEM 1: Static Factory Method(정적 메소드)
      • ITEM 2: Builder Pattern
      • ITEM 3: Singleton
      • ITEM 4: Private Constructor
      • ITEM 5: Dependency Injection
      • ITEM 6: Avoid Unnecessary Object
      • ITEM 7: Eliminate Object Reference
      • ITEM 8: Avoid finalizer and cleaner
      • ITEM 9: try-with-resources
      • ITEM 10: The gerneral contract when overriding equlas
      • ITEM 11: Overriding hashCode
      • ITEM 12: overriding toString
      • ITEM 13: overriding clone judiciously
      • ITEM 14: Consider implementing comparable
      • ITEM 15: 클래스와 멤버의 접근을 최소화해라
      • ITEM 16: Use Accessor methods
      • ITEM 17: 변경 가능성을 최소화해라(불변 클래스)
      • ITEM 18: 상속보단 컴포지션을 사용해라
      • ITEM 19: 상속을 고려해 설계하고 문서화해라
      • ITEM 20: 추상 클래스보다 인터페이스를 우선하라
      • ITEM 21: 인터페이스는 구현하는 쪽을 생각해 설계해라.
      • ITEM 22: 인터페이스는 타입을 정의하는 용도로만 사용해라
      • ITEM 23: 태그 달린 클래스보다 클래스 계층구조를 활용해라
      • ITEM 24: 멤버 클래스는 되도록 static으로 구현해라
      • ITEM 25: 톱레벨 클래스는 한 파일에 하나만 생성해라.
      • ITEM 26: Raw type은 사용하지 마라
      • ITEM 27: 비검사 경고를 제거해라
      • ITEM 28: 배열보다는 리스트를 사용해라
      • ITEM 29: 이왕이면 제네릭 타입으로 만들어라
      • ITEM 30: 이왕이면 제네릭 메서드로 만들어라
      • ITEM 31 : 한정적 와일드카드를 사용해 API 유연성을 높여라
      • ITEM 32: 제네릭과 가변인수를 함께 쓸 때는 신중해라
      • ITEM 33: 타입 안전 이종 컨테이너를 고려해라
      • ITEM 34: int 상수 대신 열거 타입을 사용해라
      • ITEM 35: ordinal 메서드 대신 인스턴스 필드를 사용해라
      • ITEM 36: 비트 필드 대신 EnumSet을 사용해라
      • ITEM 37: ordinal 인덱싱 대신 EnumMap을 사용해라
      • TEM 38 : 확장할 수 있는 열거타입이 필요하면 인터페이스를 사용해라
      • ITEM 39: 명명 패턴보다 애너테이션을 사용해라
      • ITEM 40: @Override 어노테이션을 일관되게 사용해라
      • ITEM 41: 정의하려는 것이 타입이라면 마커 인터페이스를 사용해라
      • ITEM 42: 익명 클래스보다는 람다를 사용해라
      • ITEM 43: 람다보다는 메서드 참조를 사용해라
      • ITEM 44: 표준 함수형 인터페이스를 사용해라
      • ITEM 45: 스트림은 주의해서 사용해라
      • ITEM 46: 스트림에서 부작용 없는 함수를 사용해라
      • ITEM 47: 반환 타입으로는 스트림보다 컬렉션이 낫다.
      • ITEM 48: 스트림 병렬화는 주의해서 사용해라
      • ITEM 49: 매개변수가 유효한지 검사해라
      • ITEM 50: 적시에 방어적 복사본을 만들어라
      • ITEM 51: 메서드 시그니처를 신중히 설계해라
      • ITEM 52: 다중정의는 신중히 사용해라
      • ITEM 53: 가변인수는 신중히 사용해라
      • ITEM 54: null이 아닌, 빈 컬렉션이나 배열을 반환해라
      • ITEM 55: Optional 반환은 신중하게 해라
      • ITEM 56: 공개된 API 요소에는 항상 주석을 작성해라
      • ITEM 57: 지역변수의 범위를 최소화해라
      • ITEM 58: 전통적인 for 문보다는 for-each문을 사용해라
      • ITEM 59: 라이브러리를 익히고 사용해라
      • ITEM 60: 정확한 답이 필요하다면 float와 double은 피해라
      • ITEM 61: 박싱된 기본 타입보다는 기본 타입을 사용해라
      • ITEM 62: 다른 타입이 적절하다면 문자열 사용을 피해라
      • ITEM 63: 문자열 연결은 느리니 주의해라
      • ITEM 64: 객체는 인터페이스를 사용해 참조해라
      • ITEM 65: 리플렉션보다는 인터페이스를 사용해라
      • ITEM 66: 네이티브 메서드는 신중히 사용해라
      • ITEM 67: 최적화는 신중히 해라
      • ITEM 68: 일반적으로 통용되는 명명 규칙을 따라라
    • 객체지향 설계 원칙(SOLID)
    • 디자인패턴
      • Strategy Pattern
      • Template Method Pattern
      • Factory Method Pattern
      • Singleton
      • Delegation
      • Proxy
      • Adapter Pattern
    • 실습
      • 인터페이스 실습 - Vehicle
      • 인터페이스 실습 - Remote
      • GUI 실습 - Calculator
      • GUI 실습 - button
      • GUI 실습 - lotto
      • Thread 실습 - 좌석예약, 메세지보내기
    • Jar vs War
Powered by GitBook
On this page
  • 전통적인 for문
  • collection 순회
  • 배열 순회
  • for-each문
  • for-each를 사용할 수 없는 경우
  • Iterable

Was this helpful?

  1. Java
  2. Effective Java 3/E

ITEM 58: 전통적인 for 문보다는 for-each문을 사용해라

전통적인 for문과 비교시 for-each문 장점은 명료하고, 유연하고, 버그를 예방해준다. 그러면서 성능저하도 없다.

전통적인 for문

  • 반복자와 인덱스 변수는 코드를 지저분하게 할 뿐이며, 실제로 필요한 것은 원소이다.

  • 쓰이는 요소의 종류가 늘어나면 오류가 생길 가능성도 높아진다.

  • 잘못된 변수를 사용했을 때 컴파일러가 잡아준다는 보장이 없다.

  • 컬렉션, 배열 등 컨테이너 종류에 따라 코드 형태가 달라지므로 주의가 필요하다.

collection 순회

for (Iterator<Element> i = c.iterator(); i.hasNext();) {
  Element e = i.next();
}

배열 순회

for (int i = 0; i< a.length; i++) {
}

위 문제는 for-each 문을 사용하면 해결된다.

for-each문

  • for-each문은 반복자나 인덱스 변수를 사용하지 않아 코드가 깔끔해지고, 오류가 발생할 일도 없다.

      for (Element e : elements) {
    
      }
  • 하나의 관용구로 컬렉션과 배열 모두 처리할 수 있어, 어떤 컨테이너를 사용하는지 신경쓰지 않아도 된다.

  • for-each문을 사용하는 것은 for문을 사용하는 것과 속도가 같다.

  • 컬렉션을 중첩해 사용한다면, 실수를 예방할 수 있다.

    • 전통적 for문

        enum Face { ONE, TWO, THREE, FOUR, FIVE, SIX }
      
        Collection<Face> faces = EnumSet.allOf(Face.class);
      
        for (Iterator<Face> i = faces.iterator(); i.hasNext(); )
          for (Iterator<Face> j = faces.iterator(); j.hasNext(); )
            System.out.println(i.next() + " " + j.next());

      i.next() 가 안쪽 for문에서 호출되었기때문에 36개 조합이 아닌, 6개 조합이 나온다. j보다 i의 수가 적다면, 예외가 발생할 수도 있다.

        enum Suit { CLUB, DIAMOND, HEART, SPADE }
        enum Rank { ACE, DEUCE, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, TEN, JACK, QUEEN, KING }
      
        static Collection<Suit> suits = Arrays.asList(Suit.values());
        static Collection<Rank> ranks = Arrays.asList(Rank.values());
      
        List<Card> deck = new ArrayList<>();
        for (Iterator<Suit> i = suits.iterator(); i.hasNext(); )
          for (Iterator<Rank> j = ranks.iterator(); j.hasNext(); )
            deck.add(new Card(i.next(), j.next())); // NoSuchElementException
        for (Iterator<Suit> i = suits.iterator(); i.hasNext(); )
          Suit suit = i.next();
          for (Iterator<Rank> j = ranks.iterator(); j.hasNext(); )
            deck.add(new Card(suit, j.next()));

      다음과 같이 해결할 수 있지만, for-each문을 사용하면 더 간단하게 해결할 수 있다.

    • for-each문

        for (Suit suit : suits)
          for (Rank rank : ranks)
            deck.add(new Card(suit, rank));

for-each를 사용할 수 없는 경우

파괴적인 필터링(destructive filtering)

컬렉션을 순회하면서 선택된 원소를 제거해야 하는경우, 반복자의 remove 메서드를 호출해야한다.

java8부터는 Collection의 removeIf 메서드를 사용해 컬렉션을 명시적으로 순회하는 것을 피할 수 있다.

변형(transforming)

리스트나 배열을 순회하면서 그 원소의 값 일부 혹은 전체를 교체해야한다면 리스트의 반복자는 배열의 인덱스를 사용해야한다.

병렬 반복(parallel iteration)

여러 컬렉션을 병렬로 순회해야한다면 각각의 반복자와 인텍스 변수를 사용해 엄격하고 명시적으로 제어해야한다.

Iterable

for-each문은 Iterable을 구현한 객체라면 무엇이든지 순회할 수 있다.

public interface Iterable<T> {
    /**
     * Returns an iterator over elements of type {@code T}.
     *
     * @return an Iterator.
     */
    Iterator<T> iterator();
}

원소들의 묶음을 표현하는 타입을 작성해야한다면, Iterable을 구현하는 것이 좋다. Iterable을 구현해둔다면 그 타입의 for-each문을 사용할 수 있기 때문이다.

PreviousITEM 57: 지역변수의 범위를 최소화해라NextITEM 59: 라이브러리를 익히고 사용해라

Last updated 3 years ago

Was this helpful?