You could use toLowerCase():

u -> u.name1.toLowerCase().contains(keyword.toLowerCase());

This way both values are in the same case and your search is case in-sensitive.

If you're using Java 8

List<String> list = new ArrayList<>();

boolean containsSearchStr = list.stream().anyMatch("search_value"::equalsIgnoreCase);

There are several fundamental problems with your code.

• .filter(s -> word.contains(s)) performs a substring search. Contrary to your question’s title, it does not ignore case. Still, there can be strings of different content passing the filter

• .collect(Collectors.groupingBy(Function.identity(), Collectors.counting())) creates groups according to the string’s actual content. So when multiple different strings passed the previous filter, multiple groups may exist

• .values().stream().findFirst(): since the groupingBy created a map with an unspecified ordering, this will pick an arbitrary group. Besides that, it’s a very inefficient way to ask just for the count()

• .orElse((long) -1) The value -1 is a very strange fall-back for counting, as the most natural answer would be “zero” when there are no matches.

So a straight-forward solution would be

public static long countWordOccurence(List<String> wordList, String word) {
    return Collections.frequency(wordList, word);
}

for counting case sensitive matches or

public static long countWordOccurence(List<String> wordList, String word) {
    return wordList.stream().filter(word::equalsIgnoreCase).count();
}

for counting case insensitive.

But that’s an xy problem anyway.

When you want to count occurrences of a word in a string, it’s not necessary to split the string into words and to convert the array into a list (by the way, you can stream over an array directly), before performing the actual search.

You can use

public static long countWordOccurence(String sentence, String word) {
    if(!word.codePoints().allMatch(Character::isLetter))
        throw new IllegalArgumentException(word+" is not a word");
    Pattern p = Pattern.compile("\\b"+word+"\\b");
    return p.matcher(sentence).results().count();
}

for a count of case sensitive matches and

public static long countWordOccurence(String sentence, String word) {
    if(!word.codePoints().allMatch(Character::isLetter))
        throw new IllegalArgumentException(word+" is not a word");
    Pattern p = Pattern.compile("\\b"+word+"\\b", Pattern.CASE_INSENSITIVE);
    return p.matcher(sentence).results().count();
}

for the case insensitive matches. The \b pattern denotes word boundaries, which only makes sense if the search string is actually a word. So the methods above have a pre-test for that, which also ensures that the word does not contain characters that could be misinterpreted as regex patterns.

The results() method was introduced in Java 9. This answer shows a solution for creating such a stream under Java 8, however, for such a simple task as counting the occurrences, the alternative would be not to use streams here:

public static long countWordOccurence(String sentence, String word) {
    if(!word.codePoints().allMatch(Character::isLetter))
        throw new IllegalArgumentException(word+" is not a word");
    Pattern p = Pattern.compile("\\b"+word+"\\b", Pattern.CASE_INSENSITIVE);
    int count = 0;
    for(Matcher m = p.matcher(sentence); m.find(); count++) {}
    return count;
}

anyMatch only returns true or false indicating whether there is at least 1 element in the stream that satisfies the predicate.

You should use filter and findFirst, which returns the first element that matches the predicate:

speciality = specialities.stream()
                 .filter(spec::equalsIgnoreCase)
                 .findFirst()
                 .orElse("General Practitioner");

You can use this exactly like you'd use any other ArrayList. You can pass this List out to other code, and external code won't have to understand any string wrapper classes.

public class CustomStringList3 extends ArrayList<String> {
    @Override
    public boolean contains(Object o) {
        String paramStr = (String)o;
        for (String s : this) {
            if (paramStr.equalsIgnoreCase(s)) return true;
        }
        return false;
    }
}

This seems not to be (easily) possible with Streams alone¹, but you can keep track of the already seen elements in a Set (O(1) lookup) and filter elements by whether their lowercased forms are already in that set (Set.add will return false then).

List<String> values = List.of("Value1", "vALue1", "vALue2", "valUE2");
Set<String> seen = new HashSet<>();
List<String> res = values.stream().filter(s -> seen.add(s.toLowerCase()))
                                  .collect(Collectors.toList());
System.out.println(res);  // [Value1, vALue2]

¹⁾ E.g., distinct does not accept a mapping function and Collectors.groupingBy might does not preserve order.

There is no toUpper() method for String.

It is toUpperCase() and also you need to use contains() to check "BLACK" there anywhere in the whole string, so the code should be simple as shown below:

List<Employee> filtList = inputList.stream().
         filter(value -> value.toUpperCase().//convert to uppercase for checking
         contains("BLACK")).//filter values containing black
         collect(Collectors.toList());//collect as list

Try this.

public static void main(String[] args) {
    List<Cat> cats = List.of(new Cat("たま", 3), new Cat("しろ", 2));
    List<String> favoriteNames = List.of();
    List<Cat> favoriteCats = cats.stream()
        .filter(cat -> favoriteNames.isEmpty() || favoriteNames.contains(cat.getName()))
        .toList();
    System.out.println(favoriteCats);
}

output:

 [Cat(name=たま, age=3), Cat(name=しろ, age=2)]

or

    var stream = cats.stream();
    if (!favoriteNames.isEmpty())
        stream = stream.filter(cat -> favoriteNames.contains(cat.getName()));
    List<Cat> favoriteCats = stream.toList();

For grouping operations you should use Collectors.groupingBy because Collectors.toMap will take Function as arguments

Map<String, Long> rta = users.stream().filter(user -> user.getAge() < 18 && user.getLivingPlace() != null)
        .collect(Collectors.groupingBy(us -> us.getLivingPlace().getProvince(), Collectors.counting()));

As @Holger suggested you can also use Collectors.toMap with merge function when you expect a large number of groups with small counts

Map<String, Integer> rta = users.stream()
.filter(user -> user.getAge() < 18 && user.getLivingPlace() != null)
.collect(Collectors.toMap(us -> us.getLivingPlace().getProvince(), 
    a -> 1L, Integer::sum));

And if you want to perform grouping operation by ignoring cases, you can either convert province to lower case or upper case

Map<String, Long> rta = users.stream().filter(user -> user.getAge() < 18 && user.getLivingPlace() != null)
    .collect(Collectors.groupingBy(us -> us.getLivingPlace().getProvince().toLowerCase(), Collectors.counting()));

or you can use TreeMap with CASE_INSENSITIVE_ORDER comparator

Map<String, Long> result = users.stream()
      .filter(user -> user.getAge() < 18 && user.getLivingPlace() != null)
      .collect(Collectors.groupingBy(us -> us.getLivingPlace().getProvince(),
            () -> new TreeMap<>(String.CASE_INSENSITIVE_ORDER), Collectors.counting()));

anyMatch will return true if some hobby matches.

List<Person> personsWithHobby = persons.stream()
    .filter(person -> person.getHobbies().stream()
            .anyMatch(searchHobby::contains))
    .collect(Collectors.toList());