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