集合-Collection常用方法

本文主要是介绍集合-Collection常用方法，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

Collection中能存放的元素：

• 没有使用“泛型”之前，Collection中可以存储Object的所有子类型。
• 使用了“泛型”之后，Collection中只能存储某个具体的类型。
• Collection中什么都能存，只要是Object的子类型就行。
• 集合中不能直接存储基本数据类型，也不能存java对象，只是存储java对象的内存地址。

Collection中的常用方法（Collection中的方法List集合都有）

• boolean add(Object e)    向集合中添加元素
• int size()                          获取集合中元素的个数
• void clear()                     清空集合
• boolean contains(Object o)   判断当前集合中是否包含元素o，包含返回true，不包含返回false
• boolean remove(Object o)    删除集合中的某个元素。
• boolean isEmpty()                判断该集合中元素的个数是否为0

public class CollectionTest01 {

    public static void main(String[] args) {

        // 创建一个集合对象
        //Collection c = new Collection(); //Collection 接口是抽象的，无法实例化。
        //List list = new List()           //List    是接口无法实例化

        // 多态
        Collection c = new ArrayList();
        List list = new ArrayList();

        // 测试Collection接口中的常用方法
        c.add(1200); // 自动装箱(java5的新特性。),实际上是放进去了一个对象的内存地址。Integer x = new Integer(1200);
        c.add(3.14); // 自动装箱
        c.add(new Object());
        c.add(new Student());
        c.add(true); // 自动装箱

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

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

Collection中的方法：

• contains 判断是否是：某个元素
• remove  删除集合中某个元素
• 存放在一个集合中的类型，一定要重写equals方法。
• 没有重写equals之前；应为底层调用的Object中的equals；里面判断的是双等号“==” 比较的的是：内存地址；
• 重写之后调用一定是重写之后的equals方法，这时候比较的就是内容；

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

/*
测试contains方法
测试remove方法。
结论：存放在一个集合中的类型，一定要重写equals方法。
不重写比较的时候调用Object类中的equals 使用的双等号，比较的是内存地址
重写之后调用一定是重写之后的equals方法，这时候比较的就是内容；
 */
public class CollectionTest05 {
    public static void main(String[] args) {
        // 创建集合对象
        Collection c = new ArrayList();
        // 创建用户对象
        User u1 = new User("jack");
        // 加入集合
        c.add(u1);

        // 判断集合中是否包含u2
        User u2 = new User("jack");

        // 没有重写equals之前：这个结果是false；应为底层调用的Object中的equals
        //底层比较的时候是Object中的equals，里面判断的是双等号“==” 比较的内存地址
        //new了两次，所以结果是false

        //System.out.println(c.contains(u2)); // false
        // 重写equals方法之后，比较的时候会比较name。
        System.out.println(c.contains(u2)); // true

        c.remove(u2);
        System.out.println(c.size()); // 0

        /*Integer x = new Integer(10000);
        c.add(x);

        Integer y = new Integer(10000);
        System.out.println(c.contains(y)); // true*/

        // 创建集合对象
        Collection cc = new ArrayList();
        // 创建字符串对象
        String s1 = new String("hello");
        // 加进去。
        cc.add(s1);

        // 创建了一个新的字符串对象
        String s2 = new String("hello");
        // 删除s2
        cc.remove(s2); // s1.equals(s2) java认为s1和s2是一样的。删除s2就是删除s1。
        // 集合中元素个数是？
        System.out.println(cc.size()); // 0
    }
}

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

    // 重写equals方法
    // 将来调用equals方法的时候，一定是调用这个重写的equals方法。
    // 这个equals方法的比较原理是：只要姓名一样就表示同一个用户。
    public boolean equals(Object o) {
        if(o == null || !(o instanceof User)){
            return false;
            }
        if(o == this){
            return true;
            }
        User u = (User)o;

        // 如果名字一样表示同一个人。（不再比较对象的内存地址了。比较内容。）
        return u.name.equals(this.name);
    }

/*
关于集合元素的remove
    重点：当集合的结构发生改变时，迭代器必须重新获取，如果还是用以前老的迭代器，会出现
    异常：java.util.ConcurrentModificationException

    重点：在迭代集合元素的过程中，不能调用集合对象的remove方法，删除元素：
        c.remove(o); 迭代过程中不能这样。
        会出现：java.util.ConcurrentModificationException

    重点：在迭代元素的过程当中，一定要使用迭代器Iterator的remove方法，删除元素，
    不要使用集合自带的remove方法删除元素。

 */
public class CollectionTest06 {
    public static void main(String[] args) {
        // 创建集合
        Collection c = new ArrayList();

        // 注意：此时获取的迭代器，指向的是那是集合中没有元素状态下的迭代器。
        // 一定要注意：集合结构只要发生改变，迭代器必须重新获取。
        // 当集合结构发生了改变，迭代器没有重新获取时，调用next()方法时：java.util.ConcurrentModificationException
        Iterator it = c.iterator();

        // 添加元素
        c.add(1); // Integer类型
        c.add(2);
        c.add(3);

        // 获取迭代器
        //Iterator it = c.iterator();
        /*while(it.hasNext()){
            // 编写代码时next()方法返回值类型必须是Object。
            // Integer i = it.next();
            Object obj = it.next();
            System.out.println(obj);
        }*/

        Collection c2 = new ArrayList();
        c2.add("abc");
        c2.add("def");
        c2.add("xyz");

        Iterator it2 = c2.iterator();
        while(it2.hasNext()){
            Object o = it2.next();
            // 删除元素
            // 删除元素之后，集合的结构发生了变化，应该重新去获取迭代器
            // 但是，循环下一次的时候并没有重新获取迭代器，所以会出现异常：java.util.ConcurrentModificationException
            // 出异常根本原因是：集合中元素删除了，但是没有更新迭代器（迭代器不知道集合变化了）
            //c2.remove(o); // 直接通过集合去删除元素，没有通知迭代器。（导致迭代器的快照和原集合状态不同。）
            // 使用迭代器来删除可以吗？
            // 迭代器去删除时，会自动更新迭代器，并且更新集合（删除集合中的元素）。
            it2.remove(); // 删除的一定是迭代器指向的当前元素。
            System.out.println(o);
        }

        System.out.println(c2.size()); //0
    }
}

这篇关于集合-Collection常用方法的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！