Лежнин

build.gradle.kts

@@ -10,6 +10,8 @@ repositories {
 }
 
 dependencies {
+    // https://mvnrepository.com/artifact/org.jfree/jfreechart
+    implementation("org.jfree:jfreechart:1.5.6")
     testImplementation(platform("org.junit:junit-bom:5.10.0"))
     testImplementation("org.junit.jupiter:junit-jupiter")
 }

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

@@ -1,17 +1,30 @@
 package ru.urfu;
 
+import ru.urfu.io.IParser;
+import ru.urfu.io.CsvPlayerParser;
+import ru.urfu.model.Player;
+import ru.urfu.resolver.PlayerResolver;
+import ru.urfu.visualization.ChartDrawer;
+
+import javax.swing.*;
+import java.io.IOException;
+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!");
+    public static void main(String[] args) throws IOException {
+        JFrame frame = new JFrame();
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        frame.setSize(400, 400);
+
+        IParser<Player> parser = new CsvPlayerParser();
+        List<Player> players = parser.parse("src/main/resources/fakePlayers.csv");
+        PlayerResolver playerResolver = new PlayerResolver(players);
+
+        ChartDrawer chartDrawer = new ChartDrawer(playerResolver);
+        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/exception/ValueNotFoundException.java

@@ -0,0 +1,7 @@
+package ru.urfu.exception;
+
+public class ValueNotFoundException extends RuntimeException {
+    public ValueNotFoundException(String message) {
+        super(message);
+    }
+}

src/main/java/ru/urfu/io/CsvPlayerParser.java

@@ -0,0 +1,55 @@
+package ru.urfu.io;
+
+import ru.urfu.mapper.PlayerMapper;
+import ru.urfu.model.Player;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+public class CsvPlayerParser implements IParser<Player> {
+
+    private Scanner getScanner(Path path) throws IOException {
+        try {
+            return new Scanner(path);
+        } catch (IOException e) {
+            throw new IOException("Ошибка при чтении CSV-файла: " + e.getClass().getName() + ": " + e.getMessage());
+        }
+    }
+
+    public List<String> readFile(String pathString) throws IOException {
+        Path path = Paths.get(pathString);
+        Scanner scanner = getScanner(path);
+
+        List<String> rows = new ArrayList<>();
+
+        boolean isHeaderSkipped = false;
+
+        while (scanner.hasNext()) {
+            if (!isHeaderSkipped) {
+                isHeaderSkipped = true;
+                scanner.nextLine();
+                continue;
+            }
+            rows.add(scanner.nextLine());
+        }
+
+        return rows;
+    }
+
+    public List<Player> parse(String pathString) throws IOException {
+        List<String> rows = readFile(pathString);
+        List<Player> players = new ArrayList<>();
+
+        PlayerMapper mapper = new PlayerMapper();
+
+        for (String row : rows) {
+            players.add(mapper.map(row));
+        }
+
+        return players;
+    }
+}

src/main/java/ru/urfu/io/IParser.java

@@ -0,0 +1,11 @@
+package ru.urfu.io;
+
+import java.io.IOException;
+import java.util.List;
+
+public interface IParser<T> {
+
+    List<String> readFile(String pathString) throws IOException;
+
+    List<T> parse(String pathString) throws IOException;
+}

src/main/java/ru/urfu/mapper/IMapper.java

@@ -0,0 +1,5 @@
+package ru.urfu.mapper;
+
+public interface IMapper<Data, Domain> {
+    Domain map(Data data);
+}

src/main/java/ru/urfu/mapper/PlayerMapper.java

@@ -0,0 +1,26 @@
+package ru.urfu.mapper;
+
+import ru.urfu.model.Player;
+import ru.urfu.model.PlayerBuilder;
+import ru.urfu.model.Position;
+
+public class PlayerMapper implements IMapper<String, Player> {
+    @Override
+    public Player map(String s) {
+        String[] data = s.split(";");
+        return new PlayerBuilder()
+                .name(data[0])
+                .team(data[1])
+                .city(data[2])
+                .position(Position.valueOf(data[3]))
+                .nationality(data[4])
+                .agency(data[5])
+                .transferCost(Integer.parseInt(data[6]))
+                .participations(Integer.parseInt(data[7]))
+                .goals(Integer.parseInt(data[8]))
+                .assists(Integer.parseInt(data[9]))
+                .yellowCards(Integer.parseInt(data[10]))
+                .redCards(Integer.parseInt(data[11]))
+                .build();
+    }
+}

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

@@ -0,0 +1,15 @@
+package ru.urfu.model;
+
+public record Player(
+        String name,
+        String team,
+        String city,
+        Position position,
+        String nationality,
+        String agency,
+        int transferCost,
+        int participations,
+        int goals,
+        int assists,
+        int yellowCards,
+        int redCards) {}

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

@@ -0,0 +1,93 @@
+package ru.urfu.model;
+
+public class PlayerBuilder {
+    private String name;
+    private String team;
+    private String city;
+    private Position position;
+    private String nationality;
+    private String agency;
+    private int transferCost;
+    private int participations;
+    private int goals;
+    private int assists;
+    private int yellowCards;
+    private int redCards;
+
+    public PlayerBuilder name(String name) {
+        this.name = name;
+        return this;
+    }
+
+    public PlayerBuilder team(String team) {
+        this.team = team;
+        return this;
+    }
+
+    public PlayerBuilder city(String city) {
+        this.city = city;
+        return this;
+    }
+
+    public PlayerBuilder position(Position position) {
+        this.position = position;
+        return this;
+    }
+
+    public PlayerBuilder nationality(String nationality) {
+        this.nationality = nationality;
+        return this;
+    }
+
+    public PlayerBuilder agency(String agency) {
+        this.agency = agency;
+        return this;
+    }
+
+    public PlayerBuilder transferCost(int transferCost) {
+        this.transferCost = transferCost;
+        return this;
+    }
+
+    public PlayerBuilder participations(int participations) {
+        this.participations = participations;
+        return this;
+    }
+
+    public PlayerBuilder goals(int goals) {
+        this.goals = goals;
+        return this;
+    }
+
+    public PlayerBuilder assists(int assists) {
+        this.assists = assists;
+        return this;
+    }
+
+    public PlayerBuilder yellowCards(int yellowCards) {
+        this.yellowCards = yellowCards;
+        return this;
+    }
+
+    public PlayerBuilder redCards(int redCards) {
+        this.redCards = redCards;
+        return this;
+    }
+
+    public Player build() {
+        return new Player(
+                this.name,
+                this.team,
+                this.city,
+                this.position,
+                this.nationality,
+                this.agency,
+                this.transferCost,
+                this.participations,
+                this.goals,
+                this.assists,
+                this.yellowCards,
+                this.redCards
+        );
+    }
+}

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

@@ -0,0 +1,14 @@
+package ru.urfu.model;
+
+public enum Position {
+    GOALKEEPER("Вратарь"), DEFENDER("Защитник"), FORWARD("Нападающий"), MIDFIELD("Полузащитник");
+    private final String russianName;
+
+    public String getRussianName() {
+        return russianName;
+    }
+
+    Position(String russianName) {
+        this.russianName = russianName;
+    }
+}

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

@@ -0,0 +1,75 @@
+package ru.urfu.resolver;
+
+import ru.urfu.exception.ValueNotFoundException;
+import ru.urfu.model.Player;
+import ru.urfu.model.Position;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class PlayerResolver implements IResolver {
+
+    private final List<Player> playerList;
+
+    public PlayerResolver(List<Player> playerList) {
+        this.playerList = playerList;
+    }
+
+    public List<Player> getPlayerList() {
+        return playerList;
+    }
+
+    public int getPlayersCount() {
+        return playerList.size();
+    }
+
+    @Override
+    public int getCountWithoutAgency() {
+        return (int) playerList.stream().filter(player -> player.agency() == null).count();
+    }
+
+    @Override
+    public int getMaxDefenderGoalsCount() {
+        OptionalInt opt = playerList.stream()
+                .filter(player -> player.position() == Position.DEFENDER)
+                .mapToInt(Player::goals)
+                .max();
+        if (opt.isPresent()) {
+            return opt.getAsInt();
+        }
+        throw new ValueNotFoundException("Не найден защитник с наибольшм числом голов.");
+    }
+
+    @Override
+    public String getTheExpensiveGermanPlayerPosition() {
+        String searchNationality = "Germany";
+        Optional<Player> opt = playerList.stream()
+                .filter(player -> player.nationality().equals(searchNationality))
+                .reduce((p1, p2) -> p1.transferCost() < p2.transferCost() ? p2 : p1);
+
+        if (opt.isPresent()) {
+            return opt.get().position().getRussianName();
+        }
+
+        throw new ValueNotFoundException("Не найден самый дорогой немецкий игрок");
+    }
+
+    @Override
+    public String getTheRudestTeam() {
+        Map<String, Integer> teamRedCards = playerList.stream()
+                .collect(
+                        Collectors.groupingBy(Player::team, Collectors.summingInt(Player::redCards))
+                );
+        Optional<Map.Entry<String, Integer>> opt = teamRedCards.entrySet().stream().max(Comparator.comparingInt(Map.Entry::getValue));
+
+        if (opt.isPresent()) {
+            return opt.get().getKey();
+        }
+        throw new ValueNotFoundException("Не найдена команда с наибольшим числом красных карточек.");
+    }
+
+    public Map<String, Long> getPlayersFromCountriesCount() {
+        return playerList.stream()
+                .collect(Collectors.groupingBy(Player::nationality, Collectors.counting()));
+    }
+}

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

@@ -0,0 +1,5 @@
+package ru.urfu.visualization;
+
+import java.util.Map;
+
+public record ChartData(Map<String, Double> data) {}