1.3.4 集合Collection,迭代器Iterator, for each结构, List集合, ArrayList, LinkedList, Stack, Queue

最新推荐文章于 2024-08-06 08:45:56 发布

CH_ENN

最新推荐文章于 2024-08-06 08:45:56 发布

阅读量226

点赞数

删除

本文链接：https://blog.csdn.net/chengh1993/article/details/108929119

版权

&&&&&总结&&&&&

1,集合的概述

集合的由来 , 两张图

2, Collection集合

常用的方法

3, Iterator接口

概念, 遍历集合, 常用的方法

4, for each 结构

是Java5新增的内容, 是迭代器的简化版

5, List 集合

概念, 常用实现类, 常用的方法

6, Queue集合

概念, 常用实现类, 常用的方法

14.2 Collection集合（重点）

14.2.1 基本概念

14.2.1 常用的方法（练熟、记住）

代码: Collection集合常用方法 add, addAll, contains, containsAll, retainAll, remove, removeAll, clear, size, isEmpty, equals, toArray, asList,

代码:用迭代器实现toString方法, 以及for each结构

14.5 List集合（重中之重）

14.5.1 基本概念

代码: LinkedList和ArrayList的比较

14.5.2 常用的方法

代码: LinkedList集合常用方法测试 add, get, indexOf, lastIndexOf, set, remove, subList

代码: Stack栈的常用方法 push, pop, peek,

14.6 Queue集合（重点）

14.6.1 基本概念

14.6.2 常用的方法

代码: 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); //出队后集合中元素是: []

    }
}

CH_ENN

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
1.3.4 集合Collection,迭代器Iterator, for each结构, List集合, ArrayList, LinkedList, Stack, Queue

&&&&&总结&&&&&1, 一维数组基本概念, 两种声明方式, 增删改查操作, 优缺点, 数组工具类2, 二维数组基本概念, 两种声明方式5 数组的概念和应用 5.1 一维数组5.1.1基本概念 • 当需要在Java程序中记录单个数据内容时，则声明一个变量即可。 • 当需要在Java程序中记录多个类型相同的数据内容时，则声明一个一维...
复制链接

扫一扫