Здравствуйте, AJ, Вы писали:

AJ>Коллеги, есть ли какой-то способ упростить следующий код?

пример учебный? (это я к тому, чтобы не писать дурацких вопросов "зачем и кто это сделал так?")

    
AJ>    public static int process(Stream<Object> input) {
        
AJ>        Predicate<Object> isPair = Pair.class::isInstance;
AJ>        Predicate<Pair> isLeftInteger = pair -> pair.left instanceof Integer;
AJ>        Predicate<Pair> isRightInteger = pair -> pair.right instanceof Integer;
        
AJ>        return input
AJ>            .filter(e -> isPair.test(e) && isLeftInteger.test(((Pair) e)) && isRightInteger.test((Pair) e))

AJ>            // и вот здесь есть какой-нибудь избежать всей этой цепочки кастов по второму разу?
AJ>            .map(e -> ((Integer) ((Pair) e).left + ((Integer) ((Pair) e).right)))

AJ>            .mapToInt(Integer::intValue)
AJ>            .sum();

// как-то так, наверное
return input.filter(Pair.class::isInstance).map(Pair.class::cast).filter(isLeftInteger).filter(isRightInteger)
            .mapToInt(p -> ((Integer) p.left) + ((Integer) p.right)).sum();

AJ>    }

потенциально, если облегчить условие суммирования до "всех найденных Integer'ов даже в несимметричных по типу парах", то можно было бы сразу после map(cast) сделать разворот в

flatMap(p -> Stream.concat(p.left, p.right)).filter(Integer.class::isInstance).map(Integer.class::cast).mapToInt(Integer::intValue)