java集合容器

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

推荐阅读更多精彩内容