Java基础2——集合框架

Collection和Map是集合的顶层接口

先看Collection，这个接口定义了以下方法：

添加功能：

　　boolean add(Object obj):添加一个元素

　　boolean addAll(Collection c):添加一个集合的元素

删除功能

　　void clear():移除所有元素

　　boolean remove(Object o):移除一个元素

　　boolean removeAll(Collection c):移除一个集合的元素(是一个还是所有)

判断功能

　　boolean contains(Object o)：判断集合中是否包含指定的元素

　　boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(是一个还是所有)

　　boolean isEmpty()：判断集合是否为空

获取功能

　　Iterator<E> iterator()(重点)

长度功能

　　int size():元素的个数

　　面试题：数组有没有length()方法呢?字符串有没有length()方法呢?集合有没有length()方法呢?

交集功能

　　boolean retainAll(Collection c):两个集合都有的元素?思考元素去哪了，返回的boolean又是什么意思呢?

把集合转换为数组

　　Object[] toArray()

List和Set是Collection集合的两个子接口

　　List是一个有序的队列，每一个元素都有它的索引，第一个元素的索引值是0

　　ArrayList、Vector、LinkedList、Stack是List的四个实现类，其中比较常用的是ArrayList(线性表)、LinkedList(链表)

　　Set是一个不允许有重复元素的集合

　　Set的实现类有HastSet和TreeSet，其中比较常用的是HashSet

Collection通用方法举例

        Collection c=new ArrayList();
        Student s1=new Student("aaa",15);
        Student s2=new Student("bbb",16);
        Student s3=new Student("ccc",17);
        Student s4=new Student("ddd",18);
        Student s5=new Student("eee",19);
        Student s6=new Student("fff",20);
        //添加一个或多个元素
        c.add(s1);
        c.add(s2);
        //========
        Collection c1=new ArrayList();
        c1.add(s3);
        c1.add(s4);
        c.addAll(c1);
        //========
        Collection c2=new ArrayList();
        c2.add(s5);
        c2.add(s6);
        c.addAll(c2);
        //========
        
        //移除一个或多个元素
        c.remove(s1);
        c.removeAll(c1);
        
        //查看某个元素是否存在于集合中
        System.out.println(c.contains(s2));
        System.out.println(c.containsAll(c2));
        
        //判断集合是否为空
        System.out.println(c.isEmpty());
        
        //判断集合中有几个元素
        System.out.println(c.size());
        
        //集合转数组 此处不可以用Student[]类型来接收，存入集合的元素都将变成Object类型的
        Object[] objs=c.toArray();
        
        //清空集合
        c.clear();
        
        //迭代遍历
        Iterator it=c.iterator();
        while(it.hasNext()){
            Student s=(Student)it.next();
            System.out.println(s.name+" "+s.age);
        }

List集合特有的功能

/*
         * List集合的特有功能：
         * A:添加功能
         *         void add(int index,Object element):在指定位置添加元素
         * B:获取功能
         *         Object get(int index):获取指定位置的元素
         * C:列表迭代器
         *         ListIterator listIterator()：List集合特有的迭代器
         * D:删除功能
         *         Object remove(int index)：根据索引删除元素,返回被删除的元素
         * E:修改功能
         *         Object set(int index,Object element):根据索引修改元素，返回被修饰的元素
         */
        Student s1=new Student("aaa",15);
        Student s2=new Student("bbb",16);
        Student s3=new Student("ccc",17);
        Student s4=new Student("ddd",18);
        Student s5=new Student("eee",19);
        Student s6=new Student("fff",20);
        List list=new ArrayList();
        list.add(s1);
        list.add(s2);
        
        //在指定位置添加元素，位置可以是0 1 2，否则会报IndexOutOfBoundsException越界异常
        list.add(0,s3);
        list.add(3,s4);
        
        //获取到指定位置的元素
        Student s=(Student)list.get(2);
        System.out.println(s.name+" "+s.age);
        
        //删除指定索引的元素
        list.remove(0);
        
        //设置指定位置的元素
        list.set(0, s5);
        
        System.out.println("-----------------");
        //其实这里可以通过ListIterator实现遍历
        //而且ListIterator可以实现逆向遍历，但是必须先正向遍历，才能逆向遍历，所以一般无意义，不使用
        Iterator it=list.iterator();
        while(it.hasNext()){
            Student ss=(Student)it.next();
            System.out.println(ss.name+" "+ss.age);
        }

        /*
         * 问题?
         *         我有一个集合，如下，请问，我想判断里面有没有"world"这个元素，如果有，我就添加一个"javaee"元素，请写代码实现。
         * 
         * ConcurrentModificationException:当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。 
         * 产生的原因：
         *         迭代器是依赖于集合而存在的，在判断成功后，集合的中新添加了元素，而迭代器却不知道，所以就报错了，这个错叫并发修改异常。
         *         其实这个问题描述的是：迭代器遍历元素的时候，通过集合是不能修改元素的。
         * 如何解决呢?
         *         A:迭代器迭代元素，迭代器修改元素
         *             元素是跟在刚才迭代的元素后面的。
         *         B:集合遍历元素，集合修改元素(普通for)
         *             元素在最后添加的。
         */
        List list=new ArrayList();
        list.add("hello");
        list.add("world");
        list.add("java");
        for (int x = 0; x < list.size(); x++) {
            String s = (String) list.get(x);
            if ("world".equals(s)) {
                list.add("javaee");
            }
        }
        System.out.println("list:" + list);

ArrayList里面没有什么特有的功能

LinkedList特有的功能↓

　　A:添加功能
　　　　public void addFirst(Object e)
　　　　public void addLast(Object e)
　　B:获取功能
　　　　public Object getFirst()
　　　　public Obejct getLast()
　　C:删除功能
　　　　public Object removeFirst()
　　　　public Object removeLast()

数组中必须存放同种类型的元素，那想要约束一个集合必须存储同种类型的元素就要用到泛型，集合中的泛型只能是引用类型

泛型可以把运行时的错误提前到编译期，同时避免了强制从Object到特定类型的类型转换，同时在Eclipse中也没有黄色的警告线了

ArrayList<String> array = new ArrayList<String>();
array.add("hello");
array.add("world");
array.add("java");
Iterator<String> it = array.iterator();
while (it.hasNext()) {
    String s = it.next();//不必强转
    System.out.println(s);
}

泛型类

如下代码：早期的时候，我们使用Object来代表任意的类型。向上转型是没有任何问题的，但是在向下转型的时候其实隐含了类型转换的问题。也就是说这样的程序其实并不是安全的。

public class ObjectTool {
    private Object obj;

    public Object getObj() {
        return obj;
    }

    public void setObj(Object obj) { // Object obj = new Integer(30);
        this.obj = obj;
    }
}

public class ObjectToolDemo {
    public static void main(String[] args) {
        ObjectTool ot = new ObjectTool();

        // 正常使用
        ot.setObj(new Integer(27));
        Integer i = (Integer) ot.getObj();
        System.out.println("年龄是：" + i);

        ot.setObj(new String("林青霞"));
        String s = (String) ot.getObj();
        System.out.println("姓名是：" + s);

        System.out.println("---------");
        ot.setObj(new Integer(30));
        // ClassCastException 出异常了
        String ss = (String) ot.getObj();
        System.out.println("姓名是：" + ss);
    }
}

所以Java在JDK5后引入了泛型，提高程序的安全性：

public class ObjectTool<T> {
    private T obj;

    public T getObj() {
        return obj;
    }

    public void setObj(T obj) {
        this.obj = obj;
    }
}

public class ObjectToolDemo {
    public static void main(String[] args) {
        ObjectTool<String> ot = new ObjectTool<String>();
        // ot.setObj(new Integer(27)); //这个时候编译期间就过不去
        ot.setObj(new String("林青霞"));
        String s = ot.getObj();
        System.out.println("姓名是：" + s);

        ObjectTool<Integer> ot2 = new ObjectTool<Integer>();
        // ot2.setObj(new String("风清扬"));//这个时候编译期间就过不去
        ot2.setObj(new Integer(27));
        Integer i = ot2.getObj();
        System.out.println("年龄是：" + i);
    }
}

泛型还可以用于方法和接口

泛型方法

上面的泛型类有一个很不好的地方就是setObj的参数的类型只能是和ObjectTool里面的泛型类一样的类的类型，这样就很不灵活，所以产生了泛型方法

public class ObjectTool {
    public <T> void show(T t) {
        System.out.println(t);
    }
}

public class ObjectToolDemo {
    public static void main(String[] args) {
        // 定义泛型方法后
        ObjectTool ot = new ObjectTool();
        ot.show("hello");
        ot.show(100);
        ot.show(true);
    }
}

ObjectTool类本身还可以有泛型，例如ObjectTool<Boolean>，ObjectTool本身的泛型类型和它里面的成员方法的泛型类型没有任何关系

泛型接口

public interface Inter<T> {
    public abstract void show(T t);
}

//第一种情况：已经知道该是什么类型的了，用的很少
public class InterImpl implements Inter<String> {
    public void show(String t) {
        System.out.println(t);
    }
}

//第二种情况：还不知道是什么类型的，用的很多
public class InterImpl<T> implements Inter<T> {
    public void show(T t) {
        System.out.println(t);
    }
}

public class InterDemo {
    public static void main(String[] args) {
        // 第一种情况的测试
        Inter<String> i = new InterImpl();
        i.show("hello");
    
        // 第二种情况的测试
        Inter<Integer> ii = new InterImpl<Integer>();
        ii.show(100);

        Inter<String> iii = new InterImpl<String>();
        iii.show("hello");
    }
}

泛型通配符

/*
 * 泛型高级(通配符)
 * ?:任意类型，如果没有明确，那么就是Object以及任意的Java类了
 * ? extends E:向下限定，E及其子类
 * ? super E:向上限定，E极其父类
 */
public class GenericDemo {
    public static void main(String[] args) {
        // 泛型如果明确的写的时候，前后必须一致
        Collection<Object> c1 = new ArrayList<Object>();
        // Collection<Object> c2 = new ArrayList<Animal>();
        // Collection<Object> c3 = new ArrayList<Dog>();
        // Collection<Object> c4 = new ArrayList<Cat>();

        // ?表示任意的类型都是可以的
        Collection<?> c5 = new ArrayList<Object>();
        Collection<?> c6 = new ArrayList<Animal>();
        Collection<?> c7 = new ArrayList<Dog>();
        Collection<?> c8 = new ArrayList<Cat>();

        // ? extends E:向下限定，E及其子类
        // Collection<? extends Animal> c9 = new ArrayList<Object>();
        Collection<? extends Animal> c10 = new ArrayList<Animal>();
        Collection<? extends Animal> c11 = new ArrayList<Dog>();
        Collection<? extends Animal> c12 = new ArrayList<Cat>();

        // ? super E:向上限定，E极其父类
        Collection<? super Animal> c13 = new ArrayList<Object>();
        Collection<? super Animal> c14 = new ArrayList<Animal>();
        // Collection<? super Animal> c15 = new ArrayList<Dog>();
        // Collection<? super Animal> c16 = new ArrayList<Cat>();
    }
}

class Animal {
}

class Dog extends Animal {
}

class Cat extends Animal {
}

JDK1.5新特性——可变参

/*
 * 可变参数：定义方法的时候不知道该定义多少个参数
 * 格式：
 *         修饰符 返回值类型 方法名(数据类型…  变量名){
 * 
 *         }
 * 
 *         注意：
 *             这里的变量其实是一个数组
 *             如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个
 */
public ArgsTest{
    public static void main(String args[]){
        int r=sum(10,20,30);
        System.out.println(r);
    }
    public static int sum(int... a){
        int sum=0;
        for(int i:a){
            sum+=a[i];
        }
        return sum;
    }
}

Arrays.asList传入可变参作为参数

/*
 * public static <T> List<T> asList(T... a):把数组转成集合
 * 
 * 注意事项：
 *         虽然可以把数组转成集合，但是集合的长度不能改变。
 */
public class ArraysDemo {
    public static void main(String[] args) {
        // 定义一个数组
        // String[] strArray = { "hello", "world", "java" };
        // List<String> list = Arrays.asList(strArray);

        List<String> list = Arrays.asList("hello", "world", "java");
        // UnsupportedOperationException
        // list.add("javaee");
        // UnsupportedOperationException
        // list.remove(1);
        list.set(1, "javaee");

        for (String s : list) {
            System.out.println(s);
        }
    }
}

以上是List集合的相关类及其方法的总结，List集合是有序的，即存和取的顺序是一致的，List集合里面的元素可以重复

而Set集合是无序的，存和取的顺序不一致，而且取的时候不保证顺序永久不变，但是作为集合来说，它肯定有自己的存储顺序，Set集合里面的元素是唯一的

Set的一个很重要的实现类是HashSet

此外还有LinkedHashSet，该类的底层数据结构由哈希表和链表组成，哈希表保证元素的唯一性，链表保证元素有顺序，即存进去和取出来的元素顺序相同

Collection和Collections的区别

Collection:是单列集合的顶层接口，有子接口List和Set。
Collections:是针对集合操作的工具类，有对集合进行排序和二分查找的方法

要知道的方法
public static <T> void sort(List<T> list)：排序 默认情况下是自然顺序。
public static <T> int binarySearch(List<?> list,T key):二分查找
public static <T> T max(Collection<?> coll):最大值
public static void reverse(List<?> list):反转
public static void shuffle(List<?> list):随机置换

同Collection并列的还有另外一个顶层集合接口——Map

Map中存储的是键值对，类似js里面的json

Map<String,String> hm = new HashMap<String,String>();

hm.put("it002","hello");
hm.put("it003","world");
hm.put("it001","java");

//方式1 键找值 set是键的集合
Set<String> set = hm.keySet();
for(String key : set) {
    String value = hm.get(key);
    System.out.println(key+"---"+value);
}

//方式2 键值对对象找键和值 set2是键值对的集合
Set<Map.Entry<String,String>> set2 = hm.entrySet();
for(Map.Entry<String,String> me : set2) {
    String key = me.getKey();
    String value = me.getValue();
    System.out.println(key+"---"+value);
}