java集合类

用"集合框架"设计软件时,记住该框架四个基本接口的下列层次结构关系会有用处:

Collection 接口是一组允许重复的对象.

List 接口继承 Collection,元素可重复,元素有放入顺序,并引入位置下标.

Set 接口继承 Collection ,元素无放入顺序，元素不可重复（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的）

Map 接口既不继承Set 也不继承Collection,存取的是键值对

Collection/Map	接口	成员重复性	元素存放顺序	元素中被调用的方法	基于那中数据结构来实现的
Arraylist	Collection	允许重复	插入顺序	equals()	数组
Vector	Collection	允许重复	插入顺序	equals()	数组
LinkedList	Collection	允许重复	插入顺序	equals()	链表
HashSet	Set	不允许重复	无序	equals()/ hashCode()	Hsah表
LinkedHashSet	Set	不允许重复	插入顺序	equals()/ hashCode()	Hash 表和双向链表
TreeSet	SortedSet	不允许重复	有序(二叉树排序)	equals()/ compareTo()	平衡树(Balanced tree)
HashMap	Map	key不允许重复，value允许重复	无序	equals()/ hashCode()	Hash 表
LinkedHashMap	Map	key不允许重复，value允许重复	key插入顺序排序	equals()/ hashCode()	Hash 表和双向链表
HashTable	Map	key不允许重复，value允许重复	无序	equals()/ hashCode()	Hash 表
TreeMap	SortedMap	key不允许重复，value允许重复	有序(二叉树排序)	equals()/ compareTo()	平衡树(Balanced tree)

List接口:

1.ArrayList与Vector的区别：

(1)同步性:Vector是线程安全的,也就是说它的方法之间是线程同步的.而ArrayList是线程不安全的,它的方法之间是线程不同步的.如果只有一个线程会访问到集合,　　那最好是用ArrayList,因为它不考虑线程安全,效率会高些;如果有多个线程会访问到集合,那最好是使用Vector,因为不需要我们自己再去考虑和编写线程安全的代码.

(2)数据增长: ArrayList与Vector都有一个初始的容量大小，当存储进它们里面的元素的个数超过了容量时，就需要增加ArrayList与Vector的存储空间，每次要增加存储空间时,不是只增加一个存储单元,而是增加多个存储单元，每次增加的存储单元的个数在内存空间利用与程序效率之间要取得一定的平衡。Vector默认增长为原来两倍,而ArrayList的增长策略在文档中没有明确规定 (从源代码看到的是增长为原来的1.5倍).ArrayList与Vector都可以设置初始的空间大小,Vector还可以设置增长的空间大小，而ArrayList没有提供设置增长空间的方法。总结：即Vector增长原来的一倍，ArrayList增加原来的0.5倍。

(3)产生时间:Vector是java一诞生就提供了的,而ArrayList与HashMap是java2 时才提供的.

2.ArrayList与LinkedList:

(1)对ArrayList和LinkedList而言，在列表末尾增加一个元素所花的开销都是固定的。对ArrayList而言，主要是在内部数组中增加一项，指向所添加的元素，偶尔可能会导致对数组重新进行分配；而对LinkedList而言，这个开销是统一的，分配一个内部Entry对象。

(2)在ArrayList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在LinkedList的中间插入或删除一个元素的开销是固定的。

(3)LinkedList不支持高效的随机元素访问.

(4)ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间.
可以这样说：当操作是在一列数据的后面添加数据而不是在前面或中间,并且需要随机地访问其中的元素时,使用ArrayList会提供比较好的性能；当你的操作是在一列数据的前面或中间添加或删除数据,并且按照顺序访问其中的元素时,就应该使用LinkedList了。

3.关于ArrayList的相关操作:

增、删、查、迭代、循环操作:

/**
 * @author Administrator
 * @state 关于List的增、删、改、查、排序、迭代
 */
public class ListDemo {
    List<String> list= new ArrayList<String>();
    //增加
    public void addList(){
        list.add("one");
        list.add("two");
        list.add("three");
    }
    //删除
    public void delList(){
        list.remove(0);
    }
    //查询
    public boolean selectList(){
        return list.contains("one");
    }
    //迭代
    public void interatorList(){
        Iterator<String> iterator = list.iterator();
        while(iterator.hasNext()){
            iterator.next();
        }
    }
    //循环
    public void forLsit(){
        for (int i = 0; i < list.size(); i++) {
            list.get(i);
        }
    //forech循环list
        for(String s : list){
            System.out.println(s);
        }
    }
    
}

View Code

排序操作:

（注:以下排序部分为网上摘抄,源地址为:http://www.open-open.com/lib/view/open1322614659562.html,代码做了部分细节修改）

Java API针对集合类型排序提供了两种支持：

java.util.Collections.sort(java.util.List)
java.util.Collections.sort(java.util.List, java.util.Comparator)

第一个方法要求所排序的元素类必须实现java.lang.Comparable接口。
第二个方法要求实现一个java.util.Comparator接口。

第一种:list中的对象实现Comparable接口，如下:

/**
 * @author Administrator
 * @state Userbean,compareTo根据order排序
 */
public class User implements Comparable<User> {
    private String name;
    private Integer order;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getOrder() {
        return order;
    }

    public void setOrder(Integer order) {
        this.order = order;
    }

    @Override
    public int compareTo(User arg0) {
        return this.getOrder().compareTo(arg0.getOrder());
    }

}

View Code

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        User user1 = new User();
        user1.setName("b");
        user1.setOrder(2);
        User user2 = new User();
        user2.setName("a");
        user2.setOrder(1);
        List<User> list = new ArrayList<User>();
        list.add(user2);
        list.add(user1);
        Collections.sort(list);
        for (User u : list) {
            System.out.println(u.getName());
        }

    }
}

View Code

输出结果如下:

a
b

第二种:list中的对象实现Comparator接口，如下:

Userbean

package paixu2;

public class User {
    private String name;
    private Integer order;
    
    public User(String name,Integer order){
        this.name=name;
        this.order=order;
    }
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getOrder() {
        return order;
    }
    public void setOrder(Integer order) {
        this.order = order;
    }
}

View Code

ComparatorUser

package paixu2;

import java.util.Comparator;

/**
 * @author Administrator
 * @state 现根据order排序,如果order有相等的再根据name排序
 */
public class ComparatorUser implements Comparator<User>{

    @Override
    public int compare(User arg0, User arg1) {
        int flag = arg0.getOrder().compareTo(arg1.getOrder());
        if(flag==0){
            return arg0.getName().compareTo(arg1.getName());
        }else {
            return flag;
        }
    }
    
}

View Code

Test

package paixu2;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        List<User> list = new ArrayList<User>();
        list.add(new User("刘芳",5));
        list.add(new User("张三",2));
        list.add(new User("黄华",4));
        list.add(new User("李华",1));
        list.add(new User("王五",3));
        ComparatorUser comparatorUser = new ComparatorUser();
        Collections.sort(list,comparatorUser);
        for(User user : list){
            System.out.println("order:" + user.getOrder()+"====="+"name:"+user.getName());
        }
    }
}

View Code

输出结果为:

order:1=====name:李华
order:2=====name:张三
order:3=====name:王五
order:4=====name:黄华
order:5=====name:刘芳

Set接口

hashset的常用操作:

package com.net.cn.zy.collection.demo;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

/**
 * @author Administrator
 * @state set的增、删、改、查、排序、迭代
 */
public class SetDemo {
    Set<String> set = new HashSet<String>();
    //增加
    public void addSet(){
        set.add("one");
        set.add("two");
        set.add("three");
    }
    
    //删
    public void delSet(){
        set.remove("one");
    }
    
    //查
    public boolean containsSet(){
        return set.contains("one");
    }
    
    //排序
    public void entrySet(){
        Set<String> treeSet = new TreeSet<String>();
    }
    
    //循环
    public void forSet(){
        Iterator<String> setIterator = set.iterator();
        while(setIterator.hasNext()){
            setIterator.next();
        }
    }
}

View Code

其他的两种实现类放在以后的文章单独总结。
MAP接口

1、Hashmap和Hashtable的区别

HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口，主要区别在于HashMap允许空（null）键值（key）,由于非线程安全，在只有一个线程访问的情况下，效率要高于Hashtable.

HashMap允许将null作为一个entry的key或者value，而Hashtable不允许.

HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey.因为contains方法容易让人引起误解.

Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Mapinterface的一个实现。最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable 时，不需要自己为它的方法实现同步，而HashMap 就必须为之提供外同步.Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。

就HashMap与HashTable主要从三方面来说。
一.历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java1.2引进的Map接口的一个实现
二.同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的
三.值：只有HashMap可以让你将空值作为一个表的条目的key或value

2、遍历HashMap的方法:

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class MapDemo {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<Integer, String>();
        //添加
        map.put(1, "A");
        map.put(2, "B");
        map.put(3, "C");
        map.put(4, "D");
        map.put(5, "E");
        map.put(null,"E");
        //jdk1.4
        Iterator<Map.Entry<Integer, String>> iterator = map.entrySet().iterator();
        while(iterator.hasNext()){
            Map.Entry<Integer, String> entry = iterator.next();
            System.out.println("Key:"+entry.getKey()+"  "+"Value:"+entry.getValue());
        }
        System.out.println("=========================================================");
        
        //jdk1.5
        for(Map.Entry<Integer, String> entry : map.entrySet()){
            System.out.println("Key:" + entry.getKey() +"  "+"Value:" +entry.getValue());
        }
    }
    
}

View Code