黑马程序员_Map集合和Collections工具类

android培训、java培训、期待与您交流！

Map集合及使用

/ *
Map集合：该集合存储键值对。一对一对往里存。而且要保证键的唯一性。

1，添加。
V put(K key,V value); 返回该键对应的原有的值，操作完新值覆盖旧值。
putAll(Map<? extends K,?extends V> m)
2，删除。
clear();
remove(Object key);
3，判断。
boolean containsKey(Objectkey);
boolean containsValue(ObjectValue);
boolean isEmpty();
4，获取。
V get(Object key);
size();
values();

***Map集合的两种取出方式：
entrySet();
keySet();
--------------------------------------------------------------------------------------------------
Map |--HashTable: 底层是哈希表结构，不可以存入null键null值，是线程同步的。效率低
|--HashMap: 底层是哈希表结构，允许使用null键null值，是线程不同步的。效率高
|--TreeMap: 底层是二叉树数据结构，可以用于给Map集合中元素排序线程不同步。
和Set很像，实际上，Set底层就是使用了Map集合。

Map集合的两种取出方式：
1.Set<k> keySet = map.keySet();将Map中所有的键存入到Set集合。
由于Set具备迭代器，用迭代方式取出所有键，再由get方法，获取每一个键对应的值。

原理：将Map集合转成Set集合，元素为键，再通过迭代器取出值。

2.Set< Map.Entry<k,v> > entrySet:
将Map集合中的映射关系存入Set集合中，这个关系的数据类型为Map.Entry。
【Map.Entry】
其实Entry也是一个接口，它是Map接口中的一个内部接口。

代码演示：
import java.util.*;
class MapDemo
{
public static voidmain(String[] args)
{
Map<String,String> map = new HashMap<String, String>();
//添加元素
map.put("01","jack1");
map.put("02","jack2");
map.put("03","jack3");
System.out.println("put:"+map.put("04","jack4"));
System.out.println("put:"+map.put("04","jack5"));//jack5被覆盖

①基本操作
System.out.println("containKey:"+map.containsKey("02"));
System.out.println("remove:"+map.remove("02"));

System.out.println("get:"+ map.get("03"));
//可以通过get方法的返回值来判断一个键是否存在，通过返回null来判断

//获取Map集合中所有的值。
Collection<String> coll = map.values();
System.out.println(coll);
System.out.println(map);

②第一种取出方法：
//先获取map集合的所有键的Set集合，使用keySet();
Set<String> keySet = map.keySet();

//有了Set集合，就可以获取其迭代器。
Iterator<String>it = keySet.iterator();
while(it.hasNext())
{
Stringkey = it.next();
//有了键就可以通过Map集合的get方法获取对应的值
System.out.println("key :"+key+"..."+"value:"+map.get(key));
}
③第二种取出方法：
//讲Map集合中的映射关系取出，存入到Set集合中。
Set<Map.Entry<String,String>> entrySet = map.entrySet();
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("key:"+key+"..."+"value:"+value);
}

}
}
--------------------------------------------------------------------------------------------------
【练习一】：
每一个学生都有对应的归属地。学生Student，地址String。
学生属性：姓名和年龄。姓名和年龄相同视为同一个学生、
需要保证学生的唯一性。
【练习二】：接【练习一】对学生对象的年龄进行升序排序
* /
import java.util.*;
class Student implements Comparable<Student>
{
private String name;
private int age;
Student(String name,int age){
this.name =name;
this.age = age;
}
public StringgetName(){
return name;
}
public int getAge(){
return age;
}
public StringtoString(){
return name+" : "+age;
}
//Map的put操作，会调用containsKey(使用equals)判断，因此需要覆盖hashCode和equals方法。
public int hashCode(){
System.out.println("check1");
returnthis.age*21+this.name.hashCode();
}
public booleanequals(Object obj){
if(!(obj instanceof Student))
throw newClassCastException("Not a student type");

Student p =(Student)obj;
returnthis.name.equals(p.name)&&this.age == p.age;
}
//为了防止Student被装入TreeSet集合时进行排序，需要实现Comparable接口和复写compareTo
public intcompareTo(Student stu){
int num = newInteger(this.age).compareTo(new Integer(stu.age));
if(num == 0)
returnthis.name.compareTo(stu.name);
return num;
}
}
class Comp implements Comparator<Student>//可以利用已经实现Comparable的功能，也可以利用比较器
{
public intcompare(Student s1,Student s2){
int num = newInteger(s1.getAge()).compareTo(new Integer(s2.getAge()));
if(num == 0)
returns1.getName().compareTo(s2.getName());
return num;
}
}
class MapDemo
{
public static voidmain(String[] args)
{
//Map<Student,String> map = new HashMap<Student,String>();
//TreeMap元素需要排序，因此需要定义比较器。
Map<Student,String> map = new TreeMap<Student,String>(newComp());

map.put(newStudent("Emma",22),"Nanjing");
map.put(newStudent("Mike",25),"Beijing");
map.put(newStudent("Jack",20),"Haikou");
map.put(newStudent("Penny",27),"Wuhan");
//map.put(newStudent("Penny",27),"Wuhan");
map.put(newStudent("Lily",27),"Hankou");//覆盖掉上一个Penny

Set<Map.Entry<Student,String>>entryset = map.entrySet();
Iterator<Map.Entry<Student,String>> it =entryset.iterator();
while(it.hasNext())
{
Map.Entry<Student,String> me =it.next();
Student key = me.getKey();
Stringvalue = me.getValue();
//System.out.println("Student:"+key.getName()+""+key.getAge()+"...."+"City:"+value);
System.out.println(key+"..."+value);
}
}
}
/ *
--------------------------------------------------------------------------------------------------
Map扩展知识：

Map集合被使用是因为具备映射关系。
双层映射：
(一对一+一对一)
HashMap<String,HashMap<String,String>>h=newHashMap<String,HashMap<String,String>>();
(一对多)
HashMap<String,List<Student>> h = newHashMap<String,List<Student>>();*//*
--------------------------------------------------------------------------------------------------
【需求】："sdfgzxcvasdfxcvdf"获取该字符串中的字母出现的次数。
打印格式：a(1)c(2)...

通过结果发现，字母的次数之间有映射关系。可以使用Map集合。
* /
import java.util.*;
class Comp implements Comparator<Character>
{
public intcompare(Character ch1,Character ch2){
return (newInteger(ch1)).compareTo(new Integer(ch2));

}
}
class MapTest
{
public static voidmain(String[] args)
{
StringBuilder sb= new StringBuilder("s,dfg,zxcvasd,fxcvdf");

show(sb);
}

public static voidshow(StringBuilder sb){

Map<Character,Integer> map = newTreeMap<Character,Integer>(new Comp());

for (intindex=0; index<sb.length() ;index++ )
{

char ch =sb.charAt(index);
//System.out.println(ch);
if((ch>='a'&&ch<='z')||(ch>='A'&&ch<='Z')) {
if(map.containsKey(ch)){

int value = map.get(ch);
map.put(ch,++value);
}else{
map.put(ch,1);
}
}
}
Set<Character> s = map.keySet();

Iterator<Character> it =s.iterator();
while(it.hasNext())
{
char cha= it.next();
System.out.print(cha+"("+map.get(cha)+")"+"");
}
System.out.println("\n");

}
}

【Collections】：
集合框架的工具类

【sort】：
使用sort的时候，元素必须具有可比性(Comparable的子类)。
public static <T extends Comparable<? super T>> voidsort(List<T> list)
调用方法：Collections.sort(List list);

如果需要使用另外的排序条件，只要改变自定义比较器即可。
public static <T> void sort(List<T> list,Comparator<? super T> c)
一般对象排序都会使用此方法。

-------------------------------------------
【max】：
取最大值也必须是元素可比的。
public static <T> T max(Collection<? extends T> coll,Comparator<? super T> comp)

-------------------------------------------
【binarySearch】:
public static <T> int binarySearch(List<? extendsComparable<? super T>> list,T key)
public static <T> int binarySearch(List<? extends T>list,T key,Comparator<? super T> c)
使用二分搜索法搜索指定列表，以获得指定对象。在进行此调用之前，必须根据列表元素的自
然顺序对列表进行升序排序（通过 sort(List) 方法）。如果没有对列表进行排序，则结果是
不确定的。如果列表包含多个等于指定对象的元素，则无法保证找到的是哪一个。
[参数]：
list - 要搜索的列表。
key - 要搜索的键。
[返回]：
如果搜索键包含在列表中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
插入点被定义为将键插入列表的那一点：即第一个大于此键的元素索引；
如果列表中的所有元素都小于指定的键，则为 list.size()。
注意，这保证了当且仅当此键被找到时，返回的值将 >= 0

-------------------------------------------
【fill】：
public static <T> void fill(List<? super T> list,T obj)
使用指定元素替换指定列表中的[所有]元素。

-------------------------------------------
【replaceAll】:
public static <T> boolean replaceAll(List<T> list,ToldVal, T newVal)
使用另一个值替换列表中出现的所有某一指定值。更确切地讲，使用newVal替换list中满足
(oldVal==null ? e==null : oldVal.equals(e)) 的每个 e 元素。
（此方法对列表的大小没有任何影响。）

-------------------------------------------
【reverse】：
public static void reverse(List<?> list)
反转指定列表中元素的顺序。此方法以线性时间运行。

-------------------------------------------
【reverseOrder】：
1.
public static <T> Comparator<T> reverseOrder()返回一个比较器。
它强行逆转实现了Comparable 接口的对象collection 的自然顺序。
格式：TreeSet<String> ts = newTreeSet<String>(Collections.reverseOrder());
2.
public static <T> Comparator<T> reverseOrder(Comparator<T>cmp)
返回一个比较器，它强行逆转指定比较器的顺序。
如果指定比较器为 null，则此方法等同于 reverseOrder()
格式：...new TreeSet<String>(Collections.reverseOrder(newMyComp()));

-------------------------------------------
【shuffle】：
应用：扑克牌洗牌，骰子重掷等
public static void shuffle(List<?> list)
使用默认随机源对指定列表进行置换。所有置换发生的可能性都是大致相等的。

【Array】
操作数组的工具类：(全都是静态方法)

asList: 将数组变成List集合。
好处：可以使用集合的思想和方法操作数组的元素。
【注意】：将数组变成集合，不可以使用集合的增删方法。因为数组的长度是固定的。
如果增删，会抛出UnsupportedOperationException
如果数组中的元素都是[对象]，变成集合时，数组中的元素就直接转成集合中的元素。
如果数组中的元素都是[基本数据类型]，会将该数组作为集合中的元素存在。