集合框架

简介

集合的由来
　　数组长度是固定,当添加的元素超过了数组的长度时需要对数组重新定义,太麻烦,java内部给我们提供了集合类,能存储任意对象,长度是可以改变的,随着元素的增加而增加,随着元素的减少而减少

定义：

　　java提供了一种可以存数一组数据的数据结构，其提供了丰富的方法，在实际开发中往往比数组使用的广泛。这种数据结构成为集合:Collection。

　　Collection是一个接口，其定义了集合的相关功能方法。

数组和集合的区别

• 区别1 :
  
  • 数组既可以存储基本数据类型,又可以存储引用数据类型,基本数据类型存储的是值,引用数据类型存储的是地址值
  • 集合只能存储引用数据类型(对象)集合中也可以存储基本数据类型,但是在存储的时候会自动装箱变成对象
• 区别2:
  
  • 数组长度是固定的,不能自动增长
  • 集合的长度的是可变的,可以根据元素的增加而增长

数组和集合什么时候用

• 如果元素个数是固定的推荐用数组
• 如果元素个数不是固定的推荐用集合

集合框架图

Collection （集合的最大接口）继承关系

　　——List　可以存放重复的内容
　　——Set　　不能存放重复的内容，所以的重复内容靠hashCode()和equals()两个方法区分
　　——Queue　　队列接口
　　——SortedSet　　可以对集合中的数据进行排序

关于list,set,map的我的博客链接java集合（list,set,map)

Collection定义了集合框架的共性功能。

Collection接口常见的方法

（1）单元素添加、删除操作。

（2）查询操作。

（3）组操作：作用于元素或整个结合。

（4）Collection转换为Object数组。

注：集合中存储的都是对象的引用(地址)

Iterator 迭代器

Collection提供了一个遍历集合的通用方式，迭代器(Iterator)。
获取迭代器的方式是使用Collection定义的方法:

Iterator iterator():迭代器Iterator是一个接口，集合在覆盖Collection的iterator()方法时提供了迭代器的实现。Iterator提供了统一的遍历集合元素的方式。

迭代器原理

迭代器原理:迭代器是对集合进行遍历,而每一个集合内部的存储结构都是不同的,所以每一个集合存和取都是不一样,那么就需要在每一个类中定义hasNext()和next()方法,这样做是可以的,但是会让整个集合体系过于臃肿,迭代器是将这样的方法向上抽取出接口,然后在每个类的内部,定义自己迭代方式,这样做的好处有二：
　　第一规定了整个集合体系的遍历方式都是hasNext()和next()方法；
　　第二,代码有底层内部实现,使用者不用管怎么实现的,会用即可

hasNext与next方法

迭代器用于遍历集合的两个主要方法:

• boolean hasNext():判断集合是否还有元素可以遍历。

• E next():返回迭代的下一个元素

  遍历集合应遵循“先问后取”的方式，也就是说，应当在确定hasNext()方法的返回值为true的情况下再通过next()方法取元素。

  由此可以看出，使用迭代器遍历集合是通过boolean值驱动的，所以它更适合使用while循环来遍历。

    Collection<String> c = new HashSet<String>();
    c.add("java");        
    c.add("cpp");        
    c.add("php");
    c.add("c#");        
    c.add("objective-c");
    Iterator<String> it = c.iterator();
    while (it.hasNext()) {
        String str = it.next();
        System.out.println(str);
    } 

remove方法

　　迭代器还提供了一个方法:

　　void remove()该方法用于删除迭代器当次从集合中获取的元素。若我们在迭代过程中想删除集合元素时，我们就需要通过该方法来进行。这里需要注意，在使用迭代器遍历集合时是不能通过集合自身提供的remove方法删除元素的，否则迭代器在迭代时会抛出异常。

    Collection<String> c = new HashSet<String>();
    c.add("java");        
    c.add("cpp");        
    c.add("php");
    c.add("c#");        
    c.add("objective-c"); 
    System.out.println(c); // [cpp, php, c#, java, objective-c] 
    Iterator<String> it = c.iterator();
    while (it.hasNext()) {
        String str = it.next();
        if (str.indexOf("c") != -1) {
            it.remove();
        } 
    } 
    System.out.println(c); // [php, java]  

增强for循环

Java5.0之后推出了一个新的特性，增强for循环,也称为新循环。该循环不通用于传统循环的工作，其只用于便利集合或数组。 语法:

    for(元素类型 e : 集合或数组){
        循环体 
    }

　　新循环并非新的语法，而是在编译过程中，编译器会将新循环转换为迭代器模式。所以新循环本质上是迭代器。
例如:

    Collection<String> c = new HashSet<String>();
    c.add("java");
    c.add("cpp");
    c.add("php");
    c.add("c#");
    c.add("objective-c");
    for (String str : c) {
        System.out.print(str.toUpperCase() + " ");
    } 
    // CPP PHP C# JAVA OBJECTIVE-C

泛型机制

泛型在集合中的应用

　　泛型是Java SE 5.0引入的特性，泛型的本质是参数化类型。在类、接口和方法的定义过程中，所操作的数据类型被传入的参数指定。

　　Java泛型机制广泛的应用在集合框架中。所有的集合类型都带有泛型参数，这样在创建集合时可以指定放入集合中的对象类型。Java编译器可以据此进行类型检查，这样可以减少代码在运行时出现错误的可能性。

我们来举个例子，比如ArrayList，其在定义时是这样的:

    public class ArrayList<E> {
        … … …                
        public boolean add(E e) {…};
        public E get(int index) {…};
    } 

由此我们可以看出，再声明ArrayList时，类名的右侧有一个。”<>”表示泛型，而其中可以使用数字字母下划线(数字不能的第一个字符)来表示泛型的名字。(通常我们使用一个大写字母来表示，当然这个不是规定。)这时，在类中声明的方法的参数，返回值类型可以被定义为泛型。这样在创建对象时可以将类型作为参数传递，此时，类定义所有的E将被替换成传入的参数。
例如:

    ArrayList<String> list = new ArrayList<String>();//泛型E在这里被指定为String类型
    list.add("One");//那么add方法的参数就被替换为String类型
    list.add(100);//这里就会出现编译错误，因为这里的参数应为String类型。

集合工具类

　Collections:集合框架的工具类。里面定义的都是静态方法。

　　Collections和Collection有什么区别？
　　　　Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。
　　　　　　它有两个常用的子接口，
　　　　　　List：对元素都有定义索引。有序的。可以重复元素。
　　　　　　Set：不可以重复元素。无序。

　　　　Collections是集合框架中的一个工具类。该类中的方法都是静态的。
　　　　　　提供的方法中有可以对list集合进行排序，二分查找等方法。
　　　　　　通常常用的集合都是线程不安全的。因为要提高效率。
　　　　　　如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。

常用的方法

排序操作（主要针对List接口相关）

rotate(List list, int distance)|将所有元素向右移位指定长度，如果distance等于size那么结果不变|

例子

    public void testSort() {
        System.out.println("原始顺序：" + list);

        Collections.reverse(list);
        System.out.println("reverse后顺序：" + list);

        Collections.shuffle(list);
        System.out.println("shuffle后顺序：" + list);

        Collections.swap(list, 1, 3);
        System.out.println("swap后顺序：" + list);

        Collections.sort(list);
        System.out.println("sort后顺序：" + list);

        Collections.rotate(list, 1);
        System.out.println("rotate后顺序：" + list);
    }

输出

原始顺序：[b张三, d孙六, a李四, e钱七, c赵五]
reverse后顺序：[c赵五, e钱七, a李四, d孙六, b张三]
shuffle后顺序：[b张三, c赵五, d孙六, e钱七, a李四]
swap后顺序：[b张三, e钱七, d孙六, c赵五, a李四]
sort后顺序：[a李四, b张三, c赵五, d孙六, e钱七]
rotate后顺序：[e钱七, a李四, b张三, c赵五, d孙六]

查找和替换（主要针对Collection接口相关）

例子

        public void testSearch() {
        System.out.println("给定的list：" + list);
        System.out.println("max：" + Collections.max(list));
        System.out.println("min：" + Collections.min(list));
        System.out.println("frequency：" + Collections.frequency(list, "a李四"));
        Collections.replaceAll(list, "a李四", "aa李四");
        System.out.println("replaceAll之后：" + list);

        // 如果binarySearch的对象没有排序的话，搜索结果是不确定的
        System.out.println("binarySearch在sort之前：" + Collections.binarySearch(list, "c赵五"));
        Collections.sort(list);
        // sort之后，结果出来了
        System.out.println("binarySearch在sort之后：" + Collections.binarySearch(list, "c赵五"));

        Collections.fill(list, "A");
        System.out.println("fill：" + list);
    }

输出

给定的list：[b张三, d孙六, a李四, e钱七, c赵五]
max：e钱七
min：a李四
frequency：1
replaceAll之后：[b张三, d孙六, aa李四, e钱七, c赵五]
binarySearch在sort之前：-4
binarySearch在sort之后：2
fill：[A, A, A, A, A]

同步控制

　　Collections工具类中提供了多个synchronizedXxx方法，该方法返回指定集合对象对应的同步对象，从而解决多线程并发访问集合时线程的安全问题。HashSet、ArrayList、HashMap都是线程不安全的，如果需要考虑同步，则使用这些方法。这些方法主要有：synchronizedSet、synchronizedSortedSet、synchronizedList、synchronizedMap、synchronizedSortedMap。

　　特别需要指出的是，在使用迭代方法遍历集合时需要手工同步返回的集合。

Map m = Collections.synchronizedMap(new HashMap());
      ...
  Set s = m.keySet();  // Needn't be in synchronized block
      ...
  synchronized (m) {  // Synchronizing on m, not s!
      Iterator i = s.iterator(); // Must be in synchronized block
      while (i.hasNext())
          foo(i.next());
    }

总结

　List：add/remove/get/set。

　　　　1，ArrayList：其实就是数组，容量一大，频繁增删就是噩梦，适合随机查找；

　　　　2，LinkedList：增加了push/[pop|remove|pull]，其实都是removeFirst；

　　　　3，Vector：历史遗留产物，同步版的ArrayList，代码和ArrayList太像；

　　　　4，Stack：继承自Vector。Java里其实没有纯粹的Stack，可以自己实现，用组合的方式，封装一下LinkedList即可；

　　　　5，Queue：本来是单独的一类，不过在SUN的JDK里就是用LinkedList来提供这个功能的，主要方法是offer/pull/peek，因此归到这里呢。

　　Set：add/remove。可以用迭代器或者转换成list。

　　　　1，HashSet：内部采用HashMap实现的；

　　　　2，LinkedHashSet：采用LinkedHashMap实现；

　　　　3，TreeSet：TreeMap。

　　Map：put/get/remove。

　　　　1，HashMap/HashTable：散列表，和ArrayList一样采用数组实现，超过初始容量会对性能有损耗；

　　　　2，LinkedHashMap：继承自HashMap，但通过重写嵌套类HashMap.Entry实现了链表结构，同样有容量的问题；

　　　　3，Properties：是继承的HashTable。

　　　　顺便说一下Arrays.asList，这个方法的实现依赖一个嵌套类，这个嵌套类也叫ArrayList！