Show page

Differences

This shows you the differences between two versions of the page.

--- poo-ca-cd:laboratoare:colectii [2024/12/07 14:33]
alexandru.chirac
+++ poo-ca-cd:laboratoare:colectii [2024/12/10 20:41] (current)
alexandru.chirac [Interfaţa Set]
@@ Line 1: / Line 1: @@
-===== Laboratorul 8: Colecții =====
+===== Laboratorul 9: Colecții =====
 **Video introductiv:** [[https://youtu.be/NrcJpB_XLp0| link ]]
@@ Line 232: / Line 232: @@
 | | **HashSet** | **LinkedHashSet** | **TreeSet** |
 | **Funcționarea internă** | Elementele se memorează într-o tabelă de dispersie | Elementele sunt păstrate cu ajutorul unei liste înlănțuite | Elementele se memorează într-un arbore de căutare |
-| **Utilizarea** | Se folosește când dorești să stochezi o listă de perechi cheie-valoare fără a fi interesat de ordinea acestei memorări | Se folosește atunci când se dorește conservarea ordinii de la inserare | Se folosește când se dorește păstrarea elementelor într-o ordine stabilită cu ajutorul unui Comparator |
+| **Utilizarea** | Se folosește când dorești să stochezi o listă de elemente fără a fi interesat de ordinea acestei memorări | Se folosește atunci când se dorește conservarea ordinii de la inserare | Se folosește când se dorește păstrarea elementelor într-o ordine stabilită cu ajutorul unui Comparator |
 | **Ordinea** | Ordinea elementelor este total aleatoare | Se conservă ordinea în care au fost introduse elementele | Se folosește ordinea stabilită cu ajutorul unui Comparator. Daca acesta nu este menționat, implicit elementele vor fi sortate crescător |
 | **Complexitatea operațiilor**| O(1) pentru toate operațiile de bază (inserare, ștergere, căutare) | O(1) pentru toate operațiile de bază (inserare, ștergere, căutare) | Deoarece este folosit un arbore în spate, operațiile se execută in O(log(N)) |
@@ Line 329: / Line 329: @@
   * ''Stack'' - acesta reprezintă implementarea de operații specifice pentru stivă și extinde clasa ''Vector'', despre care am vorbit anterior. Colecția recomandată în locul acesteia este ''ArrayDeque''.
 </note>
-====Funcții lambda====
-În cadrul laboratorului de clase interne, am vorbit despre funcții anonime (funcții lambda) și despre cum le putem folosi în Java.
-Putem folosi funcții anonime pentru a executa diverse operații pe liste (de exemplu ''removeIf'', care filtrează elementele unei colecții pe baza unui predicat, și ''replaceAll'', care aplică o operație pe toate elementele unei colecții).
-Exemple:
-<code java>
-List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
-// incrementează toate numerele din colecție cu 1
-list.replaceAll((x) -> x + 1);
-// șterge din colecție numerele impare
-list.removeIf((x) -> x % 2 == 1);
-</code>
-O altă utilitate a funcțiilor anonime reprezintă în implementarea comparatorilor folosiți la sortare sau la crearea de colecții sortate (TreeSet, TreeMap).
-Exemple:
-<code java>
-// o variantă
-Collections.sort(list, (o1, o2) -> o2 - o1);
-// alta variantă, prin care se folosim de metoda sort() din interfața List
-list.sort((o1, o2) -> o2 - o1);
-// colecții sortate
-TreeSet<Integer> sortedSet = new TreeSet<>((o1, o2) -> o1 - o2);
-TreeMap<Integer, Integer> sortedMap = new TreeMap<>((o1, o2) -> o1 - o2);
-</code>
-====Unit Testing====
-În procesul de dezvoltare software, o parte foarte importantă a acestuia este și verificarea dacă codul scris se comportă în modul așteptat sau nu. Tot ce presupune verificarea funcționalității codului se poate încadra sub umbrela termenului de “Testing”, dintre care există mai multe tipuri (unit testing, functional testing, integration testing, printre altele).
-Elementul de bază în testare îl constituie “unit testing-ul”. Acesta presupune scrierea de teste care verifică funcționalitatea unei singure componente: o clasă cu anumite metode, o structură de date, etc.
-Framework-ul de testare despre care vom vorbi este JUnit5. Pentru o analiză mai amânunțită a acestuia, consultați următoarea pagină: [[poo-ca-cd:alte-resurse:junit-java|JUnit5 Basics]]. Scopul prezentării în acest laborator este de a vă prezenta un punct de start în învățarea acestui framework.
-===Instalare JUnit5===
-Pentru a folosi biblioteca JUnit într-un anumit proiect, urmează următorii pași:
-  - într-un proiect, intrați pe File -> Project Structure -> Libraries
-  - din meniul de Libraries, apăsați pe "+", după care pe "From Maven"
-  - se va deschide un pop-up, în care va trebui să scrieți în fereastra de căutare "org.junit.jupiter:junit-jupiter:5.7.0", după care apăsați "Ok"
-  - IntelliJ vă va întreba dacă vreți să adăugați biblioteca la proiectul curent, apăsați "Ok"
-  - la final, în fereastra inițială apăsați "Apply" -> "Ok"
-{{:poo-ca-cd:laboratoare:tutorial_junit.png?400|}}
-Pentru a putea testa funcționalitatea bibliotecii “JUnit” puteți folosi codul exemplu de aici
-(https://ocw.cs.pub.ro/courses/poo-ca-cd/alte-resurse/junit-java). În cazul în care aveți
-erori, puteți să încercați să reactualizati cache-ul aplicației (File -> Invalidate Caches),
-timp în care JAR-urile și SDK-ul Java vi se vor reindexa (progresul operației se poate
-observa în colțul din dreapta jos sub formă de “loading bar”).
-===Utilizarea framework-ului===
-Pentru a folosi JUnit5, este important de învățat două concepte: cel de adnotări și cel de assert-uri.
-Cel mai mare avantaj al JUnit este viteza rapidă de scriere a testelor, iar lucrul acesta este posibil datorită adnotărilor. Adnotările sunt termeni standardizați, prefațați de semnul “@”, plasați fix înaintea semnăturii unei funcții. Scopul acestora este că, în momentul compilării, compilatorul să știe să adauge funcționalitate în plus metodei căreia a fost adăugat.
-Printre adnotările de bază din JUnit5 se numără:
-  * **@Test** - metoda va funcționa ca test, aceasta va trebui să întoarcă o valoare de True dacă funcționalitatea testată funcționează în modul dorit, False în mod contrar (lucru posibil prin assert-uri, despre care vom vorbi mai jos)
-  * **@BeforeEach** - metoda va fi executată înaintea fiecărui test
-  * **@AfterEach** - metoda va fi executată după fiecare test
-  * **@DisplayName(“Some_String”)** - se folosește împreună cu @Test; când testul se rulează, la consolă va apărea la output cu numele “Some_String”
-Pentru a vedea toate adnotările disponibile în JUnit5, consultați următoarea pagină de documentație https://www.swtestacademy.com/junit-5-annotations/.
-Așa cum am menționat mai sus, cel de-al doilea concept necesar scrierii testelor este cel de assert-uri. Acestea metode statice, care sunt găsite în clasa org.junit.jupiter.api.Assertions , afirmă valoarea de adevăr a diferite expresii. În continuare, vă vom prezenta câteva exemple de assert-uri des folosite:
-  * **assertEquals(value_1, value_2)** - verifică dacă cele două valori sunt egale
-  * **assertTrue(boolean value)**, respectiv **assertFalse(boolean value)** - verifică dacă value este True, respectiv False
-  * **assertNull(obj)**, respectiv **assertNotNull(obj)** - verifică dacă obj este Null, respectiv dacă nu este
-Pentru mai multe detalii despre toate funcțiile de assert existente, consultați următoarea pagină de documentație: http://junit.sourceforge.net/javadoc/org/junit/Assert.html
-Pentru a scrie teste corect și cu bună vizibilitate, aveți în minte următoarele lucruri:
-  * puneți nume sugestive pentru fiecare metodă de test pe care o implementați
-  * scrieți metode de test care să testeze doar o anumită funcționalitate, nu mai multe deodată
-  * țineți minte că testele sunt făcute să verifice că implementările făcute de voi funcționează în modul dorit de voi
-===Exemplu de folosire JUnit5===
-**FloatCalculator class**
-<code java>
-package main;
-public class FloatCalculator {
-    public float add(float first, float second) {
-        return first + second;
-    }
-    public float multiply(float first, float second) {
-        return first * second;
-    }
-    public float divide(float first, float second) {
-        return first / second;
-    }
-    public boolean isNegative(float num) {
-        return num < 0;
-    }
-}
-</code>
-**FloatCalculatorTest class**
-<code java>
-package main;
-import org.junit.jupiter.api.*;
-public class FloatCalculatorTest {
-    private FloatCalculator calculator;
-    @BeforeEach
-    public void setUp() {
-        this.calculator = new FloatCalculator();
-    }
-    @AfterEach
-    public void clean() {
-        this.calculator = null;
-    }
-    @Test
-    @DisplayName("Add test")
-    public void testAdd() {
-        Assertions.assertEquals(5, calculator.add(2, 3));
-        Assertions.assertNotEquals(5, calculator.add(2, 2));
-    }
-    @Test
-    @DisplayName("Multiply test")
-    public void testMultiply() {
-        Assertions.assertEquals(6, calculator.multiply(2, 3));
-        Assertions.assertNotEquals(7.5f, calculator.multiply(2.5f, 4));
-    }
-    @Test
-    @DisplayName("Divide test")
-    public void testDivide() {
-        Assertions.assertEquals(10, calculator.divide(100, 10));
-        Assertions.assertNotEquals(5.5f, calculator.divide(55, 12));
-    }
-    @Test
-    @DisplayName("IsNegative test")
-    public void testIsNegative() {
-        Assertions.assertTrue(calculator.isNegative(-5));
-        Assertions.assertFalse(calculator.isNegative(10));
-    }
-}
-</code>
 ====TL;DR====
@@ Line 501: / Line 349: @@
 După implementarea clasei, sortați elementele listei "students" din metoda main folosind metoda Collections.sort().
-. Sortați lista "copyStudents" din metoda main folosind, de această dată, o expresie lambda.
+. Adăugați lista "copyStudents" într-un PriorityQueue (cu ajutorul metodei Collection.addAll), care folosește un Comparator (utilizați constructorul PriorityQueue) sau o funcție anonimă. Elementele vor fi sortate crescător după id.
-. Adăugați lista "anotherCopyStudents" într-un PriorityQueue (cu ajutorul metodei Collection.addAll), care folosește un Comparator (utilizați constructorul PriorityQueue) sau o funcție anonimă. Elementele vor fi sortate crescător după id.
 . Suprascrieți metodele equals și hashCode în clasa Student (puteți folosi generatorul de cod din IntelliJ). După aceasta, adăugați în lista asociată studentilor din "studentMap" patru materii aleatorii. Pentru a obține materiile aleatorii, urmăriți indicațiile din codul din funcția main.
 . Extindeți clasa LinkedHashSet<Integer> cu o clasă în care se vor putea adăuga doar numere pare. Metoda add va fi suprascrisă astfel încât să nu permită adăugarea de numere impare în colecție. Efectuați aceeași operațiune și pentru clasele TreeSet și HashSet. Observați diferențele privind ordinea de inserare a elementelor între cele trei clase menționate.
-Scheletele il puteți gasi pe [[https://github.com/oop-pub/oop-labs/blob/master/src/lab8/Main.java|github]]. Soluția trebuie încărcată pe [[https://beta.lambdachecker.io|LambdaChecker]].
+Scheletul il puteți gasi pe [[https://github.com/oop-pub/oop-labs/blob/master/src/lab8/Main.java|github]]. Soluția trebuie încărcată pe [[https://code.devmind.ro|devmind]].
 ==== Resurse ====
   * [[:poo-ca-cd:laboratoare:old-exercises#colectii|Exerciții din alți ani]]

Administrativ

Laboratoare

Teme

Resurse utile

Alte resurse

Arhiva laboratoare

Arhiva teme

Arhiva teste grila

Teste grilă

poo-ca-cd/laboratoare/colectii.1733574818.txt.gz · Last modified: 2024/12/07 14:33 by alexandru.chirac

Show page Old revisions

Media Manager Back to top