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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + ''' +
                ", age=" + age +
                '}';
    }
}

创建ArrayList测试类：

package com.hjl.test.day23;



import java.util.ArrayList;
import java.util.Iterator;

/*
   使用ArrayList存储自定义对象并遍历
 */
public class ArrayListDemo01 {
    public static void main(String[] args) {
        //创建ArrayList集合对象
        ArrayList arrayList = new ArrayList();

        //创建学生对象
        Student s1 = new Student("刘德华", 23);
        Student s2 = new Student("张学友", 22);
        Student s3 = new Student("郭富城", 23);
        Student s4 = new Student("彭于晏", 24);
        Student s5 = new Student("周杰伦", 25);

        //将学生对象添加到集合中
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        arrayList.add(s4);
        arrayList.add(s5);

        //遍历的第一种方式：迭代器遍历
        //获取迭代器对象
        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()){
            Student s = (Student) iterator.next();
            System.out.println(s.getName() + "---" +s.getAge());
        }

        System.out.println("================================");

        //遍历的第二种方式：get()和size()方法结合
        for (int i = 0;i < arrayList.size();i++){
            Student student = (Student) arrayList.get(i);
            System.out.println(student.getName() + "---" + student.getAge());
        }

    }
}

输出结果：

刘德华---23
张学友---22
郭富城---23
彭于晏---24
周杰伦---25
================================
刘德华---23
张学友---22
郭富城---23
彭于晏---24
周杰伦---25

LinkedList

查看API文档我们知道：

public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, Serializable
双链表实现了List和Deque接口。实现所有可选列表操作，并允许所有元素（包括null ）。

所有的操作都能像双向列表一样预期。索引到列表中的操作将从开始或结束遍历列表，以更接近指定的索引为准。

请注意，此实现不同步。 如果多个线程同时访问链接列表，并且至少有一个线程在结构上修改列表，则必须在外部进行同步。（结构修改是添加或删除一个或多个元素的任何操作;仅设置元素的值不是结构修改。）这通常通过在自然封装列表的对象上进行同步来实现。如果没有这样的对象存在，列表应该使用Collections.synchronizedList方法“包装”。这最好在创建时完成，以防止意外的不同步访问列表：
  List list = Collections.synchronizedList(new LinkedList(...)); 
这个类的iterator和listIterator方法返回的迭代器是故障快速的 ：如果列表在迭代器创建之后的任何时间被结构化地修改，除了通过迭代器自己的remove或add方法之外，迭代器将会抛出一个ConcurrentModificationException 。因此，面对并发修改，迭代器将快速而干净地失败，而不是在未来未确定的时间冒着任意的非确定性行为。

请注意，迭代器的故障快速行为无法保证，因为一般来说，在不同步并发修改的情况下，无法做出任何硬性保证。失败快速迭代器尽力投入ConcurrentModificationException 。因此，编写依赖于此异常的程序的正确性将是错误的：迭代器的故障快速行为应仅用于检测错误。

底层数据结构为链表所以具有查询慢，增删快，线程不安全，效率高的特点

LinkedList特有的功能

添加功能

void addFirst(Object obj)

查看API文档我们知道：

public void addFirst(E e)
在该列表开头插入指定的元素。

Specified by:

addFirst在接口 Deque<E>

参数

e - 要添加的元素

参考代码：

import java.util.LinkedList;

public class LinkedListDemo1 {
    public static void main(String[] args) {
        //创建LinkedList对象
        LinkedList linkedList = new LinkedList();

        //添加元素到集合中
        linkedList.add("hello");
        linkedList.add("world");
        linkedList.add("java");
        linkedList.add("hadoop");
        linkedList.add("hive");
        linkedList.add("spark");

        System.out.println(linkedList);
        System.out.println("================================================");

        //void addFirst(Object obj) 在该列表开头插入指定的元素。
        linkedList.addFirst("flink");
        System.out.println(linkedList);
    }
}

输出结果：

[hello, world, java, hadoop, hive, spark]
================================================
[flink, hello, world, java, hadoop, hive, spark]

从输出结果上可以看出void addFirst(Object obj)就是在该列表开头插入指定的元素。

void addLast(Object obj)

查看API文档我们知道：

public void addLast(E e)
将指定的元素追加到此列表的末尾。

这个方法相当于add(E) 。

Specified by:

addLast在接口 Deque<E>

参数

e - 要添加的元素

参考代码：

import java.util.LinkedList;

public class LinkedListDemo1 {
    public static void main(String[] args) {
        //创建LinkedList对象
        LinkedList linkedList = new LinkedList();

        //添加元素到集合中
        linkedList.add("hello");
        linkedList.add("world");
        linkedList.add("java");
        linkedList.add("hadoop");
        linkedList.add("hive");
        linkedList.add("spark");

        System.out.println(linkedList);
        System.out.println("================================================");

        //void addLast(Object obj) 将指定的元素追加到此列表的末尾。
        linkedList.addLast("hdfs");
        System.out.println(linkedList);

    }
}

输出结果：

[hello, world, java, hadoop, hive, spark]
================================================
[hello, world, java, hadoop, hive, spark, hdfs]

从输出结果来看void addList(Object obj)就是将指定的元素追加到此列表的末尾。

获取功能

Object getFirst()

查看API文档我们知道:

public E getFirst()
返回此列表中的第一个元素。

Specified by:

getFirst在接口 Deque<E>

结果

这个列表中的第一个元素

异常

NoSuchElementException - 如果此列表为空

参考代码：

import java.util.LinkedList;

public class LinkedListDemo1 {
    public static void main(String[] args) {
        //创建LinkedList对象
        LinkedList linkedList = new LinkedList();

        //添加元素到集合中
        linkedList.add("hello");
        linkedList.add("world");
        linkedList.add("java");
        linkedList.add("hadoop");
        linkedList.add("hive");
        linkedList.add("spark");

        System.out.println(linkedList);
        System.out.println("================================================");

        //Object getFirst() 返回此列表中的第一个元素。
        Object first = linkedList.getFirst();
        System.out.println(first);
        System.out.println(linkedList);

    }
}

输出结果：

[hello, world, java, hadoop, hive, spark]
================================================
hello
[hello, world, java, hadoop, hive, spark]

从输出结果上可以看出Obje getFirst()就是返回此列表中的第一个元素。

Object getLast()

查看API文档我们知道：

public E getLast()
返回此列表中的最后一个元素。

Specified by:

getLast在接口 Deque<E>

结果

这个列表中的最后一个元素

异常

NoSuchElementException - 如果此列表为空

参考代码：

import java.util.LinkedList;

public class LinkedListDemo1 {
    public static void main(String[] args) {
        //创建LinkedList对象
        LinkedList linkedList = new LinkedList();

        //添加元素到集合中
        linkedList.add("hello");
        linkedList.add("world");
        linkedList.add("java");
        linkedList.add("hadoop");
        linkedList.add("hive");
        linkedList.add("spark");

        System.out.println(linkedList);
        System.out.println("================================================");

        //Object getLast() 返回此列表中的最后一个元素。
        Object last = linkedList.getLast();
        System.out.println(last);
        System.out.println(linkedList);

    }
}

输出结果：

[hello, world, java, hadoop, hive, spark]
================================================
spark
[hello, world, java, hadoop, hive, spark]

从输出结果来看Object getList()就是从此列表中返回最后一个元素。

删除功能

Object removeFirst()

查看API文档我们知道：

public E removeFirst()
从此列表中删除并返回第一个元素。

Specified by:

removeFirst在接口 Deque<E>

结果

这个列表中的第一个元素

异常

NoSuchElementException - 如果此列表为空

参考代码：

import java.util.LinkedList;

public class LinkedListDemo1 {
    public static void main(String[] args) {
        //创建LinkedList对象
        LinkedList linkedList = new LinkedList();

        //添加元素到集合中
        linkedList.add("hello");
        linkedList.add("world");
        linkedList.add("java");
        linkedList.add("hadoop");
        linkedList.add("hive");
        linkedList.add("spark");

        System.out.println(linkedList);
        System.out.println("================================================");

        //Object removeFirst() 从此列表中删除并返回第一个元素。
        Object o = linkedList.removeFirst();
        System.out.println(o);
        System.out.println(linkedList);

    }
}

输出结果：

[hello, world, java, hadoop, hive, spark]
================================================
hello
[world, java, hadoop, hive, spark]

从输出结果可以看出Object removeFirst()就是从此列表中删除并返回第一个元素。

Object removeLast()

查看api文档我们知道：

public E removeLast()
从此列表中删除并返回最后一个元素。

Specified by:

removeLast在界面 Deque<E>

结果

这个列表中的最后一个元素

异常

NoSuchElementException - 如果此列表为空

参考代码：

import java.util.LinkedList;

public class LinkedListDemo1 {
    public static void main(String[] args) {
        //创建LinkedList对象
        LinkedList linkedList = new LinkedList();

        //添加元素到集合中
        linkedList.add("hello");
        linkedList.add("world");
        linkedList.add("java");
        linkedList.add("hadoop");
        linkedList.add("hive");
        linkedList.add("spark");

        System.out.println(linkedList);
        System.out.println("================================================");

        //Object removeLast() 从此列表中删除并返回最后一个元素。
        Object o = linkedList.removeLast();
        System.out.println(o);
        System.out.println(linkedList);

    }
}

输出结果：

[hello, world, java, hadoop, hive, spark]
================================================
spark
[hello, world, java, hadoop, hive]

从输出结果可以看出Object removeLast()就是从此列表中删除并返回最后一个元素。

Vector

查看API文档我们知道：

public class Vector<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, Serializable
Vector类实现了可扩展的对象数组。像数组一样，它包含可以使用整数索引访问的组件。但是， Vector的大小可以根据需要增长或缩小，以适应在创建Vector之后添加和删除项目。

每个向量尝试通过维护capacity和capacityIncrement优化存储capacityIncrement 。 capacity总是至少与矢量大小一样大; 通常较大，因为当向量中添加组分时，向量的存储空间大小capacityIncrement 。应用程序可以在插入大量组件之前增加向量的容量; 这减少了增量重新分配的数量。

The iterators returned by this class's个 iterator和listIterator方法是快速失败的 ：如果向量在任何时间从结构上修改创建迭代器之后，以任何方式除非通过迭代器自身remove种或add方法，迭代器都将抛出一个ConcurrentModificationException 。因此，面对并发修改，迭代器将快速而干净地失败，而不是在未来未确定的时间冒着任意的非确定性行为。由elements返回的Enumerations 不是故障快速的。

请注意，迭代器的故障快速行为无法保证，因为一般来说，在不同步并发修改的情况下，无法做出任何硬性保证。失败快速迭代器尽力投入ConcurrentModificationException 。因此，编写依赖于此异常的程序的正确性将是错误的：迭代器的故障快速行为应仅用于检测错误。

从Java 2平台v1.2，这个类被改造为实现List接口，使其成为成员Java Collections Framework 。与新集合实现不同， Vector是同步的。如果不需要线程安全的实现，建议使用ArrayList代替Vector 。

vector:底层数据结构是数组具有查询快、增删慢、线程安全、效率低的特点。（虽然是线程安全的，但是我们并不经常使用他，后面我们会讲一个线程安全的类代替它）

Vector特有的方法

public void addElement(Object obj)

查看API文档我们知道：

public void addElement(E obj)
将指定的组件添加到此向量的末尾，将其大小增加1。如果该载体的大小大于其容量，则该载体的容量增加。

该方法的功能与add(E)方法相同（它是List接口的一部分）。

参数

obj - 要添加的组件

参考代码：

import java.util.Vector;

public class VectorDemo1 {
    public static void main(String[] args) {
        //创建Vector集合对象
        Vector vector = new Vector();

        //向集合中添加元素
        vector.addElement("hello");
        vector.add("hadoop");
        vector.addElement("java");

        System.out.println(vector);
    }
}

输出结果：

[hello, hadoop, java]

从运行结果来看addElement()和add()的效果一样，是将元素添加到集合的末尾。

public Object elementAt(int index)

查看API文档我们知道：

public E elementAt(int index)
返回指定索引处的组件。

该方法的功能与get(int)方法相同（它是List接口的一部分）。

参数

index - 这个向量的索引

结果

指定索引处的组件

异常

ArrayIndexOutOfBoundsException - 如果索引超出范围（ index < 0 || index >= size() ）

返回指定索引处的组件和get(int index)效果相同

参考代码1：

import java.util.Vector;

public class VectorDemo1 {
    public static void main(String[] args) {
        //创建Vector集合对象
        Vector vector = new Vector();

        //向集合中添加元素
        vector.addElement("hello");
        vector.add("hadoop");
        vector.addElement("java");

        System.out.println(vector);

        System.out.println("===============================");

        //public Object elementAt(int index)
        Object o = vector.elementAt(0);
        System.out.println(o);
        System.out.println(vector.elementAt(1));
        System.out.println(vector.elementAt(2));

        System.out.println(vector.get(0));

    }
}

输出结果：

[hello, hadoop, java]
===============================
hello
hadoop
java
hello

从输出结果来看elementAt()效果和get()一样，如果我们不知道集合中有多少元素不小心取多了会发生什么呢？

参考代码2：

import java.util.Vector;

public class VectorDemo1 {
    public static void main(String[] args) {
        //创建Vector集合对象
        Vector vector = new Vector();

        //向集合中添加元素
        vector.addElement("hello");
        vector.add("hadoop");
        vector.addElement("java");

        System.out.println(vector);

        System.out.println("===============================");

        //public Object elementAt(int index)
        Object o = vector.elementAt(0);
        System.out.println(o);
        System.out.println(vector.elementAt(1));
        System.out.println(vector.elementAt(2));

        System.out.println(vector.get(0));

        System.out.println(vector.elementAt(3));

    }
}

运行结果：

ArrayIndexOutOfBoundsException 数组越界异常

public Enumeration elements()

查看API文档我们知道：

public Enumeration<E> elements()
返回此向量的组件的枚举。返回的Enumeration对象将生成此向量中的所有项。产生的第一项是在索引的项0 ，则在索引项1 ，依此类推。

结果

这个向量的组件的枚举

参考代码：

import java.util.Enumeration;
import java.util.Vector;

public class VectorDemo1 {
    public static void main(String[] args) {
        //创建Vector集合对象
        Vector vector = new Vector();

        //向集合中添加元素
        vector.addElement("hello");
        vector.add("hadoop");
        vector.addElement("java");

        System.out.println(vector);
        System.out.println("===============================");

        //public Enumeration elements()
        Enumeration elements = vector.elements();

        while (elements.hasMoreElements()){
            Object o = elements.nextElement();
            System.out.println(o);
        }

        System.out.println("===========================");
        System.out.println(vector);

    }
}

输出结果：

[hello, hadoop, java]
===============================
hello
hadoop
java
===========================
[hello, hadoop, java]

从运行结果上我们可以看出该方法就是返回此向量的组件的枚举。

接下来我们写几个案例来练习一下

案例1

需求：

现在有一个集合，集合中有些字符串的元素，我想判断一下里面有没有"bigdata"这个字符串如果有，我们就添加一个"yes"

解决方法一：迭代器遍历，迭代器修改

参考代码1：

import java.util.ArrayList;
import java.util.Iterator;

public class ListTestDemo1 {
    public static void main(String[] args) {
        //创建一个集合对象
        ArrayList list = new ArrayList();

        //添加元素到集合中
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("bigdata");
        list.add("hadoop");

        //获取迭代器对象
        Iterator iterator = list.iterator();

        while (iterator.hasNext()){
            String s = (String) iterator.next();
            if("bigdata".equals(s)){
                list.add("yes");
            }
        }
        System.out.println(list);
    }
}

运行结果：

用我们之前学的获取迭代器对象则出现了一个ConcurrentModificationException:并发修改异常，当不允许这样的修改时，可以通过检测到对象的并发修改的方法来抛出此异常。

原因：迭代器是依赖于集合存在的，在遍历迭代器元素的时候，当我们判断成功后，往集合中添加了一个元素，但是呢，迭代器这个时候并不知道已经添加了元素，所以就报错了。

简单的来说就是在迭代器遍历的时候不能通过集合去修改元素。

这个时候就要用到我们的迭代器遍历，迭代器修改和集合遍历，集合修改这两种方法去解决。

参考代码2：

import java.util.ArrayList;
import java.util.ListIterator;

public class ListTestDemo1 {
    public static void main(String[] args) {
        //创建一个集合对象
        ArrayList list = new ArrayList();

        //添加元素到集合中
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("bigdata");
        list.add("hadoop");

        //迭代器遍历，迭代器修改
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()){
            String s = (String) listIterator.next();
            if ("bigdata".equals(s)){
                //在迭代器元素"bigdata"后面添加
                listIterator.add("yes");
            }
        }

        System.out.println(list);
    }
}

输出结果：

[hello, world, java, bigdata, yes, hadoop]

在迭代器元素"bigdata"后面添加。

解决方法二：集合遍历，集合修改

参考代码3：

import java.util.ArrayList;

public class ListTestDemo1 {
    public static void main(String[] args) {
        //创建一个集合对象
        ArrayList list = new ArrayList();

        //添加元素到集合中
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("bigdata");
        list.add("hadoop");

        //集合遍历，集合修改
        for (int i = 0;i<list.size();i++){
            String s = (String) list.get(i);
            if ("bigdata".equals(s)){
                //在集合尾部添加
                list.add("yes");
            }
        }

        System.out.println(list);
    }
}

输出结果：

[hello, world, java, bigdata, hadoop, yes]

在集合尾部添加

案例2

需求：去除集合中字符串的重复值（字符串的内容相同）

参考代码：

import java.util.ArrayList;
import java.util.Iterator;

public class ArrayListTest1 {
    public static void main(String[] args) {
        //创建旧集合对象
        ArrayList list = new ArrayList();

        //向集合中添加字符串元素
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("hadoop");
        list.add("hive");
        list.add("hello");
        list.add("spark");
        list.add("java");

        System.out.println("去重之前的集合为：" + list);
        //创建一个新的集合保存去重后的元素
        ArrayList list2 = new ArrayList();

        //遍历旧集合
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            //向下转型
            String s = (String) iterator.next();

            //获取到元素后，拿到这个元素去新的集合里面去找，如果找到说明重复，如果没有找到，就添加到新集合中
            if (!list2.contains(s)){
                list2.add(s);
            }
        }
        System.out.println("去重后的集合为：" + list2);
    }
}

输出结果：

去重之前的集合为：[hello, world, java, hadoop, hive, hello, spark, java]
去重后的集合为：[hello, world, java, hadoop, hive, spark]

案例3

需求：去除集合中自定义对象的值（对象的成员变量值都相同，姓名和年龄相同）

参考代码1：

创建Student类：

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + ''' +
                ", age=" + age +
                '}'+ "n";
    }
}

测试类：

import java.util.ArrayList;
import java.util.Iterator;

public class ArrayListTest2 {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList list = new ArrayList();

        //创建学生对象
        Student s1 = new Student("刘德华", 18);
        Student s2 = new Student("张学友", 19);
        Student s3 = new Student("郭富城", 20);
        Student s4 = new Student("刘德华", 18);
        Student s5 = new Student("刘德华", 19);

        //向集合中添加元素
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);
        list.add(s5);

        System.out.println("去重之前的集合为：n" + list);

        System.out.println("==================================================");

        //创建新的集合对象
        ArrayList list2 = new ArrayList();
        //遍历旧的集合
        Iterator iterator = list.iterator();
        while (!iterator.hasNext()){
            //向下转型
            Student s = (Student) iterator.next();
            //判断重复的向新集合中添加
            if (list2.contains(s)){
                list2.add(s);
            }
        }

        System.out.println("去重后的集合为：n" + list2);

    }
}

输出结果：

去重之前的集合为：
[Student{name='刘德华', age=18}
, Student{name='张学友', age=19}
, Student{name='郭富城', age=20}
, Student{name='刘德华', age=18}
, Student{name='刘德华', age=19}
]
==================================================
去重后的集合为：
[]

通过运行结果发现，这并不是我们想要的结果，我们按照字符串的形式处理重复的自定义对象，发现结果并没有去重这是为什么呢？

查看原码分析:

经过查看原码的分析后，我们发现问题出现了在判断的时候出现了。因为只有当if里面是true的时候，才添加到新集合中，说明我们的代码一直都是true,换句话说，contains()方法并没有生效怎么改呢？要想知道怎么改，看一看contains内部是怎么实现的。底层调用的是元素的equals方法，又因为我们Student类没有重写equals方法调用的是父类Object类中的equals方法，比较的是地址值，所以contains() 结果永远是true，if判断永远判断的是新集合不包含，就添加到新集合中，所以产生了没有去重的效果。

解决办法：元素类重写equals()方法

在Student类中重写equals方法：

import java.util.Objects;

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + ''' +
                ", age=" + age +
                '}'+"n";
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }
}

用我们之前的测试类：

import java.util.ArrayList;
import java.util.Iterator;

public class ArrayListTest2 {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList list = new ArrayList();

        //创建学生对象
        Student s1 = new Student("刘德华", 18);
        Student s2 = new Student("张学友", 19);
        Student s3 = new Student("郭富城", 20);
        Student s4 = new Student("刘德华", 18);
        Student s5 = new Student("刘德华", 19);

        //向集合中添加元素
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);
        list.add(s5);

        System.out.println("去重之前的集合为：n" + list);

        System.out.println("==================================================");

        //创建新的集合对象
        ArrayList list2 = new ArrayList();
        //遍历旧的集合
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            //向下转型
            Student s = (Student) iterator.next();
            //判断重复的向新集合中添加
            if (!list2.contains(s)){
                list2.add(s);
            }
        }

        System.out.println("去重后的集合为：n" + list2);

    }
}

输出结果：

去重之前的集合为：
[Student{name='刘德华', age=18}
, Student{name='张学友', age=19}
, Student{name='郭富城', age=20}
, Student{name='刘德华', age=18}
, Student{name='刘德华', age=19}
]
==================================================
去重后的集合为：
[Student{name='刘德华', age=18}
, Student{name='张学友', age=19}
, Student{name='郭富城', age=20}
, Student{name='刘德华', age=19}
]

这样就达到我们想要的目的了，是不是很有意思呢？

案例4

面试题

需求：请用LinkedList模拟栈数据结构的集合，并测试

参考代码1：

import java.util.Iterator;
import java.util.LinkedList;

public class LinkedListTest2 {
    public static void main(String[] args) {
        //创建LinkedList集合
        LinkedList linkedList = new LinkedList();

        //使用addFirst向集合中添加元素
        linkedList.addFirst("hello");
        linkedList.addFirst("world");
        linkedList.addFirst("java");
        linkedList.addFirst("hadoop");

        System.out.println("入栈：n" + linkedList);

        System.out.println("=======================");

        //遍历集合
        Iterator iterator = linkedList.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            System.out.println("出栈：n" + next);
        }
        //如果面试的时候，你按照上面的写法 0分
    }
}

输出结果：

入栈：
[hadoop, java, world, hello]
=======================
出栈：
hadoop
出栈：
java
出栈：
world
出栈：
hello

如果面试的时候，按照上面的写法 0分！！！

题目真正的意思是，让我们自己写一个类，底层是LinkedList，调用自己写的方法实现栈数据结构！

参考代码：

创建MyStack类：

import java.util.LinkedList;

public class MyStack {
    private LinkedList linkedList;

    //自定义集合类
    MyStack(){
        linkedList = new LinkedList();
    }

    //进栈方法
    public void myAdd(Object object){
        linkedList.addFirst(object);
    }

    //出栈方法
    public Object myGet(){
        return linkedList.removeFirst();
    }

    //由于不知道集合元素有多少判断集合是否为空
    public boolean myIsEmpty(){
        return linkedList.isEmpty();
    }

    @Override
    public String toString() {
        return "MyStack{" +
                "linkedList=" + linkedList +
                '}';
    }
}

创建测试类MyStackTest：

public class MyStackTest {
    public static void main(String[] args) {
        //创建自己定义的集合类
        MyStack myStack = new MyStack();

        //添加元素(入栈)
        myStack.myAdd("hello");
        myStack.myAdd("world");
        myStack.myAdd("java");
        myStack.myAdd("bigdata");

        System.out.println("入栈：n" + myStack);

        //遍历
        System.out.println("出栈：");
        while (!myStack.myIsEmpty()){
            //向下转型
            String s = (String) myStack.myGet();
            System.out.println(s);
        }
    }
}

输出结果：

入栈：
MyStack{linkedList=[bigdata, java, world, hello]}
出栈：
bigdata
java
world
hello

这样我们就可以面试拿满分啦！

到底啦！给靓仔一个关注吧！

本图文内容来源于网友网络收集整理提供，作为学习参考使用，版权属于原作者。

THE END

java 后端开发语言集合

二维码

大数据和云计算

< <上一篇

云计算清览作业

下一篇>>

搜索内容

Java的集合框架—API文档深入研究3.0

1、使用ArrayList存储自定义对象并遍历

LinkedList

LinkedList特有的功能

添加功能

void addFirst(Object obj)

void addLast(Object obj)

获取功能

Object getFirst()

Object getLast()

删除功能

Object removeFirst()

Object removeLast()

Vector

Vector特有的方法

public void addElement(Object obj)

public Object elementAt(int index)

public Enumeration elements()

案例1

解决方法一：迭代器遍历，迭代器修改

解决方法二：集合遍历，集合修改

案例2

案例3

案例4

最新文章

分类

标签云