JAVA10Collection2.docx
《JAVA10Collection2.docx》由会员分享，可在线阅读，更多相关《JAVA10Collection2.docx（18页珍藏版）》请在冰点文库上搜索。
JAVA10Collection2
JAVA基础
集合-MAP
•Map用于保存具有映射关系的数据
•Map特性:
1.Map集合里保存着两组值：
键值对
一组用于保存Map里的key-》set
一组用于保存Map里的value-》list
2.key和value可是任何引用类型的数据,key和value都可以为null
3.key不允许重复，即同一个Map对象的任何两个key通过equals方法比较总是返回false
4.key和value之间存在单向一对一关系，即通过指定的key，总能找到唯一的、确定的value
5.所有的key放在一起来看，它们就组成了一个Set集合（无序、不重复），Map提供了一个keySet（）方法用于返回Map所有key组成的Set集合
6.所有value放在一起来看，它们又非常类似于一个List（有序，可重复），每个元素可以根据索引来查找，只是Map中的索引不再是数值，而是另一对象来做索引
importjava.util.Collection;
importjava.util.HashMap;
importjava.util.Iterator;
importjava.util.Map;
importjava.util.Map.Entry;
importjava.util.Set;
publicclassMapDemo{
publicstaticvoidmain（String[]args）{
//Map定义
//HashMapextendsAbstractMapimplementsMap
//LinkedHashMap
Mapmap=newHashMap（）;
//map中添加值
map.put（"a","a"）;
map.put（"b","b"）;
map.put（"c","c"）;
map.put（"d","c"）;
//添加时替换对应key值得value
map.put（"d","d"）;
//获取map中元素的个数
System.out.println（map.size（））;
System.out.println（map.get（"d"））;
System.out.println（map.containsKey（"d"））;
System.out.println（map.containsValue（"d"））;
//返回删除的key
System.out.println（map.remove（"d"））;
//如果key值在map中不存在映射关系，则返回null
System.out.println（map.remove（"d"））;
if（null==map.remove（"d"））{
System.out.println（"key值在map中不存在映射关系"）;
}else{
System.out.println（"删除成功"）;
}
//map=null;调用方法会有什么问题
map.clear（）;//
//不存在任何的元素
System.out.println（map.isEmpty（））;
map.put（"a","a"）;
map.put（"b","b"）;
map.put（"c","c"）;
//map.put（"d","c"）;
//没有就不管
map.replace（"d","d"）;
System.out.println（map.get（"d"））;//null
//java.lang.ClassCastException
//遍历map中所有的值，map是键值对，keyvalue
Collectioncoll=map.values（）;//collection
//子接口指向父接口实现类实例ClassCastException本质上向上指
//父接口指向子接口实现类的实例，子接口变量指向父接口变量（强转）
//本质上向下指
//for-each遍历
for（Stringstr:
coll）{
System.out.println（str）;
}
System.out.println（"*********************"）;
//迭代器遍历
Iteratoriterator=coll.iterator（）;
while（iterator.hasNext（））{
System.out.println（iterator.next（））;
}
System.out.println（"*********************"）;
//可以通过遍历key值来遍历整个map
SetsetStrs=map.keySet（）;
for（Stringstr:
setStrs）{
System.out.println（str）;
}
System.out.println（"*********************"）;
Iteratorite=setStrs.iterator（）;
while（ite.hasNext（））{
//搞清楚next什么含义
Stringstr=ite.next（）;
System.out.println（str+","+map.get（str））;
}
//遍历mapEntry类封装了一个key-value对象
Set>entry=map.entrySet（）;
for（Entryen:
entry）{
System.out.println（en.getKey（））;
System.out.println（en.getValue（））;
}
System.out.println（map.toString（））
map.put（"王五","a"）;
map.put（"李四","b"）;
map.put（"张三","c"）;
map.put（"赵六","c"）;
map.put（"刘七","c"）;
System.out.println（"========================="）;
Set>entry1=map.entrySet（）;
//数据插入顺序与输出的顺序不一致
for（Entryen:
entry1）{
System.out.println（en.getKey（）+","+en.getValue（））;
}
}
}
•HashMap判断两个key相等的标准是:
两个key通过equals方法比较返回true，两个key的hashCode值也相等。
•当使用自定义的类作为HashMap的key时，如果重写该类的equals（Objectobj）和hashCode方法，应该保证两个方法判断标一致
publicclassCourse{
privateStringcourseName;
privateStringcourseId;
publicCourse（）{
}
publicCourse（StringcourseName,StringcourseId）{
super（）;
this.courseName=courseName;
this.courseId=courseId;
}
publicStringgetCourseName（）{
returncourseName;
}
publicvoidsetCourseName（StringcourseName）{
this.courseName=courseName;
}
publicStringgetCourseId（）{
returncourseId;
}
publicvoidsetCourseId（StringcourseId）{
this.courseId=courseId;
}
@Override
publicStringtoString（）{
return"Course[courseName="+courseName+",courseId="+courseId+"]";
}
}
publicclassStudentimplementsComparable{
privateStringname;
privateStringsno;
publicStudent（）{
}
publicStudent（Stringname,Stringsno）{
super（）;
this.name=name;
this.sno=sno;
}
publicStringgetName（）{
returnname;
}
publicvoidsetName（Stringname）{
this.name=name;
}
publicStringgetSno（）{
returnsno;
}
publicvoidsetSno（Stringsno）{
this.sno=sno;
}
@Override
publicStringtoString（）{
return"Student[name="+name+",sno="+sno+"]";
}
@Override
publicinthashCode（）{
finalintprime=31;
intresult=1;
result=prime*result+（（sno==null）?
0:
sno.hashCode（））;
returnresult;
}
@Override
publicbooleanequals（Objectobj）{
if（this==obj）
returntrue;
if（obj==null）
returnfalse;
if（getClass（）!
=obj.getClass（））
returnfalse;
Studentother=（Student）obj;
if（sno==null）{
if（other.sno!
=null）
returnfalse;
}elseif（!
sno.equals（other.sno））
returnfalse;
returntrue;
}
@Override
publicintcompareTo（Studento）{
return-1;
}
}
importjava.util.ArrayList;
importjava.util.HashMap;
importjava.util.List;
importjava.util.Map;
importjava.util.Map.Entry;
importjava.util.Set;
publicclassMapStu{
//创建HashMap，key值是Student对象value是course集合
publicstaticvoidmain（String[]args）{
Map>map=newHashMap>（）;
//学生不能重复，即map中的key值不能重复
Studentstudent=newStudent（"tzhang","08070245"）;
ListcourList=newArrayList（）;
courList.add（newCourse（"C语言","001"））;
courList.add（newCourse（"Java","002"））;
map.put（student,courList）;
//
Studentstudent1=newStudent（"jpXi","08070246"）;
//student1与这个new的courList绑定，绑定的是courList的引用
//此后只要在这个引用上发生的变化，都会影响到这个学生课程的变化。
map.put（student1,courList）;
Studentstudent2=newStudent（"jpXi","08070246"）;
//没有重写student的hashcode和equals方法，使新new出来的两个对象
//都可以加入到map中，因为map的key相等的判读标准时，key对应的hashcode
//相等，equals返回true
map.put（student2,courList）;
//没重写student类的hashcode和equals方法前是3
//重写后student2添加不成功，因为他与student1的hashcode相同
//equals也为true，故认为hashmap中这个key是重复的，所以添加不了
System.out.println（map.size（））;
//遍历输出，看着很复杂，其实很简单，只要知道set集合中泛型是哪部分
//对应的遍历就简单了
Set>>stuEntry=map.entrySet（）;
for（Entry>sc:
stuEntry）{
Studentstu=sc.getKey（）;
ListcL=sc.getValue（）;
//默认调用toString方法
System.out.println（stu.toString（））;
System.out.println（cL）;
}
ListcourList1=newArrayList（）;
courList1.add（newCourse（"C++","003"））;
courList1.add（newCourse（"C#","004"））;
map.replace（student1,courList1）;
System.out.println（"=================================="）;
Set>>stuEntry1=map.entrySet（）;
for（Entry>sc:
stuEntry1）{
Studentstu=sc.getKey（）;
ListcL=sc.getValue（）;
//默认调用toString方法
System.out.println（stu.toString（））;
System.out.println（cL）;
}
//重新new只是改变了集合变量的引用关系，new会产生一个新的引用
//对原来的集合没有影响，原集合的数据保持不变
courList=newArrayList（）;
//改变新创建的集合不会对原集合产生影响，因为引用关系已经发生变化
courList.addAll（courList1）;
System.out.println（"=================================="）;
Set>>stuEntry2=map.entrySet（）;
for（Entry>sc:
stuEntry2）{
Studentstu=sc.getKey（）;
ListcL=sc.getValue（）;
//默认调用toString方法
System.out.println（stu.toString（））;
System.out.println（cL）;
}
}
}
•SortedMap接口和TreeMap实现类
Set接口派生出了SortedSet子接口，SortedSet接口有一个TreeSet实现类，Map接口也派生了一个SortedMap子接口，SortedMap也有一个TreeMap实现类。
•TreeMap也有两中排序方式:
1.自然排序:
TreeMap的所有key必须实现Comparable接口，而且所有key应该是同一个类的对象，否则将会抛出ClassCastException异常
2.定制排序:
创建TreeMap时，传入一个Comparator对象，该对象负责对TreeMap中有key进行排序。
采用定制排序时不要求Map的key实现Comparable接口
类似于TreeSet中判断两个元素相等的标准，TreeMap中判断两个key相等的标准也是两个key通过equals比较返回true，而通过compareTo方法返回0,TreeMap即认为这两个key是相等的。
importjava.util.ArrayList;
importjava.util.Comparator;
importjava.util.Iterator;
importjava.util.List;
importjava.util.Map.Entry;
importjava.util.Set;
importjava.util.SortedMap;
importjava.util.TreeMap;
publicclassTreeMapStu{
publicstaticvoidmain（String[]args）{
//SortedMap>smc=newTreeMap>（）;
SortedMap>smc=newTreeMap>（
newComparator（）{
@Override
publicintcompare（Studento1,Studento2）{
//TODOAuto-generatedmethodstub
returno1.getName（）.compareTo（o2.getName（））;
}
}
）;
Studentstudent=newStudent（"tzhang","08070245"）;
ListcourList=newArrayList（）;
courList.add（newCourse（"C语言","001"））;
courList.add（newCourse（"Java","002"））;
smc.put（student,courList）;
Studentstudent1=newStudent（"jpXi","08070246"）;
smc.put（student1,courList）;
Set>>sl=smc.entrySet（）;
//遍历自己写
//迭代器遍历
Iterator>>enList=sl.iterator（）;
while（enList.hasNext（））{
Entry>entry=enList.next（）;
System.out.println（entry.getKey（））;
System.out.println（entry.getValue（））;
}
}
}
Collections
Java提供了一个操作Set、List和Map等集合的工具类：
Collections，该工具类里提供了大量方法对集合元素进行排序、查询和修改等操作,还提供了将集合对象设置为不可变、对集合对象实现同步控制等方法。
importjava.util.ArrayList;
importjava.util.Collections;
importjava.util.HashMap;
importjava.util.List;
importjava.util.Map;
/**
*集合操作工具类
*类似于Arrays
*@authortzhang
*
*/
publicclassCollectionsDemo{
publicstaticvoidmain（String[]args）{
Listlist=newArrayList（）;
list.add（"张三"）;
list.add（"李四"）;
list.add（"王五"）;
list.add（"赵六"）;
list
升级会员 