Java容器整理

JAVA容器学习总结

一:    1图

  ＪＡＶＡ容器API图

图

   

二:   6接口

1/6 : Collection接口

 

１：Collection接口常用方法

１）boolean add(E o)   add(Object o)

　<1> 确保此 collection 包含指定的元素（可选操作）。如果此 collection 随调用的结果而发生改变，则返回true。（如果此 collection 不允许有重复元素，并且已经包含了指定的元素，则返回false。）

<2> 支持此操作的 collection 可以限制哪些元素能添加到此 collection 中来。需要特别指出的是，一些 collection 拒绝添加null元素，其他一些 collection 将对可以添加的元素类型强加限制。Collection 类应该在其文档中清楚地指定能添加哪些元素方面的所有限制。

<3>如果 collection 由于某些原因（已经包含该元素的原因除外）拒绝添加特定的元素，那么它必须抛出一个异常（而不是返回false）。这确保了在此调用返回后，collection 总是包含指定的元素。

<4>抛出：

UnsupportedOperationException - 此 collection 不支持 add 操作。

ClassCastException - 指定元素的类不允许它添加到此 collection 中。

NullPointerException - 如果指定的元素为 null，并且此 collection 不支持 null 元素。

IllegalArgumentException - 此元素的某方面不允许它添加到此 collection 中。

 

２）boolean addAll(Collection<? extends E> c)

<1> 将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。如果在进行此操作的同时修改指定的 collection，那么此操作行为是不明确的。（这意味着如果指定的 collection 是此 collection，并且此 collection 为非空，那么此调用的行为是不明确的。）

<2>参数： c - 要插入到此 collection 的元素。

<3>返回：如果此 collection 随调用的结果而发生改变，则返回 true

<4>抛出的异常与add(Object)方法相似

 

３）  void clear() 移除此 collection 中的所有元素（可选操作）。此方法返回后，除非抛出一个异常，否则 collection 将为空。

抛出： UnsupportedOperationException - 如果此 collection 不支持 clear 方法。

 

4) boolean contains(Object o)

如果此 collection 包含指定的元素，则返回true。更正式地说，当且仅当此 collection 至少包含一个满足(o==null ? e==null : o.equals(e))的元素e时才返回true。

抛出：

ClassCastException - 如果指定元素的类型与此 collection 不兼容（可选）。

NullPointerException - 如果指定的元素为 null，并且此 collection 不支持 null 元素（可选）。

 

5) boolean containsAll(Collection<?> c)

如果此 collection 包含指定 collection 中的所有元素，则返回true。

抛出：

ClassCastException - 如果指定 collection 中有一个或多个元素的类型与此 collection 不兼容（可选）。

NullPointerException - 如果指定 collection 包含一个或多个 null 元素，并且此 collection 不支持 null 元素（可选）。

NullPointerException - 如果指定的 collection 为 null。

 

6) boolean isEmpty()

如果此 collection 不包含元素，则返回 true。

7)  Iterator<E> iterator()

返回在此 collection 的元素上进行迭代的迭代器。关于元素返回的顺序没有任何保证（除非此 collection 是某个能提供保证顺序的类实例）。

8) boolean remove(Object o)

从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。更正式地说，如果此 collection 包含一个或多个满足 (o==null ? e==null : o.equals(e)) 的元素 e，则移除这样的元素。如果此 collection 包含指定的元素（或者此 collection 随调用的结果而发生改变），则返回 true。

9) int size()

返回此 collection 中的元素数。如果此 collection 包含多个 Integer.MAX_VALUE 元素，则返回 Integer.MAX_VALUE。

10) Object[] toArray()

返回包含此 collection 中所有元素的数组。如果 collection 对其迭代器返回的元素顺序做出了某些保证，那么此方法必须以相同的顺序返回这些元素。

(11) boolean removeAll(Collection<?> c)   <相减>

移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。此调用返回后，collection 中将不包含任何与指定 collection 相同的元素。

(12) boolean retainAll(Collection<?> c)   <交集>

仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。换句话说，移除此 collection 中未包含在指定 collection 中的所有元素。

简单测试实例:

package zyq.collection;

 

import java.util.ArrayList;

import java.util.Collection;

 

/**

 *JAVA容器测试

 *@authorAdministrator

 *

 */

publicclass JavaCollectionTest {

    publicstaticvoid main(String[] args) {

       Collection<User> c = new ArrayList<User>();

       User user = new User("zyq");

       User wife = new User("123");

       user.setWife(wife);

        c.add(user);

        User user3 = new User("zyq");

//      因为User类中hashCode()方法的实现是return name.hashCode();所以当user3的name值为zzz时不能remove掉该元素

//      User user3 = new User("zzz");   

        user3.setWife(wife);

//      user3.serWife(user);   

        c.remove(user3);

        System.out.println(c);

    }

}

 

class User {

    String name;

    User wife;

   

    public User(String name) {

       super();

       this.name = name;

    }

 

    public User getWife() {

       returnwife;

    }

 

    publicvoid setWife(User wife) {

       this.wife = wife;

    }

 

    /*

     * 注意在JAVA容器中要判断两个容器是否相等必须重写hashCode()和equals()方法

     * (non-Javadoc)

     * @see java.lang.Object#hashCode()

     */

    publicint hashCode() {

       returnname.hashCode();

    }

   

    /*

     * (non-Javadoc)

     * @see java.lang.Object#equals(java.lang.Object)

     */

    publicboolean equals(Object obj) {

       if (this == obj)

           returntrue;

       if (obj == null)

           returnfalse;

       if (getClass() != obj.getClass())

           returnfalse;

       User other = (User) obj;

       if (name == null) {

           if (other.name != null)

              returnfalse;

       } elseif (!name.equals(other.name))

           returnfalse;

       if (wife == null) {

           if (other.wife != null)

              returnfalse;

       } elseif (!wife.equals(other.wife))

           returnfalse;

       returntrue;

    }

} 

注意:  容器类对象调用remove和contains方法时,需要比较两个对象是否相等,这时会涉及到对象类型的equals方法和hashCode方法,对于自定义的类型,需要重写equals方法和

hashCode方法以定义自定义的对象的相等规则.

附: 相等的对象应具有相等的hashCode

2/6:   Iterator接口 : 对集合进行迭代的迭代器

所有实现了Collection接口的类都有一个iterator()方法用以返回一个实现了Iterator接口的对象 .

Iterator接口的常用方法:

<1>boolean hasNext()

如果仍有元素可以迭代，则返回 true

<2>E next()

返回迭代的下一个元素。重复调用此方法直到 hasNext() 方法返回 false，这将精确地一次性返回迭代器指向的集合中的所有元素。 

<3>void remove()

从迭代器指向的集合中移除迭代器返回的最后一个元素（可选操作）。每次调用 next 只能调用一次此方法。如果进行迭代时用调用此方法之外的其他方式修改了该迭代器所指向的集合，则迭代器的行为是不明确的。

 

测试实例:

package zyq.collection;

 

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

 

/**

 *Java中Iterator接口的测试

 *@authorAdministrator

 *

 */

publicclass JavaIteratorTest {

    publicstaticvoid main(String[] args) {

       Collection<Person> c = new ArrayList<Person>();

       c.add(new Person("p1"));

       c.add(new Person("p2"));

       c.add(new Person("p3"));

       c.add(new Person("p4"));

       c.add(new Person("p5"));

        //使用Iterator接口遍历

       for(Iterator<Person> iter = c.iterator() ; iter.hasNext();){

           System.out.println(iter.next().name);

       }

    }

}

 

class Person{

    String name;

    Person wife;

    public Person(String name) {

       this.name = name;

    }

}

 

3/6: Set接口 : 一个不包含重复元素的 collection

Set接口是Collection接口的子接口,Set接口没有提供额外的方法,但实现Set接口的实现类中储存的元素是没有顺序的,而且不可以重复

      Set容器可以与数学中”集合”的概念相对应.

      Set接口的已知实现类HashSet和TreeSet等

 

简单示例:

package zyq.collection;

 

import java.util.HashSet;

import java.util.Set;

 

/**

 *JAVA中Set接口简单测试

 *@authorAdministrator

 *

 */

publicclass JavaSetTest {

    publicstaticvoid main(String[] args) {

       Set<String> s1 = new HashSet<String>();

       Set<String> s2 = new HashSet<String>();

       s1.add("a");  s1.add("d");  s1.add("c");  s1.add("b");

       s2.add("a");  s2.add("e");  s2.add("c");  s2.add("f");

       Set<String> s3 = new HashSet<String>(s1);

       Set<String> s4 = new HashSet<String>(s2);

       s3.removeAll(s2);    //将s3中出现在s2中的所有元素移除

       System.out.println(s3);

       s4.retainAll(s1);    //将既在s1中存在又在s4中存在的元素作为s4的元素

       System.out.println(s4);

        //addAll()方法略(求并集)

    }

}

4/6:  List接口: 有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。

与 set 不同，列表通常允许重复的元素.

List接口常用方法:

<1>E get(int index)

返回列表中指定位置的元素。

<2>E set(int index,

      E element)

用指定元素替换列表中指定位置的元素（

抛出：

UnsupportedOperationException - 如果列表不支持 set 方法。

ClassCastException - 如果指定元素的类不允许它添加到此列表。

NullPointerException - 如果指定的元素为 null，并且此列表不支持 null 元素。

IllegalArgumentException - 如果指定元素的某个方面不允许它添加到此列表。

IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index >= size())。

<3>void add(int index,

         E element)

在列表的指定位置插入指定元素（可选操作）。将当前处于该位置的元素（如果有的话）和所有后续元素向右移动（在其索引中加 1）。

<4>E remove(int index)

移除列表中指定位置的元素（可选操作）。将所有的后续元素向左移动（将其索引减 1）。返回从列表中移除的元素。

参数：

<5>int indexOf(Object o)

返回列表中首次出现指定元素的索引，如果列表不包含此元素，则返回 -1。更正式地说，返回满足下面条件的最低索引 i：(o==null ? get(i)==null :o.equals(get(i)))，如果没有这样的索引，则返回 -1。

<6>int lastIndexOf(Object o)

返回列表中最后出现指定元素的索引，如果列表不包含此元素，则返回 -1。更正式地说，返回满足下面条件的最高索引 i：(o==null ? get(i)==null :o.equals(get(i)))，如果没有这样的索引，则返回 -1。

<7>List<E> subList(int fromIndex,

                int toIndex)

返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。（如果 fromIndex 和 toIndex 相等，则返回的列表为空）。返回的列表由此列表支持，因此返回列表中的非结构性更改将反映在此列表中，反之亦然。返回的列表支持此列表支持的所有可选列表操作。

此方法省去了显式范围操作（此操作通常针对数组存在）。通过传递 subList 视图而非整个列表，期望列表的任何操作可用作范围操作。例如，下面的语句从列表中移除了元素的范围：

            list.subList(from, to).clear();

 

可以对 indexOf 和 lastIndexOf 构造类似的语句，而且 Collections 类中的所有算法都可以应用于 subList。

如果支持列表（即此列表）通过任何其他方式（而不是通过返回的列表）从结构上修改，则此方法返回的列表语义将变为未定义（从结构上修改是指更改列表的大小，或者以其他方式打乱列表，使正在进行的迭代产生错误的结果）。

List底层是利用链表实现的.

 

简单示例:

package zyq.collection;

 

import java.util.ArrayList;

import java.util.List;

 

/**

 *Java中List接口的简单测试

 *@authorZYQ

 *

 */

publicclass JavaListTest {

    publicstaticvoid main(String[] args) {

        List<String> list = new ArrayList<String>();

        for(int i=0; i<10; i++){

        list.add("zyq" + (i+1));

        }

        System.out.println(list.get(4));

        list.set(4, "zzz4");

        System.out.println(list);

        list.add(4, "zyq4");

        System.out.println(list);

        list.remove(5);

        System.out.println(list.indexOf("zzz4"));

       

    }

}

 

//输出结果

zyq5

[zyq1, zyq2, zyq3, zyq4, zzz4, zyq6, zyq7, zyq8, zyq9, zyq10]

[zyq1, zyq2, zyq3, zyq4, zyq4, zzz4, zyq6, zyq7, zyq8, zyq9, zyq10]

-1

 

5/6:   Comparable接口

此接口强行对实现它的每个类的对象进行整体排序。此排序被称为该类的自然排序，类的compareTo方法被称为它的自然比较方法。

int compareTo(T o)

比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。

 

6/6:  Map接口 : 实现Map接口的类用来存储键-值对

将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射一个值。

常用方法:

<1>void clear()

从此映射中移除所有映射关系（可选操作）。

<2>keySet

Set<K> keySet()

返回此映射中包含的键的 set 视图。该 set 受映射支持，所以对映射的改变可在此 set 中反映出来，反之亦然。如果修改映射的同时正在对该 set 进行迭代（除了通过迭代器自己的remove操作外），则迭代结果是不明确的。set 支持通过Iterator.remove、Set.remove、removeAllretainAll和clear操作实现元素移除，即从映射中移除相应的映射关系。它不支持 add 或addAll操作。

<3>entrySet

Set<Map.Entry<K,V>> entrySet()

返回此映射中包含的映射关系的 set 视图。返回的 set 中的每个元素都是一个Map.Entry。该 set 受映射支持，所以对映射的改变可在此 set 中反映出来，反之亦然。如果修改映射的同时正在对该 set 进行迭代（除了通过迭代器自己的remove操作，或者通过在迭代器返回的映射项上执行setValue操作外），则迭代结果是不明确的。set 支持通过Iterator.remove、Set.remove、removeAll、retainAll和clear操作实现元素移除，即从映射中移除相应的映射关系。它不支持add或addAll操作。

<4>values

Collection<V> values()

返回此映射中包含的值的 collection 视图。该 collection 受映射支持，所以对映射的改变可在此 collection 中反映出来，反之亦然。如果修改映射的同时正在对该 collection 进行迭代（除了通过迭代器自己的remove操作外），则迭代结果是不明确的。collection 支持通过Iterator.remove、Collection.remove、removeAll、retainAll和clear操作实现元素移除，即从映射中移除相应的映射关系。它不支持 add 或addAll操作。

 

<5>remove

V remove(Object key)

如果存在此键的映射关系，则将其从映射中移除（可选操作）。更正式地说，如果此映射包含满足以下从键k到值v的映射关系：(key==null ? k==null :key.equals(k))，则移除该映射关系（该映射最多只能包含一个这样的映射关系）。

返回此映射中以前映射该键的值，如果此映射不包含该键的映射关系，则返回 null（如果该实现支持 null 值，则返回 null 也可表明此映射以前将 null 与指定键相关联）。一旦调用返回，则此映射不包含指定键的映射关系。

<6>put

V put(K key,

      V value)

将指定的值与此映射中的指定键相关联（可选操作）。如果此映射中以前包含一个该键的映射关系，则用指定值替换旧值（当且仅当m.containsKey(k)返回true时，才能说映射m包含键k的映射关系）。

参数：

key - 与指定值相关联的键。

value - 与指定键相关联的值。

返回：

以前与指定键相关联的值，如果没有该键的映射关系，则返回null。如果该实现支持null值，则返回null也可表明此映射以前将null与指定键相关联。

<7>get

V get(Object key)

返回此映射中映射到指定键的值。如果此映射中没有该键的映射关系，则返回null。返回null值并非一定表明此映射不包含该键的映射关系；也可能此映射将该键显示地映射到null。可使用containsKey操作来区分这两种情况。

更正式地说，如果此映射包含满足以下从键 k 到值 v 的映射关系：(key==null ? k==null :key.equals(k))，则此方法返回 v；否则返回 null（最多只能有一个这样的映射关系）。

参数：

key - 要返回其相关值的键。

返回：

此映射中映射到指定值的键，如果此映射不包含该键的映射关系，则返回null。

<8>isEmpty

boolean isEmpty()

如果此映射未包含键-值映射关系，则返回true。

<9> size

int size()

返回此映射中的键-值映射关系数。如果该映射包含多个Integer.MAX_VALUE元素，则返回Integer.MAX_VALUE。

 

 

 

 

三: 2类

1/2:  java.util.Collections

 

常用静态方法:

<1>public static <T> int binarySearch(List<? extends Comparable<? super T>> list 使用二进制搜索算法来搜索指定列表，以获得指定对象。在进行此调用之前，必须根据列表元素的自然顺序 对列表进行升序排序（通过上面的 sort(List) 方法）。如果没有对列表进行排序，则结果是不明确的。如果列表包含多个等于指定对象的元素，则无法保证找到的是哪一个。

返回：

如果搜索键包含在列表中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。插入点 被定义为将键插入列表的那一点：即第一个大于此键的元素索引，如果列表中的所有元素都小于指定的键，则为 list.size()。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。

<2>public static void sort(List<T> list)

<3>public static void reverse(List<?> list)

反转指定列表中元素的顺序。

<4>等等………

*如何选择数据结构:

衡量标准:读的效率和改的效率

Array读快改慢

Linked改快读慢

Hash两者之间