So, based on your description, I think the filter you want is this:

segments.stream()
        .filter(m -> ((Long) m.get("ct")) != 1L)
        .collect(toList());

Or being explicit about the type of the predicate:

        .filter((Map<String, Object> m) ->
                    ((Long) m.get("ct")) != 1L)

On your edit: you have erroneous data in the Map, or you've misunderstood the way it's represented. It appears that segments is actually a List<Object[]>.

I don't really have enough information to help you fix it.

To try debugging, you could do something like:

segments.stream()
        .map(Arrays::toString)
        .forEach(System.out::println);

This will tell you what's actually in it if you don't have documentation to refer to.

If I understood correctly you need the following code:

public static List<Person> doFilter(String groupName) {
    return personMap.entrySet().stream()
            .filter(entry -> entry.getKey().equals(groupName))
            .map(entry -> entry.getValue())
            .flatMap(List::stream)
            // as an option to replace the previous two
            // .flatMap(entry -> entry.getValue().stream()) 
            .collect(Collectors.toList());
}

To filter out entries where a list contains an employee who is not of the "M" gender:

Map<String, List<Employee>> r2 = map.entrySet().stream()
    .filter(i -> i.getValue().stream().allMatch(e-> "M".equals(e.gender)))
    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

To filter out employees who are not of the "M" gender:

Map<String, List<Employee>> r1 = map.entrySet().stream()
    .filter(i -> !i.getValue().isEmpty())
    .collect(Collectors.toMap(Map.Entry::getKey,
        i -> i.getValue().stream()
              .filter(e -> "M".equals(e.gender)).collect(Collectors.toList())));

To filter out entries where a list doesn't contain any "M" employee.

Map<String, List<Employee>> r3 = map.entrySet().stream()
    .filter(i -> i.getValue().stream().anyMatch(e -> "M".equals(e.gender)))
    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

Let's have 2 entries in the map:

"1" -> ["M", "M", "M"]
"2" -> ["M", "F", "M"]

The results for them will be:

r1 = {1=[M, M, M], 2=[M, M]}
r2 = {1=[M, M, M]}
r3 = {1=[M, M, M], 2=[M, F, M]}

This transformation is not so obvious, but still feasible without instantiating a dedicated Map directly and without using forEach.

First of all, I suggest to implement hashCode and equals in Hotel and OTAProperty classes: this is often useful, especially when storing objects in collections.

Here is how the functional sequence can look like:

public static Map<Long, Hotel> createHotelMapByOtaName2(List<Hotel> hotels, String otaName) {
  return hotels.stream()
             .map(hotel ->
                hotel.getOtaProperties().stream()
                     .filter(op -> otaName.equals(op.getOtaName())) // 1
                     .collect(Collectors.toMap(OTAProperty::getId,  
                                               (h) -> hotel))) // 2
             .map(Map::entrySet) // 3
             .flatMap(Collection::stream) // 4
             .collect(Collectors.toMap(Map.Entry::getKey,
                                       Map.Entry::getValue)); // 5
}

1. Equivalent of the original if condition: we take only OTAProperties that match the required name.

2. Each hotel item is wrapped to a Map<Long, Hotel>, which is a subset of the resulting map.

3. Transformation of the stream of Maps into a stream of Set<Entry<Long, Hotel>>.

4. Concatenation of streams of Sets into a single stream of Entry<Long, Hotel>. Unfortunately, we cannot join Maps so easily, that is why there is this intermediate transformation.

5. Finally, the stream of entries is collected into a Map representing the result of the sequence.

Your sniplet wil produce a List<List<String>> not List<String>.

You are missing flatMap , that will convert stream of lists into a single stream, so basically flattens your stream:

List<String> wordsForGivenAlphabet = words.entrySet().stream()
    .filter(x-> x.getKey().equalsIgnoreCase(inputAlphabet))
    .map(Map.Entry::getValue)
    .flatMap(List::stream) 
    .collect(Collectors.toList());

You can also add distinct(), if you don't want values to repeat.

If you only need the "val1" and "val2" values, you can first use getOrDefault to get the corresponding list, and then filter on the entries' keys to get entries with Param1 or Param2 as key, and finally apply map again to get the values of these entries.

List<String> list =
    myMap.getOrDefault("SERVICE1", Collections.emptyList())
         .stream()
         .filter(e -> e.getKey() == Parameter.Param1 || e.getKey() == Parameter.Param2)
         .map(Map.Entry::getValue)
         .collect(Collectors.toList());

Also you might be interested to look at Efficiency of Java "Double Brace Initialization"?

You don't need the forEach method. You can map each entry of the Map to an int, and sum those integers :

int sum = inputMap
    .entrySet()
    .stream()
    .filter(entry -> entry.getKey().field().equals(fieldName))
    .mapToInt(entry -> Math.min(entry.getValue().size(), 5))
    .sum();

I found the below approach to be working well for me. Any better solutions are welcome to post a reply and say why its better. Currently, this code returns a map keys with an empty list if no match is found, (If you have a solution which can eliminate keys from the result and return null when nothing matches that will be good too).

             map.entrySet()
                .stream()
                .collect(Collectors.toMap(Map.Entry::getKey,
                  entry -> entry.getValue()
                               .stream().filter(predicate)
                               .collect(Collectors.toList()))
                 )