บทที่ 3: การตดั สินใจ และการประมวลผลแบบวน
count++; //number of tokens read
sum += number; //calculate sum
break; intro. to Java (FEU.faa)
default:
System.out.println("Token is not a number! " +
token.toString());
break;
}
}
เราตรวจสอบความเปนตวั เลขของ token ไดดวยการเปรยี บเทยี บ token.ttype กบั
StreamTokenizer.TT_NUMBER และถาเปน จริง token ท่ีเปนตัวเลขจะถูกเก็บไวในตัวแปร nval
(และมชี นดิ เปน double) ดังนัน้ ตัวแปร number จงึ ตองประกาศใหเ ปน double และการดึงคามาเก็บ
ในตวั แปร number ทาํ ไดด ว ยการกําหนดคาจากประโยค
number = token.nval;
เนอื่ งจากวา เราสนใจเฉพาะ token ท่เี ปน ตัวเลขเทา นน้ั เราจึงไมส นใจ token ทีเ่ ปนชนิดอ่ืน ดังนั้นเรา
จึงเพยี งแตสง คา ของ token กลับคนื ไปยังหนา จอถา token น้ันเปน ชนดิ อน่ื ทีไ่ มใชตวั เลข
for loop ของเราจะทํางานไปเรอื่ ย ๆ จนกวา user จะกดปุม <enter> ซึง่ การกดปมุ <enter> น้ีจะ
ทาํ ให expression ท่ีมอี ยเู พียงตวั เดียวใน for loop เปนเท็จ การทาํ งานของ for loop จึงสิน้ สดุ ลง
ผอู านจะสังเกตไดวาเราไมส นใจกบั expression ที่ 1 และ expression ที่ 3 ของ for loop เลยทั้งน้กี ็
เพราะวาเราไมตองมกี ารกาํ หนดคา เบ้อื งตน หรอื เพม่ิ คาใด ๆ เลย การยุตกิ ารทาํ งานของ for loop
เกดิ จากการกดปมุ <enter> ของ user เทานัน้
ผลลพั ธของการ run ดวยคาสมมติตา ง ๆ
Enter numbers (space between - enter when done): 20 30 45 789 12 34
Sum of numbers = 930.0
Average of numbers = 155.0
Enter numbers (space between - enter when done): 45 68 95
Sum of numbers = 208.0
Average of numbers = 69.33
Class StreamTokenizer ยังมี field อืน่ ๆ ที่เราสามารถเรียกใชได แตไ มไ ดก ลา วไวในทน่ี เ้ี พราะวา
โปรแกรม AddNumbers.java ของเราสนใจแตเฉพาะการอานตัวเลขเทา นน้ั ผูอานสามารถหาขอ มลู
ไดจาก javadoc ของ Sun เอง
การอา นขอมูลจากโปรแกรมการบวกเลขที่เราเหน็ น้ันมีขน้ั ตอนที่ยุงยาก (ดงั ทไ่ี ดกลา วไวแ ลว ) แตเ รา
นําแสดงใหดูก็เพื่อใหเ ห็นวาทําได แตก ม็ ีวธิ ที ส่ี ้นั กวา นัน่ ก็คือการใช Class Scanner เหมือนกับท่ีเรา
ไดทํามากอ นหนาน้ี โปรแกรม SumOfNumbers.java แสดงถงึ การใช class Scanner ในรูปแบบท่ี
คลายกนั กบั โปรแกรม AddNumbers.java
1: /**
2: Reading numbers from input line
3: */
4:
5: import static java.lang.System.out;
6: import java.util.Scanner;
7:
8: class SumOfNumbers {
9: public static void main(String[] args) {
10: double number, sum = 0;
11: int count = 0;
12:
13: out.print("Enter numbers: ");
14: Scanner input = new Scanner(System.in);
15:
16: //loop through numbers until EOF is found
17: //for windows: <ctrl/z>
18: for(; input.hasNext(); count++) {
19: sum += input.nextDouble();
20: }
21:
97
เรม่ิ ตนการเขียนโปรแกรมดวย Java intro. to Java (FEU.faa)
22: //calculate average and display result
23: double average = sum / count;
24: out.printf("Sum of numbers is %.0f\n", sum);
25: out.printf("Average of numbers is %.2f\n", average);
26: }
27: }
การนําขอ มลู เขาเรมิ่ ตนดว ยการตรวจสอบวา input มีขอมูลอยหู รือไมดว ยการใชค าํ ส่งั
input.hasNext()
ซึง่ ถา hasNext() สง คา ทเี่ ปน จริงกลบั มาเราก็จะรวู ามีขอ มูลอยู และจะทาํ ใหเราสามารถดึงขอมูล
ออกมาไดดว ยคาํ ส่ัง (บรรทดั ท่ี 19)
sum += input.nextDouble()
ทง้ั น้ี user จะตอ งใสข อมูลโดยมีชอ งวางอยรู ะหวา งเหมอื นกับโปรแกรมกอนหนา น้เี ชนเดยี วกนั แต
การบอกใหโ ปรแกรมรูว า การนําขอ มูลเขา ไดสิ้นสดุ ลง เราตอ งกดปมุ <enter> ตามดว ย <ctrl/z>
และกดปมุ <enter> อีกครั้งหนง่ึ ดงั ทแ่ี สดงจากตวั อยา งผลลัพธนี้
Enter numbers: 1 2 3 4 5
^Z
Sum of numbers is 15
Average of numbers is 3.00
ผอู านจะเหน็ วา โปรแกรมของเราสัน้ ลงกวา เกามาก และกไ็ ดผ ลเชน เดยี วกนั ถึงแมวา การยตุ ิการนาํ
ขอมลู เขา จะยงุ ยากกวาก็ตาม
เราสามารถท่จี ะเรยี กใช scanner ในการอานขอ มูลจาก dialog box ไดเ ชน เดยี วกบั ทเ่ี ราใช scanner
อานขอมูลจาก command line วิธกี ารกไ็ มยาก เพยี งแตเ ปลย่ี นการสง ชอ งทางนําขอ มลู เขา ของ
scanner จาก System.in ใหเปน การอานจาก String ทเี่ ก็บขอมลู จาก dialog box ดังนี้
String in = JOptionPane.showInputDialog(null,
"Enter int values (separate by space)",
"Sum of numbers", JOptionPane.QUESTION_MESSAGE);
Scanner input = new Scanner(in);
ซ่ึงเราไดแ สดงการใชด งั กลาวในโปรแกรม SumDialog.java ทเ่ี ห็นนี้
1: /**
2: Reading numbers from dialog box using scanner
3: */
4:
5: import java.util.Scanner;
6: import javax.swing.JOptionPane;
7:
8: class SumInDialog {
9: public static void main(String[] args) {
10: double number, sum = 0;
11: int count = 0;
12:
13: //getting numbers from a dialog box
14: String in = JOptionPane.showInputDialog(null,
15: "Enter int values (separate by space)",
16: "Sum of numbers", JOptionPane.QUESTION_MESSAGE);
17:
18: Scanner input = new Scanner(in);
19:
20: //loop through numbers and add them up
21: for(; input.hasNext(); count++) {
22: sum += input.nextDouble();
23: }
24:
25: //calculate average
26: double average = sum / count;
27:
98
บทที่ 3: การตัดสนิ ใจ และการประมวลผลแบบวน intro. to Java (FEU.faa)
28: //display result via dialog box
29: JOptionPane.showMessageDialog(null, "The sum is " +
30: String.format("%.0f\n", sum) +
31: "Average is " + String.format("%.2f\n", average),
32: "Sum of numbers", JOptionPane.INFORMATION_MESSAGE);
33: }
34: }
เราเก็บขอมูลที่ user ใสใน dialog box ไวในตวั แปร in ซึ่งเมอ่ื เราไดแลวเรากส็ งตัวแปร in นใ้ี หก บั
scanner (ในบรรทัดท่ี 14 และ 18 ตามลาํ ดบั ) ผลลพั ธของการทดลอง run โปรแกรมก็เปน อยางที่
เราคาดไวคือ
ในการใช for/loop นนั้ เราสามารถทีจ่ ะใช , (comma) เปน ตัวแบงการประมวลในแตล ะ expression
ได ดังตัวอยางโปรแกรมการหาผลรวมและคา เฉลยี่ นของเลขจากหนง่ึ ถึงรอ ย
1: /**
2: Adding numbers using for/loop
3: with comma
4: */
5:
6: import static java.lang.System.out;
7:
8: class SumUsingFor {
9: public static void main(String[] args) {
10: int i, sum;
11:
12: for(i = 1, sum = 0; i <= 100; sum += i, i++) ;
13:
14: out.printf("Sum = %d%n", sum);
15: out.printf("Average = %.2f", (double)sum / (i-1));
16: }
17: }
เรากําหนดให expression1 ของเรามขี อ ความอยสู องขอ ความคือ i = 0 และ sum = 0 โดยเราใช ,
เปนตัวแบงขอ ความทง้ั สอง เชนเดียวกันกับ expression3 เรากําหนดใหมีขอ ความ sum += i และ
i++ อยู และในตวั for/loop นั้นเราไมม ีการกาํ หนดประโยคใด ๆ เลย ทงั้ น้ีกเ็ พราะวาเราไดก ําหนดให
การหาผลรวมน้นั อยูใน expression3 แลว แตเ ราจะตอ งใส ; (หรือเราอาจใส {})เพือ่ ให Java รวู าเรา
ไดจ บ for loop ของเราแลว
for(i = 1, sum = 0; i <= 10; sum += i, i++) ;
หรือ
99
เร่ิมตนการเขยี นโปรแกรมดวย Java intro. to Java (FEU.faa)
for(i = 1, sum = 0; i <= 10; sum += i, i++) { }
การทาํ งานของ for/loop ท่วี า นี้กเ็ หมือนกันกบั การเขยี น for/loop แบบเดมิ ตางกันตรงทีเ่ ราไดย า ย
ตําแหนงของประโยคสองประโยค เทา น้นั เอง
sum = 0;
for(i = 1; i <= 10; i++)
sum += i;
ตําแหนง ของขอ ความการหาผลรวมกม็ คี วามสาํ คัญ เราตอ งกําหนดใหป ระโยค sum += i นนั้ อยกู อ น
ประโยค i++ ทง้ั น้ีก็เพราะวา Java จะประมวลผลประโยคท่ีอยทู างซายของเคร่อื งหมาย , กอน แลว
จึงจะประมวลผลประโยคทอี่ ยถู ัดไปทางขวา ซงึ่ ถา เรากําหนดให i++ อยกู อ น sum += i การ
ประมวลผลของเราก็จะผดิ พลาด คา ของผลรวมทไี่ ดคลาดเคลือ่ น
สวนท่สี ําคญั อีกสวนหนึ่งกค็ อื คาของ i สําหรบั การคาํ นวณหาคา เฉล่ีย เราตอ งหกั คาของ i ออกหนึง่
คา กอ นนาํ ไปหาร sum กเ็ นอ่ื งจากวาในขณะท่ี for/loop ยุตกิ ารทํางานนน้ั คา ของ i มีคาเปน 101
การหาผลรวมของ for/loop ทีก่ ลาวมาแลว นนั้ เราสามารถท่ีจะเขียนไดอีกหลายรูปแบบ เชน
i=;
sum = 0;
for( ; i <= 100; i++) ;
sum += i;
หรือ
i = 1;
sum = 0;
for( ; i <= 100; ) {
sum += i;
i++;
}
หรอื
sum = 0;
for( i = 1; i <= 100; ) {
sum += i;
i++;
}
ผูอา นควรคํานงึ ถงึ การเขียน code ท่ีดแู ลวอานไดงาย มีโครงสรางทม่ี องดเู ปนสากล ดงั นนั้ ถงึ แมวา
Java จะยอมใหเ ราเขียน code ไดอ ยางอสิ ระและหลายรูปแบบ เรากไ็ มควรเขยี น code ทย่ี ากตอการ
ทําความเขาใจ ยกเวนวา การเขียน code นัน้ ๆ มคี วามจําเปนท่ตี อ งใชรปู แบบนนั้ ๆ ในการเขียน
(จําเปนจริงหรือ?)
3.4.1.1 การใช for-in/loop (for-each)
Java 1.5 ไดก าํ หนดใหม กี ารใช for/loop อกี รูปแบบหนึ่งทีเ่ รียกวา for-in/loop ซ่งึ เปน for/loop ท่ี
ใชในการดึงเอาขอ มลู ออกมาจากทีเ่ กบ็ เชน ขอมูลท่ีเก็บอยใู น array ซง่ึ เราจะพูดถึงในบทที่ 4 แต
เน่ืองจากวาเราตองการใหผูอา นไดร ูจกั ถึง for-in/loop นีอ้ ยางครา ว ๆ กอน เราจงึ ไดน าํ เอาตวั อยาง
ของ for-in/loop มาแสดงใหด ใู นที่น้ี
โปรแกรมตวั อยางที่เราแสดงใหด ูเปน โปรแกรมงาย ๆ ทร่ี บั ขอมูลมาจาก command-line โดย user
จะเปนผูใสข อ มูลถัดจากช่ือของโปรแกรม เชน ถา โปรแกรมของเราชือ่ ForInLoop เราก็จะเรยี กใช
โปรแกรมดวยคาํ สง่ั ทเี่ ห็นนี้ พรอมท้ังใสข อมลู ของโปรแกรมตามหลงั คอื I love for/loop
d:\source>java ForInLoop I love for/loop
โปรแกรมตัวอยางของเรามีหนา ตาดงั น้ี
1: /**
100
บทที่ 3: การตดั สนิ ใจ และการประมวลผลแบบวน intro. to Java (FEU.faa)
2: Using for-in/loop
3: */
4:
5: import javax.swing.JOptionPane;
6:
7: class ForInLoop {
8: public static void main(String[] args) {
9: //get each word from command-line
10: //and display them
11: for(String str : args) {
12: JOptionPane.showMessageDialog(null,
13: str, "Words in sentence",
14: JOptionPane.INFORMATION_MESSAGE);
15: }
16: }
17: }
ผอู า นจะเห็นวา ในบรรทดั ท่ี 11 เราเรยี กใช for-in/loop ในการดงึ เอาขอ มูลออกจากตวั แปรท่ีชอ่ื args
ซึง่ เปน command-line argument ของตวั โปรแกรมเองโดยทชี่ นดิ ของขอ มลู จะตองเปนชนดิ
เดียวกนั กบั ท่เี ขามา และทไี่ ดก ําหนดไวใ น for-in/loop ดงั ทเี่ ราไดทาํ ไว รูปแบบของ for-in/loop มี
ดังนี้
for(declaration : expression)
statement
จากรูปแบบของ for-in/loop และที่เราไดเขียนไวในบรรทดั ที่ 11
declaration คอื String str
expression คอื args (args ของเราเปน array ทีเ่ กบ็ String)
พดู ภาษางาย ๆ กค็ ือ for-in/loop ท่ีเราใชใ นบรรทดั ท่ี 12 เปน loop ทบ่ี อกใหเ กิดการทํางานทีว่ า
"สาํ หรับ String str ทุกตัวทอี่ ยใู น args" เราจะทํากระบวนการตอ ไปนี้ …
สิ่งที่เราทําไมไดใ น for-in/loop กค็ ือการทาํ แบบทว่ั ไปกับ loop ตา ง ๆ ที่เราเคยทาํ เชน ถาเรา
ตอ งการดึงเอาขอมูลจากตําแหนง ใด ๆ ใน loop หรือแสดงขอ มลู ณ ตําแหนง น้ันๆ เปน ตน ขอ ควร
ระวังในการใช for-in/loop ก็คือ
expression จะตอ งเปน array หรือ object ท่มี าจาก java.lang.Iterable
declaration โดยท่ัวไปจะเปน ชนิด และตัวแปร (การประกาศตวั แปรน่ันเอง)
เราจะกลบั มาดูตวั อยางการใช for-in/loop อกี ในบทอืน่ ๆ ตอไป
3.4.2 การใช while/loop
การใช while/loop ก็คลาย ๆ กับการใช for/loop ตา งกนั เฉพาะโครงสรา งบางโครงสรา งเทานั้นเอง
(ตาํ แหนง ของ expression) เรามาดโู ครงสรางของ while/loop กัน
while(expression)
statement
while/loop จะตรวจสอบวา คาของ expression นน้ั เปน จรงิ หรือเท็จ ถา เปน จริงก็จะประมวลผล
ประโยคตา ง ๆ ทีอ่ ยภู ายใน while/loop และจะประมวลผลประโยคอน่ื ๆ ที่ตามมา (ภายนอก while/
loop) หลงั จากท่ีหลุดออกจาก while/loop แลว ภาพท่ี 3-5 แสดงขัน้ ตอนการทํางานของ while/
loop
101
เริม่ ตน การเขยี นโปรแกรมดว ย Java
Expression no intro. to Java (FEU.faa)
(จรงิ ?)
yes
statement
Next statement
ภาพที่ 3-5 ขนั้ ตอนการทาํ งานของ while/loop
เรามาลองใช while/loop แทน for/loop ทเ่ี ราไดใ ชในโปรแกรมตวั อยา งบางตวั กอ นหนา น้ี
1: /**
2: Adding numbers using while/loop
3: */
4: import static java.lang.System.out;
5:
6: class SumUsingWhile {
7: public static void main(String[] args) {
8: int i, sum;
9:
10: //initialize i and sum
11: i = 0;
12: sum = 0;
13:
14: //repeat process as long as i
15: //less than or equals to 100
16: while(i <= 100) {
17: sum += i; //add i to sum
18: i++; //increment i
19: }
20:
21: //print sum and average
22: out.printf("Sum = %d%n", sum);
23: out.printf("Average = %.2f", (double)sum / (i-1));
24: }
25: }
สิง่ แรกทเี่ ราตองทํากค็ อื การกาํ หนดคา เบอ้ื งตน ใหกับตวั แปร i และ sum หลงั จากน้ันเรากท็ ําการ
ตรวจสอบดูวาประโยค i <= 10 เปนจรงิ หรอื ไม ซึง่ ถา เปน จรงิ เราก็ให while/loop ของเราทําการบวก
คา ของ i เขากับตัวแปร sum พรอมท้ังเพิม่ คาใหก ับ i เม่อื เสร็จแลว ถา เราลองเปรยี บเทียบการใช
while/loop กบั for/loop เราจะเหน็ วา ประโยค
i = 0;
sum = 0;
คอื expression ท่หี นึง่ ของ for/loop และประโยค i <= 10 ก็คอื expression ทส่ี องใน for/loop
สว นประโยค i++ ก็คอื expression ทส่ี ามใน for/ loop นนั่ เอง (ถึงแมวาเราไดก ําหนดคาของ i ให
เรมิ่ ตนท่ี 0 กไ็ มทาํ ใหก ารประมวลผลเปล่ยี นไป เพียงแตว า loop ของเราทํางานมากข้ึนอกี หนงึ่ คร้งั
เทานั้น)
ทนี ีเ้ รามาลองใช while/loop แทน for/loop ในโปรแกรม AddNumbers.java พรอ มทง้ั เปลยี่ นการ
อานขอมลู และการแสดงผล
102
บทท่ี 3: การตดั สนิ ใจ และการประมวลผลแบบวน
1: /** intro. to Java (FEU.faa)
2: Calculating sum and average of numbers
3: using split() to get each token from input string
4: */
5:
6: import javax.swing.JOptionPane;
7: import static java.lang.System.out;
8:
9: class AddNumbers2 {
10: public static void main(String[] args) {
11: double number, sum = 0; //a number and sum
12: int count = 0; //total numbers read
13: String input; //input string
14:
15: //get input from user
16: input = JOptionPane.showInputDialog("Enter numbers: ");
17: String[] tokens = input.split("\\s");
18: while(count < tokens.length) {
19: try {
20: number = Integer.parseInt(tokens[count]);
21: sum += number;
22: count++;
23: }
24: //display error and exit from program
25: catch(Exception e) {
26: JOptionPane.showMessageDialog(null,
27: "Invalid input: " + tokens[count] +
28: "\nBefore invalid input\n" +
29: "Sum is " +
30: String.format("%.0f", sum) +
31: "\nAverage is " +
32: String.format("%.2f", (sum/count)),
33: "Error",
34: JOptionPane.ERROR_MESSAGE);
35: System.exit(1);
36: }
37: }
38: //calculate average and display result
39: double average = sum / count;
40: JOptionPane.showMessageDialog(null,
41: "Sum of numbers: " + input + " is " +
42: String.format("%.2f%n", sum) +
43: "Average of numbers: " +
44: String.format("%.2f", average),
45: "Sum and Average",
46: JOptionPane.INFORMATION_MESSAGE);
47: }
48: }
ในโปรแกรม AddNumbers2.java เราจะใช method split() ของ class String เปน ตวั ดึงเอาขอมลู
ออกจาก String ที่ user ใสเ ขามาแทนการใช StreamTokenizer ดงั ทีเ่ ห็นในบรรทดั ท่ี 173 ซงึ่ ขอมลู
แตล ะตวั ทถี่ ูกดงึ ออกมานน้ั เราจะนาํ ไปเกบ็ ไวใน array ชือ่ tokens การดึงขอ มลู แตล ะตวั ออกมานนั้
เราตอ งกาํ หนดให split() รูวาเราใชอะไรเปน ตวั กาํ หนดการแบงขอ มลู ท่มี ีอยูใน input ในทีน่ ้ีเราใช
ชองวาง (space) เปนตวั แบงโดยเราตองบอกให split() รูดวยการใช \s แตเน่ืองจากวา \s เปน
escape sequence เราจึงตองกาํ หนดใหม ี '\' อีกหน่งึ ตัวนาํ หนา '\s'
หลังจากน้นั เรากเ็ ขา หาขอมลู แตละตวั ดว ย while/loop โดยเรียกใช length เปนตัวกําหนดจาํ นวนคร้ัง
ของการวน loop และเราจะคาํ นวณหาผลรวมของขอ มลู ทเ่ี ปน Integer เทา นนั้ ถาหากวามขี อมลู ตวั
ใดก็ตามท่ไี มใ ช Integer โปรแกรมกจ็ ะยุตกิ ารทาํ งานพรอมทงั้ สง ผลรวมและคา เฉล่ยี ของขอ มูลท่ี
ถกู ตองมีอยูกอนหนา ออกทางหนา จอ สว นการแสดงผลของขอ มูลทีถ่ ูกตองกเ็ ปน ไปตามปกติ ดงั
ตวั อยา งน้ี
3 เราใชโ ครงสรา งท่ีเรยี กวา array ในการเกบ็ ตัวเลขแตละตัว ซ่งึ เราจะไดอธิบายอยางละเอยี ดตอ ไปในบทที่ 4
103
เรมิ่ ตนการเขียนโปรแกรมดวย Java
จากผลลพั ธจะเหน็ วาโปรแกรมจะยตุ ิการประมวลผลถา เจอขอมลู ท่ีไมใ ช Integer ตง้ั แตต ัวแรกท่ีเจอ intro. to Java (FEU.faa)
ซงึ่ ตา งจากการใช StreamTokenizer กอนหนา นี้ที่ยังสามารถประมวลผลเฉพาะขอ มลู ท่ีถกู ตอ ง
ทงั้ หมดท่ีมอี ยู
ท้งั for/loop และ while/loop เปน โครงสรา งของการทํางานแบบวนที่ตองมกี ารตรวจสอบกอนวา
ประโยคในการควบคุมของ loop ทั้งสองเปน จรงิ หรือเท็จ ซ่ึงหมายถงึ วาการทาํ งานของ loop ท้ังสอง
อาจไมเกดิ ขน้ึ เลยถา การประมวลผลประโยคควบคมุ เปน เทจ็ แตถาเราตอ งการท่ีจะประมวลผลกอน
อยางนอยหน่งึ ครัง้ เราจะทาํ อยา งไร
3.4.3 การใช do-while/loop
Java มีโครงสรา งการใช loop อกี ตวั หน่ึงท่ียอมใหม ีการทาํ งานอยางนอ ยกอ นหนึง่ คร้งั แลว จึงจะทาํ
การประมวลผลประโยคควบคุม น่นั ก็คือ do-while/loop ซง่ึ มโี ครงสรางดังน้ี
do {
statement
}
while(expression);
statement
yes Expression
(จริง ?)
no
statement
ภาพที่ 3-6 ขนั้ ตอนการทํางานของ do-while/loop
104
บทท่ี 3: การตัดสินใจ และการประมวลผลแบบวน intro. to Java (FEU.faa)
ถาเราตองการที่จะทํางานอยางนอ ยหนงึ่ ครง้ั กอ นที่จะมกี ารตรวจสอบเพื่อยตุ ิการทํางาน หรือทํางาน
ตอ ไป do-while/loop จะเปนโครงสรา งที่เหมาะสมทีส่ ุด โปรแกรมตวั อยางตอไปนี้แสดงถงึ การใช
do/while loop ในการตรวจสอบนน้ั ๆ
1: /**
2: do/while loop demonstration
3: until user enter a letter other than 'y'
4: */
5:
6: import static java.lang.System.out;
7: import java.util.Scanner;
8:
9: class DoWhile {
10: public static void main(String[] args) {
11: int score;
12: char grade, ch;
13: Scanner input = new Scanner(System.in);
14:
15: do {
16: //get input string
17: out.print("Enter your score: ");
18: score = input.nextInt();
19:
20: //determine grade by given score
21: if(score > 90)
22: grade = 'A';
23: else if(score > 80)
24: grade = 'B';
25: else if(score > 70)
26: grade = 'C';
27: else if(score > 60)
28: grade = 'D';
29: else
30: grade = 'F';
31:
32: out.println("Your grade is " + grade);
33: out.print("\nDo you want to continue? <y/n> : ");
34: String response = input.next();
35: ch = (char)response.charAt(0);
36: }
37: while(ch == 'y' || ch == 'Y');
38: }
39: }
เราเพียงแตด ดั แปลงโปรแกรมการหาเกรดของเรา ดวยการเพิม่ do/while และประโยค
out.print("\nDo you want to continue? <y/n> : ");
String response = input.next();
ch = (char)response.charAt(0);
ทใี่ ชสาํ หรับการถาม user วา ตองการทาํ งานตอ หรอื ไม โดยเราทําการดึงเอาตัวอักษรตวั แรกทอ่ี ยใู น
บรรทัดนนั้ ออกมา ทําการเปรยี บเทียบกบั ตัวอักษร y ใน expression ของ do-while/loop ซง่ึ ถา การ
เปรียบเทียบนนั้ เปน จริงเราก็จะทํางานไปเร่ือย ๆ วธิ ีการเดียวทีจ่ ะทาํ ให do-while/loop ยตุ กิ ารทาํ งาน
ก็คอื การใสตวั อักษร n (หรอื อนื่ ๆ ทไี่ มใ ช y)
เราใช method chatAt() ดว ยคา parameter ที่เปน ศูนยเพ่อื ดึงเอาอกั ษรตัวแรกสดุ ใน buffer มาเก็บ
ไวในตัวแปร ch สําหรับการเปรียบเทยี บประโยคควบคุมของ do-while/loop
ผลลพั ธก าร run โปรแกรมดว ยคา ตา ง ๆ
Enter your score: 89
Your grade is B
Do you want to continue? <y/n> : y
Enter your score: 12
Your grade is F
105
เรมิ่ ตนการเขยี นโปรแกรมดวย Java
Do you want to continue? <y/n> : y intro. to Java (FEU.faa)
Enter your score: 75
Your grade is C
Do you want to continue? <y/n> : n
เรามาลองดูโปรแกรมตัวอยางอีกตวั หนึง่ ที่ใช do-while/loop ในการหาผลรวมของเลขระหวาง 1 –
100
1: /**
2: Adding numbers using do-while/loop
3: */
4:
5: import static java.lang.System.out;
6:
7: class SumUsingDoWhile {
8: public static void main(String[] args) {
9: int i = 0; //loop counter
10: int sum = 0; //sum of i
11:
12: //repeat process until i is
13: //no longer less than or equal to 100
14: do {
15: sum += i; //add i to sum
16: i++; //increment i
17: }
18: while(i <= 100);
19:
20: out.printf("Sum = %d%n", sum);
21: out.printf("Average = %.2f", (double)sum / (i-1));
22: }
23: }
ซงึ่ เมื่อ run ดูก็ไดผลลพั ธด ังน้ี
Sum = 5050
Average = 50.5
เราไมไ ดเ ปลย่ี นแปลงอะไรมากมายใน loop ของเราเพียงแตเ ปลยี่ นมาใช do-while/loop เทาน้ันเอง
การใช do-while/loop รับรองวา จะเกดิ การทํางานอยา งนอ ยหน่ึงครง้ั เสมอดงั ทเ่ี ห็นจากตวั อยางทัง้
สอง เพราะฉะน้ันถาผอู า นไมต อ งการตรวจสอบเง่อื นไขกอ นการประมวลผล do-while/loop กเ็ ปน
ตัวเลอื กที่คอ นคา งเหมาะสมท่สี ดุ
3.5 การใช break และ continue
หลาย ๆ คร้ังทเี่ ราตองการยุติการทาํ งานของ loop โดยท่ี loop ยังไมส ิ้นสดุ การทํางานของมันเอง
เชน กาํ หนดให loop หยุดการทํางานเมอื่ เงื่อนไขทไี่ ดก าํ หนดไวเ ปน จริง ดงั แสดงใหเหน็ ในโปรแกรม
ตวั อยางน้ี
1: /**
2: Using break to get out of the loop
3: */
4:
5: import static java.lang.System.out;
6:
7: class SumWithBreak {
8: public static void main(String[] args) {
9: int i = 1, sum = 0;
10:
11: //repeat the task until i > 200
12: do {
13: sum += i;
14: i++;
15:
16: //break out of loop when i > 100
17: if(i > 100)
18: break;
106
บทท่ี 3: การตัดสินใจ และการประมวลผลแบบวน intro. to Java (FEU.faa)
19: }
20: while(i <= 200);
21:
22: out.println("Sum = " + sum);
23: out.println("Average = " + (double)sum / (i-1));
24: }
25: }
เราใชโปรแกรม SumWithBreak.java เปน พน้ื ฐานของการเปลยี่ นแปลง โดยเรากําหนดใหม ีการ
ตรวจสอบคา ของ i วา มากกวา 100 หรือไมซึง่ ถาเปน จรงิ เรากจ็ ะ break ออกจาก loop ทันที
if(i >= 100)
break;
เมอ่ื เราลอง run ดเู ราไดผลลัพธด ังน้ี
Sum = 5050
Average = 50.5
ลองมาดโู ปรแกรมท่ีใช break ในการหยุดการทาํ งานของ loop ทใี่ ชห าคาของตวั เลขทรี่ ะหวางหน่ึง
ถึงสิบทเี่ ปนเลขคู
1: /**
2: Using break in a loop
3: */
4:
5: class Break {
6: public static void main(String[] args) {
7:
8: for(int number = 1; ; number++)
9: if(number % 2 == 0) {
10: System.out.println("Number is " + number);
11:
12: //break out of loop when number >= 10
13: if(number >= 10)
14: break;
15: }
16: }
17: }
เราจะตรวจสอบวา ตัวเลขเปนเลขคกู อนแลว จึงทาํ การแสดงตัวเลขนนั้ ๆ ไปยังหนา จอเมื่อคาของ
number เปนสบิ เราก็จะยุติการทํางานของ loop ดงั ท่แี สดงใหเ ห็นจากผลลพั ธท่ีไดน้ี
Number is 2
Number is 4
Number is 6
Number is 8
Number is 10
การใช break ใน loop เปน การกาํ หนดให loop หยดุ การทํางานทันที ท่เี จอ break แตถ า เราตอ งการ
ทีจ่ ะกระโดดขามคําสัง่ หรอื ชุดคาํ ส่งั ทมี่ ีอยูเมอ่ื เงือ่ นไขบางอยา งเปนจรงิ เราตองใช continue แทน
ดงั โปรแกรมตวั อยางนี้
1: /**
2: Using continue in a loop
3: */
4:
5: import static java.lang.System.out;
6:
7: class Continue {
8: public static void main(String[] args) {
9:
10: for(int number = 1; number <= 10; number++) {
11:
12: //skip if number is 5
13: if(number == 5) {
14: out.printf("%d is skipped!%n", number);
15: continue;
107
เรม่ิ ตน การเขียนโปรแกรมดวย Java intro. to Java (FEU.faa)
16: }
17:
18: out.println("Number is " + number);
19: }
20: }
21: }
การประมวลของประโยคในบรรทัดที่ 18 จะเกิดขนึ้ ทุกคา ของ number ยกเวนเมอ่ื คา ของ number มี
คาเทา กบั หา ดงั แสดงใหเหน็ จากผลลพั ธนี้
Number is 1
Number is 2
Number is 3
Number is 4
5 is skipped!
Number is 6
Number is 7
Number is 8
Number is 9
Number is 10
การใช continue นนั้ โดยท่วั ไปมักจะไมค อยมที ใ่ี ชเทาไรนัก เพราะการเขยี นโปรแกรมโดยท่วั ไปมกั จะ
ทาํ การประมวลผลกลุมของคาํ สั่งทัง้ หมดจนเสร็จ หรอื ไมกย็ ุติการทาํ งานเม่อื เงื่อนไขบางอยางเปน
จรงิ การกระโดดขา มการประมวลผลชดุ คําส่งั ไมค อ ยจะมีใหเห็นมากมายนัก ดังน้นั กค็ งตองขึ้นอยกู บั
การออกแบบโปรแกรมของผูอานเองวา เหมาะสมอยางไรตอการใชช ดุ คําส่ังตา ง ๆ
3.6 การใช loop ใน loop (Nested Loop)
เราสามารถท่จี ะนาํ เอา loop ตาง ๆ ท่ีเราไดพ ูดถึงมาใสไ วใน loop ได เชน เดยี วกับท่ีเราทาํ กับ if –
else เนื่องจากวา ตัว loop เองกเ็ ปนประโยคอยางหนึ่ง ดังนั้นการนําประโยคมาวางซอนกนั ในการ
เขยี นโปรแกรมกย็ อมทีจ่ ะทําได เรามาลองดตู ัวอยา งการใช nested loop กนั
1: /**
2: Using loop inside another loop
3: */
4:
5: class NestedLoop {
6: public static void main(String[] args) {
7:
8: for(int row = 1; row <= 10; row++) {
9: for(int column = 1; column <= 10; column++) {
10:
11: //break out of inner loop when
12: //column is greater than row
13: if(column > row)
14: continue;
15: System.out.print("*");
16: }
17: System.out.println();
18: }
19: }
20: }
โปรแกรม NestedLoop.java ของเราใช for/loop สองตวั ในการแสดงจํานวนของ '*' ในแตละแถว
ดงั ทแี่ สดงใหเ หน็ จากผลลพั ธน้ี
*
**
***
****
*****
******
*******
********
*********
**********
108
บทท่ี 3: การตดั สนิ ใจ และการประมวลผลแบบวน intro. to Java (FEU.faa)
ใน for/loop ตวั แรกของเรา เราใชต ัวแปร row เปน loop index ซงึ่ จะประมวลผลเปนจํานวนเทากับ
สิบคร้งั และในแตละครง้ั ท่ี row มีการประมวลผล for/loop ตัวทสี่ องทม่ี ี column เปน loop index จะ
ประมวลผลเปนจํานวนเทากบั สิบครง้ั เพราะฉะน้นั การประมวลผลของ for/loop ทัง้ สองตัวจึงมีคา เปน
จาํ นวนเทา กับหน่ึงรอยคร้งั
ทกุ ๆ การประมวลผลของ for/loop ตวั ทสี่ องเราจะตรวจสอบวาคา ของ column มากกวาคา ของ row
หรอื ไม ซงึ่ ถามากกวา เราจะหยุดการแสดงคา '*' ไปยงั หนาจอทันทีดวยการเรยี กใช continue ที่เรา
ไดพดู ถึงกอนหนาน้ี
ในขณะที่ row และ column มคี าเทากับหน่ึงน้ันเราก็สง '*' ไปยงั หนา จอ หลังจากนัน้ column กม็ ีคา
เปนสอง ซง่ึ มีคา มากกวา row การกระโดดขา มจงึ เกิดขึน้ ซ่ึงจะเปน ไปจนกระทง่ั column มคี า เทากับ
สบิ เอ็ดการประมวลผลของ for/loop ดานในจึงยตุ ิลง หลังจากนั้น row กม็ ีคา เปนสอง เหตกุ ารณเ ดมิ
กเ็ กิดข้นึ อกี แตต อนนกี้ ารแสดงผล '*' จะมีเพ่ิมขึ้นจนกวา คาของ column จะมากกวา row เปนเชน นี้
ไปเรอ่ื ย ๆ จนกระทง่ั คา ของ row มคี าเปนสบิ เอ็ดการประมวลผลของ for/loop ดา นนอกจงึ ยตุ ลิ ง
โดยความเปนจรงิ แลวเราสามารถทจี่ ะใช break แทนการใช continue ได ซึ่งกจ็ ะไดผลลพั ธ
เหมอื นกนั ทั้งนี้เพราะการใช break จะทาํ ใหเ ราหลดุ ออกจาก for/loop ดานในทันที ซ่งึ เปน การ
ประมวลผลทีด่ กี วา การใช continue เนอื่ งจากวา เราประมวลผล for/loop ดา นในดว ยจํานวนครัง้ ท่ี
เทากบั คา ของ row ทเ่ี ปน อยขู ณะนัน้ (ผอู านควรตรวจสอบดวู าการประมวลผลของ for/loop ดานในมี
จาํ นวนเทา กับก่ีครงั้ ในทุก ๆ การประมวลผลของ for/loop ดา นนอก - ทกุ คาของ row)
ลองมาดูโปรแกรมตัวอยางอีกโปรแกรมหน่ึงที่ใช Nested – loop ในการแสดงผลของตัวเลขทเี่ รยี ง
กันเปนรปู สามเหลยี่ ม
1: /**
2: Triangle of numbers
3: */
4:
5: import static java.lang.System.out;
6:
7: class NumberTri {
8: public static void main(String[] args) {
9: int row, col;
10: int num;
11:
12: for(row = 0; row <= 7; row++) {
13: //print leading blanks
14: for(col = 1; col <= 7 - row; col++)
15: out.print(" ");
16: //print left half
17: for(col = 0; col <= row; col++) {
18: num = (int)Math.pow(2, col);
19: //print 4 blanks for a single digit number
20: //print 3 blanks for two-digit number
21: //print 2 blanks for three-digit number
22: if(num < 10)
23: out.print(" " + num);
24: else if(num < 100)
25: out.print(" " + num);
26: else
27: out.print(" " + num);
28: }
29: //print same format as before
30: for(col = row - 1; col >= 0; col--) {
31: num = (int)Math.pow(2, col);
32: if(num < 10)
33: out.print(" " + num);
34: else if(num < 100)
35: out.print(" " + num);
36: else
37: out.print(" " + num);
38: }
39: out.println();
40: }
41: }
42: }
109
เรมิ่ ตน การเขยี นโปรแกรมดว ย Java intro. to Java (FEU.faa)
ผลลัพธท ีไ่ ดจากการ run โปรแกรม NumberTri.java คือ
1
12 1
124 2 1
1248 4 2 1
1 2 4 8 16 8 4 2 1
1 2 4 8 16 32 16 8 4 2 1
1 2 4 8 16 32 64 32 16 8 4 2 1
1 2 4 8 16 32 64 128 64 32 16 8 4 2 1
เราไดทาํ การตรวจสอบถงึ คา ของตวั เลขทจี่ ะแสดงไปยงั หนาจอวา เปน ตัวเลขก่ี digit โดยเราจะ
กําหนดใหมีการเวน ชอ งวา งไวดานหนาตวั เลขตามคา ของ digit น้นั ๆ เชน ตัวเลขหนงึ่ digit เราจะ
แสดงชอ งวาง 3 ชอง ตวั เลข 2 digit เราจะแสดงชองวา ง 2 ชอ งและตวั เลขสาม digit เราจะแสดง 1
ชอ ง เพือ่ การเรียงลาํ ดบั ตัวเลขทดี่ แู ลวสวยงาม
3.7 การใช Label continue และ Label break ใน for loop
Java ยอมใหมกี ารใช label ในการหยุดและเรมิ่ การประมวลผลใหม ซง่ึ โปรแกรมเมอรหลาย ๆ ทาน
ไมค อยจะเหน็ ดวยกบั การใชการประมวลผลในลักษณะนเี้ ทา ใดนกั เรามาดูตวั อยา งกนั
1: /**
2: Using a label/continue
3: */
4:
5:
6: class LabeledContinue {
7: public static void main(String[] args) {
8:
9: label: for(int row = 1; row <= 10; row++) {
10: System.out.println();
11:
12: for(int col = 1; col <= 10; col++) {
13:
14: //go to label when column
15: //is greater than row
16: if(col > row)
17: continue label;
18:
19: System.out.print("*");
20: }
21: }
22: }
23: }
เราไดด ัดแปลงโปรแกรม Continue.java ของเราสําหรับการแสดงการใช labeled continue ใน
โปรแกรม LabeledContinue.java เรากาํ หนดใหมี identifier ท่ีมชี อ่ื วา label อยกู อนหนา for loop
ดา นนอกของเรา ซง่ึ ตองมเี คร่ืองหมาย ':' ตามหลงั เสมอ และในการใช continue ใน for loop ดาน
ในนนั้ เราจะตองมี identifier ทเ่ี ราใชต ามหลงั continue เสมอ
การประมวลดว ย labeled continue ก็ไมย ากนกั ที่จะทําความเขา ใจ เมื่อคา ของ col มากกวา คา ของ
row การทํางานใน for/loop ดา นในก็ส้นิ สดุ ลงและไปเรม่ิ ตนใหมท ่ี for/loop ดา นนอก เพราะนนั่ เปน
ทท่ี ีม่ ี label อยู การทํางานแบบนีก้ เ็ หมอื นกบั การกระโดดไปยงั ตาํ แหนง ท่ีเราตองการจะไปน่ันเอง
ทั้งน้ีก็ตอ งขน้ึ อยูกบั เงื่อนไขท่เี ราไดตั้งไว (ผลลพั ธเ หมือนเดมิ คอื )
*
**
***
****
*****
******
*******
********
*********
110
บทท่ี 3: การตัดสนิ ใจ และการประมวลผลแบบวน intro. to Java (FEU.faa)
ถา เราเปลีย่ น continue ใหเปน break เราจะไดผ ลลพั ธอ ะไร เรามาลองดโู ปรแกรมที่ใช labeled
break กันดู
1: /**
2: Using label/break
3: */
4:
5: import java.io.*;
6:
7: class LabeledBreak1 {
8: public static void main(String[] args) {
9:
10: label: for(int row = 1; row <= 10; row++) {
11: System.out.println("Before inner loop");
12:
13: for(int column = 1; column <= 10; column++) {
14: //break at label when column
15: //is greater than row
16: if(column > row)
17: break label;
18:
19: System.out.print("*");
20: }
21:
22: System.out.println("After inner loop");
23: }
24: System.out.println("\nAfter outter loop");
25: }
26: }
เราไดเพิม่ ประโยคทง้ั กอนและหลงั for/loop ดา นในของเราเพอื่ จะไดด ูวา การประมวลผลเกิดขน้ึ ที่
ใดบา ง ผลลัพธทเ่ี ราไดค อื
Before inner loop
*
After label
ขอความทีอ่ ยใู นบรรทัดที่ 24: System.out.println("After inner loop"); จะไมไดรับการประมวลผล
ท้งั น้กี เ็ พราะวาคําสั่งของ break กาํ หนดใหการทํางานยุติลงที่ label
เราสามารถท่จี ะมี label block ก่ี block ก็ไดในโปรแกรมของเรา การใช labeled break ถาใชไ ด
อยางเหมาะสมแลวจะทําใหก ารเขยี น code เปนไปไดอ ยางสะดวกยง่ิ ขน้ึ ท้ังนก้ี เ็ พราะวาเราสามารถท่ี
จะกระโดดไปยัง block ตา ง ๆ ไดอยา งงาย ๆ
ลองดโู ปรแกรมตัวอยา งอีกตวั หน่ึงท่ีใช labeled break ในการหาผลคณู ของเลขระหวาง 1 – 5
1: /**
2: Using label/break
3: */
4:
5: import static java.lang.System.out;
6:
7: class LabeledBreak {
8: public static void main(String[] args) {
9: int prod = 1;
10: int i = 1;
11:
12: here: while(true) {
13: //calculate product
14: prod *= i++;
15:
16: //go to label: here when i
17: //is greater than 5
18: if(i > 5)
19: break here;
20: else
21: out.printf("Value of prod is %d%n", prod);
22: }
23:
111
เร่มิ ตน การเขยี นโปรแกรมดวย Java intro. to Java (FEU.faa)
24: out.println("\nFinal product is " + prod);
25: }
26: }
เราใช while/loop ทท่ี าํ งานอยตู ลอดเวลาโดยไมม กี ารกาํ หนดใหห ยดุ (ใช true ใน expression) แต
เรากําหนดใหมกี ารหยุดจากการใช labeled break ใน while/loop เอง ตวั โปรแกรมจะคาํ นวณหาผล
คณู ไปจนกวา คา ของ i จะเปนหา ก็จะ break ออกจาก block ทช่ี อ่ื here ทนั ที และจะไปประมวลผล
ประโยคที่อยถู ัดมาจาก block ซ่งึ ก็คอื System.out.println("\n Final product is " + prod) ทาํ ให
เราไดผ ลลัพธดงั นี้
Value of prod is 1
Value of prod is 2
Value of prod is 6
Value of prod is 24
Final product is 120
Loop เปน โครงสรางท่ีใชม ากในการเขียนโปรแกรมตา ง ๆ ท้ังนี้เพราะ loop เอ้อื อาํ นวยใหผเู ขียน
เรยี กใชชุดคําสั่งตา ง ๆ ซ้าํ กนั ได ทาํ ใหการเขียนโปรแกรมลดขั้นตอนการทํางานลง และการทํางาน
ของโปรแกรมก็กระชับย่ิงขน้ึ เราจะกลับมาพูดถึง loop อกี หลาย ๆ คร้งั ในบทตอ ๆ ไป โดยเฉพาะใน
เร่ืองของ Array และ String
สรุป
ในบทน้เี ราไดพูดถงึ การใชป ระโยคของการเปรียบเทียบ และการตดั สนิ ใจ การใชประโยคควบคุมการ
ทํางาน การใช loop ในการประมวลผลตดิ ตอ กนั โดยรวมแลว เราไดพดู ถึง
9 การใช if และ if-else
9 การใช nested-if
9 การใช Conditional operator (? :)
9 การใช switch
9 การใช loop ตา ง ๆ เชน for/loop for-in/loop while/loop และ do-while/loop
9 การใช break continue และการใชประโยคท่ใี ช label
แบบฝก หัด
1. จงเขียนโปรแกรมท่ีรับ int จาก keyboard จํานวน 10 ตวั หลังจากนนั้ ใหคาํ นวณหาผลรวม และ
คาเฉล่ียของขอ มูลท้งั 10 ตวั ใหส ง ผลลัพธออกทางหนา จอ
2. จงหาผลลพั ธของ code ตอไปนโี้ ดยไมใช compiler ชว ย
class Loops {
public static void main(String[] args) {
int index = 1;
while(index != 9) {
index += 2;
System.out.println(index);
index--;
}
}
}
112
บทท่ี 3: การตดั สินใจ และการประมวลผลแบบวน intro. to Java (FEU.faa)
class Loops1 {
public static void main(String[] args) {
int index1, index2;
index1 = 33;
index2 = 1;
while(index1 < index2) {
index1 = index1 + 10;
System.out.println(index1);
index2 = index2 * 2;
}
}
}
class Loops2 {
public static void main(String[] args) {
int index = 1;
while(index != 33) {
index++;
System.out.println(index);
index++;
}
}
}
class Loops4 {
public static void main(String[] args) {
int j, k = 1;
while(k < 7) {
j = 5;
while(j > 0) {
System.out.println("j = " + j);
System.out.println("k = " + k);
j--;
}
k *= 2;
}
}
}
class Loops5 {
public static void main(String[] args) {
int j = 10, k = 1;
while(k < 8) {
while(j > 0) {
System.out.println("j = " + j);
System.out.println("k = " + k);
j--;
}
k = k * 2;
}
}
}
3. จงเขียนโปรแกรมที่สรางตวั เลขแบบสมุ จํานวน 100 ตวั เสร็จแลวใหแ สดงผลลพั ธอ อกทาง
หนา จอเฉพาะตัวเลขท่เี ปน เลขคเี่ ทานน้ั โดยกาํ หนดใหการแสดงผลเปน 10 ตวั ตอ หนงึ่ บรรทดั
4. จากโจทยใ นขอ 2 แทนท่ีจะแสดงผลเปนเลขคใี่ หแ สดงผลเฉพาะที่เปนเลขคูเทานั้น โดยแสดง
เฉพาะเลขคูทีม่ ากกวา 20 เทา นัน้
5. จงเขียนโปรแกรมทแี่ สดงตัวอักษรตงั้ แต A ไปจนถึง Z ดวยการใช while/loop โดยไมมกี ารรบั
คา ใด ๆ จาก keyboard
6. จงเขยี นโปรแกรมทีค่ าํ นวณหาคาท่เี ล็กท่ีสดุ ในกลุมตัวอกั ษรท่ีอา นเขา มาจาก keyboard ทีละตวั
(ตวั อกั ษรท่นี าํ เขา ควรมจี าํ นวนไมนอ ยกวา 10 ตวั )
113
เร่ิมตนการเขยี นโปรแกรมดวย Java
7. จงเขยี นโปรแกรมทีอ่ า นขอ มูล 2 ตัวจาก keyboard โดยทตี่ วั แรกเปน หมายเลขของสินคา intro. to Java (FEU.faa)
(product number) และตัวทสี องเปน จํานวนท่ีขายไปในแตละวัน (quantity sold) กาํ หนดใหมี
สินคา อยู 5 ชนิดท่ีมีราคาตางกนั ดังน้ี
สินคา ท่ี 1 ราคา 500.0 บาท
สนิ คา ที่ 2 ราคา 750.0 บาท
สินคา ท่ี 3 ราคา 850.0 บาท
สนิ คาท่ี 4 ราคา 950.0 บาท
สินคาท่ี 5 ราคา 1000.0 บาท
โปรแกรมจะคํานวณหายอดเงนิ ทขี่ ายไดของสนิ คา ทกุ ตวั ในอาทิตยทีผ่ านมา โดยที่จํานวนของ
สินคาแตล ะชนิดทข่ี ายไปจะนําเขามาจาก keyboard โปรแกรมท่ีเขียนขนึ้ ตอ งใช switch ในการ
แยกแยะราคาของสนิ คา แตล ะชนดิ ทีเ่ ขามา ใหแ สดงผลลพั ธอ อกทางหนา จอ
8. จงเขยี นโปรแกรมทแ่ี สดงผลลัพธ ดงั ท่ีเห็นน้ี ดวยการใช loop เทานนั้
*********** **********
********* *********
******** ********
******* *******
****** ******
***** *****
**** ****
*** ***
** **
* *
9. จงเขียนโปรแกรมทรี่ ับคา int หน่ึงตวั (n) ท่มี ากกวา ศูนย หลงั จากน้ันใหแ สดงผล ดงั นี้
1 2 3 ... n-1 n
1 2 3 … n-1
…
123
12
1
10. จงเขยี นโปรแกรมท่รี บั คาเปน วัน เดอื น ป จาก keyboard หลงั จากนั้นใหแสดงตาํ แหนงของวันที
น้นั ในป เชน 12 29 2002 จะแสดงเปน 363
11. จงเขียนโปรแกรมท่รี ับคาตา งๆ จาก keyboard เฉพาะท่เี ปน 0 มากกวา ศนู ย และนอ ยกวาศนู ยให
นับจาํ นวนของคาท้ังสามวา มอี ยางละก่ีตัว โปรแกรมจะหยดุ ทาํ งานไดก ต็ อ เม่ือ user ใสขอ มูลท่ี
ไมใชต วั เลข
12. จงเขยี นโปรแกรมท่ีรบั คาระหวา ง 1 – 100 หลงั จากนน้ั ใหแ สดงคา ทีร่ ับเขา มาในรูปแบบของ
ตวั หนงั สอื เชน ถาขอ มลู เขาเปน 11 ผลลัพธท ่ีไดค ือ สบิ เอ็ด
13. จงเขียนโปรแกรมท่ที ําการเขา รหัสของขอ มูลที่นําเขา จาก keyboard โดยนําเอาตัวอกั ษรทอี า น
เขา บวกกบั คา ของตัวอกั ษรทอ่ี ยถู ัดไป 2 ตัวอกั ษร mod ดวยจํานวนของตัวอักษรทีม่ อี ยู (26 ตัว
ในภาษาองั กฤษ) เชน ถา คา นาํ เขา เปน a ผลลัพธท ีไ่ ดจากการเขารหัสจะเปน a + c ซ่ึงจะมีคา
เทากบั 97 + 99 =196 % 26 = 14 ใหใ ชคา นี้เปนตัวบอกตาํ แหนงของตวั อักษรท่ีจะแสดงไป
ยงั หนาจอ ซ่ึงตวั อกั ษร ณ ตําแหนง ที่ 14 นคี้ ือ n
14. จงเขยี นโปรแกรมท่ีรับคา เปน ประโยคทางคณติ ศาสตร เชน 9 + 5 – 2 * 4 + 2 /3 หลงั จากนน้ั
ใหทําการประมวลผลประโยคดงั กลา ว ตามลาํ ดบั ของขอ มูลทน่ี าํ เขา
15. จงเขียนโปรแกรมทร่ี บั คา เดือนทีเ่ ปน ตัวเลขระหวาง 1 – 12 หลงั จากนั้นใหแสดงผลเปนจาํ นวน
ของวนั ท่ีมีอยูในเดอื นดังกลา ว
114
บทที่ 3: การตัดสนิ ใจ และการประมวลผลแบบวน intro. to Java (FEU.faa)
16. จงเขียนโปรแกรมที่คาํ นวณหา ตวั หารรว มมาก (GCD – Greatest Common Divisor) ของ
ตัวเลขสองตวั ทรี่ ับเขา มาจาก keyboard เชน gcd ของ 24 และ 15 คอื 3
Note: gcd ของ x และ y คอื integer ทีใ่ หญทสี่ ดุ ทห่ี าร x และ y ลงตวั
17. จงเขียนโปรแกรมทคี่ าํ นวณหา ตวั คูณรวมนอย (LCM – Least Common Multiple) ของตวั เลข
สองตัวทร่ี บั เขามาจาก keyboard เชน lcm ของ 24 และ 15 คอื 120
Note: LCM ของ x และ y คือ integer ท่นี อ ยท่สี ดุ ที่ทง้ั x และ y หารลงตวั
18. จงเขยี นโปรแกรมที่หา factor ของตัวเลขท่รี บั เขามาจาก keyboard เชน ถา ขอมลู เทากบั 18
factor ทไ่ี ดคอื 2 3 และ (18 = 2 * 3 * 3)
19. จงเขียนโปรแกรมท่มี ี menu ให user ในการเลอื กการทํางานระหวางการหา LCM หรือการหา
GCD การออกจากโปรแกรมจะถกู กาํ หนดโดย user
20. จงเขยี นโปรแกรมท่ีคาํ นวณหาผลลัพธของ series ทีใ่ หน ้ี
1/3 + 3/5 + 5/7 + 7/9 + 9/11 + … + 95/97 + 97/99
21. จงเขียนโปรแกรมทค่ี าํ นวณหาคาของ pi ดว ย series ท่ีใหน้ี
pi = 4(1 – 1/3 + 1/5 – 1/7 + 1/9 – 1/11 + 1/13 - … - 1/(2i – 1) + 1/(2i +1))
22. จงเขยี นโปรแกรมที่คาํ นวณหารคาของ e ดว ย series ทใ่ี หน้ี
e = 1 + 1/1! + 1/2! + 1/3! + 1/4! + … + 1/i!
115
เรม่ิ ตนการเขยี นโปรแกรมดวย Java intro. to Java (FEU.faa)
116
ในบทนเ้ี ราจะมาศึกษาถึงการสรางและใช array ซงึ่ เปน โครงสรา งอกี ตัวหน่งึ ทท่ี าํ ใหเราสามารถเกบ็ intro. to Java (FEU.faa)
ขอ มลู ทเ่ี ปน ชนิดเดยี วกันหลาย ๆ ตัวไวใ นตัวแปรตัวเดียว รวมไปถงึ การสรา งและใช string ซ่ึงจะเปน
การแนะนําใหผ ูอานไดร ูจักกับ object ในภาษา Java แบบคราว ๆ
หลงั จากจบบทเรียนนแี้ ลว ผอู า นจะไดทราบถึง
o การประกาศและกาํ หนดคาให array
o การเขา หาขอ มูลในตําแหนงตา ง ๆ ทีอ่ ยูใน array
o การสรา ง array ทใ่ี ชเ ก็บ array
o การสราง object ท่เี ปน string
o การสรางและใช array ท่เี กบ็ object
o การใชก ระบวนการตา ง ๆ กบั object ที่เปน string
4.1 อารเรย (Array)
array เปน โครงสรางชนดิ หน่งึ ทีป่ ระกอบไปดวยขอมูลชนดิ เดยี วกันทีอ่ าจมีมากกวา หน่งึ ตัว การเขา หา
ขอมูลแตล ะตัวท่ีอยูใ น array จะตอ งทําผา นทาง ช่อื ของ array และ index ท่ีมคี าเปน integer (int)
ประกอบกัน Java ไดก ําหนดให index ตวั แรกสดุ ทีเ่ ก็บขอมูลมคี าเปน 0 และจะเพ่มิ ขน้ึ ทีละหนึง่ คา ไป
เร่ือย ๆ จนกวาจะหมดขอ มลู ที่มอี ยูใน array น้ัน ๆ การประกาศตวั แปรทเ่ี ปน array ทําไดดงั น้ี
datatype[] nameOfArray;
เชน
int[] listOfNumbers;
double[] prices;
char[] vowels;
ในการประกาศ array เราจะตองกาํ หนดจํานวนของขอ มูลที่ตองการเกบ็ พรอมทั้งชนดิ ของขอมลู ทจ่ี ะ
เกบ็ ไวใน array นนั้ เครือ่ งหมาย [] จะเปน ตัวบอกให Java รูวา ตัวแปรที่ถูกสรา งข้นึ มาน้ีเปน array
และเครื่องหมายนกี้ ็จะเปน ตัวทีใ่ ชในการเขาหาขอมลู แตละตัวใน array หนงั สือหลาย ๆ เลม เลอื กที่
จะประกาศ array ในรปู แบบท่ีเห็นดา นลางนี้ ซง่ึ มีความหมายเหมือนกันกับท่ีเราไดประกาศกอนหนาน้ี
int listOfNumbers[];
double prices[];
char vowels[];
สําหรับหนงั สอื เลม นี้เราจะใชก ารประกาศในแบบท่หี น่ึง
หลงั จากที่เราไดประกาศใหต ัวแปรเปน array แลว เราก็ตอ งกาํ หนดความจใุ หกบั array น้นั ดังน้ี
listOfNumbers = new int[5];
ประโยคทเี่ ราไดเขยี นข้นึ นนั้ บอกให Java รูว าเราตองการให Java จองเน้ือท่ใี นการเกบ็ int เปน
จํานวนเทากับ 10 ตวั ใหกับตัวแปร listOfNumbers ซง่ึ ตวั แปรน้ีจะเปนตัวอางองิ (reference) ถึง
ขอมลู ทงั้ หมดท่ไี ดถูกเกบ็ ไวใน array น้ี ภาพที่ 4-1 แสดงถงึ สิง่ ตา ง ๆ ท่ีเกดิ ขึ้นเม่ือเราประกาศการ
ใช array
เริ่มตน การเขยี นโปรแกรมดว ย Java
ประกาศ array ท่ี ชอื่ ของ ชนิดของขอ มลู ท่ี array intro. to Java (FEU.faa)
เกบ็ int array num เก็บได
int [] num = new int[5];
ใช operator new ในการจองเนอื้ ที่ ชนิด
int จํานวน 5 ตัว
index ของ
array num
num[0] num[1] num[2] num[3] num[4]
num.length จะมคี าเทา กบั 5
ภาพที่ 4-1 การประกาศและกาํ หนดขนาดของ array
เม่ือมีการประกาศใช array เชน
int [] num;
นนั้ array ทเ่ี ราไดประกาศน้ันยังไมม ีเนอ้ื ทใ่ี นหนว ยความจาํ เลย เราตองกําหนดขนาดเพอ่ื ใหเ กิดการ
จองเนื้อทีใ่ นหนวยความจาํ ดวยการใช operator new รวมไปถึงจาํ นวนของเน้ือท่ที ่ีตอ งการใช เชน
int [] num = new int[5];
และทกุ คร้งั ของการจองเน้อื ที่ Java จะกําหนดใหข อ มูลในทุก ๆ ตาํ แหนงมคี า เปน 0 เสมอ
ในการเขา หาขอมูลแตล ะตัวนนั้ เรากเ็ พียงแตกาํ หนด index (ตวั ช้ีตาํ แหนง) ของขอมลู ท่เี ราตองการ
เขา หา เชน
num[3]
num[2]
เราไมส ามารถเขาหาขอมูล ณ ตําแหนง ทีม่ คี า index เกนิ 4 ไดท ั้งนเี้ พราะเรากําหนดให array num
มีความจุสงู สดุ เทากบั 5 ดงั นน้ั คา ของ index ท่ีเปนไปได คือ 0 1 2 3 และ 4 ถา หากวา เราเขา หา
ขอมูลทไี่ มอยูในตาํ แหนงทีก่ ลา วน้ี Java จะฟองดว ย error ทันทีวา index ที่เราอางถงึ ไมมีตัวตน
(array index out of bound)
4.2 การกาํ หนดคาเบือ้ งตน ใหก บั array
เรารวู าหลงั จากการประกาศและจองเนอื้ ที่ใหกับ array นน้ั ถา เปน array ท่เี ก็บ int ทกุ ๆ
หนวยความจาํ ของ array จะมคี าเปน 0 ดงั ทีแ่ สดงในโปรแกรมตัวอยา งนี้
118
บทท่ี 4: Array และ String
1: /** intro. to Java (FEU.faa)
2: Using array to store integers
3: */
4:
5: import static java.lang.System.out;
6:
7: class Array1 {
8: public static void main(String[] args) {
9: int[] list; //declare array of int
10:
11: //allocate space for 10 ints
12: list = new int[10];
13: for(int i = 0; i < list.length; i++)
14: out.println("list[" + i +"] = " + list[i]);
15: }
16: }
โปรแกรม Array1.java ประกาศใหตวั แปร list เปน array ทเ่ี กบ็ int เปน จํานวนเทากบั 10 ตวั เม่ือ
ประกาศเสร็จแลว เราก็ใช for/loop ในการเขาหาขอมูลในแตล ะตัว array โดยแสดงถึงคา ท่ี Java
กําหนดใหก ับ array ของเราไปยังหนาจอ ซ่ึงมคี า ดงั นี้
list[0] = 0
list[1] = 0
list[2] = 0
list[3] = 0
list[4] = 0
list[5] = 0
list[6] = 0
list[7] = 0
list[8] = 0
list[9] = 0
ดังเชนท่เี ราไดพดู ไวใ นบทที่ 3 ใน Java 1.5 เราสามารถท่ีจะใช for-in/loop แสดงขอมลู ใหเ ราดังนี้
1: /**
2: Using array to store integers
3: */
4:
5: import static java.lang.System.out;
6:
7: class ArrayForInLoop {
8: public static void main(String[] args) {
9: int[] list;//declare array of ints
10: int i = 0; //loop index
11:
12: //allocate space for 10 ints
13: list = new int[10];
14: for(int item : list)
15: out.printf("list[%d] = %d%n", i++, item);
16: }
17: }
จากโปรแกรมตวั อยา งที่เหน็ เราสามารถแสดงขอ มูลทุกตวั ของ array ดวยการใช for-in/loop ได
เชนเดยี วกับการใช for/loop แตเราไมส ามารถเขา หา index ของ array ได ซงึ่ ทําใหเ ราตอ งใชตวั
แปรอ่ืนชวยในการแสดงผล (ใหเหมือนกบั ท่ีทาํ ในโปรแกรม Array1.java)
การใช loop เปนวิธกี ารท่ีงา ยทส่ี ดุ ในการเขา หาขอ มูลทุกตวั ทอี่ ยูใ น array ยกเวน วาเรารูต าํ แหนง ที่
แนนอนของขอมลู ทีเ่ ราตอ งการใน array นน้ั เชน ตาํ แหนงท่ี 5 หรือตาํ แหนง ท่ี 3 เราก็เขา หาได
โดยตรง ดงั น้ี list[5] หรอื list[3] เปน ตน
array ทสี่ รา งข้ึนใน Java นน้ั เราสามารถทจ่ี ะดึงเอาขนาดของ array ออกมาไดด ว ยการเรยี กใช
คา คงท่ี ท่ีไดถ กู สรา งข้ึนหลงั จากการประกาศและจองเนื้อที่ใหก ับ array ดงั น้ี
list.length;
119
เรม่ิ ตนการเขยี นโปรแกรมดวย Java
ทกุ array ที่ไดถกู สรางขน้ึ จะมีขนาดของ array เกบ็ ไวในตัวแปรช่อื length และเราเรยี กขนาด intro. to Java (FEU.faa)
ออกมาไดผ านทางชอื่ ของ array ตามดว ย . และตวั แปร length
เรามาลองกําหนดคา ในตาํ แหนงตาง ๆ ใหก ับ array ของเรา
1: /**
2: Assign some values to array of ints
3: */
4:
5: import static java.lang.System.out;
6:
7: class Array2 {
8: public static void main(String[] args) {
9: int[] list; //declare array of int
10:
11: //allocate space for 10 ints
12: //assign values at index 5, 3, and 9
13: list = new int[10];
14: list[5] = 8;
15: list[3] = 2;
16: list[9] = 4;
17: for(int i = 0; i < list.length; i++)
18: out.println("list[" + i +"] = " + list[i]);
19: }
20: }
ผลลพั ธท ่ไี ดจากการ run คอื
list[0] = 0
list[1] = 0
list[2] = 0
list[3] = 2
list[4] = 0
list[5] = 8
list[6] = 0
list[7] = 0
list[8] = 0
list[9] = 4
เราสามารถทจี่ ะกําหนดคา ใหก บั array โดยทไี่ มต อ งกําหนดขนาดใหก บั array โดยตรง แตใ ห Java
จัดการเก่ยี วกับเรอ่ื งเน้ือที่ใหเรา ดังโปรแกรมตวั อยางตอ ไปน้ี
1: /**
2: Declare and assign values to array of ints
3: */
4:
5: import static java.lang.System.out;
6:
7: class Array3 {
8: public static void main(String[] args) {
9: //array of ints with initial values
10: int[] list = {2, 3, 1, 56, 90};
11: int i = 0;
12:
13: for(int item : list)
14: out.printf("list[%d] = %d%n", i++, item);
15: }
16: }
เรากําหนดให list เปน array ทีเ่ กบ็ int และกาํ หนดคา เบื้องตน เปน 2 3 1 56 และ 90 ตามลาํ ดบั
เม่ือ Java เห็นการประกาศในลักษณะน้ีก็จะทําการจองเนือ้ ที่ใหกบั array โดยอัตโนมตั ิพรอ มทงั้ นํา
คา ตา ง ๆ ทไ่ี ดถ กู กําหนดจาก user ไปใสไวใน array list และเม่ือ run ดูเราก็ไดผลลัพธด งั ท่เี ห็นน้ี
list[0] = 2
list[1] = 3
list[2] = 1
list[3] = 56
list[4] = 90
120
บทท่ี 4: Array และ String
โปรแกรมตวั อยา งตอ ไปนแ้ี สดงถงึ การเก็บขอมูลที่ user ใสเ ขา มาจาก keyboard เขาสู array (เรา intro. to Java (FEU.faa)
ยงั คงใชว ธิ ีการแบบเดมิ กอ น Java 1.5 ในการรบั ขอมูล)
1: /**
2: Get numbers from keyboard and keep them in array
3: */
4:
5: import static java.lang.System.out;
6: import java.io.BufferedReader;
7: import java.io.InputStreamReader;
8: import java.io.IOException;
9:
10:
11: class ArrayOfNumbers {
12: public static void main(String[] args) throws IOException {
13: double number, sum = 0; //a number and sum
14: double[] list; //array of double
15: int count; //number of items
16: String input; //input string
17: BufferedReader buffer; //input buffer
18: InputStreamReader isr; //input stream
19:
20: out.print("How many numbers? : ");
21: isr = new InputStreamReader(System.in);
22: buffer = new BufferedReader(isr);
23: input = buffer.readLine();
24:
25: count = Integer.parseInt(input); //total items in list
26: list = new double[count]; //allocate space for list
27: //reading each double into list
28: for(int i = 0; i < list.length; i++) {
29: out.print("Enter number: ");
30: input = buffer.readLine();
31: list[i] = Double.parseDouble(input);
32: }
33:
34: //add all doubles in list
35: int n = list.length - 1; //n is the last index of list
36: while(n >= 0) { //looping until n equals to 0
37: sum += list[n--]; //add list[n] into sum and
38: } //decrement n
39:
40: //calculate average and display result
41: double average = sum / count;
42: out.printf("Sum of numbers = %.2f%n", sum);
43: out.printf("Average of numbers = %.2f%n", average);
44: }
45: }
โปรแกรม ArrayOfNumbers.java ถาม user ถึงจาํ นวนของขอ มลู สูงสุดท่ี user จะใสเขาสูโปรแกรม
ซ่งึ เม่อื ไดแ ลวโปรแกรมจะใชจํานวนที่อานไดเ ปน ตวั กําหนดขนาดใหก บั array
list = new double[count];
หลงั จากนนั้ กจ็ ะอานขอ มูลทีละตัวจาก user นําไปเก็บไวใ น array list
for(int i = 0; i < list.length; i++) {
out.print("Enter number: ");
input = buffer.readLine();
list[i] = Double.parseDouble(input);
}
ในขณะทอ่ี านขอมลู เขา สู array นน้ั เราอาจหาผลรวมของเลขทุกตวั พรอม ๆ กนั ไปดว ยก็ได แตท ่ี
โปรแกรมนแี้ ยกการหาผลรวมก็เพ่อื ท่ีจะแสดงใหเ หน็ ถงึ การใช loop ในการเขา หา array อกี ครง้ั หนึ่ง
โดยเรากําหนดใหต วั แปร n เปน index ตวั สดุ ทา ยของ array list ดว ยประโยค
int n = list.length - 1;
121
เริม่ ตน การเขยี นโปรแกรมดว ย Java
เราตองไมลืมวา list.length ใหจ ํานวนของขอ มลู ท้ังหมดทอ่ี ยูใ น array ดงั น้นั index ตวั สดุ ทา ยก็คือ intro. to Java (FEU.faa)
list.length – 1 หลงั จากนัน้ เราจะใช while loop เปนตวั เขาหาขอมลู ใน array แตล ะตวั จากขา งหลัง
และบวกขอมลู ทุก ๆ ตัวเขา กับตัวแปร sum
while(n >= 0) {
sum += list[n--];
}
ประโยค sum += list[n--] นัน้ จะบวกขอมูลในตาํ แหนง n เขา กับตัวแปร sum กอ นท่ีจะลดคาของ n
ลงหน่งึ คา และเมอ่ื คา n นอยกวา 0 เราก็หลดุ ออกจาก while loop ทันที
ผลลัพธทเ่ี ราไดจ ากการ run โปรแกรม ArrayOfNumbers.java ดว ยขอมูลดง ทเี่ ห็น คือ
How many numbers? : 5
Enter number: 12
Enter number: 31
Enter number: 56
Enter number: 81
Enter number: 2
Sum of numbers = 182.00
Average of numbers = 36.40
โปรแกรมตัวอยา งถดั ไปเปน โปรแกรมที่ดัดแปลงจาก ArrayOfNumbers.java โดยให user ใสข อมูล
ผา น Dialog Box และแสดงผลลัพธอ อกทาง Dialog Box เชนเดียวกนั อกี ท้ังยงั ใช StringTokenizer
ในการดงึ ขอมลู ท่ี User ใสใน Dialog Box ซงึ่ ก็คลายๆ กับการใช StreamTokenizer ทเ่ี ราใชใน
โปรแกรม ArrayOfNumbers.java
1: /**
2: Using JOptionPane for I/O
3: */
4:
5: import java.io.*;
6: import java.util.StringTokenizer;
7: import javax.swing.JOptionPane;
8:
9: class ArrayOfNumbersSW {
10: public static void main(String[] args) throws IOException {
11: double number, sum = 0; //a number and sum
12: double[] list; //array of double
13: int count; //number of items
14: String input; //input string
15:
16: input = JOptionPane.showInputDialog(null,
17: "Enter numbers - separate by space",
18: "Array Example", JOptionPane.QUESTION_MESSAGE);
19:
20: StringTokenizer s = new StringTokenizer(input);
21: count = s.countTokens();
22: list = new double[count]; //allocate space for list
23:
24: //extract numbers from s into list
25: int i = 0;
26: while(s.hasMoreTokens()) {
27: list[i++] = Double.parseDouble(s.nextToken());
28: }
29:
30: //add all doubles in list
31: for(Double num : list) {
32: sum += num;
33: }
34:
35: //calculate average and display result
36: double average = sum / count;
37: JOptionPane.showMessageDialog(null, "Sum = " +
38: sum + ", Average = " +
39: String.format("%.2f", average),
40: "Output", JOptionPane.INFORMATION_MESSAGE);
41: }
42: }
122
บทที่ 4: Array และ String
ผลลพั ธของการ run คือ intro. to Java (FEU.faa)
กอนท่เี ราจะดึงขอ มูลออกจาก StringTokenizer นัน้ เราตอ งทาํ การจองเนอื้ ทใ่ี หกบั list กอ น ซึ่ง
วิธกี ารทีเ่ ราเลอื กใชก็คือ การใช method countTokens() เปน ตัวดงึ จาํ นวนของขอมูลท่มี อี ยใู น
String s ไปเก็บไวใ นตัวแปร count หลังจากนนั้ ก็ใช count จองเน้ือที่ใหกับ list เพอ่ื เก็บขอมลู
ตอไป (บรรทัดที่ 21 – 22)
สําหรับการดงึ ขอมูลจาก String s นัน้ เรากใ็ ช method nextToken() และ method
hasMoreTokens() เปนตัวดึงใหเ รา
int i = 0;
while(s.hasMoreTokens()){
list[i++] = Double.parseDouble(s.nextToken());
}
Loop จะทํางานถา method hasMoreToken() สงคาท่เี ปนจริงกลับออกมา พดู ภาษาชาวบานก็คอื s
ยงั มี token อยู และ nextToken() จะสงคา ของ token ท่เี ปน String กลบั ออกมา เราตอ งทําการ
เปลี่ยน String ตวั น้ใี หเ ปน double กอนทจ่ี ะนาํ ไปเกบ็ ไวใ น list อยา งไรก็ตามโปรแกรมตวั อยางของ
เราไมมกี ารตรวจสอบขอผิดพลาดท่ีอาจเกดิ ขน้ึ จากการใสขอมูล เชน ถา user ใสข อมลู ทไ่ี มใช
double โปรแกรมกจ็ ะฟองทันที
ในการหาผลรวมของตัวเลขนน้ั เรากใ็ ช for-in/loop เปนตวั ดงึ เอาขอมูลทีม่ อี ยใู น list ออกมารวมกนั
เพือ่ นําไปเกบ็ ไวในตวั แปร sum ตอไปดังท่แี สดงใหด ใู นบรรทดั ท่ี 31 – 32 สวนการแสดงผลเราก็ใช
format() ของ class String เปน ตวั กาํ หนดตาํ แหนง ทศนยิ มที่ตอ งการแสดง
4.3 การอา งถงึ array ดวยการ clone และการ copy array
เมื่อเราสราง array ขน้ึ มาแลว เราสามารถที่จะอางถึงตัวแปรตวั น้ีดว ยตวั แปรอน่ื ก็ได แตไ มได
หมายความวา เราไดสราง array ตัวใหมจากตวั แปรตัวใหมนี้ เราเพยี งแตใชตวั แปรตวั ใหมใ นการอา ง
ถงึ array ตัวเดมิ เพราะฉะน้ันการกระทาํ ใด ๆ ผานตวั แปรตวั ใหมก จ็ ะมีผลกระทบกับขอมลู ใน array
ตวั เดมิ น้นั ดังโปรแกรมตวั อยางนี้
1: /**
2: Cloning array
3: */
4:
5: import static java.lang.System.out;
6:
123
เริ่มตนการเขียนโปรแกรมดวย Java
7: class Array4 {
8: public static void main(String[] args) {
9: int[] list = {2, 3, 1, 56, 90}; intro. to Java (FEU.faa)
10:
11: //print list to screen
12: out.println("Before cloning");
13: for(int i = 0; i < list.length; i++)
14: out.println("list[" + i +"] = " + list[i]);
15:
16: int[] newList = list; //cloning
17: newList[0] = 11; //changing data at list[0]
18: newList[3] = 1234; //changing data at list[3]
19:
20: out.println("After cloning");
21: int i = 0;
22: for(int item : list)
23: out.printf("list[%d] = %d%n", i++, item);
24: }
25: }
เราไดดดั แปลงโปรแกรม Array3.java ใหม กี ารอางถึง (reference) array list ดวยตวั แปรตัวใหมท่ี
ชอ่ื newList
int[] newList = list;
และเรากไ็ ดท ําการเปลย่ี นขอมลู ณ ตาํ แหนง 0 ใหเ ปน 11 และขอมูลในตาํ แหนง 3 ใหเ ปน 1234
ผานทาง newList เมื่อลอง run ดเู รากจ็ ะไดผลลพั ธด งั น้ี
Before cloning
list[0] = 2
list[1] = 3
list[2] = 1
list[3] = 56
list[4] = 90
After cloning
list[0] = 11
list[1] = 3
list[2] = 1
list[3] = 1234
list[4] = 90
สวนวธิ ีการ copy ขอมลู จาก array ตวั หน่งึ ไปยัง array อีกตัวหนง่ึ นั้นมีวธิ ีการอยูส ามวธิ ที ่ที ําได วิธที ่ี
หน่ึงน้ันเราตองสรา ง array ใหมขึ้นมาแลวก็ copy ขอมลู ทุกตวั จาก array ตวั เดมิ เขาสู array ตัวใหม
ดงั น้ี
1: /**
2: Copy from one array to another
3: */
4:
5: import static java.lang.System.out;
6:
7: class Array5 {
8: public static void main(String[] args) {
9: int[] list = {2, 3, 1, 56, 90}; //original array
10: int[] newList = new int[list.length]; //new array
11:
12: //copy each item from list into newList
13: for(int i = 0; i < list.length; i++)
14: newList[i] = list[i];
15:
16: for(int i = 0; i < list.length; i++)
17: out.println("newList[" + i +"] = " + newList[i]);
18: }
19: }
โปรแกรม Array5.java สราง newList ดวยคาํ ส่ัง
int[] newList = new int[list.length];
124
บทท่ี 4: Array และ String
เรากาํ หนดขนาดของ newList ดวยขนาดที่มาจาก list หลังจากนัน้ เราก็ copy ขอ มูลทุกตวั ดว ยการ intro. to Java (FEU.faa)
ใช for/loop
for(int i = 0; i < list.length; i++)
newList[i] = list[i];
และเม่ือ run ดเู ราก็ไดผลลพั ธด ังทีค่ าดไว คอื
newList[0] = 2
newList[1] = 3
newList[2] = 1
newList[3] = 56
newList[4] = 90
สําหรับวธิ ีทส่ี องนนั้ เราจะใช method arraycopy() ของ Java เปนตัวคดั ลอกขอมูลจาก array ตัว
หน่งึ ไปยังอกี ตวั หนง่ึ ดงั ที่แสดงใหดูน้ี
1: /**
2: Using system's arraycopy to create new array
3: */
4:
5: import static java.lang.System.out;
6:
7: class Array6 {
8: public static void main(String[] args) { //original array
9: int[] list = {2, 3, 1, 56, 90};
10: int[] newList = new int[list.length]; //new array
11:
12: //copy each item from list into newList
13: System.arraycopy(list, 0, newList, 0, list.length);
14:
15: for(int i = 0; i < list.length; i++)
16: out.println("newList[" + i +"] = " + newList[i]);
17: }
18: }
ถงึ แมว าเรายงั ไมไ ดพดู ถงึ เรอ่ื งของ class หรอื method แตเราก็ตอ งมาทาํ ความเขา ใจถงึ การเรียกใช
method ท่ี Java มีให เพราะวาวิธีทสี่ องนี้เราใช method arraycopy() ทําการสรา งและ copy ขอมูล
ให ตอนนเ้ี ราคงตองจาํ วธิ กี ารเรียกใชมากกวา การทําความเขาใจอยา งละเอียด (ซ่งึ เราจะพูดถึงในบท
ตอ ๆ ไป) เรา copy ดวยการใชค าํ ส่งั
System.arraycopy(list, 0, newList, 0, list.length);
โดยเราตอ งใสขอ มลู หรอื เง่ือนไข (parameter) ตามท่ี Java กาํ หนดไวค อื
ตวั แรกเปน array ตัวเดมิ ทต่ี อ งการ copy (list)
ตวั ที่สองเปน index เริม่ ตน ของ array ตัวเดมิ (0)
ตวั ท่ีสามเปน array ตวั ใหมท ต่ี องการสรา ง (newList)
ตัวท่ีสเี่ ปน index เริม่ ตน ของ array ตวั ใหม (0)
ตัวที่หา เปน จาํ นวนของขอ มูลท่ีตองการ copy (list.length)
วิธีท่ีสามก็คลา ย ๆ กบั วธิ ที ส่ี องเพียงแตเ ราเรียกใช method clone() แทน ซ่ึงทําไดด ังน้ี
1: /**
2: Cloning array with method clone()
3: */
4:
5: import static java.lang.System.out;
6:
7: class Array7 {
8: public static void main(String[] args) {
9: int[] list = {2, 3, 1, 56, 90}; //original array
10:
11: //cloning process
12: int[] newList = (int[])list.clone();
13:
125
เรม่ิ ตน การเขยี นโปรแกรมดว ย Java
14: int i = 0; intro. to Java (FEU.faa)
15: for(int item : newList)
16: out.printf("newList[%d] = %d%n", i++, item);
17: }
18: }
เราเพียงแตเรียกใช method clone() ดงั ท่ีเหน็ ในโปรแกรม Array7.java เราก็สามารถท่จี ะมี array
ตวั ใหมสาํ หรับการใชงาน ดวยประโยค
int[] newList = (int[])list.clone();
เราจําเปน ทีจ่ ะตอ งทาํ การ cast ใหก บั array ของเราเสยี กอนเพือ่ ใหชนดิ ของ array ที่ถูก clone
ขึ้นมานัน้ เปนชนิดเดยี วกัน ซ่งึ ทําไดด ว ยการนาํ เอา (int[]) ไปใสไวห นาประโยค list.clone() ทั้งน้ี
ตอ งกาํ หนดชอื่ array ตัวเดมิ ใหถกู ตอง (list) เพ่อื ไมใหเกิดการผิดพลาดใด ๆ
วิธที ีส่ ามท่ไี ดกลา วไวจ ะ copy ขอ มูลใน array เดมิ ทม่ี ีอยูท ง้ั หมดไปเก็บไวใน array ตัวใหม ดังนัน้
ถา หากวาเราตอ งการที่จะสรา ง array ใหมจากขอ มลู บางสวนของ array ตวั เดมิ เราก็ตองใชวิธีทส่ี อง
ดังตวั อยา งน้ี
1: /**
2: Copy part of one array to another
3: */
4:
5: import static java.lang.System.out;
6:
7: class Array8 {
8: public static void main(String[] args) {
9: int[] list = {2, 3, 1, 56, 90}; //original array
10: int[] newList = new int[list.length-2];//new array
11:
12: //copy item at index 2, 3, and 4 from list into newList
13: System.arraycopy(list, 2, newList, 0, list.length - 2);
14:
15: int i = 0;
16: for(int item : newList)
17: out.printf("newList[%d] = %d%n", i++, item);
18: }
19: }
โปรแกรม Array8.java ของเราตอ งการท่ีจะ copy ขอ มูล ณ ตาํ แหนง ท่ี 2 3 และ 4 จาก array list
เขา สู array newList ในตําแหนง 0 1 และ 2 ตามลําดบั เพราะฉะน้นั เราตองเรียกใช method
arraycopy() ดังนี้
System.arraycopy(list, 2, newList, 0, list.length – 2);
ผลลัพธข องการ run คือ
newList[0] = 1
newList[1] = 56
newList[2] = 90
4.4 การใช array แบบยดื หยุน (Dynamic Array)
เราสามารถท่ีจะใชเ ทคนิคทเี่ ราพดู มากอนหนา นี้ในการสราง array แบบไมจ าํ กดั จาํ นวนของขอมลู ท่ี
สามารถจัดเกบ็ ไดใ น array น้ัน ๆ เราเรียกการจดั เก็บแบบน้ีวาการจัดเก็บแบบยดื หยุน แตก อนท่ีเราจะ
สรา งไดน ั้นเราตอ งกาํ หนดให array เร่มิ ตน ของเรามีขนาดเบือ้ งตน กอน หลงั จากนั้นจึงจะสามารถ
ขยายขนาดของ array ได ดังโปรแกรมตัวอยา งท่ีไดด ัดแปลงมาจากโปรแกรม AddNumbers.java
ทเี่ ขยี นข้นึ กอ นหนาน้ี
1: /**
2: Expand size of array when needed
3: */
4:
5: import javax.swing.JOptionPane;
6:
7: class DynamicArray {
8: public static void main(String[] args) {
126
บทท่ี 4: Array และ String
9: double number, sum = 0; //a number and sum
10: double []list = new double[2]; //array of double
11: String input; //input string intro. to Java (FEU.faa)
12:
13: //get input from user (seperate by space)
14: input = JOptionPane.showInputDialog("Enter numbers: ");
15: String[] tokens = input.split("\\s");
16:
17: int count = 0;
18: while(count < tokens.length) {
19: number = Integer.parseInt(tokens[count]);
20: if(count > list.length-1) {
21: double []newList = new double[list.length*2];
22: System.arraycopy(list, 0, newList, 0, list.length);
23: list = newList; //point to new list
24: }
25: list[count] = number; //save token to list
26: sum += list[count]; //calculate sum
27: count++; //number of tokens read
28: }
29:
30: //calculate average and display result
31: double average = sum / count;
32: JOptionPane.showMessageDialog(null,
33: "Sum of numbers: " + input + " is " +
34: String.format("%.2f%n", sum) +
35: "Average of numbers: " +
36: String.format("%.2f", average),
37: "Sum and Average",
38: JOptionPane.INFORMATION_MESSAGE);
39: }
40: }
เราประกาศตวั แปร list ใหเ ปน array ท่ีเก็บ double เรมิ่ ตนดวยจาํ นวนเทากับ 2ตวั และในการนาํ
ขอ มลู เขา สู array นน้ั เราจะตรวจสอบดูวาจํานวนของ index ทีเ่ ราใชในการเขาหาขอ มูลแตล ะตวั มีคา
เกินจาํ นวนของขอ มลู ทเี่ ปน อยูขณะนั้นหรอื ไม ซง่ึ ถา เปน จรงิ เราก็จะทาํ การขยายขนาดใหกับ array
list เปนจํานวนสองเทา ของขนาดเดิม และทําการ copy ขอมูลจาก array list ไปสู array ใหมนี้
(newList) หลังจากน้ันเราก็อา งถงึ array ตวั ใหมน้ดี วยตวั แปรเดิมที่เราใชในการเกบ็ ขอมลู ครง้ั แรก
(list) เราไมตองกงั วลถงึ หนวยความจาํ ท่ีเราไดใ ชไปในการสรา ง array ตัวเดิมเพราะ Java จะทําการ
ตรวจสอบถงึ หนว ยความจาํ ที่ไมม ีการใชงาน และจะคืนหนว ยความจําน้ใี หกบั ระบบโดยอตั โนมัติ
if(count > list.length-1) {
double []newList = new double[list.length*2];
System.arraycopy(list, 0, newList, 0, list.length);
list = newList;
}
วธิ กี ารขยายขนาดของ array แบบน้ที ําใหเราไมตองกําหนดขนาดของ array ใหม ีขนาดใหญ
มากมายเกนิ ไปตอนทเ่ี ราสราง array ในครัง้ แรก เราสนใจเฉพาะเม่อื จําเปนตอ งขยายขนาดของ
array จริง ๆ เทานั้น ผูอานอาจเปลีย่ นแปลงการขยายขนาดของ array ดวยการเพ่มิ ทลี ะก่ีตวั กไ็ ด
ทง้ั นกี้ ็ขนึ้ อยกู บั ความจําเปนและเหมาะสมกบั งานน้ัน ๆ
ผลลัพธของการ run โปรแกรม DynamicArray.java ก็คลา ย ๆ กบั ผลลพั ธของโปรแกรม
AddNumbers.java ท่ีเราไดเขียนไวกอนหนา นี้
หลายๆคร้งั ทีเ่ ราตองเขียนโปรแกรมสําหรบั การนบั จาํ นวนครงั้ ของเหตุการณหรือ จํานวนคร้ังของ
ขอมูลทเ่ี กดิ ขน้ึ เชนจาํ นวนครั้งของคะแนนที่นักศกึ ษาไดในการสอบแตละครั้ง โปรแกรมตวั อยางการ
ใช array และ indexของ array ในการนับจํานวนคร้ังของลกู เตา ทอ่ี อกซ้ํากันจากการโยนหลาย ๆ
คร้งั
1: /**
2: Frequency of faces of a die
3: */
4:
5: import javax.swing.JOptionPane;
6:
7: class DiceRolling {
127
เริม่ ตน การเขยี นโปรแกรมดวย Java
8: public static void main(String[] args) { intro. to Java (FEU.faa)
int face, roll;
9: int[] frequency = new int[7];
10:
//rolling a die for 100 times
11: roll = 1;
12: while(roll <= 100) {
13:
//roll a die
14: face = (int)(Math.random() * 6) + 1;
15: //save each time the same face occur by using
16: //indexes as faces of die
frequency[face]++;
17: roll++;
18: }
19: //store frequencies in result for displaying
20: String output;
21: String result = "";
int total = 0;
22: for(int i = 1; i < frequency.length; i++) {
23:
24: output = String.format("%2d%18c%2d%n", i, ' ', frequency[i]);
total += frequency[i];
25: result += output;
}
26:
27: //display result
String header = String.format("Face%8cFrequency%n", ' ');
28: JOptionPane.showMessageDialog(null,
29:
header + result + "\nTotal: " +
30: total,
31: "Rolling a die 100 times",
32: JOptionPane.INFORMATION_MESSAGE);
33: System.exit(0);
34: }
35:
36:
37:
38:
39:
40:
41:
42:
43: }
โปรแกรม DiceRolling.java ใชตัว index ของ array เปน หนา ของลูกเตา ทีถ่ กู โยนโดยการใชการสมุ
ผานทาง method random() ซ่ึงจะบังคับใหผลลพั ธของการโยนน้ันอยรู ะหวาง 1 – 6 ดวยการคูณ 6
เขา กบั ผลลัพธท ไี่ ดจากการสุม บวกเขากับ 1 การนับจํานวนครงั้ กท็ าํ ไดด ว ยการเพม่ิ คา ใหก ับขอมลู ที่
index นนั้ ๆ ของลกู เตา เชน ถาการโยนไดคา เทา กบั 6 เราก็เพ่มิ คา ดวย frequency[6]++ ซึ่งจะทํา
ใหคาท่ีอยู ณ ตําแหนง นน้ั เพม่ิ ข้ึนอีกหน่ึงคา วธิ กี ารใช index ของ array ในลกั ษณะนี้ชวยลดข้นั ตอน
การนบั จาํ นวนของหนาลูกเตา ท่ีเกิดขน้ึ ไดด ีกวาวิธอี ื่น ๆ เชน การใช if – else มาชวยในการ
ตรวจสอบวา การโยนใหคา อะไร แลว จึงเพ่ิมคาใหก บั ตวั แปรทเ่ี ก็บการนับของหนานน้ั ๆ
if(face == 1)
count1++;
else if(face == 2)
count2++;
else if(face == 3)
count3++;
…
…
else if(face == 6)
count6++;
ซ่ึงเปน วิธีท่ตี องเขียน code มากกวา และใชต ัวแปรเยอะกวา การใช frequency[face]++
ผลลัพธข องการ run
128
บทท่ี 4: Array และ String intro. to Java (FEU.faa)
for/loop ในบรรทดั ท่ี 27 – 30 เปนกระบวนการเตรียมขอ มูลสาํ หรบั การแสดงผลผา นทาง dialog
box เราตอ งการที่จะแสดงผลในรปู แบบของ row/column ทมี่ ีคา ของลูกเตา และจาํ นวนครงั้ ทเี่ กดิ ข้นึ
ของการโยนทงั้ หมด และเน่ืองจากวา เราตองเปลย่ี นขอ มลู ใหอ ยใู นรปู แบบของ String กอนทีจ่ ะสงไป
ยงั dialog box เราจงึ ตองใช method format() จัดการกับขอ มลู ทเี่ รามอี ยใู น array frequencies
ดงั น้ี
output = String.format("%2d%18c%2d%n", i, ' ', frequency[i]);
เรากาํ หนดให output มขี อ มลู ในรูปแบบทีไ่ ดกาํ หนดไวใน method format() คอื แสดงคา ของ
ลูกเตาในหน่ึงหนา ตามดว ยชองวาง ตามดวยจํานวนครงั้ ทเ่ี กิดข้ึน และสุดทายตามดว ยการขนึ้ บรรทดั
ใหม (new line character: %n หรือ \n) เม่ือเราไดข อมูลในหนง่ึ หนาแลว เรากเ็ กบ็ คาใน output ไว
ในตวั แปร result เพือ่ นาํ ไปแสดงใน dialog box ตอไป
4.5 การคนหาขอมลู ใน array (Searching)
การคนหาขอมลู ใน array นนั้ ทาํ ไดอยูสองวิธใี หญ ๆ คือ การคนหาแบบตามลําดับ (sequential
search) และ การคนหาแบบหารสอง (binary search) เราจะมาดูถึงวิธีการคน หาแบบตามลาํ ดับกอน
เพราะเปนการคนหาท่งี ายทีส่ ุด
4.5.1 การคนหาแบบตามลําดับ (Sequential search)
ในการคน หาแบบนี้นัน้ เราจะเร่ิมตนจากขอมลู ตัวแรกสดุ 1ทอ่ี ยใู น array ทําการเปรียบเทยี บขอ มูลตวั นี้
กับขอมลู ที่ตองการคน หาวาเปน ตัวเดียวกนั หรือไม ถา ใชเราก็หยดุ การคนหา ถา เราคนไปจนถงึ ตวั
สุดทายแตก ย็ งั ไมใ ช เราก็รูวา ขอมลู ท่ตี องการคนหาไมไ ดอ ยูใ น array ลองดโู ปรแกรมตวั อยางกัน
1: /**
2: Searching for an item in array
3: using sequential search (linear search)
4: */
5:
6: import javax.swing.JOptionPane;
7:
8: class SeqSearch {
9: public static void main(String[] args) {
10: int[] list = {2, 3, 1, 56, 90};
11: String input;
12: int number;
13:
14: //get input from user
15: input = JOptionPane.showInputDialog("What number? ");
16: number = Integer.parseInt(input);
17:
18: //search for number in the list
19: //comparing number against item in the list
20: //one by one until found or out of item in the list
1 หรืออาจเริ่มจากทางดานหลังของ array ก็ได
129
เร่มิ ตน การเขียนโปรแกรมดว ย Java intro. to Java (FEU.faa)
21: boolean found = false;
22: for(int item : list) {
23: //if number is in the list, break out of loop
24: if(number == item) {
25: found = true;
26: break;
27: }
28: }
29:
30: String result = "";
31: if(!found)
32: result += number + " is not in the list.";
33: else
34: result += "Found " + number + " in the list";
35:
36: //display result
37: JOptionPane.showMessageDialog(null,
38: result, "Sequential search",
39: JOptionPane.INFORMATION_MESSAGE);
40:
41: System.exit(0);
42: }
43: }
เราใช for-in/loop ในการเขาหาขอมูลทุกตวั ทอี่ ยูใน array list โดยเรากาํ หนดใหต วั แปร found ซึ่งมี
ชนิดเปน boolean เปนตวั ควบคมุ การทาํ งานของ loop ซึง่ ถาการคนหาประสพผลสําเร็จ ตัวแปร
found กจ็ ะถูกกาํ หนดใหเ ปน true และ loop ของเราก็จะยุติการทาํ งานทันที หลังจากน้นั เราก็
แสดงผลของการคนหาไปยงั หนา จอ ดงั ตัวอยา งทแี่ สดงผลลัพธของการคนหาที่เห็นน้ี
การคน หาแบบนไ้ี มค อ ยนิยมใชก นั มากเทาไร ทง้ั นีก้ ็เพราะวาจะใชเวลาในการคนหามาก ถา ขอ มลู ท่ี
ตองการคน หาอยูดา นหลังสุดของ array ยิ่งถา array เก็บขอมูลไวเ ยอะการคนหาก็จะใชเวลามาก
ยงิ่ ข้นึ
4.5.2 การคนหาแบบไบนารี (Binary search)
การคนหาในรูปแบบของ binary search จะทําการแบง ขอมลู ทงั้ หมดออกเปนสองสวนทกุ ครง้ั ทม่ี ีการ
เปรยี บเทียบขอมลู ทตี่ องการคนหา (key) การคน หาเริ่มตน ดว ยการเปรยี บเทยี บ key กบั ขอ มูล ณ
ตาํ แหนง ทีอ่ ยูกง่ึ กลางของ array ถา key มีคา นอ ยกวา ขอ มลู ณ ตําแหนง นีก้ ารคน หาก็ยา ยไปคน
ทางซายของขอ มูลน้ี และจะคนทางขวาถา key มีคามากกวา ขอ มลู ที่ตําแหนงน้ี การคน หาจะดําเนิน
ไปจนกวาจะคนพบ นั่นก็คอื key มคี าเทากบั ขอ มูลท่ีตําแหนงนั้น หรอื ไมก ย็ ตุ ิการคนถา ไมมีขอมูลน้นั
ใน array
ส่ิงที่สาํ คัญในการคนหาแบบนกี้ ็คือ ขอมูลจะตองมกี ารจดั เก็บแบบจัดเรยี งจากนอยไปหามาก เพราะ
ถาไมอ ยูใ นรูปแบบนแ้ี ลวการคน หาก็จะทาํ ไมได
วิธีการคนหาดวย binary search จะลดจํานวนครั้งของการเปรยี บเทียบลงไปทลี ะคร่ึง ทาํ ใหการ
คน หาใชเ วลานอยลง ตัวอยา งเชน การคนหาใน array ท่ีมขี อมลู เทากบั 1024 ตวั จะใชก าร
เปรียบเทียบเพียง 10 ครัง้ ครง้ั แรกลดลงเหลอื 512 ครั้งท่สี องเหลือ 256 และครั้งตอ ๆ ไปเหลือ
128 64 32 16 8 4 2 และ 1 จะเห็นวาลดลงมาก ซงึ่ เปนจดุ แขง็ ของการคน หาของ binary search
โปรแกรม BinSearch.java แสดงการคน หาดว ยการใช binary search
1: /**
130
บทท่ี 4: Array และ String
2: Searching for an item using binary search
3: */
4: intro. to Java (FEU.faa)
5: import javax.swing.JOptionPane;
6:
7: class BinSearch {
8: public static void main(String[] args) {
9: int[] list = new int[1024];
10: int number;
11:
12: //populate array with random ints
13: for(int i = 0; i < 1024; i++) {
14: number = (int)(Math.random() * 1024 + 1);
15: list[i] = number;
16: }
17:
18: //get input from user
19: String input;
20: int key;
21: input = JOptionPane.showInputDialog("What number? ");
22: key = Integer.parseInt(input);
23:
24: int low = 0; //lower index
25: int high = list.length - 1; //upper index
26: int middle; //pivot
27: boolean found = false;
28:
29: while(low <= high) {
30: //find pivot
31: middle = (low + high) / 2;
32: //found key - exit the loop
33: if(key == list[middle]) {
34: found = true;
35: break;
36: }
37: //key is in lower half
38: else if(key < list[middle])
39: high = middle - 1;
40: //key is in upper half
41: else
42: low = middle + 1;
43: }
44:
45: String result = "";
46: if(!found)
47: result += key + " is not in the list.";
48: else
49: result += "Found " + key + " in the list";
50:
51: //display result
52: JOptionPane.showMessageDialog(null,
53: result, "Binary search",
54: JOptionPane.INFORMATION_MESSAGE);
55:
56: System.exit(0);
57: }
58: }
โปรแกรม BinSearch.java ของเราเรมิ่ ตนดวยการกาํ หนดให array list มขี อมลู เปนจาํ นวนเทากับ 10
ตวั และกาํ หนดใหขอมูลที่ตอ งการคน หา (key) มาจากการสุม หลังจากนัน้ กก็ ําหนดให index หวั
(low) และทา ย (high) ของ array เปน 0 และ list.length – 1 ตามลาํ ดบั เราจะใช while loop เปน
ตัวเขา หาขอ มูลใน array list ของเราดวยการเปรยี บเทียบคา ของ low กับ high ซึ่งถา เมื่อใดกต็ ามที่
คา ของ low มากกวาหรือเทากับ high กห็ มายความวาการคนหาของเราไมป ระสพผลสําเรจ็ คือไมมี
ขอ มูลนน้ั อยใู น list เราก็จะยตุ ิการทํางานทันที เราหาขอมูลทอ่ี ยตู รงกลางดว ย
middle = (low + high) / 2;
และเปรียบเทียบการคน หาที่ประสพผลสาํ เร็จดวยประโยค
if(key == list[middle]) {
found = true;
131
เร่ิมตน การเขียนโปรแกรมดว ย Java
break;
}
เราจะเปรียบเทียบและแบงขอมลู ออกเปน สองสว นดว ย intro. to Java (FEU.faa)
else if(key < list[middle])
high = middle - 1;
else
low = middle + 1;
เราจะยา ย index ท่อี ยหู ลังสดุ ใหเ ปน middle – 1 ถา ขอมูลที่เปน key นอ ยกวาขอมูลทอ่ี ยู ณ
ตาํ แหนง middle และจะยาย low ไปอยูท ่ี middle + 1 ถา key มคี ามากกวา ขอมูล ณ ตําแหนง
middle เราจะทําไปจนกวาจะเจอขอมูลท่ีตําแหนง middle หรอื ไมก ็หยดุ การทาํ งานโดยไมพ บขอมูล
ทตี่ อ งการคน หาเลย
4.6 การจัดเรยี งลําดับ (sort) ขอมูลใน array
มีวิธกี ารหลากหลายวธิ ีทส่ี ามารถนํามาใชใ นการจดั เรยี งขอ มลู ใน array แตเนือ่ งจากวาเรายังตอง
ศึกษาถงึ สวนประกอบอ่ืน ๆ ของ Java กอนท่ีเราจะนาํ เอาวิธีการเหลา น้นั มาใชไ ด ซ่ึงหนงั สือสว นมาก
กจ็ ะนําเอาวิธีการจัดเรียงขอมูลไปไวใ นวชิ าโครงสรางขอมูล ดังน้ันเราจะพูดถงึ เฉพาะการนาํ เอา
method การ sort ที่ Java มีใหมาใชโ ดยตรงเพอื่ ใหก ารทาํ งานเปน ไปไดร วดเร็วยง่ิ ขึน้
เราเพยี งแตสง array ท่เี ราตอ งการ sort ไปให method sort() ที่ Java มีให ดังนี้
Arrays.sort(list)
โดยท่ี list เปน array ที่เราตองการ sort โปรแกรม Sort.java แสดงวิธีการเรียกใช sort จาก class
Arrays
1: /**
2: Using sort routine from class Arrays
3: */
4:
5: import javax.swing.JOptionPane;
6: import java.util.Arrays;
7: import java.awt.Font;
8:
9: class Sort {
10: public static void main(String[] args) {
11: int[] list = new int[100]; //array with 100 ints
12: int i;
13:
14: //populate list with random ints
15: for(i = 0; i < 100; i++)
16: list[i] = (int)(Math.random() * 100 + 1);
17:
18: //display result
19: String output = "";
20: String result = "";
21: for(i = 0; i < list.length; i++) {
22: if(i != 0 && i % 10 == 0)
23: result += "\n";
24: else
25: output = String.format("%4d", list[i]);
26: result += output;
27: }
28: JOptionPane.showMessageDialog(null,
29: result, "Data before sorting",
30: JOptionPane.INFORMATION_MESSAGE);
31:
32: Arrays.sort(list); //calling sort from class Arrays
33:
34: //display again
35: output = "";
36: result = "";
37: for(i = 0; i < list.length; i++) {
38: if(i != 0 && i % 10 == 0)
132
บทท่ี 4: Array และ String intro. to Java (FEU.faa)
39: result += "\n";
40: else
41: output = String.format("%4d", list[i]);
42: result += output;
43: }
44: JOptionPane.showMessageDialog(null,
45: result, "After sorting by Java",
46: JOptionPane.INFORMATION_MESSAGE);
47: }
48: }
ยังมี method อีกหลายตวั ใน class Arrays ทีเ่ ราสามารถเรียกใชได ทงั้ นกี้ ็ตอ งดวู า เรากําลงั ทําอะไร
อยู ในทีน่ ี้จะขอพูดอกี เพยี ง method เดยี วคือ binarySearch() เพราะวา เราไดพ ูดถงึ วิธกี ารเขยี น
code ของ binary search มากอนหนานแ้ี ลว โปรแกรม BinarySearch.java แสดงถึงวิธกี ารเรียกใช
method binarySearch() ที่วาน้ี
1: /**
2: Using search routine from class Arrays
3: Caution: data must already be sorted
4: */
5:
6: import java.util.Arrays;
7: import static java.lang.System.out;
8:
9: class BinarySearch {
10: public static void main(String[] args) {
11: //create list with 10 items
12: int[] list = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
13:
14: //random key to search for
15: int key = (int)(Math.random() * 10 + 1);
16:
17: //calling binary search from class Arrays
18: int found = Arrays.binarySearch(list, key);
19:
20: //display result to screen
21: if(found >= 0)
22: out.printf("Found %d at location: %d%n", key, found);
23: else
24: out.printf(key + " is not in the list!");
25: }
26: }
เราเรยี ก method binarySearch() ดว ย parameter 2 ตัวคอื (1) array ทีม่ ขี อมลู อยู – ในท่นี คี้ ือ list
และ (2) ขอ มูลทต่ี อ งการคน หา – ซ่ึงกค็ อื key ในโปรแกรมดา นบนน้ี ประโยค
int found = Arrays.binarySearch(list, key)
ถาขอมูลที่ตอ งการคนหาอยใู น list การเรยี ก method binarySearch() กจ็ ะไดค า ของ index ที่
ขอมลู นนั้ อยูสง กลับมายังตวั แปร found แตถ า หาไมเ จอคาทีส่ ง กลบั จะมีคา นอ ยกวา 0 เสมอ ดังน้ัน
การแสดงผลจงึ ตองเปรยี บเทียบคา ของ found กับคาของ 0 และเม่ือทดลอง run ดูผลลพั ธท ี่ไดคอื
Found 5 at location: 4
4.7 การสราง array ท่มี ขี อมลู เปน array (Array of arrays)
เราไดใ ช array ท่มี ขี อ มูลเปน primitive type จากตวั อยา งกอนหนาน้ีหลาย ๆ ตวั อยาง เรามาลองดู
การสราง array ที่มีขอ มูลเปน array ดู เราจะเรมิ่ ตนดว ยการประกาศ ดงั นี้
int[][] table = new int[5][5];
ซึ่งหมายถึงการประกาศใหต วั แปร table เปน array ทมี่ ขี อ มลู 5 ตวั โดยทแี่ ตละตัวนนั้ เปน array ท่ี
เกบ็ ขอมูลท่เี ปน int อยู 5 ตัว เราจะใช [][] สองตัวเปนตวั บอกให Java รูวา ตวั แปรตัวน้ีคือ array ท่ี
ใชเ ก็บ array โดยทั่วไปเรามกั จะเรยี ก array ในลักษณะนว้ี า array 2 มติ ิ ภาพที่ 4-2 แสดงถงึ เนื้อที่
ของ array table
133
เริ่มตน การเขยี นโปรแกรมดว ย Java
ชื่อของ array index ของขอ มูลในแตละแถว intro. to Java (FEU.faa)
และ ตําแหนง [0] [1] [2] [3] [4]
ของขอ มูลแตละ
ตวั (index)
table[0]
table[1]
table[2]
table[3]
table[4]
int [] [] table = new int [5] [5];
ภาพที่ 4-2 การสรา ง array ที่เกบ็ array (array 2 มติ ิ)
โปรแกรม TwoDArray.java ทเี่ ห็นดานลา งนแี้ สดงการใช array 2 มติ ิ โดยกําหนดใหมีขนาด 5 x 5
และกาํ หนดใหข อ มูลมีคา อยรู ะหวาง 1 ถงึ 10 ดว ยการสุมจาก random()
ความยาวหรอื ขนาดของ twoDArray หาไดจากคา คงที่ท่เี ก็บไว length เชน เดยี วกนั กับ array 1 มติ ิ
สวนขนาดของขอ มลู ท่ีอยใู นแตละแถวหาไดจ ากคาคงท่ีในแถวนั้น เชน
twoDArray[i].length
โดยที่ i เปน คา ของแถวนนั้ ๆ ใน twoDArray
1: /**
2: Two dimensional array
3: */
4:
5: import static java.lang.System.out;
6:
7: class TwoDArray {
8: public static void main(String[] args) {
9: int[][] twoDArray = new int[5][5];
10:
11: //populate array with random ints
12: for(int i = 0; i < twoDArray.length; i++) {
13: for(int j = 0; j < twoDArray[i].length; j++) {
14: twoDArray[i][j] = (int)(Math.random() * 10 + 1);
15: }
16: }
17:
18: //display content to screen
19: for(int i = 0; i < twoDArray.length; i++) {
20: for(int j = 0; j < twoDArray[i].length; j++) {
21: out.printf("%4d", twoDArray[i][j]);
22: }
23: out.printf("%n");
24:
25: }
26: }
27: }
134
บทท่ี 4: Array และ String
ผลลัพธของการ run โปรแกรม TwoDArray.java คอื
1 10 8 4 4 intro. to Java (FEU.faa)
7 6 10 4 2
42799
17889
74893
เรามาดูโปรแกรมตวั อยา งอีกตวั หนง่ึ ท่ีประกาศและกาํ หนดคาใหกับ array 2 มิตดิ ว ยการกาํ หนดแบบ
อตั โนมตั จิ าก Java เอง
1: /**
2: Declaring and initializing two dimensional array
3: */
4:
5: import static java.lang.System.out;
6:
7: class Array10 {
8: public static void main(String[] args) {
9: //declare 2-D array with specific data
10: int[][] twoDArray = { {1, 2, 3},
11: {5, 6, 8},
12: {7, 4, 6},
13: {4, 8, 9} };
14:
15: //display content to screen
16: for(int i = 0; i < twoDArray.length; i++) {
17: for(int j = 0; j < twoDArray[i].length; j++)
18: out.printf("%4d", twoDArray[i][j]);
19: out.printf("%n");
20: }
21:
22: }
23: }
เรากาํ หนดให twoDArray เปน array 2 มิติท่ีมจี าํ นวนแถวเทากบั 4 และจํานวนขอมลู ในแตละแถว
เทา กบั 3 โดยการกาํ หนดนนั้ เราตองใสข อมูลในแตล ะแถวในเคร่ืองหมาย {} และแบง ขอ มลู ท่ีอยแู ถว
ในแตล ะแถวดว ยเคร่อื งหมาย , ดังนี้
int[][] twoDArray = { {1, 2, 3}, /* แถว 0 */
{5, 6, 8}, /* แถว 1 */
{7, 4, 6}, /* แถว 2 */
/* แถว 3 */
{4, 8, 9}
};
เราสามารถทจี่ ะใหขอมลู อยูใ นบรรทัดเดยี วกันได เชน
int[][] twoDArray = {{1, 2, 3}, {5, 6, 8}, {7, 4, 6}, {4, 8, 9}};
หลังจาก run โปรแกรมแลว ผลลพั ธท ี่ไดค ือ
123
568
746
489
โปรแกรมตัวอยางท่ีจะแสดงใหดูตอไปนเี้ ปนการใช array 2 มติ ิในการคํานวณหาดอกเบีย้ ทบตน
(compound interests) ทีเ่ ราไดท ําไวใ นบทที่ 3 แตเ ราจะเพม่ิ ลูกเลนใหกบั การแสดงผลดว ยการ
เรยี กใช class JTextArea, JScrollPane, และ class Font
การคาํ นวณหาดอกเบยี้ ทบตนนัน้ เราสามารถใชส ูตรหาไดเ ลย (เชน ทที่ ําในบททีส่ าม) แตเราจะใช
วธิ ีการคาํ นวณแบบงาย ๆ ท่ีใช loop เขา มาชว ย ดังทีไ่ ดแ สดงไวในโปรแกรม
CompoundInterest.java น้ี
1: /**
2: Calculate compound interests using 2D array
135
เร่มิ ตนการเขยี นโปรแกรมดวย Java intro. to Java (FEU.faa)
3: Previously calculated using: a = p(1 + r)^n
4: see program Interests.java in chapter 3
5: */
6:
7: import javax.swing.JOptionPane;
8: import javax.swing.JTextArea;
9: import javax.swing.JScrollPane;
10: import java.awt.Font;
11:
12: class CompoundInterest {
13: public static void main(String[] args) {
14: final double START_RATE = 20;
15: final int RATES = 6;
16: final int YEARS = 10;
17:
18: //set interest rates to 20 ... 25%
19: double []interestRate = new double[RATES];
20: for(int i = 0; i < interestRate.length; i++)
21: interestRate[i] = (START_RATE + i) / 100.0;
22:
23: //set initial balances to 10000
24: double [][]balances = new double[YEARS][RATES];
25: for(int i = 0; i < balances[0].length; i++)
26: balances[0][i] = 10000;
27:
28: //calculate interest
29: for(int i = 1; i < balances.length; i++) {
30: for(int j = 0; j < balances[i].length; j++) {
31: double oldBalance = balances[i - 1][j];
32: double interest = oldBalance * interestRate[j];
33: balances[i][j] = oldBalance + interest;
34: }
35: }
36: //setup header: Year follows by interest rate
37: String output = String.format("%4s", "Year");
38: for(int i = 0; i < interestRate.length; i++)
39: output += String.format("%12.2f", 100*interestRate[i]);
40: output += "\n";
41:
42: //setup interest earned in tabular format
43: int y = 1;
44: for(double[] row : balances) {
45: output += String.format("%4d", y++);
46: for(double b : row)
47: output += String.format("%,12.2f", b);
48: output += "\n";
49: }
50: //display result
51: JTextArea area = new JTextArea(10, 30);
52: JScrollPane pane = new JScrollPane(area);
53: area.setFont(new Font("Courier", Font.PLAIN, 12));
54: area.append(output);
55: JOptionPane.showMessageDialog(null, pane,
56: "Compound Interest", JOptionPane.INFORMATION_MESSAGE);
57: }
58: }
กอนทีเ่ ราจะอธิบายถึงวิธกี ารแสดงผลในรปู แบบใหมน้ี เราจะอธบิ ายถงึ การใช array 2 มิติในการเก็บ
ขอ มูลกอ น ซึง่ ในสว นทเี่ ราเนนก็คือ array balances ท่ีไดป ระกาศไวใ นบรรทดั ที่ 24 พรอมกันนเ้ี ราก็
กําหนดใหเ งินเริ่มตน ของเรามีคาเปน 10000 โปรแกรมของเราจะคาํ นวณหาดอกเบี้ยภายในระยะเวลา
10 ป และจะใชอัตราดอกเบ้ยี เริม่ ตนท่ี 20% ไปจนถงึ 25%
หลังจากทเี่ ราไดก าํ หนดคา ของเงนิ เรม่ิ ตนดวย array balances และ array interest ท่ใี ชเ กบ็ อตั รา
ดอกเบ้ียแลว เราก็ทําการคาํ นวณหาดอกเบ้ยี ดว ยการใช for/loop สองตวั (บรรทัดที่ 29 ถงึ 35) โดย
ที่ for-i/loop จะเปนการคาํ นวณไปแนวตัง้ ซง่ึ จะทําทัง้ หมด 10 ครง้ั สวน for-j/loop จะเปน การ
คาํ นวณในแนวนอนจํานวนท้ังหมด 6 ครง้ั
ผลลพั ธท ี่เราไดจากการ run โปรแกรม คือ
136
บทที่ 4: Array และ String intro. to Java (FEU.faa)
ผลลพั ธท ี่เราไดม ี scroll bar ไวใหเราถา หากวาขอ มูลที่อยใู นหนาตา งมเี กินขอบเขตของตวั หนา ตาง
เอง วิธีการแสดงผลแบบน้จี ะเรียกใช class หลัก ๆ อยสู องตัวคือ JTextArea และ JScrollPane โดย
ข้ันตอนแรกที่เราทํากค็ อื กาํ หนดใหม กี ารใช JTextArea ท่ีมีขนาดเทากบั 10 แถว ๆ ละ 30 column
หลงั จากนั้นเราก็กาํ หนดใหม กี ารใช scroller ใน JTextArea ทีเ่ ราสรางขึ้น พรอ มกนั นีเ้ ราก็ทําการ
กําหนดให font ทีอ่ ยใู น JTextArea ของเราเปน Courier ขนาด 12 point ซง่ึ เมอื่ ไดก ําหนดเรยี บรอย
แลวเราก็ทาํ การนาํ ขอมลู ทีอ่ ยใู นตวั แปร output เขาไปเกบ็ ไวใน JTextArea ทเี่ ราไดเ ตรียมไว และ
เรากส็ ง JScrollPane ของเราไปให showMessageDialog() เหมอื นดังท่เี ราไดเ คยทาํ มากอนหนาน้ี
JTextArea area = new JTextArea(10, 30);
JScrollPane pane = new JScrollPane(area);
area.setFont(new Font("Courier", Font.PLAIN, 12));
area.append(output);
JOptionPane.showMessageDialog(null, pane,
"Compound Interest", JOptionPane.INFORMATION_MESSAGE);
ในการนําขอ มลู ออกจาก array 2 มติ เิ พือ่ เตรยี มที่จะสงใหกับ showMessageDialog() น้ันเราใช for-
in/loop เปน ตัวชว ยในการเดนิ เขา หา โดยท่ี for-in/loop ตวั แรกเปน การเดินเขา หาแถว สว น for-
in/loop ตัวทสี่ องเปนการเดนิ เขาขอมูลในแถวนัน้ ๆ (ดู code ในบรรทดั ที่ 43 ถึง 49)
ถาหากเราไมตอ งการท่ีจะใช scrollbar ในการแสดงผลของเรา เราก็ทาํ ไดด ว ยการสง JTextArea ไป
ให showMessageDialog() แทน JScrollPane ดงั เชน ตวั อยา งทแี่ สดงใหดนู ้ี
JTextArea area = new JTextArea(10, 30);
area.setFont(new Font("Courier", Font.PLAIN, 12));
area.append(output);
JOptionPane.showMessageDialog(null, area,
"Compound Interest", JOptionPane.INFORMATION_MESSAGE);
ผลลัพธท ่ีเราไดก จ็ ะเปน
137
เรมิ่ ตน การเขียนโปรแกรมดวย Java intro. to Java (FEU.faa)
ผอู า นควรสังเกตวา showMessageDialog() ขยายขนาดของตวั เองออกเพื่อรองรับผลลพั ธท ไ่ี ดจ าก
การคาํ นวณ ทั้งนีแ้ ละทง้ั นน้ั ผูอานก็คงตองเลอื กเอาเองวา การแสดงผลแบบไหนเหมาะสมกับงานท่ี
ทําอยู
4.7.1 การใช array ทม่ี ีจํานวนของขอ มูลในแตละแถวไมเทา กนั
เราสามารถทีจ่ ะกาํ หนดใหข อ มูลในแตละแถวของ array มจี ํานวนไมเ ทากันได ดงั ตวั อยา งดานลางนี้
double [][] list = new double[5][];
ซ่งึ เปน การประกาศ array 2 มติ ิทม่ี ีจํานวนแถวเทา กับ 5 แตจ าํ นวนของขอมูลในแตล ะแถวยังไมไ ดถกู
กาํ หนด เราอาจกําหนดใหขอ มลู ในแถว 0 มจี าํ นวนเทากบั 4 และขอมลู ในแถว 4 มจี ํานวนทา กับ 10
เปน ตน ดังน้ี
list[0] = new double[4];
list[4] = new double[10];
สวนขอมูลในแถวที่เหลอื อยูกแ็ ลวแตว าเราอยากทีจ่ ะใหม ขี อ มูลก่ีตวั หรือเราอาจกําหนดใหข อมูลใน
แตล ะแถวมจี าํ นวนเทากบั คาท่เี พ่ิมขึน้ ตามคา ของแถว (index) เชน
int m = 0;
while(m < list.length) {
list[m] = new double[m + 1];
m++;
}
โปรแกรม Array11.java สรา ง array 2 มติ ิทีม่ ีขอ มลู ในแตล ะแถวเทา กับคา ของ index ในแถวนนั้ ๆ
1: /**
2: Array containing rows with different sizes
3: */
4:
5: import static java.lang.System.out;
6:
7: class Array11 {
8: public static void main(String[] args) {
9: //array with five rows
10: double [][]list = new double[5][];
11:
12: //allocate space for each row
13: int m = 0;
14: while(m < list.length) {
15: list[m] = new double[m + 1];
16: m++;
17: }
18:
19: //display initial content of array
20: for(int i = 0; i < list.length; i++) {
21: for(int j = 0; j < list[i].length; j++)
22: out.printf("%6.2f", list[i][j]);
138
บทที่ 4: Array และ String
23: out.println(); intro. to Java (FEU.faa)
24: }
25: }
26: }
เมอื่ run ดูผลลพั ธท่ีไดค ือ
0.00 0.00 0.00 0.00 0.00
0.00 0.00 0.00 0.00
0.00 0.00
0.00
0.00
0.00
0.00
การกําหนดขนาดของ array แบบนที้ ําใหก ารใชเ น้ือท่ีในการเกบ็ ขอมูลในแตละแถวมปี ระสิทธภิ าพ
มากข้นึ ทัง้ นก้ี เ็ พราะวาเราใชเฉพาะเนือ้ ที่ที่จําเปน ตองใชเทานนั้ ถาเราใชก ารกําหนดแบบเกาเราตอง
ใชห นว ยความจําเทากับ 8 x 25 = 200 byte แตถ าเราใชก ารกาํ หนดตามเทาที่ใช เราก็จะใช
หนว ยความจาํ เพียงแค 8 x 15 = 120 byte
การสรา ง array ทม่ี ีความจขุ องขอ มูลในแตล ะแถวไมเทากนั เออื้ อาํ นวยความสะดวกในการจองเนอ้ื ที่
ทาํ ใหการใชหนวยความจํามีประสิทธภิ าพมากยง่ิ ขึน้ แตก ารทาํ งานจะตอ งมีการระมดั ระวงั เปนพิเศษ
เพราะจาํ นวนของขอมูลในแตล ะแถวมจี าํ นวนไมทากนั ผูอา นตองใชค วามละเอยี ดในการออกแบบ ถา
ตองการใช array แบบนี้
ตวั อยา งการใช Array of arrays ในการหาคา max คา min และคา เฉล่ีย
1: /**
2: Finding maximum and minimum in 2d-array
3: */
4:
5: import static java.lang.System.out;
6:
7: class ArrayOfArrays {
8: public static void main(String[] args) {
9: //inititial scores
10: int [][]score = { {45, 87, 68, 57},
11: {98, 70, 58, 69},
12: {85, 42, 68, 82} };
13: double average; //average of scores
14: int max, min, total = 0;//maximum, minimum, and total
15: int count = 0; //total scores
16:
17: max = score[0][0]; //assuming max score is at [0][0]
18: min = score[0][0]; //assuming min score is at [0][0]
19:
20: //looping through rows
21: for(int i = 0; i < score.length; i++) {
22: //looping through columns
23: for(int j = 0; j < score[i].length; j++) {
24: if(score[i][j] > max) //find max score
25: max = score[i][j];
26: if(score[i][j] < min) //find min score
27: min = score[i][j];
28: total += score[i][j]; //calculate total
29: count++; //number of scores
30: }
31: }
32:
33: //calculate average of scores
34: average = (double)total / count;
35:
36: out.println("Maximum score is " + max);
37: out.println("Minimum score is " + min);
38: out.printf("Average score is %4.2f", average);
39: }
40: }
โปรแกรม ArrayOfArrays.java กําหนดให score เปน array ท่ีเกบ็ ขอมลู เปน จํานวนเทา กับ 3 แถว
แถวละ 4 ตัว เราจะหา score ทีเ่ ล็กทีส่ ุด score ทีใ่ หญที่สุด รวมไปถงึ การคาํ นวณหาคาเฉลย่ี ของ
139
เริ่มตนการเขยี นโปรแกรมดว ย Java intro. to Java (FEU.faa)
score ทงั้ หมด เราใช for – loop 2 ตัวในการเขา หา array ของเราเหมอื นเดิม พรอ มทง้ั ตรวจสอบวา
score ตัวไหนเปน max และ score ตวั ไหนเปน min ดวยการกําหนดใหท ง้ั สองตัวแปรมีคาเปน ขอมลู
ตวั แรกสุดทีอ่ ยูใ น array และจะทําการเปรียบเทยี บขอ มลู ณ ตําแหนง ท้ังหมดใน array กบั ขอมลู นี้
ประโยค
if(score[i][j] > max)
max = score[i][j];
จะเปลยี่ นคาของ max ใหม คี าเทากบั score[i][j] ถา ขอ มูลทตี่ ําแหนงนมี้ ากกวา คาของ max และ
ประโยค
if(score[i][j] < min)
min = score[i][j];
จะเปลีย่ นคาของ min ใหม ีคา เทากับ score[i][j] ถาขอ มลู ทต่ี ําแหนงน้นี อ ยกวา คาของ min วธิ กี าร
หาคา ของ max และ min แบบน้ีสามารถนําไปใชไ ดกับการหาคา max และ min โดยทวั่ ไปไดโดย
ไมตองสนใจวา ขอมูลทอ่ี ยูภ ายใน array จะมี range อยูชวงไหน ทัง้ น้ีเพราะเราใชขอมูลตัวแรกสุด
เปนตัวตรวจสอบกอ น ทําใหก ารหาคาของทงั้ max และ min เปน ไปไดโ ดยไมตองกาํ หนดคา ใหกบั
ตวั แปร max หรือ min ใด ๆ ท้ังสน้ิ (ถา เราไมต อ งการตรวจสอบเอง เราก็สามารถท่ีจะเรยี กใช
method max() และ min() ทม่ี อี ยูใน class Math ได – ดใู นบทกอน ๆ) ในสวนของการหาคาเฉลย่ี ก็
เหมือนกับทเ่ี ราไดเ คยทาํ มาแลวกอ นหนานี้
การใช array of arrays น้ันก็เหมือนกับท่ีเราใชต าราง หรอื table ในการเก็บขอ มลู ตา ง ๆ หนังสือ
หลาย ๆ เลมเรยี ก array of arrays ที่มีแค row และ column วา array 2 มติ ิ (two dimensional
array) สว น array of arrays ท่มี ีขอ มลู เปน array อีกเราก็มักจะเรยี กวา array 3 มิติ เปน ดงั นี้ทุกคร้งั
ทีม่ กี ารเพม่ิ มิตใิ หก บั array แตก ารมองเห็นหรือการใชก ็คงมนี อย ถาหากวา จํานวนมติ ทิ ่ใี ชมมี ากกวา
3 มิติ เพราะวาคนเราชนิ กบั การมองเห็นแบบ 3 มิติตลอดเวลา (เราจะท้ิงใหผูอา นศกึ ษาในเรือ่ งของ
array 3 มติ เิ อง)
4.8 String
การใช string น้นั สามารถทาํ ไดหลาย ๆ วธิ ี และวิธีแรกท่ีเราจะทําความรูจกั นั้นเปนการใช array เปน
หลักในการทํางานกับ string นน้ั ๆ เราคงไมสามารถท่ีจะเรียก string ในลกั ษณะนไ้ี ดเตม็ ปากเต็มคํา
มากนกั เพราะวาโดยความเปน จรงิ แลว array ที่เราใชในการทาํ งานทเ่ี กีย่ วขอ งกบั String นัน้ ไมใช
string โดยตรงแตเ ปน array ทีเ่ ก็บ char หลาย ๆ ตวั ไว หรอื ท่ีเรียกกันวา array of characters ซ่งึ
หนงั สือหลาย ๆ เลมก็มกั จะเรยี ก string วา array of characters เราจะตรวจสอบวิธกี ารใช string
แบบน้ีพอสงั เขป แลว เราจะกลับมาพูดถงึ String ของ Java อยางละเอียดอีกทีหนึ่ง
4.8.1 Array of characters
การประกาศ string แบบนที้ าํ ไดงา ย ๆ เหมือนกับที่เราประกาศใช array ท่ีเก็บขอมูลชนิดอื่น
เพียงแตเ ราเปล่ียนให array เก็บ char แทนเทา นน้ั เชน
char [] string = new char[20];
การประกาศดา นบนนี้เปนการสราง array ท่ใี ชเ กบ็ char จํานวนเทากับ 20 ตวั โปรแกรมตัวอยา ง
ดานลา งแสดงการใช array of characters
1: /**
2: Array of characters
3: */
4:
5: import static java.lang.System.out;
6:
7: class ArrayOfChars {
8: public static void main(String[] args) {
9: //declare array of char
10: char[] string = new char[26];
11: int i = 0;
12:
13: //populate string with characters a to z
14: for(char c = 'a'; c <= 'z'; c++, i++) {
15: string[i] = c;
140
บทที่ 4: Array และ String intro. to Java (FEU.faa)
16: }
17:
18: //print all characters to screen
19: for(char ch : string) {
20: //convert to upper case if it's a vow
21: switch (ch) {
22: case 'a' : case 'e' :
23: case 'i' : case 'o' : case 'u':
24: ch = Character.toUpperCase(ch);
25: }
26: out.printf("%2c", ch);
27: }
28: System.out.println();
29: }
30: }
โปรแกรม ArrayOfChars.java เร่ิมตนดว ยการสราง array of chars จาํ นวน 27 ตัวจากประโยค
char[] string = new char[26];
หลงั จากน้ันกใ็ ช for/loop ในการกาํ หนดคาใหก บั ทกุ ๆ ตําแหนง ของ str ดว ยการใช char เปน
index ของ loop เนื่องจากวา การเพ่ิมคา ใหก ับ char นั้นทีจ่ ริงแลว เปน การเพ่มิ คาใหกับตัวเลขทเี่ ปน
ตวั แทนของตัวอักษรนน้ั ๆ เชน ถา เรากําหนดให char c = 'f' การเพมิ่ คาใหก ับ c หน่งึ ครงั้ จะทําให c
มีคาเปน 'g' ซ่งึ เปนตัวอักษรท่ีอยถู ัดไปในตาราง ASCII เพราะฉะนัน้ การใช for/loop นก้ี ท็ ําใหเ กดิ
การกาํ หนดคา ใหก ับ string ทุกตําแหนง
for(char c = 'a'; c <= 'z'; c++) {
str[i] = c;
i++;
}
ในการแสดงผลของขอมลู ทีอ่ ยูใน string น้ันเราไดเ พิ่ม code สําหรบั การตรวจสอบวาตวั อักษรท่ีเรา
จะแสดงนัน้ เปน สระหรือไม ซงึ่ ถา เปน เรากจ็ ะเปลย่ี นตวั อักษรนนั้ ใหเปนตวั ใหญ ดงั ที่เห็นในผลลัพธ
ของการ run นี้
AbcdEfghIjklmnOpqrstUvwxyz
การใช array of characters น้นั ไมคอยจะสะดวกมากนัก ทง้ั นีเ้ พราะเปน การทาํ งานที่เก่ียวกับ array
เราอยากทจี่ ะมี string จรงิ ๆ ท่ีเราสามารถทจ่ี ะทาํ กระบวนการตา ง ๆ ได เชน บวก string 2 ตัวเขา
ดวยกนั หรือตรวจสอบความเทากนั ความเหมอื นกนั ของ string อยางนี้เปนตน และ Java กม็ ี class
String ใหเราเรียกใชง านทเ่ี กย่ี วขอ งกบั string โดยตรง
4.8.2 String ใน Java
String ใน Java นั้นเปน object ดังน้ันเราจงึ จําเปนตอ งเรยี กใช class String ในการสรา ง string เพอ่ื
การใชง านของเรา เชน เราอาจตอ งการเกบ็ ช่ือของ user ไวใ นโปรแกรม หรือสงขอ ความที่เปน
string ไปให user อยา งน้เี ปนตน
การประกาศใช String กไ็ มย าก ซง่ึ ทําไดด ังน้ี
String str = new String("Java is fun");
หรือแบบนี้
String str = "Java is fun";
โดยเฉพาะการประกาศในประโยคทส่ี องน้ี มีผลเทากับประโยค 2 ประโยคตอ ไปนี้
char[] str = {'J', 'a', 'v', 'a', ' ', 'i', 's', ' ', 'f', 'u', 'n'};
String str = new String(str);
จะเห็นไดว า string กค็ ือ array of chars นั่นเอง บางครงั้ การประกาศตัวแปร string โดยทไ่ี มม ีการ
กําหนดคา ใหกบั string นน้ั เราก็ทาํ ไดด วยการประกาศเหมือนกับการประกาศตัวแปรชนดิ อ่ืน เชน
141
เรม่ิ ตน การเขียนโปรแกรมดว ย Java intro. to Java (FEU.faa)
String name;
ซึง่ มคี วามหมายวา ตวั แปร name เปน string ทไี่ มไ ดอา งถงึ คา ใด ๆ เลย และถาเราเรยี กใช string ที่
มีการประกาศแบบนีจ้ ะมี error เกิดขึน้ วิธกี ารแกไ ขน้นั เราตอ งกาํ หนดคา null ใหกับ string name
ดงั น้ี
String name = null;
ซึ่งบอกให Java รูว า string name ไมไ ดอ างถึงขอมลู ใด ๆ เลย เราสามารถท่ีจะอา งถงึ ขอ มูลใด ๆ ก็
ไดหลงั จากน้นั แตถา เราตอ งการท่ีจะสราง string ทีไ่ มม ขี อ มูลใด ๆ อยูเลยเราตองประกาศแบบนี้
String emptyString = "";
String name = null ตา งกบั String emptyStr = "" ตรงท่วี า เราสามารถใช String emptyStr ได
ทันทีท้งั น้ีเพราะวา การประกาศดงั กลาวไดกาํ หนดให emptyStr มคี าอยแู ตย ังไมม กี ารกาํ หนดใหมคี า
เปนกลุม ของตัวอกั ษรใด ๆ สว น name ไดถูกกําหนดใหช ้ีไปที่ null ซ่งึ เปนการบอกวา name ยงั
ไมไดช ี้ไปยัง object ใด ๆ (ซงึ่ ในบางคร้งั เราก็ไมรูวาเราจะกําหนดให string ชไี้ ปท่ี Object ใดแตรู
วาตอ งเปน string ทช่ี ี้ไปยงั object)
str1 HEL LO String str1 = "HELLO";
str2 ?? String str2 = null;
str3 String str3 = "";
ภาพที่ 4-3 การกําหนดคา ใหก บั String
ถาเราไดกําหนดคาให string เปน empty string เราสามารถทจ่ี ะใช method length() ในการหาคา
ความยาวของ empty string ได (ซง่ึ ตองเปน ศูนย เชน str3.length() จะมคี า เปนศนู ย และ
str1.length() จะมคี า เปน 5) สวน null string เราจะได error ทเี่ ปน NullPointerException แทน
ลองมาดโู ปรแกรมตวั อยา งการทํางานกบั string
1: /**
2: Simple string operations
3: */
4:
5: import static java.lang.System.out;
6:
7: class StringOps {
8: public static void main(String[] args) {
9: String first = "Java ";
10: String second = "Programming";
11: String third = null;
12: int percent = 100;
13:
14: third = first + second;
15: out.printf("%s is a %d fun!%n", third, percent);
16: }
17: }
142
บทที่ 4: Array และ String intro. to Java (FEU.faa)
โปรแกรม StringOps.java ประกาศตัวแปรทีเ่ ปน String 3 ตวั คือ first second และ third โดย
กําหนดให first มีคา เปน "Java " second มคี าเปน "Programming" และ third ไมมีคา อา งองิ ถึง
string ใด ๆ พรอมกนั นี้เราไดกําหนดใหต ัวแปร percent มีคาเปน 100 ประโยค
third = first + second;
ทําการรวม first และ second เขาดว ยกัน ซงึ่ ทาํ ให third มีคาเปน "Java Programming" และใน
ประโยคที่ทาํ การแสดงผลไปหนาจอนนั้ เราไดเพิ่มการแสดงผลคา ของตวั แปร percent และ string
คงทต่ี ัวอืน่ เขา ไปดวยเพือ่ ใหผ ลลัพธเปน
Java Programming is a 100% fun!
เราสามารถที่จะรวมคา ของตัวแปรอ่นื ทไ่ี มใช string เขา กบั string ไดดงั นี้ สมมตวิ าเราเพิม่ ตวั แปร
ตอไปนี้
String isa = " is a ";
String fun = "%fun!";
และเรารวม String และ int เขาดวยกนั ดว ยประโยค
third = first + second + isa + percent + fun;
เราก็จะไดผลลัพธเหมอื นกันกบั ทเ่ี ราไดทาํ กอ นหนา น้ี สาเหตทุ ที่ ําไดเ พราะ Java จะเปลย่ี น int ให
เปน string กอนท่จี ะรวมเอา string ท้งั หมดเขา ดวยกัน
Java ไดก าํ หนดให String เปน immutable object ซึ่งหมายความวาเมื่อไดก ําหนดคาใหก ับ String
แลว เราไมส ามารถจะเปลย่ี นคา ของ String น้นั ๆ ได ลองกลับมาดภู าพประกอบการประมวลผลของ
string ในโปรแกรม StringOps.java เชน ประโยคในบรรทัดที่ 9 - 10
Stack memory Heap memory
first Java
second Programming
... ??
third Java Programming
third = first + second;
ภาพที่ 4-4 ขอมูลทเี่ กดิ ขน้ึ จากการกําหนดคาให string
ประโยคการประกาศตวั แปร และกาํ หนดคา ใหก บั string ทั้งสามตวั ตอนแรกน้นั ไมม ีอะไรยุง ยาก หรือ
ซับซอ น แตพ อเรากําหนดคา ใหกับ string third น้ันสิ่งทเ่ี กดิ ขึน้ คือ Java จะจดั สรรเนื้อที่ใหกบั
string Æ "Java Programming" ใน heap memory หลังจากนั้นจงึ กาํ หนดให third อางถงึ string
ทว่ี านี้ และสมมติวาเราเขยี นประโยคใหมด ังนี้
second = third;
143
เร่ิมตนการเขยี นโปรแกรมดว ย Java intro. to Java (FEU.faa)
สงิ่ ทเ่ี กดิ ขน้ึ กค็ ือ second จะชี้ (หรือ อา งถึง) ไปที่ที่ third ชอ้ี ยูท ําใหเ ราไมสามารถเขาหาขอ มูลเดิม
ของ second ได
4.8.3 การเปรียบเทียบ String
เราไมสามารถทจ่ี ะเปรยี บเทยี บ string 2 ตวั ดว ยการใช == ไดเ หมอื นกบั ทเี่ ราทํากับตวั แปรที่เปน
primitive type ได เชน
first == third
เพราะวาประโยคดังกลาวจะเปรยี บเทยี บวา string ทั้งสองตัวอา งถึงท่เี ดียวกนั หรอื ไม (ทที่ ี่เกบ็ string
ใด string หนงึ่ ) เชน ถา เรามี
String myString = "Motorcycle";
String yourString = myString;
ซงึ่ ทาํ ใหต ัวแปร myString และ yourString อางถงึ ขอ มลู เดียวกัน (และจะใหคา true ถามีการ
เปรียบเทยี บดว ย ==) ไมใ ชการเปรียบเทยี บถึงขอมลู ท่ีตัวแปรท้งั สองอา งอยู เชนถา เรามี string
ตอไปน้ี
String keyboard = "from Thailand";
String kb = "from Thailand";
ถา เราเปรยี บเทียบดวยการใช
if(keyboard == kb) …
เราจะไดค า false ถงึ แมว าตัวแปรทง้ั สองจะมีคาท่ีเหมือนกนั ทง้ั น้ีเพราะวา เครอ่ื งหมาย == จะ
เปรยี บเทยี บคาอา งอิง (ท่อี ยู หรือ address ในหนว ยความจาํ ) ของตวั แปรทงั้ สองไมใชค าทท่ี ง้ั สอง
ตวั แปรเก็บไว เราตอ งใช method อื่นท่ี Java มใี หใ น class String
โปรแกรมตัวอยา งของการเปรียบเทยี บ string
1: /**
2: Comparing strings
3: */
4:
5: import static java.lang.System.out;
6:
7: class StringCompare {
8: public static void main(String[] args) {
9: String first = "Java ";
10: String second = "Programming";
11: String third = "Java Programming";
12: String forth;
13:
14: forth = first + second; //forth is "Java Programming"
15: if(third == forth)
16: out.println("third and forth refer to the same string");
17: else
18: out.println("thrid and forth do not refer to the same string");
19:
20: first = forth; //first and forth refer to the same string
21: out.println("first is " + first);
22: out.println("forth is " + forth);
23: if(first == forth)
24: out.println("first == forth is true");
25: else
26: out.println("first == forth is false");
27: }
28: }
โปรแกรม StringCompare.java แสดงถึงการเปรียบเทยี บ string ดว ยการใชเครอ่ื งหมาย == ถา เรา
สังเกตใหดีจะเห็นวา string third และ forth มีคาทเ่ี หมือนกนั (string ทป่ี ระกอบไปดวย char ที่
เหมอื นกันหมด) เม่อื run ดผู ลลัพธทไ่ี ดค อื
144
บทท่ี 4: Array และ String intro. to Java (FEU.faa)
third and forth do not refer to the same string
ซ่งึ บอกใหเ รารูวา การใชเคร่อื งหมาย == เปรียบเทียบความเหมอื นหรือความแตกตางของ string
ไมไ ด เชน เดยี วกันกบั ประโยคเปรยี บเทยี บถัดมาในโปรแกรม เรากําหนดให first อางถงึ ขอมลู ท่ี
เดียวกนั กบั forth และเม่ือเรา run ผลลัพธทไ่ี ดกเ็ หมือนกบั ที่เราไดค าดหวงั ไวคอื
first is Java Programming
forth is Java Programming
first == forth is true
ถาเราตองการท่ีจะเปรยี บเทยี บ string จริง ๆ เราตองใช method equals() และ method
compareTo() ดงั โปรแกรมตัวอยางตอไปน้ี
1: /**
2: Comparing strings
3: */
4:
5: import static java.lang.System.out;
6:
7: class StringCompare1 {
8: public static void main(String[] args) {
9: String first = "Java ";
10: String second = "Programming";
11: String third = "Java ProgramminG";
12: String forth;
13:
14: forth = first + second;
15: if(third.equals(forth))
16: out.println("third equals forth");
17: else
18: out.println("thrid not equals forth");
19:
20: first = forth;
21: if(first.equals(forth))
22: out.println("first equals forth");
23: else
24: out.println("first not equals forth");
25: }
26: }
เราไดเ ปล่ียนให third มีคา เปน "Java ProgramminG" เพอื่ ที่จะแสดงใหเ หน็ วา ในการเปรยี บเทียบ
น้ัน char ทกุ ตวั จะตองเหมือนกนั ผลลัพธทีเ่ ราไดจากการ run คอื
third not equals forth
first equals forth
เราใชประโยค third.equals(forth) ในการเปรยี บ third และ forth วา มีคา ทีเ่ หมือนกัน (เทากนั ) ซง่ึ
ถา เทา กนั จรงิ ผลลัพธท ไ่ี ดจากการเปรียบจะมีคาเปน true และจะใหค า false ถาไมเ ทากนั
การเปรียบเทยี บ string 2 ตวั เพ่อื ตรวจสอบความเทา กนั นัน้ เราจะเอาตัวไหนอยูดา นหนา ก็ได เชน
third.equals(forth) หรอื forth.equals(third) กไ็ ด
method equals() จะตรวจสอบตวั อักษรทุกตวั ที่อยูใน string โดยใหความสนใจในเร่อื งของตวั อักษร
วาเปนตัวอักษรตัวเลก็ หรอื ตวั ใหญ การตรวจสอบจะใหคา ท่เี ปนจริงถาเหมือนกันทัง้ รปู รางและขนาด
เชน g หรอื G ไมใชตัวอักษรตัวเดียวกัน การตรวจสอบจะเปน false
ในการเปรียบเทียบบางครง้ั เรากไ็ มส นใจวาตัวอักษรทอ่ี ยภู ายใน string นั้นเปน ตัวเลก็ หรอื ตัวใหญ ซ่งึ
ถา เราตองการเพียงแตต รวจสอบถึงความเหมอื นทางรปู รา งเราก็ตอ งใช method
equalsIgnoreCase() ในการเปรียบเทียบ string นน้ั ๆ
ถาเราเปล่ยี นการเปรียบเทียบในโปรแกรมตวั อยา งกอนหนา นีจ้ ากการใช equals() มาเปน
equalsIgnoreCase() ดงั นี้
145
เร่ิมตนการเขียนโปรแกรมดว ย Java intro. to Java (FEU.faa)
if(third.equalsIgnoreCase(forth))
System.out.println("third equals forth");
else
System.out.println("thrid not equals forth");
เราก็จะไดผ ลลัพธเปน
third equals forth
4.8.4 การเปรียบเทยี บความไมเ ทากันของ string
หลาย ๆ ครัง้ เราตอ งตรวจสอบถึงความมากกวา หรือ นอยกวา ของ string เพอ่ื ใหการจดั เก็บ string
นน้ั ๆ อยูใ นรูปแบบท่ีมีการจดั เรียง ไมว า จะเปนจากนอยไปหามาก หรอื มากไปหานอ ย ในการ
ตรวจสอบวา string ตัวไหนมากกวาหรือนอ ยกวากันน้นั เราจะใช method compareTo() เชน
myString.compareTo(yourString);
สมมติวา myString มีคา เปน "lovely bike" และ yourString มคี า เปน "lovely kite" การเปรยี บเทียบ
ดวย compareTo() จะใหคาท่ีเปน บวก ทัง้ นี้ก็เพราะวา ตวั อกั ษร 'k' ใน yourString นั้นมคี ามากกวา
ตวั อกั ษร 'b' ใน myString เรามาดโู ปรแกรมตวั อยางการใช method compareTo() กันดกี วา
1: /**
2: Compare strings using compareTo()
3: */
4:
5: import static java.lang.System.out;
6:
7: class StringCompareTo {
8: public static void main(String[] args) {
9: String first = "lovely bike";
10: String second = "lovely kite";
11: String third = "lovely";
12:
13: //compare first and second
14: if(first.compareTo(second) > 0)
15: out.println("first is greater than second");
16: else
17: out.println("second is greater than first");
18:
19: //compare first and third
20: if(first.compareTo(third) > 0)
21: out.println("first is greater than third");
22: else
23: out.println("third is greater than first");
24:
25: String a = "A";
26: String z = "Z";
27: String str1 = "AAA";
28: String str2 = "AAA";
29:
30: //compare a and z
31: if(a.compareTo(z) < 0)
32: out.println(a + " is less than " + z);
33:
34: //compare str1 and str2
35: if(str1.compareTo(str2) == 0)
36: out.println(str1 + " equals " + str2);
37: }
38: }
ผลลัพธท่ีเราไดจากการ run คือ
second is greater than first
first is greater than third
A is less than Z
AAA equals AAA
146
The words you are searching are inside this book. To get more targeted content, please make full-text search by clicking here.
Introduction to Programming Java Language
Discover the best professional documents and content resources in AnyFlip Document Base.
Search