Java

Modulul 3.
Tipuri de date
Siruri
1.Declarare
package main;
public class Main
public static void main(String[] args)
/*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;
public class Main
/*Ca să creăm şirul, folosim cuvântul cheie new. */
int șir[] = new int[5];
/*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.*/
şir [0] = 23;
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
//
/*să punem o valoare în şir*/
ş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
};
System.out.println(Arrays.toString(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;
public class Main
/*calculul dimensiunii şirului, respectiv a numărului membrilor săi*/
int array[] =
3, 5, 2, 6, 1, 6
};
System.out.println(array.length); // 6
/indexul şirului nu este la fel ca şi numărul elementelor şirului */
3
4.Copiere
package main;
/*clasa Arrays conţine diferite metode pentru manipularea şirurilor*/
public class Main
/*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
};
// lungimea şirului 3 (rezultat) este suma lungimilor primelor 2 şiruri
int destArray[] = new int[array.length + array1.length];
/* metoda arraycoppy() copiază un şir în altul, începând de la poziţiile date şi având o anumită lungime
*/
// Copierea primului şir în şirul 3.
System.arraycopy(array, 0, destArray, 0, array.length);
4
// Copierea şirului 2 în şirul 3.
System.arraycopy(array1, 0, destArray, array.length, array1.length);
System.out.println("Array length is: " + destArray.length); // 9
System.out.println("Elements are: ");
System.out.println(Arrays.toString(destArray));
5.Sortare
package main;
public class Main
int arr[] =
3, 5, 2, 6, 1, 6
};
/*metoda sort () sorteaza sirul în ordine numerica crescatoare
Arrays.sort(arr);
/*metoda toString () returneaza reprezentarea String a continutului sirului */
System.out.println(Arrays.toString(arr)); // [1, 2, 3, 5, 6, 6]
6.Cautare
5
package main;
public class Main
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;
public class Main
int[] array = new int[6];
/*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]
//
int[] array1 = new int[6];
/*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;
public class Main
/*Şirurile multidimensionale sunt utile pentru lucrul cu datele care au forma matriceală sau tabelară.
*/
//
/*2-şirul dimensional este aşa-numita Matrice */
int[][] matrix
{
7
1, 2, 3, 4
},
5, 6, 7, 8
},
9, 10, 11, 12
};
/*setul elementelor unui şir se marchează cu {}*/
/*elementele şirului matricei sunt de asemenea şiruri (3 subşiruri)*/
//
/*Pentru ca compilatorul să ştie că șirul nu este unidimensional, setăm 2 semne ale şirului lângă tipul
[][].*/
//
/*acces la elementul bidimensional al şirului*/
System.out.println(matrix[0][0]); // 1
System.out.println(matrix[1][2]); // 7
//
/*şirul tridimensional îl include pe cel bidimensional.*/
int[][][] matrix1 =
1, 2, 3, 4
},
5, 6, 7, 8
},
9, 10, 11, 12
},
8
{
13, 14, 15, 16
},
17, 18, 19, 20
},
21, 22, 23, 24
},
25, 26, 27, 28
},
29, 30, 31, 32
};
//
/*Ş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:*/
int[][] arr = new int[2][2];
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
A doua matrice are valoarea:
4 1 6
2 3 5
7 4 3
package main;
public class 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
};
int[][] matrix3 = new int[3][3];
11
matrix3[0][0] = matrix1[0][0] + matrix2[0][0];
/*Această soluţie nu este optimizată suficient.*/
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;
public class Main

{

{
int[] array =
{
1, 5, 33, 563, 0, 2, 23, 9, 9, 11, 987, 23, 934, 999, 43
12
};
System.out.println("This is array:" + Arrays.toString(array));
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;
public class Main
int x = 0;
if(x > 0)
x = 3;
2. Exerciţiul 2
Trebuie modificat codul următor pentru a fi scris corect:
 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.
14.
15. }
16.
17.
18.
19. else(x)
20.
21. {
22.
24.
25. }
package main;
public class Main
int x = 0, y = 1;
if(x == y) // nu operatorul alocării, ci al comparaţiei
else
if(x == 0) // ; este surplus
else // else nu are condiţie
14
}
Exemple probleme
1.package main;
public class Main
// if-else construcţie condiţională
int x = 0;
if(x != 0) // dacă condiţia x != 0 este îndeplinită...
System.out.println("x is different from 0"); //...se execută acest bloc
else // de altfel, dacă condiţia de sus nu este îndeplinită (tj. x == 0)...
System.out.println("x is equal to 0\n"); //...se execută acest bloc
// utilizarea construcţiei if – construcția else if
int num = 15;
if(num < 10)
System.out.println("Number is less than 10\n");
else
if(num > 10)
System.out.println("The number is greater than 10\n");
else
if(num == 10)
System.out.println("The number is equal to the number of 10\n");
// construcţia if poate să conţină doar blocul if
15
x = 110;
if(x != 0)
System.out.println("x is different from 0\n");
// blocurile if se pot trece unul după altul
x = 110;
if(x != 0) // primul bloc if
System.out.println("x is different from 0\n");
if(x < 100) // al doilea bloc if
System.out.println("x is less than 100\n");
else
System.out.println("x is larger than 100\n");
// if-else se poate şi imbrica
if(true)
if(true) // condiţie în condiţie
System.out.println("This works!\n");
// ca şi corpul condiţiei, if ia doar comanda 1. (fără paranteze acolade)
if(false)
// următoarea linie de cod nu se execută niciodată deoarece condiţia nu este îndeplinită
System.out.println("conditional execution\n");
System.out.println("this part is outside of condition\n");
// ambele comenzi fac acum parte din blocul condiţional
if(false)
16
{
System.out.println("conditional execution");
System.out.println("this is now part of condition\n");
// transparenţa codului se pierde foarte repede (deja după câteva condiţii)
x = 0;
if(x == 1)
System.out.println("x je 1\n");
if(x == 2)
if(x == 3)
// Primul mod: structura if-else
boolean isHappy = true; // variabila boolean pentru controlul fluxului
String mood = ""; // String gol (nu are valoare)
if(isHappy == true) // se execută acest bloc
mood = "I'm Happy!";
else
mood = "I'm Sad!";
System.out.println(mood + "\n");
// Al doilea mod: operator ternar
isHappy = true;
mood = (isHappy == true) ? "I'm Happy!" : "I'm Sad!";
System.out.println(mood + "\n");
/* Greşeala frecventă ce apare la crearea blocurilor condiţionale este utilizarea operatorului de

atribuire (=) în loc de operatorul de comparaţie (==). */
int variableA = 2;
if(variableA == 2) // NetBeans anunţă o eroare dacă punem variableA = 2
{
17
// logica...
// Următorul exemplu calculează 2 cifre comparativ cu operatorul definit
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)
System.out.println("x is between 1 and 5\n");
else
System.out.println("x is not between 1 and 5\n");
// La fel putem crea şi o condiţie mult mai complexă.
x = 15;
if((x > 1 && x < 25 && x != 10) || (x == 35))
System.out.println("Condition is fulfilled\n");
else
System.out.println("Condition is not fulfilled\n");
}}
18
“Switch”
package main;
public class Main
// Primul mod: if-else pentru câteva verificări asupra variabilei1
int x = 5;
if(x == 1)
System.out.println("x = 1");
else
if(x == 2)
else
if(x == 3)
else
System.out.println("x != 1, x != 2, x != 3");
// Al doilea mod: switch
/* 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:
break;
case 2:
break;
case 3:
break;
default:
System.out.println("x != 1, x != 2, x != 3");
break;
/* 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:
case 2:
default:
System.out.println("x!=1 x!=2");
/* 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;
// Există posibilitatea de a activa o expresie cu mai multe condiţii îndeplinite
x = 4;
switch(x)
case 1:
System.out.println("No. is 1, 2 or 3!");
break;
case 2:
break;
case 3:
break;
default:
System.out.println("No. is NOT 1, 2 or 3");
break;
21
/* 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:
break;
default:
System.out.println("No. is NOT 1, 2 or 3");
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;
public class Main
22
//input data
int x = 523134;
int y = 325423;
int remainder = x % y;
switch(remainder)
case 0:
System.out.println("division without remainder");
break;
default:
if(remainder > 1000)
System.out.println("remainder over 1000");
else
System.out.println("remainder below 1000");
break;
Problema 2
Avem următoarele date de intrare pentru un automobil:
String carMake= "Ford";

int doors= 4;
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
String carMake = "Ford";
int doors = 4;
switch(carMake)
case "Ford":
switch(doors) // se poate seta şi switch în switch
case 3:
System.out.println("You drive a Ford with 3 doors.");
break;
case 4:
break;
case 5:
break;
break;
default:
System.out.println("We're sorry. You do not drive a Ford car.");
break;
24
}
“For”
1.Problema 1
int[] arr = {1,2,-1,4,5,-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;
public class Main
int[] arr =
1, 2, -1, 4, 5, -1
};
int[] arr1 = new int[arr.length]; // se creaza sirul1 de aceasi marime precum sirul
for(int i = 0; i < arr.length; i++)
if(arr[i] == -1) // daca elementul sirului este egal cu -1...
arr1[i] = 0; // .. valoarea se seteaza la 0

25
else // altfel...
arr1[i] = arr[i]; // ...elementul doar se copiaza intr-un nou sir
// returneaza reprezentatia String al continutului sirului
System.out.println(Arrays.toString(arr1));
2.Problema 2
package main;
public class Main
// sir bidimensional al utilizatorului
String[][] users =
"petru", "petrescu", "1111"
},
"ion", "ionescu", "2222"
},
"achim", "damian", "3333"
};
// sirul numelui utilizatorului
String[] names = new String[users.length];
26
for(int i = 0; i < users.length; i++)
names[i] = users[i][0];
System.out.println(Arrays.toString(names));
3.package main;
public class Main
int[] array = {33, -9, 0, 14, 5, 7, -65};
/*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;
for(int i = 0; i < array.length; i++)
System.out.println((i + 1) + ". număr: " + array[i]);
sum += array[i];
System.out.println("\ nSuma este: " + sum);
/*Calculul mediei aritmetice ca şi raport dintre suma elementelor şirului şi numărul lor.*/
System.out.println("\nMedia aritmetică este: " + (double) sum / array.length);
Alte aplicatii
1.package main;
public class Main

27
{
/*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).*
// Următorul exemplu de cod scrie mesajul de salut de 4 ori
for(int counter = 1; counter < 5; counter++)
System.out.println("Welcome!");
/*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).*/
// Următorul exemplu va prezenta numerele de la 0 la 4
System.out.println(counter);
// Valoarea contorului se poate mări sau chiar reduce şi în alte moduri
for(int counter = 0; counter < 5; counter += 2)
/*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); // eroare!
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;
for(counter = 0; counter < 5; 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. */
// Buclele for se folosesc des pentru trecerea prin şiruri
String[] colors =
"red", "green", "blue", "yellow", "white"
};
for(int i = 0; i < colors.length; i++)
System.out.println("Color of element " + i + " is " + colors[i] + ".");
/*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;
for(i = 0, a = 5; i < 10; i++, a++)
System.out.println(i + ":" + a);
// Totuşi, bucla for va funcţiona chiar dacă nu se introduc toţi cei 3 parametri
for(int j = 0; j < 10;)
System.out.println(j++);
29
/*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. */
// for(int j = 1; j > 0;) // bucla infinită!
// 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.*/
// În exemplul următor valoarea contorului va rămâne şi după executarea buclei
i = 0;
for(i = 0; i < 10; i++)
System.out.println(i);
/*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.*/
/*Buclele for se pot imbrica una în alta.*/
for(i = 0; i < 10; i++)
for(int u = 0; u < 10; u++)
System.out.println(u);
/* 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. */
for(i = 10; i > 0; i--)
}
30
}
2.package main;
public class 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
};
for(int val : arr)
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ă.*/
//
//
int[] numbers =
3, 5, 9
};
System.out.println("Numbers in this array are: ");
for(int number : numbers)
System.out.println(number);
31
/*La fiecare trecere prin buclă, valoarea elementului curent se scrie la ieşire.*/
//
//
/*nu trebuie să existe paranteze acolade doar pentru o linie de cod*/
for(int number : numbers)
3.package main;
public class Main
/*Controlul fluxului buclei se poate face în câteva moduri. Primul mod este modificarea manuală a
contorului.*/
for(int i = 0; i < 10; i++)
if(i > 5)
i = 10;
//
//
/*Al doilea mod este utilizarea cuvântului cheie break.*/
for(int i = 0; i < 10; i++)

32
{
if(i > 5)
break;
//
/*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.*/
for(int i = 0; i < 10; i++)
System.out.print("\n" + i + ":");
for(int u = 0; u < 10; u++)
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.*/
for(int i = 0; i < 10; i++)
if(i == 5)
continue;
System.out.print(i);
}
33
}
“Do-While”
1.Exercitiu 1
package main;
public class Main
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 1 }
// Trebuie listat sirul dat prin intermediul buclei while.
int x = 0;
while(x < arr.length)
System.out.println(arr[x]);
x++;
2.Exercitiu 2
package main;
public class 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++;
while(x < arr.length);
Alte aplicatii
1.package main;
public class 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)
number--; //dacă se omite această decrementare => bucla infinită
/*Î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ă.*/
// while(true) // bucla infinită!
// System.out.println("in progress");
2.package main;
public class 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
number--;
while(number >= 2);
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. */
// Acest cod se va executa fără probleme
number = 5;
do
number -= 1;
while(number >= 2);
/*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!
while(number >= 2);
37

Java

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Java

Încărcat de

Drepturi de autor:

Formate disponibile

Modulul 3.

public class Main

public static void main(String[] args)

public class Main

public static void main(String[] args)

/*Ca să creăm şirul, folosim cuvântul cheie new. */

int șir[] = new int[5];

şir [0] = 23;

/*să punem o valoare în şir*/

System.out.println(Arrays.toString(objectArray)); // [3, 6.5, 2, 6, 1, 6]

public class Main

public static void main(String[] args)

/*calculul dimensiunii şirului, respectiv a numărului membrilor săi*/

/indexul şirului nu este la fel ca şi numărul elementelor şirului */

/*clasa Arrays conţine diferite metode pentru manipularea şirurilor*/

public class Main

public static void main(String[] args)

// lungimea şirului 3 (rezultat) este suma lungimilor primelor 2 şiruri

int destArray[] = new int[array.length + array1.length];

// Copierea primului şir în şirul 3.

System.arraycopy(array, 0, destArray, 0, array.length);

System.arraycopy(array1, 0, destArray, array.length, array1.length);

System.out.println("Array length is: " + destArray.length); // 9

System.out.println("Elements are: ");

public class Main

public static void main(String[] args)

/*metoda sort () sorteaza sirul în ordine numerica crescatoare

/*metoda toString () returneaza reprezentarea String a continutului sirului */

public class Main

public static void main(String[] args)

public class Main

public static void main(String[] args)

int[] array = new int[6];

int[] array1 = new int[6];

public class Main

public static void main(String[] args)

/*2-şirul dimensional este aşa-numita Matrice */

/*setul elementelor unui şir se marchează cu {}*/

/*elementele şirului matricei sunt de asemenea şiruri (3 subşiruri)*/

/*acces la elementul bidimensional al şirului*/

/*şirul tridimensional îl include pe cel bidimensional.*/

13, 14, 15, 16

17, 18, 19, 20

21, 22, 23, 24

25, 26, 27, 28

29, 30, 31, 32

int[][] arr = new int[2][2];

A doua matrice are valoarea:

public class Main

public static void main(String[] args)

int[][] matrix3 = new int[3][3];

matrix3[0][1] = matrix1[0][1] + matrix2[0][1];

matrix3[0][2] = matrix1[0][2] + matrix2[0][2];

matrix3[1][0] = matrix1[1][0] + matrix2[1][0];

matrix3[1][1] = matrix1[1][1] + matrix2[1][1];

matrix3[1][2] = matrix1[1][2] + matrix2[1][2];

matrix3[2][0] = matrix1[1][0] + matrix2[2][0];

matrix3[2][1] = matrix1[1][1] + matrix2[2][1];

matrix3[2][2] = matrix1[1][2] + matrix2[2][2];

/*Această soluţie nu este optimizată suficient.*/

public class Main

public static void main(String[] args)

public class Main

/Ca să creăm şirul, folosim cuvântul cheie new. /

/să punem o valoare în şir/

/calculul dimensiunii şirului, respectiv a numărului membrilor săi/

/clasa Arrays conţine diferite metode pentru manipularea şirurilor/

/metoda toString () returneaza reprezentarea String a continutului sirului /

/2-şirul dimensional este aşa-numita Matrice /

/setul elementelor unui şir se marchează cu {}/

/elementele şirului matricei sunt de asemenea şiruri (3 subşiruri)/

/acces la elementul bidimensional al şirului/

/şirul tridimensional îl include pe cel bidimensional./

/Această soluţie nu este optimizată suficient./