Question

我有A类和两个扩展A的B和C类。我有一个数组列表，其中包含所有这些类的多个实例。我是否可以使用一个方法来接收一个对象并返回数组列表中的所有对象，这些对象与给定方法的类型相同，我将如何进行此操作？

Answer 1

当然 - 您使用getClass()查找执行时类型：

private final List<A> allKnownValues = ...;

List<A> getAllValuesOfTheSameType(A sample) {
    ArrayList<A> results = new ArrayList<>();
    for (A candidate : allKnownValues) {
        if (candidate.getClass() == sample.getClass()) {
            results.add(candidate);
        }
    }
    return results;
}

如果要包含子类型，可以使用：

if (sample.getClass().isInstance(candidate))

Answer 2

虽然它已经回答了，但我已经开始创建一个示例，MCVE，所以我只是放在这里：

import java.util.ArrayList;
import java.util.List;

public class TypeFilterTest 
{
    public static void main(String[] args) {

        List<Object> list = new ArrayList<Object>();
        list.add(1);
        list.add(2.0f);
        list.add(3.0);
        list.add(4);
        list.add(5.0f);
        list.add(6.0);
        list.add("seven");
        list.add(null);

        System.out.println("Integers    : "+findSameType(list, Integer.class));
        System.out.println("Floats      : "+findSameType(list, Float.class));
        System.out.println("Doubles     : "+findSameType(list, Double.class));

        System.out.println("Comparables : "+findSubType(list, Comparable.class));

    }

    private static <T> List<T> findSameType(List<? super T> list, Class<T> type)
    {
        List<T> result = new ArrayList<T>();
        for (int i=0; i<list.size(); i++)
        {
            Object element = list.get(i);
            if (element != null && element.getClass().equals(type))
            {
                result.add(type.cast(element));
            }
        }
        return result;
    }

    private static <T> List<T> findSubType(List<? super T> list, Class<T> type)
    {
        List<T> result = new ArrayList<T>();
        for (int i=0; i<list.size(); i++)
        {
            Object element = list.get(i);
            if (type.isInstance(element))
            {
                result.add(type.cast(element));
            }
        }
        return result;
    }   

}

Answer 3

假设您有某个对象指向列表List<A> yourOriginalList

如果您使用的是Java 8，您可以编写一个可重用的过滤器方法，不仅适用于B或C元素，还适用于您想要比较的任何内容。这是使用Java 8中引入的新lamba表达式。

public List<A> getFilteredList(Predicate<A> predicate){
        List<A> filteredList = new ArrayList<A>();
        for(A value : yourOriginalList){
            if(predicate.test(value)){
                filteredList.add(value);
            }
        }
        return filteredList;
    }

要过滤B对象，请使用：

List<A> filteredListOfB = getFilteredList((value) -> value instanceof B);

要过滤C对象，请使用：

List<A> filteredListOfC = getFilteredList((value) -> value instanceof C);

正如您所见，您可以在getFilteredList

的参数中编写您想要测试的任何内容

（没有测试语法错误，但想法就在这里）

检查对象是否与传递的对象类型相同

3 个答案: