Map集合
java.util.Map 接口，也是集合容器
Collection集合和Map集合的区别
- Collection集合存储元素，每次只能储存单个的元素
- Map集合存储元素，每次需要存储两个元素
。一个元素作为键，一个元素做为值
。一个集合中，键必须保证唯一性
。一个键只能映射一个值
Map接口的方法
v put(K,V)将键值对存储到集合中v get(k)返回键对应的值，集合中没有这个键，返回nullboolean containsKey(K)判断集合中是否包含此键,包含返回trueboolean containsValue(V)判断集合中是否包含此值包含返回truev remove(K)移除集合中的键值对，返回被移除之前的值Conllection<V> values()集合中的所有的值取出，存储到Collection集合
public static void main(String [ ] args) {
myPut();
myGet();
myContains();
myRemove( );
myValues();
}
/*
* Map接口方法put
*/
public static void myPut() {
//创建Map集合,键是字符串,值是整数
Map<String, Integer> map = new HashMap<String, Integer>();
//集合方法put存储键值对
map.put("a" ,1);
map.put("b",2);
map. put("c",3);
System. out . println(map) ;
}
/*
*Map接口方法get
*/
public static void myGet() {
//创建Map集合 ,键是字符串,值是整数
Map<String, Integer> map = new HashMap<String, Integer>();
//集合方法put存储键值对
map. put("a", 1);
map.put("b", 2);
map.put("c", 4);
//集合方法get(),传递键,获取值
Integer value = map.get("c" );
System. out . println(value) ;
}
/*
*Map接口方法containsKey, containsValue
*/
public static void myContains() {
//创建Map集合,键是字符串,值是整数
Map<String, Integer> map = new HashMap<String, Integer>();
//集合方法put存储键值对
map.put("a",1);
map . put("b", 2);
map.put("C",3);
//判断是否包含键
boolean b = map . containsKey("a");
System. out . println(b) ;
//判断是否包含此值
b = map. containsValue(3);
System. out . println(b) ;
}
/*
*Map接口方法remove
*/
public static void myRemove( ) {
//创建Map集合,键是字符串,值是整数
Map<String, Integer> map = new HashMap<String, Integer>();
//集合方法put存储键值对
map.put("a",1);
map . put("b", 2);
map.put("C",3);
//集合万法remove,移除键值对
Integer value = map. remove("c" );
System. out. println(value);
System. out . println(map) ;
}
/*
*Map接口方法values( )
*/
public static void myValues() {
//创建Map集合，,键是字符串,值是整数
Map<String, Integer> map = new HashMap<String, Integer>();
//集合方法put存储键值对
map.put("a",1);
map . put("b", 2);
map . put("c", 3);
Collection<Integer> coll = map. values();
for(Integer integer : coll) {
System. out . println(linteger) ;
}
}
Map集合遍历一（不能直接使用增强for，Set可以使用）
Map的遍历方法，键找值方法
Map接口定义方法：Set keySet() Map集合的键，取出，存储在Set集合
/*
*Map集合方法keySet( )遍历
*步骤:
*1. Map集合方法keySet()获取存储键的Set集
*2.遍历Set集合
*3.取出Set集合元素,是Map的键
*4. Map集合键,找值
*/
public static void main(String [ ] args) {
Map<String, Integer> map = new HashMap<String, Integer>();
map. put(" abc ",123 ) ;
map.put("bcd",124);
map. put("cde", 125);
// 1. Map集合方法keySet()获取存储键的Set集合
Set<String> set = map.keySet( );
//简介使用Set增强for
for(String key : set){
Integer value = map . get(key);
System. out . println(key + "=="+ map.get(key));
}
//2.遍历Set集合
Iterator<String> it = set. iterator( );
while( it. hasNext()){
//3. 取出Set集合元素,是Map的键
String key = it.next();
//4. Map集合键,找值
Integer value = map. get(key);
System. out . println(key +"=="+ value) ;
}
}
Map集合遍历二
键值对的映射关系遍历：Map.Entry接口，实现类对象表示了键值对的对应关系，拿到Map.Entry接口实现类对象
- Entry接口的方法
。K getKey()取出集合中的键
。V getValue()取出集合中的值 - Map接口定义方法
。Set<Entry<K,V>> entrySet()集合中的键值对映射关系对象，Entry接口对象，存储在Set集合
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<String, Integer>();
map. put("abc", 123);
map. put("bcd", 124);
map. put("cde", 125) ;
//1: Map集合方法entrySet()获取到Entry接口实现类对象, 存储Set集合
Set <Map. Entry<String, Integer> > set = map. entrySet( );
//简介使用Set增强for
for (Map. Entry<String, Integer> entry : set) {
System. out. println( entry . getKey() +"== "+ entry. getValue());
}
//2:遍历Set集合
Iterator<Map. Entry<String,Integer> > it = set. iterator();
while(it. hasNext()) {
//3:取出Set集合中的元素，是Entry接 口的实现类对象(键值对的对应关系)
Map . Entry<String, Integer> entry = it. next();
//4: Entry接口对象,调用方法getKey(), getValue()
String key = entry . getKey();
Integer value = entry .getValue( );
System. out . println(key +"==" + value) ;
}
}
HashMap
java.util.HashMap类，实现Map接口
- HashMap集合特点
。底层是哈希表结构，数组+链表
。默认长度16，加载因子0.75F
。保证存储到键对象的唯一性，做为键的对象，必须重写hashCode和equals
。链表长度达到8个，转成红黑树(尾插)
。线程不安全集合，运行速度快
。集合允许存储null值，null键
pub1ic static void main(String [ ] args) {
method();
}
/*
*HashMap集合, String做为键，Person对 象做为值
*/
public static void method() {
//HashMap集合, String做为键，Person对 象做为值
Map<String, Person> map = new HashMap<String, Person>();
map. put("北京市",new Person("张三" ,20));
map. put("天津市",new Person("李四",21));
map. put("上海市",new Person("王五",22));
map. put("重庆市",new Person("赵六",23));
//keySet方式遍历
Set<String> set = map.keySet();
Iterator<String> it = set. iterator();
while(it. hasNext()) {
String key = it.next();
Person value= map.get(key);
System. out . println(key+"=="+value);
}
//entrySet方式遍历
Set<Map. Entry<String, Person>> entSet = map . entrySet();
Iterator<Map. Entry<String, Person>> enIt = entSet . iterator();
while(enIt . hasNext()) {
Map. Entry<String, Person> entry = enIt.next();
String key = entry. getKey();
Person value = entry.getValue();
System. out. println(key+"== "+value);
}
}
public static void method2() {
//HashMap集合，Person对 象做为键，String做为值
Map<Person, String> map = new HashMap<Person, String>();
map . put(new Person("张三" ,20),"北京市");
map. put(new Person("李四" ,20)，"郑州市");
map . put( new Person("王五",20),"开封市");
map . put(new Person("王瑞" ,20),"北成都市");
//keySet方式遍历
Set<Person> set = map.keySet();
Iterator<Person> it = set . iterator();
while (it.hasNext()) {
Person key = it.next();
String value = map. get(key);
System. out . println(key+"=="+value) ;
}
//entrySet方式遍历
Set<Map. Entry<Person, String>> enSet = map. entrySet();
Iterator<Map. Entry<Person, String>> enIt = enSet. iterator();
while(enIt . hasNext()) {
Map. Entry<Person, String> entry = enIt.next();
Person key = entry. getKey();
String value = entry. getValue();
System. out . println(key+"=="+value);
}
}
LinkedHashMap
java.util.LinkedHashMap类，继承HashMap，实现Map接口
java.util.LinkedHashSet类，继承HashSet，实现Set接口
- LinkedHashMap集合特点
。底层数据结构是哈希表，子类是双向链表
。集合是有序的集合，存储和取出的顺序一致
。线程不安全，运行速度快
public static void main(String[] args) {
LinkedHashMap<String, String> linked = new LinkedHashMap<String, String>();
linked.put("b", "2");
linked. put("d", "4");
linked. put("a", "1");
linked. put("c", "3");
System. out . println(linked);
}
ConcurrentHashMap
Hashtable
java.util.Hashtable类，实现Map接口
- Hashtable集合特点
。底层是哈希表结构
。不能存null值，null键(抛出空指针异常)
。线程安全的集合，运行速度慢
。从JDK1.2版本开始，被更加先进的HashMap取代 - Vector集合，List接口实现类
。线程安全的，可变数组实现
。从JDK1.2开始被更加先进的ArrayList取代
Properties
集合框架包括数组，属于临时性数据，数据在内存中存储
程序退出，关机，数据消失
和IO流技术结合，实现数据的持久化
java.util.Properties类，继承Hashtable，实现接口Map
键值对存储的集合，所有的Map的使用方式，在Properties中全部使用
没有泛型的集合，类定义中，没有使用泛型技术
Properties集合中键值对的数据类型，被锁定为String类型
Properties特有方法
setProperty(String kry,String value)键值对存储到集合中，setProperty==putString getProperty(String key)返回指定键对应的值Set<Stirng> stringPropertyNames()集合的全部键，存储到Set集合
public static void main(String[] args) {
//创建集合对象
Properties prop = new Properties();
//存储键值对
prop. setProperty("a", "1");
prop . setProperty("b","2" );
prop . setProperty("c","3");
System. out . println(prop) ;
//取出键值对
string value = prop. getProperty(" a" );
System . out . println(value);
//遍历集合，键存储到Set集合
Set<String> set = prop . stringPropertyNames( );
Iterator<String> it = set. iterator();
while(it . hasNext()) {
String k = it.next();
String v = prop. getProperty(k)
System. out. println(k+"=="+v);
}
}
Map集合练习
练习一：统计字符串中，每个字符出现的次数
/*
*统计字符串中,每个字符出现的次数
*步骤:
*1:创建字符串
*2:字符串转成char数组
*3:定义Map集合,键是字符,值出现的次数
*4:数组遍历,取出每个元素
*5:数组的元素字符,到集合中找对应的值
*A:找不到= null
*字符做为键, 1做为值，存储回集合
*B:找到了!= null
*字符做为键，找到值++,做为值，存储回集合
*遍历Map，看结果
*/
public static void main(String[] args) {
//1:创建字符串
String str = " abcaba12AwAw13Wffw" ;
//2:字符串转成char数组
char[] chs = str. toCharArray();
//3:定义Map集合,键是字符,值出现的次数
Map<Character, Integer> map = new HashMap<Character, Integer>();
//4:数组遍历,取出每个元素
for(char c : chs) {
//5:数组的元素字符,到集合中找对应的值
Integer value = map.get(c);
//A:找不到= null
if(value ==null) {
//字符做为键,1做为值,存储回集合
map.put(c, 1);
}e1se {
//找到了!= null
//值++
//字符做为键，找到值++,做为值,存储回集合
map.put(c, ++value);
}
}
//6:遍历Map集合,看结果.
// a出现2次，b出现3次,c出现4次. A出现2次, 1出现1次, 2出现1次
for(Character key : map. keySet()) {
Integer value = map. get(key);
System. out . println("字符"+key+"出现了"+value+"次");
}
}
练习二：集合嵌套
List嵌套List
/*
*集合存储到另一个集合中.
*要求: ArrayList集合存储字符串
*ArrayList集合,存储那个存储字符串的集合
*/
public static void main(String[] args) {
//建立集合, 存储字符串.
List<String> smallList = new ArrayList<String>();
smallList . add( "how");
smallList.add("are" );
smallList . add("you");
List<String> smallList2 = new ArrayList<String>();
smallList2. add("i");
smallList2.add("love");
smallList2.add("java");
//建立集合,存储,小集合
List< List<String> > bigList = new Arraylist<List<String>>();
//小集合,存储大集合
bigList. add(smallList);
bigList . add( smallList2);
iterator(bigList );
}
/*
*方法,遍历集合,遍历是大集合
*/
public static void iterator( List< List<String> > bigList ) {
//迭代器,遍历大集合
Iterator< List<String> > bigIt = bigList. iterator();
while( bigIt.hasNext()) {
//取出大集 合中的元素
List<String> smallList = bigIt.next(); //大集合的元素,是小集合
//迭代器遍历小集合
Iterator<String> smallIt = smallList. iterator();
while( smallIt. hasNext()) {
//取出小集合的元素,字符串
String str = smallIt.next();
System. out . println(str) ;
}
}
}
List嵌套Map
/*
*集合嵌套: List集合, 存储Map集合
*/
public static void main(String[] args) {
//创建Map集合，键值字符串
Map<String, String> bigMap1 = new HashMap<String, String>();
bigMap1.put("a1"，"1");
bigMap1. put("a2", "2");
bigMap1. put("a3", "3");
Map<String, String> bigMap2 = new HashMap<String, String>();
bigMap2.put("b1","1");
bigMap2. put("b2","2");
bigMap2. put("bB","3");
//创建List集合,存储Map集合
List< Map<String, String> > bigList = new ArrayList<Map<String, String>>();
//两个小map集合,存储到List集合
bigList . add(bigMap1);
bigList . add(bigMap2);
iterator(bigList );
}
/*
*方法遍历大的List集合
*/
public static void iterator(List< Map<String, String> > bigList) {
//迭代器遍历List集合
Iterator< Map<String, String> > bigIt = bigList . iterator();
while(bigIt .hasNext()) {
//取出List集合的元素
Map<string, String> map = bigIt.next(); //集合 元素是Map集合
//遍历Map集合, keySet方法
Set<String> set = map.keySet();
//迭代器遍历Set集合
Iterator<String> setIt = set. iterator( );
while(setIt . hasNext()) {
//取出Set集合元素,是Map集合键
String key = setIt.next();
//取出Map集合的值
String value = map.get(key);
System . out . println(key+"=="+value) ;
}
}
}
Map嵌套Map
public static void main(String[] args) {
//阶段集合,包含学号,姓名.
Map<String, String> firstMap = new HashMap<String, String>();
//第一阶段,集合,存储字符串
firstMap. put("001", "张三");
firstMap. put("002"，"李四");
Map<String, String> secondMap = new HashMap<String, String>();
//第二阶段集合,存储字符串
secondMap. put("003", "王五");
secondMap. put( "004", "赵六");
//创建学科集合，键是阶段名,值是阶段集合
Map<String, Map<String, String>> javaMap = new HashMap<String, Map<String, String>>();
javaMap.put("第一", firstMap);
javaMap. put("第二", secondMap) ;
keySet(javaMap);
entrySet(javaMap);
}
/*
*方法遍历javaMap集合, keySet()方式
*/
public static void keySet (Map<String, Map<String, String>> javaMap) {
//学科Map集合,遍历,方法keySet(),存储键的Set集合
Set<String> javaSet = javaMap . keySet();
//迭代器遍历Set集合
Iterator<String> javaIt = javaSet. iterator();
while(javaIt. hasNext()) {
//取出Set集合元素,是javaMap集合的键
String javaMapKey = javaIt.next();
//取出javaMap学科集合的值,值是个阶段的Map集合
Map<String, String> jieDuanMap = javaMap . get(javaMapKey);
//遍历阶段的Map集合，调用方法keySet()拿出阶段Map集合的键
Set<String> jieDuanSet = jieDuanMap . keySet();
//迭代器遍历Set集合
Iterator<String> jieDuanIt = jieDuanSet . iterator();
while(jieDuanIt . hasNext()) {
//取出Set集合 的元素,是阶段Map集合的键,学号
String key = jieDuanIt. next();
//取出阶段集合的值,姓名
String value = jieDuanMap. get(key);
System. out. println(javaMapKey+"=="+key+"=="+value);
}
}
}
/*
*方法遍历javaMap集合, entrySet()方式
*/
public static void entrySet(Map<String, Map<String, String>> javaMap) {
//学科集合javaMap,方法entrySet(),获取学科集合的键值对,映射关系对象Entry
Set<Map. Entry<String, Map<String, String>>> javaMapEntrySet = javaMap. entrySet();
//迭代器,遍历Set集合
Iterator<Map . Entry<String, Map<String, String>> javaMapEntryIt = javaMapEntrySet . iterator();
while(javaMapEntryIt. hasNext()) {
//取出Set集合元素，元素是javaMap学科集合的键值对关系对象
Map. Entry<String, Map<String, String>> javaMapEntry = javaMapEntryIt. next();
//获取javaMap阶段集合的键,是阶段名
String javaMapKey = javaMapEntry. getKey();
//获取javaMap集合值，是阶段的集合
Map<String, String> jieDuanMap = javaMapEntry . getValue();
//遍历阶段jieDuanMap,方法entrySet()取出集合的键值对映射关系对象
Set<Map. Entry<String, String>> jieDaunEntrySet = jieDuanMap . entrySet();
//迭代器,遍历Set集合
Iterator<Map. Entry<String, String>> jieDuanEntryIt = jieDaunEntrySet. iterator();
while(jieDuanEntryIt. hasNext()) {
//取出Set集合的键,是阶段集合的键值对映射关系对象
Map . Entry<String, String> jieDuanMapEntry = jieDuanEntryIt .next();
//阶段集合的键,学号
String key = jieDuanMapEntry. getKey();
//阶段集合的值,姓名
String value = jieDuanMapEntry . getValue();
System . out. print1n(javaMapKey+"=="+key+"=="+value) ;
}
}
}
斗地主排序
原理：需要自定义顺序
顺序：333344445555…AAAA2222王王
自定义顺序的思想：编号思想0 1 2 3（数字自然顺序）
每一个牌(字符串)和编号进行对应，键值对思想实现，编号为
键，牌为值
/*
*实现斗地主排序功能
*/
public static void main(String[] args) {
//定义Map集合,键是编号，值存储牌的字符串
Map<Integer, String> pokerMap = new HashMap< Integer, String>();
//定义List,存储编号
List<Integer> pokerList = new ArrayList<Integer>();
//定义变量，保存编号
int index= 0;
//定义花色数组
String[] colors={"♥","♠","♦","♣"};
//定义13个点数数组
String [] numbers={"3","4", "5","6", "7","8", "9","10","J" ,"Q","K","A","2"};
//遍历数组,组合点数和花色
for(String number : numbers) {
for(String color : colors) {
//存储到Map集合中
pokerMap. put(index, color+number ) ;
//编号,存储到List集合
pokerList . add(index);
index++;
}
}
//存储王牌
pokerMap. put(52, "🃏");
pokerMap. put(53, "🃏");
pokerList . add(52);
pokerList . add(53);
//存储编号的List,元素随机排列
Collections . shuffLe(pokerList);
//定义4个集合,List 3个玩家和底牌
List<Integer> player1 = new ArrayList<Integer>( );
List<Integer> player2 = new ArrayList<Integer>();
List<Integer> player3 = new ArrayList<Integer>();
List<Integer> bottom = new ArrayList<Integer>();
//循环遍历,存储编号的集合,进行发牌.
for(int i = 0 ; i < pokerlist.size() ; i++) {
//发底牌
if(i<3){
bottom. add( pokerList.get(i) );
}
//分别发到玩家去
else if(i%3==0){
player1.add( pokerlist.get(i));
}
else if(i%3==1){
player2.add( pokerList . get(i));
}
else if(i%3==2){
player3. add( pokerlist.get(i));
}
}
//玩家集合,牌序号的排序
Collections . sort(player1,Collections. reverseOrder());
collections . sort(player2,Collections. reverseOrder());
Collections. sort(player3,Collections. reverseOrder());
Collections. sort(bottom);
//看牌,玩家集合中的编号,做为键,到Map集合中找值
look("刘德华" , pokerMap, player1);
Look("梁朝伟" , pokerMap, player2);
Look( "周润发" , pokerMap, player3);
Look("底牌", pokerMap , bottom);
}
/*
*定义看牌方法:遍历集合
*需要编号集合,需要存储牌的Map集合
*/
public static void look(String name , Map< Integer , String> map, List<Integer> list) {
System. out. print( name+" ") ;
for(Integer key : list) {
String value = map.get(key);
System. out . print(value+" ") ;
}
System. out. println();
}
扫一扫
561
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
