文章目录
- 前言
- 一、集合的概念
- 二、集合API
- 三、Collection接口
- 四、List接口及实现类
- 五、List接口集合迭代
- 六、set接口
- 七、Map接口
前言
Java 集合概览 Java 集合， 也叫作容器，主要是由两大接口派生而来：一个是 Collection 接口，主要用于存放单一元素；另一个是 Map 接口，主要用于存放键值对。 对于 Collection 接口，下面又有三个主要的子接口： List 、 Set 和 Queue
一、集合的概念
数组：是容器，对象，指定存储空间，长度不可变
索引-->查询块 向数组中插入，删除
实际开发中数据数量是变化的，而且不同的是数据结构不同，所以java中提供了许多不同类型的集合--Java中对于各种数据结构的实现，就是集合
集合就是容器：以不同的结构特征来存储数据--动态增长长度的容器
二、集合API
集合体系概述：
Java的集合框架由许多接口、抽象类、具体类组成的，位于java.util包中
三、Collection接口
Collection接口：定义了存取一组对象的方法，其子接口Set和List分别定义了存储方式
Set中的数据对象没有顺序且不可以重复
List中的数据对象有顺序且可以重复
Collection<E> 集合可以使用泛型向集合中传入一个参数
如果不传默认是Object,都必须存储引用类型
boolean add(Object element);
boolean addAll(Collection c);
boolean remove(Object element);
删除指定集合 不包含时,删除相交的元素
boolean removeAll(Collection c);
void clear();
int size();
判断是否为空
boolean isEmpty();
是否包含
boolean contains(Object element);
boolean containsAll(Collection c);
求交集,集合数据发生变化返回true,不变返回false
boolean retainAll(Collection c);
四、List接口及实现类
List继承了Collection接口，有三个实现类：
1、ArrayList：数组列表，数据采用数组方式存储
ArrayList实现了长度可变的数组，在内存中分配连续的空间，遍历元素和随机访问元素的效率比较高
ArrayList常用方法：
add(int index, E element)
get(int index)
indexOf(Object o)
lastIndexOf(Object o)
删除并返回指定位置元素
remove(int index)
删除指定区间的元素(子类继承使用)
removeRange(int fromIndex, int toIndex)
set(int index, E element)
public class ArrayListDemo1 {
public static void main(String[] args) {
//ArrayList<>()创建一个长度为10的底层数组,第一次添加元素时，真正创建数组
ArrayList<String> alist = new ArrayList<>();
alist.add("a");
alist.add("b");
alist.add("c");
//向指定位置插入元素
alist.add(0,"d");
//获取指定位置的元素 return elementData(index);
System.out.println(alist.get(2));
//获取指定元素的位置
System.out.println(alist.indexOf("b"));
//删除并返回指定索引的元素
System.out.println(alist.remove(1));
//替换指定位置的元素
System.out.println(alist.set(1, "B"));
System.out.println(alist.size());
System.out.println(alist);
//ArrayList<String> alist = new ArrayList<>(20);
/*
add()添加一个元素到集合中的过程
调用add()添加元素时，先检查底层数组是否能够存放，直接将元素添加到末尾
如果不可以，会创建一个新的数组，将原来的数组内容复制过去
size --> 记录实际装入数组的元素个数
//底层数组
public boolean add(E e) {
ensureCapacityInternal(size + 1); // 检查元素能否存放
elementData[size++] = e;
return true;
}
放进去后容量大小 - 底层数组长度 > 0
if (minCapacity - elementData.length > 0)
grow(minCapacity);扩容
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
//数组赋值，创建一个新数组，将原来的数组内容复制到新数组中
elementData = Arrays.copyOf(elementData, newCapacity);
}
*/
}
}public class ArrayListDemo {
public static void main(String[] args) {
ArrayList<String> alist = new ArrayList<>();
alist.add("c");
alist.add("b");
alist.add("a");
alist.add("d");
//new 接口() { 方法重写 } 创建了一个匿名内部类对象
/*
alist.sort(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return 0;
}
});
*/
//创建了一个自定义String比较类的对象
//alist.sort(new StringComparator());
alist.sort((String o1,String o2)->{return o1.compareTo(o2); });
System.out.println(alist);
}
}2、LinkedList：链表
LinkedList采用链表存储方式。插入、删除元素时效率比较高
LinkedList的常用方法：
add() 每添加一个元素，创建一个Node对象
E item；
Node<E> next;
Node<E> prev;
add(int index,Object element)
addFirist(Object element)
addLast(Object element)
index<size/2从头结点开始向后查找，否则从尾节点向前找
get(int index)
removeFirst()
removeLast()
remove(int index)
getFirst()
getLast()
public class LinkedListDemo {
public static void main(String[] args) {
/*
储存重复元素
add() 每添加一个元素，创建一个Node对象
E item；
Node<E> next;
Node<E> prev;
*/
LinkedList<String> llink = new LinkedList<>();
llink.add("a");
llink.add("b");
llink.add("c");
llink.add("d");
llink.add("e");
//index<size/2 从头结点开始向后查找，否则从尾节点向前找
System.out.println(llink.get(2));
System.out.println(llink);
}
}3、Vector：数组列表，添加同步锁，线程安全的
Vector底层也是数组，但是线程是安全的
public class VectorDemo {
public static void main(String[] args) {
Vector<String> v = new Vector<>();
v.add("a");
v.add("b");
v.add("c");
System.out.println(v);
/*
Vector底层也是数组，但是线程是安全的
public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
*/
}
}五、List接口集合迭代
● for循环遍历
● 增强for循环的遍历
● 迭代器遍历（Iterator）
public class ListIteratorDemo1 {
public static void main(String[] args) {
ArrayList<String> alist = new ArrayList<>();
alist.add("a");
alist.add("b");
alist.add("c");
alist.add("d");
//for循环
//支持在遍历的过程中删除集合中的元素，注意元素向前移动，i++，会漏掉一些元素
for (int i = 0; i < alist.size(); i++) {
if (alist.get(i).equals("a")) {
alist.remove(i);
}
}
System.out.println(alist);
//增强for循环
//不支持遍历时删除元素
for (String s : alist) {
if (s.equals("a")) {
break;
}
}
System.out.println(alist);
//迭代器
//返回一个迭代器对象，控制元素的遍历
Iterator<String> it = alist.iterator();
while (it.hasNext()) {
String s = it.next();
if (s.equals("a")) {
it.remove();//使用迭代器中的方法进行遍历
}
}
System.out.println(alist);
ListIterator<String> lit = alist.listIterator();
while(lit.hasNext()) {
System.out.println(lit.next());
}
//listIterator() 只能对list接口下的实现类进行遍历
ListIterator<String> list = alist.listIterator();
while(list.hasPrevious()) {
System.out.println(list.previous());
}
}
}六、set接口
Set接口继承了Collection接口：
Set中所存储的元素是不重复的，但是是无序的，Set中的元素是没有索引的
Set接口有两个实现类
HashSet：
HashSet类中的元素不能重复，彼此调用equals方法比较，都返回false
底层数据结构是哈希表+链表
哈希表依赖于哈希存储
TreeSet：
可以给Set集合中的元素进行指定方式的排序。
存储对象必须实现Comparable接口。
TreeSet底层数据结构是二叉树
七、Map接口
Map接口：
将键映射到值的对象，一个映射不能包含重复的键，每个映射最多只能映射到一个值
Map接口常用方法：
V put(K key,V value)
V remove(Object key)
void clear()
boolean containsKey(Object key)
boolean containsValue(Object value)
boolean isEmpty()
int size()
V get(Object key)
Collection<V> values()
Set<K> keySet()
Set<Map.Entry<K,V>> entrySet()HashMap：
HashMap中元素的key值不能重复，排列顺序不固定，可以存储一个为null的键
TreeMap：
TreeMap中所有的元素都保持着某种固定的顺序，如果需要得到一个有序Map就使用TreeMap，key值所在类必须实现Comparable接口
HashTable：
实现了同步，不能存储为null的键
Map集合遍历：
根据键找值：
获取所有键的集合
遍历键的集合，获取到每一个键
根据键找值
根据键值对对象找键和值
获取所有键值对对象的集合
遍历键值对对象的集合，获取到每一个键值对对象
根基键值对对象找键和值
TreeMap：
适用于自然顺序或自定义顺序遍历键（key）
TreeMap根据key值排序，key值需要实现Comparable接口，重写compareTo方法。TreeMap根据compareTo的逻辑，对key进行排序。
键是红黑树结构，可以保证键的排序和唯一性
9、Collections类
Collections是集合类的工具类，与数组的工具类Arrays类似.
addAl l(Col lection<? super T> c, T... elements);
binarySearch(List<? extends Comparable<? super T>> l ist, T key)
sort(List<T> l ist)
sort(List<T> l ist, Comparator<? super T> c)
swap(List<?> l ist, int i, int j)
copy(List<? super T> dest, List<? extends T> src) ; 注意 dest size需大于等于src.size
emptyList() 返回为空的集合,不能添加数据
fi l l(List<? super T> l ist, T obj)
max(Col lection<? extends T> col l)
min(Col lection<? extends T> col l)
replaceAl l(List<T> l ist, T oldVal, T newVal)
reverse(List<?> l ist)
