Java 如何迭代自定义类型并查找特定类型？

我有一个奥利弗级的ArrayList：

ArrayList<Olive> olives = new ArrayList<Olive>();

olives.add(new Kalamata());
olives.add(new Ligurian());
olives.add(new Kalamata());
olives.add(new Ligurian());

如何迭代Olive类型的arrayList？我想找到name variable=“Ligurian”的位置，然后返回Ligurian.getOrigin（）

使用streams API：

Olive olive = olives.stream()
                     .filter(o -> o.name.equals("Ligurian"))
                     .findAny().get();
String origin = olive.getOrigin();

如果您使用的是Java 7，则可以使用循环，这对您来说是一种耻辱，但也可以：

Olive found;
for(Olive olive : olives) {
    if(olive.name.equals("Ligurian")) {
        found = olive;
        break;
    }
}
String origin = found.getOrigin();

---

在Java中，迭代自定义类型并选择一个

for (Olive olive : olives) {
  if (olive instanceof Ligurian) {
    String origin = olive.getOrigin();
  }
}

---

考虑让这个课程来管理你的橄榄（或其他任何东西）：

请注意，作为一个附加功能，即使不公开

getName

，这也可以工作。它不使用

getName

而是使用添加对象的类来进行子类别化或分区。使用实际的类名，比如使用

olives.get（Ligurian.class）

时，会带来额外的好处，即在编译时会发现输入错误，并且返回的对象是强类型的

如果这样做的开销可以忽略不计，那么在积累数据时总是更好地组织数据。这将使以后的处理更加高效（如果您编码正确的话）。对以后如何使用它进行预见会有所帮助

---

可能还需要另外一个想法，即在多个类加载器的情况下应该做什么。我不确定。可能需要改为使用类名在内部存储。

是否尝试过使用循环？然后在找到并处理第一个项目后，中断。“我应该提一下。”LiganmentsRasher我添加了一个Java7的答案。好主意。您好，谢谢您的回答，我只从ligurian类本身实现了getOrigin，因此这种方式向我展示了如何从超类获取Origin？@初学者问题这是一种对迭代中第一个对象调用

getOrigin

的方法，该对象的

名称

属性等于

“ligurian”

。没有更多，没有更少-你可以调用它的任何

Olive

方法。对不起，我很困惑，我怎么才能让它成为利古里亚类的起源？因为find.getOrigin（）希望我在超类上实现该方法。

for (Olive olive : olives) {
  if (olive instanceof Ligurian) {
    String origin = olive.getOrigin();
  }
}

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class TypedList<T> {
  Map<Class<? extends T>,List<T>> mlt;

  public TypedList() {
    mlt = new HashMap<>();
  }

  private <U extends T> void add(Class<U> t,U o) {
    List<U> lu = (List<U>)mlt.get(t);
    if (lu == null) {
      lu = new ArrayList<>();
      mlt.put(t, (List<T>)lu);
    }
    lu.add(o);
  }

  public void add(T o) {
    add((Class<T>)o.getClass(),o);
  }

  public <U extends T> List<U> get(Class<U> t) {
    return (List<U>)mlt.get(t);
  }

  public <U extends T> List<? extends U> getIncludingDescendands(Class<U> t) {
    List<U> nl = new ArrayList<>();
    // Inefficient Unions
    mlt.entrySet().stream().filter((e)->t.isAssignableFrom(e.getKey())).forEach((e)->{nl.addAll((List<U>)e.getValue());});
    return nl;
  }
}

public class Main {
  public static void main(String[] args) {
    TypedList<Olive> olives = new TypedList<>();

    olives.add(new Kalamata());
    olives.add(new Ligurian());
    olives.add(new Kalamata());
    olives.add(new Ligurian());
    olives.add(new BigKalamata());

    System.out.println("Number of Ligurian: "+olives.get(Ligurian.class).size());
    System.out.println("Number of Kalamata: "+olives.get(Kalamata.class).size());
    System.out.println("Number of BigKalamata: "+olives.get(BigKalamata.class).size());
    System.out.println("Number of Kalamata and Subspecies: "+olives.getIncludingDescendands(Kalamata.class).size());
    // get first Ligurian:
    Ligurian ligurian = olives.get(Ligurian.class).get(0); // Carefull for NPE
  }
}

public interface Olive {}
public class Ligurian implements Olive {}
public class Kalamata implements Olive {}
public class BigKalamata extends Kalamata {}