1.集合进阶
1.1. Collecton
1.1.1 集合知识回顾
集合类的特点:提供一种存储空间可变的存储模型,存储的数据容量可以随时发生改变
1.1.2 集合类体系结构
1.1.3 Collection 集合概述和使用
Collection集合概述
- 是单例集合的顶层接口,它表示一组对象,这些对象也称为Collection的元素
- JDK 不提供此接口的任何直接实现,它提供更具体的子接口(如Set和List)实现
创建Collection集合的对象
- 多态的方式
- 具体的实现类ArrayList
CollectionDemo01.java
package com.itheima_01;
import java.util.ArrayList;
import java.util.Collection;
/*
创建Collection集合的对象
多态的方式
ArrayList()
*/
public class CollectionDemo01 {
public static void main(String[] args) {
//创建Collection集合的对象
Collection<String> c = new ArrayList<String>();
//添加元素:boolean add(E e)
c.add("hello");
c.add("world");
c.add("java");
//输出集合对象
System.out.println(c);
}
}
1.1.4 Collection 集合常用方法
方法名 | 说明 |
---|---|
boolean add(E e) | 添加元素 |
boolean remove(Object o) | 从集合中移除指定的元素 |
void clear() | 清空集合中的元素 |
boolean contains(Object o) | 判断集合中是否存在指定的元素 |
boolean isEmpty() | 判断集合是否为空 |
int size() | 集合的长度,也就是集合中元素的个数 |
CollectionDemo02.java
package com.itheima_01;
import java.util.ArrayList;
import java.util.Collection;
/*
Collection集合常用方法:
boolean add(E e):添加元素
boolean remove(Object o):从集合中移除指定的元素
void clear():清空集合中的元素
boolean contains(Object o):判断集合中是否存在指定的元素
boolean isEmpty():判断集合是否为空
int size():集合的长度,也就是集合中元素的个数
Alt+7 打开一个窗口,能够看到类的所有信息
*/
public class CollectionDemo02 {
public static void main(String[] args) {
//创建集合对象
Collection<String> c = new ArrayList<String>();
//boolean add(E e):添加元素
// System.out.println(c.add("hello"));
// System.out.println(c.add("world"));
// System.out.println(c.add("world"));
c.add("hello");
c.add("world");
c.add("java");
//boolean remove(Object o):从集合中移除指定的元素
// System.out.println(c.remove("world"));
// System.out.println(c.remove("javaee"));
//void clear():清空集合中的元素
// c.clear();
//boolean contains(Object o):判断集合中是否存在指定的元素
// System.out.println(c.contains("world"));
// System.out.println(c.contains("javaee"));
//boolean isEmpty():判断集合是否为空
// System.out.println(c.isEmpty());
//int size():集合的长度,也就是集合中元素的个数
System.out.println(c.size());
//输出集合对象
System.out.println(c);
}
}
1.1.5 Collection 集合的遍历
Iterator:迭代器,集合的专用遍历方式
- Iterator iterator():返回此集合中元素的迭代器,通过集合的iterator()方法得到
- 迭代器是通过集合的iterator()方法得到的,所以我们说它是依赖于集合而存在的
Iterator中的常用方法
- E next():返回迭代中的下一个元素
- boolean hasNext():如果迭代具有更多元素,则返回 true
IteratorDemo.java
package com.itheima_02;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
Iterator:迭代器,集合的专用遍历方式
Iterator<E> iterator():返回此集合中元素的迭代器,通过集合的iterator()方法得到
迭代器是通过集合的iterator()方法得到的,所以我们说它是依赖于集合而存在的
Iterator中的常用方法
E next():返回迭代中的下一个元素
boolean hasNext():如果迭代具有更多元素,则返回 true
*/
public class IteratorDemo {
public static void main(String[] args) {
//创建集合对象
Collection<String> c = new ArrayList<String>();
//添加元素
c.add("hello");
c.add("world");
c.add("java");
//Iterator<E> iterator():返回此集合中元素的迭代器,通过集合的iterator()方法得到
Iterator<String> it = c.iterator();
/*
public Iterator<E> iterator() {
return new Itr();
}
private class Itr implements Iterator<E> {
...
}
*/
//E next():返回迭代中的下一个元素
/*
System.out.println(it.next());
System.out.println(it.next());
System.out.println(it.next());
System.out.println(it.next()); //NoSuchElementException:表示被请求的元素不存在
*/
//boolean hasNext():如果迭代具有更多元素,则返回 true
/*
if(it.hasNext()) {
System.out.println(it.next());
}
if(it.hasNext()) {
System.out.println(it.next());
}
if(it.hasNext()) {
System.out.println(it.next());
}
if(it.hasNext()) {
System.out.println(it.next());
}
*/
//用while循环改进判断
while (it.hasNext()) {
// System.out.println(it.next());
String s = it.next();
System.out.println(s);
}
}
}
1.1.6 集合的使用步骤
案例:Collection集合存储学生对象并遍历
- 需求:创建一个存储学生对象的集合,存储3个学生对象,使用程序实现在控制台遍历该集合
- 思路:
- 定义学生类
- 创建Collection集合对象
- 创建学生对象
- 把学生添加到集合
- 遍历集合(迭代器方式)
CollectionDemo.java
package com.itheima_03;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
需求:
创建一个存储学生对象的集合,存储3个学生对象,使用程序实现在控制台遍历该集合
思路:
1:定义学生类
2:创建Collection集合对象
3:创建学生对象
4:把学生添加到集合
5:遍历集合(迭代器方式)
*/
public class CollectionDemo {
public static void main(String[] args) {
//创建Collection集合对象
Collection<Student> c = new ArrayList<Student>();
//创建学生对象
Student s1 = new Student("林青霞", 30);
Student s2 = new Student("张曼玉", 35);
Student s3 = new Student("王祖贤", 33);
//把学生添加到集合
c.add(s1);
c.add(s2);
c.add(s3);
//遍历集合(迭代器方式)
Iterator<Student> it = c.iterator();
while (it.hasNext()) {
Student s = it.next();
System.out.println(s.getName() + "," + s.getAge());
}
}
}
Student.java
package com.itheima_03;
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
1.2. List
1.2.1 List集合概述和特点
List集合概述
- 有序集合(也称为序列),用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素,并搜索列表中的元素
- 与Set集合不同,列表通常允许重复的元素
List集合特点
-
有序:存储和取出的元素顺序一致
-
可重复:存储的元素可以重复
ListDemo01.java
package com.itheima_01;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/*
List集合特点
有序:存储和取出的元素顺序一致
可重复:存储的元素可以重复
*/
public class ListDemo01 {
public static void main(String[] args) {
//创建集合对象
List<String> list = new ArrayList<String>();
//添加元素
list.add("hello");
list.add("world");
list.add("java");
list.add("world");
//输出集合对象
// System.out.println(list);
//迭代器的方式遍历
Iterator<String> it = list.iterator();
while (it.hasNext()) {
String s = it.next();
System.out.println(s);
}
}
}
1.2.2 List集合特有方法
方法名 | 说明 |
---|---|
void add(int index,E element) | 在此集合中的指定位置插入指定的元素 |
E remove(int index) | 删除指定索引处的元素,返回被删除的元素 |
E set(int index,E element) | 修改指定索引处的元素,返回被修改的元素 |
E get(int index) | 返回指定索引处的元素 |
ListDemo02.java
package com.itheima_01;
import java.util.ArrayList;
import java.util.List;
/*
List集合特有方法:
void add(int index,E element):在此集合中的指定位置插入指定的元素
E remove(int index):删除指定索引处的元素,返回被删除的元素
E set(int index,E element):修改指定索引处的元素,返回被修改的元素
E get(int index):返回指定索引处的元素
*/
public class ListDemo02 {
public static void main(String[] args) {
//创建集合对象
List<String> list = new ArrayList<String>();
//添加元素
list.add("hello");
list.add("world");
list.add("java");
//void add(int index,E element):在此集合中的指定位置插入指定的元素
// list.add(1,"javaee");
//IndexOutOfBoundsException
// list.add(11,"javaee");
//E remove(int index):删除指定索引处的元素,返回被删除的元素
// System.out.println(list.remove(1));
//IndexOutOfBoundsException
// System.out.println(list.remove(11));
//E set(int index,E element):修改指定索引处的元素,返回被修改的元素
// System.out.println(list.set(1,"javaee"));
//IndexOutOfBoundsException
// System.out.println(list.set(11,"javaee"));
//E get(int index):返回指定索引处的元素
// System.out.println(list.get(1));
//IndexOutOfBoundsException
// System.out.println(list.get(11));
//输出集合对象
// System.out.println(list);
//遍历集合
// System.out.println(list.get(0));
// System.out.println(list.get(1));
// System.out.println(list.get(2));
//用for循环改进遍历
for (int i=0; i<list.size(); i++) {
String s = list.get(i);
System.out.println(s);
}
}
}
案例:List集合存储学生对象并遍历
- 需求:创建一个存储学生对象的集合,存储3个学生对象,使用程序实现在控制台遍历该集合
- 思路:
- 定义学生类
- 创建List集合对象
- 创建学生对象
- 把学生添加到集合
- 遍历集合(迭代器方式,for循环方式)
Student.java
package com.itheima_02;
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
ListDemo.java
package com.itheima_02;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/*
需求:
创建一个存储学生对象的集合,存储3个学生对象,使用程序实现在控制台遍历该集合
思路:
1:定义学生类
2:创建List集合对象
3:创建学生对象
4:把学生添加到集合
5:遍历集合(迭代器方式,for循环方式)
*/
public class ListDemo {
public static void main(String[] args) {
//创建List集合对象
List<Student> list = new ArrayList<Student>();
//创建学生对象
Student s1 = new Student("林青霞", 30);
Student s2 = new Student("张曼玉", 35);
Student s3 = new Student("王祖贤", 33);
//把学生添加到集合
list.add(s1);
list.add(s2);
list.add(s3);
//迭代器方式
Iterator<Student> it = list.iterator();
while (it.hasNext()) {
Student s = it.next();
System.out.println(s.getName() + "," + s.getAge());
}
System.out.println("--------");
//for循环方式
for(int i=0; i<list.size(); i++) {
Student s = list.get(i);
System.out.println(s.getName() + "," + s.getAge());
}
}
}
1.2.3 并发修改异常
并发修改异常
- ConcurrentModificationException
产生原因
- 迭代器遍历的过程中,通过集合对象修改了集合中的元素,造成了迭代器获取元素中判断预期修改值和实际修改值不一致
解决方案
- 用for循环遍历,然后用集合对象做对应的操作即可
ListDemo.java
package com.itheima_03;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/*
需求:
我有一个集合:List<String> list = new ArrayList<String>();
里面有三个元素:list.add("hello");list.add("world");list.add("java");
遍历集合,得到每一个元素,看有没有"world"这个元素,如果有,我就添加一个"javaee"元素,请写代码实现
ConcurrentModificationException:当不允许这样的修改时,可以通过检测到对象的并发修改的方法来抛出此异常
*/
public class ListDemo {
public static void main(String[] args) {
//创建集合对象
List<String> list = new ArrayList<String>();
//添加元素
list.add("hello");
list.add("world");
list.add("java");
//遍历集合,得到每一个元素,看有没有"world"这个元素,如果有,我就添加一个"javaee"元素,请写代码实现
// Iterator<String> it = list.iterator();
// while (it.hasNext()) {
// String s = it.next();
// if(s.equals("world")) {
// list.add("javaee");
// }
// }
for(int i=0; i<list.size(); i++) {
String s = list.get(i);
if(s.equals("world")) {
list.add("javaee");
}
}
//输出集合对象
System.out.println(list);
}
}
并发修改异常的源码分析.txt
public interface List<E> {
Iterator<E> iterator();
boolean add(E e);
}
public abstract class AbstractList<E> {
protected int modCount = 0;
}
public class ArrayList<E> extends AbstractList<E> implements List<E> {
public E get(int index) {
Objects.checkIndex(index, size);
return elementData(index);
}
public boolean add(E e) {
modCount++;
add(e, elementData, size);
return true;
}
public Iterator<E> iterator() {
return new Itr();
}
private class Itr implements Iterator<E> {
int expectedModCount = modCount;
/*
modCount:实际修改集合的次数
expectedModCount:预期修改集合的次数
*/
public E next() {
checkForComodification();
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
}
1.2.4 ListIterator
ListIterator:列表迭代器
- 通过List集合的listIterator()方法得到,所以说它是List集合特有的迭代器
- 用于允许程序员沿任一方向遍历列表的列表迭代器,在迭代期间修改列表,并获取列表中迭代器的当前位置
ListIterator中的常用方法
- E next():返回迭代中的下一个元素
- boolean hasNext():如果迭代具有更多元素,则返回 true
- E previous():返回列表中的上一个元素
- boolean hasPrevious():如果此列表迭代器在相反方向遍历列表时具有更多元素,则返回 true
- void add(E e):将指定的元素插入列表
ListIteratorDemo.java
package com.itheima_04;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
/*
ListIterator:列表迭代器
通过List集合的listIterator()方法得到,所以说它是List集合特有的迭代器
用于允许程序员沿任一方向遍历列表的列表的迭代器,在迭代期间修改列表,并获取列表中迭代器的当前位置
ListIterator中的常用方法
E next():返回迭代中的下一个元素
boolean hasNext():如果迭代具有更多元素,则返回 true
E previous():返回列表中的上一个元素
boolean hasPrevious():如果此列表迭代器在相反方向遍历列表时具有更多元素,则返回 true
void add(E e):将指定的元素插入列表
*/
public class ListIteratorDemo {
public static void main(String[] args) {
//创建集合对象
List<String> list = new ArrayList<String>();
//添加元素
list.add("hello");
list.add("world");
list.add("java");
//通过List集合的listIterator()方法得到
// ListIterator<String> lit = list.listIterator();
// while (lit.hasNext()) {
// String s = lit.next();
// System.out.println(s);
// }
// System.out.println("--------");
//
// while (lit.hasPrevious()) {
// String s = lit.previous();
// System.out.println(s);
// }
//获取列表迭代器
ListIterator<String> lit = list.listIterator();
while (lit.hasNext()) {
String s = lit.next();
if(s.equals("world")) {
lit.add("javaee");
}
}
System.out.println(list);
}
}
ListIterator源码分析.txt
public interface List<E> {
Iterator<E> iterator();
ListIterator<E> listIterator();
}
public abstract class AbstractList<E> {
protected int modCount = 0;
}
public class ArrayList<E> extends AbstractList<E> implements List<E> {
public Iterator<E> iterator() {
return new Itr();
}
private class Itr implements Iterator<E> {
...
}
public ListIterator<E> listIterator() {
return new ListItr(0);
}
private class ListItr extends Itr implements ListIterator<E> {
public void add(E e) {
checkForComodification();
try {
int i = cursor;
ArrayList.this.add(i, e);
cursor = i + 1;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
}
}
1.2.5 增强for循环
增强for:简化数组和Collection集合的遍历
- 实现Iterable接口的类允许其对象成为增强型 for语句的目标
- 它是JDK5之后出现的,其内部原理是一个Iterator迭代器
增强for的格式
格式:
for(元素数据类型 变量名 : 数组或者Collection集合) {
//在此处使用变量即可,该变量就是元素
}
范例:
int[] arr = {1, 2, 3, 4, 5};
for(int i : arr) {
System.out.println(i);
}
ForDemo.java
package com.itheima_05;
import java.util.ArrayList;
import java.util.List;
/*
增强for:简化数组和Collection集合的遍历
实现Iterable接口的类允许其对象成为增强型 for语句的目标
它是JDK5之后出现的,其内部原理是一个Iterator迭代器
格式:
for(元素数据类型 变量名 : 数组或者Collection集合) {
//在此处使用变量即可,该变量就是元素
}
*/
public class ForDemo {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
for(int i : arr) {
System.out.println(i);
}
System.out.println("--------");
String[] strArray = {"hello","world","java"};
for(String s : strArray) {
System.out.println(s);
}
System.out.println("--------");
List<String> list = new ArrayList<String>();
list.add("hello");
list.add("world");
list.add("java");
for(String s : list) {
System.out.println(s);
}
System.out.println("--------");
//内部原理是一个Iterator迭代器
/*
for(String s : list) {
if(s.equals("world")) {
list.add("javaee"); //ConcurrentModificationException
}
}
*/
}
}
案例:List集合存储学生对象用三种方式遍历
-
需求:创建一个存储学生对象的集合,存储3个学生对象,使用程序实现在控制台遍历该集合
-
思路:
- 定义学生类
- 创建List集合对象
- 创建学生对象
- 把学生添加到集合
- 遍历集合
迭代器:集合特有的遍历方式
普通for:带有索引的遍历方式
增强for:最方便的遍历方式
Student.java
package com.itheima_06;
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
ListDemo.java
package com.itheima_06;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/*
需求:
创建一个存储学生对象的集合,存储3个学生对象,使用程序实现在控制台遍历该集合
思路:
1:定义学生类
2:创建List集合对象
3:创建学生对象
4:把学生添加到集合
5:遍历集合
迭代器:集合特有的遍历方式
普通for:带有索引的遍历方式
增强for:最方便的遍历方式
*/
public class ListDemo {
public static void main(String[] args) {
//创建List集合对象
List<Student> list = new ArrayList<Student>();
//创建学生对象
Student s1 = new Student("林青霞", 30);
Student s2 = new Student("张曼玉", 35);
Student s3 = new Student("王祖贤", 33);
//把学生添加到集合
list.add(s1);
list.add(s2);
list.add(s3);
//迭代器:集合特有的遍历方式
Iterator<Student> it = list.iterator();
while (it.hasNext()) {
Student s = it.next();
System.out.println(s.getName()+","+s.getAge());
}
System.out.println("--------");
//普通for:带有索引的遍历方式
for(int i=0; i<list.size(); i++) {
Student s = list.get(i);
System.out.println(s.getName()+","+s.getAge());
}
System.out.println("--------");
//增强for:最方便的遍历方式
for(Student s : list) {
System.out.println(s.getName()+","+s.getAge());
}
}
}
1.2.6 数据结构
数据结构是计算机存储、组织数据的方式。是指相互之间存在一种或多种特定关系的数据元素的集合
通常情况下,精心选择的数据结构可以带来更高的运行或者存储效率
1.2.7 常见数据结构之栈
过程一
过程二
过程三
1.2.8 常见数据结构之队列
过程一
过程二
1.2.9 常见数据结构之数组
数组是一种查询快,增删慢的模型
查询数据通过索引定位,查询任意数据耗时相同,查询效率高
删除数据时,要将原始数据删除,同时后面每个数据前移,删除效率低
添加数据时,添加位置后的每个数据后移,再添加元素,添加效率极低
1.2.10 常见数据结构之链表
链表是一种增删快的模型*(对比数组)*
链表是一种查询慢的模型*(对比数组)*
1.2.11 List集合子类特点
List集合常用子类:ArrayList,LinkedList
- ArrayList:底层数据结构是数组,查询快,增删慢
- LinkedList:底层数据结构是链表,查询慢,增删快
练习:
分别使用ArrayList和LinkedList完成存储字符串并遍历
ListDemo.java
package com.itheima_07;
import java.util.ArrayList;
import java.util.LinkedList;
/*
List集合常用子类:ArrayList,LinkedList
ArrayList:底层数据结构是数组,查询快,增删慢
LinkedList:底层数据结构是链表,查询慢,增删快
练习:
分别使用ArrayList和LinkedList完成存储字符串并遍历
*/
public class ListDemo {
public static void main(String[] args) {
//创建集合对象
ArrayList<String> array = new ArrayList<String>();
array.add("hello");
array.add("world");
array.add("java");
//遍历
for (String s : array) {
System.out.println(s);
}
//剩下两种遍历方式大家补齐
System.out.println("--------");
LinkedList<String> linkedList = new LinkedList<String>();
linkedList.add("hello");
linkedList.add("world");
linkedList.add("java");
for(String s : linkedList) {
System.out.println(s);
}
//剩下两种遍历方式大家补齐
}
}
案例:ArrayList集合存储学生对象用三种方式遍历
- 需求:创建一个存储学生对象的集合,存储3个学生对象,使用程序实现在控制台遍历该集合
- 思路:
- 定义学生类
- 创建ArrayList集合对象
- 创建学生对象
- 把学生添加到集合
- 遍历集合
迭代器:集合特有的遍历方式
普通for:带有索引的遍历方式
增强for:最方便的遍历方式
Student.java
package com.itheima_08;
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
ArrayListDemo.java
package com.itheima_08;
import java.util.ArrayList;
import java.util.Iterator;
/*
需求:
创建一个存储学生对象的集合,存储3个学生对象,使用程序实现在控制台遍历该集合
思路:
1:定义学生类
2:创建ArrayList集合对象
3:创建学生对象
4:把学生添加到集合
5:遍历集合
迭代器:集合特有的遍历方式
普通for:带有索引的遍历方式
增强for:最方便的遍历方式
*/
public class ArrayListDemo {
public static void main(String[] args) {
//创建ArrayList集合对象
ArrayList<Student> array = new ArrayList<Student>();
//创建学生对象
Student s1 = new Student("林青霞", 30);
Student s2 = new Student("张曼玉", 35);
Student s3 = new Student("王祖贤", 33);
//把学生添加到集合
array.add(s1);
array.add(s2);
array.add(s3);
//迭代器:集合特有的遍历方式
Iterator<Student> it = array.iterator();
while (it.hasNext()) {
Student s = it.next();
System.out.println(s.getName() + "," + s.getAge());
}
System.out.println("--------");
//普通for:带有索引的遍历方式
for(int i=0; i<array.size(); i++) {
Student s = array.get(i);
System.out.println(s.getName() + "," + s.getAge());
}
System.out.println("--------");
//增强for:最方便的遍历方式
for(Student s : array) {
System.out.println(s.getName() + "," + s.getAge());
}
}
}
1.2.12 LinkedList集合的特有功能
方法名 | 说明 |
---|---|
public void addFirst(E e) | 在该列表开头插入指定的元素 |
public void addLast(E e) | 将指定的元素追加到此列表的末尾 |
public E getFirst() | 返回此列表中的第一个元素 |
public E getLast() | 返回此列表中的最后一个元素 |
public E removeFirst() | 从此列表中删除并返回第一个元素 |
public E removeLast() | 从此列表中删除并返回最后一个元素 |
LinkedListDemo.java
package com.itheima_09;
import java.util.LinkedList;
/*
LinkedList集合的特有功能:
public void addFirst(E e):在该列表开头插入指定的元素
public void addLast(E e):将指定的元素追加到此列表的末尾
public E getFirst():返回此列表中的第一个元素
public E getLast():返回此列表中的最后一个元素
public E removeFirst():从此列表中删除并返回第一个元素
public E removeLast():从此列表中删除并返回最后一个元素
*/
public class LinkedListDemo {
public static void main(String[] args) {
//创建集合对象
LinkedList<String> linkedList = new LinkedList<String>();
linkedList.add("hello");
linkedList.add("world");
linkedList.add("java");
// public void addFirst(E e):在该列表开头插入指定的元素
// public void addLast(E e):将指定的元素追加到此列表的末尾
// linkedList.addFirst("javase");
// linkedList.addLast("javaee");
// public E getFirst():返回此列表中的第一个元素
// public E getLast():返回此列表中的最后一个元素
// System.out.println(linkedList.getFirst());
// System.out.println(linkedList.getLast());
// public E removeFirst():从此列表中删除并返回第一个元素
// public E removeLast():从此列表中删除并返回最后一个元素
// System.out.println(linkedList.removeFirst());
// System.out.println(linkedList.removeLast());
System.out.println(linkedList);
}
}