Кременский

build.gradle.kts

@@ -1,5 +1,6 @@
 plugins {
     id("java")
+    id("application")
 }
 
 group = "ru.urfu"
@@ -10,10 +11,15 @@ repositories {
 }
 
 dependencies {
+    implementation("org.jfree:jfreechart:1.5.6")
     testImplementation(platform("org.junit:junit-bom:5.10.0"))
     testImplementation("org.junit.jupiter:junit-jupiter")
 }
 
 tasks.test {
     useJUnitPlatform()
+}
+
+application {
+    mainClass = "ru.urfu.Main"
 }

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

@@ -1,17 +1,27 @@
 package ru.urfu;
 
+import ru.urfu.drawer.ChartDrawer;
+import ru.urfu.model.Player;
+import ru.urfu.parser.CsvParser;
+
+import javax.swing.*;
+import java.util.List;
+
 //TIP To <b>Run</b> code, press <shortcut actionId="Run"/> or
 // click the <icon src="AllIcons.Actions.Execute"/> icon in the gutter.
 public class Main {
     public static void main(String[] args) {
-        //TIP Press <shortcut actionId="ShowIntentionActions"/> with your caret at the highlighted text
-        // to see how GIGA IDE suggests fixing it.
-        System.out.printf("Hello and welcome!");
+        JFrame frame = new JFrame();
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        frame.setSize(400, 400);
+
+        List<Player> players = CsvParser.parseCsvToList("src/main/resources/fakePlayers.csv");
+
+        // Resolver playerResolver = new Resolver(players);
+
+        ChartDrawer chartDrawer = new ChartDrawer(players);
+        frame.add(chartDrawer.getChartPanel());
 
-        for (int i = 1; i <= 5; i++) {
-            //TIP Press <shortcut actionId="Debug"/> to start debugging your code. We have set one <icon src="AllIcons.Debugger.Db_set_breakpoint"/> breakpoint
-            // for you, but you can always add more by pressing <shortcut actionId="ToggleLineBreakpoint"/>.
-            System.out.println("i = " + i);
-        }
+        frame.setVisible(true);
     }
 }

src/main/java/ru/urfu/drawer/ChartData.java

@@ -0,0 +1,3 @@
+package ru.urfu.drawer;
+
+public record ChartData(String team, Integer sum) {}

src/main/java/ru/urfu/drawer/ChartDrawer.java

@@ -0,0 +1,62 @@
+package ru.urfu.drawer;
+
+import org.jfree.chart.ChartFactory;
+import org.jfree.chart.ChartPanel;
+import org.jfree.chart.JFreeChart;
+import org.jfree.chart.axis.NumberAxis;
+import org.jfree.chart.block.BlockBorder;
+import org.jfree.chart.plot.CategoryPlot;
+import org.jfree.chart.renderer.category.BarRenderer;
+import ru.urfu.model.Player;
+import ru.urfu.resolver.Resolver;
+
+import javax.swing.*;
+import java.awt.*;
+import java.util.List;
+
+public class ChartDrawer {
+
+    private final List<Player> players;
+
+    public ChartDrawer(List<Player> players) {
+        this.players = players;
+    }
+
+    private JFreeChart getStatisticsChart() {
+        Resolver chartDataResolver = new Resolver(players);
+        List<ChartData> chartData = chartDataResolver.getTopNTeams();
+
+        JFreeChart chart = ChartFactory.createBarChart(
+                "топ-10 команд с наивысшей суммарной трансферной стоимостью",
+                "команда",
+                "стоймость, %",
+                new DatasetMapper().map(chartData)
+        );
+        chart.setBackgroundPaint(Color.white);
+
+        CategoryPlot plot = (CategoryPlot) chart.getPlot();
+
+        NumberAxis rangeAxis = (NumberAxis) plot.getRangeAxis();
+        rangeAxis.setStandardTickUnits(NumberAxis.createIntegerTickUnits());
+
+        BarRenderer renderer = (BarRenderer) plot.getRenderer();
+        renderer.setDrawBarOutline(false);
+
+        chart.getLegend().setFrame(BlockBorder.NONE);
+
+        return chart;
+    }
+
+    public JPanel getChartPanel() {
+
+        JFreeChart chart = getStatisticsChart();
+
+        ChartPanel panel = new ChartPanel(chart);
+        panel.setFillZoomRectangle(true);
+        panel.setMouseWheelEnabled(true);
+        panel.setPreferredSize(new Dimension(600, 300));
+
+        return panel;
+    }
+
+}

src/main/java/ru/urfu/drawer/DatasetMapper.java

@@ -0,0 +1,16 @@
+package ru.urfu.drawer;
+
+import org.jfree.data.category.DefaultCategoryDataset;
+
+import java.util.List;
+
+public class DatasetMapper  {
+    public DefaultCategoryDataset map(List<ChartData> chartData) {
+        DefaultCategoryDataset dataset = new DefaultCategoryDataset();
+
+        for (ChartData entry : chartData) {
+            dataset.addValue(entry.sum(), entry.team(), entry.team());
+        }
+        return dataset;
+    }
+}

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

@@ -0,0 +1,12 @@
+package ru.urfu.model;
+
+public record Player(
+        String name,
+        Role position,
+        String agency,
+        int goals,
+        String nation,
+        int cost,
+        String team,
+        int redCards
+){}

src/main/java/ru/urfu/model/Role.java

@@ -0,0 +1,8 @@
+package ru.urfu.model;
+
+public enum Role{
+    GOALKEEPER,
+    DEFENDER,
+    MIDFIELD,
+    FORWARD
+}

src/main/java/ru/urfu/parser/CsvParser.java

@@ -0,0 +1,47 @@
+package ru.urfu.parser;
+
+import ru.urfu.model.Player;
+import ru.urfu.model.Role;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Scanner;
+
+public class CsvParser {
+
+    public static ArrayList<Player> parseCsvToList(String pathString) {
+        Path path = Paths.get(pathString);
+        Scanner scanner = getScanner(path);
+        var list = new ArrayList<Player>();
+        scanner.nextLine();
+        while (scanner.hasNextLine()) {
+            list.add(parsePlayerRow(scanner.nextLine()));
+        }
+
+        return list;
+    }
+
+    private static Player parsePlayerRow(String row) {
+        var cells = row.split(";");
+        return new Player(
+                cells[0],
+                Role.valueOf(cells[3]),
+                cells[5],
+                Integer.parseInt(cells[8]),
+                cells[4],
+                Integer.parseInt(cells[6]),
+                cells[1],
+                Integer.parseInt(cells[11])
+        );
+    }
+
+    private static Scanner getScanner(Path path) {
+        try {
+            return new Scanner(path);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

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

@@ -0,0 +1,85 @@
+package ru.urfu.resolver;
+
+
+import ru.urfu.drawer.ChartData;
+import ru.urfu.model.Player;
+import ru.urfu.model.Role;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class Resolver implements IResolver {
+    private final List<Player> players;
+
+    public Resolver(List<Player> players) {
+        this.players = players;
+    }
+
+
+    @Override
+    public int getCountWithoutAgency() {
+        return (int)players.stream().filter(player -> player.agency().isEmpty()).
+                count();
+    }
+
+    @Override
+    public int getMaxDefenderGoalsCount() {
+        return players.stream()
+                .filter(player -> player.position() == Role.DEFENDER)
+                .mapToInt(Player::goals).max().orElse(0);
+    }
+
+    @Override
+    public String getTheExpensiveGermanPlayerPosition() {
+        int maxCost = players.stream()
+                .filter(player -> player.nation().equals("Germany"))
+                .mapToInt(Player::cost).max().orElse(0);
+        Role position = players.stream()
+                .filter(player -> player.nation().equals("Germany"))
+                .filter(player -> player.cost() == maxCost)
+                .findAny().get().position();
+        switch (position) {
+            case FORWARD -> {
+                return "Нападающий";
+            }
+            case DEFENDER -> {
+                return "Защитник";
+            }
+            case GOALKEEPER -> {
+                return "Вратарь";
+            }
+            case MIDFIELD -> {
+                return "Полузащитник";
+            }
+        }
+        return "Error";
+    }
+
+    @Override
+    public String getTheRudestTeam() {
+        Map<String, List<Player>> grouped = players.stream()
+                .collect(Collectors.groupingBy(Player::team));
+
+        Map.Entry<String, List<Player>> maxEntry = grouped.entrySet().stream()
+                .max(Comparator.comparingDouble(entry ->
+                        entry.getValue().stream()
+                                .mapToInt(Player::redCards)
+                                .average()
+                                .orElse(0)
+                ))
+                .orElse(null);
+
+        return maxEntry != null ? maxEntry.getKey() : "";
+    }
+
+    public List<ChartData> getTopNTeams() {
+        Map<String, Integer> team_sum = players.stream().collect(Collectors.groupingBy(Player::team,Collectors.summingInt(Player::cost)));
+        List<ChartData> data = team_sum.entrySet().stream()
+                .map(entry -> new ChartData(entry.getKey(),entry.getValue()))
+                .toList();
+
+        return data.stream().sorted((c1,c2) -> c2.sum().compareTo(c1.sum())).limit(10).collect(Collectors.toList());
+    }
+}

src/main/java/ru/urfu/resolver/ResolverTest.java

@@ -0,0 +1,63 @@
+package ru.urfu.resolver;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import ru.urfu.drawer.ChartData;
+import ru.urfu.model.Player;
+import ru.urfu.model.Role;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.List;
+
+
+class ResolverTest {
+
+    private Resolver resolver;
+
+    @BeforeEach
+    void setUp() {
+        List<Player> players = List.of(
+                new Player("Player1", Role.DEFENDER, "Agency1", 5, "Germany", 10000, "TeamA", 1),
+                new Player("Player2", Role.MIDFIELD, null, 3, "Spain", 8000, "TeamB", 0),
+                new Player("Player3", Role.FORWARD, "Agency2", 10, "Germany", 20000, "TeamC", 2),
+                new Player("Player4", Role.GOALKEEPER, "Agency3", 0, "France", 5000, "TeamA", 4),
+                new Player("Player5", Role.DEFENDER, "Agency4", 7, "Italy", 12000, "TeamB", 1)
+        );
+
+        resolver = new Resolver(players);
+    }
+
+    @Test
+    void testGetCountWithoutAgency() {
+        assertEquals(1, resolver.getCountWithoutAgency());
+    }
+
+    @Test
+    void testGetMaxDefenderGoalsCount() {
+        assertEquals(7, resolver.getMaxDefenderGoalsCount());
+    }
+
+    @Test
+    void testGetTheExpensiveGermanPlayerPosition() {
+        assertEquals("Нападающий", resolver.getTheExpensiveGermanPlayerPosition());
+    }
+
+    @Test
+    void testGetTheRudestTeam() {
+        assertEquals("TeamA", resolver.getTheRudestTeam());
+    }
+
+    @Test
+    void testGetTopNTeams() {
+        List<ChartData> topTeams = resolver.getTopNTeams();
+        assertEquals(3, topTeams.size());
+
+        ChartData teamC = new ChartData("TeamC", 20000);
+        ChartData teamB = new ChartData("TeamB", 20000);
+        ChartData teamA = new ChartData("TeamA", 15000);
+        assertTrue(topTeams.contains(teamA));
+        assertTrue(topTeams.contains(teamB));
+        assertTrue(topTeams.contains(teamC));
+
+    }
+}