Head First JAVA: 16. Chapter - Kamil-Jankowski/Learning-JAVA GitHub Wiki

public class Piosenka implements Comparable<Piosenka>{

    private String tytul;
    private String autor;
    private String ocena;
    private String bpm;

    @Override
    public boolean equals(Object piosenka){
        Piosenka p = (Piosenka) piosenka;
        return getTytul().equals(p.getTytul());
    }

    @Override
    public int hashCode(){
        return tytul.hashCode();
    }

    Piosenka(String t, String a, String o, String b){
        tytul = t;
        autor = a;
        ocena = o;
        bpm = b;
    }

    public String getTytul(){
        return tytul;
    }

    public String getAutor(){
        return autor;
    }

    public String getOcena(){
        return ocena;
    }

    public String getBpm(){
        return bpm;
    }

    public String toString(){
        return tytul;
//        return tytul+": "+autor;
    }

    @Override
    public int compareTo(Piosenka p) {
        return tytul.compareTo(p.getTytul());
    }
}

import java.io.*;
import java.util.*;

public class SzafaGrajaca1 {

    private ArrayList<String> listaPiosenek = new ArrayList<>();

    public static void main(String[] args) {
        SzafaGrajaca1 szafa = new SzafaGrajaca1();
        szafa.doDziela();
    }

    private void doDziela() {
        pobierzPiosenki();
        System.out.println(listaPiosenek);
        Collections.sort(listaPiosenek);
        System.out.println(listaPiosenek);
    }

    private void pobierzPiosenki() {
        try{
            File plik = new File("ListaPiosenek.txt");
            FileReader czytelnikPliku = new FileReader(plik);
            BufferedReader czytelnik = new BufferedReader(czytelnikPliku);
            String wiersz;
            while ((wiersz = czytelnik.readLine()) != null){
                dodajPiosenke(wiersz);
            }
        }catch(IOException ex){ex.printStackTrace();}
    }

    private void dodajPiosenke(String wierszDoAnalizy) {
        String[] elementy = wierszDoAnalizy.split("/");
        listaPiosenek.add(elementy[0]);
    }
}

import java.io.*;
import java.util.*;

public class SzafaGrajaca3 {

    ArrayList<Piosenka> listaPiosenek = new ArrayList<>();

    public static void main(String[] args) {
        SzafaGrajaca3 szafa = new SzafaGrajaca3();
        szafa.doDziela();
    }

    private void doDziela() {
        pobierzPiosenki();
        Collections.sort(listaPiosenek);
        System.out.println(listaPiosenek);
    }

    private void pobierzPiosenki() {
        try{
            File plik = new File("ListaPiosenek.txt");
            FileReader czytelnikPliku = new FileReader(plik);
            BufferedReader czytelnik = new BufferedReader(czytelnikPliku);
            String wiersz;
            while((wiersz = czytelnik.readLine())!= null){
                dodajPiosenke(wiersz);
            }
        } catch (Exception e) {e.printStackTrace();}
    }

    private void dodajPiosenke(String wierszDoAnalizy) {
        String[] elementy = wierszDoAnalizy.split("/");
        Piosenka nastepnaPiosenka = new Piosenka(elementy[0], elementy[1], elementy[2], elementy[3]);
        listaPiosenek.add(nastepnaPiosenka);
    }
}

import java.io.*;
import java.util.*;

public class SzafaGrajaca4 {

    ArrayList<Piosenka> listaPiosenek = new ArrayList<>();

    public static void main(String[] args) {
        SzafaGrajaca4 szafa = new SzafaGrajaca4();
        szafa.doDziela();
    }

    private void doDziela() {
        pobierzPiosenki();
        System.out.println("Nieposortowane:");
        System.out.println(listaPiosenek + "\n");
        Collections.sort(listaPiosenek);
        System.out.println("Kolekcja ArrayList posortowana według tytułu:");
        System.out.println(listaPiosenek + "\n");

        ArtystaCompare komparator = new ArtystaCompare();
        Collections.sort(listaPiosenek, komparator);
        System.out.println("Kolekcja ArrayList posortowana według autora (komparator):");
        System.out.println(listaPiosenek);
    }

    private void pobierzPiosenki() {
        try{
            File plik = new File("ListaPiosenek.txt");
            FileReader czytelnikPliku = new FileReader(plik);
            BufferedReader czytelnik = new BufferedReader(czytelnikPliku);
            String wiersz;
            while((wiersz = czytelnik.readLine())!= null){
                dodajPiosenke(wiersz);
            }
        } catch (Exception e) {e.printStackTrace();}
    }

    private void dodajPiosenke(String wierszDoAnalizy) {
        String[] elementy = wierszDoAnalizy.split("/");
        Piosenka nastepnaPiosenka = new Piosenka(elementy[0], elementy[1], elementy[2], elementy[3]);
        listaPiosenek.add(nastepnaPiosenka);
    }

    private class ArtystaCompare implements Comparator<Piosenka> {
        @Override
        public int compare(Piosenka p1, Piosenka p2) {
            return p1.getAutor().compareTo(p2.getAutor());
        }
    }
}

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class SzafaGrajaca5 {

    ArrayList<Piosenka> listaPiosenek = new ArrayList<>();

    public static void main(String[] args) {
        SzafaGrajaca5 szafa = new SzafaGrajaca5();
        szafa.doDziela();
    }

    private void doDziela() {
        pobierzPiosenki();
        System.out.println(listaPiosenek + "\n");
        Collections.sort(listaPiosenek);
        System.out.println(listaPiosenek + "\n");

        ArtystaCompare komparator = new ArtystaCompare();
        Collections.sort(listaPiosenek, komparator);

        System.out.println(listaPiosenek + "\n");
    }

    private void pobierzPiosenki() {
        try{
            File plik = new File("PelnaListaPiosenek.txt");
            FileReader czytelnikPliku = new FileReader(plik);
            BufferedReader czytelnik = new BufferedReader(czytelnikPliku);
            String wiersz;
            while((wiersz = czytelnik.readLine())!= null){
                dodajPiosenke(wiersz);
            }
        } catch (Exception e) {e.printStackTrace();}
    }

    private void dodajPiosenke(String wierszDoAnalizy) {
        String[] elementy = wierszDoAnalizy.split("/");
        Piosenka nastepnaPiosenka = new Piosenka(elementy[0], elementy[1], elementy[2], elementy[3]);
        listaPiosenek.add(nastepnaPiosenka);
    }

    private class ArtystaCompare implements Comparator<Piosenka> {
        @Override
        public int compare(Piosenka p1, Piosenka p2) {
            return p1.getAutor().compareTo(p2.getAutor());
        }
    }
}

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;

public class SzafaGrajaca6 {

    ArrayList<Piosenka> listaPiosenek = new ArrayList<>();

    public static void main(String[] args) {
        SzafaGrajaca6 szafa = new SzafaGrajaca6();
        szafa.doDziela();
    }

    private void doDziela() {
        pobierzPiosenki();
        System.out.println("Nieposortowane:");
        System.out.println(listaPiosenek + "\n");
        Collections.sort(listaPiosenek);
        System.out.println("Kolekcja ArrayList posortowana według tytułu:");
        System.out.println(listaPiosenek + "\n");

        HashSet<Piosenka> zbiorPiosenek = new HashSet<>();
        zbiorPiosenek.addAll(listaPiosenek);
        System.out.println("HashSet nieposortowany:");
        System.out.println(zbiorPiosenek + "\n");
    }

    private void pobierzPiosenki() {
        try{
            File plik = new File("PelnaListaPiosenek.txt");
            FileReader czytelnikPliku = new FileReader(plik);
            BufferedReader czytelnik = new BufferedReader(czytelnikPliku);
            String wiersz;
            while((wiersz = czytelnik.readLine())!= null){
                dodajPiosenke(wiersz);
            }
        } catch (Exception e) {e.printStackTrace();}
    }

    private void dodajPiosenke(String wierszDoAnalizy) {
        String[] elementy = wierszDoAnalizy.split("/");
        Piosenka nastepnaPiosenka = new Piosenka(elementy[0], elementy[1], elementy[2], elementy[3]);
        listaPiosenek.add(nastepnaPiosenka);
    }
}

import java.io.*;
import java.util.*;

public class SzafaGrajaca8 {

    ArrayList<Piosenka> listaPiosenek = new ArrayList<>();

    public static void main(String[] args) {
        SzafaGrajaca8 szafa = new SzafaGrajaca8();
        szafa.doDziela();
    }

    private void doDziela() {
        pobierzPiosenki();
        System.out.println("Nieposortowane:");
        System.out.println(listaPiosenek + "\n");
        Collections.sort(listaPiosenek);
        System.out.println("Kolekcja ArrayList posortowana według tytułu:");
        System.out.println(listaPiosenek + "\n");

        TreeSet<Piosenka> zbiorPiosenek = new TreeSet<>();
        zbiorPiosenek.addAll(listaPiosenek);
        System.out.println("TreeSet posortowany według tytułu (unikalne wartości):");
        System.out.println(zbiorPiosenek + "\n");
    }

    private void pobierzPiosenki() {
        try{
            File plik = new File("PelnaListaPiosenek.txt");
            FileReader czytelnikPliku = new FileReader(plik);
            BufferedReader czytelnik = new BufferedReader(czytelnikPliku);
            String wiersz;
            while((wiersz = czytelnik.readLine())!= null){
                dodajPiosenke(wiersz);
            }
        } catch (Exception e) {e.printStackTrace();}
    }

    private void dodajPiosenke(String wierszDoAnalizy) {
        String[] elementy = wierszDoAnalizy.split("/");
        Piosenka nastepnaPiosenka = new Piosenka(elementy[0], elementy[1], elementy[2], elementy[3]);
        listaPiosenek.add(nastepnaPiosenka);
    }
}

package cwiczenia;

public class Gora {
    private String nazwa;
    private int wysokosc;

    Gora(String n, int w){
        nazwa = n;
        wysokosc = w;
    }

    String getNazwa(){
        return nazwa;
    }

    int getWysokosc(){
        return wysokosc;
    }

    public String toString(){

        return nazwa + " " + wysokosc;
    }
}

package cwiczenia;
import java.util.*;

public class SortowanieGor {

    private LinkedList<Gora> listaGor = new LinkedList<>();

    public static void main(String[] args) {
        SortowanieGor atlas = new SortowanieGor();
        atlas.sortujGory();
    }

    private void sortujGory() {
        dodajGory();
        System.out.println("Bez sortowania: \n" + listaGor);
        NameComparator nazwaKomparator = new NameComparator();
        Collections.sort(listaGor, nazwaKomparator);                            // poprzedni sposób sortowania
        System.out.println("Według nazw: \n" + listaGor);
        HeightComparator wysokoscKomparator = new HeightComparator();
        listaGor.sort(wysokoscKomparator);                                      // nowy sposób sortowania
        System.out.println("Według wysokosci malejąco: \n" + listaGor);
    }

    private void dodajGory() {
        listaGor.add(new Gora("Kasprowy", 1987));
        listaGor.add(new Gora("Koscielec", 2155));
        listaGor.add(new Gora("Swinica", 2301));
        listaGor.add(new Gora("Rysy", 2499));
    }

    class NameComparator implements Comparator<Gora>{
        @Override
        public int compare(Gora g1, Gora g2) {
            return g1.getNazwa().compareTo(g2.getNazwa());
        }
    }

    private class HeightComparator implements Comparator<Gora> {
        @Override
        public int compare(Gora g1, Gora g2) {
            return g2.getWysokosc() - g1.getWysokosc();
        }
    }
}

package cwiczenia;
import java.util.*;

public class ZbiorTestowy {
    public static void main(String[] args) {
        ZbiorTestowy zbior = new ZbiorTestowy();
        zbior.doDziela();
    }

    private void doDziela() {
        Ksiazka k1 = new Ksiazka("Ostatnie życzenie", "Andrzej Sapkowski");
        Ksiazka k2 = new Ksiazka("Silmarillion", "J.R.R. Tolkien");
        Ksiazka k3 = new Ksiazka("Inferno", "Dan Brown");
        utworzPosortowanyZbiorKsiazek(k1, k2, k3);
    }

    private void utworzPosortowanyZbiorKsiazek(Ksiazka k1, Ksiazka k2, Ksiazka k3) {
        TreeSet<Ksiazka> zbiorKsiazek = new TreeSet<>();
        zbiorKsiazek.add(k1);
        zbiorKsiazek.add(k2);
        zbiorKsiazek.add(k3);
        System.out.println("Posortowany zbiór książek: \n" + zbiorKsiazek);
    }

    private class Ksiazka implements Comparable{
        private String tytul;
        private String autor;

        Ksiazka (String t, String a){
            tytul = t;
            autor = a;
        }

        @Override
        public String toString(){
            return autor + ": " + tytul;
        }

        @Override
        public int compareTo(Object o) {
            Ksiazka k = (Ksiazka) o;
            return tytul.compareTo(k.tytul);
        }
    }
}

package cwiczenia;
import java.util.*;

public class TestMap {
    public static void main(String[] args) {
        HashMap<String, Integer> wyniki = new HashMap<>();

        wyniki.put("Kasia", 42);
        wyniki.put("Berta", 343);
        wyniki.put("Sabina", 420);

        System.out.println(wyniki);
        System.out.println(wyniki.get("Berta"));
    }
}

package cwiczenia.typyOgolne;

public class TestTypowOgolnych1 {
    public static void main(String[] args) {
        new TestTypowOgolnych1().doDziela();
    }

    private void doDziela() {
        Zwierze[] zwierzeta = {new Pies(), new Kot(), new Pies()};
        Pies[] psy = {new Pies(), new Pies(), new Pies()};
        nakarmZwierzeta(zwierzeta);
        System.out.println();
        nakarmZwierzeta(psy);
    }

    private void nakarmZwierzeta(Zwierze[] zwierzeta) {
        for(Zwierze z: zwierzeta){
            z.jedz();
        }
    }
}

package cwiczenia.typyOgolne;
import java.util.*;

public class TestTypowOgolnych2 {
    public static void main(String[] args) {
        new TestTypowOgolnych2().doDziela();
    }

    private void doDziela() {
        ArrayList<Zwierze> zwierzeta = new ArrayList<>();
        zwierzeta.add(new Pies());
        zwierzeta.add(new Kot());
        zwierzeta.add(new Pies());
        nakarmZwierzeta(zwierzeta);

//        ArrayList<Pies> psy = new ArrayList<>();
//        psy.add(new Pies());
//        psy.add(new Pies());
//        psy.add(new Pies());
//        System.out.println("");
//        nakarmZwierzeta(psy);                         // to nie zadziała
    }

    private void nakarmZwierzeta(ArrayList<Zwierze> zwierzeta) {
        for(Zwierze z: zwierzeta){
            z.jedz();
        }
    }
}

package cwiczenia.typyOgolne;
import java.util.*;

public class TestTypowOgolnych3 {
    public static void main(String[] args) {
        new TestTypowOgolnych3().doDziela();
    }

    private void doDziela() {
        ArrayList<Zwierze> zwierzeta = new ArrayList<>();
        List<Zwierze> lista = zwierzeta;
        zwierzeta.add(new Pies());
        zwierzeta.add(new Kot());
        zwierzeta.add(new Pies());
        nakarmZwierzeta(zwierzeta);
        nakarmZwierzeta2(zwierzeta);
        System.out.println(lista);

        ArrayList<Pies> psy = new ArrayList<>();
        psy.add(new Pies());
        psy.add(new Pies());
        psy.add(new Pies());
        System.out.println();
        nakarmZwierzeta(psy);
        nakarmZwierzeta2(psy);
    }

    private void nakarmZwierzeta(ArrayList<? extends Zwierze> zwierzeta) {
        for(Zwierze z: zwierzeta){
            z.jedz();
        }
    }
    private <T extends Zwierze> void nakarmZwierzeta2(ArrayList<T> zwierzeta) {             // te deklaracje metod mają to samo znaczenie
        for(Zwierze z: zwierzeta){
            z.jedz();
        }
    }
}

package cwiczenia.typyOgolne;

abstract class Zwierze {
    void jedz(){
        System.out.println("zwierz wcina");
    }
}

package cwiczenia.typyOgolne;

class Kot extends Zwierze {
}

package cwiczenia.typyOgolne;

class Pies extends Zwierze{
}