_Imaev

build.gradle.kts

@@ -1,6 +1,7 @@
 plugins {
     id("java")
     id("application")
+    kotlin("jvm")
 }
 
 group = "ru.urfu"
@@ -11,14 +12,24 @@ repositories {
 }
 
 dependencies {
+    implementation(kotlin("stdlib-jdk8"))
+
+    implementation("org.jfree:jfreechart:1.5.3")
+    testImplementation(kotlin("test"))
     testImplementation(platform("org.junit:junit-bom:5.10.0"))
     testImplementation("org.junit.jupiter:junit-jupiter")
+    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine")
+
 }
 
 tasks.test {
     useJUnitPlatform()
 }
 
 application {
-    mainClass = "ru.urfu.Main"
-}
+    mainClass = "ru.urfu.MainKt"
+}
+
+kotlin {
+    jvmToolchain(22)
+}

settings.gradle.kts

@@ -1,2 +1,12 @@
+pluginManagement {
+    plugins {
+        kotlin("jvm") version "2.2.0"
+    }
+
+}
+plugins {
+    id("org.gradle.toolchains.foojay-resolver-convention") version "0.8.0"
+}
+
 rootProject.name = "Java2025_2"
 

src/main/java/ru/urfu/Main.kt

@@ -0,0 +1,18 @@
+package ru.urfu
+
+import ru.urfu.loader.PlayerLoader
+import ru.urfu.resolver.Resolver
+import ru.urfu.visual.ChartDrawer
+
+fun main() {
+    val path = "src/main/resources/fakePlayers.csv"
+    val players = PlayerLoader.loadPlayersFromCSV(path)
+    val resolver = Resolver(players)
+
+    println("Number of players without an agency: ${resolver.getCountWithoutAgency()}")
+    println("Maximum number of goals scored by a defender: ${resolver.getMaxDefenderGoalsCount()}")
+    println("Position of the most expensive German player: ${resolver.getTheExpensiveGermanPlayerPosition()}")
+    println("Team with the highest average number of red cards per player: ${resolver.getTheRudestTeam()}")
+
+    ChartDrawer.drawGoalsVsValue(players)
+}

src/main/java/ru/urfu/loader/PlayerLoader.kt

@@ -0,0 +1,30 @@
+package ru.urfu.loader
+
+import ru.urfu.model.Player
+import java.io.File
+
+object PlayerLoader {
+
+    fun loadPlayersFromCSV(path: String): List<Player> {
+        return File(path).readLines()
+            .drop(1) // Пропускаем заголовок
+            .map { line ->
+                val tokens = line.split(";").map { it.trim() }
+
+                Player(
+                    name = tokens[0],
+                    team = tokens[1],
+                    city = tokens[2],
+                    position = tokens[3],
+                    nationality = tokens[4],
+                    agency = if (tokens[5].isBlank()) null else tokens[5],
+                    transferCost = tokens[6].replace("_", "").replace("€", "").toInt(),
+                    participations = tokens[7].toInt(),
+                    goals = tokens[8].toInt(),
+                    assists = tokens[9].toInt(),
+                    yellowCards = tokens[10].toInt(),
+                    redCards = tokens[11].toInt()
+                )
+            }
+    }
+}

src/main/java/ru/urfu/model/Player.kt

@@ -0,0 +1,16 @@
+package ru.urfu.model
+
+data class Player(
+    val name: String,
+    val team: String,
+    val city: String,
+    val position: String,
+    val nationality: String,
+    val agency: String?,
+    val transferCost: Int,
+    val participations: Int,
+    val goals: Int,
+    val assists: Int,
+    val yellowCards: Int,
+    val redCards: Int
+)

src/main/java/ru/urfu/resolver/Resolver.kt

@@ -0,0 +1,34 @@
+package ru.urfu.resolver
+
+import ru.urfu.model.Player
+
+class Resolver(private val players: List<Player>) : IResolver {
+
+    override fun getCountWithoutAgency(): Int {
+        return players.count { it.agency == null }
+    }
+
+    override fun getMaxDefenderGoalsCount(): Int {
+        return players
+            .filter { it.position.equals("DEFENDER", ignoreCase = true) }
+            .maxOfOrNull { it.goals } ?: 0
+    }
+
+    override fun getTheExpensiveGermanPlayerPosition(): String {
+        return players
+            .filter { it.nationality.equals("Germany", ignoreCase = true) }
+            .maxByOrNull { it.transferCost }
+            ?.position
+            ?: "Not found"
+    }
+
+    override fun getTheRudestTeam(): String {
+        return players
+            .groupBy { "${it.team} (${it.city})" }
+            .mapValues { (_, teamPlayers) ->
+                teamPlayers.map { it.redCards }.average()
+            }
+            .maxByOrNull { it.value }
+            ?.key ?: "Not found"
+    }
+}

src/main/java/ru/urfu/visual/ChartDrawer.kt

@@ -0,0 +1,38 @@
+package ru.urfu.visual
+
+import org.jfree.chart.ChartFactory
+import org.jfree.chart.ChartPanel
+import org.jfree.chart.JFreeChart
+import org.jfree.chart.plot.PlotOrientation
+import org.jfree.data.xy.XYSeries
+import org.jfree.data.xy.XYSeriesCollection
+import ru.urfu.model.Player
+import javax.swing.JFrame
+
+object ChartDrawer {
+    fun asdasdGoalsVsValue(players: List<Player>) {
+        val series = XYSeries("FORWARD")
+
+        players.filter { it.position.equals("FORWARD", ignoreCase = true) }
+            .forEach { player ->
+                series.add(player.transferCost.toDouble(), player.goals.toDouble())
+            }
+
+        val dataset = XYSeriesCollection(series)
+
+        val chart: JFreeChart = ChartFactory.createScatterPlot(
+            "Голы vs Трансферная стоимость (FORWARD)",
+            "Трансферная стоимость (€)",
+            "Голы",
+            dataset,
+            PlotOrientation.VERTICAL,
+            true, true, false
+        )
+
+        val frame = JFrame("График")
+        frame.contentPane = ChartPanel(chart)
+        frame.defaultCloseOperation = JFrame.EXIT_ON_CLOSE
+        frame.pack()
+        frame.isVisible = true
+    }
+}

src/test/kotlin/ru/urfu/tests/ResolverTest.kt

@@ -0,0 +1,39 @@
+package ru.urfu.tests
+
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+import ru.urfu.model.Player
+import ru.urfu.resolver.Resolver
+
+
+
+class ResolverTest {
+
+    private val testPlayers = listOf(
+        Player("A", "TeamA", "CityA", "Defender", "Germany", null, 1000000, 10, 2, 1, 1, 1),
+        Player("B", "TeamB", "CityB", "Forward", "Russia", "Agency1", 8000000, 20, 10, 3, 0, 0),
+        Player("C", "TeamC", "CityC", "Goalkeeper", "Germany", "Agency2", 12000000, 15, 0, 1, 2, 0)
+    )
+
+    private val resolver = Resolver(testPlayers)
+
+    @Test
+    fun testCountWithoutAgency() {
+        assertEquals(1, resolver.getCountWithoutAgency())
+    }
+
+    @Test
+    fun testMaxDefenderGoals() {
+        assertEquals(2, resolver.getMaxDefenderGoalsCount())
+    }
+
+    @Test
+    fun testMostExpensiveGermanPlayerPosition() {
+        assertEquals("Goalkeeper", resolver.getTheExpensiveGermanPlayerPosition())
+    }
+
+    @Test
+    fun testRudestTeam() {
+        assertEquals("TeamA (CityA)", resolver.getTheRudestTeam())
+    }
+}