Iteratorを用いた、次の要素の型に応じて処理を変更する方法。

Question

前提・実現したいこと

ListIteratorを用いてリストの操作を行っています。
クラスAnimalを継承しているクラスHuman,Cat,Dog,Birdがあります。
それぞれのインスタンスをArrayList<Animal>に追加していきます。今回は以下の順で追加します。

追加する順	クラス
1	Human
2	Cat
3	Dog
4	Bird

【実現したいこと】
次の要素のクラスがBirdの時、そのクラスに特定の操作を実施する。
for文を用いた方法はわかるのですが、ListIteratorを用いた方法がわかりません。
今回でいうと、次の要素のクラスがBirdであるDogでのみ、changeFlag()を呼び出したいです。
お願いいたします。

発生している問題・エラーメッセージ

次の要素がクラスBirdであることは判別できても現在の要素(Dogのインスタンス)でのみ、changeFlag()を呼び出させる方法がわかりません。

該当のソースコード

ArrayList<Animal> list = new ArrayList<>();
Human human = new Human();
Cat cat = new Cat();
Dog dog = new Dog();
Bird bird = new Bird();
list.add(human);
list.add(cat);
list.add(dog);
list.add(bird);

// ここをIteratorにしたい
for(int i = 0;i < list.size(); i++){
    // クラスがＡ4かチェック
    if((i < list.size() - 1 )&&(list.get(i + 1) instanceof Bird)){
        list.get(i).changeFlag();
    }
}

// dogのみTrueになっているかチェック
for(Animal animal : list){
    if(!animal.getFlag()){
        System.out.println("False");
    }else{
        System.out.println("True");
    }
}

class Animal{
    private boolean flag = false;
    Animal(){}

    void changeFlag(){
        flag = true; 
    }

    boolean getFlag(){
        return flag;
    }
}

class Human extends Animal{
    Human(){}
}

class Cat extends Animal{
    Cat(){}
}

class Dog extends Animal{
    Dog(){}
}

class Bird extends Animal{
    Bird(){}
}

試したこと

// ArrayList宣言から追加までは同じ
ListIterator<Animal> iterator = list.listIterator();
while(iterator.hasNext()) {
    // 次がBirdか判別
    // 特定の処理
}

補足情報（FW/ツールのバージョンなど）

特になし。

Comments

[BeatStar]

「特定の処理」とはなんでしょうか。それとArrayListに入れる予定のAとは何でしょうか。
A1,A2,A3... とは何でしょうか。
それらによって相当変わってきますよ。

[coco_bauer]

少なくとも、クラスA、クラスA1、クラスA2、クラスA3、クラスA4を定義しているコードを示してもらわないと議論が始められないですよ。

[Chris1943]

すみません、知りたかったのはIteratorの使用方法のみなのでクラス名等は端折りました。
分かりにくかったので追記します。少々お待ちください。

[Chris1943]

追記しました。
仮のクラス名、メソッド名ですがやりたいこととしては合致しています。
宜しくお願いいたします。

[jimbe]

コードのマークダウンの ``` の所に Main とか Dog とか書いている個所は(クラス名やファイル名を書く所では無く)言語名を書く所です。
全て java としてください。
ファイル名等は枠の外に書いてください。

[xebme]

1つ前の要素を考えると簡単にならないでしょうか。
Iterator<T> iterator = list.iterator();
T previous = (iterator.hasNext()) ? iterator.next() : null;
while (iterator.hasNext()) {
T current = iterator.next();
previousがDog、currentがBirdのとき、previous.changeFlag()
previous = current;
}

Answer 1

Animalの属性と並びに応じた処理

まず初めにAnimalを以下のように定義します。哺乳類、鳥類を表すメソッドと、changeFlagメソッド。changeFlag()はAnimalの振る舞いではないのでおかしいのですがこのままにしておきます。

public interface Animal {
  boolean isMammal();
  boolean isBirds();
  void changeFlag();
}

ListIteratorをご希望ですがIteratorで目的を達成できます。一つ手前のインスタンスを保持するだけです。

    Iterator<Animal> iterator = list.iterator();
    Animal previous = (iterator.hasNext()) ? iterator.next() : null;
    while (iterator.hasNext()) {
      Animal current = iterator.next();
      if (previous.isMammal() && current.isBirds()) {
        // 目的の機能を呼ぶ。
      }
      previous = current;
    }

インスタンスのペアを生成するzip機能

changeFlag()はAnimalの振る舞いではないのでおかしいと申しましたが、changeFlag()はlist内のAnimalの並び情報を変更、保持するのが目的ですから、listに属するか、Animalのペアに属するか、あるいは、処理の中で一時的に利用するラムダ式のような位置付けになるかと思います。

ここでは、shiketaさんや先輩回答者に倣って、Animalのペアを考えてみます。型Tのペアを定義してIteratorを作ります。Java 17のrecord型でPairを定義します。

public record Pair<T>(T _1, T _2) {}

PairのIteratorを作ります。

  static <T> Iterator<Pair<T>> zip(final List<T> list) {   
    return new Iterator<Pair<T>>() {
      final Iterator<T> iterator = list.iterator();
      T previous = (iterator.hasNext()) ? iterator.next() : null;     
      @Override
      public boolean hasNext() {
        return iterator.hasNext();
      }    
      @Override
      public Pair<T> next() {
        if (!iterator.hasNext()) {
          throw new RuntimeException();
        }
        Pair<T> result = new Pair<>(previous,iterator.next());
        previous = result._2();
        return result;
      }    
    };
  }

PairのStreamも同様です。

  static <T> Stream<Pair<T>> zipStream_(List<T> list) {
    Stream.Builder<Pair<T>> builder = Stream.builder();
    Iterator<T> iterator = list.iterator();
    T previous = (iterator.hasNext()) ? iterator.next() : null;
    while (iterator.hasNext()) {
      T current = iterator.next();
      builder.accept(new Pair<>(previous,current));
      previous = current;
    }
    return builder.build();
  }

補足情報を追記するかもしれません。

Answer 2

Iteratorは、リストのどこか（通常は、先頭)から始めて、「次のデータを取り出して」というような操作を繰り返す(Iterate: 反復する)事を基本とする仕組みです。
どのデータが取り出されるかは、どの位置のデータに着目しているか(直前に取り出してデータがどこにあったか)によって決まります。
取り出すべきデータが無くなったら、動作を終了します。

質問に書かれているプログラムでは、以下の操作をループで繰り返しています。

aData = list.get(i + 1)
i = i + 1; //データ取得市を１つ進める

リストが次の値を取り出す next()というイテレータを持っていたら、以下のような操作をループで繰り返せば良いことになります。

newdata = somelist.next(); //取得位置を１つ進めて、データを取得する（データの末尾まで行っていたら、nulを返す)

だいたい、おこんな感じです。（雰囲気を感じ取ってもらえればという意図で回答しました）

Answer 3

https://teratail.com/questions/54055の回答にあるzipを定義してみてはいかがかと。

1. 元のリストと、そのリストの二番からの要素をペアにする。
2. ペアの片側は現在の要素で、もう片側が次の要素。
3. 先読みしなくても、次の要素がわかる。

先に挙げた回答ではScalaでどうぞとありますが、KotlinのListにもzipメソッドがある。こんな感じ。

object ZipSample {
  interface Animal
  class Human : Animal
  class Cat : Animal
  class Dog : Animal
  class Bird : Animal

  @JvmStatic
  fun main(args: Array<String>) {
    val list = listOf(Human(), Cat(), Dog(), Bird())

    list.zip(list.drop(1))
      .forEach { (a, b) ->
        println("${a::class.simpleName} : ${b::class.simpleName}")
      }
    //Human : Cat
    //Cat : Dog
    //Dog : Bird

    list.zip(list.drop(1))
      .forEach { (a, b) ->
        if (b is Bird) {
          println("${a::class.simpleName}. next ${b::class.simpleName}")
        }
      }
    // Dog. next Bird
  }
}

Answer 4

Iterator は通常、対象要素群に対して一律の処理を行うような場合に有効な手段で、現在位置の要素と他位置の要素を使うような場合には(ListIteratorでも next したり previous したりと)面倒なだけです。
配列のほうが簡単かと思います。