[大数据]【集合】ArrayList集合， LinkedList集合，Vector集合，测试自己定义集合类，底层是LinkedList

一.ArrayList集合

1. 需求：使用ArrayList存储字符串并遍历（如果字符串有重复的需要去除）

public class ArrayListDemo1 {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add("java");
        arrayList.add("hive");
        arrayList.add("hadoop");
        arrayList.add("spark");
        arrayList.add("mysql");
        arrayList.add("hive");
        arrayList.add("java");
        arrayList.add("hive");
        System.out.println("去重前的集合为："+arrayList);
      //创建一个新的集合存储去重后的集合
        ArrayList arrayList1 = new ArrayList();
        //用迭代器遍历旧的集合
        Iterator iterator = arrayList.iterator();
while (iterator.hasNext()){
    Object next = iterator.next();
    String s=(String) next;
    //获取到元素之后，拿着这个元素去新集合中查找，
    //如果找到说明重复，就不添加，反之添加到新集合中
    if (!arrayList1.contains(s)){
        arrayList1.add(s);

    }
}

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

2.使用ArrayList存储自定义对象并遍历（并去重）学生对象：姓名和年龄都一样的时候，表示是同一个人。

我们按照处理字符串重复的逻辑来处理自定义对象重复，发现结果并没有进行去重
为什么呢？
要想知道为什么，就得知道问题出现在了哪一行代码中。
经过简单地分析后发现，问题出现了在判断是否包含的那一行代码中
因为只有当if语句为true的时候，才会将元素添加到新集合中
说明我们这里判断，一直都是为true的，换句话contains这个方法并没有生效
要搞清楚为什么不会生效，就得搞清楚contains这个方法底层是怎么做的。

contains方法底层调用的是equals方法，但是呢，Student类中并没有重写equals方法
所以调用的是Object类中的equals方法，而Object类中的equals方法比较的是地址值，学生对象都是new出来的
地址值必然不一样，equals比较的结果永远是false，加上我们代码中的！,结果永远是为true，所以无论如何都会添加到
新集合中，最终结果没有去重。

解决方法：元素类重写equals()方法  自动生成即可

public class ArrayListDemo2 {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        Student1 s1=new Student1("小敏",20);
        Student1 s2=new Student1("龙",40);
        Student1 s3=new Student1("虎",60);
        Student1 s4=new Student1("蛇",100);
        Student1 s5=new Student1("猪",56);
        Student1 s6=new Student1("小敏",20);

        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        arrayList.add(s4);
        arrayList.add(s5);
        arrayList.add(s6);
        System.out.println("去重前的集合："+arrayList);
        ArrayList arrayList1 = new ArrayList();
        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            Student1 student1=(Student1) next;
            if (!arrayList1.contains(student1)){
                arrayList1.add(student1);
            }
        }

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

    }
}

学生类：重写equals方法

package com.shujia.wyh.day02.day18;

import java.util.Objects;

public class Student1 {
    private String name;
    private int age;

    public Student1(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 "Student1{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

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


}

结果：

去重前的集合：[Student1{name=‘小敏’, age=20}, Student1{name=‘龙’, age=40}, Student1{name=‘虎’, age=60}, Student1{name=‘蛇’, age=100}, Student1{name=‘小敏’, age=20}]

去重后的集合为：[Student1{name=‘小敏’, age=20}, Student1{name=‘龙’, age=40}, Student1{name=‘虎’, age=60}, Student1{name=‘蛇’, age=100}]

二. LinkedList集合

1.LinkedList的特点：

（1）、底层数据结构是双链表，查询慢，增删

（2）、线程是不安全的，效率高

2. LinkedList特有的方法：

1、添加功能：
public void addFirst(Object e) 在集合的开头添加元素
addLast(Object e) 在结合末尾添加元素，等同于add()方法
2、获取功能：
public Object getFirst() 获取集合中的第一个元素
getLast() 获取集合中的最后一个元素
3、删除功能：
public Object removeFirst() 从集合中删除第一个元素并返回
public Object removeLast() 从集合中删除最后一个元素并返回

public class LinkedListDemo1 {
    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();
        linkedList.add("hello");
        linkedList.add("world");
        linkedList.add("java");
        linkedList.add("bigdata");
        linkedList.add("hadoop");
        linkedList.add("hive");
        System.out.println(linkedList);
        System.out.println("===============================");
    //1、添加功能：public void addFirst(Object e) 在集合的
    //开头添加元素
       linkedList.addFirst("Hi");
        System.out.println(linkedList);
        //[Hi, hello, world, java, bigdata, hadoop, hive]

// 2. addLast(Object e) 在结合末尾添加元素，等同于add()方法
        linkedList.addLast("spark");
        System.out.println(linkedList);
        //[Hi, hello, world, java, bigdata, hadoop, hive, spark]


//3、获取功能:public Object getFirst() 获取集合中的第一个元素
        System.out.println(linkedList.getFirst());//Hi


  //4.getLast()  获取集合中的最后一个元素
    System.out.println(linkedList.getLast());//spark


 // 5、删除功能：public Object removeFirst()  从集合中删除
 //第一个元素并返回

   System.out.println(linkedList.removeFirst());
   //Hi 这是要删除的元素
        
System.out.println(linkedList);
//[hello, world, java, bigdata, hadoop, hive, spark]


 //6.public Object removeLast()   从集合中删除最后一个元素并返回
   System.out.println(linkedList.removeLast());//spark
   System.out.println(linkedList);
   //[hello, world, java, bigdata, hadoop, hive

    }
}

结果：

三.Vector集合

1.Vector的特点：

底层数据结构是数组，查询快，增删慢

线程安全，效率低(虽然它是线程安全的，我们今后也不会去使用它，后面会说一个线程安全的类代替它)

2.Vector特有的方法：

1.public void addElement(Object obj)
将元素添加到集合的末尾 效果上和add()一样
2. public Object elementAt(int index)
获取指定索引处的元素 get(int index)
3. public Enumeration elements()
返回此向量的组件的枚举。

public class VectorDemo1 {
    public static void main(String[] args) {
        //创建vector对象
        Vector vector = new Vector();
        //1.public void addElement(Object obj)
        //将元素添加到集合的末尾  效果上和add()一样
        vector.addElement("java");
        vector.addElement("hive");
        vector.addElement("mysql");
        vector.add("web");
  // 2.public Object elementAt(int index)获取指定索引处的
  //元素    get(int index)
       System.out.println(vector.elementAt(2));//mysql
        System.out.println(vector.get(2));//mysql

  //3. public Enumeration elements()返回此向量的组件的枚举。
        //简单记忆 你就把这个对象看作成一个迭代器
        Enumeration elements = vector.elements();
        while (elements.hasMoreElements()){
            Object o = elements.nextElement();
            String s=(String)o;
           System.out.println(s+"-------"+s.length());
        }
    }
}

结果：

四.例题

测试自己定义集合类，底层是LinkedList

分析： 题目真正的意思是，自己写一个集合类，底层是LinkedList,调用自己定义的方法实现栈数据结构
MyStackTest类：

/*
    测试自己定义集合类，底层是LinkedList
 */
//  题目真正的意思是，自己写一个集合类，底层是LinkedList,调用自
//己定义的方法实现栈数据结构
public class MyStackTest {
    public static void main(String[] args) {
        MyStack myStack = new MyStack();
        myStack.myAdd("java");
        myStack.myAdd("hive");
        myStack.myAdd("mysql");
        myStack.myAdd("web");
        //        System.out.println(myStack.myGet());
//        System.out.println(myStack.myGet());
//        System.out.println(myStack.myGet());
//        System.out.println(myStack.myGet());
//        System.out.println(myStack.myGet()); 
//NoSuchElementException
        //应该在获取元素之前判断集合中还有没有元素
        while (!myStack.myIsempty()){
            Object o = myStack.myGet();
            System.out.println(o);
        }
    }
}

自己定义的MyStack类：

import java.util.LinkedList;

public class MyStack {
    private LinkedList linkedList;
    //linkedList作为底层需要有一个linkedList的成员变量
    MyStack(){
         linkedList = new LinkedList();
 //将来调用方法时会会先执行构造方法，就已经创建了一个LinkedList
 //的对象，就可以在方法中直接调用LinkedList的方法，因此下面自定
 //义的方法就可以直接调用LinkedList的方法
// 需要new一个linkedList的对象将来才可以调用方法 注意这里需要
//用成员变量去接收


    }
    public void myAdd(Object obj){
        linkedList.addFirst(obj);
    }
    public Object myGet(){
        //  return linkedList.getFirst();
//注意这里不能用getFirst（）方法，否则运行结果就一直是第一个元素web，
//因此我们每得到一个元素就要把这个元素删除
        //而removeFirst（）方法就满意这个条件
        return linkedList.removeFirst();

    }
    public boolean myIsempty(){
        return linkedList.isEmpty();
    }
}

结果：与输入顺序相反满足了栈的要求