java基础27 单例集合Collection及其常用方法

1、集合

     集合是存储对象数据的集合容器

 1.1、集合比数组的优势

    1.集合可以存储任意类型的数据，数组只能存储同一种数据类型的数据
    2.集合的长度是变化的，数组的长度是固定的

1.2、数组：存储同一种类型集合的容器
1.3、 数组的特点
    1.只能存储同一种数据类型
    2.一旦初始化,长度固定
    3.数组中的元素与元素之间的内存地址是连续的

    注意: object类型的数组可以存任意类型的数据

问题：使用ArrayList无参构造函数创建对象,默认容量是多少?如果长度不够又自增多少?
    答：ArrayList底层是维护一个Object数组实现的,使用无参构造函数时,Object默认容量是10,当长度不够时,自动增长0.5倍

2、集合体系                   Collection集合详解

单例集合的体系：

---------| collection  单例集合的根接口
--------------| List  如果实现了list接口的集合类，具备的特点：有序，可重复       注：集合中的有序不是指自然顺序，而是指添加进去的顺序与出来的顺序是一致的
------------------| ArrayList  ArrayList底层维护了一个object数组的实现的。(线程不安全)，特点：查询速度快，增删速度慢。（有序，可重复）
------------------| LinkedList  LinkedList底层是使用链表结构实现的，线程不安全，特点：查询速度慢，增删速度快。（有序，可重复）
------------------| Vector(了解即可)  底层也是维护一个Object数组的实现的，实现与ArrayList是一样的，但是Vector是线程安全的，操作效率低
--------------| Set  如果实现了set接口的集合类，具备的特点：无序，不可重复     注：集合中的无序不是指自然顺序，而是指添加元素进去的顺序与元素出来的顺序是不一致的
------------------| HashSet  底层是用于一个哈希表支持的。线程不安全，特点：存储速度块
------------------| TreeSet   底层是使用红黑树(二叉树)数据结构实现的，线程不同步(即线程不安全)，不能在多线程中共享，但可以使用synchroinzedMap()方法来实现同步。特点：会对元素进行排序存储（按自然顺序）

双例集合体系：

----------| Map  双例集合的根接口。如果是实现了Map接口的集合类，具备的特点：存储的数据都是以键值对形式存在的，键不可重复，值可以重复
--------------| HashMap  底层是基于哈希表实现的，HashMap允许键和值为null，线程不安全，特点：存储速度块
--------------| TreeMap  基于红黑数(二叉树)数据结构实现的，线程不同步(即线程不安全)，特点：会对元素经行排序存储
--------------| HashTable(了解即可)  线程安全

2.1、Collection的一些方法

/*
 * 增加
 * add(E e) //向本集合中添加元素
 * addAll(Collection<? extends E> c) //向另一个集合中添加指定的集合(里面的所有元素).
 *
 * 删除
 * clear() //删除指定集合
 * remove(Object o) //指定删除的元素
 * removeAll(Collection<?> c) //删除c1,以及c和c1的交集部分.
 * retainAll(Collection<?> c) //保留c1,以及c和c1的交集部分.
 *
 * 查看
 * size() //返回当前集合中元素的个数
 *
 * 判断
 * isEmpty() //判断集合是否为空
 * contains(Object o)  //判断该集合中是否包含该集合指定元素
 * containsAll(Collection<?> c) //判断该集合是否包含指定集合中的所有元素
 *
 * 迭代
 * toArray() //返回一个包含此集合中所有元素的数组    相当于把集合转换成数组的形式
 * iterator() //返回此集合中的元素的迭代器
 * */

2.2、实例

增、删、查 方法

package com.zn.collection;

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

/**
 * @author DSHORE / 2018-5-15
 *
 */
public class Demo1 {
    public static void main(String[] args) {
        Collection<String> c=new ArrayList<String>();//父类的引用类型指向子类的对象
        c.add("张三");
        c.add("李四");
        c.add("王五");
        System.out.println(c);//返回值：[张三, 李四, 王五]
        
        //添加        创建集合
        Collection<String> c2=new ArrayList<String>();
        c2.add("张三");
        c2.add("狗蛋");
        c2.add("狗娃");
        c.addAll(c2);
        System.out.println(c);//返回值：[张三, 李四, 王五, 张三, 狗蛋, 狗娃]
            
        //删除
        //c.clear();
        //System.out.println(c);//返回值：[]   集合中没有元素，已被删除
        //c.remove("狗蛋");
        //System.out.println(c);//返回值：[张三, 李四, 王五, 张三, 狗娃]
        //c.removeAll(c2);//删除c2集合,以及c集合与c2集合的交集部分
        //System.out.println(c);//返回值：[李四, 王五]
        c.retainAll(c2);//保留c2集合,以及c集合与c2集合的交集部分
        System.out.println(c);//返回值：[张三, 张三, 狗蛋, 狗娃]

        //查看
        System.out.println("查看集合的元素个数："+c.size());//返回值：查看集合的元素个数：6
    }
}

判断方法

package com.zn.collection;

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

/**
 * @author DSHORE / 2018-5-15
 *
 */
/*
 * isEmpty() //判断集合是否为空
 * contains(Object o)  //判断该集合中是否包含该集合指定元素
 * containsAll(Collection<?> c) //判断该集合是否包含指定集合中的所有元素
 * */
class Person{
    String name;
    int id;
    public Person(String name, int id) {
        super();
        this.name = name;
        this.id = id;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", id=" + id + "]";
    }
    
    @Override
    public boolean equals(Object obj) {
        Person p=(Person)obj;
        return this.id==p.id;
    }
}
public class Demo2 {
    public static void main(String[] args) {
        Collection<String> c=new ArrayList<String>();//父类的引用类型指向子类的对象
        c.add("张三");
        c.add("李四");
        c.add("王五");
        System.out.println("判断集合是否为空:"+c.isEmpty());//返回值：false
        System.out.println("判断该集合是否包含指定元素:"+c.contains("孙尚香"));//返回值：false
        System.out.println("判断该集合是否包含指定元素:"+c.contains("王五"));//返回值：true
    
        //集合中添加自定义元素
        Collection c1=new ArrayList();//父类的引用类型指向子类的对象
        //下面添加的都是对象
        c1.add(new Person("狗娃", 1)); 
        c1.add(new Person("狗剩", 2));
        c1.add(new Person("狗蛋", 3));
        
        Collection c2=new ArrayList();
        c2.add(new Person("狗娃", 1));
        c2.add(new Person("狗剩", 2));
        c2.add(new Person("孙尚香", 3));
        
        System.out.println("c1集合中元素包含c2集合中的元素吗? "+c1.containsAll(c2));//返回值：true  说明：这里是根据id判断的，由上面的equals()方法可以看出。
    }
}

迭代方法

toArray()

package com.zn.collection;

import java.util.ArrayList;
import java.util.List;

/**
 * @author DSHORE / 2018-5-15
 * 
 * toArray：返回一个包含此集合中所有元素的数组    相当于把集合转换成数组的形式
 * 
 * List 如果实现了list接口的集合类，具备的特点：有序，可重复
 * set 如果实现了set接口的集合类，局部特点：无序，不可重复
 */
class Persons {
    String name;
    public Persons(String name) {
        super();
        this.name = name;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + "]";
    }
}
public class Demo4 {
    public static void main(String[] args) {
        List<Object> list=new ArrayList<Object>();
        list.add(new Persons("张三"));
        list.add(new Persons("李四"));
        list.add(new Persons("王五"));//可重复
        list.add(new Persons("王五"));
        //方式1：报错
        Person[] persons = (Person[]) list.toArray();
        for (int i = 0; i < persons.length; i++) {
            System.out.println(persons[i]);//报异常：Exception in thread "main" java.lang.ClassCastException
        }
        //方式1
        Object[] object = list.toArray(); //toArray把集合中的元素存储到一个Object类型的数组中，并返回
        for (int i = 0; i < object.length; i++) {
            System.out.println(object[i]);
            /*运行结果：
             * Person [name=张三]
             * Person [name=李四]
             * Person [name=王五]
             * Person [name=王五]
             **/
        }
        //方式2
        //Person[] person = new Person[];
        Persons[] person = (Persons[])list.toArray(new Persons[5]);//toArray：返回一个包含此集合中所有元素的数组    相当于把数组转换成集合的形式
        System.out.println(list);//返回值：[Person [name=张三], Person [name=李四], Person [name=王五], Person [name=王五]]

        System.out.println(person);//返回值：[Lcom.zn.collection.Persons;@544a5ab2      内存地址
        for(int i = 0; i < person.length; i++){//遍历出 数组里面的具体数据
            System.out.println(person[i]);
            /*运行结果：  解析:该数组长度为5；数据只有4条，故最后一条数据为null
              Person [name=张三]
              Person [name=李四]
              Person [name=王五]
              Person [name=王五]
              null
             */
        }
    }
}

iterator()

package com.zn.collection;

import java.util.ArrayList;
import java.util.Iterator;
/**
 * @author DSHORE / 2018-5-15
 *
 * iterator() //返回此集合中的元素的迭代器
 */
//需求:编写一个函数清除集合中的重复元素.如果书号是一样的视为重复元素
class Book{
    int id;
    String name;
    public Book(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
    @Override
    public String toString() {
        return "Book [id=" + id + ", name=" + name + "]";
    }
    @Override
    public boolean equals(Object obj) {
            Book book=(Book)obj;
        return this.id==book.id;//根据id判断是否相等
    }
}
public class Demo3 {
    public static void main(String[] args) {
        ArrayList list=new ArrayList();
        list.add(new Book(110, "java编程思想"));
        list.add(new Book(220,"java核心技术"));
        list.add(new Book(330,"深入javaweb"));
        list.add(new Book(110,"java神书"));
        System.out.println(list);
        ArrayList al=clearRepeat(list);
        System.out.println("新集合中的元素是："+al);    
    }
    public static ArrayList clearRepeat(ArrayList list){
        //创建一个新的集合
        ArrayList newList=new ArrayList();
        //获取迭代器
        Iterator it=list.iterator();
        while(it.hasNext()){//遍历 （遍历就集合中的元素）   it.hasNext()：判断是否还有元素可以迭代，有则返回true
            Book book=(Book) it.next();//从旧集合中获取的元素   it.next()：下一个元素
            if(!newList.contains(book)){//判断newList集合是否包含list集合中的元素。  有两个id是110的，故 新集合中会过滤掉一条110的数据   
                //如果新集合中没有包含该书籍,那么就存储到新集合中
                newList.add(book);
            }
        }
        return newList;    
    }
}

原创作者：DSHORE

作者主页：http://www.cnblogs.com/dshore123/

原文出自：http://www.cnblogs.com/dshore123/p/9026087.html

欢迎转载，转载务必说明出处。（如果本文对您有帮助，可以点击一下右下角的 推荐，或评论，谢谢！）