почему не работает подсчет элементов списка

public class Dispatcher {                                                                                                 
    public static void main(String[] args) {                                                                              
        ArrayList<Animal> animals = new ArrayList<>();                                                                    
        Collections.addAll(animals,                                                                                       
                new Animal("Dog", "Boolka", 3, 15),                                                                       
                new Animal("Cat", "Moorka", 4, 10),                                                                       
                new Animal("Parrot", "Kora", 3, 2));                                                                      
        HashSet<Animal> animals1 = new HashSet<>(Arrays.asList(                                                           
                new Animal("Dog", "Poor", 3, 15),                                                                         
                new Animal("Cat", "Moorka", 4, 10),                                                                       
                new Animal("Parrot", "Koraa", 3, 2)                                                                       
        ));                                                                                                               
        Animal[] animals2 = {                                                                                             
                new Animal("Dog", "Poork", 3, 15),                                                                        
                new Animal("Cat", "Moor", 4, 10),                                                                         
                new Animal("Parrot", "Kora", 3, 2)                                                                        
        };                                                                                                                
        Generic.findCommonElements(animals, animals1, animals2);                                                          
    }                                                                                                                     
}                                                                                                                         
                                                                                                                          
class Generic {                                                                                                           
    public static <T> Map<?, Long> findCommonElements(ArrayList<T> listAnimal, HashSet<T> setAnimal, T[] arrAnimal) {     
        final List<?> collect = Stream.of(listAnimal, Collections.singletonList(setAnimal), Arrays.asList(arrAnimal))     
                .flatMap(Collection::stream)                                                                              
                .collect(Collectors.toList());                                                                            
        final Map<?, Long> collect1 = collect.stream().collect(Collectors.groupingBy(o -> o, Collectors.counting()));     
        System.out.println(collect1.values());                                                                            
        return null;                                                                                                      
    }                                                                                                                     
}

public class Helper {
 
    public static void main(String[] args) {
        List<Parent> parents = new LinkedList<>();
        parents.add(new Parent("Pp11l"));
        parents.add(new Parent("Pp12l"));
        List<Child> child = new ArrayList<>();
        child.add(new Child("Chil1", 1));
        Parent[] arrayPar = new Parent[2];
        arrayPar[0] = new Parent("Pp21a");
        arrayPar[1] = new Parent("Pp22a");
        long cl = Counter.getCountElems(parents.stream(), child.stream(), Arrays.stream(arrayPar));
        System.out.println(cl);
    }
 
}
//###
class Counter {
    private Counter() {}
 
    public static <T> long getCountElems(Stream<? extends T> first, Stream<? extends T>... last) {
       if (last.length != 0) {
           Stream resStr = first;
           for (Stream st : last) {
               resStr = Stream.concat(resStr, st);
           }
           return resStr.count();
       }else return first.count();
    }
}
//###
class Parent {
    String name;
 
    public Parent(String name) {
        this.name = name;
    }
 
    @Override
    public String toString() {
        return this.getClass().getSimpleName() +
                "name='" + name + '\'' ;
    }
}
//##
class Child extends Parent {
    int pupa;
 
    public Child(String name, int pupa) {
        super(name);
        this.pupa = pupa;
    }
}