ZarzadzanieKadrami Final ver2

import java.util.Arrays;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.io.*;

class PracownikNew implements Serializable {
    private String imie;
    private String nazwisko;
    private double placa;
    private char plec;
    private int dzial;

    public PracownikNew(String imie, String nazwisko, double placa, char plec, int dzial) {
        /*
         * if (constructorValidationIfLetters(imie) &&
         * constructorValidationIfLetters(nazwisko) &&
         * constructorValidationIfNumbersDouble(String.valueOf(placa)) &&
         * constructorValidationIfLetters(String.valueOf(plec)) &&
         * constructorValidationIfNumbersInt(String.valueOf(dzial))){
         */
        this.imie = imie;
        this.nazwisko = nazwisko;
        this.placa = placa;
        this.plec = plec;
        this.dzial = dzial;
        /*
         * } else { System.out.
         * println("Nieprawidłowy typ danych przy dodawaniu pracownika."); }
         */
    }

    /*
     * private boolean constructorValidationIfLetters(String text) {
     *
     * return Pattern.matches("^[A-Za-z]+$", text); }
     *
     * private boolean constructorValidationIfNumbersDouble(String numberDouble)
     * {
     *
     * return Pattern.matches("[0-9]{1,7}.[0-9]{0,2}", numberDouble); }
     *
     * private boolean constructorValidationIfNumbersInt(String numberInt) {
     * return Pattern.matches("[0-9]", numberInt); }
     */

    @Override
    public String toString() {
        return String.format("| %15s | %20s | %10.2f |  %c |   %d |", imie, nazwisko, placa, plec, dzial);
    }

    public boolean czyPracujeWDziale(int departamentNumber) {
        return this.dzial == departamentNumber;

    }

    public double getPlaca() {
        return this.placa;
    }

    public int getDzial() {
        return this.dzial;
    }
}

class Kadry implements Serializable {
    private static final int MAKSYMALNE_ZATRUDNIENIE = 100;
    private static final double MAKSYMALNA_PLACA = 100000;
    // private static final int LICZBA_DZIALOW = 5;
    private static final char PLEC_M = 'M';
    private static final char PLEC_K = 'K';
    private static final int DZIAL_MIN = 1;
    private static final int DZIAL_MAX = 5;
    private PracownikNew[] pracownicy_;
    private int zatrudnienie_;

    public Kadry() {
        pracownicy_ = new PracownikNew[MAKSYMALNE_ZATRUDNIENIE];
        zatrudnienie_ = 0;
    }

    public void dodajPracownika(PracownikNew pracownik) {
        if (zatrudnienie_ < MAKSYMALNE_ZATRUDNIENIE) {
            pracownicy_[zatrudnienie_] = pracownik;
            zatrudnienie_++;
        } else {
            System.out.println("Za dużo pracowników");
        }

    }

    public void dodajPracownikaInteraktywnie() {
        System.out.println("Podaj dane pracownika:");
        Scanner in = new Scanner(System.in);
        System.out.print("Imie: ");
        String imie = in.next();
        System.out.print("Nazwisko: ");
        String nazwisko = in.next();

        System.out.print("Placa: ");
        String placa;
        do {
            placa = in.next();
            if (!placaValidationIfNumbersDouble(placa) || placaCheck(placa))
                System.out.println("Płaca spoza zakresu. Wpisz kwotę z zakresu 0 - " + MAKSYMALNA_PLACA);

        } while (!placaValidationIfNumbersDouble(placa) || placaCheck(placa));

        System.out.print("Płeć: ");
        char plec;
        do {
            plec = Character.toUpperCase(in.next().charAt(0));
            if (plecCheck(plec))
                System.out.println("Nieprawidłowy znak płci. Podaj M lub K.");
        } while (plecCheck(plec));

        System.out.print("Dział: ");
        String dzial;
        do {
            dzial = in.next();
            if (!dzialValidationIfNumbersInt(dzial) || dzialCheck(dzial))
                System.out.println("Nieprawidłowy numer działu. Wybierz liczbe z zakresu 1 - 5");
        } while (!dzialValidationIfNumbersInt(dzial) || dzialCheck(dzial));

        PracownikNew pracownik = new PracownikNew(imie, nazwisko, Double.valueOf(placa), plec, Integer.valueOf(dzial));
        dodajPracownika(pracownik);

    }

    private boolean placaCheck(String placa) {
        return (Double.valueOf(placa) < 0 || Double.valueOf(placa) >= MAKSYMALNA_PLACA);
    }

    private boolean plecCheck(char plec) {
        return plec != PLEC_M && plec != PLEC_K;
    }

    private boolean dzialCheck(String dzial) {
        return Integer.valueOf(dzial) < DZIAL_MIN || Integer.valueOf(dzial) > DZIAL_MAX;
    }

    public void importujZPlikuTekstowego(String fileName) throws IOException {

        try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
            String line = reader.readLine();
            while (line != null) {
                if (lineOnEmployeeValidation(line)) {
                    dodajPracownika(lineOnEmployee(line));
                    line = reader.readLine();
                } else {
                    System.out.println("Nieprawidłowy typ danych przy dodawaniu pracownika.");
                    line = reader.readLine();
                }
            }

        }

    }

    private PracownikNew lineOnEmployee(String line) {
        String[] splitLine = line.split("\\s");

        return new PracownikNew(splitLine[0], splitLine[1], Double.parseDouble(splitLine[2]), splitLine[3].charAt(0),
                Integer.parseInt(splitLine[4]));

    }

    private boolean lineOnEmployeeValidation(String line) {
        String[] splitLine = line.split("\\s");
        return textValidationIfLetters(splitLine[0]) && textValidationIfLetters(splitLine[1])
                && placaValidationIfNumbersDouble(splitLine[2]) && textValidationIfLetters(splitLine[3])
                && dzialValidationIfNumbersInt(splitLine[4]);

    }

    private boolean textValidationIfLetters(String text) {

        return Pattern.matches("^[A-Za-z]+$", text);
    }

    private boolean placaValidationIfNumbersDouble(String numberDouble) {

        return Pattern.matches("[0-9]{1,6}\\.[0-9]{0,2}|[0-9]{1,6}", numberDouble);
    }

    private boolean dzialValidationIfNumbersInt(String numberInt) {
        return Pattern.matches("[" + DZIAL_MIN + "-" + DZIAL_MAX + "]", numberInt);
    }

    public int getZatrudnienie() {
        return zatrudnienie_;
    }

    public double sredniZarobek() {
        double sumaZarobek = 0;
        for (int i = 0; i < zatrudnienie_; i++) {
            sumaZarobek += pracownicy_[i].getPlaca();
        }
        if (zatrudnienie_ == 0) {
            System.out.println("Brak pracowników w firmie");
            return 0;
        } else {
            return (sumaZarobek / zatrudnienie_);
        }
    }

    public double sredniZarobek(int dzial) {
        double sumaZarobek = 0;
        int liczbaPracownikowWDziale = 0;
        for (int i = 0; i < zatrudnienie_; i++) {
            if (pracownicy_[i].getDzial() == dzial) {
                sumaZarobek += pracownicy_[i].getPlaca();
                liczbaPracownikowWDziale++;
            }
        }
        if (liczbaPracownikowWDziale == 0) {
            System.out.println("Brak pracowników we wskazanym dziale");
            return 0;
        } else {
            return (sumaZarobek / liczbaPracownikowWDziale);
        }
    }

    public int[] dajDzialy() {

        HashSet<Integer> dzialySet = new HashSet<Integer>();
        for (int i = 0; i < zatrudnienie_; i++) {
            dzialySet.add(pracownicy_[i].getDzial());
        }
        int[] dzialy = new int[dzialySet.size()];
        int index = 0;
        for (int i : dzialySet) {
            dzialy[index++] = i;
        }
        return dzialy;

    }

    public void pisz() {
        System.out.println("|            Imie |             Nazwisko |      Placa |Plec|Dzial|");
        for (int i = 0; i < zatrudnienie_; i++) {
            System.out.println(pracownicy_[i]);
        }
        System.out.format("Średnia płaca w firmie: %.2f\n", sredniZarobek());
        for (int dzial : dajDzialy()) {

            System.out.format("Średnia płaca w dziale %d wynosi: %.2f\n", dzial, sredniZarobek(dzial));

        }
    }

    public void zapiszDoPliku(String fileName, Kadry kadry) throws FileNotFoundException {

        try (FileOutputStream fos = new FileOutputStream(fileName);
                ObjectOutputStream oos = new ObjectOutputStream(fos);) {

            oos.writeObject(kadry);

        } catch (IOException e) {
            System.out.println(e);
        }

    }

    public Kadry odczytajZPliku(String fileName) {

        Kadry afterSerialization = null;
        try (FileInputStream fis = new FileInputStream(fileName); ObjectInputStream ois = new ObjectInputStream(fis);) {

            afterSerialization = (Kadry) ois.readObject();

        } catch (IOException | ClassNotFoundException e) {
            System.out.println(e);
        }

        return afterSerialization;
    }
}

public class ZarzadzanieKadrami {

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        String fileName = "empl.txt";
        String fileNameOut = "serial.txt";
        Kadry kadry = new Kadry();
        Kadry kadry2 = new Kadry();
        System.out.println(kadry.sredniZarobek());
        kadry.importujZPlikuTekstowego(fileName);
        System.out.println(Arrays.toString(kadry.dajDzialy()));
        kadry.pisz();

        kadry.dodajPracownikaInteraktywnie();
        kadry.pisz();
        System.out.println(Arrays.toString(kadry.dajDzialy()));
        kadry.zapiszDoPliku(fileNameOut, kadry);
        kadry2 = kadry.odczytajZPliku(fileNameOut);
        kadry2.pisz();
        System.out.println(Arrays.toString(kadry2.dajDzialy()));
        /*
         * System.out.println(kadry.getZatrudnienie());
         * System.out.println(kadry.sredniZarobek());
         * System.out.println(kadry.sredniZarobek(3));
         * System.out.println(Arrays.toString(kadry.dajDzialy()));
         * kadry.dodajPracownikaInteraktywnie();
         * System.out.println(kadry.getZatrudnienie());
         * System.out.println(kadry.sredniZarobek());
         */
    }
}