3.3 集合

• 一方面， 面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象的操作，就要对对象进行存储。另一方面，使用Array存储对象方面具有一些弊端，而Java 集合就像一种容器，可以动态地把多个对象的引用放入容器中。
• Java 集合类可以用于存储数量不等的多个对象，还可用于保存具有映射关系的关联数组。

Java 集合可分为 Collection 和 Map 两种体系

• Collection接口：
• Set：元素无序、不可重复的集合 ---类似高中的“集合”
• List：元素有序，可重复的集合 ---”动态”数组
• Map接口：具有映射关系“key-value对”的集合 ---类似于高中的“函数” y = f(x) (x1,y1) (x2,y2)

3.3.1 Collection接口

• Collection 接口是 List、Set 和 Queue 接口的父接口，该接口里定义的方法既可用于操作 Set 集合，也可用于操作 List 和 Queue 集合。
• JDK不提供此接口的任何直接实现，而是提供更具体的子接口(如：Set和List)实现。
• 在 Java5 之前，Java 集合会丢失容器中所有对象的数据类型，把所有对象都当成 Object 类型处理；从 Java5 增加了泛型以后，Java 集合可以记住容器中对象的数据类型

Collection接口继承树

集合中数组间转换操作：

方法类型	方法
Object[]	toArray() 返回包含此collection中所有元素的数组
<T> T[]	toArray(T[] a) 返回包含此 collection中所有元素的数组;返回数组的运行时类型与指定数组的运行时类型相同

3.3.1.1 Iterator接口

• Iterator对象称为迭代器(设计模式的一种)，主要用于遍历 Collection 集合中的元素。
• 所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了Iterator接口的对象。
• Iterator 仅用于遍历集合，Iterator 本身并不提供承装对象的能力。如果需要创建 Iterator 对象，则必须有一个被迭代的集合。

Iterator接口方法:

在调用iterator.next()方法之前必须要调用iterator.hasNext()进行检测。
若不调用，且下一条记录无效，直接调用iterator.next()会抛出NoSuchElementException异常。

//List的知识将在下面讲到。这里先做演示
List l=new ArrayList();
//因为Collection framework只能存储对象所以new封装类
l.add(new Integer(1));
l.add(new Integer(2));
l.add(new Integer(3));
l.add(new Integer(4));
Iterator x = l.iterator();

while(x.hasNext()){
   Object o = x.next();
   System.out.println(o);
}

输出结果：

1
2
3
4

java5中提供了foreach循环迭代访问Collection

代码示例

class Persons{
    public String name ;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    Persons(){
    }
    Persons(String name){
        this.name = name;
    }
    public static void main(String[] args) {
        List<Persons> persons  = new ArrayList<Persons>();
        persons.add(new Persons("张三"));
        persons.add(new Persons("李四"));
        persons.add(new Persons("王五"));
        persons.add(new Persons("赵六"));
        
        for(Persons person: persons){
            System.out.println(person.getName());
        }
        //其中：  
        //Persons 代表要遍历的元素类型
        //person 代表遍历后元素名称
        //persons 代表要遍历的元素名称
    }
}

输出结果：

张三
李四
王五
赵六

3.3.1.2 List接口

• Java中数组用来存储数据的局限性
• List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。
• List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。
• JDK API中List接口的实现类常用的有：ArrayList、LinkedList和Vector。
• List 集合里添加了一些根据索引来操作集合元素的方法

• void add(int index, Object ele)
• boolean addAll(int index, Collection eles)
• Object get(int index)
• int indexOf(Object obj)
• int lastIndexOf(Object obj)
• Object remove(int index)
• Object set(int index, Object ele)
• List subList(int fromIndex, int toIndex)

ArrayList

• ArrayList 是 List 接口的典型实现类
• 本质上，ArrayList是对象引用的一个变长数组
• ArrayList 是线程不安全的，而 Vector 是线程安全的，即使为保证 List 集合线程安全，也不推荐使用Vector
• Arrays.asList(…) 方法返回的 List 集合既不是 ArrayList 实例，也不是 Vector 实例。Arrays.asList(…) 返回值是一个固定长度的 List 集合

LinkedList

• 对于频繁的插入或删除元素的操作，建议使用LinkedList类，效率较高

• 新增方法：

         void addFirst(Object obj)
         void addLast(Object obj)   
         Object getFirst()
         Object getLast()
         Object removeFirst()
         Object removeLast()
  

代码示例

        // List 接口的链接列表实现
        LinkedList<String> list = new LinkedList<String>();
        
        list.push("one");
        list.push("two");
        list.push("three");
        list.push("four");
        
        Iterator<String> lit = list.iterator();
        while (lit.hasNext()) {
            System.out.println(list.pop());
        }
        
        System.out.println(list.size() + "---------");

输出结果：

four
three
two
one
0---------

Vector

• Vector 是一个古老的集合，JDK1.0就有了。大多数操作与ArrayList相同，区别之处在于Vector是线程安全的。

• 在各种list中，最好把ArrayList作为缺省选择。当插入、删除频繁时，使用LinkedList；Vector总是比ArrayList慢，所以尽量避免使用。

• 新增方法：

• void addElement(Object obj)

• void insertElementAt(Object obj,int index)

• void setElementAt(Object obj,int index)

• void removeElement(Object obj)

• void removeAllElements()

代码示例

Vector<String> v = new Vector<String>();// 10

// 同步
v.add("one");
v.add("two");
v.add("three");
v.add("one");
v.add("two");
v.add("three");

for (int i = 0; i < v.size(); i++) {
    System.out.print(v.get(i)+" ");
}
System.out.println("v.size() = "+v.size());

System.out.println("使用insertElementAt方法");
v.insertElementAt("啊哈", 0);
for (int i = 0; i < v.size(); i++) {
    System.out.print(v.get(i)+" ");
}
System.out.println("v.size() = "+v.size());

System.out.println("使用remove方法");
v.remove(0);
for (int i = 0; i < v.size(); i++) {
    System.out.print(v.get(i)+" ");
}
System.out.println("v.size() = "+v.size());

System.out.println("使用removeAllElements方法");
v.removeAllElements();
for (int i = 0; i < v.size(); i++) {
    System.out.print(v.get(i)+" ");
}
System.out.println("v.size() = "+v.size());

输出结果：

one two three one two three v.size() = 6
使用insertElementAt方法
啊哈 one two three one two three v.size() = 7
使用remove方法
one two three one two three v.size() = 6
使用removeAllElements方法
v.size() = 0

LinkedList、ArrayList和Vector区别

1.ArrayList是最常用的List实现类，内部是通过数组实现的，它允许对元素进行快速随机访问。数组的缺点是每个元素之间不能有间隔，当数组大小不满足时需要增加存储能力，就要讲已经有数组的数据复制到新的存储空间中。当从ArrayList的中间位置插入或者删除元素时，需要对数组进行复制、移动、代价比较高。因此，它适合随机查找和遍历，不适合插入和删除。

2.Vector与ArrayList一样，也是通过数组实现的，不同的是它支持线程的同步，即某一时刻只有一个线程能够写Vector，避免多线程同时写而引起的不一致性，但实现同步需要很高的花费，因此，访问它比访问ArrayList慢。

3.LinkedList是用链表结构存储数据的，很适合数据的动态插入和删除，随机访问和遍历速度比较慢。另外，他还提供了List接口中没有定义的方法，专门用于操作表头和表尾元素，可以当作堆栈、队列和双向队列使用。

ArrayList和Vector的区别。

一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的
二.数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半

ArrayList 默认量:0 -10  增量 原来一半   
Vector  默认量: 10 增量 原来的一倍。

拓展了解：ListIterator接口

• List 额外提供了一个 listIterator() 方法，该方法返回一个 ListIterator 对象， ListIterator 接口继承了 Iterator 接口，提供了专门操作 List 的方法：
• void add()
• boolean hasPrevious()
• Object previous()
• Boolean hasNext()
• Object next()

Iterator和ListIterator主要区别
一、ListIterator和Iterator都有hasNext()和next()方法，可以实现顺序向后遍历。但是ListIterator有hasPrevious()和previous()方法，可以实现逆向（顺序向前）遍历。Iterator就不可以。
二、ListIterator可以定位当前的索引位置，nextIndex()和previousIndex()可以实现。Iterator 没有此功能。
三、ListIterator有add()方法，可以向List中插入对象，而Iterator不能。
四、都可实现删除对象，但是ListIterator可以实现对象的修改，set()方法可以实现。Iterator仅能遍历，不能修改。因为ListIterator的这些功能，可以实现对LinkedList等List数据结构的操作。

3.3.1.3 Set接口

• Set接口是Collection的子接口，set接口没有提供额外的方法
• Set 集合不允许包含相同的元素，如果试把两个相同的元素加入同一个 Set 集合中，则添加操作失败。
• Set 判断两个对象是否相同不是使用 == 运算符，而是根据 equals 方法

Set实现类之一 HashSet

• HashSet 是 Set 接口的典型实现，大多数时候使用 Set 集合时都使用这个实现类。
• HashSet 按 Hash 算法来存储集合中的元素，因此具有很好的存取和查找性能。
• HashSet 具有以下特点：
• 不能保证元素的排列顺序
• HashSet 不是线程安全的
• 集合元素可以是 null
• 当向 HashSet 集合中存入一个元素时，HashSet 会调用该对象的 hashCode() 方法来得到该对象的 hashCode 值，然后根据 hashCode 值决定该对象在 HashSet 中的存储位置。
• HashSet 集合判断两个元素相等的标准：两个对象通过 hashCode() 方法比较相等，并且两个对象的 equals() 方法返回值也相等。

代码示例

Set<String> set = new HashSet<String>();// ctrl+shift+O
set.add("one");
set.add("one");
set.add("two");
set.add("three");
set.add("four");
/*
 * for(int i=0;i<set.size();i++){ set. }
 */
System.out.println("长度:" + set.size());

Iterator<String> it = set.iterator();

while (it.hasNext()) {
    System.out.println(it.next());
}

输出结果：

长度:4
four
one
two
three

HashCode()

• 如果两个元素的 equals() 方法返回 true，但它们的 hashCode() 返回值不相等，hashSet 将会把它们存储在不同的位置，但依然可以添加成功。
• 对于存放在Set容器中的对象，对应的类一定要重写equals()和hashCode(Object obj)方法，以实现对象相等规则。
• 重写 hashCode() 方法的基本原则：
• 在程序运行时，同一个对象多次调用 hashCode() 方法应该返回相同的值
• 当两个对象的 equals() 方法比较返回 true 时，这两个对象的 hashCode() 方法的返回值也应相等
• 对象中用作 equals() 方法比较的 Field，都应该用来计算 hashCode 值

Set实现类之二 LinkedHashSet

• LinkedHashSet 是 HashSet 的子类
• LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置，但它同时使用链表维护元素的次序，这使得元素看起来是以插入顺序保存的。
• LinkedHashSet插入性能略低于 HashSet，但在迭代访问 Set 里的全部元素时有很好的性能。
• LinkedHashSet 不允许集合元素重复。

代码示例

Set<String> set = new LinkedHashSet<String>();// ctrl+shift+O
set.add("one");
set.add("two");
set.add("three");
set.add("four");
set.add("four");
/*
 * for(int i=0;i<set.size();i++){ set. }
 */
System.out.println("长度:" + set.size());

Iterator<String> it = set.iterator();

while (it.hasNext()) {
    System.out.println(it.next());
}

输出结果：

长度:4
one
four
two
three

Set实现类之三 TreeSet

• TreeSet 是 SortedSet 接口的实现类，TreeSet 可以确保集合元素处于排序状态。
• Comparator comparator()
• Object first()
• Object last()
• Object lower(Object e)
• Object higher(Object e)
• SortedSet subSet(fromElement, toElement)
• SortedSet headSet(toElement)
• SortedSet tailSet(fromElement)
• TreeSet 两种排序方法：自然排序和定制排序。默认情况下，TreeSet 采用自然排序。

案例5

public static void main(String[] args) {
    //创建对象
    TreeSet<String> set = new TreeSet<String>();
    //添加数据
    set.add("f");
    set.add("y");
    set.add("A");
    set.add("Z");
    System.out.println("长度   "+set.size());
    System.out.println("第一个元素："+set.first());
    System.out.println("最后个元素："+set.last());
    System.out.println("--------------------");
    Iterator<String> it = set.iterator();
    while(it.hasNext()){
        System.out.println(it.next());
    }
}

输出结果：

长度   4
第一个元素：A
最后个元素：y
--------------------
A
Z
f
y   

自然排序

• 自然排序：TreeSet 会调用集合元素的 compareTo(Object obj) 方法来比较元素之间的大小关系，然后将集合元素按升序排列
• 如果试图把一个对象添加到 TreeSet 时，则该对象的类必须实现 Comparable 接口。

• 实现 Comparable 的类必须实现 compareTo(Object obj) 方法，两个对象即通过 compareTo(Object obj) 方法的返回值来比较大小。

• Comparable 的典型实现：

• BigDecimal、BigInteger 以及所有的数值型对应的包装类：按它们对应的数值大小进行比较
• Character：按字符的 unicode值来进行比较
• Boolean：true 对应的包装类实例大于 false 对应的包装类实例
• String：按字符串中字符的 unicode 值进行比较
• Date、Time：后边的时间、日期比前面的时间、日期大

• 向 TreeSet 中添加元素时，只有第一个元素无须比较compareTo()方法，后面添加的所有元素都会调用compareTo()方法进行比较。
• 因为只有相同类的两个实例才会比较大小，所以向 TreeSet 中添加的应该是同一个类的对象
• 对于 TreeSet 集合而言，它判断两个对象是否相等的唯一标准是：两个对象通过 compareTo(Object obj) 方法比较返回值
• 当需要把一个对象放入 TreeSet 中，重写该对象对应的 equals() 方法时，应保证该方法与 compareTo(Object obj) 方法有一致的结果：如果两个对象通过 equals() 方法比较返回 true，则通过 compareTo(Object obj) 方法比较应返回 0

定制排序

• TreeSet的自然排序是根据集合元素的大小，进行元素升序排列。如果需要定制排序，比如降序排列，可通过Comparator接口的帮助。需要重写compare(T o1,T o2)方法。
• 利用int compare(T o1,T o2)方法，比较o1和o2的大小：如果方法返回正整数，则表示o1大于o2；如果返回0，表示相等；返回负整数，表示o1小于o2。
• 要实现定制排序，需要将实现Comparator接口的实例作为形参传递给TreeSet的构造器。
• 此时，仍然只能向TreeSet中添加类型相同的对象。否则发生ClassCastException异常。
• 使用定制排序判断两个元素相等的标准是：通过Comparator比较两个元素返回了0。

Set和List区别

• Set中的元素不能重复
• 类似数学中集合的概念，元素是唯一的
• 怎么叫做重复？
• List中的元素允许重复
• 隐含地有个顺序关系
• 支持ListIterator迭代器，能回溯

集合的能力：

并集
boolean addAll(Collection collectionToAdd)
差集
boolean removeAll(Collection collectionToAdd)
交集
boolean retainAll(Collection collectionToAdd)

代码示例

public static void main(String[] args) {
    Set set1=new HashSet();
    set1.add(new Date());    //向列表中添加数据
    set1.add("apple");     //向列表中添加数据
    set1.add(new Integer(3));   //向列表中添加数据
    set1.add(new Socket());    //向列表中添加数据
    int size=set1.size();
    System.out.println("Set1集合的大小为：" + size);
    Set set2=new HashSet();
    set2.add("book");     //向列表中添加数据
    set2.add(new Long(3));    //向列表中添加数据
    int size2=set2.size();
    System.out.println("Set2集合的大小为：" + size2);
    set1.addAll(set2);
    System.out.println("合并后Set1集合的大小为：" + set1.size());
    set1.removeAll(set2);
    System.out.println("拆分后Set1集合的大小为： " + set1.size());
    set1.retainAll(set2);
    System.out.println("Set1和Set2集合交集的部分：" + set1.size());
}   

输出结果：

Set1集合的大小为：4
Set2集合的大小为：2
合并后Set1集合的大小为：6
拆分后Set1集合的大小为： 4
Set1和Set2集合交集的部分：2

列表的能力：

在指定的位置插入
void add(int index, Obeject newElement)
取得某个索引的元素
Object get(int index)
设置某个索引的元素
Object set(int index, Object newElement)
删除某个索引的元素
Object remove(int index)

代码示例

class Persons{
    
    public String name ;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
    Persons(){
        
    }
    Persons(String name){
        this.name = name;
    }
    
    public static void main(String[] args) {
        List<Persons> persons  = new ArrayList<Persons>();
        persons.add(new Persons("张三"));
        persons.add(new Persons("李四"));
        persons.add(new Persons("王五"));
        persons.add(new Persons("赵六"));
        
        System.out.println(persons.get(0).getName());//这里仅作输出查看
        persons.set(1,new Persons("赵六"));
        persons.remove(2);
        
        for(Persons person: persons){
            System.out.println(person.getName());
        }
    }
}

输出结果：

get方法：张三
张三
赵六
赵六

3.3.3 Map接口

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

Map体系继承树

3.3.3.1 Map常用方法

• 添加、删除操作：

• Object put(Object key,Object value)

• Object remove(Object key)

• void putAll(Map t)

• void clear()

• 元视图操作的方法：

• Set keySet()

• Collection values()

• Set entrySet()

• 元素查询的操作：

• Object get(Object key)

• boolean containsKey(Object key)

• boolean containsValue(Object value)

• int size()

• boolean isEmpty()

• boolean equals(Object obj)

3.3.3.2 Map实现类之一 HashMap

• Map接口的常用实现类：HashMap、TreeMap和Properties。
• HashMap是 Map 接口使用频率最高的实现类。
• 允许使用null键和null值，与HashSet一样，不保证映射的顺序。
• HashMap 判断两个 key 相等的标准是：两个 key 通过 equals() 方法返回 true，hashCode 值也相等。
• HashMap 判断两个 value相等的标准是：两个 value 通过 equals() 方法返回 true。

3.3.3.3 Map实现类之二 LinkedHashMap

• LinkedHashMap 是 HashMap 的子类
• 与LinkedHashSet类似，LinkedHashMap 可以维护 Map 的迭代顺序：迭代顺序与 Key-Value 对的插入顺序一致

3.3.3.4 Map实现类之三 TreeMap

• TreeMap存储 Key-Value 对时，需要根据 key-value 对进行排序。TreeMap 可以保证所有的 Key-Value 对处于有序状态。
• TreeMap 的 Key 的排序：

• 自然排序：TreeMap 的所有的 Key 必须实现 Comparable 接口，而且所有的 Key 应该是同一个类的对象，否则将会抛出 ClasssCastException
• 定制排序：创建 TreeMap 时，传入一个 Comparator 对象，该对象负责对 TreeMap 中的所有 key 进行排序。此时不需要 Map 的 Key 实现 Comparable 接口

• TreeMap判断两个key相等的标准：两个key通过compareTo()方法或者compare()方法返回0。
• 若使用自定义类作为TreeMap的key，所属类需要重写equals()和hashCode()方法，且equals()方法返回true时，compareTo()方法应返回0。

案例6

package day07;

import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;

class Code implements Comparable<Code> {

    private int id;

    public Code(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }

        if (obj instanceof Code) {
            Code c = (Code) obj;

            if (c.id == this.id) {
                return true;
            }
        }
        return false;
    }

    @Override
    public int hashCode() {
        // TODO Auto-generated method stub
        return id;
    }

    @Override
    public String toString() {
        return "Code [id=" + id + "]";
    }

    @Override
    public int compareTo(Code o) {
        if (this.id > o.id) {
            return 1;
        } else if (this.id < o.id) {
            return -1;
        } else {
            return 0;
        }
    }
}

class Person1 {

    private Code id;// 身份

    private String name;// 姓名

    public Person1(String name, Code id) {
        this.name = name;
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public Code getId() {
        return id;
    }

    @Override
    public String toString() {
        return "Person1 [id=" + id + ", name=" + name + "]";
    }
}

public class Treemap {

    public static void main(String[] args) {

        // Comparable 与Comparator
        TreeMap<Code, Person1> map = new TreeMap<Code, Person1>();

        // 购物车 Map

        Person1 p1 = new Person1("张三", new Code(1111));
        Person1 p2 = new Person1("李四", new Code(1112));
        Person1 p3 = new Person1("王五", new Code(1113));
        Person1 p4 = new Person1("赵六", new Code(1114));

        Person1 p5 = new Person1("周七", new Code(1111));

        map.put(p1.getId(), p1);
        map.put(p2.getId(), p2);
        map.put(p3.getId(), p3);
        map.put(p4.getId(), p4);
        map.put(p5.getId(), p5);

        System.out.println("长度" + map.size());

        Set<Entry<Code, Person1>> set = map.entrySet();

        Iterator<Entry<Code, Person1>> it = set.iterator();
        while (it.hasNext()) {
            Entry<Code, Person1> entry = it.next();

            Person1 p = entry.getValue();
            System.out.println(p.getId() + "---" + p.getName());
        }

        Person1 p = map.get(new Code(1111));
        System.out.println("xxxxxx" + p);

    }
}

输出结果：

长度4
Code [id=1111]---周七
Code [id=1112]---李四
Code [id=1113]---王五
Code [id=1114]---赵六
xxxxxxPerson1 [id=Code [id=1111], name=周七]

3.3.3.4 Map实现类之四 Hashtable

• Hashtable是个古老的 Map 实现类，线程安全。
• 与HashMap不同，Hashtable 不允许使用 null 作为 key 和 value
• 与HashMap一样，Hashtable 也不能保证其中 Key-Value 对的顺序
• Hashtable判断两个key相等、两个value相等的标准，与hashMap一致。

HashMap和Hashtable的区别

一.历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现

二.同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的

三.值：只有HashMap可以让你将空值作为一个表的条目的key或value

3.3.3.5 Map实现类之五 Properties

---

• Properties 类是 Hashtable 的子类，该对象用于处理属性文件
• 由于属性文件里的 key、value 都是字符串类型，所以 Properties 里的 key 和 value 都是字符串类型
• 存取数据时，建议使用setProperty(String key,String value)方法和getProperty(String key)方法

代码示例

import java.util.Iterator;
import java.util.Properties;
import java.util.Set;

public class PropertiesDemo {

    public static void main(String[] args) {
        new PropertiesDemo();
        Properties pro = new Properties();
        pro.put("name", "root");
        pro.put("pass", "root");
        pro.put("url", "jdbc:mysql://localhost:3306/db");
        String name = pro.getProperty("name");
        System.out.println(name);
        // 遍历
        /*Set<Object> set = pro.keySet();

        Iterator<Object> it = set.iterator();

        while (it.hasNext()) {
            System.out.println(pro.get(it.next()));
        }*/
        Set<String> set = pro.stringPropertyNames();
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            System.out.println(pro.get(it.next()));
        }
    }

}

输出结果：

root
root
jdbc:mysql://localhost:3306/db
root

但是，常获取数据库密码链接等是通过外部文件得到

{
    Properties pro = new Properties();
    try {
        InputStream is = getClass().getResourceAsStream("jdbc.properties");
        pro.load(is);
        System.out.println("user=="+pro.get("user"));
        System.out.println("password=="+pro.get("password"));
        System.out.println("url==="+pro.get("url"));
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

3.3.4 操纵集合的工具类 Collections

• Collections 是一个操作 Set、List 和 Map 等集合的工具类
• Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法
• 排序操作：（均为static方法）

• reverse(List)：反转 List 中元素的顺序
• shuffle(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)：返回指定集合中指定元素的出现次数
• void copy(List dest,List src)：将src中的内容复制到dest中
• boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值

同步控制

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

3.3.4.1 Collection和Collections区别

Collections是个java.util下的类，它包含有各种有关集合操作的静态方法。

Collection是个java.util下的接口，它是各种集合结构的父接口。

3.3.5 Enumeration

Enumeration 接口是 Iterator 迭代器的 “古老版本”

案例7

Enumeration stringEnum = new StringTokenizer("a-b*c-d-e-g", "-");
while(stringEnum.hasMoreElements()){
    Object obj = stringEnum.nextElement();
    System.out.println(obj); 
}

输出结果：

a
b*c
d
e
g