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

一、集合

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

1.1、集合比数组的优势

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

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

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

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

1.2、Collection 集合 Collection集合详解

---------| collection 单例集合的根接口
--------------| List 如果实现了list接口的集合类，具备的特点：有序，可重复 注：集合中的有序不是指自然顺序，而是指添加进去的顺序与出来的顺序是一致的
------------------| ArrayList ArrayList底层维护了一个object数组的实现的。(线程不安全)，特点：查询速度快，增删速度慢。（有序，可重复）
------------------| LinkedList LinkedList底层是使用链表结构实现的，特点：查询速度慢，增删速度快。（有序，可重复）
------------------| Vector(了解即可) 底层也是维护一个Object数组的实现的，实现与ArrayList是一样的，但是Vector是线程安全的，操作效率低
--------------| Set 如果实现了set接口的集合类，具备的特点：无序，不可重复注：集合中的无序不是指自然顺序，而是指添加元素进去的顺序与元素出来的顺序是不一致的
------------------| HashSet
------------------| TreeSet

1.3、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() //返回此集合中的元素的迭代器
 * */

1.4、实例

增、删、查方法

 1 package com.zn.collection;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Collection;
 5 
 6 /**
 7  * @author DSHORE / 2018-5-15
 8  *
 9  */
10 public class Demo1 {
11     public static void main(String[] args) {
12         Collection<String> c=new ArrayList<String>();//父类的引用类型指向子类的对象
13         c.add("张三");
14         c.add("李四");
15         c.add("王五");
16         System.out.println(c);//返回值：[张三, 李四, 王五]
17         
18         //添加        创建集合
19         Collection<String> c2=new ArrayList<String>();
20         c2.add("张三");
21         c2.add("狗蛋");
22         c2.add("狗娃");
23         c.addAll(c2);
24         System.out.println(c);//返回值：[张三, 李四, 王五, 张三, 狗蛋, 狗娃]
25             
26         //删除
27         //c.clear();
28         //System.out.println(c);//返回值：[]   集合中没有元素，已被删除
29         //c.remove("狗蛋");
30         //System.out.println(c);//返回值：[张三, 李四, 王五, 张三, 狗娃]
31         //c.removeAll(c2);//删除c2集合,以及c集合与c2集合的交集部分
32         //System.out.println(c);//返回值：[李四, 王五]
33         c.retainAll(c2);//保留c2集合,以及c集合与c2集合的交集部分
34         System.out.println(c);//返回值：[张三, 张三, 狗蛋, 狗娃]
35 
36         //查看
37         System.out.println("查看集合的元素个数："+c.size());//返回值：查看集合的元素个数：6
38     }
39 }

判断方法

 1 package com.zn.collection;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Collection;
 5 
 6 /**
 7  * @author DSHORE / 2018-5-15
 8  *
 9  */
10 /*
11  * isEmpty() //判断集合是否为空
12  * contains(Object o)  //判断该集合中是否包含该集合指定元素
13  * containsAll(Collection<?> c) //判断该集合是否包含指定集合中的所有元素
14  * */
15 class Person{
16     String name;
17     int id;
18     public Person(String name, int id) {
19         super();
20         this.name = name;
21         this.id = id;
22     }
23     @Override
24     public String toString() {
25         return "Person [name=" + name + ", id=" + id + "]";
26     }
27     
28     @Override
29     public boolean equals(Object obj) {
30         Person p=(Person)obj;
31         return this.id==p.id;
32     }
33 }
34 public class Demo2 {
35     public static void main(String[] args) {
36         Collection<String> c=new ArrayList<String>();//父类的引用类型指向子类的对象
37         c.add("张三");
38         c.add("李四");
39         c.add("王五");
40         System.out.println("判断集合是否为空:"+c.isEmpty());//返回值：false
41         System.out.println("判断该集合是否包含指定元素:"+c.contains("孙尚香"));//返回值：false
42         System.out.println("判断该集合是否包含指定元素:"+c.contains("王五"));//返回值：true
43     
44         //集合中添加自定义元素
45         Collection c1=new ArrayList();//父类的引用类型指向子类的对象
46         //下面添加的都是对象
47         c1.add(new Person("狗娃", 1)); 
48         c1.add(new Person("狗剩", 2));
49         c1.add(new Person("狗蛋", 3));
50         
51         Collection c2=new ArrayList();
52         c2.add(new Person("狗娃", 1));
53         c2.add(new Person("狗剩", 2));
54         c2.add(new Person("孙尚香", 3));
55         
56         System.out.println("c1集合中元素包含c2集合中的元素吗? "+c1.containsAll(c2));//返回值：true  说明：这里是根据id判断的，由上面的equals()方法可以看出。
57     }
58 }

迭代方法

toArray()

 1 package com.zn.collection;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 
 6 /**
 7  * @author DSHORE / 2018-5-15
 8  * 
 9  * toArray：返回一个包含此集合中所有元素的数组    相当于把集合转换成数组的形式
10  * 
11  * List 如果实现了list接口的集合类，具备的特点：有序，可重复
12  * set 如果实现了set接口的集合类，局部特点：无序，不可重复
13  */
14 class Persons {
15     String name;
16     public Persons(String name) {
17         super();
18         this.name = name;
19     }
20     @Override
21     public String toString() {
22         return "Person [name=" + name + "]";
23     }
24 }
25 public class Demo4 {
26     public static void main(String[] args) {
27         List<Object> list=new ArrayList<Object>();
28         list.add(new Persons("张三"));
29         list.add(new Persons("李四"));
30         list.add(new Persons("王五"));//可重复
31         list.add(new Persons("王五"));
32         //方式1：报错
33         Person[] persons = (Person[]) list.toArray();
34         for (int i = 0; i < persons.length; i++) {
35             System.out.println(persons[i]);//报异常：Exception in thread "main" java.lang.ClassCastException
36         }
37         //方式1
38         Object[] object = list.toArray(); //toArray把集合中的元素存储到一个Object类型的数组中，并返回
39         for (int i = 0; i < object.length; i++) {
40             System.out.println(object[i]);
41             /*运行结果：
42              * Person [name=张三]
43              * Person [name=李四]
44              * Person [name=王五]
45              * Person [name=王五]
46              **/
47         }
48         //方式2
49         //Person[] person = new Person[];
50         Persons[] person = (Persons[])list.toArray(new Persons[5]);//toArray：返回一个包含此集合中所有元素的数组    相当于把数组转换成集合的形式
51         System.out.println(list);//返回值：[Person [name=张三], Person [name=李四], Person [name=王五], Person [name=王五]]
52 
53         System.out.println(person);//返回值：[Lcom.zn.collection.Persons;@544a5ab2      内存地址
54         for(int i = 0; i < person.length; i++){//遍历出 数组里面的具体数据
55             System.out.println(person[i]);
56             /*运行结果：  解析:该数组长度为5；数据只有4条，故最后一条数据为null
57               Person [name=张三]
58               Person [name=李四]
59               Person [name=王五]
60               Person [name=王五]
61               null
62              */
63         }
64     }
65 }

iterator()

 1 package com.zn.collection;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Iterator;
 5 /**
 6  * @author DSHORE / 2018-5-15
 7  *
 8  * iterator() //返回此集合中的元素的迭代器
 9  */
10 //需求:编写一个函数清除集合中的重复元素.如果书号是一样的视为重复元素
11 class Book{
12     int id;
13     String name;
14     public Book(int id, String name) {
15         super();
16         this.id = id;
17         this.name = name;
18     }
19     @Override
20     public String toString() {
21         return "Book [id=" + id + ", name=" + name + "]";
22     }
23     @Override
24     public boolean equals(Object obj) {
25             Book book=(Book)obj;
26         return this.id==book.id;//根据id判断是否相等
27     }
28 }
29 public class Demo3 {
30     public static void main(String[] args) {
31         ArrayList list=new ArrayList();
32         list.add(new Book(110, "java编程思想"));
33         list.add(new Book(220,"java核心技术"));
34         list.add(new Book(330,"深入javaweb"));
35         list.add(new Book(110,"java神书"));
36         System.out.println(list);
37         ArrayList al=clearRepeat(list);
38         System.out.println("新集合中的元素是："+al);    
39     }
40     public static ArrayList clearRepeat(ArrayList list){
41         //创建一个新的集合
42         ArrayList newList=new ArrayList();
43         //获取迭代器
44         Iterator it=list.iterator();
45         while(it.hasNext()){//遍历 （遍历就集合中的元素）   it.hasNext()：判断是否还有元素可以迭代，有则返回true
46             Book book=(Book) it.next();//从旧集合中获取的元素   it.next()：下一个元素
47             if(!newList.contains(book)){//判断newList集合是否包含list集合中的元素。  有两个id是110的，故 新集合中会过滤掉一条110的数据   
48                 //如果新集合中没有包含该书籍,那么就存储到新集合中
49                 newList.add(book);
50             }
51         }
52         return newList;    
53     }
54 }

原创作者：DSHORE

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

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

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

秒客网