javase-collection-210408-01

javase-collection-210408-01

• 什么是集合
• 集合继承图
• Collection常用方法
• 集合遍历迭代
• contains方法

---

什么是集合

集合就是一个容器，数组就是一个集合，它可以来容纳其他类型的数据

集合不能直接存储基本类型的数据，另外集合也不能直接存储java对象，
集合当中存储的都是java对象的内存地址，或者说是集合中存储的引用
	注：集合在java中本身是一个容器，是一个对象，集合中任何时候储存的都是引用
	
在java中每一个不同的集合，底层会对应不同的数据结构。往不同的集合中存储元素，等于静啊数据放到了不同的数据结构当中。
数据存储的结构就是数据结构。不同的数据结构，数据存储方式也不同，例如：
	数组（ArrayList），链表（LinkedList），二叉树（TreeSet），哈希表
	
集合在 java.util.* 中

java中的集合分为两大类：
	1. 单个方式存储元素，这一类集合的超级父类接口：java.util.Collection
	
	2. 以键值对儿的方式存储元素，这一类集合的超级父类接口：java.util.Map

集合继承图

---

Collection常用方法

package com.bgy01;
/*
    java.util.Collection 中常用方法
        1. 在不使用“泛型”的前提下，Collection中可以存储Object的所有子类型
           使用“泛型”之后，Collection中只能存储某个具体的类型
           （集合中不能直接存储基本类型，也不能存储java对象，只是存储java对象的内存地址）

        2. Collection集合的常用方法
            boolean add(E e)
            int size()
            void clear()
            boolean contains(Object o)
            boolean remove(Object o)
            boolean isEmpty()
            Object[] toArray()
*/

import java.util.ArrayList;
import java.util.Collection;

public class Test01 {
    public static void main(String[] args) {
        // 多态的体现
        Collection c = new ArrayList();

        // 自动装箱，实际上是放进去了一个对象的内存地址。Integer x = new Integer(2021);
        c.add(2021);
        c.add(3.1415);  // 自动装箱
        c.add(new Object());
        c.add(new People());
        c.add(true);    // 自动装箱

        // 转换为数组
        Object[] objs = c.toArray();
        for (int i = 0; i < objs.length; i++) {
            // 遍历数组
            Object o = objs[i];
            System.out.println(o);
        }

        // 获取集合的个数
        System.out.println("集合中的元素个数是："+c.size());

        // 清空集合
        c.clear();
        System.out.println("集合中的元素个数是："+c.size());

        c.add("白光一");
        c.add("白小光");
        c.add("迪迦");
        c.add(1);
        // 判断集合中是否包含“白光一”
        boolean flag = c.contains("白光一");
        System.out.println(flag);

        // 删除集合中的某个元素
        c.remove("迪迦");
        c.remove(1);
        System.out.println(c);
        System.out.println(c.size());


        c.clear();
        // 判断集合是否为空
        boolean flag01 = c.isEmpty();
        System.out.println(flag01);

    }
}

class People{}

---

集合遍历/迭代

package com.bgy01;
/*
    集合遍历迭代
*/
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;

public class Test02 {
    public static void main(String[] args) {
        // HashSet ：不可重复，无序
        Collection c = new HashSet();

        c.add("bgy");
        c.add("bxg");
        c.add(2021);
        c.add(new Object());

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

        /*
            2. 通过以上获取的迭代器对象开始迭代集合
                boolean hasNext()  如果仍有元素可以迭代，则返回true
                Object next()       返回迭代元素的下一个元素
         */

        while (iterator.hasNext()){
            Object obj = iterator.next();
//            if (obj instanceof String){
//                System.out.println(obj);
//            }
            System.out.println(obj);
        }

        // 单个取出来
//        boolean hasNext = iterator.hasNext();
//        if (hasNext){
//            // 不管当初存的是什么，取出来都是Object
//            // 存进去什么类型，取出来就是什么类型
//            Object obj = iterator.next();
//            System.out.println(obj);
//        }
//        hasNext = iterator.hasNext();
//        if (hasNext){
//            // 不管当初存的是什么，取出来都是Object
//            // 存进去什么类型，取出来就是什么类型
//            Object obj = iterator.next();
//            System.out.println(obj);
//        }
    }
}

---

contains()方法

Test03.java

package com.bgy01;
import java.util.ArrayList;
import java.util.Collection;

/*
    Collection中的contains()方法：
        boolean contains(Object o)
        判断集合中是否包含某个对象，如果包含返回true，反之则返回false
        那么它是如何判断集合中是否包含这个元素呢？？？
            它底层调用了equals方法进行对比，equals方法返回true，就表示包含这个元素

    当然同理remove() 方法 同理
 */
public class Test03 {
    public static void main(String[] args) {
        // 创建集合对象
        Collection c = new ArrayList();

        // 向集合中存储元素
        String s1 = new String("bgy");  // s1 = 0x1111
        c.add(s1);

        String s2 = new String("bxg");  // s2 = 0x2222
        c.add(s2);

        System.out.println(c.size());

        String x = new String("bgy");
        // c集合是否包含了 x ？
        boolean flag = c.contains(x);
        System.out.println(flag);   // true
    }
}

---

Test04.java

package com.bgy01;
import java.util.ArrayList;
import java.util.Collection;

public class Test04 {
    public static void main(String[] args) {
        Collection c = new ArrayList();

        User u1 = new User("bgy");
        User u2 = new User("bgy");

        c.add(u1);

        // 判断c中是否包含u2
        // 没有在User中重写equals()方法
//        System.out.println(c.contains(u2));     // false

        // 在User中重写equals()方法
        System.out.println(c.contains(u2));     // true
    }
}

class User{
    private String name;

    public User() {
    }

    public User(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    // 重写equals()方法
    @Override
    public boolean equals(Object obj) {
        if (obj == this) return true;
        if (obj == null || !(obj instanceof User)) return false;
        User user = (User) obj;
        return user.name.equals(this.name);
    }
}