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