Java Quick, Nishio

3 1 List 1 1.1........................... 1 1.2.......................... 2 1.3 1.................. 3 1.4 2.................. 4 1.5 1...................... 6 1.6 2...................... 6 1.7 3...................... 9 1.8....................... 11 1.8.1.................... 12 1.8.2 synchronizedlist........ 13 1.8.3............... 16 1.8.4 CopyOnWriteArrayList....... 19 1.9............................. 21 1.9.1 ArrayList LinkedList... 21 1.9.2 get Iterator.................... 23 1.9.3 CopyOnWriteArrayList............... 26 1.9.4................. 27 1.10................................. 30 2 Set 33 2.1 HashSet....................... 33 2.2 TreeSet........................ 34 2.3 contains............................. 34 2.4 containsall........................... 35 2.5 retainall............................ 36 2.6 Set.......................... 37 2.7 Set..................... 40 2.8....................... 42 2.9................................. 44 2.10............................. 44

3 Map 47 3.1 HashMap....................... 47 3.2 1......................... 48 3.3 2......................... 48 3.4................... 50 3.5..... 51

1 1 List List List ArrayList LinkedList List LinkedList ArrayList LinkedList ArrayList LinkedList 1.1 1 import java.util. ArrayList; 2 import java.util.list; 3 4 public class ArrayList1 { 5 public static void main(string[] args) { 6 7 List <String > mylist = new ArrayList <String >(); 8 mylist.add("hello "); 9 mylist.add("world"); 10 11 System.out.println(myList); 12 13 String s = mylist.get(1); 14 System.out.println(s); 15 } 16 } [Hello, World] World List<String> mylist = new ArrayList<String>(); String ArrayList mylist add

1.2 get String s = mylist.get(1); mylist 2 1.2 1 import java.util. ArrayList; 2 import java.util.list; 3 4 public class ArrayList2 { 5 6 private static final String[] colors = 7 { "RED", "GREEN", "BLUE", "BLACK", "WHITE"}; 8 10 9 public static void main(string[] args) { 11 List <String > mylist = new ArrayList <String >(); 12 13 for(string color : colors) 14 mylist.add(color); 15 16 System.out.println("myList size is " + mylist.size()); 17 System.out.println("myList is " + mylist); 18 19 mylist.remove(3); 20 mylist.remove("white"); 21 22 System.out.println("myList is " + mylist); 23 } 24 } mylist size is 5 mylist is [RED, GREEN, BLUE, BLACK, WHITE] mylist is [RED, GREEN, BLUE] for(string color : colors) mylist.add(color); for-each for(int i = 0; i < colors.length; i++) mylist.add(colors[i]); 2

1 List size colors 5 size 5 remove mylist.remove(3); 4 BLACK mylist.remove("white"); 1.3 1 1 import java.util. ArrayList; 2 import java.util. Iterator; 3 import java.util.list; 4 5 public class ArrayList_Iterator2 { 6 public static void main(string[] args) { 7 List <String > mylist = new ArrayList <String >(); 8 9 mylist.add(" B "); 10 mylist.add(" A "); 11 mylist.add(" C "); 12 13 // 14 Iterator <String > i = mylist.iterator(); 15 16 while(i.hasnext ()){ 17 String name = i.next(); 18 System.out.println(name); 19 } 20 21 } 22 } B A C String name = mylist.get(0); 3

1.4 2 mylist B get (iterator) Iterator<String> i = mylist.iterator(); // iterator boolean hasnext() hasnext true false object next() next hasnext() next() 1.4 2 1 public class Member { 2 3 private String name; // Member 4 private int age; // Member 5 6 public String getname() { 7 return name; 8 } 9 public void setname(string name) { 10 this.name = name; 11 } 12 public int getage() { 13 return age; 14 } 15 public void setage(int age) { 16 this.age = age; 17 } 18 19 public Member(String name, int age){ 20 this.name = name; 21 this.age = age; 22 } 23 } 4

1 List 1 import java.util. ArrayList; 2 import java.util. Iterator; 3 import java.util.list; 4 5 public class ArrayList_Iterator { 6 7 public static void main(string[] args) { 8 10 9 List <Member > member = new ArrayList <Member >(); 11 // Member 12 member.add(new Member(" B ", 21)); 13 member.add(new Member(" A ", 20)); 14 member.add(new Member(" C ", 22)); 15 16 // 17 Iterator <Member > i = member.iterator(); 18 while(i.hasnext ()){ 19 // 20 Member m = i.next(); 21 System.out.print("Name : " + m.getname ()); 22 System.out.println(" Age : " + m.getage()); 23 } 24 } 25 } Name : B Age : 21 Name : A Age : 20 Name : C Age : 22 Member name( ) age( ) member.add(new Member("B ", 21)); member B 21 A B String name = member.get(0).getname(); get 5

1.5 1 1.5 1 1 import java.util. ArrayList; 2 import java.util. Collections; 3 import java.util.list; 4 5 public class ArrayList_Sort { 6 7 public static void main(string[] args) { 8 List <String > mylist = new ArrayList <String >(); 9 10 mylist.add(" B "); 11 mylist.add(" A "); 12 mylist.add(" C "); 13 14 System.out.println("unsorted " + mylist); 15 // sort 16 Collections.sort(myList); 17 System.out.println("sorted " + mylist); 18 } 19 } unsorted [B, A, C ] sorted [A, B, C ] String ArrayList ArrayList sort java.util.collections Collections.sort(myList); 1.6 2 2 Collections.sort(member); 6

1 List : Collections sort(list<t>) (List<Member>) Member <T extends Comparable<? super T>> Comparable 1 String String Comparable Collections.sort() String Comparable compareto String Comparable implements compareto Member Comparable compareto String compareto public int compareto(string anotherstring) 2 1 public class ComparableTest { 2 3 public static void main(string[] args) { 4 5 String piyo = "BBB"; 6 7 String hoge = "AAA"; 8 String foo = "BBB"; 9 String bar = "CCC"; 10 11 int x = piyo.compareto(hoge); // piyo hoge 12 int y = piyo.compareto(foo); // piyo foo 13 int z = piyo.compareto(bar); // piyo bar 14 15 System.out.println("piyo hoge :" + x); 16 System.out.println("piyo foo :" + y); 17 System.out.println("piyo bar :" + z); 18 } 19 } piyo hoge :1 piyo foo :0 piyo bar :-1 compareto 7

1.6 2 "BBB" < "AAA" -1 "BBB" == "BBB" 0 "BBB" > "CCC" 1 int Object < Object Object == Object 0 Object > Object sort compareto Member compareto < == 0 > 1 public class Member2 implements Comparable <Member2 >{ // #1 2 3 private String name; // Member 4 private int age; // Member 5 6 public String getname() { 7 return name; 8 } 9 public void setname(string name) { 10 this.name = name; 11 } 12 public int getage() { 13 return age; 14 } 15 public void setage(int age) { 16 this.age = age; 17 } 18 19 public Member2(String name, int age){ 20 this.name = name; 21 this.age = age; 22 } 23 24 public int compareto(member2 o) { // #2 25 return this.getname(). compareto(o.getname ()); 26 } 27 28 } 8

1 List 1 import java.util. ArrayList; 2 import java.util. Collections; 3 import java.util. Iterator; 4 import java.util.list; 5 6 public class ArrayList_Sort2 { 7 8 public static void main(string[] args) { 9 10 List <Member2 > member = new ArrayList <Member2 >(); 11 12 // Member 13 member.add(new Member2(" B ", 21)); 14 member.add(new Member2(" A ", 20)); 15 member.add(new Member2(" C ", 22)); 16 17 // M e m b e r 2 18 Collections.sort(member); 19 20 // 21 Iterator <Member2 > i = member.iterator(); 22 while(i.hasnext ()){ 23 // 24 Member2 m = i.next(); 25 System.out.print("Name : " + m.getname ()); 26 System.out.println(" Age : " + m.getage()); 27 } 28 29 } 30 } Name : A Age : 20 Name : B Age : 21 Name : C Age : 22 Member2 1 Member2 Comparable compareto String String compareto 1.7 3 comparable 1 9

1.7 3 Collections sort 2 public static void sort(list list) public static void sort(list list, Comparator c) sort sort 1 import java.util. ArrayList; 2 import java.util. Collections; 3 import java.util. Comparator; 4 import java.util. Iterator; 5 import java.util.list; 6 7 public class ArrayList_Sort3 { 8 10 9 public static void main(string[] args) { 11 List <Member2 > member = new ArrayList <Member2 >(); 12 13 // Member 14 member.add(new Member2(" B ", 21)); 15 member.add(new Member2(" A ", 20)); 16 member.add(new Member2(" C ", 22)); 17 18 //#1 19 Collections.sort(member, new NameSort ()); 20 // 21 Iterator <Member2 > i = member.iterator(); 22 while(i.hasnext ()){ 23 // 24 Member2 m = i.next(); 25 System.out.print("Name : " + m.getname ()); 26 System.out.println(" Age : " + m.getage()); 27 } 28 29 System.out.println("----------------------"); 30 // #2 31 Collections.sort(member, new NameReverseSort ()); 32 i = member.iterator(); // 33 34 while(i.hasnext ()){ 35 // 36 Member2 m = i.next(); 37 System.out.print("Name : " + m.getname ()); 38 System.out.println(" Age : " + m.getage()); 39 } 40 41 } 42 } 43 44 // 45 class NameSort implements Comparator <Member2 >{ //#3 46 47 public int compare(member2 o1, Member2 o2) { 48 return o1.getname(). compareto(o2.getname ()); 49 } 50 } 51 10

1 List 52 // 53 class NameReverseSort implements Comparator <Member2 >{ 54 55 public int compare(member2 o1, Member2 o2) { 56 return o1.getname().compareto(o2.getname()) * (-1); //#4 57 } 58 } Name : A Age : 20 Name : B Age : 21 Name : C Age : 22 ---------------------- Name : C Age : 22 Name : B Age : 21 Name : A Age : 20 sort 2 Comparator compare Comparable #1 2 #2 #3 #4 compareto sort 2 1.8 ArrayList LinkedList 11

1.8 1.8.1 ArrayList list 1 import java.util. ArrayList; 2 import java.util. Iterator; 3 4 5 public class Practice{ 6 7 class AccessTest implements Runnable { 8 10 9 public void run() { 11 try { 12 for(;;) { 13 Iterator <Integer > iter = list.iterator(); 14 while( iter.hasnext() ) { 15 // l i s t 16 int tmp = iter.next(); 17 //50 m s 18 Thread.sleep (50); 19 } 20 System.out.println(""); 21 } 22 }catch( Exception e) { 23 // 24 System.out.println("Error @AccessTest"); 25 e. printstacktrace (); 26 } 27 } 28 } 29 30 class UpdateTest implements Runnable { 31 32 public void run() { 33 try{ 34 for(;;) { 35 for(int i=0; i < 100; i++) { 36 list.add(i); 37 } 38 Iterator <Integer > iter = list.iterator(); 39 while( iter.hasnext() ) { 40 // l i s t 41 iter.next(); 42 // n e x t 43 iter.remove(); 44 //50 m s 45 Thread.sleep (50); 46 } 47 System.out.println(""); 48 } 49 }catch( Exception e) { 50 System.out.println("Error @UpdateTest"); 51 e. printstacktrace (); 52 } 53 } 54 } 55 56 public Practice() { 57 AccessTest access = new AccessTest(); 58 UpdateTest update = new UpdateTest(); 59 Thread accessthread = new Thread(access); 12

1 List 60 Thread updatethread = new Thread(update); 61 62 // AccessTest UpdateTest 63 System.out.println(" "); 64 accessthread.start(); 65 updatethread.start(); 66 } 67 68 public static void main(string args[]) { 69 new Practice(); 70 } 71 72 private ArrayList <Integer > list = new ArrayList <Integer >(); 73 } Error @AccessTest java.util.concurrentmodificationexception at java.util.abstractlist$ Itr.checkForComodification(AbstractList.java:372) at java.util.abstractlist$itr.next(abstractlist.java:343) at Practice$AccessTest.run(Practice.java:20) at java.lang.thread.run(thread.java:619) ConcurrentModificationException AccessTest ArrayList synchronizedlist 1.8.2 synchronizedlist List Collections.synchronizedList ArrayList LinkedList 13

1.8 1 import java.util. ArrayList; 2 import java.util. Collections; 3 import java.util. Iterator; 4 import java.util.list; 5 6 7 public class Practice{ 8 10 9 class AccessTest implements Runnable { 11 public void run() { 12 13 try { 14 for(;;) { 15 synchronized( list ) { 16 Iterator <Integer > iter = list.iterator(); 17 while( iter.hasnext() ) { 18 // l i s t 19 int tmp = iter.next(); 20 //50 m s 21 Thread.sleep (50); 22 } 23 System.out.println(""); 24 //50 m s 25 Thread.sleep (50); 26 } 27 } 28 }catch( Exception e) { 29 // 30 System.out.println("Error @AccessTest"); 31 e. printstacktrace (); 32 } 33 } 34 } 35 36 class UpdateTest implements Runnable { 37 38 public void run() { 39 try{ 40 for(;;) { 41 synchronized( list ) { 42 for(int i=0; i < 100; i++) { 43 list.add(i); 44 //50 m s 45 Thread.sleep (50); 46 } 47 Iterator <Integer > iter = list.iterator(); 48 while( iter.hasnext() ) { 49 // l i s t 50 iter.next(); 51 // n e x t 52 iter.remove(); 53 //50 m s 54 Thread.sleep (50); 55 } 56 } 57 System.out.println(""); 58 } 59 }catch( Exception e) { 60 System.out.println("Error @UpdateTest"); 61 e. printstacktrace (); 62 } 14

1 List 63 } 64 } 65 66 public Practice() { 67 AccessTest access = new AccessTest(); 68 UpdateTest update = new UpdateTest(); 69 Thread accessthread = new Thread(access); 70 Thread updatethread = new Thread(update); 71 72 // AccessTest UpdateTest 73 System.out.println(" "); 74 accessthread.start(); 75 updatethread.start(); 76 } 77 78 public static void main(string args[]) { 79 new Practice(); 80 } 81 82 private List <Integer > list = 83 Collections. synchronizedlist( new ArrayList <Integer >() ); 84 } ArrayList Collections.synchronizedList Iterator list synchronized list AccessTest UpdateTest run Iterator synchronized 15

1.8 synchronized. synchronized ( 1.1) 1.1: 1.8.3 1 class AccessTest implements Runnable { 2 3 public void run() { 4 5 try { 6 for(;;) { 7 System.out.println("start @accesstest"); 8 //50 m s 9 Thread.sleep (50); 10 synchronized( list ) { 11 Iterator <Integer > iter = list.iterator(); 12 while( iter.hasnext() ) { 13 // l i s t 14 int tmp = iter.next(); 15 //50 m s 16 Thread.sleep (50); 17 } 18 System.out.println(""); 19 } 20 } 21 }catch(exception e) { 22 // 23 System.out.println("Error @AccessTest"); 24 e. printstacktrace (); 16

1 List 25 } 26 } 27 } 28 29 class UpdateTest implements Runnable { 30 31 public void run() { 32 try{ 33 for(;;) { 34 System.out.println("start @updatetest"); 35 for(int i=0; i < 100; i++) { 36 list.add(i); 37 //50 m s 38 Thread.sleep (50); 39 } 40 while( list.size()!= 0 ) { 41 list.remove (0); 42 //50 m s 43 Thread.sleep (50); 44 } 45 System.out.println(""); 46 } 47 }catch( Exception e) { 48 System.out.println("Error @UpdateTest"); 49 e. printstacktrace (); 50 } 51 } 52 } UpdateTest run synchronized 17

1.8 start @accesstest start @updatetest start @accesstest start @accesstest start @accesstest start @accesstest start @accesstest start @accesstest start @accesstest 2 UpdateTest run AccessTest run list UpdateTest AccessTest synchronized synchronized CopyOnWriteArrayList 18

1 List 1.8.4 CopyOnWriteArrayList CopyOnWriteArrayList CopyOnWriteArrayList ArrayList LinkedList 1 import java.util. ArrayList; 2 import java.util. Collections; 3 import java.util. Iterator; 4 import java.util.list; 5 import java.util. concurrent. CopyOnWriteArrayList; 6 7 8 public class Practice{ 9 10 class AccessTest implements Runnable { 11 12 public void run() { 13 14 try { 15 for(;;) { 16 System.out.println("start @accesstest"); 17 18 Iterator <Integer > iter = list.iterator(); 19 while( iter.hasnext() ) { 20 // l i s t 21 int tmp = iter.next(); 22 //50 m s 23 Thread.sleep (50); 24 } 25 System.out.println(""); 26 27 } 28 }catch( Exception e) { 29 // 30 System.out.println("Error @AccessTest"); 31 e. printstacktrace (); 32 } 33 } 34 } 35 36 class UpdateTest implements Runnable { 37 38 public void run() { 39 try{ 40 for(;;) { 41 System.out.println("start @updatetest"); 42 for(int i=0; i < 100; i++) { 43 list.add(i); 44 //50 m s 45 Thread.sleep (50); 46 } 47 while( list.size()!= 0 ) { 48 list.remove(0); 49 //50 m s 50 Thread.sleep (50); 51 } 52 System.out.println(""); 53 } 54 }catch( Exception e) { 55 System.out.println("Error @UpdateTest"); 56 e. printstacktrace (); 19

1.8 57 } 58 } 59 } 60 61 public Practice() { 62 AccessTest access = new AccessTest(); 63 UpdateTest update = new UpdateTest(); 64 Thread accessthread = new Thread(access); 65 Thread updatethread = new Thread(update); 66 67 // AccessTest UpdateTest 68 System.out.println(" "); 69 accessthread.start(); 70 updatethread.start(); 71 } 72 73 public static void main(string args[]) { 74 new Practice(); 75 } 76 77 private List <Integer > list = 78 new CopyOnWriteArrayList <Integer >(); 79 } start @accesstest start @accesstest start @accesstest start @updatetest start @accesstest start @accesstest start @updatetest start @accesstest CopyOnWriteArrayList synchronized 20

1 List CopyOnWriteArrayList CopyOnWriteArrayList ArrayList synchronizedlist Iterator Iterator add remove UnsupportedOperationException 1.9 1.9.1 ArrayList LinkedList ArrayList LinkedList ArrayList LinkedList LinkedList ArrayList ArrayList LinkedList CPU athlon64 3800+(2.41GHz), RAM 1GByte WindowsXP 1.1 1.2 1.1: ArrayList[ms] LinkedList[ms] 10000 0 0 50000 16 16 100000 16 31 500000 188 297 1000000 313 610 ( ms) LinkedList 1.2 1.3 21

1.9 700 ArrayList LinkedList 600 500 time[ms] 400 300 200 100 0 0 100000 200000 300000 400000 500000 600000 700000 800000 900000 1e+006 data 1.2: 1.2: ArrayList[ms] LinkedList[ms] 1000 0 0 5000 16 0 10000 46 0 20000 187 15 30000 516 16 40000 953 16 50000 1500 16 22

1 List 1600 ArrayList LinkedList 1400 1200 1000 time[ms] 800 600 400 200 0 0 5000 10000 15000 20000 25000 30000 35000 40000 45000 50000 data 1.3: LinkedList 10000 ArrayList 50000 LinkedList 100 LinkedList ArrayList LinkedList 1.9.2 get Iterator get Iterator Iterator ArrayList LinkedList get Iterator 23

1.9 ArrayList CPU athlon64 3800+(2.41GHz), RAM 1GByte WindowsXP 1.3 1.4 1.3: ArrayList get iterator get[ms] Iterator[ms] 10000 0 0 50000 0 0 100000 0 0 500000 15 31 1000000 31 47 50 45 get Iterator 40 35 30 time[ms] 25 20 15 10 5 0 0 100000 200000 300000 400000 500000 600000 700000 800000 900000 1e+006 data 1.4: ArrayList get iterator [ms] get LinkedList 1.4 1.5 24

1 List 1.4: LinkedList get iterator get[ms] Iterator[ms] 1000 0 0 5000 16 0 10000 141 0 15000 328 0 20000 1484 0 30000 3718 0 40000 7313 0 8000 get Iterator 7000 6000 5000 time[ms] 4000 3000 2000 1000 0 0 5000 10000 15000 20000 25000 30000 35000 40000 data 1.5: LinkedList get iterator 25

1.9 Iterator get Iterator ArrayList get get 10ms ArrayList LinkedList Iterator 1.9.3 CopyOnWriteArrayList CopyOnWriteArrayList ArrayList synchronizedlist CPU athlon64 3800+(2.41GHz), RAM 1GByte WindowsXP 1.5 1.6 ArrayList synchronizedlist CopyOnWriteArrayList CopyOnWriteArrayList synchronizedlist 1.5: CopyOnWriteArrayList ArrayList[ms] SyncArrayList[ms] CopyArrayList[ms] 1000 0 0 16 5000 0 0 109 10000 0 0 422 20000 0 0 1765 30000 15 16 4656 26

1 List 5000 4500 ArrayList SyncArrayList CopyArrayList 4000 3500 3000 time[ms] 2500 2000 1500 1000 500 0 0 5000 10000 15000 20000 25000 30000 data 1.6: CopyOnWriteArrayList 1.9.4 ArrayList LinkedList 1 import java.util. ArrayList; 2 import java.util. LinkedList; 3 import java.util.list; 4 5 6 class Practice{ 7 8 public void arraylisttest() { 9 List <Integer > mylist = new ArrayList <Integer >(); 10 long start, stop, diff; 11 12 start = System. currenttimemillis (); 13 for(int i=0; i < DATASIZE; i++ ) { 14 mylist.add(i); 15 } 16 stop = System. currenttimemillis (); 17 diff = stop - start; 18 System.out.println(" : " + diff + " ms"); 19 } 20 21 public void linkedlisttest() { 22 List <Integer > mylist = new LinkedList <Integer >(); 23 long start, stop, diff; 24 25 start = System. currenttimemillis (); 26 for(int i=0; i < DATASIZE; i++ ) { 27 mylist.add(i); 27

1.9 28 } 29 stop = System. currenttimemillis (); 30 diff = stop - start; 31 System.out.println(" : " + diff + " ms"); 32 } 33 34 public void arraylisttest2() { 35 List <Integer > mylist = new ArrayList <Integer >(); 36 long start, stop, diff; 37 38 mylist.add(0); 39 40 start = System. currenttimemillis (); 41 for(int i=0; i < DATASIZE; i++ ) { 42 mylist.add(1,i); 43 } 44 stop = System. currenttimemillis (); 45 diff = stop - start; 46 System.out.println(" : " + diff + " ms"); 47 } 48 49 public void linkedlisttest2() { 50 List <Integer > mylist = new LinkedList <Integer >(); 51 long start, stop, diff; 52 53 mylist.add(0); 54 55 start = System. currenttimemillis (); 56 for(int i=0; i < DATASIZE; i++ ) { 57 mylist.add(1,i); 58 } 59 stop = System. currenttimemillis (); 60 diff = stop - start; 61 System.out.println(" : " + diff + " ms"); 62 } 63 64 public static void main(string[] args) { 65 Practice p = new Practice(); 66 //p. arraylisttest2 (); 67 p. linkedlisttest2 (); 68 //p. arraylisttest (); 69 //p. linkedlisttest (); 70 } 71 // 72 private static final int DATASIZE = 50000; 73 } get Iterator 1 import java.util. ArrayList; 2 import java.util. Iterator; 3 import java.util. LinkedList; 4 import java.util.list; 5 6 class Practice{ 7 8 public void arraylisttest() { 9 List <Integer > mylist = new ArrayList <Integer >(); 10 long start, stop, diff; 11 12 for(int i=0; i < DATASIZE; i++ ) { 28

1 List 13 mylist.add(i); 14 } 15 16 start = System. currenttimemillis (); 17 for(int i=0; i < DATASIZE; i++) { 18 int j = mylist.get(i); 19 } 20 stop = System. currenttimemillis (); 21 22 diff = stop - start; 23 System.out.println(" : " + diff + " ms"); 24 } 25 26 public void linkedlisttest() { 27 List <Integer > mylist = new LinkedList <Integer >(); 28 long start, stop, diff; 29 30 for(int i=0; i < DATASIZE; i++ ) { 31 mylist.add(i); 32 } 33 34 start = System. currenttimemillis (); 35 for(int i=0; i < DATASIZE; i++) { 36 int j = mylist.get(i); 37 } 38 stop = System. currenttimemillis (); 39 40 diff = stop - start; 41 System.out.println(" : " + diff + " ms"); 42 } 43 44 public void arraylisttest2() { 45 List <Integer > mylist = new ArrayList <Integer >(); 46 long start, stop, diff; 47 48 for(int i=0; i < DATASIZE; i++ ) { 49 mylist.add(i); 50 } 51 52 Iterator <Integer > iter = mylist.iterator(); 53 start = System. currenttimemillis (); 54 55 while(iter.hasnext ()){ 56 int j = iter.next(); 57 } 58 stop = System. currenttimemillis (); 59 60 diff = stop - start; 61 System.out.println(" : " + diff + " ms"); 62 } 63 64 public void linkedlisttest2() { 65 List <Integer > mylist = new LinkedList <Integer >(); 66 long start, stop, diff; 67 68 for(int i=0; i < DATASIZE; i++ ) { 69 mylist.add(i); 70 } 71 72 Iterator <Integer > iter = mylist.iterator(); 73 start = System. currenttimemillis (); 74 75 while(iter.hasnext ()){ 76 int j = iter.next(); 77 } 29

1.10 78 stop = System. currenttimemillis (); 79 80 diff = stop - start; 81 System.out.println(" : " + diff + " ms"); 82 } 83 84 public static void main(string[] args) { 85 Practice p = new Practice(); 86 //p. arraylisttest2 (); 87 p. linkedlisttest2 (); 88 //p. arraylisttest (); 89 //p. linkedlisttest (); 90 } 91 92 private static final int DATASIZE = 20000; 93 } CopyOnWriteArrayList 1 import java.util. ArrayList; 2 import java.util. Collections; 3 import java.util.list; 4 import java.util. concurrent. CopyOnWriteArrayList; 5 6 public class Practice{ 7 8 public void addlisttest(list <Integer > test) { 9 List <Integer > mylist = test; 10 long start, stop, diff; 11 12 start = System. currenttimemillis (); 13 for(int i=0; i < DATASIZE; i++ ) { 14 mylist.add(i); 15 } 16 stop = System. currenttimemillis (); 17 diff = stop - start; 18 System.out.println(" : " + diff + " ms"); 19 } 20 21 public static void main(string[] args) { 22 Practice p = new Practice(); 23 //p. addlisttest(new ArrayList <Integer >() ); 24 //p. addlisttest( Collections. synchronizedlist(new ArrayList <Integer >())); 25 p. addlisttest(new CopyOnWriteArrayList <Integer >() ); 26 } 27 // 28 private static final int DATASIZE = 1000; 29 } 1.10 1 2 Member2 30

1 List 2 3 ArrayList Sort3 31

33 2 Set Set HashSet TreeSet HashSet TreeSet HashSet TreeSet 2.1 HashSet 1 import java.util.hashset; 2 import java.util. Iterator; 3 import java.util.set; 4 5 public class Set_Test { 6 7 public static void main(string[] args) { 8 Set <String > set = new HashSet <String >(); 9 10 // s e t 11 set.add("nuko"); 12 set.add("quick"); 13 set.add("nishio"); 14 set.add("nuko"); //#1 15 16 Iterator <String > ite = set.iterator(); 17 while(ite.hasnext()) 18 System.out.println(ite.next()); 19 } 20 } Nuko Nishio Quick set #1

2.2 TreeSet HashSet 2.2 TreeSet 1 import java.util. Iterator; 2 import java.util.set; 3 import java.util.treeset; 4 5 6 public class Set_Test2 { 7 8 public static void main(string[] args) { 9 Set <String > set = new TreeSet <String >(); 10 11 // s e t 12 set.add("nuko"); 13 set.add("quick"); 14 set.add("nishio"); 15 set.add("nuko"); 16 17 Iterator <String > ite = set.iterator(); 18 while(ite.hasnext()) 19 System.out.println(ite.next()); 20 } 21 22 } Nishio Nuko Quick TreeSet 2.3 contains Set contains true 1 import java.util.hashset; 2 import java.util.set; 3 4 34

2 Set 5 public class Set_Test3 { 6 public static void main(string[] args) { 7 Set <String > set = new HashSet <String >(); 8 9 // 10 set.add(new String("A")); 11 set.add(new String("B")); 12 set.add(new String("C")); 13 14 if(set.contains("a")); 15 System.out.println("A "); 16 17 if(set.contains("d")) 18 System.out.println("D "); 19 else 20 System.out.println("D "); 21 } 22 } A D set A,B,C contains A D contains Set true false 2.4 containsall containsall containsall true 1 import java.util.hashset; 2 import java.util.set; 3 4 public class Set_Test4 { 5 public static void main(string[] args) { 6 Set <String > set = new HashSet <String >(); 7 8 // 9 set.add(new String("A")); 10 set.add(new String("B")); 11 set.add(new String("C")); 12 13 Set <String > set2 = new HashSet <String >(); 14 set2.add(new String("A")); 15 set2.add(new String("B")); 16 35

2.5 retainall 17 Set <String > set3 = new HashSet <String >(); 18 set3.add(new String("C")); 19 set3.add(new String("D")); 20 21 System.out.println("set :" + set); 22 System.out.println("set2 :" + set2); 23 System.out.println("set3 :" + set3); 24 25 if(set. containsall(set2)) //#1 26 System.out.println(" s e t s e t 2 "); 27 28 if(set. containsall(set3)) //#2 29 System.out.println(" s e t s e t 3 "); 30 else 31 System.out.println(" s e t s e t 3 "); 32 } 33 } set :[A, B, C] set2 :[A, B] set3 :[D, C] set set2 set set3 #1 set [A,B,C] set2 [A,B] true #2 set[a,b,c] Set3[D,C] C D false 2.5 retainall retainall. 1 import java.util.hashset; 2 import java.util.set; 3 4 public class Set_Test5 { 5 public static void main(string[] args) { 6 Set <String > set = new HashSet <String >(); 7 8 // 9 set.add(new String("A")); 10 set.add(new String("B")); 36

2 Set 11 set.add(new String("C")); 12 13 Set <String > set2 = new HashSet <String >(); 14 set2.add(new String("A")); 15 set2.add(new String("B")); 16 set2.add(new String("D")); 17 18 Set <String > intersect = new HashSet <String >( set); //#1 19 intersect. retainall(set2); //#2 20 21 System.out.println("set AND set2 :" + intersect); 22 } 23 } set AND set2 :[A, B] #1 Set<String> intersect = set; intersect set #2 intersect [A,B,C] set2 [A,B,D] intersect C 2.6 Set 1 public class Member3 { 2 3 private String name; // Member 4 private int age; // Member 5 6 public String getname() { 7 return name; 8 } 9 public void setname(string name) { 10 this.name = name; 11 } 12 public int getage() { 13 return age; 14 } 15 public void setage(int age) { 16 this.age = age; 17 } 18 19 public Member3(String name, int age){ 20 this.name = name; 21 this.age = age; 37

2.6 Set 22 } 23 24 public Member3(String name){ 25 this.name = name; 26 this.age = 0; 27 } 28 29 public String tostring() { 30 String message = this.name + ":" + this.age; 31 return message; 32 } 33 } 1 import java.util.hashset; 2 import java.util.set; 3 4 public class Set_Test6 { 5 public static void main(string[] args) { 6 Set <Member3 > member = new HashSet <Member3 >(); 7 8 // 9 member.add(new Member3(" A ",20)); 10 member.add(new Member3(" B ",21)); 11 member.add(new Member3(" A ",22)); //#1 12 13 // A 20 14 if(!member.add(new Member3(" A ",20))) //#2 15 System.out.println(" A 20 "); 16 17 System.out.println(member); 18 } 19 } [B :21, A :22, A :20, A :20] #1 A #2 set HashSet (HashTable, HashMap, HashSet) hashcode Java Object hashcode 38

2 Set hashcode java.util.hashtable equals(object) 2 hashcode. Object hashcode JavaTM Java2 Se v1.4.0 HashCode hash equal equals. equals Object equals x y x y (x==y true) true hashcode hashcode Java2 Se v1.4.0 hashcode hashcode hash hash equals hash hash equal #2 2 hash 39

2.7 Set 1. name age 2. equal name age 2 2 2.7 Set 1 public class Member4 { 2 3 private String name; // Member 4 private int age; // Member 5 6 public String getname() { 7 return name; 8 } 9 public void setname(string name) { 10 this.name = name; 11 } 12 public int getage() { 13 return age; 14 } 15 public void setage(int age) { 16 this.age = age; 17 } 18 19 public Member4(String name, int age){ 20 this.name = name; 21 this.age = age; 22 } 23 24 public Member4(String name){ 25 this.name = name; 26 this.age = 0; 27 } 28 29 public String tostring() { 30 String message = this.name + ":" + this.age; 31 return message; 32 } 33 34 public int hashcode() { //#1 35 return this.name.hashcode() + this.age ; 36 } 37 38 public boolean equals(object obj) { //#2 39 // 40 if (obj instanceof Member4) { //#3 41 Member4 member = (Member4) obj; 42 // 43 if(this.name.equals(member.getname()) && this.age == member.getage()) //#4 44 return true; 45 else 46 return false; 47 }else{ 40

2 Set 48 return false; 49 } 50 } 51 } 1 import java.util.hashset; 2 import java.util.set; 3 4 5 public class Set_Test7 { 6 public static void main(string[] args) { 7 Set <Member4 > member = new HashSet <Member4 >(); 8 9 // 10 member.add(new Member4(" A ",20)); 11 member.add(new Member4(" B ",21)); 12 member.add(new Member4(" A ",22)); 13 14 // A 15 if(!member.add(new Member4(" A ",20))) 16 System.out.println(" A 2 0 "); 17 18 System.out.println(member); 19 } 20 } A 20 [A :20, B :21, A :22] A 20 #1 hashcode hash Hash Eclipse hashcode hash #2 equal Object #3 Object Member4 Member4 true false false #4 true 41

2.8 2.8 Set 1 public class Schedule { 2 private String date; // 3 private String subject; // 4 5 // 6 public Schedule(String date){ 7 this.date = date; 8 this.subject =""; 9 } 10 // 11 public Schedule(String date, String subject) { 12 this.date = date; 13 this.subject = subject; 14 } 15 16 // 17 public String getdate() { 18 return date; 19 } 20 public void setdate(string date) { 21 this.date = date; 22 } 23 public String getsubject() { 24 return subject; 25 } 26 public void setsubject(string subject) { 27 this.subject = subject; 28 } 29 30 // t o S t r i n g 31 public String tostring() { 32 String message = this.date + " " + this.subject + " "; 33 return message; 34 } 35 36 // e q u a l s 37 public boolean equals(object obj) { 38 // 39 if (obj instanceof Schedule) { 40 Schedule schedule = (Schedule) obj; 41 // 42 if(this.getdate(). equals(schedule.getdate ())) 43 return true; 44 else 45 return false; 46 }else{ 47 return false; 48 } 49 } 50 51 // h a s h C o d e 52 public int hashcode() { 53 // h a s h 54 return this.date.hashcode(); 55 } 56 57 } 42

2 Set 1 import java.util.hashset; 2 import java.util. Iterator; 3 import java.util.set; 4 5 6 public class Set_final { 7 8 public static void main(string[] args) { 9 Set <Schedule > schedule = new HashSet <Schedule >(); 10 11 // s e t ( 12 schedule.add(new Schedule("2008-08-05"," ")); 13 schedule.add(new Schedule("2008-08-06"," ")); 14 schedule.add(new Schedule("2008-08-07"," ")); 15 schedule.add(new Schedule("2008-08-08"," ")); 16 schedule.add(new Schedule("2008-08-10"," ")); 17 18 // 19 Iterator <Schedule > ite = schedule.iterator(); 20 21 // 22 while(ite.hasnext ()){ 23 System.out.println(ite.next()); 24 } 25 26 System.out.println("---------------"); 27 28 // 29 Set <Schedule > findschedule = new HashSet <Schedule >(); 30 findschedule.add(new Schedule("2008-08-05")); 31 findschedule.add(new Schedule("2008-08-10")); 32 findschedule.add(new Schedule("2008-08-11")); 33 34 // ----schedule AND findschedule ----- 35 Set <Schedule > intersect = new HashSet <Schedule >( schedule); 36 intersect. retainall( findschedule); 37 38 System.out.println(" :" + intersect); 39 40 //------ --------- 41 Schedule addschedule = new Schedule("2008-08-08"," "); 42 if(schedule.add( addschedule )){ 43 System.out.println(" "); 44 } else { 45 System.out.println(addSchedule.getDate() + " " + 46 " "); 47 } 48 49 // 50 System.out.println(schedule); 51 } 52 53 } 43

2.9 2008-08-10 2008-08-08 2008-08-07 2008-08-06 2008-08-05 :[2008-08-10, 2008-08-05 ] 2008-08-08 [2008-08-10, 2008-08-08, 2008-08-07, 2008-08-06, 2008-08-05 ] Member 2.9 1 HashSet TreeSet 2.10 1 public class Schedule2 implements Comparable <Schedule2 > { 2 3 private String date; // 4 private String subject; // 5 6 // 7 public Schedule2(String date){ 8 this.date = date; 9 this.subject =""; 10 } 11 // 12 public Schedule2(String date, String subject) { 13 this.date = date; 14 this.subject = subject; 15 } 44

2 Set 16 17 // 18 public String getdate() { 19 return date; 20 } 21 public void setdate(string date) { 22 this.date = date; 23 } 24 public String getsubject() { 25 return subject; 26 } 27 public void setsubject(string subject) { 28 this.subject = subject; 29 } 30 31 // t o S t r i n g 32 public String tostring() { 33 String message = this.date + " " + this.subject + " "; 34 return message; 35 } 36 37 38 public int compareto( Schedule2 o) { 39 return this.date. compareto(o.getdate()); 40 } 41 42 } 43 44 45 -------------------------------------------------- 46 47 import java.util. Iterator; 48 import java.util.set; 49 import java.util.treeset; 50 51 52 public class Set_final2 { 53 54 public static void main(string[] args) { 55 Set <Schedule2 > schedule = new TreeSet <Schedule2 >(); 56 57 // s e t ( 58 schedule.add(new Schedule2("2008-08-05"," ")); 59 schedule.add(new Schedule2("2008-08-06"," ")); 60 schedule.add(new Schedule2("2008-08-07"," ")); 61 schedule.add(new Schedule2("2008-08-08"," ")); 62 schedule.add(new Schedule2("2008-08-10"," ")); 63 64 // 65 Iterator <Schedule2 > ite = schedule.iterator(); 66 67 // 68 while(ite.hasnext ()){ 69 System.out.println(ite.next()); 70 } 71 72 System.out.println("---------------"); 73 74 // 75 Set <Schedule2 > findschedule = new TreeSet <Schedule2 >(); 76 findschedule.add(new Schedule2("2008-08-05")); 77 findschedule.add(new Schedule2("2008-08-10")); 78 findschedule.add(new Schedule2("2008-08-11")); 79 80 // ----schedule AND findschedule ----- 45

2.10 81 Set <Schedule2 > intersect = new TreeSet <Schedule2 >( schedule); 82 intersect. retainall( findschedule); 83 84 System.out.println(" :" + intersect); 85 86 //------ --------- 87 Schedule2 addschedule = new Schedule2("2008-08-08"," "); 88 if(schedule.add( addschedule )){ 89 System.out.println(" "); 90 } else { 91 System.out.println(addSchedule.getDate() + " " + 92 " "); 93 } 94 95 // 96 System.out.println(schedule); 97 } 98 99 } 46

47 3 Map Map Map 3.1 HashMap 1 import java.util.hashmap; 2 import java.util.map; 3 4 5 public class Map_Test { 6 public static void main(string[] args) { 7 // 8 Map <String,String > prefectureinfo = new HashMap <String,String >(); 9 10 prefectureinfo.put(" ", " "); //#1 11 prefectureinfo.put(" ", " "); 12 prefectureinfo.put(" ", " "); 13 prefectureinfo.put(" ", " "); //#3 14 15 System.out.println( prefectureinfo); 16 System.out.println("---------------"); 17 System.out.println(" " + prefectureinfo.get(" ") + " "); //#2 18 } 19 } =, =, = #1 Map #2 #3 Set map

3.2 1 HashMap 3.2 1 1 import java.util.hashmap; 2 import java.util.map; 3 import java.util.set; 4 5 6 public class Map_Test2 { 7 public static void main(string[] args) { 8 // 9 Map <String,String > prefectureinfo = new HashMap <String,String >(); 10 11 prefectureinfo.put(" ", " "); 12 prefectureinfo.put(" ", " "); 13 prefectureinfo.put(" ", " "); 14 prefectureinfo.put(" ", " "); 15 16 // 17 Set <String > keys = prefectureinfo.keyset(); // #1 18 19 // m a p 20 for(string key : keys) //#2 21 System.out.println(key + " : " + prefectureinfo.get(key)); 22 23 } 24 } : : : #1 keyset keyset Set String Set String //#2 get 3.3 2 48

3 Map 1 import java.util.hashmap; 2 import java.util. Iterator; 3 import java.util.map; 4 import java.util.set; 5 import java.util.treeset; 6 7 8 public class Map_Test3 { 9 public static void main(string[] args) { 10 // 11 Map <String,String > memberinfo = new HashMap <String,String >(); 12 13 memberinfo.put("003", " C "); 14 memberinfo.put("005", " E "); 15 memberinfo.put("001", " A "); 16 memberinfo.put("002", " B "); 17 18 // m e m b e r I n f o 19 Set <String > keys = memberinfo.keyset(); //#1 20 21 // 22 Set <String > sortedkeys = new TreeSet <String >( keys); //#2 23 24 // s o r t e d K e y s 25 Iterator <String > ite = sortedkeys.iterator(); //#3 26 27 // 28 while(ite.hasnext ()){ //#4 29 String key = (String)ite.next(); 30 String value = (String) memberinfo.get(key); 31 System.out.println(key + " : " + value); 32 } 33 } 34 } 001 : A 002 : B 003 : C 005 : E foreach iterator #1 Map #2 TreeSet #3 iterator #4 #2 #3 49

3.4 3.4 Tokyo Shinjuku, Hachioji, Minato C++ STL multimap 1 import java.util.hashmap; 2 import java.util.hashset; 3 import java.util. Iterator; 4 import java.util.map; 5 6 7 public class Map_Test4 { 8 public static void main(string[] args) { 9 10 // 11 Map <String,HashSet <String >> city = new HashMap <String,HashSet <String >>(); //#1 12 HashSet <String > tokyo = new HashSet <String >(); //#2 13 HashSet <String > yamanashi = new HashSet <String >(); 14 15 // 16 tokyo.add("shinjuku"); //#3 17 tokyo.add("hachioji"); 18 tokyo.add("minato"); 19 yamanashi.add("kohu"); 20 yamanashi.add(" Minamiarupusu"); 21 yamanashi.add(" Yamanashi"); 22 23 //map(city) 24 city.put("tokyo", tokyo); //#4 25 city.put(" yamanashi", yamanashi); 26 27 System.out.println("-------- Tokyo --------"); 28 // f o r e a c h t o k y o 29 for(string town: city.get("tokyo")) //#5 30 System.out.println(town); 31 32 System.out.println("-------- Yamanashi --------"); 33 // i t e r a t o r y a m a n a s h i 34 Iterator ite = city.get(" yamanashi"). iterator(); //#6 35 while(ite.hasnext()) 36 System.out.println(ite.next()); 37 38 } 39 } 50

3 Map Tokyo Shinjuku Hachioji Minato Yamanashi Kohu Minamiarupusu Yamanashi Map String HashSet (#1) HashSet #2 HashSet #3 #4 tokyo HashSet map #5 foreach tokyo #6 iterator yamanashi 3.5 3.4 1 import java.util.hashmap; 2 import java.util.hashset; 3 import java.util.map; 4 5 public class Prefecture { 6 // 7 private Map <String,HashSet <String >> prefecture = new HashMap <String,HashSet <String >>(); 8 // 9 HashSet <String > city = null; 10 11 public void add(string prefecturename, String cityname){ 12 13 // c i t y 14 if( prefecture. containskey( prefecturename)) //#1 15 city = prefecture.get( prefecturename); //#2 16 else 17 city = new HashSet <String >(); //#3 51

3.5 18 19 city.add(cityname); // //#4 20 prefecture.put(prefecturename, city);// m a p 21 } 22 23 // ArrayList <String > 24 public HashSet <String > getcityname(string prefecturename){ 25 HashSet <String > city = new HashSet <String >(); 26 // Map prefecture 27 city = prefecture.get( prefecturename); //#5 28 return city; 29 } 30 } 31 32 33 34 import java.util.hashset; 35 36 public class Map_Test5 { 37 38 public static void main(string[] args) { 39 Prefecture prefecture = new Prefecture(); 40 HashSet <String > city = new ArrayList <String >(); 41 42 // 43 prefecture.add("tokyo", "Shinjuku"); 44 prefecture.add("tokyo", "Hachioji"); 45 prefecture.add(" Yamanashi", "Kohu"); 46 47 // 48 city = prefecture. getcityname("tokyo"); 49 System.out.println(city); 50 } 51 } main Prefecture add #1 main prefecture.add( Tokyo, Shinjuku ); #3 else main prefecture.add( Tokyo, Hachioji ); #2 #1 prefecture map tokyo true false tokyo (Shinjuku) #4 (Hachioji) map add prefecture getcityname prefecturename Map prefecture 52