文章目录
一、Collection父接口
Collection代表一组任意类型的对象，无序、无下标、不能重复。
方法：
- size() : 返回集合中元素的个数 。
- isEmpty()： 判断集合是否为空。
- contains()： 判断集合是否包含指定对象。
- toArray()： 将集合转换为数组。
- add()：向集合中添加元素。
- remove()：删除指定对象。
- 、、、
Collection 源码：
package java.util;
import java.util.function.Predicate;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
public interface Collection<E> extends Iterable<E> {
int size();
boolean isEmpty();
boolean contains(Object o);
Iterator<E> iterator();
Object[] toArray();
<T> T[] toArray(T[] a);
boolean add(E e);
boolean remove(Object o);
boolean containsAll(Collection<?> c);
boolean addAll(Collection<? extends E> c);
boolean removeAll(Collection<?> c);
default boolean removeIf(Predicate<? super E> filter) {
Objects.requireNonNull(filter);
boolean removed = false;
final Iterator<E> each = iterator();
while (each.hasNext()) {
if (filter.test(each.next())) {
each.remove();
removed = true;
}
}
return removed;
}
boolean retainAll(Collection<?> c);
void clear();
boolean equals(Object o);
int hashCode();
@Override
default Spliterator<E> spliterator() {
return Spliterators.spliterator(this, 0);
}
default Stream<E> stream() {
return StreamSupport.stream(spliterator(), false);
}
default Stream<E> parallelStream() {
return StreamSupport.stream(spliterator(), true);
}
}
二、List集合：
1. 特点：
有序、有下标、元素可以重复
2. 实现类：
2.1 ArrayList【重点】
特点：
- 底层为数组结构实现，查询块、增删慢。
- 默认容量： private static final int DEFAULT_CAPACITY = 10;
- 因为底层是数组结构，所以其扩容是开辟连续空间，每次扩容是原来的1.5倍
- 线程不安全。
常用方法：
public class ArrayListDemo{
public void static main(String[] args){
ArrayList arr = new ArrayList();
//添加元素
arr.add("第一个元素");
arr.add("第二个元素");
arr.add("第三个元素");
arr.add("第四个元素");
System.out.println("--------------------添加元素---------------------");
System.out.println("所有元素："+arr.toString());
//查找元素
arr.indexOf("第二个元素"); //如果找到该对象，返回该对象的下标，反之则返回-1
System.out.println("--------------------查找元素---------------------");
System.out.println("第二个元素的位置："+arr.indexOf("第二个元素")+" 未知元素的位置："+arr.indexOf("未知元素"));
//删除元素
arr.remove("第一个元素");
System.out.println("--------------------删除元素---------------------");
System.out.println("删除之后的所有元素："+arr.toString());
//判断是否存在指定对象，返回布尔值
arr.contains("第三个元素");
System.out.println("--------------------判断元素---------------------");
System.out.println("存在第三个元素："+arr.contains("第三个元素")+" 存在未知元素："+arr.contains("未知元素"));
//遍历ArrayList
System.out.println("--------------------遍历元素---------------------");
/* 迭代器遍历*/
ListIterator listIterator=arr.listIterator();
while(listIterator.hasNext()) {
System.out.println(listIterator.next());
}
/* 增强for循环遍历*/
System.out.println("");
for (Object obj : arr){
System.out.println(obj);
}
}
}
运行结果：
2.2 LinkedList
特点：
- 双向链表结构实现，增删快，查询慢。
- 无需开辟连续空间。
- 线程不安全。
特有方法：
//查询方法：
getFirst() //获取集合中的第一个元素
getLast() //获取集合中的最后一个元素
//添加方法：
addFirst(Object o) //在集合的第一个位置添加指定元素
addLast(Object o) //在集合的最后一个位置添加指定元素
//删除方法：
removeFirst() //删除集合中的第一个元素
removeLast() //删除集合中的最后一个元素
2.3 Vector
特点：
- 数组结构实现，查询快、增删慢。
- 运行效率慢、线程安全。
个人觉得Vector使用频率较少，这里就不详细介绍了
三、Set集合：
1. 特点：
无序、无下标、元素不可重复、全部继承自Collection中的方法。
2. 实现类：
2.1 HashSet【重点】
HashSet是利用Hash算法来存储集合中的元素，因此具有很好的存取和查找性能。底层数据结构是哈希表。
- 不能保证元素的排列顺序，顺序可能与添加顺序不同，顺序也可能发生变化。
- HashSet不是同步的。
- 集合元素值可以是null。
常用方法：
public class HashSetDemo{
public void static main(String[] args){
HashSet<String> hashSet = new HashSet<>();
//添加元素
hashSet.add("张无忌");
hashSet.add("周芷若");
hashSet.add("赵敏");
//集合中元素个数
System.out.println("--------------------元素个数---------------------");
System.out.println("集合元素个数： "+hashSet.size());
//删除集合中指定元素，成功返回true，失败返回false
System.out.println("--------------------删除元素---------------------");
System.out.println(hashSet.remove("赵敏"));
//判断集合是否为空
System.out.println("--------------------集合是否为空---------------------");
System.out.println(hashSet.isEmpty());
//判断是否包含指定元素
System.out.println("--------------------集合是否包含 '赵敏'：---------------------");
System.out.println(hashSet.contains("赵敏"));
//遍历集合
System.out.println("--------------------遍历集合---------------------");
/* iterator遍历*/
Iterator<String> ite =hashSet.iterator();
while (ite.hasNext()){
System.out.println(ite.next());
}
/* forEach遍历（此处使用lambda表达式<java8新特性> *感兴趣的同学可以去了解一下）*/
System.out.println("第二种遍历方法：");
hashSet.stream().forEach(s -> {System.out.println(s);});
//移出集合中所有元素
hashSet.clear();
}
}
运行结果：
存储原理：
- 当 HashSet 新增元素时，调用该元素的 HashCode 方法得到哈希值，根据哈希值决定该元素存储的位置。
- 如果该位置为空，直接保存。
- 如果位置不为空，会执行 equals 方法，如果返回 true ，则是重复，拒绝存储。
- 如果返回 false ，说明不是相同元素（只是hash值相等），形成链表。
2.2 TreeSet
- 底层数据结构为红黑树
- 基于排序顺序实现元素不重复。
- 实现了SortedSet接口，对集合元素自动排序。
- 元素对象的类型必须实现Comparable接口，指定排序规则。
- 通过CompareTo方法确定是否为重复元素。
先创建一个对象，用于向 TreeSet 中添加
public class Person {
private String name;
private Integer age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
}
接下来重点说一下 add() 添加方法：
public class TreeSetDemo{
public void static main(String[] args){
TreeSet treeSet = new TreeSet();
Person p1 = new Person("张无忌",22);
treeSet.add(p1);
}
}
运行结果：
为什么报错呢？请注意 “元素对象的类型必须实现Comparable接口，指定排序规则。” 这点，如果不实现这个接口，就没办法判断向 TreeSet 中添加的元素是否重复，所以咱们必须在元素对象中实现Comparable接口，并重写 compareTo 方法，这样才能正常添加元素：
public class Person implements Comparable<Person>{
private String name;
private Integer age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
@Override
public int compareTo(Person o) {
int n1=this.getName().compareTo(o.getName());
int n2=this.age-o.getAge();
return n1==0?n2:n1;
}
}
四、Map集合：
1.特点：
- 无序、无下标，键值对方式存储元素。
- 键唯一，不允许重复，可以存null。
- 值可以重复，可以存null。
2. 实现类：
2.1 HashMap 【重点】
- 线程不安全，运行效率快；允许用null作为key或是value。
- 初始化容量为16，每次扩容为原来的两倍
- 存储数据结构为：哈希表（数组+链表+红黑树）
又一次看见哈希表这个东西，同学们是否发现HashSet使用的数据结构也是 “哈希表”，没错HashSet 与 HashMap 存在关系：HashSet在底层是用HashMap实现的。
常用方法：
public class HashMap{
public void static mian(String[] args){
//在实例化的时候可以指定键和值的类型
HashMap<String,Object> map = new HashMap<>();
//添加元素
map.put("第一个元素",1);
map.put("第二个元素",2);
map.put("第三个元素",3);
System.out.println(map.toString());
//遍历集合
/* keySet()遍历*/
System.out.println("-------------keySet()遍历----------------");
for(String key: map.keySet()){
System.out.println(key+":"+map.get(key));
}
/* entrySet()遍历*/
System.out.println("-------------entrySet()遍历----------------");
for(Map.Entry<String, Object> entry: map.entrySet()){
System.out.println(entry.getKey()+":"+entry.getValue());
}
//删除元素
map.remove("第三个元素");
System.out.println(map.toString());
}
}
2.2 TreeMap
- 实现了SortedMap接口（是Map的子接口），可以对key自动排序。
- 不允许null键和null值，效率比HashMap低，线程不安全。
- 存储结构：红黑树
用法与 HashMap类似。
学无止境。老狗在此欢迎各位大神指出鄙人之不足，提出你们宝贵意见。
- 转载请注明出处
1698
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
