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); } }