Java集合

Java集合

 1.java集合的概述

　　Java集合类存放于 java.util 包中，是一个用来存放对象的容器。　

　　注意：①、集合只能存放对象。比如你存一个 int 型数据放入集合中，其实它是自动转换成 Integer 类后存入的，Java中每一种基本类型都有对应的引用类型。

　　　　　②、集合存放的是多个对象的引用，对象本身还是放在堆内存中。

　　　　　③、集合可以存放不同类型，不限数量的数据类型。

　　容器API的类图结构如下图所示：

　　 

　　左边的容器也就是Collection接口的类都是一个个往里装，右边的容器也就是map这一边的是一对一对往里装

　　Collection接口定义了存取一组对象的方法，他代表了一个集合，他下面分了两个子接口set和list。

　　装东西的时候set是没有顺序并且不可以重复，list是有顺序可以重复，所谓的重复是指两个对象equals

　　Map接口定义了存储“键(key) –值(value)”  映射对的方法

　　 Java集合类架构层次关系：

　　　　 

2.Collection接口

　　1.Collection接口中所定义的方法：

　　int size();
　　boolean isEmpty();
　　void clear();
　　boolean contains(Object element);//查看是否包含某一个对象
　　bllean add(Object element);
　　boolean remove(Object element);
　　Iterator iterator();
　　boolean containsAll(collection c);
　　bllean addAll(Collection c);
　　boolean removeAll(Collection c);
　　boolean retainAll(Collection c);//交集
　　object[] toArray();

　　　　看一个示例：

public class Test{
    
    public static void main(String[] args) {
        Collection c = new ArrayList();//父类引用指向子类对象
        //可以放入不同类型的对象
        c.add("你好");
        c.add(new Name("name1","name2"));
        c.add(new Integer(100));
        c.remove("你好");
        c.remove(new Integer(100));
        System.out.println(c.remove(new 
Name("name1","name2")));
        System.out.println(c);
    }        
}
class Name{
    String name1;
    String name2;
    Name(String name1,String name2){
        this.name1 = name1;
        this.name2 = name2;
    }
}
//输出结果：
//false
//[name1 name2]
//因为两个Name("name1","name2")指向的不是同一个对象，所以equals方法返回false

　　　　容器类对象在调用remove、contains等方法时需要比较对象是否相等，这回涉及到对象类型的equals方法和hashCode方法；对于自定义的类型，需要重写equals和hashCode方法以实现自定义的对象相等规则

　　　　注意：相等的对象应该具有相等的hashCode

　　2.set接口

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

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

　　　   J2SDK 的API中所提供的Set容器类有HashSet，LinkedHashSet，TreeSet等

　　　　1.HashSet是一个典型的无序、不可重复的集合封装类，使用方式：Set hashSet = new HashSet();

　　　　注意：每一个存储到 哈希 表中的对象，都得提供 hashCode() 和 equals() 方法的实现，用来判断是否是同一个对象， 对于 HashSet 集合，我们要保证如果两个对象通过 equals() 方法返回 true，这两个对象的 hashCode 值也应该相同。

　　　　常见的 hashCode()算法：

　　　　　　 

　　　　2.LinkedHashSet是不可以重复，有序的集合类；使用方式：Set linkedHashSet = new LinkedHashSet();

　　　　因为LinkedHashSet底层采用链表和哈希表的算法。链表保证元素的添加顺序，哈希表保证元素的唯一性

　　　　3.TreeSet:有序；不可重复，底层使用 红黑树算法，擅长于范围查询。

　　　　示例：

public class Test{   
    public static void main(String[] args) {  
        Set s1 = new HashSet();
        Set s2 = new HashSet();
        s1.add("a1");
        s1.add("a2");
        s1.add("a3");  
        s2.add("a1");
        s2.add("a2");
        s2.add("a4");
        Set sn = new HashSet(s1);
        sn.retainAll(s2);//交集 
        Set su = new HashSet(s1);
        su.addAll(s2);
        System.out.println("su = "+ su);
        System.out.println("sn = "+ sn);    
    }
}
//输出结果：
//su = [a1, a2, a3, a4]
//sn = [a1, a2]

　　3.List接口

　　　　List接口是Collection的子接口,实现List接口的集合类中的元素是有顺序的，而且可以重复

　　　   List的集合中的元素都有一个整数型的序号对应其在集合中的位置，可以根据序号存取集合中的元素

　　　   J2SDK所提供的List集合类有ArrayList，LinkedList等

　　Object get(int index);
　　Object set(int index,Object lement);
　　void add(int index,Object element);
　　Object remove(int index);
　　int indexOf(Object o);
　　int lastIndexOf(Object o);

　　　   ArrayList：如果一开始就知道ArrayList集合需要保存多少元素，则可以在创建它们时就指定initialCapacity大小，这样可以减少重新分配的次数，提供性能，ArrayList还提供了如下方法来重新分配Object[]数组

1) ensureCapacity(int minCapacity): 将ArrayList集合的Object[]数组长度增加minCapacity
2) trimToSize(): 调整ArrayList集合的Object[]数组长度为当前元素的个数。程序可以通过此方法来减少ArrayList集合对象占用的内存空间

　　　　示例：

import java.util.*;

public class ListTest
{
    public static void main(String[] args) 
    {
        List books = new ArrayList();
        //向books集合中添加三个元素
        books.add(new String("轻量级Java EE企业应用实战"));
        books.add(new String("疯狂Java讲义"));
        books.add(new String("疯狂Android讲义"));
        System.out.println(books);

        //将新字符串对象插入在第二个位置
        books.add(1 , new String("疯狂Ajax讲义"));
        for (int i = 0 ; i < books.size() ; i++ )
        {
            System.out.println(books.get(i));
        }

        //删除第三个元素
        books.remove(2);
        System.out.println(books);

        //判断指定元素在List集合中位置：输出1，表明位于第二位
        System.out.println(books.indexOf(new String("疯狂Ajax讲义")));  //①
        //将第二个元素替换成新的字符串对象
        books.set(1, new String("LittleHann"));
        System.out.println(books);

        //将books集合的第二个元素（包括）
        //到第三个元素（不包括）截取成子集合
        System.out.println(books.subList(1 , 2));
    }

　　　　List常用算法：

void sort(List) //对list容器内的元素排序
void shuffle(List) //对list容器内的对象进行随机排列
void reverse(List) //岁list容器内的对象进行逆序排列
void fill(List,Object) //用一个特定的对象重写整个List容器
void copy(List dest,list src) //将srcList容器内容拷贝到destList容器
void binarySearch(List,Object) //对于顺序的list容器，采用着办查找的方法查找特定对象

　　4.comparable接口　　　

　　　　所有可以”排序”的类都实现了java.lang.Comparable接口，Comparable接口中只有一个方法：

　　public int compareTo(Object obj);

　　　　该方法：

• • • 返回0表示this == obj
    • 返回正数表示this>obj
    • 返回负数表示this <obj

　　　　实现了Comparable接口的类通过实现compataTo方法从而确定该类对象的排序方式

3.Map接口 

　　实现Map接口的类：key-value 的键值对，key 不允许重复，value 可以

　　Map接口的实现类有HashMap和TreeMap等

　　Map类中存储的键-值对通过键来标识，所以键值不能重复

　　1、严格来说 Map 并不是一个集合，而是两个集合之间 的映射关系。

　　  2、这两个集合没每一条数据通过映射关系，我们可以看成是一条数据。即 Entry(key,value）。Map 可以看成是由多个 Entry 组成。

　　  3、因为 Map 集合即没有实现于 Collection 接口，也没有实现 Iterable 接口，所以不能对 Map 集合进行 for-each 遍历。

　　　　 

　　Map接口中的方法：

Object put(Object key,Object value);
Object get(Object key);
Object remove(Object key);
boolean containsKey(Object key);
boolean containsValue(Object value);
int size();
boolean isEmpty();
void putAll(Map t);
void clear();

　　示例:

public class Test{
    
    public static void main(String[] args) {
        
        Map m1 = new HashMap();
        Map m2 = new TreeMap();
        
        m1.put("one", new Integer(1));
        m1.put("two", new Integer(2));
        m1.put("three", new Integer(3));
        
        m2.put("A", new Integer(1));
        m2.put("B", new Integer(2));
        
        System.out.println(m1.size());//3
        System.out.println(m1.containsKey("one"));//true
        System.out.println(m2.containsValue(new Integer(1)));//true
        
        if (m1.containsKey("two")) {
            int i = ((Integer)m1.get("two")).intValue();
            System.out.println(i);//2
        }
        
        Map m3 = new HashMap(m1);
        m3.putAll(m2);
        System.out.println(m3);//{A=1, B=2, two=2, three=3, one=1}
    }
}

4.泛型　　

　　起因：

　　　　JDK1.4以前类型不明确：

• • 装入集合的类型都被当作Object对待，从而时区自己的实际类型
  • 从集合中取出时往往需要转型，效率低，容易产生错误

　　解决办法：

• • 在定义集合的时候同事定义集合中对象的类型
  • 可以在定义Collection的时候指定
  • 也可以在循环时用Iterator指定

　　好处：

• • 增强程序的可读性和稳定性

　　例子代码：

public class Test{    
    public static void main(String[] args) {
        
        List<String> c = new ArrayList<String>();
        c.add("你");
        c.add("好");
        c.add("啊");        
        for(int i=0; i<c.size(); i++) {
            String s = c.get(i);
            System.out.println(s);
        }
        
        
        Collection<String> c2 = new HashSet<String>();
        c2.add("你");
        c2.add("好");
        c2.add("啊");        
        for(Iterator<String> it = c2.iterator(); it.hasNext();) {
            String s = it.next();
            System.out.println(s);
        }    
    }
}

5.Iterator接口

• 所有实现了collection接口的集合类都由一个iterator方法用以返回一个实现了Iterator接口的对象
• Iterator对象称作迭代器，用以方便的实现对集合内元素的遍历操作
• Iterator对象的remove方法是在迭代过程中删除元素的唯一的安全方法

Iterator接口定义了如下方法：

boolean hasNext();//判断游标右边是否有元素
Object next();//返回游标右边的元素并将游标移动到下一个位置
void remove();//删除游标左面的元素，在执行完next之后
 

例子：

public class Test{
    
    public static void main(String[] args) {
        
        Collection c = new HashSet();
        c.add("aaa");
        c.add("bb");
        c.add("c");
        
        for (Iterator i = c.iterator(); i.hasNext();) {
            String name = (String)i.next();
            if (name.length()<3) {
                i.remove();
                //如果换成c.remove(name);会产生例外
            }
        }
        
        System.out.println(c);
    }
}

//输出结果：[aaa]

6.增强的For循环

　　增强的for循环对于遍历array或Collection的时候非常简便

　　注意：

• 对于数组来说不能方便的访问下标值
• 对于集合来说，与使用Iterator来说，不能方便的删除集合中的内容（在for循环内部也调用Itertor）

　　因此，除了简单遍历并读出其中的内容外，不建议使用增强for

 　示例：

public class Test{  
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        for(int i : arr) {
            System.out.print(i + " ");//遍历输出
        }     
        System.out.println();     
        Collection c = new ArrayList();
        c.add(new String("aaa"));
        c.add(new String("bbb"));
        c.add(new String("vvv"));
        for (Object o : c) {
            System.out.print(o + " ");//遍历输出
        }
    }
}