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("狗娃", ));
         c1.add(new Person("狗剩", ));
         c1.add(new Person("狗蛋", ));

         Collection c2=new ArrayList();
         c2.add(new Person("狗娃", ));
         c2.add(new Person("狗剩", ));
         c2.add(new Person("孙尚香", ));

         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 = ; 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 = ; 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[]);//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 = ; 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(, "java编程思想"));
         list.add(new Book(,"java核心技术"));
         list.add(new Book(,"深入javaweb"));
         list.add(new Book(,"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

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