JAVA基础--JAVA API集合框架(ArrayList、HashSet、HashMap使用)14

一、集合Collection

　　1. 集合介绍

　　变量：表示的内存中的一个空间，只能保存确定类型的单个数据

　　数组：表示的是内存中的多个连续的空间，这些空间中可以存储多个同类型的数据。

　　后期继续学习面向对象技术，我们在程序中开始创建对象，使用对象。当在程序中创建的多少越来越多的时候，我们就需要将这些对象也存储起来。

　　需要存储对象：肯定是需要容器。

         　　变量：可以，要求这个变量必须是引用变量，但只能存储单个对象

         　　数组：可以，但是它要求存储的对象个数是固定的。

         　   字符串缓冲区：不可以，因为它中的数据最后都会被转成字符串。

　　　　 Java中提供了另外一类容器：集合，它专门负责存储程序中的对象。

　　开发中使用频率最高的三个集合对象：

        　   ArrayList：

         　  HashSet：

              HashMap：

　　集合是类容器：它也具备了容器最基本的操作方式：

        　　 增、删、改、查、判断、遍历。

在Java中设计的集合容器比较多，它们都可以存储对象，但是当对象被存储到这些容器中之后，容器会对其中的对象进行不同的处理。

学习集合的重点：知道每个集合的底层是怎么处理其中存储的对象。知道每个集合的底层数据结构。

由于集合容器太多，需要程序员知道每个集合自己的处理方式，不容易记忆以及使用。于是Java又对这些集合容器的共性操作行为进行的抽取和总结，最后给我们形成了一套所有集合容器都应该具备的基本的操作方式。

Java中定义Collection接口，这个接口中定义了所有集合的共性的操作规则。Java中的所有集合容器都是按照Collection中定义的规则做的实现，我们在开发中只要按照Collection接口中定义的规则，就能够轻易的去操作各个集合容器。

　　2.Collection接口介绍

　　　　　

　　　　Collection 层次结构 中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现。此接口　　　　通常用来传递 collection，并在需要最大普遍性的地方操作这些 collection。

　　　　Collection它是集合体系中的顶层接口。它下面有多个集合容器对象，有些集合可以存放重复的对象，有些不可以，有些可以保证存储的数据的顺序，有些则不可以保证。

　　　　Collection接口中定义了集合最共享的操作方式。

　　3. Collection中的方法介绍

　　　　3.1添加方法

　　　　　　　　

　　　　add方法是将一个对象添加到集合中容器中，如果添加成功返回true，如果添加失败返回false。

　　　　

/*
 * 演示Collection接口中的add方法
 */
public class CollectionAddMethodDemo {
    public static void main(String[] args) {
        
        //创建集合容器对象
        Collection coll = new ArrayList();
        //调用添加的方法
        coll.add("abc");
        /*
         * 能否直接将一个基本类型数据添加到集合中
         * 将基本类型保存到集合中的时候，只要JDK的版本高于5版本，
         * 就可以发生自动装箱
         */
        coll.add(123); //自动装箱 ，真正保存的是Integer对象
        
        coll.add("aaasssdd");
        coll.add(new Object());
        //打印
        System.out.println(coll);
    }
}

　　　　3.2  删除方法

　　　　　

　　　　

/*
 * 演示Collection接口中的删除方法
 */
public class CollectionRemoveDemo {
    public static void main(String[] args) {
        
        //创建集合容器对象
        Collection coll = new ArrayList();
        
        //添加元素
        boolean b = coll.add("abc");
        coll.add("abc");
        coll.add("itcast");
        coll.add("banzhang");
        
        System.out.println(b);
        System.out.println(coll);
        
        //删除的方法  删除集合中指定的元素，元素存在就会被删除，如果有多个删除其中的第一个
        boolean b2 = coll.remove("abc");
        System.out.println(b2);
        System.out.println(coll);
    }
}

 　　　　3.3  判断方法

　　　　

　　　　

　　　　

　　　　3.4  获取元素个数

　　　　

　　　　　

　　　　3.5  Collection接口中带All的方法

　　　　

　　　　

　　　　

　　　　

　　　　

　　　　

　　　　　　　

　　　　coll.removeAll(coll2) 从coll中删除coll和coll2两个集合中的相同元素（交集）。

　　　　　　　　

　　　　coll.retainAll(coll2) 将coll集合中的 于 coll2 不相同的元素删除（将coll和coll2的交集保留在coll中）。

　　　　

　　　　

/*
 * 演示Collection接口中的clear方法
 */
public class CollectionDemo3 {
    public static void main(String[] args) {
        
        //创建集合对象
        Collection coll = new ArrayList();
        
        coll.add("abc");
        coll.add("cba");
        coll.add("nba");        
        /*
         * 将集合中的所有元素删除，但是集合容器依然存在，还可以正常使用
         * 问题：调用集合的clear方法和 coll = null 的区别？
         *   clear仅仅是情况集合中的元素
         *   coll=null 是将coll引用置为null，它不再指定任何的集合容器    
         */
        //coll = null;
        coll.clear();
        System.out.println(coll);
        coll.add("aaa");
        System.out.println(coll);
    }
}

 　　　4. 迭代器

　　　　　　4.1 迭代器介绍　　

　　　　　　由于集合容器较多，并且每个集合容器对保存在其中的元素的处理方式都不同。这样导致不同的集合容器在取出元素的时候都会一定的差异。

　　　　　　Java针对不同的集合容器进行取出元素的共性抽取，得到了一个遍历集合的对象，这个对象被称为迭代器（遍历器）。

　　　　　　迭代器：它的功能就是遍历集合容器的。

         　　　遍历容器的规则：需要先判断容器中有没有数据，如果有，就将这个数据取出，如果没有就不用再进行遍历。

 　　　　　　

　　　　　　　　　　

　　　　　　Iterator接口，它仅仅是在规定容器应该如何遍历，但是具体的实现类由每个集合容器针对自己存储数据的方式做具体的实现。

　　　　　　而在Collection接口中提供了iterator方法，可以得到不同集合容器自己实现的那个迭代器对象。

 　　　　　　

 　　　　　　4.2  迭代器的使用　　　　

/*
 * 演示迭代器的使用
 */
public class IteratorDemo {
    public static void main(String[] args) {
        method2();
    }
    //使用迭代器遍历集合
    public static void method2() {
        //创建集合容器对象
        Collection coll = new ArrayList();
        
        //添加元素
        coll.add("abc");
        coll.add("itcast");
        coll.add("123");
        coll.add("123");
        
        //获取迭代器对象
        Iterator it = coll.iterator();
        //使用循环遍历
        while( it.hasNext() ){
            System.out.println(it.next());
        }
        
        /*
         * 开发中一般使用for循环遍历集合
         * 注意：当基于集合容器得到一个迭代器对象之后，
         * 这个迭代器的隐式光标会位于集合的第一个元素的前面，
         * 如果遍历结束，这时迭代器的隐式光标就已经位于集合中最后一个元素的后面
         * 这时光标是无法在移动的集合的第一个元素的前面的，如果还需要遍历
         * 就需要重新基于这个集合容器获取一个新的迭代器
         */
        for( Iterator it2 = coll.iterator() ; it2.hasNext() ; ){
            System.out.println(it2.next());
        }
        
    }
    //演示迭代器的获取
    public static void method() {
        
        //创建集合容器对象
        Collection coll = new ArrayList();
        
        //添加元素
        coll.add("abc");
        coll.add("itcast");
        coll.add("123");
        coll.add("123");
        
        //获取迭代器
        Iterator it = coll.iterator();
        
        //判断和取出元素
        System.out.println(it.hasNext());
        System.out.println(it.next());
        System.out.println(it.hasNext());
        System.out.println(it.next());
        System.out.println(it.hasNext());
        System.out.println(it.next());
        System.out.println(it.hasNext());
        System.out.println(it.next());
        System.out.println(it.hasNext());
        System.out.println(it.next());
    }
}

 　　　　　　4.3 迭代器注意细节

　　　　　　　　 a.  迭代器对象获取到之后，将容器遍历完之后，这个迭代器中的隐式光标就已经移动的集合容器的最后，当前迭代器无法再去遍历集合容器。

　　　　　　　　 b. 在使用迭代器遍历集合容器的时候，不能使用集合自身的增删方法修改集合中的元素。

　　　　　　　　原因：是因为在获取迭代器的时候，迭代器对象它知道在获取自己的时候，自己需要遍历的集合容器中的元素具体的个数以及存储的细节情况，而在遍历的过程中，如果强行使用集合的增删方法会导致集合中的元素顺序已经存储结构发生变化，但是当前这个迭代器并无法检测到，于是在　　　　　　　　正常的遍历过程中就发生    java.util.ConcurrentModificationException。

　　　　

/*
     * 遍历集合中的元素，判断取出的元素是否是 "abc" 这个字符串，如果是删除
     */
    public static void method3() {
        //创建集合容器对象
        Collection coll = new ArrayList();
        
        //添加元素
        coll.add("abc");
        coll.add("itcast");
        coll.add("123");
        coll.add("123");
        
        //获取到迭代器对象
        for( Iterator it = coll.iterator(); it.hasNext() ; ){
            //获取到从集合中遍历出来的某个元素数据，并保存到obj引用中
            Object obj = it.next();
            //判断
            if( obj.equals("abc") ){
                /*
                 * 判断成立，说明取出的这个元素一定是"abc"这个字符串，删除
                 * 不能使用集合自身的增删方法对集合中的元素进行操作
                 * 否则会发生异常,如果需要删除集合中的元素，需要使用迭代器自己的删除方法
                 */
                //coll.remove(obj);
                it.remove();
            }
        }
        System.out.println(coll);
        
    }

 

　　　　　　　　c.在使用迭代器的时候，一般情况下，调用一次hasNext方法，会对应一个next方法。 不建议在遍历集合的时候，在判断完有没有元素之后，在循环中调用多次next方法。容易发生异常

　　　　5.  集合的细节

　　　　　　5.1  集合是保存对象的。真正是将对象的内存地址存储在集合容器中。

　　　　　   5.2  如果集合在使用的时候没有添加任何的限制（泛型），这时给集合中保存的任何元素，在存储到集合中之后都会被提升为Object类型。

假设集合中的add方法定义格式：

           public boolean add( Object e ){

         //.................

}

                   Collection coll = new ArrayList();

                   coll.add(“abc”);

         当我们在调用add方法的时候，会传递一个具体的对象，但是这个对象会被Object类型的引用接收。

         Object e = “abc”; 这里发生了多态，发生了向上转型。

3、  从集合中取出的所有元素，统一都是Object类型，如果想要调用对象自身的特有方法，这时必须使用向下转型。

　　　　

//集合中保存的元素会被提升为Object类型
    public static void method5() {
        //创建集合容器对象
        Collection coll = new ArrayList();
        
        coll.add("abc");  //添加了String对象
        coll.add(123);    //添加了一个Integer对象
        
        //取出元素
        for (Iterator it = coll.iterator(); it.hasNext();) {
            Object obj = it.next();
            //取出的字符串的长度
            if( obj instanceof String ){
                String s = (String) obj;
                System.out.println(s.length());
            }
        }
    }

 二、List接口介绍

Collection接口是集合体系中的顶层（根）接口。它中定义的方法是所有集合最共性的操作规则。

但是JDK中不对Collection接口提供直接的实现类，而提供的直接的子接口：

         List：列表

                   List接口下的集合容器都拥有下标（索引），它可以存储重复元素。

         Set：视图

                   Set接口下的集合容器，不能存放重复元素。

　　　

List接口：

         List接口是Collection接口的子接口，在List接口中继承到了Collection中的所有方法，并且List接口中还增加了围绕集合容器下标（索引）而设计的其他的 增  删  改  查  判断 遍历的方法。

　　1. List的特有方法

　　

/*
 * List集合中的特有方法
 */
public class ListDemo {
    public static void main(String[] args) {
        
        List list = new ArrayList();
        
        //添加方法
        list.add("aaa");
        list.add(1, "abc");
        list.add(12);
        System.out.println(list);
        
        /*
         * 删除方法
         * 如果调用List接口中的remove方法的时候：
         *     传递的参数是一个int类型的数据，这时这个int类型的数据
         *     表示的是集合容器的角标（索引），而不会将这个int类型的数据
         *     自动装箱为Integer对象.
         */
        //list.remove("abc");
        //list.remove(12);
        System.out.println(list);
        //获取方法
        System.out.println(list.get(2));
        //修改方法
        list.set(0, "itcast");
        System.out.println(list);
        
    }
}

　　2.List的特有迭代器　　　

由于List接口下的所有集合容器都拥有角标（index），因此List接口除了Iterator迭代器可以迭代集合之外，还提供另外一个List接口专用的迭代器ListIterator。

 

　　Iterator迭代器，它只能从前往后遍历集合，一旦遍历结束，迭代器的隐式光标就会位于集合最后一个元素的后面。无法在使用这个迭代器对集合进行迭代。同时迭代的过程中不能使用集合自身的增删等方法对集合修改。而Iterator中仅仅只提供的remove方法，删除集合中的元素。

      List接口中提供的ListIterator迭代器，它可以对List集合从前往后遍历，也可以从后往前遍历，同时ListIterator接口中还提供的对集合增 删  改 查 的方法。

    /*
 * 演示List接口的特有迭代器
 */
public class ListIteratorDemo {
    public static void main(String[] args) {
        //定义List集合对象
        List list = new ArrayList();
        
        //添加元素
        list.add("aaa");
        list.add("abc");
        list.add("cba");
        list.add("nba");
        list.add("wcba");
        list.add("aaa");
        
        System.out.println("使用ListIterator正向遍历集合");
        //使用List接口特有的迭代器进行遍历
        ListIterator li = list.listIterator();
        while( li.hasNext() ){
            System.out.println(li.next());
        }
        
        System.out.println("使用ListIterator逆向遍历集合");
        while( li.hasPrevious() ){
            System.out.println(li.previous());
        }
        
    }
}

3.List集合的迭代

/*
 * 演示List集合的所有遍历方式
 */
public class ListDemo {
    public static void main(String[] args) {
        
        //定义List集合对象
        List list = new ArrayList();
        
        //添加元素
        list.add("aaa");
        list.add("abc");
        list.add("cba");
        list.add("nba");
        
        //使用Iterator遍历
        System.out.println("使用Iterator遍历");
        for( Iterator it = list.iterator() ; it.hasNext() ; ){
            System.out.println(it.next());
        }
        //使用ListIterator遍历
        System.out.println("使用ListIterator遍历");
        for( ListIterator li = list.listIterator(); li.hasNext(); ){
            System.out.println(li.next());
        }
        //使用普通的for循环提供下标遍历
        System.out.println("使用普通的for循环提供下标遍历");
        for(int i = 0 ; i < list.size() ; i++){
            System.out.println(list.get(i));
        }
        /*
         * 使用foreach遍历
         *     格式：
         *      for( 容器中元素的类型  变量名  ： 容器名  ){
         *       变量名中保存的就是从容器中取出的元素
         *   }
         */
        System.out.println("使用foreach遍历");
        for( Object obj : list ){
            System.out.println(obj);
        }
    }
}