java学习记录十四：Collection、List、泛型、数据结构
一、集合
一、解释
集合是java提供的一种容器,可以用来存储多个引用类型数据,基本类型需要包装成引用数据类型,才能存入集合。
二、集合和数字的区别
- 数组的长度是固定的。集合的长度是可变的。
- 集合存储的都是引用数据类型。如果想存储基本类型数据需要存储对应的包装类类型。
- 数组可以存储
三、单列集合
单列集合就是单个元素存储的，相当于没有键，与值对应，双列集合就是有键，有值。单列就是单个对象存从。
Collection：是单列集合类的根接口，用于存储一系列符合某种规则的元素，
一、collection集合
一、解释
collection集合是单列集合的顶层父接口，collection集合没有索引，不能遍历，但是sun公司有一个遍历器，可以遍历其中的数据。
它有两个重要的子接口,分别是
-
java.util.List:List的特点是元素有序、元素可重复,元素有索引 ;-
List接口的主要实现类有java.util.ArrayList和java.util.LinkedList， - ArrayList集合: 实现类,查询快,增删慢
- LinkedList集合: 实现类,查询慢,增删快
-
-
java.util.Set:Set的特点是元素不可重复,元素无索引。-
Set接口的主要实现类有java.util.HashSet和java.util.LinkedHashSet，java.util.TreeSet。 - LinkedHashSet集合:实现类,元素存取有序
- TreeSet集合:实现类,可以对集合中的元素进行排序
-
二、collection集合常用方法
1.把给定的对象添加到当前集合中
//public boolean add(E e)： 把给定的对象添加到当前集合中 。
// 创建Collection集合对象,限制集合中元素的类型为String
Collection<String> col = new ArrayList<>();
// 往col集合中添加元素
col.add("范冰冰");
col.add("李冰冰");
col.add("林心如");
col.add("赵薇");
System.out.println("col集合:"+col);// col集合:[范冰冰, 李冰冰, 林心如, 赵薇]
2.清空集合中所有的元素
//public void clear() :清空集合中所有的元素
// 创建Collection集合对象,限制集合中元素的类型为String
Collection<String> col = new ArrayList<>();
// 往col集合中添加元素
col.add("范冰冰");
col.add("李冰冰");
col.add("林心如");
col.add("赵薇");
System.out.println("col集合:"+col);// col集合:[范冰冰, 李冰冰, 林心如, 赵薇]
// 清空集合中所有的元素
col.clear();
System.out.println("col集合:"+col);// col集合:[]
3.把给定的对象在当前集合中删除
//public boolean remove(E e): 把给定的对象在当前集合中删除。
// 创建Collection集合对象,限制集合中元素的类型为String
Collection<String> col = new ArrayList<>();
// 往col集合中添加元素
col.add("范冰冰");
col.add("李冰冰");
col.add("林心如");
col.add("赵薇");
// 删除李冰冰这个元素
col.remove("李冰冰");
System.out.println("col集合:"+col);// col集合:[范冰冰, 林心如, 赵薇]
4.判断当前集合中是否包含给定的对象
//public boolean contains(Object obj): 判断当前集合中是否包含给定的对象
// 创建Collection集合对象,限制集合中元素的类型为String
Collection<String> col = new ArrayList<>();
// 往col集合中添加元素
col.add("范冰冰");
col.add("李冰冰");
col.add("林心如");
col.add("赵薇");
boolean res1 = col.contains("我");
System.out.println("res1:"+res1);// false
5.判断当前集合是否为空
//public boolean isEmpty(): 判断当前集合是否为空。
// 创建Collection集合对象,限制集合中元素的类型为String
Collection<String> col = new ArrayList<>();
// 往col集合中添加元素
col.add("范冰冰");
col.add("李冰冰");
col.add("林心如");
col.add("赵薇");
//判断当前集合是否为空。(判断集合中是否有元素)
boolean res3 = col.isEmpty();
System.out.println("res3:"+res3);// false
6.返回集合中元素的个数
//public int size(): 返回集合中元素的个数。
// 创建Collection集合对象,限制集合中元素的类型为String
Collection<String> col = new ArrayList<>();
// 往col集合中添加元素
col.add("范冰冰");
col.add("李冰冰");
col.add("林心如");
// 获取集合中元素的个数
System.out.println("集合中元素的个数:"+col.size());// 3
7.把集合中的元素，存储到数组中
//public Object[] toArray(): 把集合中的元素，存储到数组中
// 创建Collection集合对象,限制集合中元素的类型为String
Collection<String> col = new ArrayList<>();
// 往col集合中添加元素
col.add("范冰冰");
col.add("李冰冰");
col.add("林心如");
// 把集合中的元素，存储到数组中
Object[] arr = col.toArray();
System.out.println(Arrays.toString(arr));// [范冰冰, 李冰冰 林心如]
三、迭代器
一、解释
在程序开发中，经常需要遍历单列集合中的所有元素。针对这种需求，JDK专门提供了一个接口java.util.Iterator。
迭代：即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续再判断，如果还有就再取出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。
二、写法
//Collection集合提供了一个获取迭代器的方法：
//`public Iterator iterator(): 获取集合对应的迭代器，用来遍历集合中的元素的。
// Iterator接口的常用方法
//public E next():返回迭代的下一个元素。
//public boolean hasNext():有元素可以迭代，则返回 true。
Collection<String> col = new ArrayList<>();
// 往col集合中添加元素
col.add("范冰冰");
col.add("李冰冰");
col.add("林心如");
col.add("赵薇");
// 获取迭代器对象
Iterator<String> it = col.iterator();
// 循环判断集合中是否有元素可以迭代
while (it.hasNext()){
// 说明有元素可以迭代
String e = it.next();
System.out.println(e);
}
三、迭代器的注意事项
- 在进行集合元素获取时，如果集合中已经没有元素可以迭代了，还继续使用迭代器的next方法，将会抛出java.util.NoSuchElementException没有集合元素异常。如果还想继续迭代集合，需要重新获取一个迭代器
- 在进行集合元素迭代时，如果添加或移除集合中的元素 , 将无法继续迭代 , 将会抛出ConcurrentModificationException并发修改异常，但是删除可以解决，不用集合的删除方法，而是使用迭代器的删除方法就可以删除元素。添加暂无法解决。
// 创建Collection集合对象,限制集合中元素的类型为String
Collection<String> col = new ArrayList<>();
// 往col集合中添加元素
col.add("范冰冰");
col.add("李冰冰");
col.add("林心如");
col.add("赵薇");
// 获取集合的迭代器对象
Iterator<String> it = col.iterator();
// 循环判断集合中是否有元素可以迭代
while (it.hasNext()) {
// 获取可以迭代的元素
String e = it.next();
System.out.println(e);
// 添加元素到集合中
//col.add("高圆圆");// 报异常
// 删除元素
//col.remove(e);// 报异常
// 如果迭代出来的元素是李冰冰,就删除
if (e.equals("李冰冰")){
it.remove();
}
}
四、迭代器原理
当遍历集合时，首先通过调用t集合的iterator()方法获得迭代器对象，然后使用hashNext()方法判断集合中是否存在下一个元素，如果存在，则调用next()方法将元素取出，否则说明已到达了集合末尾，停止遍历元素。
Iterator迭代器对象在遍历集合时，内部采用指针的方式来跟踪集合中的元素。在调用Iterator的next方法之前，迭代器的索引位于第一个元素之前，不指向任何元素，当第一次调用迭代器的next方法后，迭代器的索引会向后移动一位，指向第一个元素并将该元素返回，当再次调用next方法时，迭代器的索引会指向第二个元素并将该元素返回，依此类推，直到hasNext方法返回false，表示到达了集合的末尾，终止对元素的遍历。
四、增强for循环
一、解释
增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。
二、写法
/*for(元素的数据类型 变量 : Collection集合or数组){
//写操作代码
}*/
// 创建Collection集合对象,限制集合中元素的类型为String
Collection<String> col = new ArrayList<>();
// 往col集合中添加元素
col.add("范冰冰");
col.add("李冰冰");
col.add("林心如");
col.add("赵薇");
// 增强for循环遍历
for (String e : col) {
System.out.println(e);
}
String[] arr = {"范冰冰","李冰冰","林心如", "赵薇"};
for (String e : arr){
System.out.println(e);
}
// 增强for循环快捷键: 数组名\集合名.for
三、使用注意点
-
增强for循环必须有被遍历的目标，目标只能是Collection或者是数组；
-
增强for（迭代器）仅仅作为遍历操作出现，不能对集合进行增删元素操作，否则抛出ConcurrentModificationException并发修改异常
五、泛型
一、解释
表示一种未知的数据类型,在使用的时候确定其具体的数据类型。泛型的作用是在创建对象时，将未知的类型确定具体的类型。当没有指定泛型时，默认类型为Object类型。
在创建集合的时候，<>里不写数据类型，可以什么都存，但是在取出来的时候，会出现转换异常。要是指定了类型，只能存储着一种数据了。这时候就需要泛型。在定义的时候，使用泛型，而在使用的时候确定其具体的类型。
二、定义和使用泛型的类写法
/*修饰符 class 类名<代表泛型的变量> { }
代表泛型的变量: 可以是任意字母 例如: T,E...
class ArrayList<E>{
public boolean add(E e){ }
public E get(int index){ }
....
}
当E确定后，方法的返回值，变量的类型就都确定了。即E是String，成员变量和方法的返回值和参数都是String了
相当于是一个模板。
*/
public class MyArrayList<E> {
//定义成员变量
E e;
int age;
String name;
//定义成员方法，不知道返回类型和参数类型，这时候泛型就当于一个占位。在使用的时候再确定。
public E method(E e){
return e;
}
}
//创建String类的集合
MyArrayList<String> list1 = new MyArrayList<>();
list.age = 10
list.name ="世界"
list1.e = "itheima";
String res1 = list1.method("itcast");
System.out.println("res1:"+res1);// itcast
//创建Integer类型的集合
MyArrayList<Integer> list2 = new MyArrayList<>();
list2.e = 100;
Integer res2 = list2.method(10);
System.out.println("res2:"+res2);// 10
三、定义和使用含有泛型的方法的写法
//修饰符 <代表泛型的变量> 返回值类型 方法名(参数){ }
//
// 定义含有泛型的方法
//要是类没有使用泛型，这里不能直接光写T，因为不是定义在泛型类中
public static <T> T method1(T t){
return t;
}
Integer i1 = method1(100);// 指定泛型的具体数据类型为Integer
System.out.println(i1);// 100
String s = method1("itheima");// 指定泛型的具体数据类型为String
System.out.println(s);// itheima
四、定义和使用含有泛型的接口的写法
//修饰符 interface接口名<代表泛型的变量> { }
public interface IA<E> {
public abstract void method1(E e);
public default E method2(E e){
return e;
}
}
五、实现含有泛型接口的写法
1、定义实现类时确定泛型的类型
// 通过实现类的方式确定接口泛型的具体数据类型
public class Imp1 implements IA<String> {
@Override
public void method1(String s) {
}
@Override
public String method2(String s) {
return null;
}
}
// 创建实现类对象的时候确定接口泛型的具体数据类型
Imp2<String> imp1 = new Imp2<>();
imp1.method1("itheima");
String s1 = imp1.method2("itcast");
System.out.println(s1);// itcast
2.始终不确定泛型的类型，直到创建对象时，确定泛型的类型
// 实现类实现接口的时候不确定接口泛型的具体数据类型,
// 而是创建实现类对象的时候确定接口泛型的具体数据类型
public class Imp2<E> implements IA<E> {
@Override
public void method1(E e) {
System.out.println("实现类 method1");
}
@Override
public E method2(E e) {
return e;
}
}
Imp2<Integer> imp2 = new Imp2<>();
imp2.method1(100);
Integer i = imp2.method2(100);
System.out.println(i);// 100
六、小结
泛型：定义的时候表示一种未知的数据类型,在使用的时候确定其具体的数据类型。
使用含有泛型的类: 创建该类对象的时候,指定泛型的具体数据类型
使用含有方向的方法: 调用该方法的时候,确定泛型的具体数据类型
使用含有泛型的接口:
1.创建实现类实现接口的时候,指定泛型的具体数据类型
2.创建实现类实现接口的时候,不知道泛型的具体数据类型,而是创建实现类对象的时候指定泛型的具体数据类型
六、泛型通配符
一、解释
不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。此时只能接受数据,不能往该集合中存储数据。
二、写法
public class Test {
public static void main(String[] args) {
// 关系:String继承Object,Integer继承Number,Number继承Objec
ArrayList<Object> list1 = new ArrayList<>();
ArrayList<String> list2 = new ArrayList<>();
ArrayList<Integer> list3 = new ArrayList<>();
ArrayList<Number> list4 = new ArrayList<>();
list2.add("itheima");
//method1(list1);
method1(list2);
//method1(list3);
//method1(list4);
//method2(list1);
method2(list2);
//method2(list3);
//method2(list4);
// 泛型没有多态
//ArrayList<Object> list = new ArrayList<String>();// 编译报错
}
// 定义一个方法,可以接收以上4个集合
public static void method1(ArrayList list){
Object obj = list.get(0);
list.add("jack");
System.out.println("obj:"+obj);// itheima
System.out.println("list:"+list);// [itheima, jack]
}
public static void method2(ArrayList<?> list){
Object obj = list.get(0);
//list.add("jack");// 编译报错，不能存储数据，但是可以获取数据
System.out.println("obj:"+obj);// itheima
System.out.println("list:"+list);// [itheima]
}
}
七、受限泛型
一、解释
之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限和下限。
二、写法
public class Test {
public static void main(String[] args) {
/*
通配符高级使用----受限泛型:
上限: <? extends 类名> 只能接收该类类型或者其子类类型
下限: <? super 类名> 只能接收该类类型或者其父类类型
*/
// 关系:String继承Object,Integer继承Number,Number继承Objec
ArrayList<Object> list1 = new ArrayList<>();
ArrayList<String> list2 = new ArrayList<>();
ArrayList<Integer> list3 = new ArrayList<>();
ArrayList<Number> list4 = new ArrayList<>();
method1(list1);
method1(list2);
method1(list3);
method1(list4);
//method2(list1);// 编译报错
//method2(list2);// 编译报错
method2(list3);
method2(list4);
method3(list1);
//method3(list2);// 编译报错
method3(list3);
method3(list4);
}
// 定义一个方法,只可以接收以上list3和list4集合
public static void method2(ArrayList<? extends Number> list){
}
// 定义一个方法,只可以接收以上list3和list4,list1集合
public static void method3(ArrayList<? super Integer> list){
}
// 定义一个方法,可以接收以上4个集合
public static void method1(ArrayList<?> list){
}
// 定义一个方法,可以接收以上4个集合
public static void method(ArrayList list){
}
}
八、数据结构
一、解释
数据结构 : 其实就是存储数据和表示数据的方式。常见的数据结构：堆栈、队列、数组、链表和红黑树。
二、堆栈结构
stack,又称堆栈，它是运算受限的线性表，其限制是仅允许在表的一端进行插入和删除操作，不允许在其他任何位置进行添加、查找、删除等操作。
特点：
- 先进后出（即，存进去的元素，要在后它后面的元素依次取出后，才能取出该元素）。例如，子弹压进弹夹，先压进去的子弹在下面，后压进去的子弹在上面，当开枪时，先弹出上面的子弹，然后才能弹出下面的子弹。
- 栈的入口、出口的都是栈的顶端位置。
- 压栈：就是存元素。即，把元素存储到栈的顶端位置，栈中已有元素依次向栈底方向移动一个位置。
- 弹栈：就是取元素。即，把栈的顶端位置元素取出，栈中已有元素依次向栈顶方向移动一个位置。
三、队列结构
queue,简称队，它同堆栈一样，也是一种运算受限的线性表，其限制是仅允许在表的一端进行插入，而在表的另一端进行取出并删除。
特点：
- 先进先出（即，存进去的元素，要在后它前面的元素依次取出后，才能取出该元素）。例如，小火车过山洞，车头先进去，车尾后进去；车头先出来，车尾后出来。
- 队列的入口、出口各占一侧
四、数组结构
Array,是有序的元素序列，数组是在内存中开辟一段连续的空间，并在此空间存放元素。就像是一排出租屋，有100个房间，从001到100每个房间都有固定编号，通过编号就可以快速找到租房子的人。
特点：
- 查找元素快：通过索引，可以快速访问指定位置的元素
- 增删元素慢
- 指定索引位置增加元素：需要创建一个新数组，将指定新元素存储在指定索引位置，再把原数组元素根据索引，复制到新数组对应索引的位置。
- 指定索引位置删除元素：需要创建一个新数组，把原数组元素根据索引，复制到新数组对应索引的位置，原数组中指定索引位置元素不复制到新数组中。
五、链表结构
linked list,由一系列结点node（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域，最后一个节点的指针域存储的是null。我们常说的链表结构有单向链表与双向链表。单列只有向下一个的指针域，双向链表一个节点有两个指针与，存储的两边的节点地址的指针域。
特点：
- 多个结点之间，通过地址进行连接。例如，多个人手拉手，每个人使用自己的右手拉住下个人的左手，依次类推，这样多个人就连在一起了。
- 查找元素慢：想查找某个元素，需要通过连接的节点，依次向后查找指定元素。
- 增删元素快：只需要修改链接下一个元素的地址值即可
六、树结构
特点：
- 每一个节点有零个或者多个子节点
- 没有父节点的节点称之为根节点，一个树最多有一个根节点。
- 每一个非根节点有且只有一个父节点
- 子节点可以超过2个。
| 名词 | 含义 |
|---|---|
| 节点 | 指树中的一个元素 |
| 节点的度 | 节点拥有的子树的个数，二叉树的度不大于2 |
| 叶子节点 | 度为0的节点，也称之为终端结点 |
| 高度 | 叶子结点的高度为1，叶子结点的父节点高度为2，以此类推，根节点的高度最高 |
| 层 | 根节点在第一层，以此类推 |
| 父节点 | 若一个节点含有子节点，则这个节点称之为其子节点的父节点 |
| 子节点 | 子节点是父节点的下一层节点 |
| 兄弟节点 | 拥有共同父节点的节点互称为兄弟节点 |
1、二叉树
解释：
如果树中的每个节点的子节点的个数不超过2，那么该树就是一个二叉树。
2.二叉查找树
特点：
- 左子树上所有的节点的值均小于等于他的根节点的值
- 右子树上所有的节点值均大于或者等于他的根节点的值
- 每一个子节点最多有两个子树
- 遍历获取元素的时候可以按照"左中右"的顺序进行遍历；这样去取出的数是从小到大的
- 获取元素时有前序：中左右，中序：左中右，后序：左右中，不同的方式取，取的顺序是不一样的。
- 注意：二叉查找树存在的问题：会出现"瘸子"的现象，影响查询效率
3.平衡二叉树
1.解释：
为了避免出现"瘸子"的现象，减少树的高度，提高我们的搜素效率，又存在一种树的结构：“平衡二叉树”
规则：它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。
2.旋转
在构建一棵平衡二叉树的过程中，当有新的节点要插入时，检查是否因插入后而破坏了树的平衡，如果是，则需要做旋转去改变树的结构。旋转是自动完成的。
3.左旋
左旋就是将节点的右支往左拉，右子节点变成父节点，并把晋升之后多余的左子节点出让给降级节点的右子节点
4.右旋
将节点的左支往右拉，左子节点变成了父节点，并把晋升之后多余的右子节点出让给降级节点的左子节点
5.左左
左左：只需要做一次右旋就变成了平衡二叉树。
6.左右
左右先做一次分支的左旋，再做一次树的右旋，才能变成平衡二叉树。
7.右右
右右：只需要做一次左旋就变成了平衡二叉树。
8.右左
先做一次分支的右旋，再做一次数的左旋，才能变成平衡二叉树。
4、红黑树
红黑树是一种自平衡的二叉查找树，是计算机科学中用到的一种数据结构，它是在1972年由Rudolf Bayer发明的，当时被称之为平衡二叉B树，后来，在1978年被Leoj.Guibas和Robert Sedgewick修改为如今的"红黑树"。它是一种特殊的二叉查找树，红黑树的每一个节点上都有存储位表示节点的颜色，可以是红或者黑；红黑树不是高度平衡的，它的平衡是通过"红黑树的特性"进行实现的；
红黑树的特性：
- 每一个节点或是红色的，或者是黑色的。
- 根节点必须是黑色
- 每个叶节点(Nil)是黑色的；（如果一个节点没有子节点或者父节点，则该节点相应的指针属性值为Nil，这些Nil视为叶节点）
- 如果某一个节点是红色，那么它的子节点必须是黑色(不能出现两个红色节点相连的情况)
- 对每一个节点，从该节点到其所有后代叶节点的简单路径上，均包含相同数目的黑色节点；
在进行元素插入的时候，和之前一样； 每一次插入完毕以后，使用黑色规则进行校验，如果不满足红黑规则，就需要通过变色，左旋和右旋来调整树，使其满足红黑规则；
- 红黑树的作用: 提高搜索效率
- 表示集合的类有很多,但是每个集合存储数据的的数据结构不同,所以每个集合有各自的特点,
- ArrayList集合: 查询快,增删慢 —>存储数据的数据结构是数组
- LinkedList集合: 查询慢,增删快—>存储数据的数据结构是链表
九、list接口
一、解释
java.util.List接口继承自Collection接口，是单列集合的一个重要分支，习惯性地会将实现了List接口的对象称为List集合。
二、特点
- 它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、22、33的顺序完成的）。
- 它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。
- 集合中可以有重复的元素。
- .ArrayList类，该类中的方法都是来自List中定义。是list接口的子类。
三、list接口常用方法
List作为Collection集合的子接口，不但继承了Collection接口中的全部方法，而且还增加了一些根据元素索引来操作集合的特有方法。怎么看是否是新增方法，看方法需不需要给索引，需要索引的方法是list新增的，Collection不可能有索引，因为它要给list和set提供方法，而set接口是没有索引的。
1.将指定的元素，添加到该集合中的指定位置上。
//public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。
// 创建list集合,限制集合中元素的类型为String类型
List<String> list = new ArrayList<>();
// 往集合中添加一些元素
list.add("王老师");
list.add("李老师");
System.out.println(list);// [王老师, 李老师]
// 在索引为1的位置添加张老师
list.add(1, "张老师");
System.out.println(list);// [王老师, 张老师，李老师]
//两个add是不同的方法
2.返回集合中指定位置的元素。
//public E get(int index):返回集合中指定位置的元素。
List<String> list = new ArrayList<>();
// 往集合中添加一些元素
list.add("王老师");
list.add("李老师");
System.out.println(list);// [王老师, 李老师]
// 在索引为1的位置添加张老师
list.add(1, "张老师");// [王老师, 张老师，李老师]
// 获取索引为1的元素
System.out.println("索引为1的元素:"+list.get(1));// 张老师
3.移除列表中指定位置的元素, 返回的是被移除的元素。
List<String> list = new ArrayList<>();
// 往集合中添加一些元素
list.add("王老师");
list.add("李老师");
System.out.println(list);// [王老师, 李老师]
// 在索引为1的位置添加张老师
list.add(1, "张老师");// [王老师, 张老师，李老师]
// 删除索引为1的老师
String removeE = list.remove(1);
System.out.println("被删除的元素:"+removeE);// 张老师
4.用指定元素替换集合中指定位置的元素,返回值的更新前的元素
//public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素
// 创建list集合,限制集合中元素的类型为String类型
List<String> list = new ArrayList<>();
// 往集合中添加一些元素
list.add("王老师");
list.add("李老师");
System.out.println(list);// [王老师, 李老师]
// 在索引为1的位置添加张老师
list.add(1, "张老师");// [王老师, 张老师，李老师]
// 把索引为0的元素替换为赵老师
String setE = list.set(0, "赵老师");
System.out.println("被替换的元素:"+setE);// 张老师
十一、list接口的实现类
一、ArrayList集合
java.util.ArrayList集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合。
二、LinkedList集合
java.util.LinkedList集合数据存储的结构是链表结构。方便元素添加、删除的集合。LinkedList是一个双向链表,LinkedList提供了大量首尾操作的方法。
public class Test {
public static void main(String[] args) {
/*
LinkedList集合特有的方法:
- public void addFirst(E e):将指定元素插入此列表的开头。
- public void addLast(E e):将指定元素添加到此列表的结尾。
- public E getFirst():返回此列表的第一个元素。
- public E getLast():返回此列表的最后一个元素。
- public E removeFirst():移除并返回此列表的第一个元素。
- public E removeLast():移除并返回此列表的最后一个元素。
- public E pop():从此列表所表示的堆栈处弹出一个元素。 removeFirst()
- public void push(E e):将元素推入此列表所表示的堆栈。addFirst()
*/
// 创建LinkedList集合,限制集合元素的类型为String类型
LinkedList<String> list = new LinkedList<>();
// 往集合中添加元素
list.add("蔡徐坤");
list.add("鹿晗");
list.add("吴亦凡");
System.out.println(list);// [蔡徐坤, 鹿晗, 吴亦凡]
// 在集合的首尾添加一个元素
list.addFirst("罗志祥");
list.addLast("陈冠希");
System.out.println(list);// [罗志祥, 蔡徐坤, 鹿晗, 吴亦凡, 陈冠希]
// 获取集合的首尾元素
String firstE = list.getFirst();
String lastE = list.getLast();
System.out.println("第一个元素是:"+firstE);// 罗志祥
System.out.println("最后一个元素是:"+lastE);// 陈冠希
// 删除首尾元素
String removeFirst = list.removeFirst();
String removeLast = list.removeLast();
System.out.println("被删除的第一个元素是:"+removeFirst);// 罗志祥
System.out.println("被删除的最后一个元素是:"+removeLast);// 陈冠希
System.out.println(list);// [蔡徐坤, 鹿晗, 吴亦凡]
// pop --->删除第一个元素
String popE = list.pop();
System.out.println("被删除的第一个元素是:"+popE);// 蔡徐坤
System.out.println(list);// [鹿晗, 吴亦凡]
// push --->添加一个元素在开头
list.push("蔡徐坤");
System.out.println(list); // [蔡徐坤, 鹿晗, 吴亦凡]
}
}