zoukankan      html  css  js  c++  java

  • Java基础---集合

    第一讲    集合框架

    先看下面的图：

    这就是集合框架的构成。由于数据结构的不同，有不同的集合，也叫容器。下面是集合类的简单介绍。

    一、为什么出现集合类？

            面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。

    二、数组和集合类同是容器，有何不同？

            数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。

    三、集合类的特点

            集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

    第二讲     Collection

            Collection是集合框架中的常用接口。其下有两个子接口：List（列表），Set（集）。

           所属关系：

                Collection

                         |--List//元素是有序的，元素可以重复。因为该集合体系有索引。

                         |--Set//元素是无序的，元素不可以重复。

    一、Collection接口中的常见操作

    1、添加元素

            add(Objectobj); //add方法的参数类型是Object。以便于接收任意类型对象。

    2、删除元素

            remove(Objectobj);

            removeAll(另一集合);//调用者只保留另一集合中没有的元素。

            clear();//清空集合

    3、判断元素

            contains(Objectobj);//判断是否存在obj这个元素

            isEmpty();//是否为空

    4、获取个数，集合长度

            size();

    5、取交集

            retainAll(另一集合);//调用者只保留两集合的共性元素。

    注：集合中存储的都是对象的引用（地址）。

    二、迭代

    1、概述

            迭代是取出集合中元素的一种方式。

            对于集合的元素取出这个动作：

            当不足以用一个函数来描述，需要用多个功能来体现，所以就将取出这个动作封装成一个对象来描述。就把取出方式定义在集合的内部，这样取出方式就可以直接访问集合内部的元素。那么取出方式就被定义成了内部类。

            而每一个容器的数据结构不同，所以取出的动作细节也不一样。但是都具有共性内容： 判断和取出。那么就可以将这些共性抽取。

             那么这些内部类都符合一个规则（或者说都抽取出来一个规则）。该规则就是Iterator。通过一个对外提供的方法：iterator();，来获取集合的取出对象。

             因为Collection中有iterator方法，所以每一个子类集合对象都具备迭代器。

    2、迭代的常见操作

            hasNext();//有下一个元素，返回真

            next();//取出下一个元素

            remove();//移除

    注：在迭代时循环中next调用一次，就要hasNext判断一次。

    使用：

             ArrayList a=newArrayList();//创建一个集合

            Iteratorit=a.iterator();//获取一个迭代器，用于取出集合中的元素。

            第一种打印方式：

                    for(Iterator iter = a.iterator();iter.hasNext();  )

                    {

                               System.out.println(iter.next());

                    }

           第二种打印方式：

                     Iteratoriter = a.iterator();

                    while(iter.hasNext())

                   {

                               System.out.println(iter.next());

                   }

    3、迭代注意事项

    • 迭代器在Collcection接口中是通用的，它替代了Vector类中的Enumeration(枚举)。
    • 迭代器的next方法是自动向下取元素，要避免出现NoSuchElementException。
    • 迭代器的next方法返回值类型是Object，所以要记得类型转换。

    第三讲     List

    一、List

    组成

            List：元素是有序的，元素可以重复。因为该集合体系有索引。

                |--ArrayList：底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。

                |--LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢。

                |--Vector：底层是数组数据结构。线程同步。被ArrayList替代了。

    二、List的特有方法

            凡是可以操作角标的方法都是该体系特有的方法。

    1、增

            booleanadd(index,element);//指定位置添加元素

            BooleanaddAll(index,Collection);//在指定位置增加给定集合中的所有元素，若省略位置参数，则在当前集合的后面依次添加元素

    2、删

            Booleanremove(index);//删除指定位置的元素

    3、改

            set(index,element);//修改指定位置的元素。

    4、查

            get(index);//通过角标获取元素

            subList(from,to);//获取部分对象元素

    5、其他

            listIterator();//List特有的迭代器

            indexOf(obj);//获取元素第一次出现的位置，如果没有则返回-1

    注：List集合判断元素是否相同，移除等操作，依据的是元素的equals方法。

    三、ListIterator

    1、概述 

            ListIterator是List集合特有的迭代器，是Iterator的子接口。

           在迭代时，不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException异常。所以在迭代器时，只能用迭代器的方法操作元素。可是Iterator方法是有限的，只能对元素进行判断，取出，删除的操作。如果想要其他的操作，如添加、修改等，就需要使用其子接口：ListIterrator。该接口只能通过List集合的ListIterator方法获取。

    2、ListIterator特有的方法

            add(obj);//增加

            set(obj);//修改为obj

            hasPrevious();//判断前面有没有元素

            previous();//取前一个元素

    四、枚举Enumeration

    枚举：

            就是Vector特有的取出方式。Vector有三种取出方式。

            其实枚举和迭代是一样的。因为枚举的名称以及方法的名称都过长。所以被迭代器取代了。

    特有方法：

             addElement(obj);//添加元素，相当于add(obj);

             Enumerationelements();//Vector特有取出方式(枚举)

             hasMoreElements();//相当于Iterator的hasNext()方法

             nextElements();//相当于Iterator的next()方法

    例：  

    [java] view plaincopy
     
    1. Vector v=new Vector();  
    2.     for(Enumeration e=v.elements();e.hasMoreElements();)  
    3. {  
    4.     System.out.println(e.nextElements());  
    5. }  

    五、LinkedList

            LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢。

    特有方法：

    1、增

            addFirst();

            addLast();

    2、获取

            //获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException

            getFirst();

            getLast();

    3、删

            //获取元素，并删除元素。如果集合中没有元素，会出现NoSuchElementException

            removeFirst();

            removeLast();

    在JDK1.6以后，出现了替代方法。

    1、增

            offFirst();

            offLast();

    2、获取

            //获取元素，但是不删除。如果集合中没有元素，会返回null。

            peekFirst();

            peekLast();

    3、删

            //获取元素，并删除元素。如果集合中没有元素，会返回null。

            pollFirst();

            pollLast();

    示例：

    [java] view plaincopy
     
    1. /* 
    2. 使用LinkedList模拟一个堆栈或者队列数据结构。 
    3.  
    4. 堆栈：先进后出  如同一个杯子。 
    5. 队列：先进先出 First in First out  FIFO 如同一个水管。 
    6.  
    7. */  
    8. import java.util.*;  
    9.   
    10. class LinkedListTest  
    11. {  
    12.     public static void main(String[] args)   
    13.     {  
    14.         LinkedList l=new LinkedList();  
    15.         l.addFirst("java01");  
    16.         l.addFirst("java02");  
    17.         l.addFirst("java03");  
    18.         l.addFirst("java04");  
    19.         l.addFirst("java05");  
    20.       
    21.         //堆栈输出  
    22.     //  stack(l);  
    23.           
    24.         //队列输出  
    25.         queue(l);  
    26.   
    27.     }  
    28.   
    29.     //堆栈  
    30.     public static void stack(LinkedList l)  
    31.     {  
    32.         while (!l.isEmpty())  
    33.         {  
    34.             sop(l.removeFirst());  
    35.         }  
    36.     }  
    37.   
    38.     //队列  
    39.     public static void queue(LinkedList l)  
    40.     {  
    41.         while(!l.isEmpty())  
    42.         {  
    43.             sop(l.removeLast());  
    44.         }  
    45.     }  
    46.   
    47.     //输出  
    48.     public static void sop(Object obj)  
    49.     {  
    50.         System.out.println(obj);  
    51.     }  
    52. }  

    第四讲     Set

    一、概述

            Set：元素是无序（存入和取出的顺序不一定一致），元素不可以重复。     

               |--HashSet：底层数据结构是哈希表。线程不同步。 保证元素唯一性的原理：判断元素的hashCode值是否相同。如果相同，还会继续判断元素的equals方法，是否为true。

               |--TreeSet：可以对Set集合中的元素进行排序。默认按照字母的自然排序。底层数据结构是二叉树。保证元素唯一性的依据：compareTo方法return 0。

            Set集合的功能和Collection是一致的。

    二、HasSet

            HashSet：线程不安全，存取速度快。

           可以通过元素的两个方法，hashCode和equals来完成保证元素唯一性。如果元素的HashCode值相同，才会判断equals是否为true。如果元素的hashCode值不同，不会调用equals。

    注意：HashSet对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法。

    示例：

    [java] view plaincopy
     
    1. /* 
    2. 往hashSet集合中存入自定对象 
    3. 姓名和年龄相同为同一个人，重复元素。去除重复元素 
    4. 思路：1、对人描述，将人的一些属性等封装进对象 
    5.       2、定义一个HashSet容器，存储人对象 
    6.       3、取出 
    7.  
    8. */  
    9. import java.util.*;  
    10.   
    11. //人描述  
    12. class Person  
    13. {  
    14.     private String name;  
    15.     private int age;  
    16.   
    17.     Person(String name,int age)  
    18.     {  
    19.         this.name=name;  
    20.         this.age=age;  
    21.     }  
    22.   
    23.     public String getName()  
    24.     {  
    25.         return name;  
    26.     }  
    27.   
    28.     public int getAge()  
    29.     {  
    30.         return age;  
    31.     }  
    32.   
    33.     public boolean equals(Object obj)  
    34.     {  
    35.         if(!(obj instanceof Person))  
    36.             return false;  
    37.         Person p=(Person)obj;  
    38.         return this.name.equals(p.name)&&this.age==p.age;  
    39.     }  
    40.   
    41.     public int hashCode()  
    42.     {  
    43.         return this.name.hashCode()+this.age;  
    44.     }  
    45. }  
    46. class  HashSetTest  
    47. {  
    48.     public static void main(String[] args)   
    49.     {  
    50.         HashSet h=new HashSet();  
    51.         h.add(new Person("shenm",10));  
    52.         h.add(new Person("shenm2",6));  
    53.         h.add(new Person("shenm1",30));  
    54.         h.add(new Person("shenm0",10));  
    55.         h.add(new Person("shenm0",10));  
    56.           
    57.         getOut(h);  
    58.   
    59.     }  
    60.   
    61.     //取出元素  
    62.     public static void getOut(HashSet h)  
    63.     {  
    64.         for (Iterator it=h.iterator(); it.hasNext(); )  
    65.         {  
    66.             Person p=(Person)it.next();  
    67.             sop(p.getName()+"..."+p.getAge());  
    68.         }  
    69.     }  
    70.   
    71.     //打印  
    72.     public static void sop(Object obj)  
    73.     {  
    74.         System.out.println(obj);  
    75.     }  
    76. }  

    三、TreeSet

    1、特点

            a、底层的数据结构为二叉树结构（红黑树结构）

            b）可对Set集合中的元素进行排序，是因为：TreeSet类实现了Comparable接口，该接口强制让增加到集合中的对象进行了比较，需要复写compareTo方法，才能让对象按指定需求（如人的年龄大小比较等）进行排序，并加入集合伤感的句子。

            java中的很多类都具备比较性，其实就是实现了Comparable接口。

    注意：排序时，当主要条件相同时，按次要条件排序。

    二叉树示意图

            c、保证数据的唯一性的依据：通过compareTo方法的返回值，是正整数、负整数或零，则两个对象较大、较小或相同。相等时则不会存入。

    2、Tree排序的两种方式

            1）第一种排序方式：自然排序

            让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。这种方式也被称为元素的自然顺序，或者叫做默认顺序。

    示例：

    [java] view plaincopy
     
    1. import java.util.*;  
    2. //学生类  
    3. class Student implements Comparable  
    4. {  
    5.     private String name;  
    6.     private int age;  
    7.     Student(String name,int age)  
    8.     {  
    9.         this.name=name;  
    10.         this.age=age;  
    11.     }  
    12.     public String getName()  
    13.     {  
    14.         return name;  
    15.     }  
    16.   
    17.     public int getAge()  
    18.     {  
    19.         return age;  
    20.     }  
    21.     //复写hashCode以便HashSet集合调用  
    22.     public int hashCode()  
    23.     {  
    24.         return name.hashCode()+age;  
    25.     }  
    26.     //复写equals以便HashSet集合和集合中一些比较方法调用  
    27.     public boolean equals(Object obj)  
    28.     {  
    29.         if(!(obj instanceof Student))  
    30.             throw new RuntimeException();  
    31.         Student s = (Student)obj;  
    32.         return this.name.equals(s.name)&&this.age==s.age;  
    33.     }  
    34.     //复写compareTo以便TreeSet集合调用  
    35.     public int compareTo(Object obj)  
    36.     {  
    37.         Student s=(Student)obj;  
    38.         if(this.age==s.age)  
    39.             return this.name.compareTo(s.name);  
    40.         return this.age-s.age;  
    41.         //return new Integer(this.age).compareTo(new Integer(s.age));   
    42.     }  
    43. }  
    44.   
    45. class  TreeSetTest  
    46. {  
    47.     public static void main(String[] args)   
    48.     {  
    49.         TreeSet<Student> t=new TreeSet<Student>();  
    50.         t.add(new Student("wo1",12));  
    51.         t.add(new Student("wosj",2));  
    52.         t.add(new Student("wo1sdj",12));  
    53.         t.add(new Student("wo6sd",12));  
    54.         t.add(new Student("wo",22));  
    55.   
    56.           
    57.         for (Iterator<Student> it=t.iterator(); it.hasNext(); )  
    58.         {  
    59.             Student s=it.next();  
    60.             System.out.println(s.getName()+"....."+s.getAge());  
    61.         }  
    62.     }  
    63. }  

            2）第二种方式：比较器

            当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。

            在集合初始化时，就有了比较方式。定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。

            比较器构造方式：定义一个类，实现Comparator接口，覆盖compare方法淘宝开店。

            当两种排序都存在时，以比较器为主。

    示例：

    [java] view plaincopy
     
    1. /* 
    2. 需求： 
    3. 往TreeSet集合中存储自定义对象学生。 
    4. 想按照学生的年龄进行排序。 
    5.  
    6. */  
    7.   
    8. import java.util.*;  
    9. //学生类  
    10. class Student implements Comparable  
    11. {  
    12.     private String name;  
    13.     private int age;  
    14.     Student(String name,int age)  
    15.     {  
    16.         this.name=name;  
    17.         this.age=age;  
    18.     }  
    19.     public String getName()  
    20.     {  
    21.         return name;  
    22.     }  
    23.   
    24.     public int getAge()  
    25.     {  
    26.         return age;  
    27.     }  
    28.     //复写hashCode以便HashSet集合调用  
    29.     public int hashCode()  
    30.     {  
    31.         return name.hashCode()+age;  
    32.     }  
    33.     //复写equals以便HashSet集合和集合中一些比较方法调用  
    34.     public boolean equals(Object obj)  
    35.     {  
    36.         if(!(obj instanceof Student))  
    37.             throw new RuntimeException();  
    38.         Student s = (Student)obj;  
    39.         return this.name.equals(s.name)&&this.age==s.age;  
    40.     }  
    41.     //复写compareTo以便TreeSet集合调用  
    42.     public int compareTo(Object obj)  
    43.     {  
    44.         Student s=(Student)obj;  
    45.         if(this.age==s.age)  
    46.             return this.name.compareTo(s.name);  
    47.         return this.age-s.age;  
    48.         //return new Integer(this.age).compareTo(new Integer(s.age));   
    49.     }  
    50.   
    51. }  
    52.   
    53. class  TreeSetTest  
    54. {  
    55.     public static void main(String[] args)   
    56.     {  
    57.         TreeSet<Student> t=new TreeSet<Student>(new LenCompare());  
    58.         t.add(new Student("wo1",12));  
    59.         t.add(new Student("wosj",2));  
    60.         t.add(new Student("wo1sdj",12));  
    61.         t.add(new Student("wo6sd",12));  
    62.         t.add(new Student("wo",22));  
    63.   
    64.           
    65.         for (Iterator<Student> it=t.iterator(); it.hasNext(); )  
    66.         {  
    67.             Student s=it.next();  
    68.             System.out.println(s.getName()+"....."+s.getAge());  
    69.         }  
    70.     }  
    71.   
    72. }  
    73. //定义一个比较器，以姓名长度为主要比较  
    74. class LenCompare implements Comparator<Student>  
    75. {  
    76.     public int compare(Student s1,Student s2)  
    77.     {  
    78.         int num=new Integer(s1.getName().length()).compareTo(new Integer(s2.getName().length()));  
    79.         if (num==0)  
    80.         {  
    81.             return new Integer(s1.getAge()).compareTo(s2.getAge());  
    82.         }  
    83.         return num;  
    84.     }  
    85. }  

    第五讲     Map集合

    一、概述

    1、简述：

            Map<K,V>集合是一个接口，和List集合及Set集合不同的是，它是双列集合，并且可以给对象加上名字，即键（Key）

    2、特点：

            1）该集合存储键值对，一对一对往里存

            2）要保证键的唯一性。

     

    二、Map集合的子类

            Map

                |--Hashtable：底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。JDK1.0，效率低。

                |--HashMap：底层是哈希表数据结构。允许使用null键null值，该集合是不同步的。JDK1.2，效率高。

                |--TreeMap：底层是二叉树数据结构。线程不同步。可以用于给Map集合中的键进行排序。

            Map和Set很像。其实Set底层就是使用了Map集合。

     

    三、Map集合的常用方法

    1、添加

            Vput(K key,V value);//添加元素，如果出现添加时，相同的键，那么后添加的值会覆盖原有键对应值，并put方法会返回被覆盖的值。

            voidputAll(Map <? extends K,? extends V> m);//添加一个集合

    2、删除

            clear();//清空

            Vremove(Object key);//删除指定键值对

    3、判断

            containsKey(Objectkey);//判断键是否存在

            containsValue(Objectvalue)//判断值是否存在

            isEmpty();//判断是否为空

    4、获取

            Vget(Object key);//通过键获取对应的值

            size();//获取集合的长度

            Collection<V>value();//获取Map集合中所以得值，返回一个Collection集合

    还有两个取出方法，接下来会逐个讲解：

            Set<Map.Entry<K,V>>entrySet();

            Set<K>  keySet();

    注：HashMap集合可以通过get()方法的返回值来判断一个键是否存在，通过返回null来判断。

    四、Map集合的两种取出方式

            Map集合的取出原理：将Map集合转成Set集合。再通过迭代器取出。

    1、Set<K> keySet()：将Map中所以的键存入到Set集合。因为Set具备迭代器。所以可以通过迭代方式取出所以键的值，再通过get方法。获取每一个键对应的值。

    示例：

    [java] view plaincopy
     
    1. /* 
    2. 每一个学生都有对应的归属地。 
    3. 学生Student，地址String。 
    4. 学生属性：姓名，年龄。 
    5. 注意：姓名和年龄相同的视为同一个学生。 
    6. 保证学生的唯一性。 
    7.  
    8. 思路：1、描述学生类 
    9.       2、定义一个Map集合，存储学生对象和地址值 
    10.       3、获取Map中的元素 
    11. */  
    12.   
    13. import java.util.*;  
    14.   
    15. //描述学生类  
    16. class Student implements Comparable<Student>  
    17. {  
    18.     private String name;  
    19.     private int age;  
    20.     Student(String name,int age)  
    21.     {  
    22.         this.name=name;  
    23.         this.age=age;  
    24.     }  
    25.     public String getName()  
    26.     {  
    27.         return name;  
    28.     }  
    29.   
    30.     public int getAge()  
    31.     {  
    32.         return age;  
    33.     }  
    34.   
    35.     //复写hashCode  
    36.     public int hashCode()  
    37.     {  
    38.         return name.hashCode()+age*33;   
    39.     }  
    40.     //复写equals，比较对象内容  
    41.     public boolean equals(Object obj)  
    42.     {  
    43.         if(!(obj instanceof Student))  
    44.             throw new ClassCastException("类型不匹配");  
    45.         Student s=(Student)obj;  
    46.         return this.name.equals(s.name)&&this.age==s.age;  
    47.     }  
    48.   
    49.     //复写compareTo,以年龄为主  
    50.     public int compareTo(Student c)  
    51.     {  
    52.         int num=new Integer(this.age).compareTo(new Integer(c.age));  
    53.         if(num==0)  
    54.         {  
    55.             return this.name.compareTo(c.name);  
    56.         }  
    57.         return num;  
    58.     }  
    59.   
    60.     //复写toString，自定义输出内容  
    61.     public String toString()  
    62.     {  
    63.         return name+"..."+age;  
    64.     }  
    65.   
    66. }  
    67. class  HashMapTest  
    68. {  
    69.     public static void main(String[] args)   
    70.     {  
    71.         HashMap<Student,String > hm=new HashMap<Student,String >();  
    72.         hm.put(new Student("zhangsan",12),"beijing");  
    73.         hm.put(new Student("zhangsan",32),"sahnghai");  
    74.         hm.put(new Student("zhangsan",22),"changsha");  
    75.         hm.put(new Student("zhangsan",62),"USA");  
    76.         hm.put(new Student("zhangsan",12),"tianjing");  
    77.   
    78.         keyset(hm);  
    79.     }  
    80.   
    81.     //keySet取出方式  
    82.     public static void keyset(HashMap<Student,String> hm)  
    83.     {  
    84.         Iterator<Student> it=hm.keySet().iterator();  
    85.   
    86.         while(it.hasNext())  
    87.         {  
    88.             Student s=it.next();  
    89.             String addr=hm.get(s);  
    90.             System.out.println(s+":"+addr);  
    91.         }  
    92.     }  
    93. }  

    2、Set<Map.Entry<K,V>>   entrySet()：将Map集合中的映射关系存入到Set集合中，而这个关系的数据类型就是：Map.Entry

           其实，Entry也是一个接口，它是Map接口中的一个内部接口。   

    [java] view plaincopy
     
    1. interface Map  
    2.     {  
    3.          public static interface Entry  
    4.          {  
    5.               public abstract Object getKey();  
    6.               public abstract Object getValue();  
    7.          }  
    8.  }  

    示例：

           同上面示例的学生类----

    [java] view plaincopy
     
    1. class  HashMapTest  
    2. {  
    3.     public static void main(String[] args)   
    4.     {  
    5.         HashMap<Student,String > hm=new HashMap<Student,String >();  
    6.         hm.put(new Student("zhangsan",12),"beijing");  
    7.         hm.put(new Student("zhangsan",32),"sahnghai");  
    8.         hm.put(new Student("zhangsan",22),"changsha");  
    9.         hm.put(new Student("zhangsan",62),"USA");  
    10.         hm.put(new Student("zhangsan",12),"tianjing");  
    11.   
    12.         entryset(hm);  
    13.     }  
    14. //entrySet取出方式  
    15.     public static void entryset(HashMap<Student,String> hm)  
    16.     {  
    17.         Iterator<Map.Entry<Student,String>> it=hm.entrySet().iterator();  
    18.   
    19.         while(it.hasNext())  
    20.         {  
    21.             Map.Entry<Student,String> me=it.next();  
    22.             Student s=me.getKey();  
    23.             String addr=me.getValue();  
    24.             System.out.println(s+":::"+addr);  
    25.         }  
    26.     }  
    27. }  

    关于Map.Entry：

            Map是一个接口，其实，Entry也是一个接口，它是Map的子接口中的一个内部接口，就相当于是类中有内部类一样。为何要定义在其内部呢？

            原因：a、Map集合中村的是映射关系这样的两个数据，是先有Map这个集合，才可有映射关系的存在，而且此类关系是集合的内部事务。

                         b、并且这个映射关系可以直接访问Map集合中的内部成员，所以定义在内部。

    五、Map集合的应用及扩展

    1、何时使用Map集合：当量数据之间存在着映射关系的时候，就应该想到使用Map集合。

    2、示例：

            获取该字符串中的字母出现的次数，如："sjokafjoilnvoaxllvkasjdfns"；希望打印的结果是：a(3)c(0).....

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

    [java] view plaincopy
     
    1. /* 
    2. 思路：1、将字符串转换为字符数组 
    3.       2、定义一个TreeMap集合，用于存储字母和字母出现的次数 
    4.       3、用数组去遍历集合，如果集合中有该字母则次数加1，如果集合中没有则存入 
    5.       4、将TreeMap集合中的元素转换为字符串 
    6. */  
    7. package TreeMapTest;  
    8. import java.util.*;  
    9.   
    10. class CharCount  
    11. {  
    12.     public static void main(String[] args)   
    13.     {  
    14.         String s="sdfgzxcvasdfxcvdf";  
    15.         System.out.println("s中各字母出现的次数："+charCount(s));  
    16.     }  
    17.   
    18.     //定义一个方法获取字符串中字母出现的次数  
    19.     public static String charCount(String str)  
    20.     {  
    21.         char[] cha=str.toCharArray();//转换为字符数组  
    22.   
    23.         //定义一个TreeMap集合，因为TreeMap集合会给键自动排序  
    24.         TreeMap<Character,Integer> tm=new TreeMap<Character,Integer>();  
    25.   
    26.         int count=0;//定义计数变量  
    27.         for (int x=0;x<cha.length ;x++ )  
    28.         {  
    29.             if(!(cha[x]>='a'&&cha[x]<='z'||cha[x]>='A'&&cha[x]<='Z'))  
    30.                 continue;//如果字符串中非字母，则不计数  
    31.             Integer value=tm.get(cha[x]);//获取集合中的值  
    32.             if(value!=null)//如果集合中没有该字母，则存入  
    33.                 count=value;  
    34.             count++;  
    35.             tm.put(cha[x],count);//存入键值对  
    36.             count=0;//复位计数变量  
    37.         }  
    38.            
    39.          StringBuilder sb=new StringBuilder();//定义一个容器  
    40.   
    41.         //遍历集合，取出并以题目格式存入容器中  
    42.         for(Iterator<Character> it=tm.keySet().iterator();it.hasNext();)  
    43.         {  
    44.             Character ch=it.next();  
    45.             Integer value=tm.get(ch);  
    46.             sb.append(ch+"("+value+")");  
    47.         }  
    48.         return sb.toString();//返回字符串       
    49.     }  
    50. }  

    六、Map扩展知识

            在很多项目中，应用比较多的是一对多的映射关系，这就可以通过嵌套的形式将多个映射定义到一个大的集合中，并将大的集合分级处理，形成一个体系。

    如：

    [java] view plaincopy
     
    1. /* 
    2. map扩展知识。 
    3. map集合被使用是因为具备映射关系。 
    4. 以下是班级对应学生，而学生中学号对应着姓名的映射关系： 
    5. "yureban"   Student("01" "zhangsan"); 
    6.  
    7. "yureban" Student("02" "lisi"); 
    8.  
    9. "jiuyeban" "01" "wangwu"; 
    10. "jiuyeban" "02" "zhaoliu"; 
    11.  
    12. 就如同一个学校有多个教室。每一个教室都有名称。 
    13. */  
    14. import java.util.*;  
    15.   
    16. class  MapExpandKnow  
    17. {  
    18.     public static void main(String[] args)   
    19.     {  
    20.         //预热班集合  
    21.         HashMap<String,String> yureban=new HashMap<String,String>();  
    22.         //就业班集合  
    23.         HashMap<String,String> jiuyeban=new HashMap<String,String>();  
    24.         //学校集合  
    25. HashMap<String,HashMap<String,String>> czbk=new HashMap<String,HashMap<String,String>>();  
    26.           
    27.         //学校中班级集合和名称的映射  
    28.         czbk.put("yureban",yureban);  
    29.         czbk.put("jiuyueban",jiuyeban);  
    30.           
    31. //预热班级中学号与姓名的映射  
    32.         yureban.put("01","zhangsan");  
    33.         yureban.put("02","lisi");  
    34.           
    35.         //就业班级中学号与姓名的映射  
    36.         jiuyeban.put("01","wangwu");  
    37.         jiuyeban.put("02","zhouqi");  
    38.               
    39.             //直接显示全部学生信息  
    40.         getAllStudentInfo(czbk);  
    41.   
    42.     }  
    43.     //定义一个方法获取全部学生信息，包括在哪个班级，叫什么名字，学号多少  
    44.     public static void getAllStudentInfo(HashMap<String ,HashMap<String,String>> hm)  
    45.     {  
    46.         for (Iterator<String> it=hm.keySet().iterator();it.hasNext() ; )//用keySet取出方式  
    47.         {  
    48.             String s= it.next();//班级名称  
    49.             System.out.println(s+":");  
    50.             HashMap<String,String> stu=hm.get(s);//班级集合  
    51.   
    52.             getStudentInfo(stu);  
    53.         }  
    54.     }  
    55.       
    56.     //获取班级中学生的信息，包括姓名和学号  
    57.     public static void getStudentInfo(HashMap<String,String> hm)  
    58.     {  
    59.         for (Iterator<String> it=hm.keySet().iterator();it.hasNext() ; )  
    60.         {  
    61.             String key=it.next();//学号  
    62.             String value=hm.get(key);//姓名  
    63.             System.out.println(key+"..."+value);  
    64.         }  
  • 相关阅读:
    【POJ1958】汉诺塔+
    hdu 5067(暴力搜索)
    hdu 5063(思路题-反向操作数组)
    hdu 5062(水题)
    hdu 2227(树状数组+dp)
    hdu 5480(维护前缀和+思路题)
    hdu 2492(树状数组)
    hdu 1394(树状数组)
    poj 2299(离散化+树状数组)
    poj 3321(树状数组)
  • 原文地址：https://www.cnblogs.com/tiankong101/p/4227166.html
Copyright © 2011-2022 走看看