Robustness

I can see no difference in the robustness of the three approaches.

Readability

I am not aware of any credible scientific studies on code readability involving experienced Java programmers, so readability is a matter of opinion. Even then, you never know if someone giving their opinion is making an objective distinction between actual readability, what they have been taught about readability, and their own personal taste.

So I will leave it to you to make your own judgements on readability ... noting that you do consider this to be a high priority.

FWIW, the only people whose opinions on this matter are you and your team.

Performance

I think that the answer to that is to carefully benchmark the three alternatives. Holger provides an analysis based on his study of some versions of Java. But:

1. He was not able to come to a definite conclusion on which was fastest.
2. Strictly speaking, his analysis only applies to the versions of Java he looked at. (Some aspects of his analysis could be different on (say) Android Java, or some future Oracle / OpenJDK version.)
3. The relative performance is likely depend on the length of the string being split, the number of fields, and the complexity of the separator regex.
4. In a real application, the relative performance may also depend what you do with the Stream object, what garbage collector you have selected (since the different versions apparently generate different amounts of garbage), and other issues.

So if you (or anyone else) are really concerned with the performance, you should write a micro-benchmark and run it on your production platform(s). Then do some application specific benchmarking. And you should consider looking at solutions that don't involve streams.

Use Collectors.groupingBy with a downstream collector which gets the second part of the split line before collecting to a list.

Map<Integer, List<String> table =
    Files.lines(Paths.get("path-to-file"))
         .map(line -> line.split(" ", 2))
         .collect(Collectors.groupingBy(
             parts -> Integer.valueOf(parts[0]),
             Collectors.mapping(parts -> parts[1], Collectors.toList())
         ));

try this:

    String fileName = "file.txt";
        try {
        Map<String, Long> wordCount = Files.lines(Path.of(fileName))
                .flatMap(line -> Arrays.stream(line.split("\\s+")))
                     .filter(w->w.matches("[a-zA-Z]+"))
                     .sorted(Comparator.comparing(String::length)
                            .thenComparing(String.CASE_INSENSITIVE_ORDER))  
                        .collect(Collectors.groupingBy(w -> w, 
         LinkedHashMap::new, Collectors.counting()));
        wordCount.entrySet().forEach(System.out::println);
        }catch (Exception e) {
            e.printStackTrace();
        }

This is relatively simple. It just splits on white space and counts the words by putting them in a map where the Key is the word and the Value is a long containing the count.

I included a filter to only capture words of nothing but letters. The way this works is that the Lines put into a stream. Each line is then split into words using String.split. Since this creates an array, the flatMap converts all these individual streams of words into a single stream where they are processed. The work horse of this is the Collectors.groupingBy which will group the values in a particular way for each key. In this case, I specified the Collectors.counting() method to increase the count each time the key (i.e. word) appeared.

As an option, I sorted the words first on length and then alphabetically, ignoring case.

The second map operation you write keep the first word.

Instead, here what you can do :

1. Replace the spaces (\\s as regex) by a -

   Optional<String> temp = list.stream()
                               .map(x -> x.name)
                               .map(x -> x.replaceAll("\\s", "-"))
                               .reduce((str1, str2) -> str1 + "&&" + str2);
   

2. Split on space, and then join with the -

   Optional<String> temp  = list.stream()
                                .map(x -> x.name)
                                .map(x -> String.join("-", x.split("\\s")))
                                .reduce((str1, str2) -> str1 + "&&" + str2);
   

It was an interesting challenge even if streams should not be used for such simple tasks. Here's the complete code:

public class Example {
    public static void main(String[] args) {
        String[] strings = {"randomText1 randomText2"};
        MyClass myClass = Arrays.stream(strings)
                .map(string -> string.split(" "))
                .flatMap(Arrays::stream)
                .collect(new MyCollector());
        System.out.println("myClass = " + myClass.toString());
    }
}

class MyCollector implements Collector<String, List<String>, MyClass> {
    @Override
    public BiConsumer<List<String>, String> accumulator() {
        return List::add;
    }

    @Override
    public Supplier<List<String>> supplier() {
        return ArrayList::new;
    }

    @Override
    public BinaryOperator<List<String>> combiner() {
        return (strings, strings2) -> {
            strings.addAll(strings2);
            return strings;
        };
    }

    @Override
    public Function<List<String>, MyClass> finisher() {
        return strings -> new MyClass(strings.get(0), strings.get(1));
    }

    @Override
    public Set<Characteristics> characteristics() {
        return Collections.emptySet();
    }
}

class MyClass {
    String s1;
    String s2;

    public MyClass(String s1, String s2) {
        this.s1 = s1;
        this.s2 = s2;
    }

    @Override
    public String toString() {
        return "MyClass{" +
                "s1='" + s1 + '\'' +
                ", s2='" + s2 + '\'' +
                '}';
    }
}

You may do it like so,

Path path = Paths.get("src/main/resources", "data.txt");
try (Stream<String> lines = Files.lines(path)) {
    List<String> strings = lines.flatMap(l -> Arrays.stream(l.split(","))).map(String::trim)
        .collect(Collectors.toCollection(LinkedList::new));
}

Read each line of the file, then split it using the delimiter. After that trim it to eliminate any remaining white space characters. Finally collect it to a result container.