[AppleScript] 纯文本查看 复制代码
package fuxi;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
public class Demo_dianzhao1 {
/**
* @param args
* 1. 有一个map,其中有{1=”张三”,2=”李四”,3=”王五”,4=”赵六”}.
打印元素
添加元素（5=”张七”）
删除元素(key=1)
修改元素(key=2,value=”赵四”)
*/
public static void main(String[] args) {
Map<Integer,String> map = new HashMap<>();
map.put(1, "张三");
map.put(2, "李四");
map.put(3, "王五");
map.put(4, "赵六");
/*if(!map.containsKey(5)){
map.put(5, "张七");
}*/
if(map.containsKey(1)){
map.remove(1);
}
/*if(map.containsKey(2)){
map.put(2,"赵四");
}*/
/*Set<Integer> s = map.keySet();
Iterator<Integer> it = s.iterator();
while(it.hasNext()){
Integer key = it.next();
String vaule = map.get(key);
System.out.println(key+"="+vaule);*/
Set<Entry<Integer,String>> entry = map.entrySet();//修改元素尽量使用Map.Entry接口
Iterator<Entry<Integer,String>> it = entry.iterator();//迭代器的泛型就是Entry
while(it.hasNext()){
Entry<Integer,String> en = it.next();//获取迭代元素
if(en.getKey().equals(2)){//如果跌倒这个键值就修改他的值
en.setValue("赵四");
}
if(!map.containsKey(5)){
map.put(5, "aa");
}
String vaule = en.getValue();//获取值
Integer key = en.getKey();//获取键
System.out.println(key+"="+vaule);
}
}
}
[AppleScript] 纯文本查看 复制代码
package fuxi;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
public class Demo_fuxi1 {
/**
* @param args
* 一、双列集合Map中键和值是成对存在的，键是你唯一的，值是可以重复的
* 在双列集合中我们所说的元素存在不存在，看的是键值，如果集合中有该键值则证明该集合中存在该元素
* 给双列集合添加元素时，如果集合中没有该简直，则直接添加，然后返回一个null值，如果已经存在了，则覆盖掉原来的值，将其返回
* Set也是一个双列结合，不过值被隐藏了
* 二、因为集合中的键值是唯一的所以我们是能够根据指定键值删除集合中的元素的
* 三、 * boolean containsKey(Object key)：判断集合是否包含指定的键
* boolean containsValue(Object value):判断集合是否包含指定的值
* boolean isEmpty()：判断集合是否为空
四、
* Set<Map.Entry<K,V>> entrySet():
* V get(Object key):根据键获取值
* Set<K> keySet():获取集合中所有键的集合
* Collection<V> values():获取集合中所有值的集合
*/
public static void main(String[] args) {
//demo();
//demo1();
//demo2();
// demo3();
//demo4();
//获取所有键值对对象的集合
//遍历键值对对象的集合，获取到每一个键值对对象
//根据键值对对象找键和值
Map<String,Integer> map = new HashMap<>();
map.put("qq",13);
map.put("pp",12);
map.put("oo",14);
map.put("bb",16);
Set<Map.Entry<String, Integer>> entrySet = map.entrySet();//获取集合中所有键值对象的集合
Iterator<Map.Entry<String, Integer>> it = entrySet.iterator();//获取迭代器
while(it.hasNext()){
Entry<String,Integer> en = it.next();//获取键值对对象
String key = en.getKey();//获取键值
Integer vaule = en.getValue();//获取值
System.out.println(key+"="+vaule);
}
}
private static void demo4() {
Map<String,Integer> map = new HashMap<>();
map.put("aa", 22);
map.put("cc", 11);
map.put("mm", 11);
map.put("nn", 11);
/*while(!map.isEmpty()){
}*/
//主要思路就是，先将集合中的所有键获取到，放入单列集合中
//迭代键的集合，然后根据键就获取到了值
Set<String> s = map.keySet();//获取集合中所有键值
Iterator<String> it = s.iterator();//获取迭代器
while(it.hasNext()){//判断还有没有可以迭代的元素
String key = it.next();//获取键值
Integer vaule = map.get(key);//根据键值获取值
System.out.println(key+"="+vaule);
}
//使用增强for循环遍历集合中的元素
/*for (String key : map.keySet()) {
System.out.println(key+"="+map.get(key));
}*/
}
private static void demo3() {
Map<String,Integer> map = new HashMap<>();
map.put("aa", 3);
map.put("bb", 13);
map.put("cc", 13);
map.put("dd", 13);
Collection<Integer> c = map.values();//获取双列集合中的所有值
System.out.println(c);
Set<String> s = map.keySet();//获取双列集合中所有的键
System.out.println(s);
Integer i = map.get("aa");//根据键获取值
System.out.println(i);
}
private static void demo2() {
Map<String,Integer> map = new HashMap<>();
map.put("asd", 12);
map.put("mm", 12);
map.put("ad", 12);
map.put("d", 12);
boolean b = map.containsKey("ad");//判断集合中是否包含该键值
boolean b1 = map.containsValue(12);//判断结婚中是否包含该值
boolean b2 = map.isEmpty();//判断集合是否为空
System.out.println(b);//ture
System.out.println(b1);//ture
System.out.println(b2);//false
}
private static void demo1() {
Map<String,Integer> map = new HashMap();
map.put("aaa",23);
map.put("ddd",23);
map.put("bbb",23);
map.put("ccc",23);
map.remove("aaa");//根据键值删除集合中的元素，因为键值是唯一存在的所以不会误删
System.out.println(map);
map.clear();//清空集合中的所有元素
System.out.println(map);
}
private static void demo() {
Map<String,Integer> map = new HashMap<>();
Integer i1 = map.put("张三",23);//存储时，如果集合中没有该元素时，则添加该元素，返回null
Integer i2 = map.put("李四",23);
map.put("王五",23);
Integer i3 = map.put("张三",23);//存储时如果该已经存在了该元素，则用这个元素覆盖原来的元素，返回值
System.out.println(map);
System.out.println(i1);//输出null
System.out.println(i2);//输出null
System.out.println(i3);//输出23
}
}