import java.util.Arrays;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class Main {

    public static void main(String[] args) {
        Stream<Object> input = Arrays.stream(new Object[] {
            "ABC", 1, Pair.of(3, 4), Pair.of(1, "2"), Pair.of(2, 3), "TEST"
        });
        System.out.println(process(input));
    }
    
    public static int process(Stream<Object> input) {
        
        Predicate<Object> isPair = Pair.class::isInstance;
        Predicate<Pair> isLeftInteger = pair -> pair.left instanceof Integer;
        Predicate<Pair> isRightInteger = pair -> pair.right instanceof Integer;
        
        // Хотелось бы что-то такое как
        // Predicate<Object> isLeftInteger = (Pair) object -> pair.left instanceof Integer;
        // Predicate<Object> isRightInteger = (Pair) object -> pair.right instanceof Integer;
        // чтобы можно было объединить предикаты как
        // input.filter(isPair.and(isLeftInteger).and(isRightInteger))
        
        return input
            .filter(e -> isPair.test(e) && isLeftInteger.test(((Pair) e)) && isRightInteger.test((Pair) e))

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

            .mapToInt(Integer::intValue)
            .sum();        
    }

    static class Pair<L, R> {
        
        static <L, R> Pair<L, R> of(L left, R right) {
            Pair<L, R> pair = new Pair<>();
            pair.left = left;
            pair.right = right;
            return pair;
        }
        
        L left;
        R right;
    }
}