集合-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 判断是否是：某个元素
存放在一个集合中的类型，一定要重写equals方法。
没有重写equals之前；应为底层调用的Object中的equals；里面判断的是双等号“==” 比较的的是：内存地址；
重写之后调用一定是重写之后的equals方法，这时候比较的就是内容；
remove 删除集合中某个元素
在迭代集合元素的过程中，不能调用集合对象的remove方法，删除元素： c.remove(o); 迭代过程中不能这样。
会出现：java.util.ConcurrentModificationException
在迭代元素的过程当中，一定要使用迭代器Iterator的remove方法，删除元素，不要使用集合自带的remove方法删除元素。

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

        // 创建集合对象
        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（）

/*
关于集合元素的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();
// 添加元素
        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();

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

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

posted @ 2022-04-25 00:18 280887072 阅读(196) 评论(0) 编辑收藏举报

刷新页面返回顶部

lwt280887072

集合-Collection常用方法

迭代器中的：删除：remove（）