Java基础知识——集合体系回顾整理（List Set Map）

（一）Collection

|--Collection（接口）

      

|--List(接口)：有序，可重复（有角标），特有迭代器ListIterator，允许多个null

              |--ArrayList（类）：不同步，查询快，增删稍慢，底层是数组结构

              |--LinkedList（类）：不同步，查询稍慢，增删快，底层是链表结构

              |--Vector（类）：同步，效率低，底层是数组结构，已被ArrayList取代

 

|--Set（接口）：无序，不可重复，没有索引

              |--HashSet（类）：底层是hash表，不同步，通过hashCode和equals保证唯一

              |--TreeSet（类）：底层二叉树，不同步，使用自然顺序（默认）或比较器进行排序

 

（二）Map

|--Map（接口）

|--Hashtable（类）：底层是Hash表结构，不可以存入null键值。同步，.效率低

。

       |--HashMap：底层是Hash表结构，允许用 null 值键，不同步，替代HashTable效率高。

 

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

 

（ps：Set底层就是用来Map结构中的Key）

 

 

（三）工具类Collections

由于Collections中全部为静态方法，因此不用实现对象，可以通过Collections.方法名（）来使用。

 

常用方法：

（1）      sort：对List排序，可以自然排序，也可传入比较器。

（2）      max/min：获得collection的最大/小值，可指定比较器

（3）      BinarySearch：二分查找，可指定比较器

（4）      Fill：用指定元素替换List中所有元素

（5）      replaceAll：使用指定值替换List中所有某一指定值

（6）      reverse：翻转指定List中的所有顺序

（7）      reverseOrder：返回一个比较器，强行逆转自然顺序

（8）      shuffle：使用默认随机源对List顺序进行置换

（9）      synchronizedSet/ synchronizedMap/synchronizedList/ synchronizedCollection：

返回一个同步的（线程安全的）Set/Map/List/Collection

 

（四）工具类Arrays

       Arrays中同样全为静态方法，主要用于对数组进行各种操作（搜索或排序）。

 

       常用方法：

（1）      BinarySearch：二分查找，可查找任意类型数组，可指定比较器，可指定比较范围。

（2）      hashCode：基于指定数组内容返回哈希码

（3）      sort：升序排序，可指定范围，也可指定比较器

 

 

 

（五）必要练习

 

1、对“shemsasls,fkfhlskf.fdhg:hah”字符串进行操作，获取该字符串中字母出现的次数

打印格式：a(4)b(1)......

 

2、对学生对象的年龄进行升序排序，因为数据是以键值对的形式存在，所以要使用可以排序的Map集合——TreeMap

 

 

 

练习答案：

1、

/*
需求：对“shemsasls,fkfhlskf.fdhg:hah”字符串进行操作，获取该字符串中字母出现的次数
打印格式：a(4)b(1)......
*/
 
import java.util.*;
class MapTest
{
       publicstatic void main(String[] args)
       {
              Stringstr = "shemsasls,fkfhlskf.fdhg:hah";
 
              TreeMap<Character,Integer>tm = new TreeMap<Character,Integer>();
 
              char[]ch = str.toCharArray();
 
              intnum = 0;
              for(int i = 0; i < str.length(); i++ )
              {
                     if(!(ch[i]>='a' && ch[i]<='z' || ch[i]>='A' &&ch[i]<='Z'))
                     {
                            continue;
                     }
                     Integervalue = tm.get(ch[i]);
                     if(value!= null)
                     {
                            num= value;
                     }
                     tm.put(ch[i],++num);
                    
                     num= 0;
 
              }
 
             
 
              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();
                     Characterkey = me.getKey();
                     Integervalue = me.getValue();
                     System.out.print(key+"("+value+")");
 
              }
       }
}

2、

import java.util.*;
import static java.lang.System.*;
/*
 
需求：对学生对象的年龄进行升序排序，因为数据是以键值对的形式存在，所以要使用可以排序的Map集合——TreeMap
 
*/
 
class TreeMapDemo
{
       publicstatic void main(String[] args)
       {
              TreeMap<Student,String>tm = new TreeMap<Student,String>(new MyComparator());
 
              tm.put(newStudent("zhangsan3",23),"nanjin");
              tm.put(newStudent("zhangsan2",22),"shanghai");
              tm.put(newStudent("zhangsan4",22),"tianjin");
              tm.put(newStudent("zhangsan1",21),"beijin");
              /*
              Map遍历有两种方法，setKey()和Map.entrySet(),他们都可以遍历Map，但是在速度上有差别。
              setKey()的速度较慢，因为他实际上遍历了两遍，第一遍的时候取出key，第二遍的时候通过key的set集合取出所有value。
              Map.entrySet()速度较快，因为它只遍历了一遍。
              所以推荐使用第二种方法。
              */
 
              //使用第二种遍历方法
 
              Set<Map.Entry<Student,String>>entrySet = tm.entrySet();
              Iterator<Map.Entry<Student,String>>it = entrySet.iterator();
 
              while(it.hasNext())
              {
                     Map.Entry<Student,String>me = it.next();
                     out.println(me.getKey()+"_"+me.getValue());
              }
       }
}
 
//定义学生类
class Student implements Comparable
{
 
       privateString name;
       privateint age;
 
       Student(Stringname,int age)
       {
              this.name= name;
              this.age= age;
       }
 
       publicString getName()
       {
              returnthis.name;
       }
 
       publicint getAge()
       {
              returnthis.age;
       }
 
       publicint compareTo(Object obj)
       {
              if(!(obj instanceof Student))
              {
                     thrownew ClassCastException("不是学生类");
              }
 
              Studentst = (Student)obj;
 
              intnum = this.age-st.getAge();
 
              if(num == 0)
              {
                     returnthis.name.compareTo(st.getName());
              }
 
              returnnum;
       }
 
       publicString toString()
       {
              return  this.name+","+this.age;
       }
}
 
/*
Comparable和Comparator的区别：
1.Compatable是通用的接口，用户可以通过实现它的compareTo()方法来完成自己的特定比较。
而Comparator可以看成一种算法的实现，在容器集合collection需要比较功能的时候，来指定这个比较器，这可以看成一种设计模式（策略模式），将算法和设计分离。
 
2.前者比较固定，和一个具体类相绑定，而后者比较灵活，它可以被用于各个需要比较功能的类使用。
可以说前者属于静态绑定，而后者属于动态绑定。
 
3.一个类实现了Comparable接口标明这个类的对象之间是可以互相比较的。如果用数学语言描述的话就是这个类的对象组成的集合中存在一个全序。
这样，这个类对象组成的集合就可以使.用.Sort.方.法.排序了.
 
4.而Comparato的作用有两个：
a.如果类的设计师没有考虑到Compare的问题而没有实现Comparable接口，可以通过Comparator来实现比较算法进行排序。
b.可以更加灵活的实现排序规则，为了使用不同的排序标准做准备，比如升序，降序，或者将来想通过类的其他字段进行排序。
 
*/
 
//自定义比较器，使年龄按照倒序排列
class MyComparator implementsComparator<Student>
{
       publicint compare(Student st1,Student st2)
       {
 
              intnum = st2.getAge()-st1.getAge();
              if(num == 0)
              {
                     returnst2.getName().compareTo(st1.getName());
              }
              returnnum;
       }
}