java笔记--java集合框架

1、Collection接口
Collection接口是一个重要的操作接口，它规定了集合的基本操作规范，该接口有两个子接口Set和List
Collection继承自Iterator接口，其定义如下：
public interface Collection<E>extends Iterable<E>；其中定义的主要的方法如下：
（1）boolean add（E e）-->增加一个元素
（2）boolean addAll(Collection<? extends E> c) -->增加一组数据
（3）void clear（）-->移除此Collection中的所有元素
（4）boolean remove（Object o）-->删除指定的元素
（5）boolean removeAll（Collection<? extends E> c）-->删除Collection指定的一组元素
（6）int size（）-->返回集合元素的个数
（7）boolean isEmpty（）-->判断结合是否为空
（8）boolean contains(Object o) -->判断集合是否包含某元素
（9）Object[] toArray()-->返回此集合所有元素的数组
（10）......
那么现在开发基本很少使用Collection完成功能，基本上使用其子接口List和Set。
2、List接口
List接口继承子Collection接口，在Collection的基础上扩展了一些方法，List接口最大的
特点是里面的内容允许重复。增加的方法：
(1)void add(int index,E element) -->在指定的位置添加元素
(2)boolean addAll(int index,Collection<? extends E> c)
(3)E get(int index)
(4)E remove(int index)
(5)E set(int index E element)
(6)List<E> sunList(int fromindex,int toindex)
2.1 ArrayList
ArrayList类是List接口最常用的一个子类，定义如下：
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable
例子：
import java.util.*;
class ArrayListDemo {


    public static void main(String[] args) {
       List<String> myList = new ArrayList<String>();//实例化ArrayList
       myList.add("hello");//增加元素
       myList.add("帅哥");
       myList.add(2, "OKOK");//在指定的位置增加元素
       System.out.println(myList);
       myList.remove(1);//根据索引来删除一个元素
       myList.remove("帅哥");//根据对象删去帅哥对象
       System.out.println(myList);
       System.out.println(myList.get(0));
       System.out.println(myList.size());
       System.out.println(myList.subList(0, 1));
    }
}
2.2 Vector
Vector类是一个元老级的操作类，它也实现了List接口，Vector一般来说使用较少，与ArrayList相比，Vector
是线程安全的，而ArrayList是非线程安全的。它的使用基本上与ArrayList类似。
2.3 LinkedList
LinkedList类是基于链式线性表实现的，其特点是适合于在链表中间需要频繁进行插入和删除操作。但是其缺点是随机访问速度较慢。
查找一个元素需要从头开始一个一个的找，速度较慢。


3、Set接口
Set接口也是Collection的子接口，最大的特点是没有重复元素。在Set接口中有以下的两个子类的常用的：
（1）HashSet：散列存放
（2）TreeSet：有序存放
Set接口本身继承了Collection却没有扩充Collection接口。
（1）散列存放：不重复，无序
例子：
class HashSetDemo {


    public static void main(String[] args) {


       Set<String> mySet = new HashSet<String>();
       mySet.add("hello");
       mySet.add("java");
       mySet.add("hello"); //编译可以通过，会覆盖前一个“hello”
       mySet.add("world");
       System.out.println(mySet);


    }
}
（2）有序存放：TreeSet（没有重复对象、内部根据cmparaTo()方法自动进行排序）
例子：
class TreeSetDemo {


    public static void main(String[] args) {
       Set<String> mySet = new TreeSet<String>();
       mySet.add("A");
       mySet.add("D");
       mySet.add("G");
       mySet.add("B");
       mySet.add("C");
       mySet.add("F");
       mySet.add("E");
       System.out.println(mySet);
    }


}
输出：[A, B, C, D, E, F, G]
4、使用迭代器遍历集合元素
迭代器Iterator和ListIterator是接口，不能实例化，不同的集合提供了可以遍历自身元素的迭代器实现。
Iterator迭代器包含的方法有：
（1）hasNext()：如果迭代器指向位置后面还有元素，则返回 true，否则返回false
（2）next()：返回集合中Iterator指向位置后面的元素
（3）remove()：删除集合中Iterator指向位置后面的元素
ListIterator迭代器包含的方法有：
（1）add(E e): 将指定的元素插入列表，插入位置为迭代器当前位置之前
（2）hasNext()：以正向遍历列表时，如果列表迭代器后面还有元素，则返回 true，否则返回false
（3）hasPrevious():如果以逆向遍历列表，列表迭代器前面还有元素，则返回 true，否则返回false
（4）next()：返回列表中ListIterator指向位置后面的元素
（5）nextIndex():返回列表中ListIterator所需位置后面元素的索引
（6）previous():返回列表中ListIterator指向位置前面的元素
（7）previousIndex()：返回列表中ListIterator所需位置前面元素的索引
（8）remove():从列表中删除next()或previous()返回的最后一个元素（有点拗口，意思就是对迭代器使用hasNext()方法时，删除ListIterator指向位置后面的元素；当对迭代器使用hasPrevious()方法时，删除ListIterator指向位置前面的元素）
（9）set(E e)：从列表中将next()或previous()返回的最后一个元素返回的最后一个元素更改为指定元素e
两者的区别：
（1）使用范围不同，Iterator可以应用于所有的集合，Set、List和Map和这些集合的子类型。而ListIterator只能用于List及其子类型。
（2）ListIterator有add方法，可以向List中添加对象，而Iterator不能。
（3）ListIterator和Iterator都有hasNext()和next()方法，可以实现顺序向后遍历，但是ListIterator有hasPrevious()和previous()方法，可以实现逆向（顺序向前）遍历。Iterator不可以。
（4）ListIterator可以定位当前索引的位置，nextIndex()和previousIndex()可以实现。Iterator没有此功能。
（5）都可实现删除操作，但是ListIterator可以实现对象的修改，set()方法可以实现。Iterator仅能遍历，不能修改。
ListIterator例子：
class ListIteratorTest 
{
   public static void main(String[] args) 
   {
        List<String> staff = new LinkedList<>();
        staff.add("zhuwei");
        staff.add("xuezhangbin");
        staff.add("taozhiwei");
        ListIterator<String> iter = staff.listIterator();
        String first = iter.next();
        iter.remove();
        System.out.println("first:"+first);
        iter.add("xiaobai");


        System.out.println("travel1: ");
        for(String str : staff)
         System.out.println(str+"  ");


        iter = staff.listIterator();
        System.out.println("travel2: ");
        while(iter.hasNext())
        {
          System.out.println(iter.next());
        }
   }
}


Iterator的例子：
class IteratorDemo 
{
    public static void main(String[] args) 
    {


       List<String> myList = new ArrayList<String>();
       myList.add("hello");
       myList.add("lenuy");
       myList.add("haha");
       myList.add("hehe");
       Iterator it = myList.iterator();
       while(it.hasNext())
       {
           System.out.println(it.next());
       }


    }
}


5、Map接口
Map接口保存一对值（key—value），Map中的key是不能重复的。
Map接口有三个常用子类：
HashMap、HashTable、TreeMap
Map接口中的方法有：
（1）boolean containsKey(Object key)此映射是否包含指定键的映射
（2）boolean containsValue(Object value)此映射是否包含指定值的映射
（3）V get(Object key)返回指定键所映射的值
（4）put(K key,V value)向此Map实例增加内容
（5）V remove(Object key)从映射中移除其映射关系的键，返回与 key 关联的值；如果没有 key 的映射关系，则返回 null。
（6）int size()求映射的程度
（7）boolean isEmpty()判断映射是否为空
（8）Set<K> keySet()返回此映射中包含的键的 Set 集合
（9）Collection<V> values()返回此映射中包含的值的 Collection 集合
5.1 HashMap类
HashMap是无序的。Map中的key是不能重复的，如果重复了，则属于覆盖，即保留了后来增加的内容。Map最大的特点是查找操作，如果查找到了则返回Value，否则返回null值。
例子：
class HashMapDemo 
{
    public static void main(String[] args)
    {


       Map<String,Integer> myMap = new HashMap<String,Integer>();
       myMap.put("A", 1);
       myMap.put("B", 2);
       myMap.put("C", 3);
       myMap.put("C", 3);
       System.out.println(myMap);
       System.out.println(myMap.get("A"));
       System.out.println(myMap.get("D"));
    }


}
输出：
{A=1, B=2, C=3}
1
null


5.2 HashTable类
Hashtable属于线程安全的。其操作和Map几乎一样。
5.3 TreeMap类
TreeMap类按键（key）进行了排序，如果key的类型的任意对象类型，要TreeMap能够自动进行排序的话，则此类必须实现Comparable的comparaTo()方法。
看以下例子：
class TreeMapDemo 
{


    public static void main(String[] args)
    {
       Map<String,Integer> myMap = new TreeMap<String,Integer>();
       myMap.put("D", 1);
       myMap.put("B", 2);
       myMap.put("C", 3);
       myMap.put("C", 3);
       myMap.put("A", 4);
       System.out.println(myMap);
       Set<String> set = myMap.keySet();
       Iterator it = set.iterator();
       while(it.hasNext()){
           String str = (String) it.next();
           System.out.println(str+" --> "+myMap.get(str));
       }
    }
}
输出：
{A=4, B=2, C=3, D=1}
A --> 4
B --> 2
C --> 3
D --> 1


6、java集合框架小结
（1）类集合设置的主要目的是实现动态的对象数组操作。


（2）List接口允许值的重复。其子类有：ArraryList（最采用）、Vector（旧的类）、LinkedList（允许null值，实现了Queue接口）


（3）Set接口：不允许对象重复，依靠equal()和hashCode（）【注意：java中默认hashCode的根据对象的地址计算得来的】方法来检查区分是否为同一对象。
HashSet：无序的
TreeSet：能够按照对象的comparaTo()方法进行排序。


（4）Map接口：存放一对值，key不能重复。不能放空值，Map并没有继承Collection接口
HashMap：无序的
Hashtable：无序的而且同步的，线程安全的，旧的类（不允许关键字或值为null
TreeMap,:能够按照key自动来排序，按照Key对象的comparaTo()方法。
（5）注意Collections和Collection的区别。Collections是个java.util下的类，它包含有各种有关集合操作的静态方法。 Collection是个java.util下的接口，它是各种集合结构的父接口。