java集合

Collection集合

常用方法：

Int size()                                                返回集合长度

boolean isEmpty()                     集合是否为空，为空则返回true 不为空则返回false

void clear()                                 将集合清空

boolean contains(Object o)      查看集合中是否包含0元素（使用equals方法进行对象的比较）

boolean add(Object 0)             向集合中添加元素，添加成功则返回true 添加失败则返回false

boolean remove（Object o）将o元素从集合中删除 删除成功返回true 删除失败返回false

Iterator iterator()                     遍历集合的迭代器

boolean containsAll(Collection c)            查看集合是否包含集合c

boolean addAll（Collection c）                将集合c中的元素一次全部添加到目标集合

boolean removeAll（Collection c）         目标集合与集合c的差集

boolean retainAll(Collection c)                  移除本集合中未包含集合c元素的元素

Object toArray()                                            将集合元素转换为对象数组。

Collection方法举例

/**

 * 集合添加元素方法

 * @author Pursuit.

 * @version 2013-11-16  上午9:34:30

 */

publicclass TestArraylistAdd {

    publicstaticvoid main(String[] args) {

        /**

         * ArrayList集合可以存放重复的元素并且保存元素存储的顺序

         */

        Collection c = new ArrayList();

        /**

         * 使用父类引用指向子类对象好处之一：

         * 集合中此时选取的ArrayList若不再满足需求可直接将其修改为LinkedList等

         * 其他Collection实现类，程序更加灵活。

         */

        c.add("a");

        c.add("hello");

        c.add("word");

        c.add("a");

        System.out.println(c.size());  //4

        System.out.println(c);      //[a, hello, word, a]

    }

}

重写对象类的equals和hashcode方法

集合类对象在调用add以及remove，contains方法时需要比较对象是否相等，这要涉及到对象类型的equals和hashcode方法；对于自定义的类型需要重写equals、hashcode方法

Equals方法比较为true的对象其hashcode值也应该相等。

Set集合重元素是否重复的判定方法为equals方法；Map集合中键的位置确定使用的是hashcode值。

/**

 * 集合中的自定义类型需要重写equals方法，因为集合判断元素是否相等使用的是equals方法

 * Map集合中的键值使用到hashcode进行位置的判定因此也需要保证两个对象equals比较相等的

 * 时候hashcode值也应该相等

 * @author Pursuit.

 * @version 2013-11-16  上午9:59:50

 */

publicclass CollectionOverrideEqualsHashCode {

    publicstaticvoid main(String[] args) {

        Collection<Cat> c = new HashSet<Cat>();

        c.add(new Cat("小花",2));

        c.add(new Cat("小花",2));

        /**

         * 当不重写equals方法时集合c张添加了两个元素

         * 只重写equals方法不重写hashcode方法时也是添加了两个元素

         * （hashset集合添加元素时需要用hashcode值确定其存储位置，然后再

         * 使用equals比较对象实际值，如果equals也相等则判定为同一元素，不能同时添加进hashset集合）

         * （若hashcode值不同虽然equals比较相同但仍然会被当做连个对象添加进去，同一个位置的数值放到一起作为链表形式存在）

         * 因此集合中重写equals方法时要保证当equals比较为true时需要确保两个对象的hashcode值也相同

         */

        System.out.println(new Cat("小花",2).equals(new Cat("小花",2)));

        System.out.println(c.size());

        //若想正确打印出自定义类型的集合需要重写对应类的toString方法

        System.out.println(c);

    }

}

class Cat{

    private String name;

    privateintage;

    public Cat(String name,int age){

        this.name = name;

        this.age = age;

    }

    /**

     * 重写equals方法

     */

    publicboolean equals(Object o){

        if(o instanceof Cat){

            return (this.name.equals(((Cat) o).name) &&

                    this.age == (((Cat) o).age));

        }

        //不是同一类型时交给Object的equals方法比较（==比较）

        returnsuper.equals(o);

    }

    publicint hashCode(){

        //String类重写了hashcode值此处返回相同字符串的hashcode肯定是相同的

        returnthis.name.hashCode();

    }

    public String toString(){

        return"名字:"+this.name+"。年龄:"+this.age;

    }

}

 

 

Iterator接口

所有实现了Iterator接口的类都有一个iterator迭代器，都具有以下三个方法，Iterator返回值为Object类型。

boolean hasNext（） 是否具有下一个元素

Object next（）         返回元素

boolean removeNext（）       删除当前遍历到的元素  在执行完next（）方法后此方法只能执行一次

/**

 * 使用iterator迭代器遍历集合

 * @author Pursuit.

 * @version 2013-11-16  上午10:42:06

 */

publicclass TestIterator {

    publicstaticvoid main(String[] args) {

        Collection<String> c = new HashSet<String>();

        c.add("asdf");

        c.add("as");

        c.add("hello");

        c.add("bff");

        //使用Iterrator接口实现遍历集合

        Iterator it = c.iterator();

        while(it.hasNext()){

            String str = (String) it.next();

            System.out.print(str+"\t");

            //只能使用c.remove()方法不能使用集合本身的remove方法

        }

    }

}

增强型for循环

优点：可以方便的遍历一个数组或者一个集合

缺点：在数组中使用不能取对应元素的下表，在集合中使用不能删除元素（其内部也是调用的Iterator实现）。

总结：除了简单遍历集合或者数组不建议使用。

Set接口-Collection的子接口

Set接口实现类没有顺序，不可以存储重复元素（equals方法比较是否为重复元素）。

Set接口实现类没有自己的方法，全部都是Collection中的方法

List接口-Collection子接口

• List接口实现类存储元素时有顺序的，而且可以重复。
• List容器中每一个元素都有一个整形的序号记载其在集合中的位置。可以根据序号存取集合元素。
• List集合类有ArrayList（底层使用数组实现）、LinkedList（底层使用链表实现）

List接口有自己的方法：

Object get（int index）                    返回集合中指定位置的元素

Object set（int index,Object o） 用指定元素替换指定位置的元素 返回被替换掉的元素

void add（int index,Object o）  在指定位置插入指定元素

Object remove（int index） 从集合中删除指定位置的元素

int indexOf(Object o)                         获取指定元素所在集合中第一次出现的下标

int lastIndexOf(Objext o)                  获取指定元素在集合中最后一次出现的下标

Collecitons类的静态方法

Collections为java.util包下的一个类，提供了好多常用集合的静态方法。

void sort(List)  对list集合的排序

• 自然排序
• 自定义排序（需要实现copare to方法进行自定义排序算法）

void shuffle(List) 对list集合进行随机排序

void reverse(List) 将list集合的元素进行翻转

void fill(List,Object o )使用给定元素对List集合进行填充

void copy(List a,List b)将集合b的元素拷贝纸集合a。

int binarySearch(List,Object 0) 在list集合中使用二分法查找给定元素并返回下标。查找前需要进行排序sort（）；

/**

 * collections常用静态方法

 * @author Pursuit.

 * @version 2013-11-16  上午11:30:07

 */

publicclass TestCollections {

    publicstaticvoid main(String[] args) {

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

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

        for(int i =1;i<8;i++){

            l1.add("a"+i);

        }

        Collections.sort(l1);//自然排序

        System.out.println(l1);

        Collections.shuffle(l1);//随机排序

        System.out.println(l1);

        Collections.reverse(l1);//翻转排序

        System.out.println(l1);

//      Collections.sort(l1);

//      System.out.println(l1);

        //使用二分法查找之前必须对元素进行排序不然结果不确定

        System.out.println(Collections.binarySearch(l1, "a3"));

    }

}

 

Comparable接口  java.lang

compareTo方法

public int compareTo(Object o); 

         返回值=0 相等

         返回值>0 被比较对象大

         返回值<0 比较对象大

    publicint compareTo(Object o) {

        int a = age-((Cat)o).age;

        return a>0?a:

            name.compareTo(((Cat)o).name);

    }

如何选择数据结构

Array读快该慢

Liked改快读慢

Hash两者之间

Map接口

实现Map接口的类存储 键——值 对  key-value

Map实现类有HashMap  TreeMap

Map存储元素通过键值进行标示，所以键值不能重复（按照equals比较对象是否相同）

重写equals方法的同时也必须同时重写hashcode方法

常用方法

Object put(Object key,Object value)   存储元素 按照key-value的形式

Object get(Object key)                                 获取指定key位置的元素

Object remove(Object key)                         删除指定key位置而当元素

boolean containsKey(Object key)              查看Map集合中是否包含给定的key

boolean containsValue(Object value)      查看Map集合中是否包含给定的value

int size();                                                         Map集合长度  多少对对象

boolean isEmpty()                                         是否为空

void putAll(Map c)

void clear()

import java.util.HashMap;

import java.util.Map;

 

/**

 * 求出给定数组中重复的元素个数并打印

 * @author Pursuit.

 * @version 2013-11-16  下午2:54:16

 */

publicclass TetsMap {

    publicstaticvoid main(String[] args) {

        String[] str = {"aaa","bbb","aaa","ccc","ddd","aaa","bbb",

                "eee","fff","eee"};

        method(str);

        Integer[] il = {1,1,1,2,3,4,4,4,5,6,7,8,9,5,67,8,32,6,8,6};

        method(il);

        }

    //定义一个泛型方法

    publicstatic <T> void method(T[] s){

        final  Integer one = new Integer(1);

        Map<T,Integer> m = new HashMap<T,Integer>();

        for(int i=0;i<s.length;i++){

            Integer temp = m.get(s[i]);

            //如果当前key已经存在则将value+1后更新value值

            m.put(s[i], temp==null? one : new Integer(temp+1));

        }

        System.out.println(m.size()+"个元素被留下");

        System.out.println(m);

    }

}

 

集合总结

第一类集合Collection根接口

Collection接口

Colleciton接口为List Set Queue接口的父接口，定义了许多操作此类接口实现类的通用方法。

 

Set接口：

         Set集合类似于一个罐子，不保存存储数据时的顺序；除了Collection提供的集合方法之外Set集合没有提供额的方法。由于Set集合是无序的因此Set集合不能够存储重复的元素（此处判定元素是否重复使用的是equals方法，需要注意的是在往集合中添加自定义类型的元素时如果重写equals方法则需要保证如果两个对象使用equals方法比较返回为true时其hashcode值也应该相同，也就是说重写equals方法的同时也要重写hashcode方法）；

HashSet实现类

HashSet是Set集合的典型实现类，java中经常用到的Set集合类。HashSet是按照hash值来存取元素的，具有以下特点

• 不保证元素的顺序，顺序可能会发生变化
• HashSet不是同步的也就是线程不安全，当多个线程同时访问HashSet集合时容易引发线程安全问题，如果有多个线程需要访问HashSet集合则要保证其同步
• 集合元素可以是null
• HashSet集合会根据元素的hash值计算其存储位置，如果两个元素equals比较相同但是其hash值不同仍然可以保存在HashSet集合中，但是会降低其性能。如果两个元素HashCode值相同但是使用equals比较为false此时处理更加麻烦，HashSet会试图将两个元素添加到同一个位置。
• 重写equals方法的同时需要保证如果两个对象使用equals方法比较返回为true则一定要重写其hashcode方法保证hash值也相同

TreeSet实现类

TreeSet类时SortedSet接口的唯一实现类，TreeSet集合可以保证期存储的顺序。同时TreeSet集合使用一个链表维护元素的顺序，因此性能略低于HashSet但是在迭代访问元素时性能较好。

TreeSet额外的方法：

• Comparator comparator（）返回当前集合使用的Comparato（比较器），返回null表示为自然排序
• Object first() 返回集合第一个元素
• Object last（）返回集合最后一个元素
• Object lower(Object o)返回集合中位于指定元素之前的元素（即小于指定元素的最大元素，此指定元素可以不包含在集合中）
• Object higher（Object o）返回集合中位于指定元素之后的元素（即大于指定元素的最小元素，此元素可以不包含在集合中）
• SortedSet subset（from，to）返回集合的子集合，从指定位置from（包含）到最后位置to（不包含）

List接口：

         List集合代表一个有序集合，集合中的每个元素都有其对应的索引。List集合可以存放重复元素，可以根据索引获取响应的元素。List时有序集合因此List集合添加了一部分根据索引进行操作的方法

ArrayList实现类 Vector

ArrayList时基于数组实现的List集合。ArrayList也是线程不安全的集合但是Vector时线程安全的。ArrayList增加了capacity属性，我们可以动态人为调整期存储能力。

LinkedList实现类

Queue接口

         Queue用于模拟队列数据结构，采取先进先出的原则，方法为：

boolean offer（Object o） 添加元素 将制定元素添加到队里的尾部

Object peek（） 获取队列的头部元素，但是不删除元素，如果队列为空则返回null

Object poll（）获取队列的头部元素并且删除该元素，如果该元素不存在则返回null

Obect remove（） 获取队列的头部元素并且删除

LinkedList实现类

LinkedList即实现了List接口要实现了DeQueue接口，他是一个双向队列。

PriorityQueue实现类

标准队列的实现类而不是绝对标准的队列实现类是因为他是按照元素的大小重新排序后添加进去而不是按照本来添加的顺序存储元素

 

第二类集合Map根接口

Map接口

HashMap实现类

Hashtable是一个古老的Map接口实现类现在用的较少但是它是线程安全的，HashMap效率较高但是线程不安全。

Hashtable不可以接受null的元素会引发空指针异常，但是HashMap可以接受Null元素存储。

Hashtable竟然没有按照标准命名类名。。。。。。太古老了 慎用吧。

用作key的对象必须重写equals方法以及hashcode方法，key值是不重复的

SortedMap接口及其TreeMap实现类

TreeMap基于红黑树对所有的key进行排序，两种排序方式

• 自然排序
• 自定义排序

自定义排序需要key值对应的对象实现comparable接口，重写其compareTo方法

 

第三操作集合的工具类Collections

基于List集合的排序静态方法

         reverse（List l） 将List集合所有元素翻转排序

         shuffle（List l）将List集合元素随机排序

         sort（List l）将list集合自然排序 升序

         sort（List l，Comparator C） 将List集合按照给定的比较器进行排序

         swap( int I,int j)将两个位置的元素互换