个人理解：
个人感觉map接口以后会经常用到，可以很清晰地查找某个对象，要熟悉其四种遍历方法。特别注意其键值对的键不能是重复的，有想定义有序存取的话，可以使用linkedhashmap集合。不过定义自定义对象时，要复写其对象的hashcode和equals方法。静态导入的话，不用编辑器的话可以使用下。再定义方法时有多个参数的话，可以使用可变参数，不过只能一个且在最后面。collections的工具类可以对数据进行升序和打乱顺序。集合是可以嵌套的。
一、map接口概述：
map接口下的集合与collection接口下的集合存储数据的不同在于：
map中的集合，元素是以键值对的形式存在的，但是集合中不能包含重复的键，值可以重复，每个键只能对应一个值。常用集合为hashmap集合、linkedhashmap集合（有序）。
二、常用方法：
1、get（）：获取指定键对应的值；
2、put():将指定的键与值对应起来，并添加到集合中，返回对应的值，无的话返回null;
3、remove（）：移除
三、map集合遍历键找值方式：
keyset() 返回此key所在的set集合
我要评论import java.util.hashmap;
import java.util.iterator;
import java.util.map;
import java.util.set;
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");
//system.out.println(map.get("3"));
//ketset遍历集合
//1.获取所有key的set集合
/* set<string> set=map.keyset();
//2.遍历set集合取到每一个key
for(string key:set){
//3.根据每个key获取每个值
system.out.println(key+"...."+map.get(key));
}*/
//使用迭代器遍历
//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、在map类设计时，提供了一个嵌套接口（又定义一个接口）：entry。entry将键值对的对应关系封装成了对象。即键值对对象。
2、方法：
getkey() 返回entry对象中的键
getvalue() 返回entry对象中的值
entryset() 用于返回map集合中所有的键值对(entry)对象，以set集合形式返回
3、map集合遍历键值对方式：
import java.util.hashmap;
import java.util.iterator;
import java.util.map;
import java.util.set;
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);
}*/
//迭代器遍历
set<map.entry<string,string>> set=map.entryset();
iterator<map.entry<string,string>> it=set.iterator();
while(it.hasnext()){
map.entry<string,string> entry=it.next();
string key=entry.getkey();
string value=entry.getvalue();
system.out.println(key+"..."+value);
}
五、hashmap存储自定义类型键值：
1、当给hashmap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须复写对象的hashcode和equals方法。
2、如果要保证map中存放的key和取出的顺序一致，可以使用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("熊大",22));
map.put("java0611", new person("熊三",33));
//遍历（entryset迭代器）
//获取集合
set<map.entry<string,person>> set=map.entryset();
//获取迭代器对象
iterator<map.entry<string,person>> it=set.iterator();
//循环判断下个元素是否有值
while(it.hasnext()){
//获取每个对象
map.entry<string, person> entry=it.next();
//获取key
string key=entry.getkey();
//获取value
person value=entry.getvalue();
system.out.println(key+"..."+value);
}
}
}
六、静态导入：
在导包的过程中我们可以直接导入静态部分，这样某个类的静态成员就可以直接使用了。在源码中经常会出现静态导入。
静态导入格式：
import static xxx.yyy; 导入后yyy可直接使用。
package com.oracle.demo02;
import static java.lang.system.out;
import static java.lang.math.pi;
public class demo01 {
public static void main(string[] args) {
out.println("你好");
out.print("hello");
out.println(2*pi);
}
}
七、可变参数：
在jdk1.5之后，如果我们定义一个方法需要接受多个参数，并且多个参数类型一致，我们可以对其简化成如下格式：
修饰符 返回值类型 方法名(参数类型... 形参名){ }
其实这个书写完全等价与
修饰符 返回值类型 方法名(参数类型[] 形参名){ }
只是后面这种定义，在调用时必须传递数组，而前者可以直接传递数据即可。
package com.oracle.demo02;
public class demo02 {
public static void main(string[] args) {
int sum=add(1,2,3,5,6,11,33,44);
system.out.println(sum);
}
//写方法，计算整数参数的和
public static int add(int...a){
int sum =0;
/*for(int i:a){
sum=sum+i;
}*/
for(int i=0;i<a.length;i++){
sum=sum+a[i];
}
return sum;
}
}
add方法在同一个类中，只能存在一个。因为会发生调用的不确定性
注意：如果在方法书写时，这个方法拥有多参数，参数中包含可变参数，可变参数一定要写在参数列表的末尾位置。
八、collections集合工具类：
shuffle() 随机置换（只能传list)
sort() 集合元素升序排列
import java.util.arraylist;
import java.util.collections;
public class demo03 {
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(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+" ");
}
}
}
九、集合嵌套：
集合嵌套，仅仅是集合内容又是集合，如collection集合嵌套、collection集合与map集合相互嵌套、map集合嵌套。
package com.oracle.demo02;
import java.util.hashmap;
import java.util.iterator;
import java.util.map;
import java.util.set;
import com.oracle.demo01.person;
public class demo04 {
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("孙鹏坤",24), "java0929");
map2.put(new person("李瑞",21), "php0705");
//向大的map存数据
map.put("java班", map1);
map.put("php班", map2);
//1、遍历
//获取大map中所有的key的所在的set集合
/*set<string> bigkeys=map.keyset();
//遍历所有key
for(string bigkey:bigkeys){
//根据bigkey获取小map的对象
hashmap<person,string> smallmap=map.get(bigkey);
//获取小map所有的key所在的set集合
set<person> smallkeys=smallmap.keyset();
//遍历小map的key
for(person smallkey:smallkeys){
//根据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(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);
}
}
}
}
十、集合继承体系的面向对象思想
1、接口：用来明确所有集合中该具有的功能，相当于在定义集合功能标准；
2、抽象类：把多个集合中功能实现方式相同的方法，抽取到抽象类实现，具体集合不再遍写，继承使用即可；
3、 具体类：继承抽象类，实现接口，重写所有抽象方法，达到具备指定功能的集合。每个具体集合类，根据自身的数据存储结构方式，对接口中的功能方法，进行不同方式的实现。
如对本文有疑问， 点击进行留言回复！！
android用Popup弹出窗(PopupWindow的使用方式)
ionic3 打包 Could not get resource ‘https://jcenter.bintray.com/com/google/zxing/core/3.2.1/core-3.2.1
NullPointerException: Attempt to invoke virtual method ‘android.content.res.XmlResourceParser androi
网友评论