Java에서 자체 반복기를 작성할 수 있습니까?

Java에서 자체 반복기를 작성할 수 있습니까?

다음 항목을 포함하는 목록이 있는 경우[alice, bob, abigail, charlie]그리고 a로 시작하는 요소를 반복하도록 반복기를 쓰고 싶은데, 내 것을 써도 될까요?내가 어떻게 그럴 수 있을까?

재사용 가능한 최선의 옵션은 인터페이스 Itable을 구현하고 메서드 반복기()를 덮어쓰는 것입니다.

다음으로 인터페이스를 구현하는 ArrayList와 같은 클래스의 예를 나타냅니다.이 클래스에서 메서드 Iterator()를 덮어씁니다.

import java.util.Iterator;

public class SOList<Type> implements Iterable<Type> {

    private Type[] arrayList;
    private int currentSize;

    public SOList(Type[] newArray) {
        this.arrayList = newArray;
        this.currentSize = arrayList.length;
    }

    @Override
    public Iterator<Type> iterator() {
        Iterator<Type> it = new Iterator<Type>() {

            private int currentIndex = 0;

            @Override
            public boolean hasNext() {
                return currentIndex < currentSize && arrayList[currentIndex] != null;
            }

            @Override
            public Type next() {
                return arrayList[currentIndex++];
            }

            @Override
            public void remove() {
                throw new UnsupportedOperationException();
            }
        };
        return it;
    }
}

이 클래스는 Generics를 사용하여 Itherable 인터페이스를 구현합니다.어레이에 요소가 있다고 가정하면 예를 들어 "foreach" 루프가 사용하는 필수 인스턴스인 반복기 인스턴스를 가져올 수 있습니다.

반복기를 만들지 않고 반복기의 익명 인스턴스를 만들고 currentSize 값을 사용하여 어레이를 탐색할 수 있는 위치까지 확인할 수 있습니다(용량 10의 어레이를 생성했지만 0과 1의 요소는 2개뿐이라고 가정합니다).인스턴스에는 현재 위치에 대한 소유자 카운터가 있으며 현재 값이 null이 아닌지 확인하는 hasNext()와 현재 인스턴스를 반환하는 next()를 함께 사용하면 됩니다.인덱스. 다음은 이 API를 사용하는 예입니다.

public static void main(String[] args) {
    // create an array of type Integer
    Integer[] numbers = new Integer[]{1, 2, 3, 4, 5};

    // create your list and hold the values.
    SOList<Integer> stackOverflowList = new SOList<Integer>(numbers);

    // Since our class SOList is an instance of Iterable, then we can use it on a foreach loop
    for(Integer num : stackOverflowList) {
        System.out.print(num);
    }

    // creating an array of Strings
    String[] languages = new String[]{"C", "C++", "Java", "Python", "Scala"};

    // create your list and hold the values using the same list implementation.
    SOList<String> languagesList = new SOList<String>(languages);

    System.out.println("");
    // Since our class SOList is an instance of Iterable, then we can use it on a foreach loop
    for(String lang : languagesList) {
        System.out.println(lang);
    }
}
// will print "12345
//C
//C++
//Java
//Python
//Scala

필요한 경우 반복기 인스턴스를 사용하여 반복할 수도 있습니다.

// navigating the iterator
while (allNumbers.hasNext()) {
    Integer value = allNumbers.next();
    if (allNumbers.hasNext()) {
        System.out.print(value + ", ");
    } else {
        System.out.print(value);
    }
} 
// will print 1, 2, 3, 4, 5

Forech 매뉴얼은 http://download.oracle.com/javase/1,5.0/docs/guide/language/foreach.html에 있습니다.제 개인 업무용 구글 코드에서 좀 더 완벽한 구현을 보실 수 있습니다.

필요한 효과를 얻으려면 필터 개념을 반복기에 삽입해야 합니다.반복기는 다음 값에 의존하기 때문에 hasNext()에서 true를 반환하고 next() 구현을 예를 들어 문자 "a"로 시작하지 않는 값으로 필터링하는 것은 어렵습니다.필터가 지정된 값으로 필터링된 목록에 따라 보조 인터레이터를 사용해야 합니다.

물론이죠. 반복기는 인터페이스의 구현일 뿐입니다.기존 반복 가능한 개체를 사용하는 경우(예:LinkedList부터의 설명java.util둘 중 하나를 iterator것을 할 수 있는 합니다.Iterator인스턴스(더 폭넓게 사용된다는 장점이 있음) 등

요인 계산을 수행할 수 있는 좋은 예제

FactorialIterable fi = new FactorialIterable(10);
Iterator<Integer> iterator = fi.iterator();
while (iterator.hasNext()){
     System.out.println(iterator.next());
}

Java 1.8의 단축 코드

new FactorialIterable(5).forEach(System.out::println);

사용자 지정 반복 클래스

public class FactorialIterable implements Iterable<Integer> {

    private final FactorialIterator factorialIterator;

    public FactorialIterable(Integer value) {
        factorialIterator = new FactorialIterator(value);
    }

    @Override
    public Iterator<Integer> iterator() {
        return factorialIterator;
    }

    @Override
    public void forEach(Consumer<? super Integer> action) {
        Objects.requireNonNull(action);
        Integer last = 0;
        for (Integer t : this) {
            last = t;
        }
        action.accept(last);
    }

}

Custom Iterator 클래스

public class FactorialIterator implements Iterator<Integer> {

    private final Integer mNumber;
    private Integer mPosition;
    private Integer mFactorial;


    public FactorialIterator(Integer number) {
        this.mNumber = number;
        this.mPosition = 1;
        this.mFactorial = 1;
    }

    @Override
    public boolean hasNext() {
        return mPosition <= mNumber;
    }

    @Override
    public Integer next() {
        if (!hasNext())
            return 0;

        mFactorial = mFactorial * mPosition;

        mPosition++;

        return  mFactorial;
    }
}

이것은 'a'로 시작하는 요소를 반복하도록 반복기를 쓰는 완전한 코드입니다.

import java.util.Iterator;

public class AppDemo {

    public static void main(String args[]) {

        Bag<String> bag1 = new Bag<>();

        bag1.add("alice");
        bag1.add("bob"); 
        bag1.add("abigail");
        bag1.add("charlie"); 

        for (Iterator<String> it1 = bag1.iterator(); it1.hasNext();) {

            String s = it1.next();
            if (s != null)
                System.out.println(s); 
        }
    }
}

Custom Iterator 클래스

import java.util.ArrayList;
import java.util.Iterator;

public class Bag<T> {

    private ArrayList<T> data;

    public Bag() {

        data = new ArrayList<>();
    }

    public void add(T e) {

        data.add(e); 
    }

    public Iterator<T> iterator() {

        return new BagIterator();
    }

    public class BagIterator<T> implements Iterator<T> {

        private int index; 
        private String str;

        public BagIterator() {

            index = 0;
        }

        @Override
        public boolean hasNext() {

             return index < data.size();  
        }

        @Override
        public T next() {

            str = (String) data.get(index); 
            if (str.startsWith("a"))
                return (T) data.get(index++); 
            index++; 
            return null; 
        }
    } 
}

독자적인 Iterator를 실장할 수 있습니다.반복기는 목록에 의해 반환된 반복기를 래핑하도록 구성하거나 커서를 유지한 채 목록의 get(int 인덱스) 메서드를 사용할 수 있습니다.필터링 기준을 고려하기 위해 Iterator의 다음 메서드와 hasNext 메서드에 논리를 추가하면 됩니다.또한 반복기에서 제거 작업을 지원할지 여부도 결정해야 합니다.

여기 질문에 대한 완전한 답변이 있습니다.

import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;

class ListIterator implements Iterator<String>{
    List<String> list;
    int pos = 0;

    public ListIterator(List<String> list) {
        this.list = list;
    }

    @Override
    public boolean hasNext() {
        while(pos < list.size()){
            if (list.get(pos).startsWith("a"))
                return true;
            pos++;
        }
        return false;

    }

    @Override
    public String next() {
        if (hasNext())
            return list.get(pos++);
        throw new NoSuchElementException();
    }
}

public class IteratorTest {

    public static void main(String[] args) {
        List<String> list = Arrays.asList("alice", "bob", "abigail", "charlie");
        ListIterator itr = new ListIterator(list);

        while(itr.hasNext())
            System.out.println(itr.next()); // prints alice, abigail
    }
}

• ListIterator는 'a'로 시작하는 요소를 반환하는 배열의 반복기입니다.
• 반복 가능한 인터페이스를 구현할 필요가 없습니다.하지만 그건 가능한 일이야.
• 이것을 일반적으로 구현할 필요는 없습니다.
• 이는 hasNext()와 next()에 대한 계약을 완전히 충족합니다.즉, hasNext()가 아직 요소가 있다고 하면 next()는 이러한 요소를 반환합니다. hasNext 하면 한 hasNext()가 반환됩니다.NoSuchElementException★★★★★★ 。

언급URL : https://stackoverflow.com/questions/5849154/can-we-write-our-own-iterator-in-java