黑马程序员_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

如果数组中的元素都是[对象]，变成集合时，数组中的元素就直接转成集合中的元素。

如果数组中的元素都是[基本数据类型]，会将该数组作为集合中的元素存在。