java集合框架

       // 7.containsAll(Collection coll):判断当前集合中是否包含coll中所有的元素

      // 8.retainAll(Collection coll):求当前集合与coll的共有的元素，返回给当前集合（将当前集合修改了）

        // 9.remove(Object obj):删除集合中的obj元素。若删除成功，返回true。否则，返回false

      //13.toArray() :将集合转化为数组
        Object[] obj = coll.toArray();
     
      //14  Iterator iterator = coll.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

集合的遍历：
方式一：
Iterator i = coll.iterator();
        while(i.hasNext()){
            System.out.println(i.next());
        }
示意图：

方式二：//使用增强for循环实现集合的遍历

for(Object i:coll){
            System.out.println(i);
        }
//使用增强for循环实现数组的遍历
    @Test
    public void testFor1(){
        String[] str = new String[]{"AA","BB","DD"};
        for(String s:str){
            System.out.println(s);
        }
    }
增强for循环的注意点：
String[] str = new String[]{"AA","BB","DD"};
        for(int i = 0;i < str.length;i++){
            str[i] = i + "";
        }
        
        for(int i = 0;i < str.length;i++){
            System.out.print(str[i]+“ ”);
        }
打印结果：0 1 2
通过str[i]这种方式可以修改数组的值。

String[] str = new String[]{"AA","BB","DD"};
        for(String s : str){
            s =  "MM";//此处的s是新定义的局部变量，其值的修改不会对str本身造成影响。
            System.out.println(s);
        }        
        
        for(int i = 0;i < str.length;i++){
            System.out.print(str[i]+“ ”);
        }
打印结果AA BB CC
s是新定义的局部变量，其值的修改不会对str本身造成影响。


List的常用方法（有序可以重复的集合）：（在继承colletion的基础上，会有一些自己的方法）

     * List中相对于Collection，新增加的方法
     *  void add(int index, Object ele):在指定的索引位置index添加元素ele
        boolean addAll(int index, Collection eles)
        Object get(int index):获取指定索引的元素
        Object remove(int index):删除指定索引位置的元素
        Object set(int index, Object ele):设置指定索引位置的元素为ele
        int indexOf(Object obj):返回obj在集合中首次出现的位置。没有的话，返回-1
        int lastIndexOf(Object obj)：返回obj在集合中最后一次出现的位置.没有的话，返回-1
        List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex结束的左闭右开一个子list
        
        List常用的方法：增(add(Object obj)) 删(remove) 改(set(int index,Object obj))
                    查(get(int index)) 插(add(int index, Object ele)) 长度(size())
     */
      ArrayList：List的主要实现类，底层数组存储。
      LinkedList:相对于ArrayList，linkedList底层是用链表实现的。
     新增加的方法：

ArrayList 采用的是数组形式来保存对象的，这种方式将对象放在连续的位置中，查询时候很快，
但是最大的缺点就是插入删除时非常麻烦(会有大量的位置移动)
LinkedList 采用的将对象存放在独立的空间中，而且在每个空间中还保存下一个链接的索引，
对于频繁的插入或删除元素的操作 ，效率很高， 但是缺点就是查找非常麻烦 要丛第一个索引开始。

Set 接口：

Set接口是Collection的子接口，set接口没有提供额外的方法
Set:存储的元素是无序的，不可重复的！
*  1.无序性：无序性！= 随机性。真正的无序性，指的是元素在底层存储的位置是无序的。
* 2.不可重复性：当向Set中添加进相同的元素的时候，后面的这个不能添加进去。

HashSet：是 Set 接口的典型实现，大多数时候使用 Set 集合时都使用这个实现类。
HashSet具有以下特点：
不能保证元素的排列顺序
HashSet不是线程安全的
集合元素可以是 null
* 说明：要求添加进HashSet中的元素所在的类，一定要重写equals()和hashCode()方法。
 进而保证Set中元素的不可重复性！
* HashSet中的元素时如何存储的呢？使用了哈希算法。
* 当向Set中添加对象时，首先调用此对象所在类的hashCode()方法，计算此对象的哈希值，此哈希值
* 决定了此对象在Set中的存储位置。若此位置之前没有对象存储，则这个对象直接存储到此位置。若此位置
* 已有对象存储，再通过equals()比较这两个对象是否相同。如果相同，后一个对象就不能再添加进来。 万一返回false呢，都存储。（不建议如此）
* >要求：hashCode()方法要与equals()方法一致。


LinkedHashSet:
LinkedHashSet是 HashSet的子类

使用链表维护了一个添加进集合中的顺序。导致当我们遍历LinkedHashSet集合元素时，是按照添加进去的顺序遍历的！
LinkedHashSet根据元素的 hashCode值来决定元素的存储位置，但它同时使用链表维护元素的次序，这使得元素看起来是以插入顺序保存的
LinkedHashSet插入性能略低于 HashSet（因为得维护链表的结构），但在迭代访问 Set 里的全部元素时有很好的性能（）。

TreeSet: 不是HashSet的子类，是Set的实现类。
        1.向TreeSet中添加的元素必须是同一个类的。
     * 2.可以按照添加进集合中的元素的指定的顺序遍历。像String，包装类等默认按照从小到大的顺序遍历。
     * 3.当向TreeSet中添加自定义类的对象时，有两种排序方法：①自然排序②定制排序
     * 4.自然排序：要求自定义类实现java.lang.Comparable接口并重写其compareTo(Object obj)的抽象方法
     * 在此方法中，指明按照自定义类的哪个属性进行排序。
     //当向TreeSet中添加Person类的对象时，依据此方法，确定按照哪个属性排列。
       public class Person implements Comparable
    @Override
    public int compareTo(Object o) {
        if(o instanceof Person){
            Person p = (Person)o;
            //return this.name.compareTo(p.name);
            //return -this.age.compareTo(p.age);
            int i = this.age.compareTo(p.age);
            if(i == 0){
                return this.name.compareTo(p.name);
            }else{
                return i;
            }
        }
        return 0;
    }
     * 
     * 5.向TreeSet中添加元素时，首先按照compareTo()进行比较，一旦返回0，虽然仅是两个对象的此
     * 属性值相同，但是程序会认为这两个对象是相同的，进而后一个对象就不能添加进来。
     * 6，添加元素时，先compareTo（），如果return 0，则不添加，如果return的不是0，再hashcode（）和equals方法比较。
     * >要求compareTo()与hashCode()以及equals()三者保持一致！


     * TreeSet的定制排序： 见下面的步骤 compare()与hashCode()以及equals()三者保持一致！
     */
    @Test
    public void testTreeSet2() {
        // 1.创建一个实现了Comparator接口的类对象
        Comparator com = new Comparator() {
            // 向TreeSet中添加Customer类的对象，在此compare()方法中，指明是按照Customer
            // 的哪个属性排序的。
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof Customer && o2 instanceof Customer) {
                    Customer c1 = (Customer) o1;
                    Customer c2 = (Customer) o2;
                    int i = c1.getId().compareTo(c2.getId());
                    if (i == 0) {
                        return c1.getName().compareTo(c2.getName());
                    }
                    return i;
                }
                return 0;
            }
        };
        // 2.将此对象作为形参传递给TreeSet的构造器中
        TreeSet set = new TreeSet(com);
        // 3.向TreeSet中添加Comparator接口中的compare方法中涉及的类的对象。
        set.add(new Customer("AA", 1003));
        set.add(new Customer("BB", 1002));
        set.add(new Customer("GG", 1004));
        set.add(new Customer("CC", 1001));
        set.add(new Customer("DD", 1001));

        for (Object str : set) {
            System.out.println(str);
        }
    }

Map接口：
Map与Collection并列存在。用于保存具有映射关系的数据:Key-Value
Map 中的 key 和  value 都可以是任何引用类型的数据
Map 中的 key 用Set来存放，不允许重复，即同一个 Map 对象所对应的类，须重写hashCode()和equals()方法。
常用String类作为Map的“键”。
key 和 value 之间存在单向一对一关系，即通过指定的 key 总能找到唯一的、确定的 value

TreeMap判断两个key相等的标准：跟treeSet一致。

Hashtable是个古老的Map实现类，线程安全。

与HashMap不同，Hashtable不允许使用null作为 key 和value

与HashMap一样，Hashtable也不能保证其中Key-Value对的顺序

Hashtable判断两个key相等、两个value相等的标准，与hashMap一致。

Properties 类是Hashtable的子类，该对象用于处理属性文件

由于属性文件里的 key、value都是字符串类型，所以Properties里的key和 value 都是字符串类型

存取数据时，建议使用setProperty(Stringkey,String value)方法和getProperty(String key)方法

?Properties pros = new Properties();

?pros.load(newFileInputStream("jdbc.properties"));

?String user = pros.getProperty("user");

?System.out.println(user);

操作集合的工具类Collections：

        reverse(List)：反转 List 中元素的顺序
        sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
        sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
        swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换

        Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
        Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
        Object min(Collection)
        Object min(Collection，Comparator)
        int frequency(Collection,Object)：返回指定集合中指定元素的出现次数

Collections 类中提供了多个 synchronizedXxx() 方法，该方法可使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题