LAPORAN RESMI ALGORITMA

DAN STRUKTUR DATA

(COLLECTIONS)
2.TUJUAN
1.Memahami cara penyimpanan obyek menggunakan Collection.

2.Mengetahui pengelompokan dari Collection.

3.Mengetahui perbedaan dari interface Set, List dan Map.

4.Mengetahui penggunaan class-class dari interface Set, List dan Map.

5.Mengetahui cara penggunaan Iterasi dan Enumeration.

3.PERCOBAAN
1. Listing Program :

import java.util.*;
public class SetExample {
public static void main(String[] args) {
Set set=new HashSet();
set.add("Bernadine");
set.add("Elizabeth");
set.add("Gene");
set.add("Elizabeth");
set.add("Clara");
System.out.print("Elemen pada HashSet : ");
System.out.println(set);
Set sortSet=new TreeSet(set);
System.out.print("Elemen pada TreeSet : ");
System.out.println(sortSet);
}
}
Outputnya :

Analisa :

2. Listing Program :

import java.util.*;

public class FindDups {

public static void main(String[] args) {
Set<String> s = new HashSet<String>();
for (String a : args)
if (!s.add(a))
System.out.println("Duplicate detected: " + a);

System.out.println(s.size() + " distinct words: " + s);

}
}
import java.util.*;

public class FindDups2 {

public static void main(String[] args) {
Set<String> uniques = new HashSet<String>();
Set<String> dups = new HashSet<String>();
for (String a : args)
if (!uniques.add(a))
dups.add(a);
// Destructive set-difference
uniques.removeAll(dups);
 System.out.println("Unique Words: " + uniques);
System.out.println("Duplicate Words: " + dups);
}
}
Outputnya :

Analisa :

3. Listing Program :

import java.util.*;
public class SetExample {
public static void main(String[] args) {
Set s1=new HashSet();
s1.add("Australia");
s1.add("Sweden");
s1.add("Germany");
Set s2=new HashSet();
s2.add("Sweden");
s2.add("France");
Set union=new TreeSet(s1);
union.addAll(s2);
// gabungan dari s1 dan s2
print("Union",union);
Set intersect=new TreeSet(s1);
intersect.retainAll(s2);
// irisan dari s1 dan s2
print("Intersection",intersect);
}
protected static void print(String label, Collection c){
System.out.println("---------------- "+ label+" ---------------");
Iterator it=c.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
Outputnya :
 Analisa :

4. Listing Program :

import java.util.*;
public class ListExample {
public static void main(String[] args) {
List list=new ArrayList();
list.add("Bernadine");
list.add("Elizabeth");
list.add("Gene");
list.add("Elizabeth");
list.add("Clara");
System.out.println(list);
System.out.println("2 : "+list.get(2));
System.out.println("0 : "+list.get(0));
LinkedList queue=new LinkedList();
queue.addFirst("Bernadine");
queue.addFirst("Elizabeth");
queue.addFirst("Gene");
queue.addFirst("Elizabeth");
queue.addFirst("Clara");
System.out.println(queue);
queue.removeLast();
queue.removeLast();
System.out.println(queue);
}
}
Outputnya :

Analisa :
5. Listing Program :

import java.util.Vector;
public class VectorExample {
public static void main(String[] args) {
Vector<String> vc=new Vector<String>();
//<E> Element type of Vector e.g. String, Integer, Object ...
// add vector elements
vc.add("Vector Object 1");
vc.add("Vector Object 2");
vc.add("Vector Object 3");
vc.add("Vector Object 4");
vc.add("Vector Object 5");
// add vector element at index
vc.add(3, "Element at fix position");
// vc.size() inform number of elements in Vector
System.out.println("Vector Size :"+vc.size());
// get elements of Vector
for(int i=0;i<vc.size();i++)
{
System.out.println("Vector Element "+i+" :"+vc.get(i));
}
}
}
Outputnya :

Analisa :

6. Listing Program :

import java.util.*;

class IteratorDemo {
public static void main(String[] args) {
// create an array list
ArrayList al = new ArrayList();
// add elements to the array list
al.add("C");
al.add("A");
al.add("E");
al.add("B");
al.add("D");
al.add("F");
// use iterator to display contents of al
System.out.print("Original contents of al: ");
Iterator itr = al.iterator();
 while (itr.hasNext()) {
Object element = itr.next();
System.out.print(element + " ");
}
System.out.println();
// modify objects being iterated
ListIterator litr = al.listIterator();
while (litr.hasNext()) {
Object element = litr.next();
litr.set(element + "+");
}
System.out.print("Modified contents of al: ");
itr = al.iterator();
while (itr.hasNext()) {
Object element = itr.next();
System.out.print(element + " ");
System.out.println();
}
// now, display the list backwards
System.out.print("Modified list backwards: ");
while (litr.hasPrevious()) {
Object element = litr.previous();
System.out.print(element + " ");
}
System.out.println();
}
}
Outputnya :

Analisa :

7. Listing Program :

import java.util.Vector;
import java.util.Enumeration;
public class EnumerationTester {
public static void main(String args[]) {
Enumeration days;
Vector dayNames = new Vector();
dayNames.add("Sunday");
dayNames.add("Monday");
dayNames.add("Tuesday");
dayNames.add("Wednesday");
 dayNames.add("Thursday");
dayNames.add("Friday");
dayNames.add("Saturday");
days = dayNames.elements();
while (days.hasMoreElements ())
System.out.println(days.nextElement());
}
}
Outputnya :

Analisa :

8. Listing Program :

import java.util.*;

public class CreateArrayListFromEnumerationExample {

public static void main(String[] args) {
Vector<String> v = new Vector<String>();
v.add("A");
v.add("B");
v.add("D");
v.add("E");
v.add("F");
System.out.println("Vector contains : " + v);
Enumeration e = v.elements();
ArrayList aList = Collections.list(e);
System.out.println("Arraylist contains : " + aList);
}
}
Outputnya :

Analisa :
9. Listing Program :

import java.util.ArrayList;
import java.util.Collections;
import java.util.Vector;
public class CopyElementsOfArrayListToVectorExample {
public static void main(String[] args) {
//create an ArrayList object
ArrayList arrayList = new ArrayList();
//Add elements to Arraylist
arrayList.add("1");
arrayList.add("4");
arrayList.add("2");
arrayList.add("5");
arrayList.add("3");
//create a Vector object
Vector v = new Vector();
//Add elements to Vector
v.add("A");
v.add("B");
v.add("D");
v.add("E");
v.add("F");
v.add("G");
v.add("H");
System.out.println("Before copy, Vector Contains : " + v);
//copy all elements of ArrayList to Vector using copy method of
Collections class
Collections.copy(v,arrayList);
System.out.println("After Copy, Vector Contains : " + v);
}
}
Outputnya :

Analisa :

10. Listing Program :

import java.util.ArrayList;
import java.util.Vector;
public class AppendAllElementsOfOtherCollectionToArrayListExample {
public static void main(String[] args) {
//create an ArrayList object
ArrayList arrayList = new ArrayList();
 //Add elements to Arraylist
arrayList.add("1");
arrayList.add("2");
arrayList.add("3");
//create a new Vector object
Vector v = new Vector();
v.add("4");
v.add("5");
//append all elements of Vector to ArrayList
arrayList.addAll(v);
//display elements of ArrayList
System.out.println("After appending all elements of Vector, ArrayList
contains..");
for (int i = 0; i < arrayList.size(); i++) {
System.out.println(arrayList.get(i));
}
}
}
Outputnya :

Analisa :

11. Listing Program :

import java.util.*;
public class PriorityQueueDemo {
public static void main(String[] args){
PriorityQueue<String> stringQueue;
stringQueue = new PriorityQueue<String>();
stringQueue.add("ab");
stringQueue.add("abcd");
stringQueue.add("abc");
stringQueue.add("a");
//don't use iterator which may or may not
//show the PriorityQueue's order
while(stringQueue.size() > 0)
System.out.println(stringQueue.remove());
}
}
Outputnya :
 Analisa :

12. Listing Program :

import java.util.Comparator;
import java.util.PriorityQueue;

public class PQueueTest {

public static void main(String[] args) {
PriorityQueue<Integer> pQueue = new PriorityQueue<Integer>(10, new
Comparator<Integer>() {
public int compare(Integer int1, Integer int2) {
boolean flag1 = isPrime(int1);
boolean flag2 = isPrime(int2);

if(flag1==flag2) {
return int1.compareTo(int2);
} else if(flag1){
return -1;
} else if(flag2){
return 1;
}
return 0;
}
});

pQueue.add(1);
pQueue.add(2);
pQueue.add(3);
pQueue.add(4);
pQueue.add(5);
pQueue.add(6);
pQueue.add(7);
pQueue.add(8);
pQueue.add(9);
pQueue.add(10);

while(true) {
Integer head = pQueue.poll();
if(head==null) {
break;
}
System.out.print(head + " <-- ");
}
}

/**
*
 * @param n
* @return
*/
public static boolean isPrime(int n) {
if(n<=1) {
return false;
}
if(n==2) {
return true;
}
if(n%2==0) {
return false;
}
long m = (long) Math.sqrt(n);
for(long i=3;i<=m;i+=2) {
if(n%1==0) {
return false;
}
}
return true;
}
}
Outputnya :

Analisa :

13. Listing Program :

import java.util.HashMap;

public class RemoveValueFromHashMapExample {

public static void main(String[] args) {
//create HashMap Object
HashMap hMap = new HashMap();

//add key value pairs to HashMap

hMap.put("1","One");
hMap.put("2","Two");
hMap.put("3","Three");
Object obj = hMap.remove("2");
System.out.println(obj + " Removed from HashMap");
hMap.clear();

System.out.println("Total key value pairs in HashMap are : " +

hMap.size());
}
}
Outputnya :
 Analisa :

14. Listing Program :

15.import java.util.Collection;
16.import java.util.HashMap;
17.import java.util.Iterator;
18.public class IterateValuesOfHashMapExample {
19. public static void main(String[] args) {
20. //create HashMap object
21. HashMap hMap = new HashMap();
22. //add key value pairs to HashMap
23. hMap.put("1","One");
24. hMap.put("2","Two");
25. hMap.put("3","Three");
26. Collection c = hMap.values();
27. //obtain an Iterator for Collection
28. Iterator itr = c.iterator();
29. //iterate through HashMap values iterator
30. while(itr.hasNext())
31. System.out.println(itr.next());
32. }
33.}
34.
35.
Outputnya :

Analisa :

15. Listing Program :

16.import java.util.HashMap;
17.import java.util.HashSet;
 18.import java.util.Collections;
19.import java.util.*;
20.
21.public class GetSetViewOfKeysFromHashMapExample {
22. public static void main(String[] args) {
23. //create HashMap object
24. HashMap hMap = new HashMap();
25. //add key value pairs to HashMap
26. hMap.put("1","One");
27. hMap.put("2","Two");
28. hMap.put("3","Three");
29. Set st = hMap.keySet();
30. System.out.println("Set created from HashMap Keys contains :");
31. //iterate through the Set of keys
32. Iterator itr = st.iterator();
33. while(itr.hasNext())
34. System.out.println(itr.next());
35. //remove 2 from Set
36. st.remove("2");
37. }
38.}
39.
40.

Outputnya :

Analisa :

41. Listing Program :

42.import java.util.HashMap;
43.
44.public class CheckValueOfHashMapExample {
45. public static void main(String[] args) {
46. //create HashMap object
47. HashMap hMap = new HashMap();
48. //add key value pairs to HashMap
49. hMap.put("1","One");
50. hMap.put("2","Two");
51. hMap.put("3","Three");
52. boolean blnExists = hMap.containsValue("Two");
53. System.out.println("Two exists in HashMap ? : " + blnExists);
54. }
55.}
 Outputnya :

Analisa :

56. Listing Program :

57.import java.util.HashMap;
58.public class CheckKeyOfHashMapExample {
59. public static void main(String[] args) {
60. //create HashMap object
61. HashMap hMap = new HashMap();
62. //add key value pairs to HashMap
63. hMap.put("1","One");
64. hMap.put("2","Two");
65. hMap.put("3","Three");
66. boolean blnExists = hMap.containsKey("3");
67. System.out.println("3 exists in HashMap ? : " + blnExists);
68. }
69.}

Outputnya :

Analisa :

70. Listing Program :

71.import java.util.Enumeration;
72.import java.util.Hashtable;
73.import java.util.HashMap;
74.public class CreateHashtableFromHashMap {
75. public static void main(String[] args) {
76. //create HashMap
77. HashMap hMap = new HashMap();
78. //populate HashMap
79. hMap.put("1","One");
80. hMap.put("2","Two");
81. hMap.put("3","Three");
82. //create new Hashtable
 83. Hashtable ht = new Hashtable();
84. //populate Hashtable
85. ht.put("1","This value would be REPLACED !!");
86. ht.put("4","Four");
87. //print values of Hashtable before copy from HashMap
88. System.out.println("Hashtable contents before copy");
89. Enumeration e = ht.elements();
90. while(e.hasMoreElements())
91. System.out.println(e.nextElement());
92. ht.putAll(hMap);
93. //display contents of Hashtable
94. System.out.println("Hashtable contents after copy");
95. e = ht.elements();
96. while(e.hasMoreElements())
97. System.out.println(e.nextElement());
98. }
99. }

Outputnya :

Analisa :

100. Listing Program :

101. import java.util.TreeMap;

102. public class GetLowestHighestKeyTreeMapExample {
103. public static void main(String[] args) {
104. //create TreeMap object
105. TreeMap treeMap = new TreeMap();
106. //add key value pairs to TreeMap
107. treeMap.put("1","One");
108. treeMap.put("3","Three");
109. treeMap.put("2","Two");
110. treeMap.put("5","Five");
111. treeMap.put("4","Four");
112. System.out.println("Lowest key Stored in Java TreeMap is : "
+ treeMap.firstKey());
113. System.out.println("Highest key Stored in Java TreeMap is : "
+ treeMap.lastKey());
114. }
115. }

Outputnya :
 Analisa :

116. Listing Program :

117. import java.util.SortedMap;

118. import java.util.TreeMap;
119. public class GetTailMapFromTreeMapExample {
120. public static void main(String[] args) {
121. //create TreeMap object
122. TreeMap treeMap = new TreeMap();
123. //add key value pairs to TreeMap
124. treeMap.put("1","One");
125. treeMap.put("3","Three");
126. treeMap.put("2","Two");
127. treeMap.put("5","Five");
128. treeMap.put("4","Four");
129. SortedMap sortedMap = treeMap.tailMap("2");
130. System.out.println("Tail Map Contains : " + sortedMap);
131. }
132. }

Outputnya :

Analisa :

133. Listing Program :

134. import java.util.*;

135.
136. public class GetSubMapFromTreeMapExample {
137. public static void main(String[] args) {
138. //create TreeMap object
139. TreeMap treeMap = new TreeMap();
140. //add key value pairs to TreeMap
141. treeMap.put("1","One");
 142. treeMap.put("3","Three");
143. treeMap.put("2","Two");
144. treeMap.put("5","Five");
145. treeMap.put("4","Four");
146. SortedMap sortedMap = treeMap.subMap("2","5");
147. System.out.println("SortedMap Contains : " + sortedMap);
148. }
149. }

Outputnya :

Analisa :

150. Listing Program :

151. import java.util.SortedMap;

152. import java.util.TreeMap;
153.
154. public class GetHeadMapFromTreeMapExample {
155. public static void main(String[] args) {
156. //create TreeMap object
157. TreeMap treeMap = new TreeMap();
158. //add key value pairs to TreeMap
159. treeMap.put("1","One");
160. treeMap.put("3","Three");
161. treeMap.put("2","Two");
162. treeMap.put("5","Five");
163. treeMap.put("4","Four");
164. SortedMap sortedMap = treeMap.headMap("3");
165. System.out.println("Head Map Contains : " + sortedMap);
166. }
167. }

Outputnya :

Analisa :
168. Listing Program :

169. import java.util.*;

170. public class Latihan1 {
171. public static void main(String[] args) {
172. Set set1 = new HashSet();
173. set1.add("1");
174. set1.add("2");
175. set1.add("3");
176. set1.add("4");
177. set1.add("5");
178. System.out.print("Elemen Himpunan A : " + set1);
179.
180. Set set2 = new HashSet();
181. set2.add("6");
182. set2.add("7");
183. set2.add("8");
184. set2.add("9");
185. set2.add("10");
186. System.out.print("\nElemen Himpunan B : " + set2);
187.
188. Set irisan = new TreeSet(set1);
189. irisan.retainAll(set2);
190. System.out.print("\nA ^ B : " + irisan);
191.
192. Set gabungan = new TreeSet(set1);
193. gabungan.addAll(set2);
194. System.out.print("\nA U B : " + gabungan);
195.
196. Set komplemen = new TreeSet(set1);
197. komplemen.removeAll(set2);
198. System.out.print("\nA - B : " + komplemen);
199.
200. Set subset1 = new TreeSet(set1);
201. subset1.removeAll(set2);
202.
203. Set subset2 = new TreeSet(set2);
204. subset2.removeAll(set1);
205.
206. System.out.println("\nA c B : " + subset1 + subset2);
207. }
208. }

Outputnya :
 Analisa :

209. Listing Program :

210. import java.util.*;

211.
212. public class Latihan2 {
213. public static void main(String[] args) {
214. ArrayList data = new ArrayList();
215. data.add("x");
216. data.add("w");
217. data.add("a");
218. data.add("m");
219. Iterator itr = data.iterator();
220. System.out.print("Data : ");
221. while(itr.hasNext()) {
222. System.out.print(itr.next() + " ");
223. }
224. System.out.println();
225.
226. System.out.print("Data Sebelum Terbalik : ");
227. ListIterator litr = data.listIterator();
228. while(litr.hasNext()) {
229. System.out.print(litr.next() + " ");
230. }
231. System.out.println();
232. System.out.print("Data Terbalik : ");
233. while(litr.hasPrevious()) {
234. System.out.print(litr.previous() + " ");
235. }
236. System.out.println();
237. System.out.print("Data Acak : ");
238. Collections.shuffle(data);
239. System.out.print(data);
240. System.out.println();
241.
242. System.out.print("Data Terurut : ");
243. Collections.sort(data);
244. System.out.print(data);
245. System.out.println();
246. }
247. }

Outputnya :
 Analisa :

248. Listing Program :

249. import java.util.*;

250. import java.util.Comparator;
251.
252. public class Mahasiswa implements Comparable<Mahasiswa>{
253. public int nrp;
254. public String nama;
255. public float nilai;
256. public Mahasiswa(int nrp, String nama){
257. this.nrp = nrp;
258. this.nama = nama;
259. }
260.
261. public int cetaknrp() {
262. return nrp;
263. }
264.
265. public String cetaknama() {
266. return nama;
267. }
268.
269. @Override
270. public int compareTo(Mahasiswa m){
271. return (int)(this.nrp-m.nrp);
272. }
273. }
import java.util.*;
import java.util.Collections;

public class Latihan3 {

public static void main(String[] args) {

List<Mahasiswa> mhs = new LinkedList<Mahasiswa>();
String[] nama={"nama1","nama2","nama3","nama4"};
int[] nrp={1,2,3,4};
int i=0;
while(i<nama.length) {
mhs.add(new Mahasiswa(nrp[i], nama[i]));
i++;
}
System.out.println("Data : ");
for(Mahasiswa mahasiswa : mhs) {
System.out.println("Nama : " + mahasiswa.cetaknama() + "|NRP:" +
mahasiswa.cetaknrp());
}
System.out.println("Dibalik : ");
Collections.reverse(mhs);
for(Mahasiswa mahasiswa : mhs) {
System.out.println("Nama:"+mahasiswa.cetaknama()+"|NRP:"+
mahasiswa.cetaknrp());
}
System.out.println("Setelah Diacak : ");
Collections.shuffle(mhs);
 for(Mahasiswa mahasiswa : mhs){
System.out.println("Nama:"+mahasiswa.cetaknama()+"|NRP:"+
mahasiswa.cetaknrp());
}
System.out.println("Setelah Diurutkan : ");
Collections.sort(mhs);
for(Mahasiswa mahasiswa : mhs){
System.out.println("Nama:"+mahasiswa.cetaknama()+"|NRP:"+
mahasiswa.cetaknrp());
}
}
}
Outputnya :

Analisa :

274. Listing Program :

275. import java.util.*;

276. public class Latihan5{
277. public static void main(String[] args) {
278. List warna=new LinkedList();
279. warna.add("MAGENTA");
280. warna.add("RED");
281. warna.add("WHITE");
282. warna.add("BLUE");
283. warna.add("CYAN");
284. List hapuswarna=new LinkedList();
285. hapuswarna.add("RED");
286. hapuswarna.add("WHITE");
287. hapuswarna.add("BLUE");
288. warna.removeAll(hapuswarna);
289. System.out.println("Warna : ");
290. System.out.print(warna);
 291. }
292. }

Outputnya :

Analisa :

293. Listing Program :

294. import java.util.*;

295. import java.util.Comparator;
296.
297. public class Mahasiswa2 implements Comparable<Mahasiswa2>{
298. public String nama;
299. public int nrp;
300. public float nilai;
301.
302. public Mahasiswa2(String nama){
303. this.nama=nama;
304. }
305.
306. public Mahasiswa2(int nrp, String nama){
307. this.nama=nama;
308. this.nrp=nrp;
309. this.nilai= 60 + (float) Math.random()*40;
310. }
311.
312. @Override
313. public int compareTo(Mahasiswa2 mhs){
314. return (int)(this.nilai-mhs.nilai);
315. }
316.
317. public float cetaknilai(){
318. return nilai;
319. }
320.
321. public int cetaknrp(){
322. return nrp;
323. }
324.
325. public String cetaknama() {
326. return nama;
327. }
328. }
import java.util.*;
import java.util.Collections;
public class Latihan4 {
public static void main(String[] args) {
List<Mahasiswa2> mhs=new LinkedList<Mahasiswa2>();
 String[]nama={"nama1","nama2","nama3","nama4"};
int[] nrp = {1,2,3,4};
int i=0;
while(i<nama.length){
mhs.add(new Mahasiswa2(nrp[i], nama[i]));
i++;
}
System.out.println("Data Mahasiswa : ");
Collections.sort(mhs);
for(Mahasiswa2 mahasiswa : mhs){
System.out.println("Nama:" + mahasiswa.cetaknama()+"|
NRP:"+mahasiswa.cetaknrp()+"|Nilai:"+mahasiswa.cetaknilai());
}
}
}
Outputnya :

Analisa :

329. Listing Program :

330. import java.util.*;

331. import java.util.Map.Entry;
332. import java.util.Scanner;
333. import java.util.Comparator;
334. import java.util.Collections;
335.
336. public class Latihan6 {
337. public static void main(String[]args){
338. Scanner in = new Scanner(System.in);
339. int jml=0, i=0;
340. String kata;
341. System.out.print("Masukkan kata : ");
342. kata = in.nextLine();
343. TreeMap<String,Integer> map = new TreeMap();
344. String[]pc=kata.split("");
345. while(i<pc.length){
346. if(map.containsKey(pc[i])){
347. jml = map.get(pc[i]);
348. map.put(pc[i], jml+1);
349. }
350. else {
351. map.put(pc[i], 1);
352. }
353. i++;
354. }
355. System.out.println(map);
356. }
 357. }

Outputnya :

Analisa :

358. Listing Program :

359. import java.util.*;

360. import java.util.Map.Entry;
361. import java.util.Scanner;
362. import java.util.Comparator;
363. import java.util.Collections;
364.
365. public class Latihan7 {
366. public static void main(String[]args){
367. Scanner in = new Scanner(System.in);
368. int jml=0;
369. int i=0;
370. String kata;
371. System.out.print("Enter some katas : ");
372. kata = in.nextLine();
373. TreeMap<String,Integer> tools=new TreeMap();
374. String[]pc=kata.split("");
375. while(i<pc.length){
376. if(tools.containsKey(pc[i])){
377. jml = tools.get(pc[i]);
378. tools.put(pc[i], jml+1);
379. }
380. else {
381. tools.put(pc[i], 1);
382. }
383. i++;
384. }
385. class treeMappComparator implements Comparator<Map.Entry<String,
Integer>> {
386. public int
compare(Map.Entry<String,Integer>aa,Map.Entry<String,Integer>bb){
387. return aa.getValue().compareTo(bb.getValue());
388. } }
389. System.out.println(tools);
390. System.out.println("Min:"+Collections.min(tools.entrySet(),new
treeMappComparator()));
391. System.out.println("Max:"+Collections.max(tools.entrySet(),new
treeMappComparator()));
392. System.out.println("Dengan awala
nm:"+tools.subMap("m",true,"t",false));}
393. }
 Outputnya :

Analisa :

394. Listing Program :

395. import java.util.SortedMap;

396. import java.util.TreeMap;
397. public class Latihan8 {
398. public static void main(String[] args) {
399. TreeMap<String, TreeMap<String, String>>pulau=new TreeMap();
400. TreeMap<String, String>province=new TreeMap();
401. pulau.put("Sumatera", new TreeMap<String, String>());
402. TreeMap<String, String> sumatra=pulau.get("Sumatera");
403. sumatra.put("Nagroe Aceh Darussalam", "Banda Aceh");
404. sumatra.put("Sumatera Utara", "Medan");
405. sumatra.put("Riau", "Pekanbaru");
406. sumatra.put("Sumatera Barat", "Padang");
407. sumatra.put("Kepulauan Riau", "Tanjung Pinang");
408. sumatra.put("Lampung", "Bandar Lampung");
409. sumatra.put("Bengkulu", "Bengkulu");
410. System.out.println("IbukotaProvinsidiSumatera:");
411. System.out.println(toStringWrapper(pulau.get("Sumatera")));
412. pulau.put("Jawa", new TreeMap<String, String>());
413. TreeMap<String, String>jawa=pulau.get("Jawa");
414. jawa.put("Banten", "Serang");
415. jawa.put("DKI Jakarta", "Jakarta");
416. jawa.put("Jawa Timur", "Surabaya");
417. jawa.put("Jawa Tengah", "Semarang");
418. jawa.put("DI Yogyakarta", "Yogyakarta");
419. System.out.println("IbukotaProvinsidiJawa:");
420. System.out.println(toStringWrapper(pulau.get("Jawa")));
421. pulau.put("Sulawesi", new TreeMap<String, String>());
422. TreeMap<String, String>sulawesi=pulau.get("Jawa");
423. sulawesi.put("Gorontalo", "Gorontalo");
424. sulawesi.put("Sulawesi Utara", "Manado");
425. sulawesi.put("Sulawesi Tengah", "Palu");
426. sulawesi.put("Sulawesi Barat", "Kota Manuju");
427. sulawesi.put("Sulawesi Tenggara", "Kendari");
428. sulawesi.put("Sulawesi Selatan", "Makassar");
429. System.out.println("IbukotaProvinsiyangberawalanS:");
430. for(TreeMap<String,String>a:pulau.values()){
431. SortedMap<String, String> b=a.tailMap("S");
432. System.out.println(b.size()<=0?(""):toStringWrapper(b));
433. }
434. }
 435. private static String toStringWrapper (Object obyek){
436. return (obyek.toString().replace("{", "\t").replace("{", "
").replace(",", "\n\t").replace(" = ", " = "));
437. }
438. }

Outputnya :

Analisa :
5.KESIMPULAN
Semua method yang ada dalam set, list, dan map berguna untuk diterapkan dalam hal menginputkan data dan
mengolahnya agar sesuai dengan keinginan user.