Kontynuacja pracy z plikami – w poprzednim wpisie omówiliśmy jak zrobić zapis do pliku, dziś zajmiemy się odczytem. Podobnie jak przy zapisie mamy wiele opcji do wyboru 😉

Podobnie jak w przypadku zapisu do pliku przy użyciu BufferedWriter, BufferedReder oferuje nam bardzo przejrzyste API do odczytania zawartości pliku:

public static void bufferedReader() throws IOException {
    try (BufferedReader reader = new BufferedReader(new FileReader("test.txt"))) {
        System.out.println(reader.readLine());
    }
}

Scanner jest kolejną klasą która może nam umożliwić odczytanie zawartości pliku:

public static void scannerLineReader() throws FileNotFoundException {
    try (Scanner scanner = new Scanner(new File("test.txt"))) {
            System.out.println(scanner.nextLine());
    }
}

Klasy scanner możemy również używać do czytania pliku z użyciem “ogranicznika”, ogranicznikiem może być wybrany przez nas znak. Scanner będzie czytał do pierwszego wystąpienia danego znaku, kolejne części są czytane z wykorzystaniem metody next().

public static void scannerReader() throws FileNotFoundException {
    try (Scanner scanner = new Scanner(new File("test.txt"))) {
        scanner.useDelimiter(" ");
        while (scanner.hasNext()) {
            System.out.println(scanner.next());
        }
    }
}

Od Javy 7 pojawiła się klasa Pomocnicza: Files, z jej pomocą możemy ułatwić sobie nieco czytanie plików.

public static void filesReader() throws IOException {
    System.out.println(Files.readAllLines(Path.of("test.txt")).get(0));
}

Tylko żeby ktoś nie pomyślał że temat jest wyczerpany! W tym krótkim wpisie przedstawiłem jedynie podstawowe metody do czytania plików. Jeśli ktoś potrzebuje wgłębić się w zaawansowane operacje pracy z plikami, serdecznie zachęcam do zajrzenia do dokumentacji 🙂 Dokumentacja Javy jest na prawdę na dość dobrym poziomie! 🙂

Dziś popracujemy sobie z plikami! Temat wcale nie jest taki oczywisty – Java udostępnia nam wiele możliwości aby zapisać dane do pliku. Postaram się omówić najczęściej używane opcje oraz różnice między nimi. Zaczynamy!

Pierwszą sposób zapisu do pliku jaki przedstawię, jest użycie klasy BufferWriter:

public static void createAndWriteToNewFile(String fileName, String content) throws IOException {
    try (BufferedWriter writer = new BufferedWriter(new FileWriter(fileName))) {
        writer.write(content);
    }
}

Jest to bardzo podstawowa metoda która utworzy nam plik, oraz wypisze w nim to co podaliśmy w metodzie write. W tym momencie należy wspomnieć że wielokrotne uruchomienie tej metody nie spowoduje dodanie do pliku niczego nowego – za każdym razem plik będzie nadpisywany.

Warto również zaznaczyć że BufferWriter jest tworzony w bloku “try with resources”, dzięki temu nie musimy się martwić że jakieś zasoby nie zostaną zamknięte w momencie gdy kończymy pracę.

Żeby dodać do pliku kolejne informacje musimy użyć metody append.

public static void appendFileWithBufferedWriter(String fileName, String content) throws IOException {
    try (BufferedWriter writer = new BufferedWriter(new FileWriter(fileName, true))) {
        writer.append(' ');
        writer.append(content);
    }
}

Kolejną metodą którą możemy użyć aby zapisać informacje do pliku jest PrintWriter

public static void createAndWriteToNewFilePrintWriter(String fileName, String content) throws IOException {
    try (PrintWriter writer = new PrintWriter(new FileWriter(fileName))) {
        writer.println(content);
    }
}

Istnieją pewne różnice pomiędzy BufferedWriter a PrintWriter – PrintWriter posiada dodatkowe metody które mogą nam nieco ułatwić pracę z plikami, właściwie z PrintWriterem możemy pracować tak jak byśmy chcieli wypisać informacje na konsolę.

Jednak PrintWriter “połyka” błędy, zauważ że podczas pracy z PrintWriterem, metody zapisu nie deklarują wyrzucanego wyjątku:

public void println(String x) {...}

Może być to naprawdę problematyczne – w momencie gdy pójdzie coś nie tak, nie dowiemy się o tym, aby sprawdzić czy pojawił się jakiś problem musimy użyć metody checkError.

FileOutputStream jest klasą która pozwoli nam pracować z danymi w postaci binarnej

public void howToUseFOS(String fileName, String content) throws IOException {
    try (FileOutputStream outputStream = new FileOutputStream(fileName)) {
        outputStream.write(content.getBytes());
    }
}

DataOutputStream jest bardzo podobny do klasy opisanej wyżej – jednak pozwala na dodatkowe operacje umożliwiając nam zapis do pliku również typów prostych

try (DataOutputStream dataOutputStream = new DataOutputStream(new FileOutputStream(fileName))) {
    dataOutputStream.write(1);
}

RandomAccessFile jest klasą która pozwala nam edytować plik w wybranym miejscu.

public static void writeToPosition(String filename, String content, long position)
        throws IOException {
    try (RandomAccessFile writer = new RandomAccessFile(filename, "rw")) {
        writer.seek(position);
        writer.write(content.getBytes());
    }
}

Od Javy 7 pojawiła się klasa która nieco ułatwia nam podstawową pracę z pikami. Zamiast zastanawiać się co wybrać – możemy użyć klasy Files! 🙂

public static void java7FilesMethod(String fileName) throws IOException {
    List<String> lines = Arrays.asList("The first line", "The second line");
    Files.write(Paths.get(fileName), lines);
}

Warto wspomnieć że nie są to wszystkie możliwe metody zapisu do pliku, istnieje np. klasa FileChannel która przeznaczona jest do pracy z dużymi plikami. Istnieje również szereg klas które ułatwiają nam pracę z plikami – np. pozawalają na założenie “locka” – powoduje to zablokowanie pliku na inne operacje do momentu w którym nie skończymy swoich operacji.

Bardzo ważną rzeczą jest zamknięcie strumienia danych po zakończonej pracy, najlepiej użyć bloku try-with-resources jak było to pokazane w powyższych przykładach.

Najczęstsze użycia:
PrintWriter – jest używany do zapisu “formatowanego” tekstu z użyciem printf();
FileOutputStream –  do zapisu binarnych danych;
DataOutputStream – do zapisu typów prymitywnych (int, long, double etc.);
RandomAccessFile –  do edycji pliku w konkretnym miejscu;
FileChannel – do pracy z dużymi plikami.

Wpis jest częścią kursu programowania w Javie.

Kolejna część kursu programowania w Javie! Zanim rozpocznę dodatkową serię, roboczo nazwaną Java By Example, chciałbym omówić jeszcze jeden zdecydowanie ważny element języka jakim są wyjątki (ang. Exceptions). Wyjątki w Javie potrafią zaskoczyć. Powiem szczerze że niektóre decyzje projektowe zaskakują mnie do dziś na tym obszarze 😉

Wyjątki w Javie standardowo dzielimy na dwie grupy – Checked exceptions oraz Unchecked Exceptions. Różnica polega na tym że Checked exceptions muszą zostać obsłużone przez programistę, natomiast Unchecked Exceotions mogą być „pozostawione” same sobie. Tyle jeśli chodzi o prostą teorię.

Zawsze pomocny przy takich tematach jest mały diagram 😊 zatem proszę bardzo:

Małe wyjaśnienie. Wszystko co dziedziczy po klasie Throwable zaliczamy do wyjątków, mamy początkowe rozgałęzienie na Error oraz Exception.

Error w 99,9% nie powinien nas przejmować, w momencie kiedy nasz program sypnie errorem nie jesteśmy w stanie nic zrobić. Nasz program po prostu „padnie”. Musimy wtedy poszukać błędu w naszej logice może pojawiła się jakaś nieskończona pętla? Może dodajemy bardzo wiele elementów do ArrayListy co spowoduje przepełnienie pamięci? Tak czy siak, jeśli nasz program wyrzuci error, prawdopodobnie się wyłączy.

W drugiej gałęzi mamy klasę Exception, jest to pierwszy z Checked exceptions (pomijając Throwable który jest rodzicem dla wszystkich wyjątków 😉 ) – wyjątek który musi zostać obsłużony przez programistę. Poniżej mamy RuntimeException który jest pierwszym z Unchecked excptions – wyjątków które nie wymagają od programisty żadnych akcji 😊

Podstawowym mechanizmem jest blok try catch finally, z czego blok finally jest opcjonalny, jest to blok kodu który zawsze się wykona, bez znaczenia czy wystąpi wyjątek czy nie.

try {
    //code
} catch (Exception ex) {
    //code
} finally {
    //code 
}

Checked Exceptions – na diagramie są zaznaczone kolorem czerwonym. Nie są to wszystkie wyjątki Checked Exception’y! Nie starczyło by mi nocy żeby wyrysować je wszystkie 😉 Tak jak zostało to wcześniej powiedziona, są to wyjątki które muszą zostać obsłużone przez programistę.

Jednym z najbardziej popularnych tego typu wyjątków to IOException:

String pathToFile = "C:\\Users\\abc.txt";
BufferedReader bufferedReader = null;
try {
    bufferedReader = new BufferedReader(new FileReader(pathToFile));
    System.out.println(bufferedReader.readLine());
} catch (IOException e) {
    e.printStackTrace();
    System.out.println(e.getMessage());
} finally {
    if(bufferedReader != null) {
        try {
            bufferedReader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    System.out.println("blok finally wykona sie zawsze :)");
}

Co tu się dzieje? Po prostu próbujemy odczytać plik znajdujący się na dysku naszego komputera. Wiele rzeczy przy takiej operacji może pójść nie tak! Chociażby – nie ma takiego pliku w określonej ścieżce.

W momencie kiedy próbujemy użyć metody która w swojej sygnaturze mówi o tym iż może rzucić takim wyjątkiem, nasze IDE podpowie nam, iż musimy taki wyjątek obsłużyć.

Np. metoda readLine()

public String readLine() throws IOException

Aby użyć takiej metody możemy ją zamknąć w bloku try catch tak jak zostało to przedstawione powyżej, lub przesłać wyjątek „dalej do góry”

public static void main(String[] args) throws IOException {
    String pathToFile = "C:\\Users\\abc.txt";
    BufferedReader bufferedReader = null;
    bufferedReader = new BufferedReader(new FileReader(pathToFile));
    System.out.println(bufferedReader.readLine());
}

Unchecked Exception – na diagramie oznaczone kolorem zielonym, są to wyjątki które nie wymagają od programisty żadnej reakcji.  Przykład:

String param = "abc";
Integer number = Integer.valueOf(param);

Jednak oczywiście jeśli mamy takie życzenie, możemy obsłużyć taki wyjątek:

String param = "abc";
try {
    Integer number = Integer.valueOf(param);
    System.out.println("Udała się konwersja na liczbę :)");
} catch (NumberFormatException e) {
    System.out.println("Ejjj '"+param+"' to nie jest liczba!");
}

Nieprzypadkowo wybrałem tego typu przykład 😉 Na StackOverflow jest bardzo fajny temat w którym ludzie dyskutują na temat czy np. NumberFormatException powinien być typu checked (powinna być wymagana obsługa), no ale polecam zajrzeć już do tego wpisu. Naprawdę bardzo ciekawa lektura!

Temat wyjątków został jedynie zarysowany w tym wpisie 😊 Jednak jest to solidna podstawa która w połączeniu z resztą kursu pozwoli nam pisać podstawowe aplikacje! Koncepcje wyjątków w Javie jeszcze poruszę w bardziej zaawansowanym stopniu, w późniejszej części kursu!

Dotarliśmy do końca drogi kolekcji, dziś omówimy Mapy, które zamkną nam serię dotyczącą podstaw kolekcji. Jak to zostało wspomniane we wstępie serii, mapy nie są ściśle kolekcjami – nie dziedziczą interfejsu Collection, jednak zawsze gdy mówi się o kolekcjach w Javie, mapy dokłada do całego grona 😊

Mapy są specyficzną strukturą danych, które przechowują elementy w sposób klucz – wartość. Oczywiście Mapy są generyczne – o typie kluczy jak i wartości decyduje programista, jest to kolejna cecha łącząca Mapy z resztą kolekcji.

Mapa jest bardzo przydatną strukturą, pozwala bardzo szybko pobrać z niej elementy, pod warunkiem że znasz odpowiedni klucz 😉

Klucze w Mapie są unikalne, jednak wartości w mapach mogą się powtarzać. W zależności od implementacji (HashMap oraz LinkedHashMap) możemy posiadać nulle jako klucz oraz wartość, natomiast w przypadku TreeMapy nulle są niedozwolone.

HashMap – Jest najpopularniejszą implementacją, podobnie jak HashSet, HashMapa nie zachowuje konkretnej kolejności.

Map<Integer, String> map = new HashMap<>();
map.put(10, "Arek");
map.put(2,"Zuza");

for (String value : map.values()) {
    System.out.println(value);
}

Wynik:

Zuza
Arek

LinkedHashMap – Jest analogiczna do LinkedHashSetu, zachowuje kolejność elementów w jakiej zostały one dodane.

Map<Integer, String> map = new LinkedHashMap<>();
map.put(10, "Arek");
map.put(2,"Zuza");

for (String value : map.values()) {
    System.out.println(value);
}

Wynik:

Arek
Zuza

TreeMap – Jest analogiczna do TreeSetu, wartość są posortowane według comparatora klucza. Możemy podać własny comparator podczas tworzenia mapy. Jeśli tego nie zrobimy, zostanie użyty domyślny comparator klucza.

Map<Integer, String> map = new TreeMap<>();
map.put(10, "Arek");
map.put(2,"Zuza");
map.put(8,"Klaudiusz");

for (String value : map.values()) {
    System.out.println(value);
}

Wynik:

Zuza
Klaudiusz
Arek

Podstawowymi operacjami na Mapach są operacje put oraz get. Metoda put dodaje element do mapy w postaci klucz – wartość:

Map<Integer, String> map = new HashMap<>();
map.put(10, "Arek");
map.put(2,"Zuza");
map.put(8,"Klaudiusz");

Natomiast metoda get pozwala nam wyciągnąć daną wartość po konkretnym kluczu.

String value = map.get(2);

Jeśli chcemy przeszukać całą mapę, możemy pobrać wszystkie klucze jako Set:

Set<Integer> keySet = map.keySet();

wartości jako Collection:

Collection<String> values = map.values();

lub wszystkie elementy mapy w postaci klucz – wartość jako Set 😊

Set<Map.Entry<Integer, String>> entries = map.entrySet();

Dzięki takim pomocniczym metodą, możemy w łatwy sposób iterować po interesujących nas elementach, korzystamy przecież z dobrze nam znanych kolekcji 😊

Mapy są specyficzną strukturą danych. Umiejętne posługiwanie się mapami pozwoli oszczędzić nam naprawdę sporo mocy obliczeniowej w momencie gdy musimy wyszukiwać specyficzne elementy, dobrze przemyślana mapa może zdecydowanie przyspieszyć działanie naszego programu 😊

Kontynuacja tematu kolekcji 😊 Tak ja powiedziałem w pierwszym wpisie z serii, temat kolekcji jest dość złożony. Dziś omówimy kolejki. Muszę przyznać że przez ponad 7 lat aktywnego programowania czystych Javowych kolejek nie używałem zbyt często 😉 Jednak nie zmienia to faktu że kolejki w określonych sytuacjach mogą być naprawdę bardzo przydatne!

Kolejki zachowują się mniej więcej jak kolejki w sklepie. Ktoś podchodzi do kasy, zanim ustawiają się kolejne osoby, pierwsza osoba zostaje obsłużona, odchodzi o kasy, kolejna osoba jest z przodu, gotowa aby ją obsłużyć. Większość kolejek w Javie jest typu FIFO – first in first out, dokładnie takich jak w sklepie.

Odstępem od kolejek typu FIFO jest PriorityQueue o której wspomniałem w pierwszym wpisie odnośnie kolekcji. Kolejka ta zachowuje się podobnie do TreeSetu, sortuje elementy według comperatora.

ArrayDeque jest  specyficzną implementacją kolejki która pozwala na obsługę elementów z początku jak i końca kolejki.

Ciekawostką jest to że LinkedList jest jednocześnie Listą oraz Kolejką 😊 (Spójrz na rysunek w pierwszym wpisie o kolekcjach), zatem całkowicie poprawnym sposobem na utworzenie kolejki jest taki zapis:

Queue<String> stringQueue = new LinkedList<>();

Podstawowe operacja dla kolejek add, offer, remove, poll, element oraz peek. Wszystkie te metody są zadeklarowane w interfejsie Queue. Jednak tylko trzy z tych metod są najczęściej wykorzystywane, są to:

offer – dodaje element do kolejki, jest to preferowana metoda dodawania elementu do kolejki, metoda add w niektórych implementacjach podczas nieudanego dodania rzuca wyjątkiem, co może zaskoczyć 😉 Gdy pracujemy z kolejkami i chcemy dodać do niej element, stosujmy offer.

poll – pobiera oraz zdejmuje element z początku kolejki.

peek – pobiera element z kolejki bez zdejmowania go.

Należy pamiętać że kolejki należą do kolekcji! Możemy zatem sprawdzić ile elementów znajduje się w kolejce wywołując metodę size, czy przejść przez wszystkie elementy z wykorzystaniem pętli.

Queue<String> stringQueue = new LinkedList<>();
stringQueue.offer("Arek");
stringQueue.offer("Karol");
stringQueue.offer("Robert");
stringQueue.offer("Szymon");

System.out.println(stringQueue.size());
System.out.println(stringQueue.poll());
System.out.println(stringQueue.size());
System.out.println("--------");

for (String hero : stringQueue) {
    System.out.println(hero);
}

Kolejki są naprawdę specyficznym rodzajem kolekcji, jest to bardzo przydatna struktura w określonych sytuacjach. Dobrze mieć świadomość tego jak działa i jakie możliwości oferuje. Nigdy nie wiadomo kiedy przyjdzie czas w którym może uratować sytuację 😊

Dziś kontynuujemy temat kolekcji. W poprzednim wpisie zostały omówione Sety, dziś natomiast zajmiemy się Listami. Temat będzie nieco krótszy od Setów (uffff!), chociażby ze względu na to że omówimy tylko najbardziej popularne implementacje, ArrayList oraz LinkedList. Zapraszam! 🙂

Niezależnie od implementacji, Sety oraz Listy zaliczamy do grona kolekcji, wywodzą się od wspólnego interfejsu Collection. Listy tak samo jak Sety, są generyczne. Czym są generyki zarysowałem w poprzednim wpisie odnośnie Setów.

Główną różnicą jest to iż Lista pozwala przechowywać duplikaty, dokładnie ten sam obiekt, lub taki sam obiekt, możemy dodać wielokrotnie do Listy, gdzie Set nam to uniemożliwi.

Wiele stron oraz kursów w różnicach podaje że Lista jest uporządkowana, natomiast Set nie. Nie jest to prawda! Wszystko zależy od użytej implementacji Setu np. LinkedHashSet zachowuje kolejność dodania 😊

Niezależnie od implementacji z jakiej korzystamy, dysponujemy takim samym podstawowym arsenałem funkcjonalności. Możemy dodawać pojedyncze elementy do listy, dodawać całe kolekcje, usuwać elementy, sortować,  iterować po wszystkich elementach, lub pobrać konkretny element z listy.

Nie będę omawiać tutaj każdego elementu z osobna, operacje są tak domyślne że zachęcam was do samodzielnego eksperymentowania! 😊

Główna różnica leży w wydajności konkretnych implementacji dla danej operacji, np. dodawanie wielu elementów do ArrayListy jest niewydajne, do tego zdecydowanie lepiej nadaje się LinkedLista.

List<Hero> heroList = new LinkedList<>();
heroList.add(new Person("Arek"));
heroList.add(new Person("Arek"));
heroList.add(new Person("Dominika"));
heroList.add(new Person("Karolina"));
heroList.add(new SuperPerson("Dominika"));
for (Hero hero : heroList) {
    System.out.println(hero);
}

//skorzystałem z tych samych klas co w omówieniu Setów

ArrayList jest tak naprawdę dynamiczną tablicą. W ramach przypomnienia odsyłam do lekcji o tablicach, zauważ że podczas tworzenia tablicy deklarujemy jej wielkość która jest niezmienna.

ArrayList wewnętrznie używa tablicy do przechowywania danych, a w momencie dodawania sprawdza czy zbliżamy się do końca tablicy, jeśli tak, tworzona jest nowa tablica o większym rozmiarze, i przepisywane są do niej elementy ze starej tablicy.

Jeśli będziemy dodawać bardzo dużo elementów do ArrayListy, możemy mieć problemy związane z wydajnością. ArrayList ma natomiast przewagę jeśli chcemy odczytywać elementy z wybranych indexów. Dostęp do każdego elementu jest stały.

LinkedList wewnętrznie przechowuje elementy w podwójnie związanej liście elementów. Każdy z elementów posiada wskaźnik do następnego jak i poprzedniego elementu. Iterowania po wszystkich elementach jest szybkie, natomiast pobranie konkretnego elementu z danego indexu wymaga większego nakładu pracy. Wewnętrznie i tak musimy przejść przez wszystkie poprzedzające elementy aż dojdziemy do konkretnego indexu.

Zaletą LinkedListy w porównaniu z ArrayListą jest szybkość wykonywania operacji dodawania oraz usuwania.

LinkedLista powinna być wybierana w przypadku gdy nie posiadamy „losowych” pobrań elementów (z konkretnego indexu), oraz gdy na danej liście stosujemy wiele operacji dodawania lub usuwania elementów.

Jeśli zaś liczba elementów w liście jest stała, oraz potrzebujemy bardzo szybkiego dostępu do elementów znajdujących się na konkretnych pozycjach, wtedy zdecydowanie lepszym wyborem będzie ArrayList.