kubabebe

Wszystkie metody - bez poprawek

Jul 24th, 2017
89
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 7.66 KB | None | 0 0
  1. import java.util.Arrays;
  2. import java.util.Scanner;
  3. import java.io.*;
  4.  
  5. class PracownikNew implements Serializable {
  6.     private String imie;
  7.     private String nazwisko;
  8.     private double placa;
  9.     private char plec;
  10.     private int dzial;
  11.  
  12.     public PracownikNew(String imie, String nazwisko, double placa, char plec, int dzial) {
  13.         this.imie = imie;
  14.         this.nazwisko = nazwisko;
  15.         this.placa = placa;
  16.         this.plec = plec;
  17.         this.dzial = dzial;
  18.     }
  19.  
  20.     @Override
  21.     public String toString() {
  22.         return String.format("| %15s | %20s | %10.2f |  %c |   %d |", imie, nazwisko, placa, plec, dzial);
  23.     }
  24.  
  25.     public boolean czyPracujeWDziale(int departamentNumber) {
  26.         return this.dzial == departamentNumber;
  27.  
  28.     }
  29.  
  30.     public double getPlaca() {
  31.         return this.placa;
  32.     }
  33.  
  34.     public int getDzial() {
  35.         return this.dzial;
  36.     }
  37. }
  38.  
  39. class Kadry implements Serializable {
  40.     private static final int MAKSYMALNE_ZATRUDNIENIE = 100;
  41.     private static final double MAKSYMALNA_PŁACA = 100000;
  42.     private static final int LICZBA_DZIALOW = 5;
  43.     private static final char PLEC_M1 = 'm';
  44.     private static final char PLEC_M2 = 'M';
  45.     private static final char PLEC_K1 = 'k';
  46.     private static final char PLEC_K2 = 'K';
  47.     private PracownikNew[] pracownicy_;
  48.     private int zatrudnienie_;
  49.  
  50.     public Kadry() {
  51.         pracownicy_ = new PracownikNew[MAKSYMALNE_ZATRUDNIENIE];
  52.         zatrudnienie_ = 0;
  53.     }
  54.  
  55.     public void dodajPracownika(PracownikNew pracownik) {
  56.         if (zatrudnienie_ < MAKSYMALNE_ZATRUDNIENIE) {
  57.             pracownicy_[zatrudnienie_] = pracownik;
  58.             zatrudnienie_++;
  59.         } else {
  60.             System.out.println("Za dużo pracowników");
  61.         }
  62.  
  63.     }
  64.  
  65.     public void dodajPracownikaInteraktywnie() {
  66.         System.out.println("Podaj dane pracownika:");
  67.         Scanner in = new Scanner(System.in);
  68.         System.out.print("Imie: ");
  69.         String imie = in.next();
  70.         System.out.print("Nazwisko: ");
  71.         String nazwisko = in.next();
  72.         System.out.print("Placa: ");
  73.         double placa;
  74.         do {
  75.             placa = in.nextDouble();
  76.             if (placa < 0 || placa >= MAKSYMALNA_PŁACA)
  77.                 System.out.println("Płaca spoza zakresu. Wpisz kwotę z zakresu 0 - 100000");
  78.         } while (placa < 0 || placa >= MAKSYMALNA_PŁACA);
  79.         System.out.print("Płeć: ");
  80.         char plec;
  81.         do {
  82.             plec = in.next().charAt(0);
  83.             if (plec != PLEC_M1 && plec != PLEC_M2 && plec != PLEC_K1 && plec != PLEC_K2)
  84.                 System.out.println("Nieprawidłowy znak płaci. Podaj M lub K.");
  85.         } while (plec != PLEC_M1 && plec != PLEC_M2 && plec != PLEC_K1 && plec != PLEC_K2);
  86.         System.out.print("Dział: ");
  87.         int dzial;
  88.         do {
  89.             dzial = in.nextInt();
  90.             if (dzial != 1 && dzial != 2 && dzial != 3 && dzial != 4 && dzial != 5)
  91.                 System.out.println("Nieprawidłowy numer działu. Wybierz liczbe z zakresu 1 - 5");
  92.             ;
  93.         } while (dzial != 1 && dzial != 2 && dzial != 3 && dzial != 4 && dzial != 5);
  94.         // in.close(); //dopytać czemu nie zamykać
  95.         PracownikNew pracownik = new PracownikNew(imie, nazwisko, placa, plec, dzial);
  96.         System.out.println(pracownik.toString());
  97.         dodajPracownika(pracownik);
  98.  
  99.     }
  100.  
  101.     public void importujZPlikuTekstowego(String fileName) throws IOException {
  102.         BufferedReader file = null;
  103.         try {
  104.             file = new BufferedReader(new FileReader(fileName));
  105.             String line = file.readLine();
  106.             String[] helper = new String[5];
  107.  
  108.             while (line != null) {
  109.                 int j = 0;
  110.                 Arrays.fill(helper, "");
  111.                 for (int i = 0; i < line.length(); i++) {
  112.  
  113.                     if (line.charAt(i) != ' ') {
  114.                         helper[j] += line.charAt(i);
  115.                     } else {
  116.                         j++;
  117.                     }
  118.                 }
  119.                 PracownikNew pracownik = new PracownikNew(helper[0], helper[1], Double.parseDouble(helper[2]),
  120.                         helper[3].charAt(0), Integer.parseInt(helper[4]));
  121.                 // System.out.println(pracownik.toString());
  122.                 dodajPracownika(pracownik);
  123.                 line = file.readLine();
  124.             }
  125.  
  126.         } finally {
  127.             if (file != null) {
  128.                 file.close();
  129.             }
  130.  
  131.         }
  132.     }
  133.  
  134.     public int getZatrudnienie() {
  135.         return zatrudnienie_;
  136.     }
  137.  
  138.     public double sredniZarobek() {
  139.         double sumaZarobek = 0;
  140.         for (int i = 0; i < zatrudnienie_; i++) {
  141.             sumaZarobek += pracownicy_[i].getPlaca();
  142.         }
  143.         return (sumaZarobek / zatrudnienie_);
  144.     }
  145.  
  146.     public double sredniZarobek(int dzial) {
  147.         double sumaZarobek = 0;
  148.         int j = 0;
  149.         for (int i = 0; i < zatrudnienie_; i++) {
  150.             if (pracownicy_[i].getDzial() == dzial) {
  151.                 sumaZarobek += pracownicy_[i].getPlaca();
  152.                 j++;
  153.             }
  154.         }
  155.         if (j == 0) {
  156.             System.out.println("Brak pracowników we wskazanym dziale");
  157.             return -1;
  158.         } else {
  159.             return (sumaZarobek / j);
  160.         }
  161.     }
  162.  
  163.     public int[] dajDzialy() {
  164.         int[] dzialy = new int[LICZBA_DZIALOW];
  165.         int k = 0;
  166.         for (int j = 0; j < LICZBA_DZIALOW; j++)
  167.             for (int i = 0; i < zatrudnienie_; i++) {
  168.                 if (j == pracownicy_[i].getDzial()) {
  169.                     dzialy[k] = pracownicy_[i].getDzial();
  170.                     k++;
  171.                     i = zatrudnienie_;
  172.                 }
  173.             }
  174.         return dzialy;
  175.     }
  176.  
  177.     public void pisz() {
  178.         System.out.println("|            Imie |             Nazwisko |      Placa |Plec|Dzial|");
  179.         for (int i = 0; i < zatrudnienie_; i++) {
  180.             System.out.println(pracownicy_[i]);
  181.         }
  182.         System.out.format("Średnia płaca w firmie: %.2f\n", sredniZarobek());
  183.         int[] dzialy = dajDzialy();
  184.         for (int i = 0; i < LICZBA_DZIALOW; i++) {
  185.             if (dzialy[i] != 0) {
  186.                 System.out.format("Średnia płaca w dziale %d wynosi: %.2f\n", dzialy[i], sredniZarobek(dzialy[i]));
  187.             }
  188.         }
  189.     }
  190.  
  191.     public void zapiszDoPliku(String fileName) {
  192.         FileOutputStream fos = null;
  193.         ObjectOutputStream oos = null;
  194.         try {
  195.             fos = new FileOutputStream(fileName);
  196.             oos = new ObjectOutputStream(fos);
  197.             int i = 0;
  198.             while (pracownicy_[i] != null) {
  199.                 oos.writeObject(pracownicy_[i]);
  200.                 i++;
  201.             }
  202.         } catch (FileNotFoundException e) {
  203.             e.printStackTrace();
  204.         } catch (IOException e) {
  205.             e.printStackTrace();
  206.         } finally {
  207.             try {
  208.                 if (oos != null)
  209.                     oos.close();
  210.             } catch (IOException e) {
  211.             }
  212.             try {
  213.                 if (fos != null)
  214.                     fos.close();
  215.             } catch (IOException e) {
  216.             }
  217.         }
  218.     }
  219.  
  220.     public Kadry odczytajZPliku(String fileName) {
  221.         Kadry afterSerialization = new Kadry();
  222.         FileInputStream fis = null;
  223.         ObjectInputStream ois = null;
  224.         try {
  225.             int i = 0;
  226.  
  227.             fis = new FileInputStream(fileName);
  228.             ois = new ObjectInputStream(fis);
  229.             while (fis.available() > 0) {
  230.                 afterSerialization.pracownicy_[i] = (PracownikNew) ois.readObject();
  231.                 afterSerialization.zatrudnienie_++;
  232.                 i++;
  233.             }
  234.         } catch (FileNotFoundException e) {
  235.             e.printStackTrace();
  236.         } catch (IOException e) {
  237.             e.printStackTrace();
  238.         } catch (ClassNotFoundException e) {
  239.             e.printStackTrace();
  240.         } finally {
  241.             try {
  242.                 if (ois != null)
  243.                     ois.close();
  244.             } catch (IOException e) {
  245.             }
  246.             try {
  247.                 if (fis != null)
  248.                     fis.close();
  249.             } catch (IOException e) {
  250.             }
  251.         }
  252.         return afterSerialization;
  253.     }
  254. }
  255.  
  256. public class ZarzadzanieKadrami {
  257.  
  258.     public static void main(String[] args) throws IOException, ClassNotFoundException {
  259.         String fileName = "empl.txt";
  260.         String fileNameOut = "serial.txt";
  261.         Kadry kadry = new Kadry();
  262.         Kadry kadry2 = new Kadry();
  263.         kadry.importujZPlikuTekstowego(fileName);
  264.         kadry.pisz();
  265.         // kadry.dodajPracownikaInteraktywnie();
  266.         kadry.pisz();
  267.         kadry.zapiszDoPliku(fileNameOut);
  268.         kadry2 = kadry.odczytajZPliku(fileNameOut);
  269.         kadry2.pisz();
  270.         /*
  271.          * System.out.println(kadry.getZatrudnienie());
  272.          * System.out.println(kadry.sredniZarobek());
  273.          * System.out.println(kadry.sredniZarobek(3));
  274.          * System.out.println(Arrays.toString(kadry.dajDzialy()));
  275.          * kadry.dodajPracownikaInteraktywnie();
  276.          * System.out.println(kadry.getZatrudnienie());
  277.          * System.out.println(kadry.sredniZarobek());
  278.          */
  279.     }
  280. }
  281. /* Do pliku "empl.txt":
  282. Jan Kowalski 2010 M 3
  283. Agnieszka Cuber 2900 K 3
  284. Adam Nowak 1100 M 4
  285. Sylwia Zych 2100 K 3
  286. Beata Dudek 1900 K 4
  287. */
Advertisement
Add Comment
Please, Sign In to add comment