&&&&&总结&&&&&
1,集合的概述
集合的由来 , 两张图
2, Collection集合
常用的方法
3, Iterator接口
概念, 遍历集合, 常用的方法
4, for each 结构
是Java5新增的内容, 是迭代器的简化版
5, List 集合
概念, 常用实现类, 常用的方法
6, Queue集合
概念, 常用实现类, 常用的方法
目录
代码:用迭代器实现toString方法, 以及for each结构
代码: LinkedList集合常用方法测试 add, get, indexOf, lastIndexOf, set, remove, subList
代码: Stack栈的常用方法 push, pop, peek,
代码: Queue集合常用方法 offer, poll, peek
第十四章 集合类库(上)
14.1 集合的概述(重点)
14.1.1 集合的由来
当需要在Java程序中记录单个数据内容时,则声明一个变量。
当需要在Java程序中记录多个类型相同的数据内容时,声明一个一维数组。
当需要在Java程序中记录多个类型不同的数据内容时,则创建一个对象。
当需要在Java程序中记录多个类型相同的对象数据时,创建一个对象数组。
当需要在Java程序中记录多个类型不同的对象数据时,则准备一个集合。
14.1.2 集合的框架结构
Java中集合框架顶层框架是:java.util.Collection集合 和 java.util.Map集合。
其中Collection集合中存取元素的基本单位是:单个元素。
其中Map集合中存取元素的基本单位是:单对元素。
14.2 Collection集合(重点)
14.2.1 基本概念
java.util.Collection接口是List接口、Queue 接口以及Set接口的父接口,
因此该接口里定义的方法 既可用于操作List集合,也可用于操作Queue集合和Set集合。
14.2.1 常用的方法(练熟、记住)
代码: Collection集合常用方法 add, addAll, contains, containsAll, retainAll, remove, removeAll, clear, size, isEmpty, equals, toArray, asList,
package com.lagou.task14;
import java.util.*;
/**
* @author CH
* @date 2020/9/30 20:20
*/
public class CollectionTest {
public static void main(String[] args) {
//1.1//准备一个Collection集合并打印
//1.2//Collection c1 = new Collection(); //接口不能实例化,也就是不能创建对象
//接口类型的引用指向实现类的对象. 形成了多态
Collection c1 = new ArrayList();
// 自动调用toString方法, 调用ArrayList类中的toString方法, 默认打印格式为: [元素1, 元素2, ...]
System.out.println("集合中的元素有:" + c1); // [啥也没有]
System.out.println("-------------------------------------------");
//2.1//向集合中添加单个元素并打印
boolean b1 = c1.add(new String("one"));
System.out.println("b1 = " + b1); //true
System.out.println("集合中的元素有:" + c1); // [one]
b1 = c1.add(Integer.valueOf(2));
System.out.println("b1 = " + b1); //true
System.out.println("集合中的元素有:" + c1); // [one, 2]
b1 = c1.add(new Person("zhangfei",30));
System.out.println("b1 = " + b1); //true
//打印集合中的所有元素时,本质上就是打印集合中的每个对象, 也就是让每个对象调用对应类中的toString方法
System.out.println("集合中的元素有:" + c1); // [one, 2, Person{name='zhangfei', age=30}]
System.out.println("-------------------------------------------");
//3.1//向集合中添加多个元素并打印
Collection c2 = new ArrayList();
c2.add("three"); //常量池
c2.add(4); //自动装箱机制
System.out.println("c2 = " + c2); //c2 = [three, 4]
//将c2中的所有元素全部添加到集合c1中,也就是将c2集合中的元素一个一个依次添加到c1中
b1 = c1.addAll(c2);
System.out.println("b1 = " + b1); //b1 = true
System.out.println("c1 = " + c1); //c1 = [one, 2, Person{name='zhangfei', age=30}, three, 4]
//考点: 下面这种和上面有什么区别
//表示将集合c2整体看作一个元素添加到集合c1中
b1 = c1.add(c2);
System.out.println("b1 = " + b1); //b1 = true
System.out.println("c1 = " + c1); //c1 = [one, 2, Person{name='zhangfei', age=30}, three, 4, [three, 4]]
System.out.println("-------------------------------------------");
//4.1//判断集合中是否包含参数指定的单个元素
b1 = c1.contains(new String("one"));
System.out.println("b1 = " + b1); //true
b1 = c1.contains(new String("two"));
System.out.println("b1 = " + b1); //false
b1 = c1.contains(Integer.valueOf(2));
System.out.println("b1 = " + b1); //true
b1 = c1.contains(Integer.valueOf(3));
System.out.println("b1 = " + b1); //false
//contains方法的工作原理是: Objects.equals(o, e), 其中o代表contains方法的形参, e代表集合中的每个元素
//也就是contains的工作原理是, 拿着参数对象与集合中已有的元素依次进行比较, 比较的方式调用Objects中的equals方法
/*而Objects.equals工作原理是:
public static boolean equals(Object a, Object b) { 其中a代表Person对象, b代表集合中已有的对象
return (a == b) || (a != null && a.equals(b));
//元素包含的第一种方式: Person对象与集合中已有对象的地址相同
第二种方式: Person对象不为空, 则Person对象调用equals方法与集合中已有元素相等
}
*/
//当Person类中没有重写equals方法时, 则调用从Object类中继承下来的equals方法, 比较两个对象的地址
//当前, Person中未重写equals方法, 因此下面结果为false
//b1 = c1.contains(new Person("zhangfei",30));
//System.out.println("b1 = " + b1); // false
//当前, 已重写Person类中的equals方法, 故以下的结果为重写Person中equals方法后的结果
b1 = c1.contains(new Person("zhangfei",30));
System.out.println("b1 = " + b1); // false
System.out.println("------------------------------------------------------");
System.out.println("c1 = " + c1);
//c1 = [one, 2, Person{name='zhangfei', age=30}, three, 4, [three, 4]]
//5.1//判断当前集合中是否包含参数指定集合中的所有元素
Collection c3 = new ArrayList();
c3.add(4);
System.out.println("c3 = " + c3); //c3 = [4]
//判断集合c1中是否包含集合c3中的所有元素
b1 = c1.containsAll(c3);
System.out.println("b1 = " + b1); //b1 = true
c3.add("five");
System.out.println("c3 = " + c3); //c3 = [4, five]
//判断集合c1中是否包含集合c3中的所有元素,只有c3中所有元素都在c1中出现才会返回true
b1 = c1.containsAll(c3);
System.out.println("b1 = " + b1); //b1 = false
System.out.println("------------------------------------------------------");
//笔试考点
//判断集合c1中是否有c2中的所有元素
//c1 = [one, 2, Person{name='zhangfei', age=30}, three, 4, [three, 4]]
System.out.println("c2 = "+ c2); //c2 = [three, 4]
b1 = c1.containsAll(c2);
System.out.println("b1 = " + b1); //b1 = true
//判断集合c1中是否拥有集合c2这个整体为单位的元素
b1 = c1.contains(c2);
System.out.println("b1 = " + b1); //b1 = true
System.out.println("------------------------------------------------------");
//6.1//计算两个集合的交集并保留到当前集合中
System.out.println("c2 = " + c2);//c2 = [three, 4]
System.out.println("c3 = " + c3);//c3 = [4, five]
//让自己和自己取交集,还是自己,也就是当前集合中的元素没有改变
b1 = c2.retainAll(c2);
System.out.println("b1 = " + b1);//b1 = false 表示当前集合中的元素没有发生改变
System.out.println("c2 = " + c2);//c2 = [three, 4]
//计算集合c2和c3的交集并保留到集合c2中, 取代集合c2中原有的数值
b1 = c2.retainAll(c3);
System.out.println("b1 = " + b1);//true 当前集合中的元素发生了改变
System.out.println("c2 = " + c2);//c2 = [4]
System.out.println("c3 = " + c3);//c3 = [4, five]
System.out.println("-----------------------------------------------------");
//7.1//实现集合中单个元素和所有元素的删除操作
//c1 = [one, 2, Person{name='zhangfei', age=30}, three, 4, [three, 4]]
System.out.println("c1 = " + c1);
//删除参数指定的单个元素
b1 = c1.remove(1);
System.out.println("b1 = " + b1); //false
System.out.println("c1 = " + c1);
//c1 = [one, 2, Person{name='zhangfei', age=30}, three, 4, [4]]
b1 = c1.remove("one");
System.out.println("b1 = " + b1); //b1 = true
System.out.println("c1 = " + c1);
//c1 = [2, Person{name='zhangfei', age=30}, three, 4, [4]]
///remove方法的工作原理 : Objects.equals(o, e)
b1 = c1.remove(new Person("zhangfei", 30));
System.out.println("b1 = " + b1); //b1 = true
System.out.println("c1 = " + c1); //c1 = [2, three, 4, [4]]
System.out.println("--------------------------------------------");
//8.1//实现集合中所有元素的删除操作
System.out.println("c3 = " + c3); //c3 = [4, five]
System.out.println("c1 = " + c1); //c1 = [2, three, 4, [4]]
//从集合c1中删除集合c3的所有元素, 本质上就是一个一个元素进行删除, 有则删,无则不删
b1 = c1.removeAll(c3);
System.out.println("b1 = " + b1); //b1 = true
System.out.println("c1 = " + c1); //c1 = [2, three, [4]]
//笔试考点,删除整体对象c3
b1 = c1.remove(c3);
System.out.println("b1 = " + b1); //false
System.out.println("c1 = " + c1); //c1 = [2, three, [4]]
System.out.println("--------------------------------------------");
//9.1//实现集合中其他方法的测试 ctrl+n 可以直接搜索并打开类的源码, ctrl+F12可以搜索类中的方法
System.out.println("集合中的元素个数为: " + c1.size());
System.out.println(0 == c1.size()? "集合已经空了" : "集合还没有空");//集合还没有空
System.out.println(c1.isEmpty()? "集合已经空了" : "集合还没有空");//集合还没有空
//清空集合中的所有元素
c1.clear();
System.out.println("集合中的元素个数为: " + c1.size());
System.out.println(0 == c1.size()? "集合已经空了" : "集合还没有空");//集合已经空了
System.out.println(c1.isEmpty()? "集合已经空了" : "集合还没有空");//集合已经空了
//准备两个集合并判断是否相等
Collection c4 = new ArrayList();
c4.add(1);
c4.add(2);
System.out.println("c4 = " + c4); //c4 = [1, 2]
Collection c5 = new ArrayList();
c5.add(1);
c5.add(2);
System.out.println("c5 = " + c5); //c5 = [1, 2]
//判断是否相等
b1 = c4.equals(c5);
System.out.println("b1 = " + b1); //b1 = true
System.out.println("--------------------------------------------");
//10.1//实现集合和数组之间的转换 通常认为: 集合是用于取代数组的结构
//实现集合向数组类型的转换
Object[] objects = c5.toArray();
//打印数组中的所有元素
System.out.println("数组中的元素有: " + Arrays.toString(objects)); //数组中的元素有: [1, 2]
//实现数组类型到集合类型的转换
List objects1 = Arrays.asList(objects);
System.out.println("集合中的元素有:" + objects1); //集合中的元素有:[1, 2]
}
}
代码:Person类封装
package com.lagou.task14;
import java.util.Objects;
/**
* @author CH
* @date 2020/9/30 20:33
*/
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age &&
Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public Person() {
}
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;
}
}
14.3 Iterator接口(重点)
14.3.1 基本概念
java.util.Iterator接口主要用于描述迭代器对象,可以遍历Collection集合中的所有元素。
java.util.Collection接口继承Iterator接口,因此所有实现Collection接口的实现类都可以使用该迭 代器对象。
14.3.2 常用的方法
案例题目: 如何使用迭代器实现toString方法的打印效果?
14.4 for each循环(重点)
14.4.1 基本概念
Java5推出了增强型for循环语句,可以应用数组和集合的遍历。 是经典迭代的“简化版”。
14.4.2 语法格式
for(元素类型 变量名 : 数组/集合名称) {
循环体;
}
14.4.3 执行流程
不断地从数组/集合中取出一个元素赋值给变量名并执行循环体,直到取完所有元素为止。
代码:用迭代器实现toString方法, 以及for each结构
package com.lagou.task14;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
/**
* @author CH
* @date 2020/10/3 18:41
*/
public class CollectionPrintTest {
public static void main(String[] args) {
//1.1//准备一个Collection集合并放入元素后打印
Collection c1 = new ArrayList();
c1.add("one");
c1.add(2);
c1.add(new Person("zhangfei",30));
//遍历方式一: 自动调用toString方法, String类型的整体
System.out.println("c1 = " + c1); //c1 = [one, 2, Person{name='zhangfei', age=30}]
System.out.println("--------------------------------------------");
//2//遍历方式二 : 使用迭代器来遍历集合中的所有元素 更加灵活
//2.1//获取当前集合中的迭代器对象
Iterator iterator1 = c1.iterator(); //想象成获取到一个箭头
/*
//2.2//判断是否有元素可以访问
System.out.println(iterator1.hasNext()); //true
//2.3//取出一个元素并指向下一个
System.out.println("获取到的元素是: " + iterator1.next()); //one
System.out.println(iterator1.hasNext()); //true
System.out.println("获取到的元素是: " + iterator1.next()); //2
System.out.println(iterator1.hasNext()); //true
System.out.println("获取到的元素是: " + iterator1.next()); //Person{name='zhangfei', age=30}
System.out.println(iterator1.hasNext()); //false
//System.out.println("获取到的元素是: " + iterator1.next()); //编译OK, 运行发生 NoSuchElementException
*/
//2.4//
while(iterator1.hasNext()) {
System.out.println("获取到的元素是: " + iterator1.next());
}
System.out.println("-----------------------------------------------------------");
//由于上个循环已经使得迭代器走到最后,因此需要重置迭代器
iterator1 = c1.iterator();
//3.1//使用迭代器模拟toString方法的打印效果
StringBuilder stringBuilder = new StringBuilder("[");
while(iterator1.hasNext()) {
Object o = iterator1.next();
if(!iterator1.hasNext()) {
stringBuilder.append(o).append("]");
} else {
stringBuilder.append(o).append(",").append(" ");
}
}
System.out.println("c1 = " + stringBuilder);
//c1 = [one, 2, Person{name='zhangfei', age=30}]
System.out.println("-----------------------------------------------------------");
//4.1//不断获取集合中的元素并判断,当元素值为"one"时则删除该元素
iterator1 = c1.iterator();
while(iterator1.hasNext()) {
Object o = iterator1.next();
if("one".equals(o)) {
iterator1.remove();
//c1.remove(o); // ConcurrentModificationException 并发修改异常
}
}
System.out.println("删除后c1 = " + c1); //c1 = [2, Person{name='zhangfei', age=30}]
System.out.println("-----------------------------------------------------------");
//5.1//使用 for each 结构实现集合和数组中元素的遍历, 代码简单且方法灵活
// 由调试源码可知, 该方式确实是迭代器的简化版
for(Object o : c1) {
System.out.println("取出来的元素是: " + o);
}
int[] arr = new int[] {11, 22, 33, 44, 55};
for (int i : arr) {
System.out.println("i = " + i);
// i = 66; //修改局部变量i的数值,并不是修改数组中元素的数值
}
System.out.println("数组中的元素有: " + Arrays.toString(arr)); //数组中的元素有: [11, 22, 33, 44, 55]
}
}
14.5 List集合(重中之重)
14.5.1 基本概念
java.util.List集合是Collection集合的子集合,该集合中允许有重复的元素并且有先后放入次序。
该集合的主要实现类有:ArrayList类、LinkedList类、Stack类、Vector类。
其中ArrayList类的底层是采用动态数组进行数据管理的,支持下标访问,增删元素不方便。
其中LinkedList类的底层是采用双向链表进行数据管理的,访问不方便,增删元素方便。
可以认为ArrayList和LinkedList的方法在逻辑上完全一样,只是在性能上有一定的差别,ArrayList 更适合于 机访问而LinkedList更适合于插入和删除;在性能要求不是特别苛刻的情形下可以忽略这个差别。
代码: LinkedList和ArrayList的比较
package com.lagou.task14;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
/**
* @author CH
* @date 2020/10/4 13:57
*/
public class ListTest {
public static void main(String[] args) {
//1.1//声明一个List接口类型的引用指向, ArrayList类型的对象,形成了多态
//由源码可知, new对象时, 并没有申请数组的内存空间
List lt1 = new ArrayList();
//2.1//向集合中添加元素并打印
//由源码可知, 当调用add方法添加元素时, 会给数组申请长度为10的一位数组, 扩容原理为 原长度的1.5倍
lt1.add("one");
System.out.println("lt1 = " + lt1); //[one]
System.out.println("----------------------------------------------------");
//2.1//声明一个List接口类型的引用, 指向LinkedList类型的对象,形成了多态
List lt2 = new LinkedList();
lt2.add("one");
System.out.println("lt2 = " + lt2); //[one]
}
}
其中Stack类的底层是采用动态数组进行数据管理的,该类主要用于描述一种具有后进先出特征的 数据结构,叫做栈(last in first out LIFO)。
其中Vector类的底层是采用动态数组进行数据管理的,该类与ArrayList类相比属于线程安全的 类,效率比较低,以后开发中基本不用。
14.5.2 常用的方法
代码: LinkedList集合常用方法测试 add, get, indexOf, lastIndexOf, set, remove, subList
package com.lagou.task14;
import java.util.LinkedList;
import java.util.List;
/**
* @author CH
* @date 2020/10/4 17:15
*/
public class ListMethodTest {
public static void main(String[] args) {
//1.1//准备一个List集合并打印
List lt1 = new LinkedList();
System.out.println("lt1 = " + lt1); //[啥也没有]
System.out.println("----------------------------------------------");
//2.1//向集合中添加元素
//向集合中的开头位置添加元素
lt1.add(0,"one");
System.out.println("lt1 = " + lt1); //[one]
//向集合中的末位位置添加元素
lt1.add(1,3);
System.out.println("lt1 = " + lt1); //[one, 3]
//向集合的中间位置添加元素
lt1.add(1,"two");
System.out.println("lt1 = " + lt1); //[one, two, 3]
System.out.println("----------------------------------------------");
//3.1//根据参数指定的下标来获取元素
//String str1 = lt1.get(0); //报错 Required type:String Provided:Object
String str1 = (String)lt1.get(0); //需要强转
System.out.println("获取到的元素是: " + str1); // one
//注意: 获取元素并进行强制类型转换时,一定要慎重,因为容易发生类型转换异常
//String str2 = (String)lt1.get(2); //编译OK, 运行发生ClassCastException 类型转换异常
//System.out.println("获取到的元素是: " + str2);
System.out.println("----------------------------------------------");
//4.1//使用get方法获取集合中所有元素并打印
for(int i = 0; i < lt1.size(); i++) {
Object o = lt1.get(i);
System.out.println("获取到的元素是: " + o);
}
//拼接出来
StringBuilder sb1 = new StringBuilder("[");
for(int i = 0; i < lt1.size(); i++) {
//若取出的元素是最后一个元素,则拼接元素值和 ]
//否则拼接元素和逗号以及空格
if(lt1.size() - 1 == i) {
sb1.append(lt1.get(i)).append("]");
} else {
sb1.append(lt1.get(i)).append(", ");
}
}
System.out.println("sb1 = " + sb1);
System.out.println("----------------------------------------------");
//5.1//查找指定元素出现的索引位置
System.out.println("one第一次出现的索引位置为: " + lt1.indexOf("one")); //0
lt1.add("one");
System.out.println("lt1 = " + lt1); //lt1 = [one, two, 3, one]
System.out.println("one反向第一次出现的索引位置为: " + lt1.lastIndexOf("one")); //3
System.out.println("----------------------------------------------");
System.out.println("lt1 = " + lt1); //lt1 = [one, two, 3, one]
//6.1//实现集合中元素的修改
Integer t1 = (Integer) lt1.set(2,"three");
System.out.println("被修改的元素是: " + t1); //被修改的元素是: 3
System.out.println("修改后lt1 = " + lt1); //修改后lt1 = [one, two, three, one]
String str2 = (String)lt1.set(3,"four");
System.out.println("被修改的元素是: " + str2); //被修改的元素是: one
System.out.println("修改后lt1 = " + lt1); //修改后lt1 = [one, two, three, four]
System.out.println("----------------------------------------------");
//7.1//使用remove方法将集合中的所有元素删除
//for (int i = 0; i < lt1.size();) {
/*for (int i = lt1.size()-1; i >= 0; i--) {
//System.out.println("被删除的元素是: " + lt1.remove(0)); // one two three four
System.out.println("被删除的元素是: " + lt1.remove(lt1.size()-1)); // four three two one
}
System.out.println("最终集合中的元素有: " + lt1); //[啥也没有]
System.out.println("----------------------------------------------");
*/
//8.1//获取当前集合中的子集合, 也就是将集合中的一部分内容或取出来, 子集合和当前集合共用内存空间
//表示获取当前集合中下标从1开始到3之间的元素, 含1不含3
List lt2 = lt1.subList(1,3);
System.out.println("lt2 = " + lt2); //lt2 = [two, three]
//子集合和当前集合共用内存空间
//删除lt2中的元素的数值
str2 = (String) lt2.remove(0);
System.out.println("被删除的元素是: " + str2); //被删除的元素是: two
System.out.println("删除后lt2 = " + lt2); //删除后lt2 = [three]
System.out.println("删除后lt1 = " + lt1); //删除后lt1 = [one, three, four]
}
}
案例题目 准备一个Stack集合,将数据11、22、33、44、55依次入栈并打印,然后查看栈顶元素并打印, 然后将栈中所有数据依次出栈并打印。
再准备一个Stack对象,将数据从第一个栈中取出来放入第二个栈中,然后再从第二个栈中取出并 打印。
代码: Stack栈的常用方法 push, pop, peek,
package com.lagou.task14;
import java.util.Stack;
/**
* @author CH
* @date 2020/10/5 10:41
*/
public class StackTest {
public static void main(String[] args) {
//1.1//准备一个Stack类型的对象并打印
Stack st1 = new Stack();
Stack st2 = new Stack();
System.out.println("st1 = " + st1); //st1 = []
System.out.println("st2 = " + st2); //st2 = []
System.out.println("-------------------------------------------");
//2.1//将数据11,22,33,44,55依次入栈并打印
for(int i = 1; i <= 5; i++) {
Object o = st1.push(11 * i);
System.out.println("入栈的元素是: " + o); // 11,22,33,44,55
System.out.println("栈中的元素有: " + st1); // [11, 22, 33, 44, 55]
}
System.out.println("-------------------------------------------");
//3.1//查看栈顶元素值并打印
System.out.println("当前栈顶元素为: " + st1.peek()); // 55
System.out.println("-------------------------------------------");
//4.1//对st1栈中所有元素依次出栈并打印, 出栈元素放入另一个栈st2中, 再从st2中依次取出并打印
int size = st1.size();
for(int i = 0; i < size; i++) {
/*Object o = st1.pop();
System.out.println("st1当前出栈元素为: " + o);
Object o1 = st2.push(o);
System.out.println("st2当前入栈元素为: " + o1);*/
Object o = st2.push(st1.pop());
System.out.println("st1出栈并入栈st2的元素是: " + o); //55,44,33,22,11
}
System.out.println();
for(int i = 0; i < size; i++) {
Object o = st2.pop();
System.out.println("st2当前出栈元素为: " + o); // 11,22,33,44,55
}
/*for(int i = st1.size(); i > 0; i--) {
Object o = st1.pop();
System.out.println("当前出栈元素为: " + o);
}*/
//5.1//最终打印栈中的所有元素
System.out.println("出栈后st1 = " + st1);
System.out.println("出栈后st2 = " + st2);
}
}
14.6 Queue集合(重点)
14.6.1 基本概念
java.util.Queue集合是Collection集合的子集合,与List集合属于平级关系。
该集合的主要用于描述具有先进先出特征的数据结构,叫做队列(first in first out FIFO)。
该集合的主要实现类是LinkedList类,因为该类在增删方面比较有优势。
14.6.2 常用的方法
案例题目 准备一个Queue集合,将数据11、22、33、44、55依次入队并打印,然后查看队首元素并打印, 然后将队列中所有数据依次出队并打印。
代码: Queue集合常用方法 offer, poll, peek
package com.lagou.task14;
import java.util.LinkedList;
import java.util.Queue;
/**
* @author CH
* @date 2020/10/5 11:22
*/
public class QueueTest {
public static void main(String[] args) {
//1.1//准备一个Queue集合并打印
Queue q1 = new LinkedList();
System.out.println("-------------------------------------------");
//2.1//将数据11,22,33,44,55依次入队并打印
for(int i = 1; i <= 5; i++) {
boolean b1 = q1.offer(11 * i);
//System.out.println("b1 = " + b1); //true true true true true
System.out.println("当前队中元素有: " + q1); //当前队中元素有: [11, 22, 33, 44, 55]
}
System.out.println("-------------------------------------------");
//3.1//查看队首元素并打印
System.out.println("当前队首元素是: " + q1.peek()); //11
System.out.println("-------------------------------------------");
//4.1//依次出队并打印
int size = q1.size();
for (int i = 0; i < size; i++) {
System.out.println("当前出队元素是: " + q1.poll()); //11 22 33 44 55
}
System.out.println("-------------------------------------------");
//5.1//查看队列中的最终元素
System.out.println("出队后集合中元素是: " + q1); //出队后集合中元素是: []
}
}