ืืคืืกื ืื, ื ืืื ืืจืืื ืฉืื ืืช ืืืืืจ ืขื ืืคื ื-Java. ืืื ืืืืจืืื ืื ืคืืฆืืช ืฉืื ืืืืฆื ืืืฉืชืืฉ ืืื ืืขืืจืช ืืืืืืืช. ืืคื ื ืฉืืชืืืืื, ืื ื ืื ืืืื ืฉืืชื ืืืื
ืืืฉืงืื
ืืืคืืช
ื- Java. ืขื ืืืช, ืื ื ืชืงืฆืืจ ืืืืจ ืขืืืจื.
ืืื ืืคื ื-Java?
ืืฉ ืืจืื ืคืจืฉื ืืืืช ืืื, ืืื ืืืื ื ืืื ืืช ืื ืืคืฉืืืช.
"ืืคื ืืื ืืืฉืง ื-Java, ืืืฉืืฉ ืืืืกืื ื ืชืื ืื ืืฆืืจื ืฉื ืฆืืื ืืคืชื-ืขืจื."
ืื ืืชื ืืืฉื ืืื ืืฉืืฉืืช ืืคืืช? ืื ืืชื ืืฉ ืฆืืจื ืืื? ืื ืืฉ ืืจืื ืืฆืืื ืืืืื ืืืืืชืืื ืฉืืื ืื ืื ื ืฆืจืืืื ืืืืกื ื ืชืื ืื ืืฆืืื ืืคืชื-ืขืจื. ืืืืืื, ื ืืชื ืืืืกื ืืช ืื ืืืืืื ืืืชืืืืืช ืืืืช ืืืืืช ืืืืืื ืืฆืืจื ืฉื ืืคื ื-Java.
ืง |
ืขืคืืคืื, ืืื, ืงืืจืืื, ืืืืจ,... ืืื'. |
ื |
ืืื, ืืืื, ืืืจ, ืืืื, ืืื ืื,... ืืื'. |
ืืชืจ ืขื ืื, ืืชื ืืืื ืืืกืชืื ืขื ืืืืืืืืช ืืืืืช ืืื ืืืืื ืืืช ืืื ืืืชืจ.
ืึทืคึฐืชึตืึท |
ืขืจื |
ืชืขืืืช ืืืืช ืืฉืคืืชืืช |
ืืืจื ืืฉืคืื |
ืฉื ืืืืชื |
ืชืขืืืืช ืกืืืื ื |
ืฉื ืืืืจ |
ืืืงืื |
ืืืืง ืฉืื |
ืืกืคืจื ืืืช |
ืืื ืื ืื ื ืฆืจืืืื ืืขืืืจ ืืจื ืืคื?
ืื ืื ื ืฆืจืืืื ืืขืืืจ ืื ืืืืืจ ืขื ืืืคื ืืื ืืืฉืช, ืืฉื ืืช ืื ืืืกืืจ ื ืชืื ืื. ืืืื ื ืืืืง ืืื ืืืืคืฉืจืืืืช ืฉืืฉ ืื ื.
ืืื ืืื ืืจืืื ื ืคืืฆืืช ืืืืืจ ืขื ืืคื ื-Java?
ืื ืื ืืฉื ื ืืจืืื ืจืืืช ืืืฆืืช ืืคื. ืขื ืืืช, ื ืชืืงื ืืืจืืื ืืืขืืืืช ืืืคืฉืืืืช ืืืืชืจ.
- ืฉืืืช ForEach Loop
- ืฉืืืช ืืืืืจืืืจืื
ืื ื ืืฆื ืืช ืืืืฉืื ืฉื ืฉืชื ืืฉืืืืช ืืืื.
ืฉืืืืฉ ืืฉืืืช Foreach Loop
ืืืืื
import java.util.Map;
import java.util.HashMap;
public class ForEachDemo {
public static void main(String[] args) {
Map<String, String> businessDays = new HashMap<String, String>();
businessDays.put("1", "Monday");
businessDays.put("2", "Tuesday");
businessDays.put("3", "Wednesday");
businessDays.put("4", "Thursday");
businessDays.put("5", "Friday");
for (Map.Entry<String, String> entry : businessDays.entrySet())
{
System.out.println("key = " + entry.getKey() + ", value = " + entry.getValue());
}
}
}
ืชึฐืคืึผืงึธื
ืืคืชื = 1, ืขืจื = ืืคืชื ืืื ืฉื ื = 2, ืขืจื = ืืคืชื ืืื ืฉืืืฉื = 3, ืขืจื = ืืคืชื ืืื ืจืืืขื = 4, ืขืจื = ืืคืชื ืืื ืืืืฉื = 5, ืขืจื = ืืื ืฉืืฉื
ืึถืกืึผึตืจ
ืืืืืื ืื ืืฉืชืืฉื ื ืืืืืื ืืงืืืืช ืืื ืืืืืจ ืขื ืืืคื. ืขื ืืื ืฉืืืืฉ ืืืืืื for-each, ืื ื ืืงืืืื
entrySet() ืืืกืคืง "ืชืฆืืื" ืืืืืืืืช ืฉื ืื ืชืื ืื ืืืคื, ืืฆืืจื ืฉื ืฆืืื ืืคืชื-ืขืจื. ืื ืขืจืืช ืขืจืืืช ืืืืื ืืคืชื ืืขืจืืื ืืชืืืืื. ืืืคื ืืชื ืืืื ืืืฉืชืืฉ ืืื ืืฉืืืืช ืฉื
Map.Entry<key, value> ืืคื ืืืจืืฉืืช ืฉืื. ืืื, ืืฉืชืืฉื ื ืจืง
ื-getKey() ืื-
getValue() ืืื ืืืฆืื ืืช ืื ืชืื ืื ืืืกืืฃ. ืืชืจืืื, ืืชื ืืืื ืืืงืืจ ืืช ืฉืืจ ืืฉืืืืช ืืื ืืืืง ืืช ืืคืงืืื ืฉืื ืขื ืืืฉื ืื.
ืฉืืืืฉ ืืฉืืืช Iterators
ืืืืื
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class MapIterator {
public static void main(String[] args) {
Map<String, String> monthsInAYear = new HashMap<String, String>();
monthsInAYear.put("1", "January");
monthsInAYear.put("2", "February");
monthsInAYear.put("3", "March");
monthsInAYear.put("4", "April");
monthsInAYear.put("5", "May");
monthsInAYear.put("6", "June");
monthsInAYear.put("7", "July");
monthsInAYear.put("8", "August");
monthsInAYear.put("9", "September");
monthsInAYear.put("10", "October");
monthsInAYear.put("11", "November");
monthsInAYear.put("12", "December");
Iterator<Map.Entry<String, String>> iterator = monthsInAYear.entrySet().iterator();
while (iterator.hasNext())
{
Map.Entry<String, String> entry = iterator.next();
System.out.println("key = " + entry.getKey() + ", value = " + entry.getValue());
}
}
}
ืชึฐืคืึผืงึธื
ืืคืชื = 11, ืขืจื = ืืคืชื ื ืืืืืจ = 1, ืขืจื = ืืคืชื ืื ืืืจ = 12, ืขืจื = ืืคืชื ืืฆืืืจ = 2, ืขืจื = ืืคืชื ืคืืจืืืจ = 3, ืขืจื = ืืคืชื ืืจืฅ = 4, ืขืจื = ืืคืชื ืืคืจืื = 5, ืขืจื = ืืคืชื ืืื = 6, ืขืจื = ืืคืชื ืืื ื = 7, ืขืจื = ืืคืชื ืืืื = 8, ืขืจื = ืืคืชื ืืืืืกื = 9, ืขืจื = ืืคืชื ืกืคืืืืจ = 10, ืขืจื = ืืืงืืืืจ
ืึถืกืึผึตืจ
ืืืืืื ืื, ืื ื ืืืฆืจืื ืืืืจืืืจ ืืคืืจืฉ ืืื ืืขืืืจ / ืืืืืจ ืขื ืืืคื. ืจืืฉืืช, ืขืืื ืืืืื ืืช ืืืืงืช ืืืืืจืืืจ, ืืืืืจ ืืื ืืงืื ืืช ืืืืืจืืืจ ืขืืืจ ื-entrySet. ืืขืช ืืฆื ืืช ืืืคื ืชืื ืฉืืืจื ืขื ืืืืงืช ืืืฉืืช ืืืื ืฉืงืืืืช ืืืคื. ืื ื ืื! ืืืขืืจ ืฉืื ืืืฉืื, ืืืืืง ืืื.
ืืื ืืืืืช Foreach ืืืื ืืืชืจ ืืฉืืืช ืืืืืจืืืจืื?
ืื ืื ืืฉื ื ืืืืื ืฉืืื ืืชื ืืฉืชืืฉ ืืืขืืจ ืฉื ืืคื ืื ืขืื ืืื ืขืืฉื ืืช ืืขืืืื ืืฉืืืื.
ืืืืื ืช ืืืฆืืขืื, ืื ืขืืืจ ืื ืืืืื ืืื ืขืืืจ ืืืืืจืืืจืื ืืฉ ืืืชื ืืืจืืืืช ืืื . ืื ืืฃ ืืื ืื ืืื ืืืชืจ ืืืฉื ื, ืื ืชืืื ืืื ืืชื ืฆืจืื ืืืฉืชืืฉ ืืืชื.
ืื ืืืืื ืืื ืฉืชื ืืฉืืืืช?
ืืืืืื ืฉื ืื ืืื ืื ืืืคืฉืจืช ืืขืืื/ืืฉื ืืช ืืช ืื ืชืื ืื ืืืคื. ืืืืคื, ืืชื ืืืื ืืงืืืช ืืฉื ืืช ื ืชืื ืื ืืืืฆืขืืช ืืืืจืืืจืื. ืืืืงืช ืืืืืจืืืจืื ืืืคืฉืจืช ืื ืืกืคืง ืืืฉืื ืืขืจืืื/ืืกืจื ืฉื ืื ืชืื ืื ืืืคื. ืืืืคื, ืื ืชื ืกื ืืขืจืื/ืืืืืง ื ืชืื ื ืืคื ืืืืฆืขืืช ืืืืืื ืฉื ืื ืืื, ืื ืืืจืืง
ConcurrentModificationException
. ืืกืืื ืืื ืืื ืฉืืืืืื ืขืืืจ-ืื ืืืฆืจืช ืืืืคื ืืจืืื ืืืืจืืืจ, ืฉืืื ื ืืฉืืฃ ืืืฉืชืืฉ. ืืคืืื, ืืื ืื ืืืฉื ืืฉื ืืช ืื ืืืืืง ื ืชืื ืื ืืืฉืื.
ืืืืื ืฉืืืช ืืขืืจ ืืืฉืชืืฉ ืืืชื?
ืื ืืื ื ืืืื ืื ืืืฉืชืืฉ ื-for-each ืื ืืืืืจืืืจืื ืืื ืืืืืจ ืขื ืืืคื ืฉืื, ืชืืื ืืงืืช ืืช ืืืฆืขืืช ืืืืืช.
- ืืฉืชืืฉ ืืืืืจืืืจ ืื ืขืืื ืืฉื ืืช ืืช ืืืคื.
- ืืฉืชืืฉ ืืืืืื ืืื ืืื ืื ืืฉ ืื ืืืืืืช ืืงืื ื ืืช (ืืื ืืื ืืข ืืืจืืืืช).
ืกืืืื
ืขื ืกืืฃ ืืคืืกื, ืื ื ืืงืืืื ืฉืืืืช ืืืฆื ืืืฆืข ืืืืจืฆืื ืฉื ืืคื ืื'ืืืื. ืืืืืฅ ืืชืจืื ืืช ืืื ืืื ืกืืช ืื ืฉืืืืช ืืืจืืช ืฉื ืืขืืจ. ืื ืชืืกืก ืืงืคืืฅ ืืืืจื ืื ืืคืจืกื ืฉืืืืช ืืื ืคืขื ืฉืืชื ืืจืืืฉ ืชืงืืข. ืขื ืื, ืืืืื ืืื ื!
GO TO FULL VERSION