大数据Java基础DAY18——集合（ArrayList类，Vector类，LinkedList类）

16年义务教育

已于 2022-02-15 19:41:45 修改

阅读量674

点赞数 2

文章标签： java big data idea 大数据

于 2022-02-14 20:45:47 首次发布

本文链接：https://blog.csdn.net/qq_52400447/article/details/122918070

版权

ArrayList类概述及使用

ArrayList类概述

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

b.线程不安全，效率高

ArrayList案例

1.例：使用ArrayList存储字符串并遍历，并且去重。（不会遍历看 List接口或者 Collection接口）

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

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

        //添加元素
        list1.add("java");
        list1.add("hive");
        list1.add("hadoop");
        list1.add("spark");
        list1.add("java");
        list1.add("world");
        list1.add("hadoop");

        //创建新集合去保存去重的元素
        ArrayList list2=new ArrayList ();

        //获取迭代器对象遍历
        Iterator iterator = list1.iterator();
        while (iterator.hasNext()){
            //向下转型，获取元素
            String s=(String) iterator.next();  //这里直接合并，也可先获取每个元素 Object o =iterator.next(); 再转型

            //判断是否重复，list2不包含的元素添加到新集合
            if (!list2.contains(s)){
                list2.add(s);
            }
        }
        System.out.println(list1);
        System.out.println(list2);
    }
}

2.使用ArrayList存储自定义对象遍历并去重（学生类）

首先创建公共的学生类（不会的看面向对象封装）

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

    public Student() {} //无参勾造方法
    public Student(String name, int age) {  //有参构造方法
        this.name = name;
        this.age = age;
    }
      //get()方法
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
      //set()方法
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
     //toString重写
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

然后创建集合去重遍历

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

public class ArrayListTest2 {
    public static void main(String[] args) {
         //创建集合对象
        ArrayList list1=new ArrayList ();
        //创建学生对象
        Student s1 = new Student("java",20);
        Student s2 = new Student("hive",22);
        Student s3 = new Student("wr2324",24);
        Student s4 = new Student("we",25);
        Student s5 = new Student("java",20);
        Student s6 = new Student("we",22);

        //添加元素
        list1.add(s1);
        list1.add(s2);
        list1.add(s4);list1.add(s3); 
        list1.add(s5);
        list1.add(s6);

        //创建新的集合存储去重的元素
        ArrayList  list2 = new ArrayList ();

        //获取迭代器对象遍历
        Iterator iterator = list1.iterator();

        while (iterator.hasNext()){
            //向下转型
            Student s=(Student) iterator.next();
            //判断是否包含元素去重
            if (!list2.contains(s)){
                list2.add(s);
            }
        }
        System.out.println(list1);
        System.out.println(list2);
    }
}

但是这样，我们发现结果并没有去重，输出集合跟原来的集合一样。

因为contains底层调用的是equals方法，但是我们创建的Student类中没有重写equals方法，所以调用的是Object类中的equals方法，Object类中的equals方法比较的是地址值，每个学生对象的地址值都不一样，所以（！list2.contains(s)）永远是true，所以所有的元素都添加到了新集合中。

contains方法原码（仅了解就行）：

 public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }

    /**
     * Returns the index of the first occurrence of the specified element
     * in this list, or -1 if this list does not contain the element.
     * More formally, returns the lowest index <tt>i</tt> such that
     * <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>,
     * or -1 if there is no such index.
     */
    public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

所以解决方案就是去公共类（学生类）中重写equals方法。（快捷键Alt+Insert 选equals）

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

Vector类概述及使用

Vector类概述

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

b.线程安全，效率低

Vector类特有功能

public void addElement(E obj) 将元素添加到集合的末尾，效果跟add()一样

  //public void addElement(E obj) 将元素添加到集合的末尾
        vector.addElement("java");
        vector.add("java");
        vector.addElement("hive");

        System.out.println(vector);

public E elementAt(int index) 获取指定索引处的元素 get( int index)

//public E elementAt(int index) 获取指定索引处的元素
        System.out.println(vector);//原集合
        System.out.println(vector.elementAt(0));
        System.out.println(vector.get(1));
        System.out.println(vector.elementAt(2));

可以看出vector特有的获取和添加方法和add（）和get（）效果一样，相对还麻烦一点，不如就用add和get方法

public Enumeration elements() 返回此向量的元素的枚举（你可以把它看作迭代器，因为方法相似）

//public Enumeration elements() 返回此向量的元素的枚举
        Enumeration elements = vector.elements();

        while (elements.hasMoreElements()){
            //向下转型
            String s=(String) elements.nextElement();

            System.out.println(s+" 长度："+s.length());
        }

从这可以看出vector 类除了线程安全，没有什么特点，后面会有一个线程安全的类代替它。

LinkedList类概述及使用

LinkedList类概述

a.底层数据结构是链表，查询慢，增删快

b.线程不安全，效率高

LinkedList类特有功能

1.添加功能

public void addFirst(E e) 在元素的开头添加元素

public void addLast(E e) 在集合末尾添加元素，等同add（）方法

 //创建LinkedList 集合对象
        LinkedList linkedList = new LinkedList ();

        //向集合添加元素
        linkedList.add("java");
        linkedList.add("hive");
        linkedList.add("bigdata");
        linkedList.add("Collection");
        System.out.println(linkedList);

        //public void addFirst(E e)  在元素的开头添加元素
        linkedList.addFirst("hadoop");
        System.out.println(linkedList);

        //addLast(E e) 在集合末尾添加元素，等同add（）方法
        linkedList.addLast("Flink");
        System.out.println(linkedList);

2.获取功能

public E getFirst() 获取集合中的第一个元素

public E getLast() 获取集合中的最后一个元素

        System.out.println(linkedList);//原集合

        //public E getFirst()  获取集合中的第一个元素
        Object first = linkedList.getFirst();
        System.out.println(first);

        //public E getLast() 获取集合中的最后一个元素
        Object last = linkedList.getLast();
        System.out.println(last);

        System.out.println(linkedList);//获取不改变集合

3.修改功能

public E removeFirst() 从集合中删除第一个元素并返回

public E removeLast() 从集合中删除最后一个元素并返回

        System.out.println(linkedList);//原集合

        //public E removeFirst()  从集合中删除第一个元素并返回
        Object o1 = linkedList.removeFirst();
        System.out.println(o1);
        System.out.println(linkedList);

        //public E removeLast()  从集合中删除最后一个元素并返回
        Object o2 = linkedList.removeLast();
        System.out.println(o2);
        System.out.println(linkedList);

LinkedList练习

例：用LinkedList模拟栈数据结构的集合，并测试（栈：先进后出）

思路：自己创建一个集合类，底层是LinkedList，调用自己的方法实现栈数据结构

首先自己创建集合类

import java.util.LinkedList;

public class Stack {
    private LinkedList linkedList;

    public Stack() {
         linkedList = new LinkedList();  //创建集合对象
    }

    public void myAdd(Object object){    //创建自己的添加方法
        linkedList.addFirst(object);   //用linkedList.First()方法能保证后面添加的元素在第一个
    }

    public Object myGet(){        //创建自己的获取方法
        return linkedList.removeFirst();  //linkedList.removeFirst()方法一直获取返回的第一个元素并删除，这样就不会得到已经获取的元素
    }

    public boolean myIsEmpty(){   //创建判断集合是否为空的方法，因为自己的类没有办法去直接判断
        return  linkedList.isEmpty();     //集合为空返回true
    }
}

然后测试自己创建的类，调用自己创建的方法实现

public class LinkedListTest2 {
    public static void main(String[] args) {
        //创建自己创建的集合类的对象
        Stack stack=new Stack();

        //调用添加方法
        stack.myAdd("java");
        stack.myAdd("hive");
        stack.myAdd("hadoop");
        stack.myAdd("flink");

        //判断是否为空，否则自己创的myGet方法输出一个元素删除一个，元素删光了再输出会报错
        while(!stack.myIsEmpty()){
            Object o = stack.myGet(); //获取每一个元素
            System.out.println(o);
        }
    }
}

这样就实现了栈的先进后出。

下次说泛型，为了简化我都省略了。

16年义务教育

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
大数据Java基础DAY18——集合（ArrayList类，Vector类，LinkedList类）

ArrayList类概述及使用ArrayList类概述a.底层数据结构是数组，查询快，增删慢b.线程不安全，效率高ArrayList案例1.例：使用ArrayList存储字符串并遍历，并且去重。import java.util.ArrayList;import java.util.Iterator;public class ArrayListTest1 { public static void main(String[] args) { /
复制链接

扫一扫