Map接口、Entry键值对对象、可变参数、HashMap存储自定义、静态导入、Collections集合工具、集合嵌套
Map接口
map 常用集合HashMap集合、LinkedHashMap集合
HashMap<k,v>:存储数据用哈希表，元素存取顺序不能保证一致，哈希表可保证键的唯一、不重复，需要写hashCode()方法、equals()方法。
LinkedHashMap<k,v> :HashMap的子类，存储数据用哈希表结构+链表结构。链表结构保证元素存储顺序一致，哈希表结构保证键的唯一、不重复，需要写hashCode()、equals()
注：Map接口的集合都有两个泛型变量<k,v>,使用时为两个泛型变量赋予数据，<k,v数据可以相同，或不同>
Collection 集合只能存一列 是孤立存在（单身）单列集合
Map集合：双列集合。元素成对存在(夫妻)。 是key和value 组成，一个位置存两个值，通过键可找对所对应的值。
注意：键不可重复，每个键值能对应一个值 map是无下标 （set原理：重写哈希code和equals方法） 值可重复
Map接口中的常用方法
get（）：获取指定键对应的值
put（）:将指定的键与值对应起来，并添加到集合中，返回对应的值，无的话返回null
remove（）：移除
Map集合遍历键找值方式
keyset（）；取每一列的键
思路：
1.获取Map集合中所有键，键是唯一，返回一个Set集合存储所有的键
2.遍历键的Set集合，得到每一个键
3.根据键，获取键所对应的值
package com.oracle.demo01; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; //Map接口 public class Demo01 { public static void main(String[] args) { Map<String,String> map=new HashMap<String,String>(); map.put("1","a"); map.put("2","a"); map.put("3","b"); map.put("3","c"); //删除元素 map.remove("3");//写的是key 就等于删除的是值 /*//System.out.println(map.get("3")); //keySet 用增强for遍历集合 //1.获取所有key的Set集合 Set<String> set=map.keySet(); //2.遍历Set集合取到每一个key for(String key:set){ //根据每个key获取每个值 System.out.println(key+"..."+map.get(key)); }*/ //keyset遍历集合 用（迭代器遍历） //1.获取所有key的集合 Set<String> set=map.keySet(); //2.获取迭代器对象 Iterator<String> it=set.iterator(); //3.判断容器中是否有值 while(it.hasNext()){ //获取每一个key值 String key=it.next(); //根据key值获取每一个Value值 System.out.println(key+"..."+map.get(key)); } } }
Entry键值对对象：Map.Entry<K,V>
思路
1.获取集合中所有的键值对(Entry)对象，返回Set
2.遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象
3.通过键值对(Entry)对象，获取Entry中的键与值
getKey() 返回Entry对象中的键
getValue() 返回Entry对象中的值
entrySet() 用于返回Map集合中所有的键值对(Entry)对象，以Set集合形式返回
package com.oracle.demo01; import java.util.HashMap; import java.util.Map; import java.util.Set; //Entry public class Demo02 { public static void main(String[] args) { Map<String,String> map=new HashMap<String,String>(); map.put("1","a"); map.put("2","a"); map.put("3","b"); map.put("3","c"); //entrySet遍历（增强for） //1.获取所有结婚证对象存在的Set集合 Set<Map.Entry<String,String>> set=map.entrySet(); //2.遍历所有结婚证取到每一个结婚证 for(Map.Entry<String,String> entry:set){ //3.通过每一个结婚证对象获取key String key=entry.getKey(); //4.通过每一个结婚证对象获取value String value=entry.getValue(); System.out.println(key+"..."+value); } } }
pm
HashMap存储自定义类型键值
1、当给HashMap中存放自定义对象时，如果自定义对象是键存在，保证键唯一，必须复写对象的hashCode和equals方法。
2、如果要保证map中存放的key和取出的顺序一致，可使用LinkedHashMap集合来存放
package com.oracle.demo01; public class Person { private String name; private int age; public Person(String name, int age) { super(); //有参构造 this.name = name; this.age = age; }//无参构造 public Person() { super(); } //get set public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } //toString方法 public String toString() { return "Person [name=" + name + ", age=" + age + "]"; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + age; result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } //哈西和equals public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Person other = (Person) obj; if (age != other.age) return false; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; } } --------------------------------------------- package com.oracle.demo01; //HashMap存储自定义类型键值 import java.util.HashMap; import java.util.Map; import java.util.Set; public class Demo03 { public static void main(String[] args) { Map<Person,String> map=new HashMap<Person,String>(); map.put(new Person("胸大",22),"java0322班"); map.put(new Person("胸二",20), "java0222班"); map.put(new Person("胸二",20), "java0262班"); //遍历 //1.获取装有所有key的Set集合 Set<Person> set=map.keySet(); //2.遍历set集合取到每一个key for(Person key:set){ System.out.println(key+"..."+map.get(key)); } } }
LinkedHashmap
package com.oracle.demo01; //LinkedHashmap import java.util.Iterator; import java.util.LinkedHashMap; import java.util.Map; import java.util.Set; public class Demo04 { public static void main(String[] args) { Map<String,Person> map=new LinkedHashMap<String,Person>(); //添加数据 map.put("java0322",new Person("胸三",33)); map.put("java0222",new Person("胸大",33)); map.put("java0611",new Person("胸三",33)); //遍历(entrySet迭代器) //1.获取所有结婚证存在的集合 Set<Map.Entry<String,Person>> set=map.entrySet(); //2.获取迭代器对象 Iterator<Map.Entry<String,Person>> it=set.iterator(); //3.循环判断下个元素是否有值 while(it.hasNext()){ //4.获取每一个结婚证对象 Map.Entry<String, Person> entry=it.next(); //5.从结婚证对象中获取key String key=entry.getKey(); //6.从结婚证对象中获取value Person value=entry.getValue(); System.out.println(key+"..."+value); } } }
静态导入 格式：
import static XXX.YYY; 导入后YYY可直接使用
package com.oracle.demo01; import static java.lang.System.out; import static java.lang.Math.PI; public class Jingtai { public static void main(String[] args) { out.println("你好"); out.println("Hello"); out.print(2*PI); } }
可变参数
修饰符 返回值类型 方法名(参数类型... 形参名){ } = 修饰符 返回值类型 方法名(参数类型[] 形参名){ }
后面这种定义，在调用时必须传递数组，前者可以直接传递数据
package com.oracle.demo01; //可变参数 public class Kebiancanshu { public static void main(String[] args) { int sum=add(1,2); System.out.println(sum); } //写方法，计算整数参数的和 public static int add(int...a){ int sum=0; //增强for /*for(int i:a){ sum=sum+i; } return sum;*/ //或者用 for也可以实现 //获取长度 for(int i=0;i<a.length;i++){ sum=sum+a[i]; } return sum; } }
注意问题：
如果在方法书写时，这个方法拥有多参数，参数中包含可变参数，可变参数一定要写在参数列表的末尾位置
Collections集合工具类
shuffle() 随机置换（只能传list)
sort() 集合元素升序排列
package com.oracle.demo01; import java.util.ArrayList; import java.util.Collections; //Collections集合工具 shuffle打乱顺序 public class Collections集合工具 { public static void main(String[] args) { ArrayList<String> arr=new ArrayList<String>(); arr.add("a"); arr.add("b"); arr.add("c"); arr.add("d"); //增强for for(String s:arr){ System.out.print(s+" "); } System.out.println(); //打乱集合中的元素顺序 Collections.shuffle(arr); for(String s:arr){ System.out.print(s+" "); } System.out.println(); //排序 Collections.sort(arr); for(String s:arr){ System.out.print(s+" "); } } }
集合嵌套
package com.oracle.demo01; //集合嵌套 import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; public class Jihe嵌套 { public static void main(String[] args) { HashMap<String,HashMap<Person,String>> map=new HashMap<String, HashMap<Person,String>>(); //第一个小map HashMap<Person,String> map1=new HashMap<Person,String>(); map1.put(new Person("袁移民",21),"java0322"); map1.put(new Person("韩振宇",21),"java0322"); //第二个小map HashMap<Person,String> map2=new HashMap<Person,String>(); map2.put(new Person("阿斯蒂芬",21),"java03"); map2.put(new Person("大剁手党",21),"php0705"); //向大的map中存数据 map.put("java班",map1); map.put("php班",map2); //用增强for遍历 //1.获取大map中所有的key所在的set集合 Set<String> bigkeys=map.keySet(); //2.遍历所有key取到每一个key for(String bigkey:bigkeys){ //根据bigkey获取小map对象得value值 HashMap<Person,String> smallmap=map.get(bigkey); //3.在走1.获取小map中所有的key所在的set集合 Set<Person> smallkeys=smallmap.keySet(); //2.遍历小map中所有的key取到每一个key for(Person smallkey:smallkeys){ //3.根据smallkey获取对应的value值 System.out.println(bigkey+"..."+smallkey+"..."+smallmap.get(smallkey)); } } //2.用迭代器遍历 //获取大的Key集合 /*Set<String> bigkeys=map.keySet(); //获取迭代器对象 Iterator<String> bigkey=bigkeys.iterator(); //判断 while(bigkey.hasNext()){ //获取迭代器中每个key值 String bigkey1=bigkey.next(); //根据bigkey1获取小的对象 HashMap<Person,String> smallmap=map.get(bigkey1); //获取小的key的集合 Set<Person> smallkeys=smallmap.keySet(); //获取迭代器对象 Iterator<Person> smallkey=smallkeys.iterator(); //判断 while(smallkey.hasNext()){ //获取每个小key Person smallkey1=smallkey.next(); System.out.println(bigkey1+"..."+smallkey1+"..."+smallmap.get(smallkey1)); } }*/ //3.EntrySet遍历（增强for遍历） //获取大的键值对所在的集合 /*Set<Map.Entry<String,HashMap<Person,String>>> bigkeys=map.entrySet(); //增强for循环遍历 for(Map.Entry<String,HashMap<Person,String>> entry:bigkeys){ //通过每个键值对获取每个大key String bigkey=entry.getKey(); //获取每个小Map HashMap<Person,String> smallmap=entry.getValue(); //获取每个小map的小key所在的集合 Set<HashMap.Entry<Person,String>> smallkeys=smallmap.entrySet(); //增强for for(HashMap.Entry<Person,String> smallkey:smallkeys){ //获取每个小key Person smallkey1=smallkey.getKey(); //获取每个value String value =smallkey.getValue(); System.out.println(bigkey+"..."+smallkey+"..."+value); } }*/ //4、EntrySet迭代器遍历 //获取大的键值对所在的集合 Set<Map.Entry<String,HashMap<Person,String>>> bigmaps=map.entrySet(); //获取迭代器对象 Iterator<Map.Entry<String,HashMap<Person,String>>> bigmap=bigmaps.iterator(); //判断 while(bigmap.hasNext()){ //获得每一个键值对 Map.Entry<String,HashMap<Person,String>> bigmap1=bigmap.next(); //获取大key String bigkey=bigmap1.getKey(); //获取小map HashMap<Person,String> smallmap=bigmap1.getValue(); //获取小的键值对所在的集合 Set<HashMap.Entry<Person,String>> smallkeys=smallmap.entrySet(); //获取迭代器对象 Iterator<HashMap.Entry<Person,String>> smallkey=smallkeys.iterator(); //判断 while(smallkey.hasNext()){ //获取小键值对 HashMap.Entry<Person,String> smallkey1=smallkey.next(); //获取小key Person smallkey2=smallkey1.getKey(); //获取小value String value=smallkey1.getValue(); System.out.println(bigkey+"..."+smallkey1+"..."+value); } } } }
