Académique Documents
Professionnel Documents
Culture Documents
Tipuri de date
Siruri
1.Declarare
package main;
/*Variabila pentru declarare este alcătuită din 2 părţi: tipul şi denumirea şirului. Parantezele drepte
reprezintă caractere speciale care spun că această variabilă este de fapt un şir. Prin declarare nu se creează
automat şi şirul. Declararea îi spune compilatorului că variabila creată va conţine valoarea şirului cu tipul
marcat.*/
int[] array;
2.Initializare acces
package main;
import java.util.Arrays;
/*clasa Arrays conţine metode pentru manipularea şirurilor, iar metoda toString() returnează
reprezentarea string a conţinutului şirului */
System.out.println(Arrays.toString(șir)); // [0, 0, 0, 0, 0]
/*Variabila x va conţine 5 elemente dintre care fiecare va prezenta un spaţiu cu valoarea int 1. Vor fi
iniţializate automat şi toate valorile în cadrul lui la 0.*/
1
//
/*Ca să umplem şirul de valori, tratăm fiecare membru al său ca o variabilă specială, folosind poziţia sa
de identificare.*/
System.out.println(Arrays.toString(şir)); // [23, 0, 0, 0, 0]
//
/*Şirul se poate iniţializa şi declara în prima linie, dacă ştim dinainte valorile elementelor sale. */
int[] şir1 =
3, 5, 2, 6, 1, 6
};
System.out.println(Arrays.toString(şir1)); // [3, 5, 2, 6, 1, 6]
//
/*După ce creăm şirul, acestuia nu i se mai poate schimba dimensiunea sau structura.*/
//
/* Data din şir se obţine cu numele şirului şi prin alocarea numărului de index (numeraţie) în paranteză
dreaptă. */
int x = şir1[3];
System.out.println(x); // 6
//
şir1[3] = 5;
System.out.println(Arrays.toString(şir1)); // [3, 5, 2, 5, 1, 6]
//
/* Şirul poate să accepte exclusiv valori de acelaşi tip. Pe de altă parte, există trucuri cu care putem
pune tipuri de valori diferite în primul şir. Unul din ele este crearea şirului de obiecte.*/
//
//int integerArray[] =
//{
//3, 6.5, 2, 6, 1, 6 // eroare (incompatible types: possible loosy conversion from double to int)
//};
//
2
Object objectArray[] =
3, 6.5, 2, 6, 1, 6
};
/*Şirul este alcătuit din obiecte, deoarece Object este tipul de bază în Java, pe care se bazează toate
celelalte tipuri. Şirul care nu permite amestecarea tipurilor, totuși, poate să funcţioneze cu diferite tipuri,
deoarece tipurile în şir sunt într-adevăr înscrise ca egale, respectiv, înainte să fie puse în şir, compilatorul le
transformă în tipul Object, iar la scoaterea din şir, le converteşte în tipul lor sursă. */
3.Lenght
package main;
int array[] =
3, 5, 2, 6, 1, 6
};
System.out.println(array.length); // 6
3
4.Copiere
package main;
import java.util.Arrays;
/*Odată format, şirul nu îşi poate modifica dimensiunea. Aceasta poate fi o problemă, dacă vrem să
adăugăm elemente noi în şir. Soluţia este copierea şirului 2 în şirul 3, manual sau cu ajutorul metodelor
finite. */
int array[] =
3, 5, 2, 6, 1, 6
};
int array1[] =
12, 13, 14
};
/* metoda arraycoppy() copiază un şir în altul, începând de la poziţiile date şi având o anumită lungime
*/
4
// Copierea şirului 2 în şirul 3.
System.out.println(Arrays.toString(destArray));
5.Sortare
package main;
import java.util.Arrays;
int arr[] =
3, 5, 2, 6, 1, 6
};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr)); // [1, 2, 3, 5, 6, 6]
6.Cautare
5
package main;
import java.util.Arrays;
int[] a =
5, 1, 3, 4, 2
};
Arrays.sort(a);
/*Metoda binarySearch() cauta valoarea data în sirul numerelor întregi cu ajutorul algoritmului cautarii
binare. Sirul trebuie sortat anterior. Valoarea returnata va fi >=0 daca elementul este gasit. */
System.out.println(Arrays.binarySearch(a, 2)); // 1
System.out.println(Arrays.binarySearch(a, 6)); // -6
7.Fill
package main;
import java.util.Arrays;
/*metoda fill () cu 2 parametri alocă valoarea int fiecărui element al şirului cu numere întregi */
Arrays.fill(array, 7);
6
System.out.println(Arrays.toString(array)); // [7, 7, 7, 7, 7, 7]
//
/*metoda fill() cu 4 parametri atribuie valoarea int fiecărui element din şir cu numere întregi în
intervalul dat de index (parametrul 2 şi 3) */
Arrays.fill(array1, 0, 4, 7);
System.out.println(Arrays.toString(array1)); // [7, 7, 7, 7, 0, 0]
//
/*Această metodă se foloseşte rar, pentru completarea şirurilor în condiţii reale. Ea este utilă când
vrem să alocăm elementelor şirului aceleaşi valori. Totuşi, şirurile se completează cel mai des cu trecerea
prin buclă.*/
8.Multidimensional
package main;
/*Şirurile multidimensionale sunt utile pentru lucrul cu datele care au forma matriceală sau tabelară.
*/
//
int[][] matrix
{
7
1, 2, 3, 4
},
5, 6, 7, 8
},
9, 10, 11, 12
};
//
/*Pentru ca compilatorul să ştie că șirul nu este unidimensional, setăm 2 semne ale şirului lângă tipul
[][].*/
//
System.out.println(matrix[0][0]); // 1
System.out.println(matrix[1][2]); // 7
//
int[][][] matrix1 =
1, 2, 3, 4
},
5, 6, 7, 8
},
9, 10, 11, 12
},
8
{
},
},
},
},
};
//
/*Şirul multidimensional se poate crea şi fără iniţializare, aşadar, la declarare, vom stabili numărul de
elemente, apoi vom seta manual valorile:*/
arr[0][0] = 1;
arr[0][1] = 2;
arr[1][0] = 3;
arr[1][1] = 4;
System.out.println(arr[0][1]); // 2
9
//
/*Numărul dim. nu trebuie să se oprească la 3. Se pot forma şi şiruri cu 4 şi mai multe dim. Astfel de
şiruri sunt greu de înţeles, iar utilizarea lor este rară.*/
Exerciţii
Exerciţiul 1
Trebuie creat un program care adună două matrice. Prima matrice are valoarea:
1 2 3
5 6 7
9 0 1
4 1 6
2 3 5
7 4 3
package main;
/*Matricele se adună astfel încât fiecare membru al unei matrice se adună cu membrul altei
matrice pe aceeaşi poziţie. */
int[][] matrix1 =
1, 2, 3
10
},
5, 6, 7
},
9, 0, 1
};
int[][] matrix2 =
4, 1, 6
},
2, 3, 5
},
7, 4, 3
};
11
matrix3[0][0] = matrix1[0][0] + matrix2[0][0];
Exerciţiul 2
Trebuie să creat un program care va sorta şirul dat şi la ieşire va da şirul vechi şi cel nou:
int[] array = {1, 5, 33, 563, 0, 2, 23, 9, 9, 11, 987, 23, 934,
999, 43};
package main;
import java.util.Arrays;
Arrays.sort(array);
System.out.println("This is a sorted array:" + Arrays.toString(array));
}
}
Modulul 4.Controlul fluxului,buclele si ramnificarea
Buclele
“If”
1.Exerciţiul 1
Este necesară următoarea construcție logică: dacă x primește o valoare mai mare decât zero, se intră
în blocul de cod și x este egal cu 3.
1.package main;
int x = 0;
if(x > 0)
x = 3;
2. Exerciţiul 2
code
13
source
1. if(x=y)
2.
3. {
4.
5. //logic goes here
6.
7. }
8.
9. else if(x=0);
10.
11. {
12.
13. //logic goes here
14.
15. }
16.
17.
18.
19. else(x)
20.
21. {
22.
23. //logic goes here
24.
25. }
package main;
int x = 0, y = 1;
else
14
}
Exemple probleme
1.package main;
int x = 0;
else
else
if(num == 10)
15
x = 110;
if(x != 0)
x = 110;
else
if(true)
System.out.println("This works!\n");
if(false)
System.out.println("conditional execution\n");
if(false)
16
{
System.out.println("conditional execution");
x = 0;
if(x == 1)
System.out.println("x je 1\n");
if(x == 2)
System.out.println("x je 2\n");
if(x == 3)
System.out.println("x je 3\n");
else
System.out.println(mood + "\n");
isHappy = true;
System.out.println(mood + "\n");
int variableA = 2;
{
17
// logica...
char op = '/';
double a = 5;
double b = 3;
if(op == '+')
System.out.println(a + b);
if(op == '-')
System.out.println(a - b);
if(op == '/')
System.out.println(a / b);
if(op == '*')
System.out.println(a * b);
System.out.println();
/* La construirea condiţiei se poate folosi o combinaţie de expresii, până când combinaţia completă dă
ca rezultat tipul boolean.*/
x = 3;
if(x > 1 && x < 5) // unim 2 expresii cu operatorul logic && (AND)
else
x = 15;
System.out.println("Condition is fulfilled\n");
else
}}
18
“Switch”
package main;
int x = 5;
if(x == 1)
System.out.println("x = 1");
else
if(x == 2)
System.out.println("x = 2");
else
if(x == 3)
System.out.println("x = 3");
else
System.out.println("x != 1, x != 2, x != 3");
System.out.println();
/* Valoarea care este menţionată între parantezele blocului switch se compară cu valorile menţionate între
semnele/mărcile case. Dacă valoarea coincide cu un dintre valorile din semnul/marca case, se execută un
grup de comenzi care însoțesc acest semn. Dacă valoarea expresiilor este diferită de toate cele menţionate,
se execută grupul de comenzi după semnul default. */
x = 5;
switch(x)
19
{
case 1:
System.out.println("x = 1");
break;
case 2:
System.out.println("x = 2");
break;
case 3:
System.out.println("x = 3");
break;
default:
System.out.println("x != 1, x != 2, x != 3");
break;
System.out.println();
/* Partea implicită a fiecărui case block este comanda break. Dacă nu este menţionată această
comandă, se va ajunge la execuția tuturor blocurilor de cod.*/
x = 1;
switch(x)
case 1:
System.out.println("x = 1");
case 2:
System.out.println("x = 2");
default:
System.out.println("x!=1 x!=2");
System.out.println();
/* Java permite procesarea valorilor număr întreg, a caracterului şi enumerării, iar începând cu
versiunea 1.7 permite şi procesarea stringurilor în structura Switch.*/
20
// Exemplu de utilizare a valorii string ca şi condiţie pentru intrare într-un anumit bloc
String a = "myValue";
switch(a)
case "myValue":
System.out.println("myValue text");
break;
case "otherValue":
System.out.println("otherValue text");
break;
System.out.println();
x = 4;
switch(x)
case 1:
System.out.println("No. is 1, 2 or 3!");
break;
case 2:
System.out.println("No. is 1, 2 or 3!");
break;
case 3:
System.out.println("No. is 1, 2 or 3!");
break;
default:
break;
21
System.out.println();
/* Există posibilitatea ca acelaşi cod să se scrie mult mai simplu şi mai transparent, deoarece în codul
de sus am repetat de 3 ori blocul identic de comenzi. În construcţia switch se poate executa acelaşi bloc de
cod în condiţii diferite, respectiv valori test. */
x = 4;
switch(x)
case 1:
case 2:
case 3:
System.out.println("No. is 1, 2 or 3!");
break;
default:
break;
package main;
Problema 1
Trebuie să verificăm restul împărţirii dintre x şi y. Dacă nu există rest, trebuie să se afişeze mesajul că restul
nu există, în caz contrar, trebuie să se verifice dacă restul este mai mare sau mai mic decât o mie şi să se
afişeze mesajul corespunzător
int x = 523134;
int y = 325423;
22
public static void main(String[] args)
//input data
int x = 523134;
int y = 325423;
int remainder = x % y;
switch(remainder)
case 0:
break;
default:
else
break;
Problema 2
Trebuie să se facă o structură condițională care va verifica dacă producătorul automobilului este
Ford și, dacă este, în funcție de numărul de uși, să afișeze mesajul adecvat.
package main;
23
public class Main
int doors = 4;
switch(carMake)
case "Ford":
case 3:
break;
case 4:
break;
case 5:
break;
break;
default:
break;
24
}
“For”
1.Problema 1
Cu ajutorul buclei for, trebuie să copiem acest şir în şirul arr1, unde toţi membrii cu valoarea -1
trebuie înlocuiţi de membrii cu valoarea zero. Arr1 trebuie afişat apoi la ieşire.
package main;
import java.util.Arrays;
int[] arr =
1, 2, -1, 4, 5, -1
};
int[] arr1 = new int[arr.length]; // se creaza sirul1 de aceasi marime precum sirul
System.out.println(Arrays.toString(arr1));
2.Problema 2
package main;
import java.util.Arrays;
String[][] users =
},
},
};
26
for(int i = 0; i < users.length; i++)
names[i] = users[i][0];
System.out.println(Arrays.toString(names));
3.package main;
/*Adăugarea elementelor şirului în buclă: Se foloseşte variabila ajutătoare sum care iniţial are valoarea
0. Valoarea fiecărui element nou-citit se adaugă la valoarea curentă a acestei variabile.*/
int sum = 0;
sum += array[i];
/*Calculul mediei aritmetice ca şi raport dintre suma elementelor şirului şi numărul lor.*/
Alte aplicatii
1.package main;
/*Bucla for se foloseşte când se ştie în avans numărul de repetări ale unui bloc al comenzii.*/
/*Primul parametru se foloseşte la crearea şi setarea valorii iniţiale a contorului. Al doilea parametru
conţine condiţia contorului (adică la ce valoare a contorului va fi activă bucla), iar al treilea parametru
stabileşte în ce mod se schimbă contorul(adică pasul de mărire sau de micşorare).*
System.out.println("Welcome!");
System.out.println();
/*Contorul are mai multe semnificaţii. Acesta este în primul rând singurul mod de a controla numărul
de execuții ale unui bloc în buclă. Dar, pe lângă aceasta, în fiecare cerc al buclei (iteraţiei) contorul ne
afișează valoarea sa, pe care o putem folosi. După finalizarea buclei, variabila definită ca şi contorul buclei
își încetează existenţa (dacă am declarat-o în cadrul definiţiei buclei).*/
System.out.println(counter);
System.out.println();
System.out.println(counter);
System.out.println();
/*Dacă, după bloc, mai adăugăm o linie în care am prezenta valoarea variabilei contor, s-ar ajunge la
eroare, deoarece variabila contor este declarată şi iniţializată în cadrul buclei.*/
System.out.println(counter);
//System.out.println(counter); // eroare!
System.out.println();
28
/*Dacă am vrea să ne fie în continuare accesibil contorul pentru utilizarea după executarea buclei,
atunci ar trebui să-l declarăm mai devreme, în afara definiţiei buclei.*/
int counter;
System.out.println(counter);
System.out.println(counter + "\n");
/*Bucla iterează de 5 ori, de câte ori a fost îndeplinită condiţia. După aceasta, valoarea variabilei contor
creşte cu 1 (primeşte valoarea 5), imediat ce condiţia nu mai este îndeplinită. Ca rezultat, bucla este
părăsită, dar valoarea contorului este în continuare 5. */
String[] colors =
};
System.out.println();
/*Există trei părţi de iniţializare a buclei for. În exemplele precedente fiecare parte a avut câte 1
parametru, dar aceasta nu este structura obligatorie. Uneori putem să definim mai mulţi parametri în prima
iniţializare.*/
int i;
int a;
System.out.println();
// Totuşi, bucla for va funcţiona chiar dacă nu se introduc toţi cei 3 parametri
System.out.println(j++);
29
System.out.println();
/*Incrementarea am făcut-o în bloc, ceea ce poate fi foarte periculos, deoarece dacă se ajunge la lipsa
incrementului, putem intra în aşa-numita buclă infinită.*/
/*În general, trebuie să ne ferim de buclele infinite, deoarece există diferite moduri de a se produce. Pur şi
simplu, aveţi grijă ca bucla voastră să fie concepută astfel încât condiţiile ei pentru executare să fie
întotdeauna îndeplinite. */
// System.out.println(j++);
/*După condiţie, se poate scrie doar un rând din cod fără paranteze. Dacă vreţi să scrieţi un bloc (2 linii
şi mai mult), trebuie să puneţi întregul bloc între paranteze acolade.*/
i = 0;
System.out.println(i);
System.out.println();
/*Valoarea variabilei „i“ va fi, după executare, 10. De aceea, este cel mai bine să se respecte anumite
denumiri standard ale variabilelor care vor fi folosite în acest scop. De exemplu, chiar litera i. Aşa vom şti
întotdeauna că această literă va fi rezervată pentru buclă şi nu o vom folosi pentru variabile actuale.*/
System.out.println(u);
System.out.println();
/* Acest exemplu va scrie clar variabila „u“ de 100 de ori. Deoarece bucla „i“ este bucla externă, iar
bucla „u“ se execută în cadrul ei, de fiecare dată când are loc prima iteraţie a buclei „i“, se va executa un
ciclu complet al buclei u… şi tot aşa, până la ultima iteraţie a buclei „i“,când va fi gata şi întregul ei ciclu. */
/*La începutul buclei am menţionat că se „măreşte” contorul buclei. Aceasta nu este regula obligatorie.
Contorul se poate şi micşora, nici nu trebuie să existe. */
System.out.println(i);
}
30
}
2.package main;
/*Bucla foreach reprezintă variaţia buclei for, destinată exclusiv lucrului cu şiruri şi colecţii.*/
/*Nu trebuie să ştim nimic despre şirul prin care vrem să trecem, doar numelui său. La iniţializare,
introducem denumirea şirului şi numele variabilei pentru care vrem să preia valoarea actuală a şirului la
fiecare iteraţie. */
int[] arr =
1, 2, 3, 4, 5
};
System.out.println(val);
/*De exemplu, se trece prin şir şi la fiecare iteraţie, valoarea elementului curent se mută în variabila
val. În blocul de comenzi se poate folosi această variabilă, dar astfel încât valoarea inițială a elementului
curent al şirului să nu fie modificată.*/
//
System.out.println();
//
int[] numbers =
3, 5, 9
};
System.out.println(number);
31
/*La fiecare trecere prin buclă, valoarea elementului curent se scrie la ieşire.*/
//
System.out.println();
//
System.out.println(number);
3.package main;
/*Controlul fluxului buclei se poate face în câteva moduri. Primul mod este modificarea manuală a
contorului.*/
if(i > 5)
i = 10;
System.out.println(i);
//
System.out.println();
//
if(i > 5)
break;
System.out.println(i);
//
/*Acest exemplu scrie 10 rânduri, în care fiecare va conţine numere de la 0 la 5. De fiecare dată când
contorul iteraţiei buclei interne este egal cu 5, aceasta se întrerupe. Astfel, bucla externă își continuă
activitatea.*/
System.out.print("\n" + i + ":");
System.out.print(u);
if(u == 5)
break;
//
System.out.println("\n");
//
/*Diferenţa dintre comenzile break şi continue: continue trece imediat la următoarea iteraţie a buclei,
în timp ce break întrerupe executarea completă a buclei şi trece la codul definit sub buclă.*/
/*Următorul exemplu va prezenta toate numerele în afară de numărul 5, deoarece am menţionat explicit
că, atunci când apare numărul 5, executăm comanda continue, respectiv sărim această iteraţie a buclei.*/
if(i == 5)
continue;
System.out.print(i);
}
33
}
“Do-While”
1.Exercitiu 1
package main;
int x = 0;
System.out.println(arr[x]);
x++;
2.Exercitiu 2
package main;
int[] arr =
1, 2, 3, 4, 5, 6, 7, 8, 9, 10
};
// Modificarea codului din sarcina precedentă astfel încât să se execute cu ajutorul buclei do-while.
34
int x = 0;
do
System.out.println(arr[x]);
x++;
Alte aplicatii
1.package main;
/*Pentru bucla while este caracteristic faptul că o folosim când nu ştim în avans număr exact de iterații
înainte de executarea a, ci aceasta depinde, de obicei, de îndeplinirea condiţiilor în cadrul corpului ei.
Aceasta repetă pur şi simplu un bloc de comenzi cât timp o condiţie este corectă. */
int number = 5;
while(number >= 2)
System.out.println(number);
/*În iniţializarea buclei nu există ceva precum incrementul în bucla for. De fapt, această buclă nu
trebuie să manipuleze orice contor. Singurul lucru necesar este ca, la fiecare iteraţie următoare, valoarea
35
condiţiei să fie corectă. Aceasta poate prezenta şi o problemă, deoarece această buclă trebuie controlată
manual. Bucla while ca tip de date al condiţiilor necesită tipul boolean.*/
/*Este foarte important ca în buclă să avem întotdeauna un mijloc de a manipula această buclă (în
afară de comenzile break şi continue). Bucla while acceptă exclusiv tipul boolean, ca rezultat al expresiei
condiţionale, deşi o altă înregistrare nu ar înregistra greşeala de sintaxă. De exemplu, următorul exemplu se
va executa, dar este total inutil şi va duce la o bucla infinită.*/
// System.out.println("in progress");
2.package main;
/*Bucla do/while este similară cu while, cu diferenţa că la bucla do/while condiţia se verifică după
executarea blocului de comenzi, nu înainte. Aceasta înseamnă că blocul de comenzi în cadrul buclei
do/while se va executa cel puţin o dată, indiferent de corectitudinea condiţiilor.*/
int number = 5;
do
System.out.println(number);
number--;
System.out.println();
36
/*În bucla while sunt valabile aceleaşi reguli de sintaxă ca şi în celelalte structuri ale fluxului. De
asemenea, sunt valabile regulile de punere oligatorie a parantezelor acolade dacă blocul este mai lung de o
linie. Acest lucru este valabil şi pentru do/while. Totuşi, la scrierea fără acolade trebuie să aveţi grijă,
deoarece, deşi pare ca şi cum blocul ar fi încercuit de structură (precum cazurile switch-case), în bucla
do/while nu doar că nu se va executa mai mult de o linie în cadrul buclei (fără acolade), ci se va ajunge la
eroare. */
number = 5;
do
number -= 1;
/*Acest cod va enunţa eroare din cauză că nu are paranteze acolade, deși apar mai multe linii în corp.
*/
number = 5;
do
//System.out.println(number); // eroare!
number -= 1; // eroare!
37