集合--ArrayList类、Vector类、LinkedList类、List集合练习

ArrayList类

import java.util.Objects;
/*
      ArrayList类概述
      		底层数据结构是数组，查询快，增删慢
      		线程不安全，效率高
*/
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);
    }
}


/*
        使用ArrayList存储自定义对象并遍历
*/

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

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

        //创建5个学生对象
        Student s1 = new Student("范闲", 23);
        Student s2 = new Student("范思辙", 22);
        Student s3 = new Student("鸡腿菇凉", 20);
        Student s4 = new Student("范若若", 21);
        Student s5 = new Student("庆帝", 50);

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

        //遍历的第一种方式1：迭代器遍历
        //获取迭代器对象
        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()) {
            Student s = (Student) iterator.next();

            System.out.println(s.getName() + "---" + s.getAge());
        }
        System.out.println("============================================");

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

Vector类

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

/*
        Vector:
            底层数据结构是数组，查询快，增删慢
            线程安全的（被同步关键字synchronized修饰），
                  效率低（虽然是线程安全的，以后我们也不使用它，后面会说一个线程安全的类替代它）
            
       Vector特有的方法：
        public void addElement(Object obj)
            将元素添加到集合的末尾---效果和add()一样
        public Object elementAt(int index)
            返回指定索引处的组件-----效果和get(int index)
        public Enumeration elements()
            返回此向量的组件的枚举--效果与迭代器一样
*/
public class VectorDemo1 {
    public static void main(String[] args) {
        //创建Vector集合对象
        Vector vector = new Vector();

      
        //向集合中添加元素
        vector.addElement("hello");
            //效果和add()一样
        vector.add("world");
        vector.addElement("java");

      
        //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));
            //报错：下标越界异常3(下标索引)>=3(元素个数)
        //System.out.println(vector.elementAt(3));
            //效果和get(int index)
        //System.out.println(vector.get(0));

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

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

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

LinkedList类

import java.util.LinkedList;

/*
       LinkedList:
          底层数据结构为双链表，查询慢，增删快
          线程不安全的，效率高

        LinkedList特有的功能：
            1、添加功能：
                void addFirst(Object obj) 在该列表开头插入指定的元素。
                void addLast(Object obj) 将指定的元素追加到此列表的末尾。等同于add()方法
            2、获取功能：
                Object getFirst() 返回此列表中的第一个元素。
                Object getLast() 返回此列表中的最后一个元素。
            3、删除功能：
                Object removeFirst() 从此列表中删除并返回第一个元素。
                Object removeLast() 从此列表中删除并返回最后一个元素。
*/

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);
      
        //void addLast(Object obj) 将指定的元素追加到此列表的末尾。
        linkedList.addLast("Hbase");
        System.out.println(linkedList);

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

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

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

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

List集合练习

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

import java.util.AbstractCollection;
import java.util.ArrayList;
import java.util.Iterator;
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);
    }
}

/*
    去除集合中自定义对象的重复值(对象的成员变量值都相同,姓名和年龄相同)

    我们按照处理字符串的形式处理重复的自定义对象，发现结果并没有去重
    为什么呢？
        要想知道为什么，就得知道问题处在了哪一行代码
        经过简单的分析后，我们发现问题出现了在判断的时候出现了。
        因为只有当if里面是true的时候，才添加到新集合中，
        说明我们的代码一直都是true,换句话说，contains()方法并没有生效
        怎么改呢？要想知道怎么改，看一看contains内部是怎么实现的。

        底层调用的是元素的equals方法，又因为我们Student类没有重写equals方法
        调用的是父类Object类中的equals方法，比较的是地址值，所以contains()方法
            结果永远是false，就相当于if（！false）{.....}--if语句永远是true。所以
        产生了没有去重的效果。

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

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(list);

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

        ArrayList list2 = new ArrayList();

        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            Student s = (Student) iterator.next();
          //if()方法判断：如果新集合中不包含旧集合中的元素就进入循环         
            if(!list2.contains(s)){
              //观察源码发现contains()方法底层调用的==和equals()方法
              //由于原先我们并没有在Student类中重写equals()方法，所以比较的是地址值
              //观察源码后，我们发现contains()方法返回结果是一直是false，所以加上一个 ！就变成true。
              //所以进入if()语句体
                list2.add(s);
            }
        }

        System.out.println(list2);
    }
}

//-----------contains()方法源码-------------------

public boolean contains(Object o) {
    return indexOf(o) >= 0;//-1不大于0，所以contains()方法结果永远是false。
}

//The size of the ArrayList (the number of elements it contains).
private int size;

/**
 * The array buffer into which the elements of the ArrayList are stored.
 * The capacity of the ArrayList is the length of this array buffer. Any
 * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
 * will be expanded to DEFAULT_CAPACITY when the first element is added.
 */
transient Object[] elementData;

public int indexOf(Object o) {
    if (o == null) {//--o的地址值肯定不是null
        for (int i = 0; i < size; i++)
            if (elementData[i]==null)
                return i;
    } else {
        for (int i = 0; i < size; i++)
          //o为旧集合中的元素(Student)，而调用方法的是新集合
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;//--返回的是-1
}

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

/*
    请用LinkedList模拟栈数据结构的集合，并测试

    栈的特点：
        先进后出

    题目的真正意思是，自己写一个类，底层是LinkedList，调用自己写的方法实现栈数据结构
*/
public class LinkedListTest1 {
    public static void main(String[] args) {
        //创建集合
        LinkedList linkedList = new LinkedList();
//        linkedList.add("hello");
//        linkedList.add("world");
//        linkedList.add("java");
        linkedList.addFirst("hello");
        linkedList.addFirst("world");
        linkedList.addFirst("java");
        linkedList.addFirst("hadoop");

        System.out.println(linkedList);

        //遍历
        Iterator iterator = linkedList.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next);
        }

        //如果面试的时候，你按照上面的写法 0分
    }
}

//--------------------正确答案-----------------------------

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(){
      //如果用getFirst()方法获取的都是第一个元素
//        return linkedList.getFirst();
        return linkedList.removeFirst();
    }

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

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(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();
            String s = (String) o;
            System.out.println(s);
        }
    }
}

posted @ 2021-12-21 00:33 赤兔胭脂小吕布阅读(39) 评论(0) 收藏举报

刷新页面返回顶部

赤兔胭脂小吕布

天行健，君子以自强不息！

集合--ArrayList类、Vector类、LinkedList类、List集合练习

ArrayList类

Vector类

LinkedList类

List集合练习

公告