【Java】【基础篇】day14：集合（ArrayList，LinkedList，HashSet）

前言

本期任务：毕向东老师Java视频教程学习笔记（共计25天）

• 原视频链接：黑马程序员_毕向东_Java基础视频教程
• day01：编写HelloWorld程序
• day02：操作符与条件选择语句
• day03：循环语句与函数
• day04：数组
• day07：继承、抽象类与接口
• day08：多态
• day09：异常处理
• day11：多线程
• day12：线程安全与同步机制
• day13：String类
• day14：集合（ArrayList，LinkedList，HashSet）
• day15：集合（TreeSet）和泛型）
• day16：集合（HashMap、TreeMap）
• day17：集合框架的工具类（Arrays、Collections）
• day18：IO流（字符流读写）
• day19：IO流（字节流、转换流读写）
• day20：IO流（File对象）

---

代码

/*
Collection定义了集合框架的共性功能。
1，添加
	add(e);
	addAll(collection);

2，删除
	remove(e);
	removeAll(collection);
	clear();

3，判断。
	contains(e);
	isEmpty();

4，获取
	iterator();
	size();

5，获取交集。
	retainAll();

6，集合变数组。
	toArray();



1，add方法的参数类型是Object。以便于接收任意类型对象。

2，集合中存储的都是对象的引用(地址)


什么是迭代器呢？
其实就是集合的取出元素的方式。
如同抓娃娃游戏机中的夹子。

迭代器是取出方式，会直接访问集合中的元素。
所以将迭代器通过内部类的形式来进行描述。
通过容器的iterator()方法获取该内部类的对象。




*/

import java.util.*;

public class CollectionDemo {
    public static void main(String[] args) {
//        method_get();
        method_get1();
    }

    public static void method_get(){
        ArrayList a1 = new ArrayList();

        // 1.添加元素
        a1.add("java1");
        a1.add("java2");
        a1.add("java3");
        a1.add("java4");

        // 获取迭代器，用于取出集合中的元素


        Iterator it = a1.iterator();

        // 写法1
        while (it.hasNext()){
            System.out.println(it.next());
        }

        //写法2
        for (; it.hasNext();)
        {
            System.out.println(it.next());
        }

    }

    public static void method_get1(){
        ArrayList a1 = new ArrayList();
        // 1.添加元素
        a1.add("java2");
        a1.add("java2");
        a1.add("java3");
        a1.add("java4");

        // 打印原集合
        System.out.println(a1);

        // 删除元素
        a1.remove("java2");
        System.out.println(a1);
//        a1.clear();
//        System.out.println(a1);

        // 判断元素
        System.out.println("java3是否存在："+a1.contains("java3"));
        System.out.println("集合是否为空："+a1.isEmpty());

        // 获取元素个数
        System.out.println("size："+ a1.size());


        ArrayList a2 = new ArrayList();
        a2.add("java5");
        a2.add("java6");
        a2.add("java7");
        a2.add("java2");

        // 取交集，a1中只会保留与a12中不同的元素
        a1.retainAll(a2);
        System.out.println(a1);

        // 去交集，a1中只会保留与a12中不同的元素
        a1.removeAll(a2);
        System.out.println(a1);

    }
}

import java.util.*;

/*
去除ArrayList集合中的重复元素。

*/

public class ArrayListTest {

    public static void main(String[] args) {

        ArrayList al = new ArrayList();
        al.add("java1");
        al.add("java1");
        al.add("java2");
        al.add("java3");

        System.out.println(al);
        System.out.println(singleElements(al));

    }

    public static ArrayList singleElements(ArrayList al) {
        // 定义一个临时容器
        ArrayList newAl = new ArrayList();

        for (Iterator it = al.iterator(); it.hasNext(); ) {
            Object obj = it.next();
            if (newAl.contains(obj)) {
                continue;
            } else {
                newAl.add(obj);
            }
        }
        return newAl;

    }

}

import java.util.*;

/*
将自定义对象作为元素存到ArrayList集合中，并去除重复元素。

比如：存人对象。同姓名同年龄，视为同一个人。为重复元素。


思路：
1，对人描述，将数据封装进人对象。
2，定义容器，将人存入。
3，取出。



List集合判断元素是否相同，依据是元素的equals方法。



*/

class Person {
    private int age;
    private String name;

    Person(int age, String name) {
        this.age = age;
        this.name = name;
    }

    // 自定义的类，需要重写equals函数，使得对象可比较
    public boolean equals(Object obj) {
        if (!(obj instanceof Person)) {
            return false;
        }
        Person p = (Person) obj; // obj当前为object类型，所以需要强制类型转换
        return p.age == this.age && p.name.equals(this.name);
    }
}


public class ArrayListTest2 {

    public static void main(String[] args) {

        ArrayList al = new ArrayList();

        al.add(new Person(10, "张三"));
        al.add(new Person(10, "张三"));
        al.add(new Person(11, "李四"));
        al.add(new Person(12, "王五"));

        System.out.println(al);
        System.out.println(singleElements(al));

    }

    public static ArrayList singleElements(ArrayList al) {
        // 定义一个临时容器
        ArrayList newAl = new ArrayList();

        for (Iterator it = al.iterator(); it.hasNext(); ) {
            Object obj = it.next();
            if (newAl.contains(obj)) {
                continue;
            } else {
                newAl.add(obj);
            }
        }
        return newAl;

    }

}

/*
使用LinkedList模拟一个堆栈或者队列数据结构。

堆栈：先进后出  如同一个杯子。
队列：先进先出 First in First out  FIFO 如同一个水管。



*/

import java.util.*;

// 模拟实现栈
class Stack {
    private LinkedList ll;

    Stack() {
        ll = new LinkedList();
    }

    public void myAdd(Object obj) {
        ll.addLast(obj);
    }

    public Object myGet() {
        return ll.pollLast();
    }

    public boolean isNull() {
        return ll.isEmpty();
    }

}

// 模拟实现队列
class Queue {
    private LinkedList ll;

    Queue() {
        ll = new LinkedList();
    }

    public void myAdd(Object obj) {
        ll.addLast(obj);
    }

    public Object myGet() {
        return ll.pollFirst();
    }

    public boolean isNull() {
        return ll.isEmpty();
    }

}

public class LinkedListTest {
    public static void main(String[] args) {
//        Queue q = new Queue();
//        q.myAdd("张三");
//        q.myAdd("张三");
//        q.myAdd("李四");
//        q.myAdd("王五");
//
//        while (!(q.isNull())){
//            System.out.println(q.myGet());
//        }

        Stack s = new Stack();
        s.myAdd("张三");
        s.myAdd("张三");
        s.myAdd("李四");
        s.myAdd("王五");

        while (!(s.isNull())){
            System.out.println(s.myGet());
        }
    }
}

import java.util.*;

/*
枚举就是Vector特有的取出方式。
发现枚举和迭代器很像。
其实枚举和迭代是一样的。

因为枚举的名称以及方法的名称都过长。
所以被迭代器取代了。
枚举郁郁而终了。



*/

public class VectorDemo {

    public static void main(String[] args) {
        Vector v = new Vector();

        v.add("java1");
        v.add("java2");
        v.add("java3");
        v.add("java3");

        Enumeration en = v.elements();

        while (en.hasMoreElements()) {
            System.out.println(en.nextElement());
        }

    }
}

import java.util.*;

/*
往hashSet集合中存入自定对象
姓名和年龄相同为同一个人，重复元素。

需要重写equals和hashCode



*/


class Person1 {
    private int age;
    private String name;

    Person1(int age, String name) {
        this.age = age;
        this.name = name;
    }

    // 自定义的类，需要重写equals和hashCode函数，使得对象可比较
    public boolean equals(Object obj) {
        if (!(obj instanceof Person1)) {
            return false;
        }
        Person1 p = (Person1) obj; // obj当前为object类型，所以需要强制类型转换
        return p.age == this.age && p.name.equals(this.name);
    }

    public int hashCode() {
        return name.hashCode() + age * 47;

    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

}

public class HashSetTest {
    public static void main(String[] args) {
        HashSet hs = new HashSet();

        hs.add(new Person1(10, "张三"));
        hs.add(new Person1(11, "张三"));
        hs.add(new Person1(12, "李四"));
        hs.add(new Person1(13, "王五"));

        System.out.println(hs);

        for (Iterator it = hs.iterator(); it.hasNext(); ) {

            Person1 p = (Person1) it.next();
            System.out.println(p.getName() + "......" + p.getAge());
        }
    }
}