跟着老毕学Java-集合框架篇之Map与工具类

Map和集合工具类

Map

概述

共性方法

示例代码1

importjava.util.Collection;
importjava.util.HashMap;
importjava.util.Map;
classMapDemo
{
publicstaticvoidmain(String[]args)
{
Map<String,String>map=newHashMap<String,String>();
System.out.println("put:"+map.put("01","zhangsan01"));//结果为null
System.out.println("put:"+map.put("01","wangwu"));//结果我zhangsan01
/*
put如果存入了已经存在的键，则新键值会覆盖旧键值，并将旧键值返回；put存入一个未存在的键时，会返回null。
*/
map.put("02","zhangsan02");
map.put("03","zhangsan02");
map.put(null,null);

System.out.println("containsKey:"+map.containsKey("022"));
//System.out.println("remove:"+map.remove("02"));
System.out.println("get:"+map.get("023"));
map.put("04","null");
System.out.println("get:"+map.get("04"));
//可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断。（毕老师这点讲的是不是有问题？）

//获取map集合中的值
Collection<String>coll=map.values();

System.out.println(coll);
System.out.println(map);
}
}
/*
既然hashMap可以存放null键null值，那么通过get方法返回null，应该不能判断该键是不是存在，因为可能出现有键值为空的情况;这时就要用containsKey()方法来判断了
*/

Map的体系

元素取出的两种方式

示例代码2

/*

map集合的两种取出方式：
1.Set<K>keySet;将map中的所有的键存入到Set集合，因为set具有迭代器。
所以可以迭代方式取出所有的键，再根据get方法，获取每一个键对应的值。
Map集合的取出原理:将Map集合转成Set集合，再通过迭代器取出。
2.Set<Map.Entry<K,V>>entrySet:将Map集合中的映射关系存入到了Set集合中，
而这个关系的数据类型就是：Map.Entry.
*/
importjava.util.HashMap;
importjava.util.Iterator;
importjava.util.Set;
importjava.util.Map;

classMapDemo2
{
publicstaticvoidmain(String[]args)
{
Map<String,String>map=newHashMap<String,String>();
map.put("01","zhangsan01");
map.put("02","zhangsan02");
map.put("03","zhangsan03");
map.put("04","zhangsan04");
System.out.println(map);
System.out.println("-------------");

//Map元素取出的方式一（EntrySet）：将Map集合中的映射关系取出，存入到Set集合中。
Set<Map.Entry<String,String>>entrySet=map.entrySet();
System.out.println(entrySet);
System.out.println("-------------");

Iterator<Map.Entry<String,String>>it=entrySet.iterator();
while(it.hasNext())
{
Map.Entry<String,String>me=it.next();
Stringkey=me.getKey();
Stringvalue=me.getValue();
System.out.println(me);
System.out.println("key:"+key+",value="+value);

}

//元素取出的方式二（KeySet)
/*
//先获取map集合的所有键的Set集合。
Set<String>keySet=map.keySet();
//有了Set集合，就可以获取机迭代器。
Iterator<String>it=keySet.iterator();
while(it.hasNext())
{
Stringkey=it.next();
Stringvalue=map.get(key);
System.out.println("key:"+key+",value="+value);

}
*/
}
}

/*
Map.Entry其实Entry也是一个接口，他是Map接口中的一个内部接口。如下：

interfaceMap
{
publicstaticinterfaceEntry
{
publicabstractObjectgetKey();
publicabstractObjectgetValue();
}
}
classHashMapimplementsMap
{
classHahaimplementsMap.Entry
{
publicObjectgetKey(){}
publicObjectgetValue(){}
}

}
*/

练习1

/*
每一个学生都有对应的归属地
学生Student，地址String
学生属性：姓名，年龄
注意：姓名和年龄相同视为同一个学生
保证学生的唯一性。

1.描述学生
2.定义Map容器，将学生作为键，地址作为值，存入。
3.获取Map集合中的元素。
*/

importjava.util.*;
classMapTest
{
publicstaticvoidmain(String[]args)
{
HashMap<Student,String>hm=newHashMap<Student,String>();
hm.put(newStudent("lisi1",22),"beijing");
hm.put(newStudent("lisi1",22),"shanghai");
hm.put(newStudent("lisi3",24),"wuhan");
hm.put(newStudent("lisi4",25),"nanjing");

//第一种取出方式：keySet()
Iterator<Student>it=hm.keySet().iterator();
while(it.hasNext())
{
Studentstu=it.next();
Stringaddr=hm.get(stu);
System.out.println(stu+".."+addr);
}
System.out.println("-------------");

//第二种取出方式：entrySet()
Set<Map.Entry<Student,String>>entrySet=hm.entrySet();
Iterator<Map.Entry<Student,String>>ite=entrySet.iterator();
while(ite.hasNext())
{
Map.Entry<Student,String>me=ite.next();
Students=me.getKey();
Stringstr=me.getValue();
System.out.println(s+","+str);
}

}
}

/*
为什么将复写equals、hashCode方法，并实现comparable接口？
因为，Sutdent有可能存入HashMap中，也有可能存入TreeMap中。

*/
classStudentimplementsComparable<Student>
{
privateStringname;
privateintage;
Student(Stringname,intage)
{
this.name=name;
this.age=age;
}
publicStringgetName()
{
returnname;
}
publicvoidsetName(Stringname)
{
this.name=name;
}
publicintgetAge()
{
returnage;
}
publicvoidsetAge(intage)
{
this.age=age;
}
publicinthashCode()
{
returnname.hashCode()+37*age;//这点要注意
}
publicbooleanequals(Objectobj)
{
if(!(objinstanceofStudent))
thrownewClassCastException("类型不匹配");
Students=(Student)obj;
returnthis.name.equals(s.getName())&&this.age==s.getAge();
}
publicintcompareTo(Students)
{
intnum=newInteger(this.age).compareTo(newInteger(s.getAge()));
if(num==0)
this.name.equals(s.name);
returnnum;
}
publicStringtoString()
{
returnname+","+age;
}
}

练习2

/*
需求:对学生对象的年龄进行升序排序。

因为数据是以键值对形式存在的,所以要使用可以排序的Map集合，TreeMap。
*/
importjava.util.*;

classStuNameComparatorimplementsComparator<Student>
{
publicintcompare(Students1,Students2)
{
intnum=s1.getName().compareTo(s2.getName());
if(num==0)
returnnewInteger(s1.getAge()).compareTo(s2.getAge());
returnnum;
}
}
classMapTest2
{
publicstaticvoidmain(String[]args)
{
TreeMap<Student,String>tm=newTreeMap<Student,String>(newStuNameComparator());
tm.put(newStudent("lisi1",22),"beijing");
tm.put(newStudent("alisi1",23),"shanghai");
tm.put(newStudent("alisi1",24),"shanghai");
tm.put(newStudent("xlisi3",24),"wuhan");
tm.put(newStudent("lisi4",25),"nanjing");

Iterator<Map.Entry<Student,String>>it=tm.entrySet().iterator();
while(it.hasNext())
{
Map.Entry<Student,String>me=it.next();
Studentstu=me.getKey();
Stringaddr=me.getValue();
System.out.println(stu+","+addr);
}

}
}

练习3

/*
练习：
”stdafasdffadf“获取该字符串中的字母出现的次数。
希望打印结果:a(1)c(2)。。。。

通过结果发现，每个字母都有对应的次数
说明字母和次数之间都有映射关系。

注意了，当发现有映射关系时，可以选择Map集合
因为Map集合中存放的就是映射关系。

什么时候使用Map集合呢？
当数据之间存在这个映射关系时，就要先想到Map集合。
我的思路：
1.建立字母为键，类型为char，次数为值，类型为int，的Map，因为字母按顺序打印，所以选用TreeMap
2.将字符串遍历，重复的字符，值++；
3.使用迭代器打印TreeMap集合。

毕老师思路：
1.将字符串转换成字符数组，因为要对每一个字母进行操作。

2.定义一个map集合，因为打印结果的字母有顺序，所以使用TreeMap集合。

3.遍历字符数组。
将每一个字符作为键去查map集合。
如果返回null，将该字母和1存入到map集合。
如果返回不是null，说明该字母在map集合已经存在，并有对应的次数。
那么就获取该次数进行自增，然后将该字母和自增后的次数存入到map集合中，覆盖调用原键所对应的值。
4.将map集合中的数据变成指定的字符串形式返回。

*/
importjava.util.*;
classMapTest3
{
publicstaticvoidmain(String[]args)
{
//Stringstr=myCharCount("adfasdf!!!!!sssasdfas");
Stringstr=charCount("dsadfadfasdf");
System.out.println(str);
}
//毕老师的方法
publicstaticStringcharCount(Stringstr)
{
char[]chs=str.toCharArray();
TreeMap<Character,Integer>tm=newTreeMap<Character,Integer>();
for(intx=0;x<chs.length;x++)
{
intcount=0;
charch=str.charAt(x);
if(!(ch>='a'&&ch<='z'||ch>='A'&&ch<='Z'))
continue;

Integervalue=tm.get(chs[x]);

/*
if(value==null)
tm.put(chs[x],1);
else
{
value=value+1;
tm.put(chs[x],value);
}
*/
if(value!=null)
count=value;
count++;
tm.put(chs[x],count);
}

StringBuildersb=newStringBuilder();
Set<Map.Entry<Character,Integer>>entrySet=tm.entrySet();
Iterator<Map.Entry<Character,Integer>>it=entrySet.iterator();
while(it.hasNext())
{
Map.Entry<Character,Integer>me=it.next();
Characterch=me.getKey();
Integervalue=me.getValue();
sb.append(ch+"("+value+")");
}
returnsb.toString();

}
//我的方法
publicstaticStringmyCharCount(Stringstr)
{

Stringresault="";
TreeMap<Character,Integer>tm=newTreeMap<Character,Integer>();

intcount=0;
for(intx=0;x<str.length();x++)
{
charch=str.charAt(x);
if(!(ch>='a'&&ch<='z'||ch>='A'&&ch<='Z'))
continue;
if(!tm.containsKey(ch))
tm.put(ch,1);
else
{
intnum=tm.get(ch)+1;
tm.put(ch,num);
}
}

Iterator<Map.Entry<Character,Integer>>it=tm.entrySet().iterator();
while(it.hasNext())
{
Map.Entry<Character,Integer>me=it.next();
charletter=me.getKey();
intnum=me.getValue();
resault+=letter+"("+num+")";
}

returnresault;

}
}

Map扩展

示例代码3

/*
map扩展知识

map集合使用是因为具备映射关系。

“yureban”“01”“zhangsan”
“yureban”“02”"lisi"
"jiuyeban""01""zhousi"
"jiuyeban""02""liuwu"

一个学校有多个教室，每个教室都有自己的名字，而一个教室对应多个学生。

*/
importjava.util.*;
classStudent1
{
privatestaticStringid;
privateStringname;
Student1(Stringid,Stringname)
{
this.id=id;
this.name=name;
}
publicStringtoString()
{
returnid+":::"+name;
}
publicstaticvoidmain(String[]args)
{
Student1s1=newStudent1("id","name");
id="1212";
Integera=Integer.parseInt(id,10);
System.out.println(s1.id);
System.out.println(a);

}

}
classMapDemo3
{
publicstaticvoiddemo()
{
HashMap<String,List<Student1>>czbk=newHashMap<String,List<Student1>>();
List<Student1>yure=newArrayList<Student1>();
List<Student1>jiuye=newArrayList<Student1>();

czbk.put("yuer:",yure);
czbk.put("jiuye:",jiuye);

yure.add(newStudent1("01","zhangsan"));
yure.add(newStudent1("02","wagnwu"));

jiuye.add(newStudent1("01","liuqiang"));
jiuye.add(newStudent1("02","limeng"));

Iterator<String>it=czbk.keySet().iterator();
while(it.hasNext())
{
StringroomName=it.next();
List<Student1>room=czbk.get(roomName);
System.out.println(roomName);
getInfos(room);
}
}
publicstaticvoidgetInfos(List<Student1>room)
{
Iterator<Student1>it=room.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}

publicstaticvoidmain(String[]args)
{
demo();
}

publicstaticvoidgetStudentInfo(HashMap<String,String>hm)
{
Iterator<Map.Entry<String,String>>it=hm.entrySet().iterator();
while(it.hasNext())
{
Map.Entry<String,String>me=it.next();
Stringnum=me.getKey();
Stringname=me.getValue();
System.out.println(num+":"+name);
}
System.out.println(hm);
}
}

集合框架工具类

Collections

2、

synchronizedCollection

(Collection<T>c)

synchronizedList(List<T>list)

synchronizedMap(Map<K,V>m)

synchronizedSet(Set<T>s)

示例代码4：

importjava.util.*;
classCollectionsDemo
{

publicstaticvoidmain(String[]args)
{
sortDemo();
}

publicstaticvoidsortDemo()
{
List<String>list=newArrayList<String>();
list.add("abcdd");
list.add("asdfas");
list.add("saa");
list.add("bbb");
list.add("qt");
list.add("bbb");

sop(list);
//排序演示，要排序的元素继承comparable类或者新建一个比较器。
Collections.sort(list,newStrLenComparator());
sop(list);
sop("----------sort");

//取最大值演示：要排序的元素继承comparable类或者新建一个比较器。
Stringmax=Collections.max(list,newStrLenComparator());
sop(max);
sop("----------max");

//二分查找：必须先是有序集合，前后排序的比较规需要相同，是自然顺序都是自然顺序，是比较器都是比较器。
intindex=Collections.binarySearch(list,"kkkk");
//intindex=halfSearch(list,"aaaa");
sop(index);
sop("----------binarySearch");
/*
我的问题：如果前边排序是用比较器，后来查找的时候没有加比较器，返回值如何？
*/

//reverse：将集合中的元素反转。
Collections.reverse(list);
sop(list);
sop("----------reverse");

//swap():交换集合中两个元素的位置
Collections.swap(list,2,5);
sop(list);
sop("----------swap");

//shufle:使用默认随机源对指定列表进行置换(如洗牌动作、色子)
Collections.shuffle(list);
sop(list);
sop("----------shuffle");

//fill方法：可以将list集合中的所有元素替换成指定元素，
//练习：将list集合中的部分元素替换成指定元素。
sop(list);
Collections.fill(list,"yyyy");
sop(list);
sop("----------fill");
//repalceAll:将集合中的所有的指定元素替换成新元素
Collections.replaceAll(list,"yyyy","00");//其实封装了list.set(index,"00");
sop(list);
sop("----------repalceAll");

}

//二分法原理。
publicstaticinthalfSearch(List<String>list,Stringkey/*,Comparatorcmp*/)
{
intmax,min,mid;
max=list.size()-1;
min=0;

while(min<max)
{
mid=(max+min)>>1;
Stringstr=list.get(mid);
intnum=str.compareTo(key);//intnum=cmp.compare(s1,s2);
if(num>0)
max=mid-1;
elseif(num<0)
min=mid+1;
else
returnmid;
}

returnmin;//-min-1;
}
publicstaticvoidsop(Objectobj)
{
System.out.println(obj);
}
}
classStrLenComparatorimplementsComparator<String>
{
publicintcompare(Strings1,Strings2)
{
if(s1.length()>s2.length())
return1;
if(s1.length()<s2.length())
return-1;
returns1.compareTo(s2);
}
}

示例代码5：

*
Collections.reverseOrder()命令：反转自然顺序或比较器
*/
importjava.util.*;
classStrComparatorimplementsComparator<String>
{
publicintcompare(Strings1,Strings2)
{
/*intnum=s1.compareTo(s2);
if(num>0)
return1;
if(num<0)
return-1;
returnnum;
*/

returns2.compareTo(s1);
}
}
classStrLenComparatorimplementsComparator<String>
{
publicintcompare(Strings1,Strings2)
{
if(s1.length()>s2.length())
return1;
if(s1.length()<s2.length())
return-1;
returns1.compareTo(s2);
}
}

classCollectionsDemo2
{
publicstaticvoidmain(String[]args)
{
orderDemo();
}
publicstaticvoidorderDemo()
{
TreeSet<String>ts=newTreeSet<String>(Collections.reverseOrder(newStrLenComparator()));
ts.add("adsdf");
ts.add("afasdf");
ts.add("efsf");
ts.add("bc");
ts.add("e");

Iterator<String>it=ts.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
}

Arrays

CollectionToArray

示例代码6：

/*
集合变数组。
Collection接口中的toArray方法。
*/
importjava.util.*;
classCollectionToArray
{
publicstaticvoidmain(String[]args)
{
ArrayList<String>al=newArrayList<String>();
al.add("abc1");
al.add("abc2");
al.add("abc3");

/*
1.指定类型的数组到底要定义多长？
当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组，数组的长度为集合的size
当指定类型的数组长度大于了集合的size，就不会新创建数组，而是用传递进来的数组。

所以创建一个刚刚好的数组最优。

2.为什么要将集合变数组？
为了限定对元素的操作。（如返回数据时，将数据变成数组）

*/

String[]arr=al.toArray(newString[0]);
System.out.println(Arrays.toString(arr));

}
}

ArrayToList

示例代码7：

classArraysDemo
{
publicstaticvoidmain(String[]args)
{
//		int[]arr=newint[]{2,5,7};
//		System.out.println(Arrays.toString(arr));

String[]arr={"abc","cc","kkk"};
//把数组编程List集合有什么好处？
/*
可以使用集合的思想和方法来操作数组中的元素。（如判断是否包含：如果是数组，需要进行循环判断））。否则需要自己封装多种方法。

注意：将数组变成集合，不可以使用集合的增删方法(add,remove)，因为数组的长度是固定的。

如果增删了，那么会发生UnsupportedOperationException
*/

List<String>list=Arrays.asList(arr);
//list.add(0,"k");//UnsupportedOperationException
System.out.println(list);

int[]nums={2,5,9};
List<int[]>li=Arrays.asList(nums);

/*
如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素。
如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存储。
*/

sop(li);
Integer[]nums1={2,5,9};
List<Integer>lis=Arrays.asList(nums1);
sop(lis);
}
publicstaticvoidsop(Objectobj)
{
System.out.println(obj);
}
}