Map接口

Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。

Map中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的值。

Collection中的集合称为单列集合，Map中的集合称为双列集合。

 需要注意的是，Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

Map中常用的集合为HashMap集合、LinkedHashMap集合。

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"));
　　//keySet遍历集合
　　//1.获取所有key的Set集合
　　/*Set<String> set=map.keySet();
　　//2.遍历Set集合取到每一个key
　　for(String key:set){
　　//3.根据每个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));
　　　　}
　　}
}

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>> s=map.entrySet();
　　Iterator<Map.Entry<String, String>> it=s.iterator();
　　while(it.hasNext()){
　　　　Map.Entry<String,String> key=it.next();
　　　　String k=key.getKey();
　　　　String v=key.getValue();
　　　　System.out.println(k+"..."+map.get(k));
　　　　}
　　}
}

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),"java0322班");
　　　　map.put(new Person("熊二",20),"java0601班");
　　　　//遍历
　　　　//1.获取装有所有key的set集合
　　　　Set<Person> set=map.keySet();
　　　　//2.遍历set集合取到每一个key
　　　　for(Person key:set){
　　　　　　System.out.println(key+"..."+map.get(key));
　　　　}
　　}
}

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迭代器)
　　　　//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();
　　　　　　//从结婚证对象中获取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);
　　}
}

可变参数：

格式：修饰符 返回值类型 方法名(参数类型... 形参名){  }

public class Demo02 {
　　public static void main(String[] args) {
　　int sum=add(5,1,2,12,12,1,3,1,31,31,2);
　　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;
　　}
}

 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(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+" ");
　　}
}

集合嵌套

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("琪琪国王",31), "java0705");
　　　　//向大的map中存数据
　　　　map.put("java班", map1);
　　　　map.put("php班", map2);
　　　　//遍历
　　　　//1.获取大map中所有的key所在的set集合
　　　　/*Set<String> bigkeys=map.keySet();
　　　　//2.遍历所有key取到每一个key
　　　　for(String bigkey:bigkeys){
　　　　　　//3.根据bigkey获取小map对象
　　　　　　HashMap<Person, String> smallmap=map.get(bigkey);
　　　　　　//获取小map中所有的key所在的set集合
　　　　　　Set<Person> smallkeys=smallmap.keySet();
　　　　　　//遍历小map中所有的key取到每一个key
　　　　　　for(Person smallkey:smallkeys){
　　　　　　　　//根据smallke获取对应的value值
　　　　　　　　System.out.println(bigkey+"..."+smallkey+"..."+smallmap.get(smallkey));
　　　　　　}
　　　　}*/
　　　　　/*Set<String> bigkeys=map.keySet();
　　　　　Iterator<String> it=bigkeys.iterator();
　　　　　while(it.hasNext()){
　　　　　　　　String bigkey=it.next();
　　　　　　　　HashMap<Person, String> has=map.get(bigkey);
　　　　　　　　Set<Person> smallkey=has.keySet();
　　　　　　　　Iterator<Person> it1=smallkey.iterator();
　　　　　　　　while(it1.hasNext()){
　　　　　　　　　　Person small=it1.next();
　　　　　　　　　　System.out.println(bigkey+"..."+small+"..."+has.get(small));
　　　　　　　　　}
　　　　　　}*/
　　　　　　/*Set<Map.Entry<String, HashMap<Person,String>>> bigkeys=map.entrySet();
　　　　　　for(Map.Entry<String, HashMap<Person,String>> big:bigkeys){
　　　　　　　　String k=big.getKey();
　　　　　　　　HashMap<Person,String> v=big.getValue();
　　　　　　　　Set<Map.Entry<Person, String>> smallkey=v.entrySet();
　　　　　　　　for(Map.Entry<Person, String> small:smallkey){
　　　　　　　　　　Person key=small.getKey();
　　　　　　　　　　String value=small.getValue();
　　　　　　　　　　System.out.println(k+"..."+key+"..."+value);

　　　　　　　　}
　　　　　　}*/
　　　　　　Set<Map.Entry<String,HashMap<Person,String>>> bigkeys=map.entrySet();
　　　　　　Iterator<Map.Entry<String,HashMap<Person,String>>> it=bigkeys.iterator();
　　　　　　while(it.hasNext()){
　　　　　　　　Map.Entry<String,HashMap<Person,String>> key=it.next();
　　　　　　　　String k=key.getKey();
　　　　　　　　HashMap<Person, String> v=key.getValue();
　　　　　　　　Set<HashMap.Entry<Person, String>> smallkey=v.entrySet();
　　　　　　　　Iterator<HashMap.Entry<Person, String>> i=smallkey.iterator();
　　　　　　　　while(i.hasNext()){
　　　　　　　　　　HashMap.Entry<Person, String> has=i.next();
　　　　　　　　　　Person kk=has.getKey();
　　　　　　　　　　String vv=has.getValue();
　　　　　　　　　　System.out.println(k+"..."+kk+"..."+vv);
　　　　　　　　}
　　　　　　}
　　　　}
　　}

Map接口

原文：https://www.cnblogs.com/boss-H/p/10959062.html