如何重构嵌套切换案例（Java）或何时（Kotlin）？

Question

[要求：我需要编写一个可以与多个玩家一起玩的Jo-Ken-Pô游戏。有5个角色（SPOCK，剪刀，纸张，石头和蜥蜴）。我可以通过这两个链接的when / switch来完成此操作（波纹管代码使用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>

用户模型

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语句：减少以比较彼此的播放类型，并判断是否有多个我编码的获胜者.count分开

2-当然，用lambda编码两个链接的开关可能会有更优雅和可读的方法，但是我什至可以尝试的第一步

PS：代码是Kotlin，但是如果您用Java指向任何内容，我都可以轻松地将其翻译为kotlin。任何技巧或建议，都将高度赞赏工厂的重构]

任何有兴趣让游戏可以免费从https://github.com/jimisdrpc/games.git克隆的人>

[要求：我需要编写一个可以与多个玩家一起玩的Jo-Ken-Pô游戏。有5个角色（SPOCK，剪刀，纸张，石头和蜥蜴）。我可以通过以下两个链接来完成它，当/ ...

Answer 1

switch inside switch结构看起来很难看，你是对的。

以这种方式思考：每个PlayType都从另一个中获胜。而且此信息看起来像配置，因此可以以声明的方式进行描述，如下所示：