黑马程序员——java集合的整理

----------------------<a href="http://edu.csdn.net/heima"target="blank">android培训</a>、<a href="http://edu.csdn.net/heima"target="blank">java培训</a>、期待与您交流！ ----------------------

java集合的体系结构
 List、Set、Map是这个集合体系中最主要的三个接口。
      其中List和Set继承自Collection接口。
      Set不允许元素重复。HashSet和TreeSet是两个主要的实现类。
      List有序且允许元素重复。ArrayList、LinkedList和Vector是三个主要的实现类。
      Map也属于集合系统，但和Collection接口不同。Map是key对value的映射集合，其中key列就是一个集合。key不能重复，但是value可以重复。HashMap、TreeMap和Hashtable是三个主要的实现类。
      SortedSet和SortedMap接口对元素按指定规则排序，SortedMap是对key列进行排序。

1、Set(集):

    集合中的对象不按特定方式排列，并且没有重复对象。它的有些实现类能对集合中的对象按

特定方式排列。

     Set接口主要有两个实现类：HashSet和TreeSet,

     HashSet按照哈希算法来存储对象，具有很好的存取和查找性能，当向集合中添加一个对象时，
HashSet会调用对象的hashCode()方法来获得哈希码，然后根据这个哈希码进一步计算出对象在集合
中的存放位置。HashSet还有一个子类LinkedHashSet类，它在HashSet的基础之上实现了链表数据结
构，链表数据结构可以提高新增和删除元素的性能。

     TreeSet类实现了SortedSet接口(继承自Set),具有排序功能。有自然排序和客户化排序两种排
序方式：
     在jdk类库中，有一部分类实现了Comparable接口，该接口有一个compareTo(Object o)方法，
它返回整数类型。TreeSet调用对象的compareTo()方法比较集合中的对象的大小，然后进行排序，这
种排序方式称为自然排序。
     以下是jdk类库中实现了Comparable接口的一些类排序方式：
        Byte Double Float Integer Long Short  --->按数字大小排序；
        Character ---->按字符的Unicode值的数字大小排序；
        String    ---->按字符串中字符的Unicode值排序。
     使用自然排序时，只能向TreeSet集合中加入同类型的对象，并且这些对象的类必须实现了
Comparable接口。

   2、List(列表):
     集合中的对象按照索引位置排序，可以有重复对象。允许按照对象在集合中的索引位置检

索对象。该集合与数组有些相似。
   List接口的主要实现类：
     ArrayList:代表长度可变的数组。允许对元素的快速的随机访问，但是向ArrayList中插入与删除
元素的速度较慢。
/*
集合框架的工具类
Collections；

 

*/
import java.util.*;

class CollectionsDemo
{
 public static void main(String[] args)
 {
  //sortDemo();
  //max();
  binarySearchDemo();
  
 }
 
 public static void binarySearchDemo()
 {
  List<String> list = new ArrayList<String>();
    
    list.add("abcd");
    list.add("aaa");
    list.add("zz");
    list.add("kkkk");
    list.add("qq");
    list.add("cc");
    list.add("z");
    sop(list);
    Collections.sort(list);
    sop(list);
    int index = halfSeach(list,"aaa");
    sop("index....="+index);

 } 

 public static int halfSeach(List<String> list,String key)
 {
  
  int max,min,mid;
  max = list.size()-1;
  min = 0;

  while (min<=max)
  {
   mid = (max + min)>>1;  //除以2
   String str = list.get(mid);
   int num = str.compareTo(key);
   if (num >0)
   {
    max = mid -1;
   }
   else if (num <0)
   {
    min = mid+1;
   }
   else
    return mid;
  }
  return -min-1;
 }

 

 public static void max()
 {
  List<String> list = new ArrayList<String>();
    
    list.add("abcd");
    list.add("aaa");
    list.add("zz");
    list.add("kkkk");
    list.add("qq");
    list.add("cc");
    list.add("z");
    sop(list);
    Collections.sort(list);
    sop(list);
    String max = Collections.max(list);
    sop("max....="+max);
 }

 public static void sortDemo()
   {
    List<String> list = new ArrayList<String>();
    
    list.add("abcd");
    list.add("aaa");
    list.add("z");
    list.add("kkkk");
    list.add("qq");
    list.add("cc");
    list.add("z");
    
    sop(list);
    //Collections.sort(list);
    //Collections.sort(list,new StrLenComparator());
    /*1 错误

d:\Users\Administrator\Desktop\集合>javac CollectionsDemo.java
CollectionsDemo.java:26: 无法从静态上下文中引用非静态 变量 this
                                Collections.sort(list,new StrLenComparator());*/
                                                     
    sop(list);
   } 
  
   public static void sop(Object obj)
   {
     System.out.println(obj);
   }
   
class StrLenComparator implements Comparator<String>
{
   public int compare(String s1,String s2)
   {
    if(s1.length()>s2.length())
      return 1;
    if(s1.length()<s2.length())
      return -1;
      return s1.compareTo(s2);
   }
}    
}
     LinkedList:在实现中采用链表数据结构。对顺序访问进行优化，向List中插入和删除元素的速度
较快，随机访问速度较慢。随机访问是指检索特定索引位置的元素。LinkedList单独具有addFirst()、
addLast()、getFirst()、getLast()、removeFirst()、removeLast()方法，fill()方法;这些方法使得LinkedList
fill()方法:import java.util.*;

class  CollectonsDemo2
{
 public static void main(String[] args)
 {
  fillDemo();
 }

 public static void fillDemo()
 {
  List<String> list = new ArrayList<String>();
    
    list.add("abcd");
    list.add("aaa");
    list.add("zz");
    list.add("kkkk");
    list.add("qq");
    list.add("cc");
    list.add("z");
    sop(list);
    Collections.fill(list,"pp");
    sop(list);
 }

 public static void sop(Object obj)
 {
  System.out.println(obj);
  
 }
}

可以作为堆栈，队列和双向队列使用。

     List只能对集合中的对象按索引位置排列，如果希望对List中的对象按其他特定的方式排序，可以
借助Collections类和Comparable接口（或Comparator接口）；Collections类是Java集合类库中的辅助类，
它提供了操纵集合的各种静态方法，其中sort()方法用于对List中的对象进行排序。
    》sort(List list):对象List中的对象进行自然排序。
    》sort(List list,Comparator comparator):对List中的对象进行客户化排序，comparator参数
指定排序方式。

   3、Map(映射):
     集合中的每一对元素包含一个键对象和值对象，集合中没有重复的键对象，值对象可以重复。它的有
些实现类能对集合中的键对象进行排序。
   向Map集合中加入元素时，必须提供一对键对象和值对象，从集合中检索元素时，只要给出键对象，就会
返回相应的值对象。
    Map有两种常用的实现：HashMap和TreeMap。
    HashMap按照哈希算法存储对象，有很好的存取性能；TreeMap实现了SortedMap接口，能对键对象进行
排序。TreeMap也支持自然排序和客户化排序。
    如果希望TreeMap对键对象进行客户化排序，可以调用它的另一个构造方法----TreeMap（Comparator comparator),
参数comparator指定具体的排序方式。

下面是学完Java集合后自己梳理出来的一些笔记，有什么不完善的地方还请大家指出来，一起总结一起进步
Java 中的集合：两大接口 collection和map
Collection 两个子接口 Set和List
        List 是有序的集合，能精确地控制每一个元素的插入位置。三个直接实现类 LinkedList  ArrayList  Vector
        LinkedList  内部由链表实现，没有实现同步，多个线程同时访问List需要自己解 决同步问题。由于是采用链表的实现，对数据的插入和删除会表现出较高的效率，但是对数据的查询和定位效率较低。
        ArrayList 是采用一个可变的数组实现，对数据的插入删除效率较低，到时数据的查询和定位效率较高。
        Vector 相对于ArrayList实现了同步的问题，它还有一个子类Stack栈，实现先进先出。
      
        Set是一种不包含重复元素的集合，最多只能有一个NULL。
        HashSet是用一张哈希表做数据存储，它是无序的，可以随机访问，是Set的最优性能实现。
        TreeSet 实现了Set的一个子接口SortedSet，使用一棵红黑树来存储元素，被加入的元素必须实现comparable接口，插入时使用comparator进行排序。
        使用Set集合时需要注意，当存储可变对象时，可能经过改变出现重复的元素，这从根本上违反了Set的不可重复的原则，Set的行为将变得不可预测。
      
Map 两个实现类HashMap HashTable
        Map 提供Key-value的映射集合，key不能重复，value能重复
        Hashmap不是同步的  Hashtable是同步的
        注意：作为key的对象必须同时重写hashcod（）和 equies（）方法

----------------------<a href="http://edu.csdn.net/heima"target="blank">android培训</a>、<a href="http://edu.csdn.net/heima"target="blank">java培训</a>、期待与您交流！ ----------------------