Java集合框架
集合：集合就是一个容器，可以存储很多东西，可以添加，可以删除，可以修改。
Collection接口
Collection接口式Java集合的根接口，是所有集合的父接口。该接口里面提供了很多操作集合的抽象方法。
JDK源码的一个介绍：
The root interface in the collection hierarchy. A collection
-
represents a group of objects, known as its elements. Some
-
collections allow duplicate elements and others do not. Some are ordered
-
and others unordered. The JDK does not provide any direct
-
implementations of this interface: it provides implementations of more
-
specific subinterfaces like Set and List. This interface
-
is typically used to pass collections around and manipulate them where
-
maximum generality is desired.
Jdk对于Collectioin接口不提供直接的实现类，而是提供子接口，子接口的层次结构如下图：
其中最常用的主要有两个子接口： Set和List接口
此接口的实现类有（非直接的实现类）：
层次关系简单如下图所示：
Collection接口提供的抽象方法
boolean add(E e)
向集合里面添加元素。
boolean addAll(Collection<? extends E> c) （批量添加元素）
将指定集合中的所有元素添加到这个集合（可选操作）。
void clear()
从这个集合中移除所有的元素（可选操作）。
boolean contains(Object o)
返回 true如果集合包含指定元素。
boolean containsAll(Collection<?> c)
返回 true如果这个集合包含指定集合的所有元素。
boolean equals(Object o)
将指定的对象与此集合进行比较，以进行相等性。
int hashCode()
返回此集合的哈希代码值。
boolean isEmpty()
返回 true如果集合不包含任何元素。
Iterator<E> iterator()
返回此集合中的元素的迭代器。
default Stream<E> parallelStream()
返回一个可能并行 Stream与集合的来源。
boolean remove(Object o)
从这个集合中移除指定元素的一个实例，如果它是存在的（可选操作）。
boolean removeAll(Collection<?> c)
删除此集合中包含的所有元素（可选操作）的所有元素（可选操作）。
default boolean removeIf(Predicate<? super E> filter)
删除满足给定谓词的这个集合的所有元素。
boolean retainAll(Collection<?> c)
仅保留包含在指定集合中的这个集合中的元素（可选操作）。
int size()
返回此集合中的元素的数目。
default Spliterator<E> spliterator()
创建此集合中的元素的 Spliterator。
default Stream<E> stream()
返回一个序列 Stream与集合的来源。
Object[] toArray()
返回包含此集合中所有元素的数组。
<T> T[] toArray(T[] a)
返回包含此集合中所有元素的数组；返回数组的运行时类型是指定的数组的运行时类型。
Collectioni集合的操作集合的基本方法的测试代码：
package com.tedu.cn.collections;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Demo1 {
@Test
public void m1(){
System.out.println("测试junit环境是否可行");
}
/**
* 测试Collection接口提供的操作集合的方法
*
* 对于这一个测试方法，你必须掌握如何创建集合对象，
* 如何向集合里面添加元素
* 如何访问集合的长度
* 如何遍历集合
*/
@Test
public void m2(){
/**
* 创建一个集合对象，把子类的对象赋值给父类的引用，这个对象叫做上转型对象
*/
Collection collection = new ArrayList();
/**
* 添加元素之前调用 size方法查看集合的元素个数,size方法返回集合的长度，集合长度就是值集合元素的个数
*/
System.out.println("添加元素之前集合的长度是："+collection.size());
/*
* 向集合里面添加元素，如果添加成功返回true，失败返回false
*/
collection.add("语文");
collection.add("数学");
collection.add("英语");
collection.add("物理");
System.out.println("添加元素之后；集合的长度是："+collection.size());
/**
* 遍历集合元素，遍历集合元素和遍历数组一样都可以采用for循环，使用新循环
*/
for(Object ob: collection){
System.out.println("当前遍历的元素是："+ob);
}
}
/**
* 测试向集合里面批量添加元素
* addAll方法
*/
@Test
public void m3(){
Collection c1 = new ArrayList();
Collection c2 = new ArrayList();
c1.add("语文");
c1.add("数学");
c2.add("英语");
c2.add("物理");
System.out.println("添加之前c1的长度"+c1.size());
/**
* 使用 addAll方法把一个集合里面的元素批量添加到另外一个集合里面
*/
//把集合c2的所有元素添加到c1
c1.addAll(c2);
System.out.println("c1集合批量添加c2集合的所有元素之后长度是："+c1.size());
System.out.println("----------------以下是遍历c1集合的操作---------------------");
for (Object o: c1){
System.out.println("当前遍历的元素是："+o);
}
}
/**
* 测试删除集合中的元素
* remove方法
*/
@Test
public void m4(){
Collection c1 = new ArrayList();
c1.add("语文");
c1.add("数学");
System.out.println("删除前集合的长度是："+c1.size());
c1.remove("语文");
System.out.println("删除后c1的长度是："+c1.size());
}
/**
* 清除集合中的所有元素
* clear方法
*/
@Test
public void m5(){
Collection c1 = new ArrayList();
c1.add("语文");
c1.add("数学");
System.out.println("清除前集合的长度是："+c1.size());
c1.clear();
System.out.println("清除后集合的长度是："+c1.size());
}
/**
* 测试判断一个集合是否为空
* isEmpty()方法 如果集合为空那么该方法就返回true ,否则返回false
*/
@Test
public void m6(){
Collection c1 = new ArrayList();
c1.add("语文");
c1.add("数学");
System.out.println("清除前集合的长度是："+c1.size());
c1.clear();
c1.add("物理");
System.out.println("清空集合之后");
System.out.println(c1.isEmpty());
}
/**
* 测试批量从集合里面移除元素
*/
@Test
public void m7(){
Collection c1 = new ArrayList();
Collection c2 = new ArrayList();
c1.add("语文");
c1.add("数学");
c2.add("英语");
c2.add("物理");
c2.add("语文");
c2.add("数学");
boolean flage = c2.removeAll(c1);
if(flage){
System.out.println("批量移除元素成功");
}
for(Object o:c2){
System.out.println("当前遍历的元素是："+o);
}
}
/**
* 测试使用迭代器遍历集合
*/
@Test
public void m8(){
/**
* 获取迭代器的方法，可以通过集合的对象名.iterator
*/
Collection c1 = new ArrayList();
c1.add("语文");
c1.add("数学");
//获取c1集合的迭代器
Iterator iterator = c1.iterator();
//使用迭代器遍历集合
while(iterator.hasNext()){
System.out.println("当前迭代的集合元素是："+iterator.next());
}
}
/**
* 测试将集合转化为数组
*/
@Test
public void m9(){
Collection c1 = new ArrayList();
c1.add("语文");
c1.add("数学");
Object[] obs = c1.toArray();
System.out.println(obs[0]);
}
}
Set集合
Set集合的特点：无序不可重复集（集合的元素的顺序是无序的，而且元素不能重复），Set是一个接口，父接口是Collection，主要实现类有HashSet TreeSet等，继承关系图如下：
Set集合底层的实现原理
set集合之所以无序是因为底层的算法是经过hash算法实现（散列算法），计算的时候会计算出相应的元素的hashCode值（hash码），每一个元素的hash码不一样导致该集合的元素是不能重复的和顺序没有办法保证。（顺序是指添加元素的顺序和元素在集合里面的顺序）
总结： Haset集合在添加元素的时候，如果元素对象的hashCode值和之前添加的HashCode值一样，这是HashSet集合回去比较两个元素对象的equal方法，如equal方法比较相等，那么认为这两个元素是同一个元素，那么就会把最后一次添加的元素替换上一次添加的元素，如果equals方法比较不相等那么认为这两个元素就是两个不同的对象，那么这两个元素都会被添加到HashSet集合中。如果两个元素对象的HashCode值不一样，那么直接认为这两个对象是不同的对象，这两个对象就会直接被添加到集合中。
注意： HashSet LinkedHashSet TreeSet的区别
相同点：
三者都是Set接口的子类实现
不同点： HashSet是一个无序不可重复集（底层基于Hash算法实现） LinkedHashSet是HashSet的一个子类，该类提供了一个线性表维护了元素的添加顺序。而对于TreeSet来说，它的父类是AbstractSet，AbstractSet的父类又是AbstractCollection，AbstractCollection 的父类是Set集合，
TreeSet底层算法是基于红黑树实现的，该算法保证了元素的重小到大排序。
测试代码：
package com.tedu.cn.collections;
import com.tedu.cn.collections.entity.Student;
import org.junit.Test;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;
public class Demo2 {
/**
* Set集合是无序不可重复集，当向Set集合里面添加元素的时候，
* 如果发现本次添加的元素和是一次添加的元素一样，那么最后添加的将会覆盖上一次添加的元素
*/
@Test
public void m1(){
Set c1 = new HashSet();
c1.add("语文");
c1.add("数学");
c1.add("英语");
c1.add("语文");
System.out.println(c1.size());
for (Object o:c1){
System.out.println(o);
}
}
@Test
public void m2(){
Student s1 = new Student("Jack01","M",18);
Student s2 = new Student("Jack02","G",20);
Student s3 = new Student("Jack03","M",19);
Set c1 = new HashSet();
c1.add(s1);
c1.add(s2);
c1.add(s3);
s2.setsName("Mike");
c1.add(s2);
//遍历集合
for (Object o:c1){
if(o instanceof Student){
Student s= (Student)o;
System.out.println(s);
}
}
}
@Test
public void m3(){
Student s1 = new Student("Jack01","M",18);
Student s2 = new Student("Jack02","G",18);
Student s3 = new Student("Jack03","M",18);
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
System.out.println(s3.hashCode());
Set c1 = new HashSet();
c1.add(s1);
c1.add(s2);
c1.add(s3);
//遍历集合
for (Object o:c1){
if(o instanceof Student){
Student s= (Student)o;
System.out.println(s);
}
}
}
@Test
public void m4(){
Set c1 = new HashSet();
c1.add(8);
c1.add(100);
c1.add(7);
c1.add(5);
c1.add(5);
c1.add(5);
for (Object o: c1){
System.out.println(o);
}
}
/**
* TreeSet
*/
@Test
public void m5(){
Set c1 = new TreeSet();
c1.add(8);
c1.add(100);
c1.add(6);
c1.add(7);
c1.add(5);
for (Object o: c1){
System.out.println(o);
}
/**
* TreeSet和HashSet 都是无序不可重复集，不同点就是底层的算法不一样，
* TreeSet是基于黄黑树算法实现 HashSet是基于Hash算法实现
* TreeSet底层基于红黑树维护元素的排序（从小到大） TreeSet无序
*/
}
@Test
public void m6(){
/**
* LinkedHashSet是HashSet的一个子类，该类添加了一个线性链表来维护元素的添加顺序，这样就是可以
* 保证集合里面的元素顺序和添加的元素顺一样
*/
Set c1 = new LinkedHashSet();
c1.add(8);
c1.add(100);
c1.add(6);
c1.add(7);
c1.add(7);
c1.add(7);
c1.add(7);
for (Object o: c1){
System.out.println(o);
}
}
}
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
