集合(JAVA高级)

1.1集合框架的概述

1.1.1java集合是什么?

1.java语言对事物的体现都是以对象的形式,因此我们就会大量操作对象,就会对对象进行存储。

2.在初级阶段我们使用的array存储对象会有很多弊端,而java集合就像是一个容器,可以动态的把多个对象的引用放入容器中。

1.1.2数组在内存存储的特点

1)数组一旦初始化之后长度就不可变了

2)数组声明时是什么类型,就决定了之后存储元素的类型

1.1.3数组在存储时的弊端

1)长度不可变,扩展性差

2)数组提供的属性和方法少,增删改查操作繁琐,效率低

3)数组存储数据太单一

1.1.4集合框架体系图


1.2Collection接口方法

1.2.1Collection接口

1)Collection接口是List、Set的父接口,因此二者中的方法可以通用。

2)在java5之前集合会丢失容器中的对象数据类型,所有的对象都当做是Object类型处理,在java5之后增加了泛型以后,java集合可以记住容器当中的对象的数据类型。

1.2.2Collection接口方法

1)添加

①add(Object obj)

②addAll(Collection)

2)获取集合中元素个数

①int size()

3)清空集合

①void clear()

4)是否为空

①boolean isEmpty()

5)集合中是否包含某个元素

①boolean contains(Object obj)

②boolean containsAll(Collection col)

6)删除

①boolean remove(Object obj)

②boolean removeAll(Collection col)

7)两个集合的交集

①boolean retainAll(Collection col)

8)判断集合是否相等

①boolean equals(Object obj)

9)转为对象数组

①Object[] toArray()

10)获取集合对象的哈希值

①hashCode()

11)遍历

①iterator()


1.3Iterator迭代器接口

1.3.1迭代器概述

  由于Collection接口继承了Iterator接口,因此iterator()方法在所有实现Collection接口的集合类中都可使用,用来返回一个实现Iterator接口的对象。

1.3.2迭代器作用

1)Iterator用于遍历集合

注意:每次在调用iterator()方法是都会得到一个全新的迭代器对象,默认游标都在集合的第一个元素之前。

1.3.3迭代器中的方法

 

注意:在调用it.next()方法之前必须调用it.hasNext()进行检测下一个位置是否有元素,如果直接调用it.next()会抛出NoSuchElementException异常。 

Iterator it = coll.iterator();
while(it.hasNext()){
    System.out.println(it.next());
 }

 1.4List接口

1.4.1List接口概述

1.List集合中元素有序、可重复,有索引下标

2.List接口常用的实现类有ArrayList、LinekList。

1.4.2List接口方法

1.void add(int index,Object obj):在index处插入元素obj元素

2.boolean addAll(int index,Collection col):从index开始把col中所有元素添加进去

3.get (int index):获取指定index位置的元素

4.indexOf(Object obj):返回obj在集合中第一次出现的位置

5.lastIndexOf(Object obj):返回obj在集合中最末尾出现的位置

6.remove()删除指定位置的元素

7.set(int index,Object obj):把index位置的元素换成元素obj

8.subList(int fromIndex,int toIndex):返回从fromIndex到toIndex位置的子集合

 1.4.3ArrayList

1.ArrayList是List接口的主要实现类

2.可以把ArrayList对象引用理解为一个变长的数组

3.ArrayList在java7时像饿汉式,直接创建一个初始化为10的数组,在java8时像懒汉式,一开始创建一个长度为0的数组,当添加第一个元素时再创建一个初始化为10的数组

1.4.4LinkedList

1.对于频繁的插入或删除元素的操作,建议使用LinkedList类,效率更高

2.LinkedList: 双向链表 ,内部没有声明数组,而是定义了 Node 类型的 first last, 用于记录首末元素。同时,定义内部类Node ,作为 LinkedList 中保存数据的基本结构。 
Node 除了保存数据,还定义了两个变量:
①prev 变量记录前一个元素的位置
②next 变量记录下一个元素的位置
private static class Node<E> {
E item;
Node<E> next;
Node<E> prev;
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}

1.4.5ArrayListLinkedList的异同

  二者都是线程不安全,ArrayList是实现了基于动态数组的数据结构,LinkedList基于链表的数据结构。对于随机访问get和set,ArrayList更优于LinkedList,因为LinkedList要移动指针。对于新增和删除操作LinkedList更好,因为ArrayList要移动数据。


1.5set接口

1.5.1set接口概述

1.set接口是Collection的子接口,set接口没有提供额外的方法

2.set集合不允许包含相同的元素,如果试把两个相同的元素加入同一个set集合中,则添加操作失败。

3.set判断两个对象是否相同不是使用==运算符,是根据equals()方法

1.5.2set实现类之一:HashSet

1.HashSet是按Hash算法存储集合中的元素,因此具有很好的存取、查找、删除性能

2.不能保证元素排序顺序,线程不安全,集合元素可以为null

3.HashSet根据两个对象HashCode()方法比较相等并且两个对象的equals()方法返回值也相等。

4.对于存放在Set容器中的对象,对应的类一定要重写equals()和hashCode(Object obj)方法,以实现对象相等规则。即:“相等的对象必须具有相等的散列码”。

1.5.3向HashSet中添加元素的过程

1.首先判断两个元素的hashCode()值是否相等,如果相等继续调用equals()方法,如果返回true,添加失败,如果返回false,那会会保存元素,但是该位置上的数组已经有元素了那么会通过链表的方式继续连接(java7 HashSet底层:数组+链表)

1.5.4TreeSet

1.TreeSet可以确保集合元素处于排序状态。底层使用红黑树结构存储数据

2.TreeSet两种排序方法:自然排序和定制排序。默认使用自然排序

2.1自然排序:

1)TreeSet会调用集合元素的comparaTo方法来比较元素之间的大小关系,然后将集合元素按升序排列

2)实现Comparable的类必须实现comparaTo()方法,两个对象即通过comparaTo()方法返回值比较大小

2.2定制排序

1)在自然排序中要求元素实现Comparable接口,如果你不想实现这个接口或者不希望按照升序的方式排序,则考虑使用定制排序,定制排序通过Comparator接口来实现,需要重写compare()方法


1.6Map接口

1.Map与Collection并列存在。用于保存具有映射关系的:key-value

2.Map中的key和value都可以是任何引用类型的数据

3.Map中的key用set来存放,不允许重复,即同一个map对象所对应的类必须重写hashCode()和equals()方法

4.key和value之间存在单向的一对一的关系,即通过指定的key总能找到唯一的、确定的value

1.6.1Map接口:常用方法 

添加、删除、修改操作:

1)put(Object key,Object value):将指定的key-value添加到当前map对象中

2)putAll(Map map):将map中所有key-value对存放到当前map中

3)remove(Object key):移除指定key的key-value,并返回value

4)clear():清空当前map中的所有数据

元素查询的操作:

1)get(Object key):获取指定key对应的value

2)boolean containsKey(Object key):是否包含指定key

3)boolean containsValue(Object calue):是否包含指定的value

4)int size() :返回map中key-value对的个数

5)boolean idEmpty():判断当前map是否为空

6)boolean equals(Object obj):判断当前map和参数对象obj是否相等

原始图操作的方法:

1)Set keySet():返回所有key构成的Set集合

2)Collection values():返回所有value构成的Collection集合

3)Set entrySet():返回所有key-value对构成的Set集合

Map map = new HashMap();
System.out.println("map的所有key:");
Set keys = map.keySet();//keySet()
for (Object key : keys) {
System.out.println(key + "->" + map.get(key));
}
System.out.println("map的所有的value:");
Collection values = map.values();//values()
Iterator iter = values.iterator();
while (iter.hasNext()) {
System.out.println(iter.next());
}
System.out.println("map所有的映射关系:");
Set mappings = map.entrySet();//entrySet()
for (Object mapping : mappings) {
Map.Entry entry = (Map.Entry) mapping;
System.out.println("key是:" + entry.getKey() + ",value是:" + entry.getValue());
}

1.6.2HashMap

1.HashMap是Map接口使用频率最高的实现类

2.与HashSet一样不保证映射的顺序

3.所有的key构成的集合是Set:无序的、不可重复的。所以value所在的类要重写equals()

4.一个key-value构成一个entry

5.所有的entry构成的集合是Set:无序的、不可重复的

6.HashMap判断两个key相等的标准是:两个key通过equals()方法返回true,hashCode值也得相等

7.HashMap判断两个value相等的标准是:两个value通过equals()方法返回true


1.7HashMap存储结构

jdk8之前:HashMap是数组+链表结构

jdk8发布以后:HashMap是数组+链表+红黑树实现

1.7.1jdk7及之前

1)底层实现原理

HashMap的内部存储结构是数组+链表的结合。当实例化一个HashMap时,系统会创建一个长度为Capacity的Entry数组,这个长度是容量,在这个存放元素的位置我们称之为bucket,每个bucket都有自己的索引,系统可以根据索引快速找到其中元素。而在bucket中 的每个元素都是一个entry对象,每一个entry对象可以带一个引用变量,用于指向下一个元素,因此,在一个bucket里面可能生成一个Entry链,并且新添加的元素作为链表的head。

2)扩容问题

当HashMap中的元素越来越多的时候,hash冲突的几率也就越来越高,因为数组的长度是固定的。所以为了提高查询效率,就要对HashMap的数组进行扩容,而在HashMap数组扩容之后,最消耗性能的点就是:原数组的所有元素必须重新计算在新数组的位置,并且放进去,这样很消耗性能。

3)何时进行扩容

当HashMap中的元素个数超过数组大小(数组总大小length)*loadFactor(填充因子固定值,默认值一般为0.75)时,就会进行数组的扩容。也就是说默认情况下,数组大小为16,而数组中元素达到16*0.75=12的时候,就会扩容为原来二倍,然后进行上述的扩容问题。

1.7.2jdk1.8

1)底层原理

HashMap的内部变为数组+链表+树的结合。当实例化一个 HashMap时,会初始化initialCapacityloadFactor,在put第一对映射关系 时,系统会创建一个长度为initialCapacityNode数组,这个长度在哈希表中被称为容量(Capacity),在这个数组中可以存放元素的位置我们称之为 bucket,每个bucket都有自己的索引,系统可以根据索引快速的查 找bucket中的元素。

2)每个bucket中存储一个元素,即一个Node对象,但每一个Node对象可以带一个引用变量next,用于指向下一个元素,因此,在一个桶中,就有可能生成一个Node链。也可能是一个一个TreeNode对象,每一个TreeNode对象可以有两个叶子结点left和right,因此,在一个桶中,就有可能生成一个TreeNode树。而新添加的元素作为链表的last,或树的叶子结点。

3)扩容问题

在jdk1.7扩容问题的前提下,当HashMap中的其中一个链的对象个数达到8个,此时如果capacity没有达到64,那么HashMap会进行扩容,如果已经达到64,那么这个链会变成树,结点Node变为TreeNode类型。当然当树的结点数低于6个的时候,也会把树转换为链表。

1.7.3jdk1.8之变化

1.HashMap map = new HashMap();//默认情况下,先不创建长度为16的数组
2.当首次调用map.put()时,再创建长度为16的数组
3.数组为Node类型,在jdk7中称为Entry类型
4.形成链表结构时,新添加的key-value对在链表的尾部(七上八下)
5.当数组指定索引位置的链表长度>8时,且map中的数组的长度> 64时,此索引位置
上的所有key-value对使用红黑树进行存储。

1.7.4:TreeMap

1.TreeMap存储 Key-Value 对时,需要根据 key-value 对进行排序,TreeMap 可以保证所有的 Key-Value 对处于有序状态。
2.TreeSet底层使用红黑树结构存储数据
3.TreeMap 的 Key 的排序:
1)自然排序:TreeMap 的所有的 Key 必须实现 Comparable 接口,而且所有的 Key 应该是同一个类的对象,否则将会抛出 ClasssCastException
2)定制排序:创建 TreeMap 时,传入一个 Comparator 对象,该对象负责对TreeMap 中的所有key 进行排序。此时不需要 Map 的 Key 实现Comparable 接口
4.TreeMap判断两个key相等的标准:两个key通过compareTo()方法或者compare()方法返回0。
  • 2
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值