题目

给定一个字符串s，s包含以空格分隔的若干个单词，请对s进行如下处理后输出：

1、单词内部调整：对每个单词字母重新按字典序排序；

2、单词间顺序调整：

1）统计每个单词出现的次数，并按次数降序排列；

2）次数相同时，按单词长度升序排列；

3）次数和单词长度均相同时，按字典序升序排列。

请输出处理后的字符串，每个单词以一个空格分隔。

代码

package org.example.niuke;

import org.junit.jupiter.api.Test;

import java.util.*;
import java.util.stream.Collectors;

public class strSort {
    // 第一版
    public static void main(String[] args) {
        String s1 = "My sister is in the house not in the yard";
        String[] s = s1.split(" ");
        Arrays.stream(s)
                .map(a -> a.chars()
                        .sorted()
                        .mapToObj(i->String.valueOf((char)i))
                        .collect(Collectors.joining()))
                .collect(Collectors.toMap(k -> k, v -> 1, (a, b) -> a + 1))
                .entrySet().stream()
                .sorted((a,b)->{
                    if(a.getValue()>b.getValue()){
                        return -1;
                    } else if (a.getValue().equals(b.getValue())) {
                        if (a.getKey().length()<b.getKey().length()){
                            return -1;
                        }
                    } else if (a.getValue()==b.getValue()
                            &&a.getKey().length()==a.getKey().length()) {
                        if (a.getKey().charAt(0)<b.getKey().charAt(0)){
                            return -1;
                        }
                    }
                    return 0;
                })
                .forEach(System.out::println);
//                .map(x->x.getKey())
//                .collect(Collectors.joining(" ")));

        System.out.println("正确输出： in in eht eht My is not adry ehosu eirsst");
    }
    // 第二版
    @Test
    void t1(){
        String s1 = "My sister is in the house not in the yard";

        // 单词内部调整：对每个单词字母重新按字典序排序；
        List<String> collect = Arrays.stream(s1.split(" "))
                .map(a -> a.chars()
                        .sorted()
                        .mapToObj(i -> String.valueOf((char) i))
                        .collect(Collectors.joining()))
                .collect(Collectors.toList());

        // 添加至hashmap，计算单词出现次数
        Map<String, Integer> map = collect.stream().collect(Collectors.toMap(k -> k, v -> 1, (a, b) -> a + 1));

        // 生成最终字符串
        String str = collect.stream()
                .sorted((a, b) -> {
                    // 统计每个单词出现的次数，并按次数降序排列；
                    if (map.get(a) > map.get(b)) {
                        return -1;

                    // 次数相同时，按单词长度升序排列；
                    } else if (map.get(a).equals(map.get(b))) {
                        if (a.length() < b.length()) {
                            return -1;
                        }

                    // 次数和单词长度均相同时，按字典序升序排列。
                    } else if (map.get(a) == map.get(b)
                            && a.length() == a.length()) {
                        if (a.charAt(0) < b.charAt(0)) {
                            return -1;
                        }
                    }
                    return 0;
                })
                // 生成字符串，每个单词以一个空格分隔。
                .collect(Collectors.joining(" "));
        System.out.println("结果： "+str);

        System.out.println("正确输出： in in eht eht My is not adry ehosu eirsst");
    }
}

总结

第一版想一次流到底，但是hashmap的entrySet的流会导致key唯一的问题，也就是字符串中两个in，只能输出一个。表演失败。

写不出来也不用太纠结，毕竟思想才是灵魂。