java集合接口和常见类
「这是我参与11月更文挑战的第1天,活动详情查看:2021最后一次更文挑战」
集合就是许多数据(啥类型的都有)存储在同一个“容器”中,那个“容器”好像就叫做集合,哈哈哈。 从数据库中提取出来数据,在后端存入一个集合,然后前端调用这个集合,然后一股脑的将该集合中的数据加载到页面上,让用户能看到数据。应该是这么回事。
一、Collection接口
Collection接口是List接口和Set接口的父接口,所以该接口中封装的方法,子接口可以照常使用。
以下方法都是基础的方法,详细的请查看API
java public static void main(String[] args) { /* Collection接口的常用方法: 增加:add(E e) addAll(Collection<? extends E> c) 删除:clear() remove(Object o) 查看:iterator() size() 判断:contains(Object o) equals(Object o) isEmpty() */ //创建对象:接口不能创建对象,利用实现类创建对象:该创建方法为多态的一种使用方法 Collection col = new ArrayList(); //调用方法: //集合有一个特点:只能存放引用数据类型的数据,不能是基本数据类型 //基本数据类型自动装箱,对应包装类。int--->Integer col.add(18); //向集合中添加数据 //将这些数据转换成包装类,然后调用Arrays类中的asList方法转换为List集合 List list = Arrays.asList(new Integer[]{11, 15, 3, 7, 1}); col.addAll(list);//将另一个集合添加入col中 //col.clear();清空集合 System.out.println("集合中元素的数量为:"+col.size()); System.out.println("集合是否为空:"+col.isEmpty()); //返回值为布尔类型,true或false boolean isRemove = col.remove(15); //删除值为15的元素 System.out.println("集合中数据是否被删除:"+isRemove); //返回值为布尔类型,true或false Collection col2 = new ArrayList(); col2.add(18); col2.add(12); Collection col3 = new ArrayList(); col3.add(18); col3.add(12); System.out.println(col2.equals(col3)); //调用equals方法比较两个集合中的元素是否相等,返回true或false System.out.println(col2==col3);//地址一定不相等 false System.out.println("是否包含元素:"+col3.contains(117)); //contain是否包含此元素,返回true或false }
1.List接口(继承于Collection接口)(特点:不唯一,有序的)
因为List接口为有序的集合,所以在该集合中增加的方法都是一些与索引相关的方法。 增加:add(int index, E element) 删除:remove(int index) remove(Object o) 修改:set(int index, E element) 查看:get(int index) List集合的遍历:
java //方式1:普通for循环: System.out.println("---------------------"); for(int i = 0;i<list.size();i++){ System.out.println(list.get(i)); } //方式2:增强for循环: System.out.println("---------------------"); for(Object obj:list){ System.out.println(obj); } //方式3:迭代器: System.out.println("---------------------"); //Iterator为迭代器,后续会介绍 Iterator it = list.iterator(); while(it.hasNext()){ System.out.println(it.next());
(1)、ArrayList类(底层为数组存储)
因为JDK1.7跟JDK1.8版本的ArrayList是不一样的,所以我会分别列举: 1.7版本:当在调用构造器时,数组初始化的长度为10,然后当数据超出初始化时,会自动扩容为原来的1,5倍,然后再将老数组指向新数组,在返回新数组。 1.8版本:当在调用构造器时,底层数组为null,只有在调用add方法以后底层的数组才重新复制新的数组,长度为10,也是扩容1.5倍。优点:节省内存 ArrayList的线程不安全,但是效率高 数组的优点:查询速度快,但是可以重复。 数组的缺点:删除,增加元素效率低
(2)、Vector类(已淘汰,底层为数组存储)
该类底层也是数组,但是该类扩容2倍,线程安全,效率低。
(3)、LinkeList类(底层为双向链表存储)
LinkedList的源码: ```java public class LinkedList
{//E是一个泛型,具体的类型要在实例化的时候才会最终确定 transient int size = 0;//集合中元素的数量 //Node的内部类 private static class Node
{ E item;//当前元素 Node
next;//指向下一个元素地址 Node
prev;//上一个元素地址 Node(Node
prev, E element, Node
next) { this.item = element; this.next = next; this.prev = prev; } } transient Node
first;//链表的首节点 transient Node
last;//链表的尾节点 //空构造器: public LinkedList() { } //添加元素操作: public boolean add(E e) { linkLast(e); return true; } void linkLast(E e) {//添加的元素e final Node
l = last;//将链表中的last节点给l 如果是第一个元素的话 l为null //将元素封装为一个Node具体的对象: final Node
newNode = new Node<>(l, e, null); //将链表的last节点指向新的创建的对象: last = newNode;
if (l == null)//如果添加的是第一个节点
first = newNode;//将链表的first节点指向为新节点
else//如果添加的不是第一个节点
l.next = newNode;//将l的下一个指向为新的节点
size++;//集合中元素数量加1操作
modCount++;
}
//获取集合中元素数量
public int size() {
return size;
}
//通过索引得到元素:
public E get(int index) {
checkElementIndex(index);//健壮性考虑
return node(index).item;
}
Node<E> node(int index) {
//如果index在链表的前半段,那么从前往后找
if (index < (size >> 1)) {
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {//如果index在链表的后半段,那么从后往前找
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
} ```
2.Set接口(继承于Collection接口)(特点:唯一,无序的)
该接口因为是无序的(而非随机,而是根据底层的算法来进行排序),所以没有与索引相关方法。
遍历的方法:使用Iterator迭代器迭代;增强for循环遍历。
(1)、HashSet类(底层为哈希表(数组+链表)存储)
该类下还有一个实现类为:LinkedHashSet实现类。
该类的特点为:唯一,而且有序的(按照输入的顺序输出)。
该类底层是HashMap类。
(2)、TreeSet类(底层为二叉树存储)
该类的特点:唯一,有序的(是按照升序的排序进行输出),无序(没有按照输入的方式进行输出)。
底层原理:实现内部比较器(compareTo)或者外部比较器(compare)
当调用TreeSet的空构造器时,底层创建了一个TreeMap。
二、Map接口
Map接口的常用方法: java import java.util.Collection; import java.util.HashMap; import java.util.Map; import java.util.Set; 增加:put(K key, V value) 删除:clear() remove(Object key) 修改: 查看:entrySet() get(Object key) keySet() size() values() 判断:containsKey(Object key) containsValue(Object value) equals(Object o) isEmpty() */ //创建一个Map集合:无序,唯一 Map<String,Integer> map = new HashMap<>(); System.out.println(map.put("lili", 10101010)); map.put("nana",12345234); map.put("feifei",34563465); System.out.println(map.put("lili", 34565677)); map.put("mingming",12323); /*map.clear();清空*/ /*map.remove("feifei");移除*/ System.out.println(map.size()); System.out.println(map); System.out.println(map.containsKey("lili")); System.out.println(map.containsValue(12323)); Map<String,Integer> map2 = new HashMap<>(); System.out.println(map2.put("lili", 10101010)); map2.put("nana",12345234); map2.put("feifei",34563465); System.out.println(map2.put("lili", 34565677)); map2.put("mingming2",12323); System.out.println(map==map2); System.out.println(map.equals(map2));//equals进行了重写,比较的是集合中的值是否一致 System.out.println("判断是否为空:"+map.isEmpty()); System.out.println(map.get("nana")); System.out.println("-----------------------------------"); //keySet()对集合中的key进行遍历查看: Set<String> set = map.keySet(); for(String s:set){ System.out.println(s); } System.out.println("-----------------------------------"); //values()对集合中的value进行遍历查看: Collection<Integer> values = map.values(); for(Integer i:values){ System.out.println(i); } System.out.println("-----------------------------------"); //get(Object key) keySet() Set<String> set2 = map.keySet(); for(String s:set2){ System.out.println(map.get(s)); } System.out.println("-----------------------------------"); //entrySet() Set<Map.Entry<String, Integer>> entries = map.entrySet(); for(Map.Entry<String, Integer> e:entries){ System.out.println(e.getKey()+"----"+e.getValue()); } } }
1、HashMap类(底层为哈希表(数组+链表)存储)
HashMap实现类的特点为:无序,但唯一。
该实现类按照key值进行排序总结,因底层key是按照哈希表的结构进行排序。
所以当放入这个集合的数据对应的类时,必须重写HashCode方法(将key进行哈希运算)和equals方法(判断维不唯一)。
HashMap源码详解:
```java
public class HashMap extends AbstractMap //【1】继承的AbstractMap中,已经实现了Map接口,这个地方属于重复使用 implements Map , Cloneable, Serializable{ static final int DEFAULT INITIALCAPACITY = 16;//哈希表主数组的默认长度 //定义了一个float类型的变量,以后作为:默认的装填因子,加载因子是表示Hsah表中元素的填满的程度 //太大容易引起哈西冲突,太小容易浪费 0.75是经过大量运算后得到的最好值 static final float DEFAULT LOADFACTOR = 0.75f; transient Entry [] table;//主数组,每个元素为Entry类型 transient int size; int threshold;//数组扩容的界限值,门槛值 16*0.75=12 final float loadFactor;//用来接收装填因子的变量
//【4】查看构造器:内部相当于:this(16,0.75f);调用了当前类中的带参构造器
public HashMap() {
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
//【5】本类中带参数构造器:--》作用给一些数值进行初始化的!
public HashMap(int initialCapacity, float loadFactor) {
//【6】给capacity赋值,capacity的值一定是 大于你传进来的initialCapacity 的 最小的 2的倍数
int capacity = 1;
while (capacity < initialCapacity)
capacity <<= 1;
//【7】给loadFactor赋值,将装填因子0.75赋值给loadFactor
this.loadFactor = loadFactor;
//【8】数组扩容的界限值,门槛值
threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
//【9】给table数组赋值,初始化数组长度为16
table = new Entry[capacity];
}
//【10】调用put方法:
public V put(K key, V value) {
//【11】对空值的判断
if (key == null)
return putForNullKey(value);
//【12】调用hash方法,获取哈希码
int hash = hash(key);
//【14】得到key对应在数组中的位置
int i = indexFor(hash, table.length);
//【16】如果你放入的元素,在主数组那个位置上没有值,e==null 那么下面这个循环不走
//当在同一个位置上放入元素的时候
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
//哈希值一样 并且 equals相比一样
//(k = e.key) == key 如果是一个对象就不用比较equals了
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
//【17】走addEntry添加这个节点的方法:
addEntry(hash, key, value, i);
return null;
}
//【13】hash方法返回这个key对应的哈希值,内部进行二次散列,为了尽量保证不同的key得到不同的哈希码!
final int hash(Object k) {
int h = 0;
if (useAltHashing) {
if (k instanceof String) {
return sun.misc.Hashing.stringHash32((String) k);
}
h = hashSeed;
}
//k.hashCode()函数调用的是key键值类型自带的哈希函数,
//由于不同的对象其hashCode()有可能相同,所以需对hashCode()再次哈希,以降低相同率。
h ^= k.hashCode();
// This function ensures that hashCodes that differ only by
// constant multiples at each bit position have a bounded
// number of collisions (approximately 8 at default load factor).
/*
接下来的一串与运算和异或运算,称之为“扰动函数”,
扰动的核心思想在于使计算出来的值在保留原有相关特性的基础上,
增加其值的不确定性,从而降低冲突的概率。
不同的版本实现的方式不一样,但其根本思想是一致的。
往右移动的目的,就是为了将h的高位利用起来,减少哈西冲突
*/
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
//【15】返回int类型数组的坐标
static int indexFor(int h, int length) {
//其实这个算法就是取模运算:h%length,取模效率不如位运算
return h & (length-1);
}
//【18】调用addEntry
void addEntry(int hash, K key, V value, int bucketIndex) {
//【25】size的大小 大于 16*0.75=12的时候,比如你放入的是第13个,这第13个你打算放在没有元素的位置上的时候
if ((size >= threshold) && (null != table[bucketIndex])) {
//【26】主数组扩容为2倍
resize(2 * table.length);
//【30】重新调整当前元素的hash码
hash = (null != key) ? hash(key) : 0;
//【31】重新计算元素位置
bucketIndex = indexFor(hash, table.length);
}
//【19】将hash,key,value,bucketIndex位置 封装为一个Entry对象:
createEntry(hash, key, value, bucketIndex);
}
//【20】
void createEntry(int hash, K key, V value, int bucketIndex) {
//【21】获取bucketIndex位置上的元素给e
Entry<K,V> e = table[bucketIndex];
//【22】然后将hash, key, value封装为一个对象,然后将下一个元素的指向为e (链表的头插法)
//【23】将新的Entry放在table[bucketIndex]的位置上
table[bucketIndex] = new Entry<>(hash, key, value, e);
//【24】集合中加入一个元素 size+1
size++;
}
//【27】
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
//【28】创建长度为newCapacity的数组
Entry[] newTable = new Entry[newCapacity];
boolean oldAltHashing = useAltHashing;
useAltHashing |= sun.misc.VM.isBooted() &&
(newCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
boolean rehash = oldAltHashing ^ useAltHashing;
//【28.5】转让方法:将老数组中的东西都重新放入新数组中
transfer(newTable, rehash);
//【29】老数组替换为新数组
table = newTable;
//【29.5】重新计算
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
//【28.6】
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry<K,V> e : table) {
while(null != e) {
Entry<K,V> next = e.next;
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
//【28.7】将哈希值,和新的数组容量传进去,重新计算key在新数组中的位置
int i = indexFor(e.hash, newCapacity);
//【28.8】头插法
e.next = newTable[i];//获取链表上元素给e.next
newTable[i] = e;//然后将e放在i位置
e = next;//e再指向下一个节点继续遍历
}
}
}
} ``` HashMap效率高,但线程不安全。key可以存入null值,并且key的null值也遵循唯一的特点。 在JDK1.2之前有个Hashtable实现类,但是它的效率低,线程安全,并且key不可以存入null值。
2、TreeMap类(底层为二叉树存储)
TreeMAp底层为二叉树,所以遵照二叉树的特点,放入集合的key的数据对应的类型内部一定要实现比较器(内部或外部比较器)。
补充泛型的相关知识
泛型就相当于标签 形式:<>
集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象,所以在JDK1.5之前只能把元素类型设计为Object, JDK1.5之 后使用泛型来解决。因为这个时候除了元素的类型不确定,其他的部分是确定的,例如关于这个元素如何保存,如何管理等是确定的,因此此时把元素的类型设计成一个参数,这个类型参数叫做泛型。 Collection
,List
,ArrayList
中的
就是类型参数,就是泛型。 示例代码:
java import java.util.ArrayList; public class Test01 { //这是main方法,程序的入口 public static void main(String[] args) { //创建一个ArrayList集合,向这个集合中存入学生的成绩: //加入泛型的优点:在编译时期就会对类型进行检查,不是泛型对应的类型就不可以添加入这个集合。 ArrayList<Integer> al = new ArrayList<Integer>(); al.add(98); al.add(18); al.add(39); al.add(60); al.add(83); /*al.add("丽丽"); al.add(9.8);*/ //对集合遍历查看: /*for(Object obj:al){ System.out.println(obj); }*/ for(Integer i:al){ System.out.println(i); } } }
· 泛型引用的必须都是引用数据类型,不能是基本数据类型。
·ArrayList<Integer> al = new ArrayList<Integer>();在JDK1.7之后可以写钻石运算符:ArrayList<Integer> al = new ArrayList<>();
`泛型继承关系:当父类指定了泛型,子类可以直接使用;当父类没指定泛型时,那么子类可以在创建子类对象的时候指定泛型。
·泛型类可以定义多个参数。例如:
public class TestGeneric<A,B,C>{
A age ; B name ; C sex ;
public void a(A m , B n , C x ){
}
}
·静态方法不能使用类的泛型;也就是有static关键词修饰的方法
·泛型如果没被指定,那么系统就会把他擦除。
泛型方法的含义:没带泛型的方法为泛型方法。 泛型方法对应的参数类型与当前所在的这个类是否为泛型类,是否为泛型无关。 · 泛型方法的定义前边要加上< T >,< T >在调用方法的时候确认。泛型方法可以是静态方法。 示例: java public static <T> void b(T t){ }
泛型的通配符>的作用:当G< A >和G< B >不存在父子关系时,加入G>就会变成他俩的父类。 List extends Person>: 就相当于: List extends Person>是List
的父类,是List
List super Person>就相当于:List super Person>是List 的父类,是List
补充二叉树的比较器compareTo方法的与原理及使用
比较器分为内部比较器compareTo()跟外部比较器compareTo()
String类实现了Comparable接口,这个接口中有一个抽象方法compareTo,String类中重写这个方法即可。 内部比较器的使用逻辑代码里重写compareTo()方法。 外部比较器是创建单独的类来重写compare()方法。
问题1:Iterator迭代器与ListIterator迭代器的区别
Iterator只是单纯的迭代数据。 当程序需要对集合进行迭代加修改双重操作时,就会使用ListIterator。
问题2:iterator(),Iterator,Iterable的关系
HashMap中的装填因子是0.75的原因
这时我们得考虑时间跟空间的问题
如果装填因子为1,那么就证明需要等到数组满了时候才能进行数组2倍扩容,这样可以做到最大的空间利用率,但是现实中元素不可能完全的均匀分布,那就很可能发生哈希碰撞,就会产生链表,产生链表就会使查询速度变慢。 所以说当装填因子为1时,能做到最大的空间利用率,但是时间会变慢。
如果装填因子变小,变到0.5时,也就说当元素数量增加到数组容量的一半时就会进行2倍的数组扩容,这样做可以减少哈希碰撞,若不产生链表,那么查询的效率很高,但是会浪费空间。 所以当装填因子为0.5时,查询时间会很快,但是空间会浪费。
所以我们会在空间和时间中取中间值0.75来平衡这个因素。