java-Collection集合，List集合-蒲公英云

集合数组

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDgxOTI0_size_16_color_FFFFFF_t_70

65.集合的由来和集合继承体系图

-集合的由来：数组长度是固定,当添加的元素超过了数组的长度时需要对数组重新定义,太麻烦,java内部给我们提供了集合类,能存储任意对象,长度是可以改变的,随着元素的增加而增加,随着元素的减少而减少

-数组和集合的区别：

1：

*数组既可以存储基本数据类型，也可以存储引用数据类型，基本数据类型存储的是值，引用数据类型存储的是地址值

*集合只能存储引用数据类型（对象）集合中也可以存储基本数据类型，但在存储的时候会自动装箱为对象，100->new Integer(100)

*数组的长度是固定的，不能自动增长

*集合的长度是可变的，可以根据元素的增加而增长

-集合和数组什么时候用：

        **\*如果元素个数是固定推荐用数组，因为当使用集合****时，由于集合也有通过数组实现的，所以在赋值时可能会产生大量垃圾，浪费内存**

*如果元素个数不是固定的推荐用集合

-集合继承体系图：

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDgxOTI0_size_16_color_FFFFFF_t_70 1

66.Collection集合的基本功能

-方法：

    **boolean add(E e)              //向集合中添加元素（参数为object的任意对象）**

注：add方法如果是List集合一直会返回true，因为List集合是可以存储重复元素的，如果是Set集合存储重复元素就会返回false
boolean remove(Object o) //删除集合中的元素
void clear() //清空集合中的元素
boolean contains(Object o) //查看集合中是否包含指定元素，返回一个boolean值
boolean isEmpty() //判断集合是否为空
int size() //获取集合中元素的个数

-ArrayList的父类的父类重写toString方法，所以在打印对象引用的时候，输出的结果不是Object类中toString的结果

package Collection;
import java.util.ArrayList;
import java.util.Collection;
public class demo1 {
    public static void main(String[] args) {
        Collection c = new ArrayList();           //父类引用指向子类对象，编译看父类，运行看子类
        boolean b1 = c.add("abc");  
        boolean b2 = c.add(true);                 //基本数据类型，会自动装箱，new Boolean(true);
        boolean b3 = c.add(123);                 //new Integer(123)
        boolean b4 = c.add(new Student("张三",23));     
        System.out.println(c);
    }
}

67.集合的遍历

-遍历：其实就是依次获取集合中的每一个元素

-实现：将集合转换为数组，可以实现集合的遍历

方法：toArray(); //将集合转换为数组

package Collection;
import java.util.ArrayList;
import java.util.Collection;
public class demo2 {
    public static void main(String[] args) {
        demo1();
        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));
        Object[] arr = c.toArray();                  //将集合转换为Object数组
        for (int i = 0; i < arr.length; i++) {
            //System.out.println(arr[i]);        //它的作用只是为了显示
            Student s = (Student)arr[i];          //将obj向下转型为Student对象，这样就可以使用student中特有的属性和方法
            System.out.println(s.getName()+".."+s.getAge());    //这样不仅可以显示，还可以获取数据做其他操作
        }
    }
    private static void demo1() {
        Collection c = new ArrayList();
        c.add("a");
        c.add("b");
        c.add("c");
        c.add("d");
        Object[] arr = c.toArray();
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

68.Collection集合中带All的方法测试

-方法：

    **boolean addAll(Collection c)                          //将整个集合添加为另一集合的元素中，合并  
    boolean removeAll(Collection c)                    //删除的是交集  
    boolean containsAll(Collection c)                  //判断一集合是否包含另一集合的元素，可以重复，但如果另一集合含有集合中不存在的元素，则返回fasle  
    boolean retainAll(Collection c)                       //获取两个集合的交集，如果调用的集合改变就返回true，如果调用的集合不变就返回false**
package Collection;
import java.util.ArrayList;
import java.util.Collection;
public class demo3 {
    public static void main(String[] args) {
        addAll();
        removeAll();
        containsAll();
        Collection c1 = new ArrayList();
        c1.add("a");
        c1.add("b");
        c1.add("c");
        c1.add("d");
        Collection c2 = new ArrayList();
        c2.add("a");
        c2.add("b");
        c2.add("b");
        boolean b = c1.retainAll(c2);
        Collection c3 = new ArrayList();
        c3.add("a");
        c3.add("b");
        c3.add("c");
        c3.add("d");
        c3.add("e");
        c3.add("f");
        System.out.println("获取c1,c2中相同的元素，若c1改变，返回true若不变，返回false");
        System.out.println(b);
        System.out.println(c1);
        System.out.println("c3包含c1的全部元素，此时c1不变，返回false");
        boolean b2 = c1.retainAll(c3);
        System.out.println(b2);
        System.out.println(c1);
    }
    private static void containsAll() {
        Collection c1 = new ArrayList();
        c1.add("a");
        c1.add("b");
        c1.add("c");
        c1.add("d");
        Collection c2 = new ArrayList();
        c2.add("a");
        c2.add("b");
        c2.add("b");
        boolean b = c1.containsAll(c2);
        System.out.println("判断c1中是否含有c2中的所有元素，c2中的元素可以重复，但如果含有c1没有的元素，则返回false");
        System.out.println(b);
        System.out.println(c1);
    }
    private static void removeAll() {
        Collection c1 = new ArrayList();
        c1.add("a");
        c1.add("b");
        c1.add("c");
        c1.add("d");
        Collection c2 = new ArrayList();
        c2.add("a");
        c2.add("b");
        c2.add("3");
        boolean b = c1.removeAll(c2);
        System.out.println("获取两个集合的交集，若没有交集则返回false");
        System.out.println(b);
        System.out.println(c1);
    }
    private static void addAll() {
        Collection c1 = new ArrayList();
        c1.add("a");
        c1.add("b");
        c1.add("c");
        c1.add("d");
        Collection c2 = new ArrayList();
        c2.add("a");
        c2.add("b");
        c2.add("3");
        boolean b = c1.addAll(c2);
        System.out.println("将两个集合合并，并将结果返回给调用的集合");
        System.out.println(b);
        System.out.println(c1);
    }
}

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNDgxOTI0_size_16_color_FFFFFF_t_70 2

69.集合的遍历之迭代器遍历

-概述： 集合是用来存储元素,存储的元素需要查看,那么就需要迭代(遍历)

-迭代器：Iterator（接口）

-迭代器原理：迭代器是对集合进行遍历,而每一个集合内部的存储结构都是不同的,所以每一个集合存和取都是不一样,那么就需要在每一个类中定义hasNext()和next()方法,这样做是可以的,但是会让整个集合体系过于臃肿,迭代器是将这样的方法向上抽取出接口,然后在每个类的内部,定义自己迭代方式,这样做的好处有二,第一规定了整个集合体系的遍历方式都是hasNext()和next()方法,第二,代码有底层内部实现,使用者不用管怎么实现的,会用即可

-方法：

*boolean hasnext() //如果仍有元素可以迭代，返回true

*next() //返回迭代的下一个元素

package Collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class demo4 {
    public static void main(String[] args) {
        demo1();
        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()){
            Student s = (Student)it.next();                  //将集合中的元素向下转型，由object对象转换为Student对象
            System.out.println(s.getName()+".."+s.getAge());
        }
    }
    private static void demo1() {
        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());           //指针会自动向后移动
         }
    }
}

70.List集合的特有功能概述

-概述：有序的Collection也称为序列，此接口的用户可以对列表中每个元素的插入位置进行精确的控制，用户可以根据元素的整数索引访问元素，并搜索列表中的元素。

-方法：

* void add(int index,E element) //在列表的指定位置插入元素
* E remove(int index) //删除指定位置的元素
* E get(int index) //根据索引获取指定元素
* E set(int index,E element) //修改指定位置的元素

package Collection;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class demo5_List {
    public static void main(String[] args) {
        add();
        remove();
        get();
        set();
    }
    private static void set() {
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.set(1, "x");
        System.out.println(list);
    }
    private static void get() {
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        //利用迭代器遍历List集合
        Iterator it = list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }    
        //通过索引遍历List集合
        for(int i=0;i<list.size();i++){
            System.out.print(list.get(i) +" ");
        }
        System.out.println();
    }
    private static void remove() {
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add(111);
        list.add(222);
        Object obj = list.remove(1);               //返回删除的元素，根据索引删除指定元素
        //Object obj1 = list.remove(111);       //参数不能为数字，将数字当成了索引，所以会报错
        System.out.println(obj);
        System.out.println(list);
    }
    private static void add() {
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add(4, "e");                    //index<=size    ,且index>=0都不会触发异常
        //list.add(10,"e");               IndexOutOfBoundsException索引越界异常
        System.out.println(list);
    }
}

-List集合的遍历

package Collection;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class demo6 {
    public static void main(String[] args) {
        List list  = new ArrayList();
        list.add(new Student("张三",23));
        list.add(new Student("李四",24));
        list.add(new Student("王五",25));
        list.add(new Student("赵六",26));
        //利用get方法遍历
        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());
        }
        System.out.println();
        //利用迭代器遍历
        Iterator it = list.iterator();
        while(it.hasNext()){
            Student s = (Student)it.next();             //将obj对象向下转型，这样就可以使用student类中特有的属性和方法
            System.out.println(s.getName()+".."+s.getAge());
        }
    }
}

-并发修改异常产生的原因及解决方案

-ListIterator接口：系列表迭代器，允许按任一方法遍历集合，迭代期间修改列表，接口中有add方法，可以在迭代期间向列表添加元素，而不触发并发修改异常（ConcurrentModificationException）的错误

package Collection;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class demo7_listIterator {
    public static void main(String[] args){
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("hello");
        list.add("c");
        list.add("d");
        /*Iterator it= list.iterator();     //获取迭代器
        while (it.hasNext()) {             //判断集合是否有元素
            String s = (String)it.next();      //向下转型
            if("hello".equals(s)){             //如果集合中含有"hello"字符串，就向集合中添加world
                list.add("wolrd");          //遍历的同时再增加元素，不允许在遍历期间修改集合，触发ConcurrentModificationException异常（并发修改异常）
            }
        }*/
        ListIterator lit = list.listIterator();
        while (lit.hasNext()) {             //判断集合是否有元素
            String s = (String)lit.next();      //向下转型
            if("hello".equals(s)){             //如果集合中含有"hello"字符串，就向集合中添加world
                lit.add("wolrd");               //调用    ListIterator接口中的add方法，允许再遍历期间修改集合
            }
        }
        System.out.println(list);
    }
}

-ListIterator接口功能

  **\* boolean hasNext()         是否有下一个  
  \* boolean hasPrevious()  是否有前一个  
  \* Object next()                  返回下一个元素  
  \* Object previous()           返回上一个元素**

71.Vector接口的概述

-概述：实现了List接口，功能被ArrayList取代

-特有功能：

未实现List接口时，Vector通过枚举来遍历获取集合中的值

*void addElement(obj E) 添加元素

-Enumeration 枚举对象，实现枚举功能

*hasMoreElements() 测试此枚举是否包含更多的元素

*nextElement() 如果还有下一个对象，返回下一个元素

package Collection;
import java.util.Enumeration;
import java.util.Vector;
public class demo8_Vector {
    public static void main(String[] args) {
        Vector v = new Vector();
        v.addElement("a");
        v.addElement("b");
        v.addElement("c");
        v.addElement("d");
        Enumeration en = v.elements();                 //获取枚举
        while(en.hasMoreElements()){                 //判断是否有元素
            System.out.println(en.nextElement());      //输出集合中的所有元素
        }
    }
}

72.List的三个子类

-数组与链表的比较:
数组：查询快修改也快

增加和删除慢

链表：查询慢修改也慢

增加和删除快

-ArrayList，LinkList，Vector的比较：

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

73.ArrayList去重

-思路：1.创建新集合接收老集合中不重复的值

2.获取老集合中的迭代器

3.遍历老集合

4.通过新集合是否包含老集合中的元素，如果包含就不添加，不包含就添加

package Collection;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class demo9_ArrayList去重 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add("a");
        list.add("a");
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("c");
        list.add("b");
        ArrayList li = method(list);
        System.out.println(li);
    }
    public static ArrayList method(ArrayList list){
        ArrayList al = new ArrayList();                     //创建新集合
        Iterator it = list.iterator();                            //获取传入集合的迭代器
        while(it.hasNext()){
            Object obj = it.next();                                //取得集合中每一个元素
            if(!al.contains(obj)){                                  //如果新集合不包含obj，就添加
                al.add(obj);
            }
        }
        return al;
    }
}

-自定义类实现去重

-注意点：Contains方法和remove方法底层是通过equals方法实现的，如果自定义类没有重写equals方法的话，就会调用object类的equals方法，此时比较的是对象的地址值。

package Collection;
import java.util.ArrayList;
import java.util.Iterator;
public class demo9_ArrayLIst2 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(new Student("张三",23));
        list.add(new Student("张三",23));
        list.add(new Student("张三",25));
        list.add(new Student("李四",24));
        list.add(new Student("李四",24));
        ArrayList al = method(list);
        System.out.println(al);
    }
    public static ArrayList method(ArrayList list){
        ArrayList aList = new ArrayList();                //创建新集合
        Iterator it = list.iterator();
        while(it.hasNext()){
            Object obj = it.next();
            if(!aList.contains(obj)){                            //Contains底层是通过equals实现的，如果自定义类没有重写equals方法，就会自动调用object类的equals方法，此时比较的是地址值
                aList.add(obj);
            }
        }
        return aList;
    }
}
Student类：
@Override           //重写equals方法
    public boolean equals(Object obj) {
        Student s = (Student)obj;
        return this.name.equals(s.name) && this.age == s.age;
    }

75.LinkedList的概述及使用

-概述：List接口的链表形式实现

-链表：查询和修改慢，增加和删除快，因为链表的每一个元素（除开头和结尾外）都保留着它前一个元素和后一个元素的地址，这样就可以以链的形式连接，但查询时，只能从头或从尾依次查找，直至找到，所以查询慢，而删除时只要将两个元素之间的链去掉即可。

-方法：

* public void addFirst(E e)及addLast(E e) //在链的头部或尾部添加元素
* public E getFirst()及getLast() //获取链的头部或尾部的元素
* public E removeFirst()及public E removeLast() //删除链的头部或尾部的元素
* public E get(int index) //获取指定索引的元素，由（index和size/2）比较，判断应从头部还是尾部开始查找

-用LinkedList模拟栈数据结构

package Collection;
import java.util.LinkedList;
public class demo11_stack {
    private LinkedList list = new LinkedList();
    public static void main(String[] args) {
        demo11_stack d = new demo11_stack();
        d.inStack("a");
        d.inStack("b");
        d.inStack("c");
        d.inStack("d");
        while(!d.isEmpty()){
            System.out.println(d.outStack());
        }
    }
    public void inStack(Object obj){
         list.addFirst(obj);
    }
    public Object outStack(){
        return list.removeFirst();
    }
    public boolean isEmpty(){
        return list.isEmpty();
    }
}

77.增强for**概述及其使用**

-概述：简化数组及Collection集合的遍历（底层用迭代器实现）

-格式：

       **for(元素数据类型 变量 : 数组或者Collection集合) \{  
              使用变量即可，该变量就是元素  
        \}**
package generic;
import java.util.ArrayList;
public class demo5_foreach {
    public static void main(String[] args) {
        int arr[]  = {11,22,33,44,55};
        for (int i : arr) {
            System.out.println(i);
        }
        ArrayList< String > list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        for (String string : list) {
            System.out.println(string);
        }
    }
}

78.三种迭代的能否删除

package generic;
import java.util.ArrayList;
import java.util.Iterator;
public class demo6 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("d");
        //for 循环遍历删除指定元素
        /*for (int i = 0; i < list.size(); i++) {       
            if("b".equals(list.get(i))){            //找到"b"
                list.remove(i--);                          //删除"b"，并使索引回退一位，因为当删除一个元素时，list的size会减少一位，此时如果i的索引不减一的话，就会跳过删去元素的下一位元素
            }*/
        //迭代器循环遍历删除指定元素
        /*Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            if("b".equals(it.next())){
                it.remove();
                //list.remove("b");                不能用集合的修改方法，因为会出现并发修改异常
        }
        }*/
        //foreach循环遍历删除（不可以）因为foreach底层依赖迭代器实现
        /*for (String string : list) {
            if("b".equals(string)){
                list.remove("b");                //并发修改异常，不能删除指定元素
            }
        }*/
    }
}

79.静态导入

-概述：静态导入类方法

-格式：import static 包名… 类名.方法名

可以直接导入到方法的级别

-注意事项：方法必须是静态的，但如果有多个同名的静态方法，容易不知道使用谁？这个时候要使用，必须加前缀。

80.可变参数

-概述：当定义方法的时候不知道应该定义多少个参数

-格式：

*修饰符返回值类型方法名（数据类型 … 变量名）{}

-注意事项：

*这里的可变参数其实是一个数组

*如果一个方法有可变参数，并且还有多个参数，可变参数肯定是最后一个

package generic;
public class demo7_changeableargs {
    public static void main(String[] args) {
        String[] arr = {"a","b","c","d"};
        method("s1","z","x","y");
    }
    public static void method(String s1,String ... arr1){
        for (String string : arr1) {
            System.out.println(string);
        }
    }
}

81.asList方法

-功能：将数组转换成集合

-注意：

*数组转换成集合后不能增加或删除元素，但是可以用集合的思想来操作数组，也就是说可以使用其他集合里的方法

      \***基本数据类型转数组，会将整个数组转化为一个对象**

*将数组转化为集合，数组必须是引用数据类型

package Arrays;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class demo2_asList {
    public static void main(String[] args) {
        Integer[] arr = {11,11,22,33,33,44,44,55};
        List<Integer> list = Arrays.asList(arr);
        System.out.println(list);               //数组转集合只能是引用数据类型
        listtoarray();
    }
    private static void listtoarray() {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        String[] arr = list.toArray(new String[5]); //当集合转数组时，数组的长度如果<=size，转换后的数组长度等于集合的size，如果>size，那么数组的长度就和你指定的长度一样
        for (String string : arr) {
            System.out.println(string);
        }
    }
}

82.集合中嵌套集合

package Collection;
import java.util.ArrayList;
public class demo12 {
    public static void main(String[] args) {
        ArrayList<ArrayList<Student>> list = new ArrayList<>();
        ArrayList<Student> First = new ArrayList<>();
        First.add(new Student("张三",23));
        First.add(new Student("李四",24));
        First.add(new Student("王五",25));
        ArrayList<Student> Second = new ArrayList<>();
        Second.add(new Student("赵六",26));
        Second.add(new Student("周七",27));
        Second.add(new Student("潘八",28));
        list.add(First);
        list.add(Second);
        for (ArrayList<Student> as :list ) {
            System.out.println(as);
            for (Student s : as) {
                System.out.println(s);
            }
        }
     }
}