Java基础之集合？？？？？？？

集合框架(集合的由来及集合继承体系图)

• A:集合的由来
  
  • 数组长度是固定,当添加的元素超过了数组的长度时需要对数组重新定义,太麻烦,java内部给我们提供了集合类,能存储任意对象,长度是可以改变的,随着元素的增加而增加,随着元素的减少而减少
• B:数组和集合的区别
  
  • 区别1 :
    
    • 数组既可以存储基本数据类型,又可以存储引用数据类型,基本数据类型存储的是值,引用数据类型存储的是地址值
    • 集合只能存储引用数据类型(对象)集合中也可以存储基本数据类型,但是在存储的时候会自动装箱变成对象
  • 区别2:
    
    • 数组长度是固定的,不能自动增长
    • 集合的长度的是可变的,可以根据元素的增加而增长
• C:数组和集合什么时候用
  * 1,如果元素个数是固定的推荐用数组
  * 2,如果元素个数不是固定的推荐用集合
• D:集合继承体系图
  

集合框架(Collection集合的基本功能测试)

• 基本功能

boolean add(E e)
boolean remove(Object o)
void clear()
boolean contains(Object o)
boolean isEmpty()
int size()

案例:

    /**
        add方法如果是List集合一直都返回true,因为List集合中是可以存储重复元素的
        如果是Set集合当存储重复元素的时候,就会返回false
     */
        Collection c = new ArrayList();             //父类引用指向子类对象
        c.add("a");
        //c.remove("b");                            //删除指定元素
        //c.clear();                                //清空集合
        //System.out.println(c.contains("b"));      //判断是否包含
        //System.out.println(c.isEmpty());          //判断集合是否为空
        System.out.println(c.size());               //获取元素的个数
        boolean b2 = c.add(true);                   //自动装箱newBoolean(true);
        boolean b3 = c.add(100);
        boolean b4 = c.add(new Student("张三",23));          
    }
}

集合框架(集合的遍历之集合转数组遍历)

• A:集合的遍历
  
  • 其实就是依次获取集合中的每一个元素。
• B:案例
  
  • 把集合转成数组，可以实现集合的遍历
  • toArray()

Collection coll = new ArrayList();
            coll.add(new Student("张三",23));     
            coll.add(new Student("李四",24));
            coll.add(new Student("王五",25));
            coll.add(new Student("赵六",26));

            Object[] arr = coll.toArray();              //将集合转换成数组
            for (int i = 0; i < arr.length; i++) {
                Student s = (Student)arr[i];            //强转成Student
                System.out.println(s.getName() + "," + s.getAge());
            }

集合框架(Collection集合的带All功能测试)

• A:案例

带All的功能演示
boolean addAll(Collection c)
boolean removeAll(Collection c)  //删除交集
boolean containsAll(Collection c)
boolean retainAll(Collection c) //取交集

案例:

        Collection c1 = new ArrayList();
        c1.add("a");
        c1.add("b");
        c1.add("c");

        Collection c2 = new ArrayList();
        c2.add("b");
        c2.add("c");
        c2.add("d");

        //取交集,如果调用的集合改变就返回true,如果调用的集合不变就返回false
        boolean b = c1.retainAll(c2);               //取交集
        boolean b = c1.containsAll(c2);             //判断调用的集合是否包含传入的集合
        boolean b = c1.removeAll(c2);                   //删除的是交集
        c1.addAll(c2);                            //将c2中的每一个元素添加到c1中
        c1.add(c2);                                 //将c2看成一个对象添加到c1中
    }
}

集合框架(集合的遍历之迭代器遍历)

• A:迭代器概述
  
  • 集合是用来存储元素,存储的元素需要查看,那么就需要迭代(遍历)
• B:案例
  
  • 迭代器的使用

Collection c = new ArrayList();
            c.add("a");
            c.add("b");
            c.add("c");
            c.add("d");

            Iterator it = c.iterator();                     //获取迭代器的引用
            while(it.hasNext()) {                           //集合中的迭代方法(遍历)
                System.out.println(it.next());
            }

集合框架(Collection存储自定义对象并遍历)

• A:案例
  
  • Collection存储自定义对象并用迭代器遍历

    /**
     * 迭代
     * * A:迭代器概述
     * 集合是用来存储元素,存储的元素需要查看,那么就需要迭代(遍历)
     */
        Collection c = new ArrayList();
        c.add(new Student("张三", 23));               //Object obj = new Student("张三",23);
        c.add(new Student("李四", 24));
        c.add(new Student("王五", 25));
        c.add(new Student("赵六", 26));

        //获取迭代器
        Iterator it = c.iterator();
        while(it.hasNext()) {
            //System.out.println(it.next());
            Student s = (Student)it.next();         //向下转型
            System.out.println(s.getName() + "..." + s.getAge());
        }
    }
}

集合框架(迭代器的原理及源码解析)(了解)

• A:迭代器原理
  
  • 迭代器原理:迭代器是对集合进行遍历,而每一个集合内部的存储结构都是不同的,所以每一个集合存和取都是不一样,那么就需要在每一个类中定义hasNext()和next()方法,这样做是可以的,但是会让整个集合体系过于臃肿,迭代器是将这样的方法向上抽取出接口,然后在每个类的内部,定义自己迭代方式,这样做的好处有二,第一规定了整个集合体系的遍历方式都是hasNext()和next()方法,第二,代码有底层内部实现,使用者不用管怎么实现的,会用即可
• B:迭代器源码解析
  
  • 1,在eclipse中ctrl + shift + t找到ArrayList类
  • 2,ctrl+o查找iterator()方法
  • 3,查看返回值类型是new Itr(),说明Itr这个类实现Iterator接口
  • 4,查找Itr这个内部类,发现重写了Iterator中的所有抽象方法
    迭代器原理图：
    集合中存放元素,想要操作元素,在集合内部操作最方便,所以就定义了一个内部类,完成取出动作的定义,而每个容器中都有内部类,发现以后再产生容器还得定义内部类,干脆抽取出一个接口
    每个容器中都有存和取的方式,而且因为每个容器的数据结构不同,所以他们存和取的动作也有可能实现的方式不一样,虽然都具备存和取的动作,但是底层的数据结构不同,存取方式也不同,具体实现方式不一样,每个集合都具备取出方式,而这个方式不足以用一个方法来描述,不像添加那么简单,去之前要判断有没有,有就取,没有就不取,所以对于取出不足以用一个方法来描述,就将取出动作封装成对象.

Collection定义了集合框架的共性功能。
1，添加 add(e); addAll(collection);
2，删除 remove(e); removeAll(collection); clear();
3，判断。contains(e); isEmpty();
4，获取 iterator(); size();
5，获取交集。retainAll();
6，集合变数组。 toArray();
1，add方法的参数类型是Object。以便于接收任意类型对象。
2，集合中存储的都是对象的引用(地址)
什么是迭代器呢？
其实就是集合的取出元素的方式。如同抓娃娃游戏机中的夹子。
迭代器是取出方式，会直接访问集合中的元素。所以将迭代器通过内部类的形式来进行描述。
通过容器的iterator()方法获取该内部类的对象。

集合框架(List集合的特有功能概述和测试)

• A:List集合的特有功能概述

* void add(int index,E element)
    * E remove(int index)
    * E get(int index)
    * E set(int index,E element)

案例:

        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");

        list.set(1, "z");                       //将指定位置的元素修改
        Object obj1 = list.get(2);              //获取指定位置的元素
        //通过索引遍历List集合                    //遍历List
        for(int i = 0;i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        Object obj = list.remove(10);          //通过索引删除元素,将被删除的元素返回.删除的时候不会自动装箱,把10当作索引
        list.add(4, "f");                      //index<=size并且index>=0都不会报异常
        list.add(10, "z");                     //java.lang.IndexOutOfBoundsException,当存储时使用不存在的索引时
    }
}

集合框架(List集合存储学生对象并遍历)

• A:案例
  
  • 通过size()和get()方法结合使用遍历。
    遍历的方式:
    1.转成数组遍历
    2.迭代器遍历
    3.通过size()和get()遍历
    4.高级for遍历

案例:

    /**
     * * A:案例演示
     * 向List集合中存储学生对象
     * 通过size()和get()方法结合使用遍历。
     */
        List list = new ArrayList();
        //Object obj = new Student("张三",23);
        list.add(new Student("张三", 23));                    
        list.add(new Student("李四", 24));
        //第一种方式遍历
        for(int i = 0; i < list.size(); i++) {
            //System.out.println(list.get(i));              //通过索引获取每一个元素
            Student s = (Student)list.get(i);
            System.out.println(s.getName() + "..." + s.getAge());
        }
        //第二种方式遍历
        Iterator iterator = list.iterator();
        while(iterator.hasNext()) {
            Student s = (Student)iterator.next();
            System.out.println(s.getName()+":"+s.getAge());        
        }
    }
}

集合框架(并发修改异常产生的原因及解决方案)

• A:案例
  
  • 需求：我有一个集合，请问，我想判断里面有没有”world”这个元素，如果有，我就添加一个”javaee”元素，请写代码实现。

List list = new ArrayList();
            list.add("a");
            list.add("b");
            list.add("world");
            list.add("d");
            list.add("e");

            /*Iterator it = list.iterator();
            while(it.hasNext()) {
                String str = (String)it.next();
                if(str.equals("world")) {
                    list.add("javaee");         //这里会抛出ConcurrentModificationException并发修改异常
                }
            }*/

• B:ConcurrentModificationException出现
  
  • 迭代器遍历，集合修改集合
• C:解决方案
  
  • a:迭代器迭代元素，迭代器修改元素(ListIterator的特有功能add)
  • b:集合遍历元素，集合修改元素

    ListIterator lit = list.listIterator();     //如果想在遍历的过程中添加元素,可以用ListIterator中的add方法
    while(lit.hasNext()) {
        String str = (String)lit.next();
        if(str.equals("world")) {
            lit.add("javaee");  
        }
    }

**总结:
在迭代时,不可以通过集合对象的方法操作集合中的元素,因为会发生ConcurrentModificationException异常.
所以在使用迭代器时,只能用迭代器的方法操作元素,可是Iterator(迭代器)的方法是有限的,只能对元素进行判断(hasNext())、取出(next())、删除(remove())的操作,如果想要其他的操作如添加,修改等,就需要使用其子接口,ListIterator。该接口只能通过List集合的listIterator()方法获取.**

集合框架(Vector的特有功能)(了解)

• A:Vector类概述
• B:Vector类特有功能

    public void addElement(E obj)
    public E elementAt(int index)
    public Enumeration elements()

• C:案例
  
  • Vector的迭代

Vector v = new Vector();                //创建集合对象,List的子类
            v.addElement("a");
            v.addElement("b");
            v.addElement("c");

            //Vector迭代
            Enumeration en = v.elements();          //获取枚举
            while(en.hasMoreElements()) {           //判断集合中是否有元素
                System.out.println(en.nextElement());//获取集合中的元素
            }

集合框架(数据结构之数组和链表)

• A:数组
  
  • 查询快修改也快
  • 增删慢
• B:链表
  
  • 查询慢,修改也慢
  • 增删快

集合框架(List的三个子类的特点)

• A:List的三个子类的特点

• ArrayList:
      底层数据结构是数组，查询快，增删慢。
      线程不安全，效率高。
  Vector:
      底层数据结构是数组，查询快，增删慢。
      线程安全，效率低。
  Vector相对ArrayList查询慢(线程安全的)
  Vector相对LinkedList增删慢(数组结构)
  LinkedList:
      底层数据结构是链表，查询慢，增删快。
      线程不安全，效率高。
  
  Vector和ArrayList的区别
      Vector是线程安全的,效率低
      ArrayList是线程不安全的,效率高
  共同点:都是数组实现的
  ArrayList和LinkedList的区别
      ArrayList底层是数组结构,查询和修改快
      LinkedList底层是链表结构的,增和删比较快,查询和修改比较慢
  共同点:都是线程不安全的
  

• B:List有三个儿子，我们到底使用谁呢?
  查询多用ArrayList
  增删多用LinkedList
  如果都多ArrayList

集合框架(LinkedList的特有功能)(掌握)

LinkedList类特有功能
     public void addFirst(E e)及addLast(E e)
     public E getFirst()及getLast()
     public E removeFirst()及public E removeLast()
     public E get(int index);

集合框架(泛型概述和基本使用)(掌握)

• A:泛型概述:限定集合存储的数据类型,Collection其中E代表引用数据类型,如果加上了该引用数据类型,表示该集合中只能存储该类型对象,或者该类型的子类对象.
• B:泛型好处
  
  • 提高安全性(将运行期的错误转换到编译期)
  • 省去强转的麻烦
• C:泛型基本使用
  
  • <>中放的必须是引用数据类型
• D:泛型使用注意事项
  
  • 前后的泛型必须一致,或者后面的泛型可以省略不写(1.7的新特性菱形泛型)

集合框架(泛型类的概述及使用)(了解)

• A:泛型类概述
  
  • 把泛型定义在类上
• B:定义格式
  
  • public class 类名<泛型类型1,…>
• C:注意事项
  
  • 泛型类型必须是引用类型
• D:案例演示
  
  • 泛型类的使用
    案例(使用上个案例中的实体类):

public class Tool<Q> {//在类上定义了泛型Q,Q什么时候有值,当你用这个类时,指定了泛型是什么,Q就代表什么
    private Q q;
​
    public Q getObj() {
        return q;
    }
​
    public void setObj(Q q) {
        this.q = q;
    }   
}


​
    /**
     * A:案例演示
     * 泛型的由来:通过Object转型问题引入
     * 早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。也就存在这隐患，所以Java提供了泛型来解决这个安全问题。
     */
    public static void main(String[] args) {
        demo1();    
    }
​
    public static void demo1() {
        Tool<Student> t = new Tool<>();                 //创建工具类对象
        t.setObj(new Student("张三",23));

        Student s = t.getObj();         //因为使用了泛型,存入的是啥,取出的就是啥,不用向下转型
        System.out.println(s);
    }
​
}

集合框架(可变参数的概述和使用)(掌握)

• A:可变参数概述
  
  • 定义方法的时候不知道该定义多少个参数
• B:格式
  
  • 修饰符 返回值类型 方法名(数据类型… 变量名){}
• C:注意事项：
  
  • 这里的变量其实是一个数组
  • 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个

  public static void show(int j,int ... arr) {            //可变参数其实是一个数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

集合框架(Arrays工具类的asList()方法的使用)(掌握)

• A:案例演示
  
  • Arrays工具类的asList()方法的使用
  • Collection中toArray(T[] a)泛型版的集合转数组
    案例:

 /**
   * 数组转换成集合
   * 数组转换成集合虽然不能增加或减少元素,但是可以用集合的思想操作数组,也就是说可以使用其他集合中的方法
   */

         //当集合转换数组时,数组长度如果是小于等于集合的size时,转换后的数组长度等于集合的size
         //如果数组的长度大于了size,分配的数组长度就和你指定的长度一样
        String[] arr = list.toArray(new String[10]);       

        //List<int[]> list = Arrays.asList(arr);            //基本数据类型的数组转换成集合,会将整个数组当作一个对象转换

        String[] arr = {"a","b","c"};
        List<String> list = Arrays.asList(arr);             //将数组转换成集合
        //list.add("d");                                    //不能添加
    }
}

泛型相关未详细说明？？？？？？？？？？？？？？？？？？？？？？？？？