如何重构嵌套的 switch-case (Java) 或 when (Kotlin)？

Question

要求：我需要编写一个可以与多个玩家一起玩的 Jo-Ken-Pô 游戏。 有5个角色（SPOCK、剪刀、纸、石头和蜥蜴）。 我可以用这两个链接的 when/switches 来完成它（下面的代码使用 when() 因为它在 Kotlin 但同样的想法可以在 Java 中使用 switch 应用）

  when (u1.play) {
        PlayType.SPOCK -> when (u2.play) {
            //SPOCK WINS
            PlayType.TESOURA -> return u1
            PlayType.PEDRA -> return u1
            //SPOCK LOSES
            PlayType.PAPEL -> return u2
            PlayType.LAGARTO -> return u2
        }
        PlayType.TESOURA -> when (u2.play) {
            //TESOURA (scissors) WINS
            PlayType.PAPEL -> return u1
            PlayType.LAGARTO -> return u1
            //TESOURA (scissors) LOSES
            PlayType.SPOCK -> return u2
            PlayType.PEDRA -> return u2
        }
        PlayType.PAPEL -> when (u2.play) {
            //PAPEL (paper) WINS
            PlayType.SPOCK -> return u1
            PlayType.PEDRA -> return u1
            //PAPEL (paper) LOSES
            PlayType.TESOURA -> return u2
            PlayType.LAGARTO -> return u2
        }
        PlayType.PEDRA -> when (u2.play) {
            //PEDRA (stone) WINS
            PlayType.LAGARTO -> return u1
            PlayType.TESOURA -> return u1
            //PEDRA (stone) LOSES
            PlayType.SPOCK -> return u2
            PlayType.PAPEL -> return u2
        }
        PlayType.LAGARTO -> when (u2.play) {
            //LAGARTO (lizard) WINS
            PlayType.SPOCK -> return u1
            PlayType.PAPEL -> return u1
            //LAGARTO (lizard) LOSES
            PlayType.TESOURA -> return u2
            PlayType.PEDRA -> return u2
        }
    }

我已经阅读了几个小时，试图找到如何使用 lambda 使这段代码更优雅，但我找不到任何线索。 拜托，任何帮助都会非常受欢迎。

我将在这里粘贴整个代码。 尽管您看到我至少使用 lambda 来调用该方法，但我肯定缺少 lambda 的一些强大功能，并且几乎按照 Java 7 < 经典方式进行编码。

所有用户都来自 H2 数据库。 这是存储库

import com.mycomp.jokenpo.model.User
import org.springframework.data.repository.CrudRepository

interface UserRepository : CrudRepository<User, Long>

用户 model

import com.mycomp.jokenpo.enums.PlayType
import javax.persistence.*


@Entity
data class User(
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        val id: Long,

        @Column(nullable = false)
        val name: String,

        @Enumerated
        @Column(nullable = false)
        val play: PlayType

)

枚举播放类型

enum class PlayType(val value: Int) {
    SPOCK(1), TESOURA(2), LAGARTO(3), PAPEL(4), PEDRA(5)
}

服务* 这里有问题 *

import com.mycomp.jokenpo.enums.PlayType
import com.mycomp.jokenpo.model.User
import com.mycomp.jokenpo.respository.UserRepository
import org.springframework.stereotype.Component

@Component
class GameService(private val userRepository: UserRepository) {

    fun returnWinnerBetweenTwoPlayers(u1: User, u2: User): User {

        when (u1.play) {
            PlayType.SPOCK -> when (u2.play) {
                //SPOCK WINS
                PlayType.TESOURA -> return u1
                PlayType.PEDRA -> return u1
                //SPOCK LOSES
                PlayType.PAPEL -> return u2
                PlayType.LAGARTO -> return u2
            }
            PlayType.TESOURA -> when (u2.play) {
                //TESOURA (scissors) WINS
                PlayType.PAPEL -> return u1
                PlayType.LAGARTO -> return u1
                //TESOURA (scissors) LOSES
                PlayType.SPOCK -> return u2
                PlayType.PEDRA -> return u2
            }
            PlayType.PAPEL -> when (u2.play) {
                //PAPEL (paper) WINS
                PlayType.SPOCK -> return u1
                PlayType.PEDRA -> return u1
                //PAPEL (paper) LOSES
                PlayType.TESOURA -> return u2
                PlayType.LAGARTO -> return u2
            }
            PlayType.PEDRA -> when (u2.play) {
                //PEDRA (stone) WINS
                PlayType.LAGARTO -> return u1
                PlayType.TESOURA -> return u1
                //PEDRA (stone) LOSES
                PlayType.SPOCK -> return u2
                PlayType.PAPEL -> return u2
            }
            PlayType.LAGARTO -> when (u2.play) {
                //LAGARTO (lizard) WINS
                PlayType.SPOCK -> return u1
                PlayType.PAPEL -> return u1
                //LAGARTO (lizard) LOSES
                PlayType.TESOURA -> return u2
                PlayType.PEDRA -> return u2
            }
        }
        return u1
    }

    fun playGameWithAll(): User? {
        val allUsers = userRepository.findAll().toList()

        val winner = allUsers.reduce { a, b ->
            returnWinnerBetweenTwoPlayers(a, b)
        }

        if (allUsers.filter { player -> player.play == winner.play }
                        .count() == 1)
            return winner
        else
            return null

    }
}

上面的代码按预期工作，但我有两个原因，我的代码很糟糕：

1 - 我拆分了两个小的 lambda 语句：减少以比较彼此的游戏类型，只是为了计算我编码的获胜者是否不止一个。计数分开

2 - 当然可能有一种更优雅、更易读的方式来使用 lambda 对两个链式开关进行编码，但我什至可以尝试第一步

PS：代码是 Kotlin 但如果您在 Java 中指出任何内容，我可以轻松地将其转换为 kotlin。 任何技巧或建议如何重构将受到高度赞赏

任何有兴趣免费获得游戏填充的人都可以从https://github.com/jimisdrpc/games.git克隆

***在米哈伊尔回答后编辑

主.java

    package poc;

    import java.util.List;
    import java.util.Map;
    import java.util.Optional;
    import java.util.Set;

    public class Main {

        public static void main(String[] args) {

            //Fake returned list from database
            List<User> usersList = List.of(
                    new User(1L, "Jimis", PlayType.LAGARTO),
                    new User(2L, "Drpc", PlayType.PAPEL));


            //User winnerUser = returnWinnerBetweenTwoPlayers(usersList.get(0), usersList.get(1));

            Optional<User> winnerUser  = usersList.stream().reduce( (a, b) ->
            returnWinnerBetweenTwoPlayers(a , b));

            System.out.print(winnerUser);

        }

        //Trying to refactoring from classical switch to some structure for using with lambda
        private final static Map<PlayType, Set<PlayType>> CONFIG = Map.of(
                PlayType.SPOCK,
                    Set.of(PlayType.TESOURA, PlayType.PEDRA), 
                PlayType.TESOURA, 
                    Set.of(PlayType.PAPEL, PlayType.LAGARTO)

        );

        private static User returnWinnerBetweenTwoPlayers(User u1, User u2) {
/// ****** Exception next line
            if (CONFIG.get(u1.getPlay()).contains(u2.getPlay())) {
                return u1;
            }
            return u2;
        }
    }

用户 model

package poc;

public class User {

    Long id;
    String name;
    PlayType play;

    public User(Long id, String name, PlayType play) {
        super();
        this.id = id;
        this.name = name;
        this.play = play;
    }

//... getters/setters removed
}

播放类型枚举

package poc;

public enum PlayType {
    SPOCK,
    TESOURA, 
    PEDRA, 
    PAPEL,
    LAGARTO;
}

运行此部分时出现异常 CONFIG.get(u1.getPlay()).contains(u2.getPlay()

Exception in thread "main" java.lang.NullPointerException
    at moduleinfo/poc.Main.returnWinnerBetweenTwoPlayers(Main.java:39)
    at moduleinfo/poc.Main.lambda$0(Main.java:21)
    at java.base/java.util.stream.ReduceOps$2ReducingSink.accept(ReduceOps.java:123)
    at java.base/java.util.AbstractList$RandomAccessSpliterator.forEachRemaining(AbstractList.java:720)
    at java.base/java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:484)
    at java.base/java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:474)
    at java.base/java.util.stream.ReduceOps$ReduceOp.evaluateSequential(ReduceOps.java:913)
    at java.base/java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234)
    at java.base/java.util.stream.ReferencePipeline.reduce(ReferencePipeline.java:558)
    at moduleinfo/poc.Main.main(Main.java:20)

如果我尝试在没有 stream().reduce() 的情况下进行简化和调用，我会在同一点遇到这个问题

Exception in thread "main" java.lang.NullPointerException
    at moduleinfo/poc.Main.returnWinnerBetweenTwoPlayers(Main.java:49)
    at moduleinfo/poc.Main.main(Main.java:19)

***最终解决方案

public class Main {

    public static void main(String[] args) {

        //Fake returned list from database
        List<User> usersList = List.of(
                new User(1L, "Jogador 1", PlayType.PEDRA),
                new User(2L, "Jogador 2", PlayType.TESOURA),
                new User(3L, "Jogador 3", PlayType.TESOURA),
                new User(4L, "Jogador 4", PlayType.SPOCK)
                );


        Optional<User> winnerUser  = usersList.stream().reduce( (a, b) ->
            returnWinnerBetweenTwoPlayers(a , b));

        System.out.print(winnerUser.get().getName());

    }

    private final static Map<PlayType, Set<PlayType>> CONFIG = Map.of(
            PlayType.SPOCK,
                Set.of(PlayType.TESOURA, PlayType.PEDRA), 
            PlayType.TESOURA, 
                Set.of(PlayType.PAPEL, PlayType.LAGARTO),
            PlayType.PAPEL, 
                Set.of(PlayType.SPOCK, PlayType.PEDRA),
            PlayType.PEDRA, 
                Set.of(PlayType.LAGARTO, PlayType.TESOURA),
            PlayType.LAGARTO, 
                Set.of(PlayType.SPOCK, PlayType.PAPEL)
    );

    private static User returnWinnerBetweenTwoPlayers(User u1, User u2) {
        if (CONFIG.get(u1.getPlay()).contains(u2.getPlay())) {
            return u1;
        }
        return u2;
    }
}

Answer 1

switch inside switch看起来真的很难阅读，你是对的。

可以这样想：每个 PlayType 都从其他一些 PlayType 中获胜。 而且这些信息看起来像一个配置，所以可以用声明的方式来描述，像这样：

• SPOCK 战胜 TESOURA & PEDRA
• TESOURA 战胜 PAPEL & LAGATO
• ETC

所以你可以定义一个Map<PlayType, Set<PlayType>>并验证u2.play is contained by map.get(u1.play)

UPD。 代码示例（java，用记事本编写，因此可能包含一些语法错误）

class GameService {
  private final static Map<PlayType, Set<PlayType>> CONFIG = Map.of(
    PlayType.SPOCK, Set.of(PlayType.TESOURA, PlayType.PEDRA),
    PlayType.TESOURA, Set.of(PlayType.PAPEL, PlayType.LAGARTO)
    //etc
  );

  function User returnWinnerBetweenTwoPlayers(User u1, User u2){
    if (CONFIG.get(u1.getType()).contains(u2.getType()){
      return u1;
    }
    return u2;
  } 
}