集合（1）

1 collection集合

package Clooection集合;

public class Test {
    public static void main(String[] args) {
//        数组作为容器，可以存储元素，但是不是很方便，比如说我们对元素的增删，就不是那么的方便
//        因为数组一旦定义，长度就定义了，在图中如果增删元素，就会改变数组的长度，就会报错
//        所以说JAVA为了我们更加方便的对容器中的元素操作，给我们提供了另外一种容器叫做集合，我们对集合中的元素进行增删改查
//        就比较方便
//        集合和数组的区别：
//        相同点：
//        都可作为容器来存储元素
//        不同点:数组的长度是固定的,一旦定义,就会固定
//                集合的长度是可改变的
//                 数组既可以存储基本类型,也可以存储引用数据类型
//                   集合只能存储引用数据类型
//        数组作为容器,容器中只能存储同一种数据类型(这种数据类型可以存该类的也可以存该类的子类数据类型)
//        集合作为容器，容器中可以存储多种引用数据类型

    }
}

package Clooection集合.Collection接口;
//集合中元素的添加
import java.util.ArrayList;
import java.util.Collection;

public class Test {
    public static void main(String[] args) {
//        从上往下学习，先学习最最最开始的根接口的方法
//        以ArrayList为例，采用多态
        Collection collection=new ArrayList();
//        往集合中添加元素
//        集合中存储的是以用数据类型
         collection.add("dasd");
        boolean add = collection.add(123);//这里是自动装箱了，集合只能存引用数据类型
//        该方法有返回值，为boolean类型，true表示添加成功，false表示添加失败
        System.out.println(add);
        System.out.println(collection);//Collection的子类重写了toString方法，记住是子类(这里是ArrayList类)
        //从写了toString方法，Collection是接口，无法重写toString方法 ，所以输出的时候不会输出地址值，打印集合的元素
//如果说集合存储了一个引用数据类型的元素，且该元素的类也重写了toString方法，那么输出的时候也不是输出地址，只有没有重写toString
//        方法的时候才输出地址，记住了

    }
}

package Clooection集合.Collection接口;
//集合中元素的添加
import java.util.ArrayList;
import java.util.Collection;
//记住，只要带all的方法是对多个集合进行操作
public class Test1 {
    public static void main(String[] args) {
        Collection collection=new ArrayList();
        ((ArrayList) collection).add(100);
        ((ArrayList) collection).add(200);
        ((ArrayList) collection).add(300);
        Collection collection1=new ArrayList();
        ((ArrayList) collection1).add(400);
        ((ArrayList) collection1).add(400);
        ((ArrayList) collection1).add(500);
        ((ArrayList) collection1).add(600);
//        我想把两个集合中的元素放到一个集合中
        boolean b = collection.addAll(collection1);//这样就吧collection1中的元素添加到collection中去了
//        返回值仍然为boolean类型，且clooection1中的元素不受影响
    }
}

package Clooection集合.Collection接口;

import java.util.ArrayList;
import java.util.Collection;

//集合中元素的删除
public class Test2 {
    public static void main(String[] args) {
        Collection collection=new ArrayList();
        ((ArrayList) collection).add("123");
        ((ArrayList) collection).add(100);
        ((ArrayList) collection).add(200);
        ((ArrayList) collection).add(300);
        ((ArrayList) collection).add(400);
        boolean remove = collection.remove(100);//删除集合中的某一个元素，且返回值也为boolean
        System.out.println(collection);
//        清空集合所有的元素
        collection.clear();//无返回值
        System.out.println(collection);

    }
}

package Clooection集合.Collection接口;

import java.util.ArrayList;
import java.util.Collection;

//集合中元素的删除
public class Test3 {
    public static void main(String[] args) {
        Collection collection=new ArrayList();
        ((ArrayList) collection).add("123");
        ((ArrayList) collection).add(100);
        ((ArrayList) collection).add(200);
        ((ArrayList) collection).add(300);
        ((ArrayList) collection).add(400);
        ((ArrayList) collection).add(500);
        Collection collection2=new ArrayList();
        collection2.add("123");
        collection2.add(100);
        collection2.add(200);
        collection2.add(300);
        collection2.add(400);
        boolean b = collection.removeAll(collection2);//这个方法是用来删除collection中的与collection2的交集
//        元素部分，只删除交集元素部分，且返回boolean类型，如果有删掉交集元素，则返回true，没有交集元素，则返回false
        System.out.println(collection);
        System.out.println(collection2);

    }
}

package Clooection集合.Collection接口;
//判断集合中是否包含子元素
import java.util.ArrayList;
import java.util.Collection;

public class Test4 {
    public static void main(String[] args) {
        Collection collection=new ArrayList();
        ((ArrayList) collection).add("123");
        ((ArrayList) collection).add(100);
        ((ArrayList) collection).add(200);
        ((ArrayList) collection).add(300);
        ((ArrayList) collection).add(400);
        ((ArrayList) collection).add(500);
//        用这个方法去判断是否包含子元素
        boolean contains = collection.contains("123");
        System.out.println(contains);
        Collection collection2=new ArrayList();
        collection2.add("123");
        collection2.add(100);
        collection2.add(200);
        collection2.add(300);
        collection2.add(400);
//        A集合.containsAll(B集合)表示的是B集合中的元素只有A集合中全包含的时候，才返回true，否则返回false
//        如：
        boolean b = collection.containsAll(collection2);//collection2中的元素collection都有，都包含了，所以返回
//        true
        System.out.println(b);
    }
}

package Clooection集合.Collection接口;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

//集合的遍历
public class Test5 {
    public static void main(String[] args) {
        Collection collection=new ArrayList();
        ((ArrayList) collection).add("123");
        ((ArrayList) collection).add(100);
        ((ArrayList) collection).add(200);
        ((ArrayList) collection).add(300);
        ((ArrayList) collection).add(400);
        ((ArrayList) collection).add(500);
//        iterator()
//        返回在此 collection 的元素上进行迭代的迭代器。
//        通过collection的这个方法获取迭代器
        Iterator iterator = collection.iterator();//通过集合的方法调出了其实现类的迭代器，记住就行了
//        通过集合中的方法调出迭代器，通过迭代器对集合中的元素进行迭代
        System.out.println(iterator);//在这里返回的是其子类对象，记住就行了，当有多态形式时，输出父类引用
//        则打印出来的是其子类对象//以该语句为例，打印出java.util.ArrayList$Itr@1e643faf，其中Itr为接口子类实现
//        对象，其中$表示的是内部类得意思


//  每一个Collection的实现类里面都有这个迭代器，且Iterator是个接口，在实现类里面（以ArrayList类为例）有一个
//        私有的内部类（Itr类），实现了Iterator接口，则这个类（Itr类）就成为了迭代器
//        boolean hasNext()
//          如果仍有元素可以迭代，则返回 true。
// E next()
//          返回迭代的下一个元素。
//此为迭代器中的两个方法
//        则实现如下：
        while (iterator.hasNext()){//判断还有没有下一个元素可以迭代
            Object next = iterator.next();//这里的Object其实是Integer String等一切类的父类
            System.out.println(next.toString());//这里其实是toString方法，但是子类方法重写了，就调用子类的方法
        }
    }
}

package Clooection集合.Collection接口;

import java.util.ArrayList;
import java.util.Collection;

//获取集合的长度
public class Test6 {
    public static void main(String[] args) {
        Collection collection=new ArrayList();
        ((ArrayList) collection).add("123");
        ((ArrayList) collection).add(100);
        ((ArrayList) collection).add(200);
        ((ArrayList) collection).add(300);
        ((ArrayList) collection).add(400);
        ((ArrayList) collection).add(500);
//     获取集合的长度,注意是size
        int size = collection.size();
//        可以通过.var快捷键进行自动补全
        int size1 = collection.size();
       int[] a=new int[10];
//       获取数组的长度
       int b=a.length;
       String c="asdsadad";
//       获取字符串的长度，要分清三种获取长度的方法
        int length = c.length();

    }
}

package Clooection集合.Collection接口;

import java.util.ArrayList;
import java.util.Collection;

public class Test7 {
    public static void main(String[] args) {
        Collection collection=new ArrayList();
        ((ArrayList) collection).add("123");
        ((ArrayList) collection).add(100);
        ((ArrayList) collection).add(200);
        ((ArrayList) collection).add(300);
        ((ArrayList) collection).add(1000);





        Collection collection1=new ArrayList();
        ((ArrayList) collection1).add("123");
        ((ArrayList) collection1).add(100);
        ((ArrayList) collection1).add(200);
        ((ArrayList) collection1).add(300);
        ((ArrayList) collection1).add(400);
        ((ArrayList) collection1).add(500);
//        获取两集合交集元素
        boolean b = collection.retainAll(collection1);//只对.前面的集合有改变，括号里面的没有改变，如果collection发生
//        变化了，即collection元素取完交集元素之后，集合有没有多元素，如果多了就为true，没有发生变化就为false
        System.out.println(b);
        System.out.println(collection);//只从collection集合里面获取到交集的元素，即collection与collection1的公共部分的元素
//      如果两集合是没有交集的，则返回一个空集合，即最后只返回集合collection有交集的部分，感觉绕口就记住
        System.out.println(collection1);

    }
}

package Clooection集合.Collection接口;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;

//把集合转换为数组
public class Test8 {
    public static void main(String[] args) {
        Collection collection1=new ArrayList();
        ((ArrayList) collection1).add(123);
        ((ArrayList) collection1).add(100);
        ((ArrayList) collection1).add(200);
        ((ArrayList) collection1).add(300);
        ((ArrayList) collection1).add(400);
        ((ArrayList) collection1).add(500);
        Integer[] integers=new Integer[collection1.size()];
        Iterator iterator = collection1.iterator();
        int[] a=new int[collection1.size()];
        int i=0;
        while (iterator.hasNext()){
            Object next = iterator.next();
        integers[i] =(Integer)next;
        i++;
        }
        System.out.println(Arrays.toString(integers));
//        现在不用我们自己写方法了，有现成的方法可以用,直接用这个方法就可以
        Object[] objects = collection1.toArray();
        System.out.println(Arrays.toString(objects));
    }
}

2 list集合

package Clooection集合.Collection接口.List集合;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class Test {
    public static void main(String[] args) {
//        List集合描述及特点：
//        元素有序，并且每一个元素都存在一个索引，元素可以重复，一定记住元素有序可重复，元素有序表示存和取顺序
//        是一致的
//        add(int index, E element)
//          在列表的指定位置插入指定元素
//        get(int index)
//          返回列表中指定位置的元素。
//        indexOf(Object o)
//          返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
//        lastIndexOf(Object o)
//          返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。
//        index跟之前学的那一块儿一样
//remove(int index)
//          移除列表中指定位置的元素（可选操作）。根据索引值去移除元素
//        set(int index, E element)
//          用指定元素替换列表中指定位置的元素（可选操作）。
//        subList(int fromIndex, int toIndex)
//          返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
//        listIterator()
//        返回此列表元素的列表迭代器（按适当顺序）。
        List list=new ArrayList();
//        向集合中添加元素
        list.add(100);
        list.add("123");
        list.add(200);
//        但是List集合中还可以用另一种方式添加，即通过按指定索引值添加数据
        list.add(0,500);//从这里添加进来，之前的元素依次往后挪
        System.out.println(list);
//        通过索引获取元素
        Object o = list.get(1);
        System.out.println(o);
        System.out.println("===================================");
//        从这以后也可以通过for循环遍历集合了
        //遍历方式一：
        for (int i = 0; i < list.size(); i++) {
            Object o1=list.get(i);//Collection没有get和set方法，所以不能用这种方法去迭代
            System.out.println(o1);
        }
        System.out.println("============================================");
        //遍历方式二：
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next);
        }
        System.out.println("===============================");
        //遍历方式三：可以用List集合自己特有的迭代器
        //listIterator()
//        返回此列表元素的列表迭代器（按适当顺序）。
        // listIterator是一个接口，其继承自Iterator接口
//        ============================================================
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()){
            Object next = listIterator.next();
            System.out.println(next);
        }
    }
}

package Clooection集合.Collection接口.List集合;

import java.util.ArrayList;
import java.util.List;

public class Test1 {
    public static void main(String[] args) {
        //        indexOf(Object o)
//          返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。注意是第一次
//        lastIndexOf(Object o)
//          返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。
        List list=new ArrayList();
        list.add(100);
        list.add(100);
        list.add(100);
        list.add(100);
        list.add(100);
        list.add("123");
        list.add(200);
        int i = list.indexOf(100);
        System.out.println(i);
        int i1 = list.lastIndexOf(100);
        System.out.println(i1);
    }
}

package Clooection集合.Collection接口.List集合;

import java.util.ArrayList;
import java.util.List;

public class Test2 {
    public static void main(String[] args) {
        List list=new ArrayList();
        list.add(100);
        list.add(100);
        list.add(100);
        list.add(100);
        list.add(100);
        list.add("123");
        list.add(200);
// 根据元素删除集合元素
        boolean remove = list.remove("123");//返回的是是否删除成功
        System.out.println(remove);
        System.out.println(list);
        // 根据索引删除集合元素，返回的是你删除的那个元素
        Object remove1 = list.remove(1);
        System.out.println(remove1);


    }
}

package Clooection集合.Collection接口.List集合;

import java.util.ArrayList;
import java.util.List;

public class Test4 {
    public static void main(String[] args) {
        List list=new ArrayList();
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(400);
        list.add(500);
//        这个根据索引删好删，但是根据元素的话就不能直接填写100，200……等等，因为你只要写数字的话就根据按索引删
//        但是我就想按照这种方式去删，可以用包装类的装箱方法,将对应想删除的数自动包装成那个Integer类：
//        因为Integer重写了equals方法，所以这里就直接进行的比较，看看构造参数是否对应一样
        Object remove = list.remove(Integer.valueOf(300));
        System.out.println(list);

    }
}

package Clooection集合.Collection接口.List集合;

import java.util.ArrayList;
import java.util.List;

public class Test5 {
    public static void main(String[] args) {
//          set(int index, E element)
          用指定元素替换列表中指定位置的元素（可选操作）。其实就是将某个索引值对应的元素修改成别的元素
        List list=new ArrayList();
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(400);
        list.add(500);
        Object set = list.set(list.size() - 1, 600);//注意：这里返回的是替换之前的旧值
        System.out.println(set);
        System.out.println(list);

    }
}

package Clooection集合.Collection接口.List集合;

import java.util.ArrayList;
import java.util.List;

public class Test6 {
    public static void main(String[] args) {
        //        subList(int fromIndex, int toIndex)
//          返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
        List list=new ArrayList();
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(400);
        list.add(500);
        List list1 = list.subList(1, 3);//跟字符串截取一个道理，方法名也挺像的，含头不含尾，返回一个新的集合
//        原集合元素不受影响
        System.out.println(list1);
    }
}

package Clooection集合.Collection接口.List集合;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class Test7 {
    public static void main(String[] args) {
        List list=new ArrayList();
        list.add("aaa");
        list.add("aba");
        list.add("aca");
        list.add("ada");
// list特有迭代器正向迭代，当然所有的迭代器都有正向迭代，从上往下迭代
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            Object next = listIterator.next();
            System.out.println(next);
        }
        System.out.println(list);
        //        list特有迭代器反向迭代：从下往上迭代
//    //hasPrevious()
//   // 如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。
    previous()
          返回列表中的前一个元素
        System.out.println("=========================");
//        !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
//        这里注意，迭代器一进来不能直接反向迭代，因为用hasnext（或hasprevioous）方法时，其指针在数组第一个
//        元素的上面，只有先用hasnext遍历完才能将指针挪到最下面，如果上来直接hasprevioous，那么指针在数组第一
//        个元素的上面，在往上挪一个仍然是没有元素，所以返回false，所以必须要先hasnext遍历完，在hasprevioous
//        如果直接获取一个新的迭代器，那么指针还是在第一个元素的上面，因为这是一个新的迭代器，新旧迭代器两个指针
//        要使用的是同一个迭代器才行
        while (listIterator.hasPrevious()){
            Object previous = listIterator.previous();
            System.out.println(previous);
        }
    }



    }

package Clooection集合.Collection接口.List集合;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class Test8 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("aaa");
        list.add("World");
        list.add("aca");
        list.add("World");
        list.add("World");
        list.add("World1");
        list.add("World2");
        list.add("World3");
        list.add("World4");
//        要求：查找集合中有没有一个是“World”的元素，如果有的话，则添加“javaee”
//        这里有更简单的办法可以达到要求，但是为了演示一个问题，采用遍历：
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()) {
           // Object next = listIterator.next();// listIterator.next()返回的就是一个父类型,类似Fu fu= new Fu();
//            但这里的.next方法这里应该是有个泛型，表示的是其子类,这里先暂时记住
            String next1 = (String) listIterator.next();//这里就类似 Son s=（Son） new Fu（）;
         //   String string = (String) next;//这里就类似 Son s=（Son）fu;
//            if ("World".equals(next1)) {
//                list.add("javaee");//在这里逻辑是没有问题的，但是：如果运行的话，会报出并发修改异常(NoSuchElementException)
            System.out.println(next1);
            }
//               为什么会有这个异常呢(NoSuchElementException)？
//            因为迭代器在对集合进行迭代的时候，已经获取到了集合的元素和顺序（在迭代器源
//            码中有源码体现，LIST集合其实就是数组，在迭代的时候其大小与顺序已经固定不能在变，在源码中有体现），
//            在迭代器
//            不断迭代的过程中，其会不断算集合的长度及元素顺序，当集合长度或者元素顺序发生改变时，会报异常
//            只有集合大小和顺序都不改变时，迭代器才能正常工作，这些在源码中都有体现
//            以此例子为例，当在迭代过程中直接往集合中添加一个元素，其集合的大小发生了改变，就报了异常
//        ====================================================================================================
//            解决方式一：还是用迭代器，迭代途中还是想增删集合中的元素。那么你要使用迭代器自带的增删元素的方法
//        add(E e)
//          将指定的元素插入列表（可选操作）。
            ListIterator listIterator1 = list.listIterator();
            while (listIterator1.hasNext()) {
                Object s = listIterator1.next();
                if ("World".equals(s)) {
                    listIterator1.add("javaee");//这个表示如果匹配到了“World”这个，就在其后面，注意是在world这个元素
//                后面添加javaee
                    // listIterator1.remove();//里面没有参数，该方法作用是如果匹配到这个元素了（这里指"World"），就
//                会把World删掉
//                    注意：！！！！！迭代器的add和remove功能不能同时用，暂时不清楚为什么
                }
                System.out.println(s);//这样迭代的时候不会输出新加的元素，只有直接输出list集合元素的时候才会打印新元素
            }
            System.out.println(list);
        System.out.println("====================================");
//            解决方式二：
//        用for 循环来遍历，遍历途中可以增删元素了就：
        for (int i = 0; i < list.size(); i++) {
               Object o=list.get(i);
               if ("World".equals(o)){
                   list.add("javase");//这里也是在其后面加，记住了
//                   因为这里没有用到迭代器迭代，只是用for循环遍历，所以不受影响，因为要用迭代器去迭代的话迭代器每次迭代要去算
//                   集合个数和顺序有没有发生变化，迭代器依赖集合，但是for循环不牵扯。所以一般采用for循环进行迭代
               }
            System.out.println(o);
        }
        }
    }

3 list接口实现类
(1) ArratList实现类

package Clooection集合.Collection接口.Collection各个实现类.ArrayList实现类;
//下面所写的东西,都是每个类中特有的方法,有的方法可能不同类是重复的,但是不影响,其仍为该类所独有的方法
import java.util.ArrayList;
import java.util.function.Consumer;

public class Test {
    public static void main(String[] args) {
//        ArrayList()
//          构造一个初始容量为 10 的空列表。其初始容量为10,如果写有参构造的话,那么形参为集合的初始容量




//      Arraylist底层采用的是数组,查询快,增删慢 线程不安全的,效率高注意:此线程是不同步的.
//        元素编有索引,是有序的(存取顺序一致),允许元素重复
//        选中它然后Ctrl+h可以查看一个类的继承关系(向上的都表示为父类)
        ArrayList arrayList=new ArrayList();
        arrayList.add(100);
        arrayList.add(100);
        arrayList.add(200);
        arrayList.add(300);
        arrayList.add(null);//元素存储时有序可重复的
//        遍历方式:
        arrayList.iterator();//方式一
        arrayList.listIterator();//方式二
//        for循环 //方式三
//        foreach //方式四 也是比较常用的一款,ArrayList类重写了该方法,直接可以用了
//        ctrl+p可以看方法要的参数
//        ctrl+q可以详细看一下方法的介绍
        arrayList.forEach(new Consumer() {
            @Override
            public void accept(Object o) {
//                o就是集合中的元素
                System.out.println(o);
            }
        });//暂时不知道其原理时怎么回事,先记住这个方法把,大概就是new Consumer作为实参进入forEach这个方法,然后
//        最后出结果的




    }
}

package Clooection集合.Collection接口.Collection各个实现类.ArrayList实现类;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.function.Predicate;

public class Test1 {
    public static void main(String[] args) {
        ArrayList arrayList=new ArrayList();
        arrayList.add(100);
        arrayList.add(100);
        arrayList.add(200);
        arrayList.add(300);
        arrayList.add(400);
        arrayList.add(500);
        arrayList.add(600);
//        对集合中元素的排序
//        Comparator是一个比较器
    arrayList.sort(new Comparator() {//这个方法记一下,也是经常用  ArrayList的特有方法
        @Override
        public int compare(Object o1, Object o2) {
            Integer o3= (Integer) o1;
            Integer o4= (Integer) o2; //这里要向下转型下
          int a=  ((Integer) o1).intValue()-((Integer) o2).intValue();
            return o3-o4;//自动拆箱  按照o3-o4的顺序就是升序,按照o4-o3的顺序就是降序,o3和o4对应o1 o2去记
        }
    });
        System.out.println(arrayList);
//        删除某一部分的元素
        arrayList.removeIf(new Predicate() {
            @Override
            public boolean test(Object o) {
                Integer a= (Integer) o;
                return a>300;//在这里设定条件,为真的删除,为假的保留
            }
        });
        System.out.println(arrayList);
//        判断集合是否为空的方法
        arrayList.clear();
        boolean empty = arrayList.isEmpty();
        System.out.println(empty);//true为空,false为不空
    }
}

（2）Vector实现类

package Clooection集合.Collection接口.Collection各个实现类.Vactor实现类;

import java.util.Vector;
import java.util.function.Consumer;
// Vactor类的初始容量及设置方式跟ArrayList一样
public class Test {
    public static void main(String[] args) {
        Vector vector = new Vector();
        vector.add(100);
        vector.addElement(120);
        vector.addElement("bbb");//vector自带的添加元素的方法,跟add一样
        vector.forEach(new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.println(o);
            }
        });
        System.out.println("===============================");
//        lastElement()
//          返回此向量的最后一个组件。
//        firstElement()
//          返回此向量的第一个组件（位于索引 0) 处的项）。   Vector的特有的方法
//        其实还不如用get来的实在
        Object o = vector.lastElement();
        Object o1 = vector.firstElement();
        System.out.println(o);
        System.out.println(o1);
        Object o2 = vector.elementAt(2);//跟charAt()方法类似,直接跟据索引去找出元素来,也可以用get方法就可以了
        System.out.println(o2);
//        elements()
//          返回此向量的组件的枚举。
    }
}

package Clooection集合.Collection接口.Collection各个实现类.Vactor实现类;

import java.util.Enumeration;
import java.util.Vector;

public class Test1 {
    public static void main(String[] args) {
//        elements()
//          返回此向量的组件的枚举。
//        这个时Vector自己的迭代器,可以遍历集合中的元素
        Vector vector = new Vector();
        vector.add(100);
        vector.add(200);
        vector.add(300);
        vector.add(400);
        vector.add(500);
        Enumeration elements = vector.elements();//Vector自带的迭代器,使用方法跟之前的一样,要认识
        while (elements.hasMoreElements()){
            Object o = elements.nextElement();
            System.out.println(o);
        }
    }
}

（3） LinkedList实现类

package Clooection集合.Collection接口.Collection各个实现类.LinkedList实现类;

import java.util.LinkedList;

//LinkedList()
//          构造一个空列表。
public class Test {
    public static void main(String[] args) {
//      LinkedList底层时链表,查询慢,增删快,线程不安全效率高.
        LinkedList linkedList = new LinkedList();
        linkedList.add(100);//普通的添加方法
        linkedList.addFirst(200);//这里表示从头加,从一个元素开始加,所以上面的100往后挪一位
        linkedList.addFirst(300);//以此类推
        linkedList.addFirst(400);//以此类推
        linkedList.addFirst(500);// ....
        System.out.println(linkedList);
        linkedList.addLast(400);
        linkedList.addLast(300);
        linkedList.addLast(200);
        linkedList.addLast(100);//跟add一样,都是往后加
        linkedList.getFirst();//获取第一个元素
        linkedList.getLast();//获取最后一个元素
        linkedList.removeFirst();//移除最后一个
        linkedList.removeLast();//...
    }
}

package Clooection集合.Collection接口.Collection各个实现类.LinkedList实现类;

import java.util.LinkedList;

public class Test1 {
    public static void main(String[] args) {
//         E poll()
//          获取并移除此列表的头（第一个元素）
// E pollFirst()
//          获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
// E pollLast()
//          获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。见名知意,后面可以自己试试
        LinkedList linkedList = new LinkedList();
        linkedList.add(100);
        linkedList.add(200);
        linkedList.add(300);
        linkedList.add(400);
        linkedList.add(500);
        Object poll = linkedList.poll();//获取并且删除掉集合中的第一个元素
        System.out.println(poll);//获取了第一个元素
        System.out.println(linkedList);
        Object poll1 = linkedList.poll();
        System.out.println(poll);
        System.out.println(linkedList);//可以一直删,当删完了,集合中没有元素了,则返回null

    }
}

package Clooection集合.Collection接口.Collection各个实现类.LinkedList实现类;

import java.util.LinkedList;

public class Test2 {
    public static void main(String[] args) {
//         E pop()
//          从此列表所表示的堆栈处弹出一个元素。
// void push(E e)
//          将元素推入此列表所表示的堆栈。
        LinkedList linkedList = new LinkedList();
        linkedList.add(100);
        linkedList.add(200);
        linkedList.add(300);
        linkedList.add(400);
        linkedList.add(500);
        Object pop = linkedList.pop();//其实就是表示删除该集合的第一个元素,并且返回值表示删除的元素,跟poll一样,集合中
//        没元素了继续删的话返回null
        System.out.println(pop);
        System.out.println(linkedList);
        linkedList.push(600);//其实就是表示将元素加在元素的第一个的位置上
        linkedList.push(700);//跟一个类里面的addFirst一样,这些不需要去硬记.有个大概印象就行,到时候能打出来就打
//        打不出来就用普通方法就行
        System.out.println(linkedList);


    }
}