集合
Java中的集合将数结构做成了类和API直接拿来使用。集合类中存储的不是真正的数据,而是对象的指针或者引用地址。
实际开发中,经常用到 java 的集合框架,比如 ArrayList 、 LinkedList 、 HashMap 、 LinkedHashMap等等。
Java 集合就像一种容器,可以把多个对象(实际上是对象的引用,但习惯上都称对象)“丢进”该容器中。从 Java 5 增加了泛型以后,Java 集合可以记住容器中对象的数据类型,使得编码更加简洁、健壮。
Java 集合大致可以分为两大体系,一个是 Collection,另一个是 Map;
Collection :主要由List、Set、Queue接口组成,List代表有序、重复的集合;其中Set代表无序、不可重复的集合;Java 5 又增加了Queue体系集合,代表一种队列集合实现。
Map:则代表具有映射关系的键值对集合。
java.util.Collection 及其集合
Collection中的集合基本都是线性结构,存储结构是顺序表和链表,但是TreeSet和HashSet也借助了Map集合实现。
java.util.Collection:集合父类
这个是所有集合都要用到的公共接口,里面有一些常用方法,一些不常用的方法可以查询API使用,下面的实现类:ArrayList 、 LinkedList ,都是要实现这些方法的:
boolean add(E e)
确保此集合包含指定的元素(可选操作)。
void clear()
从此集合中删除所有元素(可选操作)。
boolean contains(Object o)
如果此集合包含指定的元素,则返回 true 。
boolean equals(Object o)
将指定的对象与此集合进行比较以获得相等性。
int hashCode()
返回此集合的哈希码值。
boolean isEmpty()
如果此集合不包含元素,则返回 true 。
Iterator<E> iterator()
返回此集合中的元素的迭代器。
boolean remove(Object o)
从该集合中删除指定元素的单个实例(如果存在)(可选操作)。
boolean retainAll(Collection<?> c)
仅保留此集合中包含在指定集合中的元素(可选操作)。
int size()
返回此集合中的元素数。
Object[] toArray()
返回一个包含此集合中所有元素的数组。
java.util.Iterable接口:迭代器
Iterable是所有集合接口和类的祖先类,证明每一个被实现的集合类型中的内容都是可迭代,每一个实现类都要实现制造迭代器这个函数。Iterator是一个接口,所以每个实现类也需要实现这个的Iterator这个接口。
Iterator<T> iterator()
返回类型为 T元素的迭代器。
以Arraylist为例子,下面是ArrayList的部分源代码,实现Iterator iterator()这个方法:
如何实现Iterator这个函数?采用了内部类的方式。Iterator主要是针对某一种数据结构特别设定的类,生成的对象其作用就是索引,或者是指针,初始状态下索引或者指向第一个元素的前一个位置,通过调用hasNext来判断是否有值,通过next获取下一个元素值,这些方法对所有的Collection类型都适用:
boolean hasNext()
如果迭代具有更多元素,则返回 true 。
E next()
返回迭代中的下一个元素。并且指针向下移动一次。
default void remove()
从底层集合中删除此迭代器返回的最后一个元素(可选操作)
java.util.List :表集合(顺序表和链表的通用方法)
像顺序表和链表这种数据结构肯定新增一些方法,这些方法组成的List接口,这个接口中的方法会被顺序表和链表实现。
比如E get(int index),在Queue和Stack中尽量就不要使用,因为这两种数据结构是对头和尾都有限制的操作。
以下是顺序表和链表特有的,常用的一些方法:
void add(int index, E element)
将指定的元素插入此列表中的指定位置(可选操作)。
E get(int index)
返回此列表中指定位置的元素。
int indexOf(Object o)
返回此列表中指定元素的第一次出现的索引,如果此列表不包含元素,则返回-1。
ListIterator<E> listIterator()
返回列表中的列表迭代器(按适当的顺序)。
ListIterator<E> listIterator(int index)
从列表中的指定位置开始,返回列表中的元素(按正确顺序)的列表迭代器。
E remove(int index)
删除该列表中指定位置的元素(可选操作)。
boolean remove(Object o)
从列表中删除指定元素的第一个出现(如果存在)(可选操作)。
E set(int index, E element)
用指定的元素(可选操作)替换此列表中指定位置的元素。
java.util.ArrayList
ArrayList实现了java.util.List这些方法。
ArrayList实现的是顺序表。
ArrayList是一个泛型类,但是类中的属性是非泛型的。是Obejct类型,但是其中的方法很多都是带泛型的。
要注意擦拭法,ArrayList满足类型自动推断和自动转换,get,set,iterator方法都可以进行自动转换。
其中的基本操作函数和数据结构的思想类似,增加后移,删除前移等等。
案例
public class Main{
public static void main(String[] args){
ArrayList<String> arrayList = new ArrayList<>();
String s = "1111";
arrayList.add(s);
arrayList.add("bbb");
arrayList.add("ccc");
arrayList.add("ddd");
arrayList.add(0,"zzz");
String ss = arrayList.get(0); // get方法擦拭之后,本来返回的是Object类型,但是泛型有自动转换的机制。
System.out.println(ss);
for (String sss : arrayList){
System.out.println(sss);
}
}
}
java.util.LinkedList
LinkedList实现了java.util.List这些方法。
LinkedList实现的是双向链表,带有头尾指针,不是双向循环链表,是双向链表。
LinkedList是一个泛型类,类中的属性有头指针和尾指针组成,实现方式和双向链表一样
要注意擦拭法,LinkedList满足类型自动推断和自动转换,get,set,iterator方法都可以进行自动转换。
其中的基本操作函数和数据结构的思想类似,插入是先右后左等等。
public class Main{
public static void main(String[] args){
LinkedList<String> b = new LinkedList<>();
b.add("Bob");
b.add("Doug");
b.add("Frances");
b.add("Gloria");
System.out.println(b.getLast()); // 自动类型转换
for (String ss : b){
System.out.println(ss);
}
}
}
java.util.Set:Set集合的接口
Set集合的特点:元素不重复,存取无顺序、序,无下标,存取都是没有特定顺序的,并且指针指向的元素不能重复
其中Set集合存取无顺序就是说,存进去的顺序和取出来的顺序大多数不一致。
接口常用方法:
boolean add(E e)
如果指定的元素不存在,则将其指定的元素添加(可选操作)。
void clear()
从此集合中删除所有元素(可选操作)。
boolean contains(Object o)
如果此集合包含指定的元素,则返回 true 。
boolean equals(Object o)
将指定的对象与此集合进行比较以实现相等。
int hashCode()
返回此集合的哈希码值。
boolean isEmpty()
如果此集合不包含元素,则返回 true 。
Iterator<E> iterator()
返回此集合中元素的迭代器。
boolean remove(Object o)
如果存在,则从该集合中删除指定的元素(可选操作)。
int size()
返回此集合中的元素数(其基数)。
default Spliterator<E> spliterator()
在此集合中的元素上创建一个 Spliterator 。
Object[] toArray()
返回一个包含此集合中所有元素的数组。
<T> T[] toArray(T[] a)
返回一个包含此集合中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。
其中只有基本的一些方法,并没有下标,因为这是Set集合的特征。
java.util.HashSet
HashSet泛型原理和List集合基本一致,实现了Set集合的方法,但是呢,底层用的是HashMap集合。
HashSet不能有方法带有下标的方法get,indexOf等等方法,所以这个类比较容易。
HashSet底层是基于 HashMap 的k实现的,元素不可重复,特性同 HashMap。
public class Main{
public static void main(String[] args){
HashSet<String> hs = new HashSet<>();
hs.add("Doug");
hs.add("Frances");
hs.add("Bob");
hs.add("Doug");
hs.add("Frances");
hs.add("Gloria");
for (String s : hs){
System.out.println(s.hashCode());
}
}
}
案例:
public class Main{
public static void main(String[] args){
TreeSet<String> hs = new TreeSet<>();
hs.add("1111");
hs.add("Doug");
hs.add("Frances");
hs.add("Bob");
hs.add("Doug");
hs.add("Frances");
hs.add("Gloria");
for (String s : hs){
System.out.println(s + ":" +s.hashCode()); // 和hashcode无关
}
}
}
java.util.TreeSet
TreeSet泛型原理和List集合基本一致,实现了Set集合的方法,但是呢,底层用的是TreeSet集合。
TreeSet不能有方法带有下标的方法get,indexOf等等方法,所以这个类比较容易。
TreeSet底层是基于TreeMap 的k实现的,元素不可重复,特性同TreeMap。
TreeSet中的数据元素是自动排序的,有大小关系的,是有序的,但是是无顺序的,不可重复的
public class Main{
public static void main(String[] args){
TreeSet<String> hs = new TreeSet<>();
hs.add("Doug");
hs.add("Frances");
hs.add("Bob");
hs.add("Doug");
hs.add("Frances");
hs.add("Gloria");
for (String s : hs){
System.out.println(s + ":" +s.hashCode()); // 和hashcode无关
}
}
}
Set 集合的实现,基本都是基于 Map 中的键做文章,使用 Map 中键不能重复、无顺序的特性;所以,只需要重点关注 Map 的实现即可!
java.util.Map及其映射集合
Map集合,是基于哈希表的数据结构,基本采用的是链地址法这种形式。
基于K-V形式,存储的是K-V所指对象的地址
java.util.Map:接口常用方法
void clear()
从该地图中删除所有的映射(可选操作)。
boolean containsKey(Object key)
如果此映射包含指定键的映射,则返回 true 。
boolean containsValue(Object value)
如果此地图将一个或多个键映射到指定的值,则返回 true 。
Set<Map.Entry<K,V>> entrySet()
返回此地图中包含的映射的Set视图。
boolean equals(Object o)
将指定的对象与此映射进行比较以获得相等性。
V get(Object key)
返回到指定键所映射的值,或 null如果此映射包含该键的映射。
int hashCode()
返回此地图的哈希码值。
boolean isEmpty()
如果此地图不包含键值映射,则返回 true 。
Set<K> keySet()
返回此地图中包含的键的Set视图。
V put(K key, V value)
将指定的值与该映射中的指定键相关联(可选操作)。
V remove(Object key)
如果存在(从可选的操作),从该地图中删除一个键的映射。
default boolean remove(Object key, Object value)
仅当指定的密钥当前映射到指定的值时删除该条目。
default V replace(K key, V value)
只有当目标映射到某个值时,才能替换指定键的条目。
default boolean replace(K key, V oldValue, V newValue)
仅当当前映射到指定的值时,才能替换指定键的条目。
int size()
返回此地图中键值映射的数量。
Collection<V> values()
返回此地图中包含的值的Collection视图。
案例
public class Main {
public static void main(String[] args) {
HashMap<Integer, String> hs = new HashMap<Integer, String>();
hs.put(1, "222");
hs.put(2, "111");
hs.put(100, "333");
hs.put(4, "4444");
Collection<String> cl = hs.values(); // 返回此地图中包含的值的Collection视图,包含Value
for(String ss : cl) {
System.out.println(ss);
}
Set<Integer> set = hs.keySet(); // 返回此地图中包含的键的Set视图,包含Key
for(Integer i : set) {
System.out.println(i);
}
Set<Map.Entry<Integer, String>> sset = hs.entrySet(); // 返回此地图中包含的映射的Set视图,内容是返回整个key和valuse,即Node对象
for(Map.Entry<Integer, String> me : sset) {
System.out.println(me);
}
}
}
java.util.HashMap
HashMap是内部原理是基于链地址法来解决冲突
通过hashcode的值进入hash算法确定下标
key的位置不确定,所以HashSet是没有排序的
Key的类需要重写hashcode和equals方法来保持Key的唯一性,不重写hashcode就会导致每个对象都不一样,出现对象属性一样,但是对象不一样。
不重写equals,就无法判断出Key部分是否相等,equls即能判断出是否是属于同一个类,又能判断属性是否相等。
在使用get和put方法中,类的属性相等,hashcode必须相等
public class Main {
public static void main(String[] args) {
HashMap<A, String> hs = new HashMap<>();
hs.put(new A(), "222");
hs.put(new A(), "111");
hs.put(new A(), "333");
hs.put(new A(), "4444");
Collection<String> cl = hs.values();
for(String ss : cl) {
System.out.println(ss);
}
Set<A> set = hs.keySet();
for(A i : set) {
System.out.println(i);
}
Set<Map.Entry<A, String>> sset = hs.entrySet();
for(Map.Entry<A, String> me : sset) {
System.out.println(me.toString());
}
}
}
class A{
private int i;
@Override
public String toString() {
return this.i + "";
}
}
java.util.TreeMap
使用方法和原理如下,基于红黑树:
https://www.cnblogs.com/liahon/p/11221634.html
Key类型自己定义也需要实现CompareTo方法,用来进行排序,因为红黑树和AVL树都是基于二叉排序树的改进,所以排序的时候,如果重复就不会添加到树结构中。