Programowanie obiektowe /Java/
Laboratorium nr 8
Tablice
1
Inicjalizacja
1
package
pl.kielce.tu.lab8;
2
3
public class
TabInit {
4
public static void
main(String[] args) {
5
Integer[] t1 = {
new
Integer(10),
new
Integer(11) };
6
Integer[] t2;
7
// t2 = { new Integer(20), new Integer(21) };
8
// Error: Array constants can only be used in initializers
9
Integer[] t3;
10
t3 =
new
Integer[] {
new
Integer(30),
new
Integer(31) };
11
Integer[] t4 =
new
Integer[4];
12
for
(
int
i = 0; i < t4.length; i++)
13
t4[i] =
new
Integer(40 + i);
14
15
Integer[][] tt1 =
new
Integer[2][];
16
tt1[0] =
new
Integer[] { 1, 2, 3 };
17
tt1[1] =
new
Integer[] { 7 };
18
19
Integer[][] tt2 =
new
Integer[2][2];
20
Integer tt3[][] = { {}, {}, {}, };
21
22
Integer[] tt4[] = { { 1 }, { 2, 3 }, { 4, 5, 6 }, };
23
}
24
}
Przykład 1: src/pl/kielce/tu/lab8/TabInit.java {link}
2
Długość tablicy
1
package
pl.kielce.tu.lab8;
2
3
public class
TabLength {
4
public static void
main(String[] args) {
5
Integer[] t1 = {
new
Integer(10),
new
Integer(11) };
6
System.out.println(
"t1.length = "
+ t1.length);
7
Integer[] t2;
8
// System.out.println("t2.length = " + t2.length);
9
// The local variable t2 may not have been initalized
10
Integer[] t3;
11
t3 =
new
Integer[] {
new
Integer(30),
new
Integer(31) };
12
System.out.println(
"t3.length = "
+ t3.length);
13
Integer[] t4 =
new
Integer[4];
14
for
(
int
i = 0; i < 2; i++)
15
t4[i] =
new
Integer(40 + i);
16
System.out.println(
"t4.length = "
+ t4.length);
17
}
18
}
Przykład 2: src/pl/kielce/tu/lab8/TabLength.java {link}
1
Thinking in Java, Bruce Eckel, Wydanie IV, Helion, 2006
1
3
Wyświetlanie
Klasa java.util.Arrays posiada przeciążone metody toString(), które wykorzystują metodę toString()
zdefiniowaną w klasie, której obiekty znajdują się w tablicy. Dla tablic wielowymiarowych jest to metoda
deepT oString().
http : //download.oracle.com/javase/6/docs/api/java/util/Arrays.html {link}:
1
package
pl.kielce.tu.lab8;
2
3
import
java.util.Arrays;
4
5
public class
TabPrint {
6
static class
MyClass {
7
int
i;
8
9
MyClass(
int
i) {
10
this
.i = i;
11
}
12
13
@Override
14
public
String toString() {
15
return
"MyClass"
+ i +
" "
;
16
}
17
}
18
19
public static void
main(String[] args) {
20
MyClass[] m = {
new
MyClass(5),
new
MyClass(1),
new
MyClass(9),
new
MyClass(4) };
21
System.out.println(
"Arrays.toString(m) = "
+ Arrays.toString(m));
22
MyClass[][] m2 = { {
new
MyClass(5) }, {
new
MyClass(1),
new
MyClass(9) }, {
new
MyClass←֓
(4) } };
23
System.out.println(Arrays.deepToString(m2));
24
}
25
}
Przykład 3: src/pl/kielce/tu/lab8/TabPrint.java {link}
4
Wypełnianie
Klasa java.util.Arrays posiada przeciążone metody f ill() pozwalające wypełniać tablicę podaną warto-
ścią.
1
package
pl.kielce.tu.lab8;
2
3
import
java.util.Arrays;
4
5
public class
TabFill {
6
public static void
main(String[] args) {
7
Integer[] f1 = { 1, 2, 3 };
8
System.out.println(Arrays.toString(f1));
9
Arrays.fill(f1, 7);
10
System.out.println(Arrays.toString(f1));
11
}
12
}
Przykład 4: src/pl/kielce/tu/lab8/TabFill.java {link}
5
Zwracanie tablic
2
1
package
pl.kielce.tu.lab8;
2
3
import
java.util.Arrays;
4
import
java.util.Random;
5
6
public class
TabReturn {
7
public static void
main(String[] args) {
8
Object[] o = returnTable();
9
System.out.println(
"Class : "
+ o.getClass().getName());
10
System.out.println(
"Length : "
+ o.length);
11
System.out.println(
"Values : "
+ Arrays.toString(o));
12
}
13
14
static
Object[] returnTable() {
15
Object[] o =
null
;
16
Random r =
new
Random();
17
int
t = r.nextInt(4);
18
switch
(t) {
19
case
0:
20
o =
new
Long[r.nextInt(20)];
21
for
(
int
i = 0; i < o.length; i++)
22
o[i] = r.nextLong();
23
break
;
24
case
1:
25
o =
new
Integer[r.nextInt(20)];
26
for
(
int
i = 0; i < o.length; i++)
27
o[i] = r.nextInt();
28
break
;
29
case
2:
30
o =
new
Double[r.nextInt(20)];
31
for
(
int
i = 0; i < o.length; i++)
32
o[i] = r.nextDouble();
33
break
;
34
case
3:
35
o =
new
Float[r.nextInt(20)];
36
for
(
int
i = 0; i < o.length; i++)
37
o[i] = r.nextFloat();
38
break
;
39
}
40
return
o;
41
}
42
}
Przykład 5: src/pl/kielce/tu/lab8/TabReturn.java {link}
6
Kopiowanie
Klasa java.lang.System posiada metodę arraycopy().
http : //download.oracle.com/javase/6/docs/api/java/lang/System.html {link}
Klasa java.util.Arrays posiada przeciążone metody copyOf () oraz copyOf Range().
1
package
pl.kielce.tu.lab8;
2
3
import
java.util.Arrays;
4
5
public class
TabCopy {
6
public static void
main(String[] args) {
7
Integer[] t1 = {
new
Integer(10),
new
Integer(11) };
8
Integer[] t2 = {
new
Integer(20),
new
Integer(21) };
3
9
Integer[] t3 = {
new
Integer(30),
new
Integer(31) };
10
11
System.out.println(
"Przed t1[] = "
+ Arrays.toString(t1));
12
System.out.println(
"Przed t2[] = "
+ Arrays.toString(t2));
13
System.out.println(
"Przed t3[] = "
+ Arrays.toString(t3));
14
15
System.arraycopy(t2, 0, t1, 1, 1);
16
System.out.println(
"Po t1[] = "
+ Arrays.toString(t1));
17
System.out.println(
"Po t2[] = "
+ Arrays.toString(t2));
18
19
Integer[] t31 = Arrays.copyOf(t3, 1);
20
Integer[] t32 = Arrays.copyOfRange(t3, 1, 2);
21
System.out.println(
"Po t3[] = "
+ Arrays.toString(t3));
22
System.out.println(
"Po t31[]= "
+ Arrays.toString(t31));
23
System.out.println(
"Po t32[]= "
+ Arrays.toString(t32));
24
}
25
}
Przykład 6: src/pl/kielce/tu/lab8/TabCopy.java {link}
7
Porównywanie
Klasa java.util.Arrays posiada przeciążone metody equals(), które wykorzystują metodę equals() zdefi-
niowaną w klasie, której obiekty znajdują się w tablicy. W przykładzie poniżej w klasie M yClass nie została
przesłonięta metoda equals() dlatego wynikiem porównania jest f alse. Do porównywania tablic wielowymia-
rowych służy metoda deepEquals().
1
package
pl.kielce.tu.lab8;
2
3
import
java.util.Arrays;
4
5
public class
TabCompare {
6
7
static class
MyClass {
8
int
i;
9
10
MyClass(
int
i) {
11
this
.i = i;
12
}
13
14
@Override
15
public
String toString() {
16
return
"MyClass"
+ i +
" "
;
17
}
18
}
19
20
public static void
main(String[] args) {
21
MyClass[] m1 = {
new
MyClass(5),
new
MyClass(1),
new
MyClass(9),
new
MyClass(4) };
22
MyClass[] m2 = {
new
MyClass(5),
new
MyClass(1),
new
MyClass(9),
new
MyClass(4) };
23
Arrays.equals(m1, m2);
24
System.out.println(
"Arrays.equals(m1, m2) = "
+ Arrays.equals(m1, m2));
25
26
MyClass[][] mm1 = { {
new
MyClass(5) }, {
new
MyClass(1),
new
MyClass(9) }, {
new
MyClass←֓
(4) } };
27
MyClass[][] mm2 = { {
new
MyClass(5) }, {
new
MyClass(1),
new
MyClass(9) }, {
new
MyClass←֓
(4) } };
28
Arrays.equals(mm1, mm2);
29
System.out.println(
"Arrays.equals(mm1, mm2) = "
+ Arrays.equals(mm1, mm2));
30
System.out.println(
"Arrays.deepEquals(mm1, mm2) = "
+ Arrays.deepEquals(mm1, mm2));
31
}
4
32
}
Przykład 7: src/pl/kielce/tu/lab8/TabCompare.java {link}
W przykładzie poniżej w klasie M yClass metoda equals() zwraca true jeżeli porównywany obiekt jest
takiej samej klasy jak aktualny obiekt (this.getClass().isInstance(o)) oraz wartość pola i w aktualnym
obiekcie i porównywanym jest taka sama (this.i == tmp.i).
1
package
pl.kielce.tu.lab8;
2
3
import
java.util.Arrays;
4
5
import
pl.kielce.tu.lab8.TabCompare.MyClass;
6
7
public class
TabCompare2 {
8
9
static class
MyClass {
10
int
i;
11
12
MyClass(
int
i) {
13
this
.i = i;
14
}
15
16
@Override
17
public
String toString() {
18
return
"MyClass"
+ i +
" "
;
19
}
20
21
@Override
22
public boolean
equals(Object o) {
23
if
(
this
.getClass().isInstance(o) ==
false
)
24
return false
;
25
MyClass tmp = (MyClass) o;
26
return this
.i == tmp.i;
27
}
28
}
29
30
public static void
main(String[] args) {
31
MyClass[] m1 = {
new
MyClass(5),
new
MyClass(1),
new
MyClass(9),
new
MyClass(4) };
32
MyClass[] m2 = {
new
MyClass(5),
new
MyClass(1),
new
MyClass(9),
new
MyClass(4) };
33
Arrays.equals(m1, m2);
34
System.out.println(
"Arrays.equals(m1, m2) = "
+ Arrays.equals(m1, m2));
35
36
MyClass[][] mm1 = { {
new
MyClass(5) }, {
new
MyClass(1),
new
MyClass(9) }, {
new
MyClass←֓
(4) } };
37
MyClass[][] mm2 = { {
new
MyClass(5) }, {
new
MyClass(1),
new
MyClass(9) }, {
new
MyClass←֓
(4) } };
38
Arrays.equals(mm1, mm2);
39
System.out.println(
"Arrays.equals(mm1, mm2) = "
+ Arrays.equals(mm1, mm2));
40
System.out.println(
"Arrays.deepEquals(mm1, mm2) = "
+ Arrays.deepEquals(mm1, mm2));
41
}
42
}
Przykład 8: src/pl/kielce/tu/lab8/TabCompare2.java {link}
8
Sortowanie
Klasa java.util.Arrays posiada przeciążone metody sort(). Przykład poniżej powoduje zgłoszenie wyjątku
java.lang.ClassCastException: MyClass cannot be cast to java.lang.Comparable
. Problem ten może zostać
rozwiązany na co najmniej dwa sposoby.
5
1
package
pl.kielce.tu.lab8;
2
3
import
java.util.Arrays;
4
5
public class
TabSort {
6
7
static class
MyClass {
8
int
i;
9
10
MyClass(
int
i) {
11
this
.i = i;
12
}
13
14
@Override
15
public
String toString() {
16
return
"MyClass"
+ i +
" "
;
17
}
18
}
19
20
public static void
main(String[] args) {
21
MyClass[] m = {
new
MyClass(5),
new
MyClass(1),
new
MyClass(9),
new
MyClass(4) };
22
// java.lang.ClassCastException: MyClass cannot be cast to java.lang.Comparable
23
Arrays.sort(m);
24
System.out.println(Arrays.toString(m));
25
}
26
}
Przykład 9: src/pl/kielce/tu/lab8/TabSort.java {link}
Rozwiązanie 1. Implementacja interfejsu java.lang.Comparable.
1
package
pl.kielce.tu.lab8;
2
3
import
java.util.Arrays;
4
5
public class
TabSort2 {
6
7
static class
MyClass
implements
Comparable<MyClass> {
8
int
i;
9
10
MyClass(
int
i) {
11
this
.i = i;
12
}
13
14
@Override
15
public
String toString() {
16
return
"MyClass"
+ i +
" "
;
17
}
18
19
@Override
20
public int
compareTo(MyClass o) {
21
return this
.i - o.i;
// !!!
22
}
23
}
24
25
public static void
main(String[] args) {
26
MyClass[] m = {
new
MyClass(5),
new
MyClass(1),
new
MyClass(9),
new
MyClass(4) };
27
Arrays.sort(m);
28
System.out.println(Arrays.toString(m));
29
}
30
}
6
Przykład 10: src/pl/kielce/tu/lab8/TabSort2.java {link}
Rozwiązanie 2. Wykorzystanie implementacji interfejsu java.util.Comparator.
1
package
pl.kielce.tu.lab8;
2
3
import
java.util.Arrays;
4
import
java.util.Comparator;
5
6
public class
TabSort3 {
7
8
static class
MyClass {
9
int
i;
10
11
MyClass(
int
i) {
12
this
.i = i;
13
}
14
15
@Override
16
public
String toString() {
17
return
"MyClass"
+ i +
" "
;
18
}
19
}
20
21
static class
MyComparator
implements
Comparator<MyClass> {
22
23
@Override
24
public int
compare(MyClass o1, MyClass o2) {
25
return
o1.i - o2.i;
// !!!
26
}
27
}
28
29
public static void
main(String[] args) {
30
MyClass[] m = {
new
MyClass(5),
new
MyClass(1),
new
MyClass(9),
new
MyClass(4) };
31
Arrays.sort(m,
new
MyComparator());
32
System.out.println(Arrays.toString(m));
33
}
34
}
Przykład 11: src/pl/kielce/tu/lab8/TabSort3.java {link}
9
Przeszukiwanie tablicy posortowanej
Klasa java.util.Arrays posiada przeciążone metody binarySearch() pozwalające przeszukiwać uporząd-
kowaną tablicę.
1
package
pl.kielce.tu.lab8;
2
3
import
java.util.Arrays;
4
5
import
pl.kielce.tu.lab8.TabSort2.MyClass;
6
7
public class
TabSearch {
8
9
static class
MyClass
implements
Comparable<MyClass> {
10
int
i;
11
12
MyClass(
int
i) {
13
this
.i = i;
7
14
}
15
16
@Override
17
public
String toString() {
18
return
"MyClass"
+ i +
" "
;
19
}
20
21
@Override
22
public int
compareTo(MyClass o) {
23
return this
.i - o.i;
// !!!
24
}
25
26
@Override
27
public boolean
equals(Object o) {
28
if
(
this
.getClass().isInstance(o) ==
false
)
29
return false
;
30
MyClass tmp = (MyClass) o;
31
return this
.i == tmp.i;
32
}
33
}
34
35
public static void
main(String[] args) {
36
MyClass[] m = {
new
MyClass(5),
new
MyClass(1),
new
MyClass(9),
new
MyClass(4) };
37
System.out.println(
"MyClass[] = "
+ Arrays.toString(m));
38
System.out.println(
"Index = "
+ Arrays.binarySearch(m,
new
MyClass(4)));
39
40
Arrays.sort(m);
41
System.out.println(
"MyClass[] = "
+ Arrays.toString(m));
42
System.out.println(
"Index = "
+ Arrays.binarySearch(m,
new
MyClass(4)));
43
}
44
}
Przykład 12: src/pl/kielce/tu/lab8/TabSearch.java {link}
10
Przykładowa treść laboratorium
Należy szczegółowo zapoznawać się z klasami związanymi z tablicami takimi jak np. java.util.Arrays,
java.lang.System, itp.
Proszę stworzyć oraz uruchomić aplikację, która:
- stworzy i zainicjuje kilkoma sposobami tablice jednowymiarowe zawierającą referencje do obiektów
klasy stworzonej przez użytkownika (np. klasy Osoba, tablice tekstów, typów prostych, itp. nie będą
oceniane), wyświetli zawartość tablicy, skopiuje fragment tablicy, porówna tablice, posortuje tablicę,
przeszuka tablicę posortowaną, itp.,
- stworzy i zainicjuje tablice dwuwymiarowe zawierającą referencje do obiektów klasy stworzonej przez
użytkownika, wyświetli zawartość tablicy, porówna tablice, itp.
8
Document Outline
- 1 Inicjalizacja
- 2 Dlugosc tablicy
- 3 Wyswietlanie
- 4 Wypelnianie
- 5 Zwracanie tablic
- 6 Kopiowanie
- 7 Porownywanie
- 8 Sortowanie
- 9 Przeszukiwanie tablicy posortowanej
- 10 Przykladowa tresc laboratorium
Wyszukiwarka
Podobne podstrony:
infa, Inf Lab08
LAB08 id 258842 Nieznany
Lab08
sop-2009-lab08
Inf Lab08
Spraw lab08
Lab08'11
Lab08
AiP Lab08
infa Inf Lab08
lab08 makra id 258846 Nieznany
Lab08 Sprawozdanie id 258847 Nieznany
cz 1, Lab08, 1
lab08'08
BO Lab08
Lab08 TCP
Inf Lab08
LAB08 Analityczne i graficzne kryteria stabilno ci liniowych UAR
infa, Inf Lab08
więcej podobnych podstron