Code Review

public class Task01 {
    private String[] array;
    private Map<String, String> map;

    public Task01(Map<String, String> map) {
        this.map = map;
    }

    public Task01(String[] array) {
        this.array = array;
    }

    public Map<String, String> getMapFromArray(String[] array) {
        return Stream.iterate(0, (x) -> x < array.length, (x) -> x + 2)
                .collect(Collectors.toMap(
                        (x) -> array[x],
                        (x) -> array[x + 1]));
    }

    public String[] getArrayFromMap(Map<String, String> map) {
        return map.entrySet()
                .stream()
                .flatMap((x) -> Stream.of(x.getKey(), x.getValue()))
                .toArray(String[]::new);
    }
}

public class Task02 {
    private int startTable;
    private int endTable;

    public Task02(int startTable, int endTable) {
        this.startTable = startTable;
        this.endTable = endTable;
    }

    public void getMultiplicationTableOneColumn() {
        IntStream.range(startTable, endTable)
                .forEach((x) -> {
                    IntStream.range(startTable, endTable).forEach((y) -> System.out.printf("%d * %d = %d\n", x, y, x * y));
                    System.out.println();
                });
    }

    public void getMultiplicationTableFiveColumn() {
        IntStream.range(startTable, endTable).forEach((x) -> {
            IntStream.range(startTable, 6).forEach((y) -> {
                System.out.print(y + " x " + x + " = " + (x * y) + "\t");
            });
            System.out.println();
        });
        IntStream.range(startTable, endTable).forEach((x) -> {
            IntStream.range(6, endTable).forEach((y) -> {
                System.out.print(y + " x " + x + " = " + (x * y) + "\t");
            });
            System.out.println();
        });
    }
}

public int getCountNumberOfEven(List<Integer> listOfNumbers) {
    return (int) listOfNumbers.stream()
            .filter((x) -> x % 2 == 0 && x != 0)
            .count();
}

public TV(String manufacturer, String modelName, int yearOfIssue, int diagonal, int price) {
    this.manufacturer = manufacturer;
    this.modelName = modelName;
    this.yearOfIssue = yearOfIssue;
    this.diagonal = diagonal;
    this.price = price;
}

public class ProjectTWTests {
    static TV tv1 = new TV("Samsung", "RT520", 2010, 25, 1000);
    static TV tv2 = new TV("Philips", "DXC360", 2009, 23, 900);
    static TV tv3 = new TV("LG", "LT7790", 2013, 23, 1100);
    static TV tv4 = new TV("Samsung", "RT770", 2012, 28, 1300);
    static TV tv5 = new TV("LG", "LT8800", 2008, 22, 770);
    List<TV> listTV = new ArrayList<TV>(Arrays.asList(tv1, tv2, tv3, tv4, tv5));
    static Stream<Arguments> provideArgumentsGetTVWithGivenDiagonal() {
        return Stream.of(
                Arguments.of(23, List.of(tv2, tv3)),
                Arguments.of(25, List.of(tv1)),
                Arguments.of(20, List.of())
        );
    }

@FunctionalInterface
public interface MapToArrayString {
    public String[] transferToMap(Map<String, String> map);
}

public class ToArrayString {
    public String[] methodMapToStringArray(Map<String, String> map) {
        String[] text = new String[map.size() * 2];
        int i = 0;

        for (Map.Entry<String, String> entry : map.entrySet()) {
            text[i] = entry.getKey();
            text[i + 1] = entry.getValue();
            i += 2;
        }
        return text;
    }
}

public long getEven(List<Integer> list) {
    return list.stream().filter(x -> x % 2 == 0).count();
}

public long getEven(List<Long> list) {
    return list.stream()
            .filter(x -> x % 2 == 0)
            .count();
}

    static Stream<Arguments> provideFromGetEven() {
        return Stream.of(Arguments.of(List.of(2, 2, 5, 6, 8, 1, 0, 99), 5));
    }

    @ParameterizedTest
    @MethodSource("provideFromGetEven")
    public void getEven(List<Integer> list, long expected) {
        ProjectMathsStatistics projectMathsStatistics = new ProjectMathsStatistics();

        long actual = projectMathsStatistics.getEven(list);

        Assertions.assertEquals(expected, actual);
    }

public class Task02 {
    public void one() {
        IntStream.range(1, 11).forEach((x) -> {
            IntStream.range(1, 11).forEach((y) -> System.out.printf("%d * %d = %d\n", y, x, y * x));
        });
    }

    public void five() {
        IntStream.range(1, 11).forEach((x) -> {
            IntStream.range(1, 6).forEach((y) -> System.out.printf("%d * %d = %d\t", y, x, y * x));
            System.out.println();
        });
        IntStream.range(1, 11).forEach((x) -> {
            IntStream.range(6, 11).forEach((y) -> System.out.printf("%d * %d = %d\t", y, x, y * x));
            System.out.println();
        });
    }
}

public List<String> getCitiesMoreSixSymbol(List<String> cities) {
    List<String> newList = new ArrayList<>();
    cities.stream().filter(x -> x.length() > 6).forEach(newList::add);
    return newList;
}

public class TestCities {

public class TV {
    private List<ProjectTV> tvList;

    public TV(List<ProjectTV> tvList) {
        this.tvList = tvList;
    }

    public List<ProjectTV> getTVDiagonal(List<ProjectTV> list, Integer diagonal) {
        return list.stream()
                .filter(x -> x.getDiagonal().equals(diagonal))
                .collect(Collectors.toList());
    }

public ProjectTV(String manufacture, String modelName, Integer yearOfRelease, Integer diagonal, Integer price) {
    this.manufacture = manufacture;
    this.modelName = modelName;
    this.yearOfRelease = yearOfRelease;
    this.diagonal = diagonal;
    this.price = price;
}

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

@ParameterizedTest
@MethodSource("ConvertMapToArrayArguments")
public void convertMapToArray(Map<String, String> map, String[] expected) {
    Task01 task1 = new Task01();

    String[] actual = task1.mapToArray(map);
    Arrays.sort(expected);
    Arrays.sort(actual);

    Assertions.assertArrayEquals(expected, actual);
}

public class UtilityCityHelper {
    public List<String> cities;

    public UtilityCityHelper(List<String> cities) {
        this.cities = cities;
    }

    public List<String> getUniqueCities() {
        return cities.stream()
                .distinct()
                .collect(Collectors.toList());
    }

    public List<String> getLongCities() {
        return cities.stream()
                .distinct()
                .filter(word -> word.length() > 6)
                .collect(Collectors.toList());
    }

public class Utility {
    public int getRandom() {
        return (int) (Math.random() * 100);
    }

    public List<Integer> getRandomList() {
        List<Integer> list = new ArrayList<>();
        IntStream.range(1, 16)
                .forEach(i -> list.add(getRandom()));
        return list;
    }

public class MathStatisticsTest {
    Utility util = new Utility();
    List<Integer> listExample = util.getRandomList();

@ParameterizedTest
    @MethodSource("provideArgumentsForTVByDiagonal")
    public void getTVByDiagonal(double diagonal, List<TV> expected) {
        tvs.add(tv1);
        tvs.add(tv2);
        tvs.add(tv3);
        tvs.add(tv4);
        tvs.add(tv5);

        List<TV> actual = tvInfo.getTVByDiagonal(diagonal);

        Assertions.assertEquals(expected, actual);
    }

public class TestTask01 {
    Task01 task01 = new Task01();

    @Test
    public void testConvertArrayToMap() {
        String expected = "{-o=out.txt, -d=1, -i=in.txt, --limit=40}";
        String actual = task01.convertArrayToMap(
                new String[]{"-i", "in.txt", "--limit", "40", "-d", "1", "-o", "out.txt"}).toString();
        Assertions.assertEquals(expected, actual);
    }

public class DemoMathsStatisticsUtility {
    public static void main(String[] args) {
        Utility utility = new Utility();
        System.out.println(Arrays.toString(utility.generateArrayOfRandomIntegers(5)));
    }
}

public class Utility {
    public Set<String> getUniqueCities(List<String> cities) {
        Set<String> uniqueCities = new HashSet<>();
        cities.stream().forEach(s -> uniqueCities.add(s));
        return uniqueCities;
    }

    public Set<String> getUniqueCitiesWithLengthMoreThan6Letters(List<String> cities) {
        Set<String> uniqueCities = new HashSet<>();
        cities.stream().filter(s -> s.length() > 6).forEach(s -> uniqueCities.add(s));
        return uniqueCities;
    }

public Televisor(String manufacturer, String modelName, int yearOfIssue, double diagonal, double price) {
        this.manufacturer = manufacturer;
        this.modelName = modelName;
        this.yearOfIssue = yearOfIssue;
        this.diagonal = diagonal;
        this.price = price;
    }

    @Override
    public String toString() {
        return "Televisor{" +
                "manufacturer='" + manufacturer + '\'' +
                ", modelName='" + modelName + '\'' +
                ", yearOfIssue=" + yearOfIssue +
                ", diagonal=" + diagonal +
                ", price=" + price +
                '}';
    }

    public String getManufacturer() {
        return manufacturer;
    }

public class TestTvTelevisorUtility {
    Utility utility = new Utility();

    static Stream<Arguments> provideArgumentsGetTelevisorWithSetDiagonal() {
        return Stream.of(
                Arguments.of(List.of(
                                new Televisor("LG", "Model1", 2000, 5.0, 100.0),
                                new Televisor("Philips", "Model2", 2001, 5.5, 105.0),
                                new Televisor("Xiaomi", "Model3", 2002, 6.0, 110.0)),
                        5.5,
                        "[Televisor{manufacturer='Philips', modelName='Model2', yearOfIssue=2001, diagonal=5.5, price=105.0}]"));
    }

    @ParameterizedTest
    @MethodSource("provideArgumentsGetTelevisorWithSetDiagonal")
    void testGetTelevisorWithSetDiagonal(List<Televisor> tv, double setDiagonal, String expected) {
        List<Televisor> actual = utility.getTelevisorWithSetDiagonal(tv, setDiagonal);

        Assertions.assertEquals(expected, actual.toString());
    }

    static Stream<Arguments> provideArgumentsGetTelevisorWithSetManufacturer() {
        return Stream.of(
                Arguments.of(List.of(
                                new Televisor("LG", "Model1", 2000, 5.0, 100.0),
                                new Televisor("Philips", "Model2", 2001, 5.5, 105.0),
                                new Televisor("Xiaomi", "Model3", 2002, 6.0, 110.0)),
                        "Philips",
                        "[Televisor{manufacturer='Philips', modelName='Model2', yearOfIssue=2001, diagonal=5.5, price=105.0}]"));
    }

public Map<String, String> getMap(String[] array) {
    Map<String, String> argsMap = new LinkedHashMap<>(array.length / 2);
    for (int i = 0; i < array.length; i += 2) {
        argsMap.put(array[i], array[i + 1]);
    }
    return argsMap;
}

public String[] getArrayString(Map<String, String> map) {
    String[] argsArray = map.entrySet().stream()
            .flatMap(e -> Stream.of(e.getKey(), e.getValue()))
            .toArray(String[]::new);
    return argsArray;
}

public class Task2 {
    public static void main(String[] args) {
        oneColumnMultiplicationTable();
        fiveColumnMultiplicationTable();
    }

    public static void oneColumnMultiplicationTable() {
        IntStream.rangeClosed(1, 10)
                .forEach(i -> {
                    IntStream.rangeClosed(1, 10)
                            .forEach(j -> System.out.printf("%d * %d = %d\n", i, j, i * j));
                    System.out.println();
                });
    }

    public static void fiveColumnMultiplicationTable() {
        IntStream.rangeClosed(1, 10)
                .forEach(i -> {
                    IntStream.rangeClosed(1, 5)
                            .forEach(j -> System.out.printf("%d * %d = %d\t", j, i, j * i));
                    System.out.println();
                });
        System.out.println();
        IntStream.rangeClosed(1, 10)
                .forEach(i -> {
                    IntStream.rangeClosed(6, 10)
                            .forEach(j -> System.out.printf("%d * %d = %d\t", j, i, j * i));
                    System.out.println();
                });
    }
}

public class TestTask1 {
    Task1 task1 = new Task1();
    String[] array = new String[]{"-i", "in.txt", "--limit", "40", "-d", "1", "-o", "out.txt"};

    @Test
    void testGetMap() {
        Map<String, String> actual = task1.getMap(array);
        Map<String, String> expected = new TreeMap<>(Map.of("-i", "in.txt", "--limit", "40", "-d", "1", "-o", "out.txt"));

        Assertions.assertEquals(actual, expected);
    }

   @Test
    void testGetArrayString() {
        Map<String, String> map = task1.getMap(array);

        String[] actual = task1.getArrayString(map);

        Assertions.assertArrayEquals(actual, array);
    }
}

public List<Integer> getListOfRandomNumbers(int length) {
    List<Integer> randomNumbers = new ArrayList<>();
    for (int i = 0; i < length; i++) {
        randomNumbers.add((int) (Math.random() * 1000));
    }
    return randomNumbers;
}

public long countEvenNumbers(List<Integer> randomNumbers) {
    long countEvenNumbers = randomNumbers.stream()
            .filter(n -> n % 2 == 0)
            .count();
    return countEvenNumbers;
}

public class City {
    private String name;

    public City(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        City city = (City) o;
        return name == city.name;
    }

    @Override
    public int hashCode() {
        return Objects.hash(name);
    }
}

public List<City> getSpecialLetterBeginCityNames(List<City> cityList, String letter) {
    List<City> longCityNames = cityList.stream()
            .filter(s -> s.getName().toLowerCase().startsWith(letter.toLowerCase()))
            .distinct()
            .collect(Collectors.toList());
    return longCityNames;
}

public enum Manufacturer {
    SONY,
    LG,
    PHILIPS,
    SAMSUNG
}

public class DiagonalAscendingComparator implements Comparator<Television> {
    @Override
    public int compare(Television a, Television b) {
        return Integer.compare(a.getDiagonal(), b.getDiagonal());
    }
}

static Stream<Arguments> provideArgumentsForGetUniqueList() {
    return Stream.of(
            Arguments.of(new ArrayList<>(List.of(new City("London"), new City("Minsk"), new City("NY"), new City("Riga"), new City("Paris"), new City("Kair"))),
                    new ArrayList<>(List.of(new City("London"), new City("Minsk"), new City("NY"), new City("Riga"), new City("Paris"), new City("Kair")))),
            Arguments.of(new ArrayList<>(List.of(new City("Kiev"), new City("Minsk"), new City("NY"), new City("Riga"), new City("Kiev"), new City("Minsk"), new City("NY"), new City("Riga"))),
                    new ArrayList<>(List.of(new City("Kiev"), new City("Minsk"), new City("NY"), new City("Riga")))),
            Arguments.of(new ArrayList<>(List.of(new City("London"), new City("London"), new City("London"))),
                    new ArrayList<>(List.of(new City("London"))))
    );
}

@ParameterizedTest(name = "countGetUniqueList")
@MethodSource("provideArgumentsForGetUniqueList")
void testGetUniqueList(List<City> cityList, List<City> expected) {
    List<City> actual = cityHelper.getUniqueList(cityList);

    Assertions.assertEquals(expected, actual);
}

public long getEvenNumbers(List<Integer> list) {
    return list.stream()
            .filter(c -> c % 2 == 0)
            .count();
}

public class MathsStatistics {

    public MathsStatistics() {
    }

public class TV {
    String manufacturer;
    String model;
    int year;
    double diagonal;
    double price;

@ParameterizedTest
@MethodSource("ConvertMapToArrayArguments")
public void convertToArray(Map<String, String> map, String[] expected) {
    Task1 task1 = new Task1();
    String[] actual = task1.convertToArray(map);
    Arrays.sort(actual);
    Arrays.sort(expected);
    Assertions.assertArrayEquals(expected, actual);
}

public List<TV> sortedByDiagonalAsc() {
    return tv.stream()
            .sorted(Comparator.comparingDouble(TV::getDiagonal))
            .collect(Collectors.toList());
}

public List<TV> sortedByDiagonalDesc() {
    return tv.stream()
            .sorted((x, y) -> -Double.compare(x.getDiagonal(), y.getDiagonal()))
            .collect(Collectors.toList());
}

@ParameterizedTest
@MethodSource("provideArgumentsForGetTelevisionSortedMaxMinDiagonal")
void testGetTelevisionSortedMaxMinDiagonal(List<Television> televisions, String expected) {
    InformationSystemTv infoTv = new InformationSystemTv(televisions);
    List<Television> actual = infoTv.getTelevisionSortedMaxMinDiagonal(televisions);

    Assertions.assertEquals(expected, actual.toString());
}