容器（Container）

最新推荐文章于 2024-07-13 13:55:40 发布

qq_40876806

最新推荐文章于 2024-07-13 13:55:40 发布

阅读量776

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_40876806/article/details/121475361

版权

一、集合

1.1 作用

可以储存多个数据

1.2 特点

其容量可以动态地改变，但只能存储引用数据类型

1.3 迭代器

1）获取某一个集合的迭代器

        Iterator it = col2.iterator();

2）是否存在下一个元素

3）获取下一个元素

        while(it.hasNext()){
            //3)获取下一个元素
            System.out.println(it.next());
        }

1.4 泛型

是一种参数化的类型，用于指定数据的类型作为参数传递，可以提高代码的可读性与稳定性

二、List

2.1 定义

是一个有序的集合

2.2 特点

有序的，可重复的，可以根据索引进行操作

2.3 新增功能

新增了一些根据索引进行操作的方法

2.4 遍历方式

for、foreach、iterator迭代器、listuterator迭代器

其中listiterator迭代器，允许程序员在任一方向上进行遍历列表，在迭代期间修改列表，即边修改边遍历，并获取迭代器在列表中的当前位置

三、ArrayList

3.1 底层结构

数组

3.2 特点

有序的，可重复的，存在索引，因为底层是数组，所以查询效率高，增删效率低。

3.3 应用场景

适合用在大量做查询，少量做增删的场景

3.4 扩容

默认的初始容量是 10 ，每次扩容是原容量的 1.5 倍

3.5 新增方法

void forEach(Consumer<? super E> action)

用法：list.forEach(System.out::println);

3.6 遍历方式

for、foreach、iterator迭代器、listiterator迭代器

3.7 注意事项

存储JavaBean数据，需要重写equals方法

3.8 Vector和ArrayList的区别

Vector是向量，是List接口的实现类

相同点：底层结构、特点、应用场景相同

不同点：1）Vector线程安全，同步 ArrayList线程不安全，不同步

2）Vector每次扩容是原容量的2倍 ArrayList每次扩容是原容量的1.5倍

四、LinkList

4.1 底层结构

双向链表

单向链表：

4.2 特点

有序的，可重复的，查询效率低，增删效率高

4.3 应用场景

适用于大量做增删，少量做查询的场景

4.4 新增功能

新增了一些针对于操作链头链尾的方法

4.5遍历

for、foreach、iterator迭代器、listiterator迭代器

五、Set

5.1 特点

无序：存放的顺序和内部真实存储的顺序不一致

不重复

5.2 新增内容

static <E> Set<E> of(E... elements) 返回包含任意数量元素的不可修改集。

5.3 遍历

foreach、iterator

六、TreeSet

6.1 底层结构

红黑树（平衡二叉树）

6.2 特点

可以自动对数据进行默认的排序

6.3 应用场景

需要实现去重，对数据进行默认排序的情况

6.4 遍历

foreach、iterator

七、比较器

7.1 内部比较器（自然排序）

实现Comparable接口，重写compareTo()方法，在方法体中指定比较规则

使用方法：在类名后面实现一个Comparable接口，然后在类内部重写compareTo()方法

7.2 外部比较器（自定义排序）

实现Comparator接口，重写compare()方法，在方法体中指定比较规则

使用方法：创建一个自定义类，在类后面实现Comparator接口，然后在类的内部重写compare()方法

7.3 注意事项

1）TreeSet的去重，排序，都根据比较规则实现

2）如果指定了外部比较规则，使用外部比较规则，没有指定外部，使用内部比较规则，如果都不在，抛出类型转换异常ClassCastException

八、HashSet

8.1 底层结构

哈希表（数组+链表+红黑树）

8.2 特点

查询增删效率高，无序，去重

8.3 应用场景

适用于去重、无序、增删效率较高的情况

8.4 注意事项

在存储JavaBean类型的数据时，要实现去重，就需要重写hashcode和equals方法，重写方法的目的是因为如果不重写的话，是根据对象的地址进行判断的，并不是根据对象的属性，这样返回出来的就是对象的地址。

在重写hashcode和equals以后：两个对象的hashcode相等，equals不一定相等。

两个对象的equals相等，hashcode一定相等

8.5 Hash表

九、Map

9.1 定义

存储键值对类型数据

键值对：K-V 映射关系

K：键 ---> 是唯一的，不可重复的，无序的 ---> map中的所有的key拿出来，可以构成一个Set集合

V：值 ---> 可重复的，无序的 ---> map中的所有的value拿出来，可以构成一个Collection集合

一个key对应一个value

9.2 遍历

1）values（）只能遍历value，不能遍历key

        Collection<String> values =  map.values();
        for (String str:values) {
            System.out.println(str);
        }

2）keySet（）value和key都有

        Set<Integer> set =  map.keySet();
        Iterator<Integer> it = set.iterator();
        while(it.hasNext()){
            Integer i = it.next();   //i作为键值对的key
            System.out.println(i+"---->"+map.get(i));
        }

3）entrySet（）value和key都有

        Set<Map.Entry<Integer,String>> entrys = map.entrySet();
        for (Map.Entry<Integer,String> entry:entrys){
            System.out.println(entry.getKey()+"---->"+entry.getValue());
        }

十、HashMap

10.1 定义

基于哈希表的Map接口的实现，此实现提供了所有可选的映射操作，并允许null值和null键

10.2 底层结构

哈希表（数组+链表+红黑树）

10.3 特点

查询、增删效率高，无序的，是根据key去重的，线程不安全的

10.4 扩容

默认初始容量是：16

加载因子（loadFactor）：0.75，即达到容量的0.75时实现扩容

扩容临界值（threshold）：size = Capacity*loadFactor 来实现扩容

扩容的机制：每次扩大原容量的 2 倍

分析源码: 数组长度要求2的整数次幂
链表长度>8,容量<64,会通过resize()进行扩容,如果容量>64,才会把链表变为红黑树
1.根据key计算哈希值hash(key) int hash = (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
2.调用putVal(hash,key,value)实现存储键值对数据
3.先判断哈希表中的节点数组是否为null,或者长度为0 ((tab = table) == null || (n = tab.length) == 0),如果是证明是第一次添加数据,调用resize()方法为数组扩容
4.resize()扩容方法内部的扩容机制 int newCap = oldCap << 1,每次扩容原容量的2倍
5.计算位桶的索引(节点数据要存储在数组的指定索引位置) index = (n - 1) & hash
6.判断数组对应索引位置是否存在节点数据 tab[index] == null
7.如果没有存在数据,证明链表中没有节点,当前要存储的数据节点作为链表头节点存在,长度+1,然后判断是否需要扩容,需要扩容调用resize方法进行扩容 if (++size > threshold) {resize();}
tab[index] = new Node<>(hash, key, value, null);
8.如果存在数据,判断已有的节点是否为红黑树的节点,如果调用putTreeVal()方法实现添加,如果不是树的节点,证明还是链表结构
遍历链表,判断已有链表的节点的key是否与要存储的键值对的key相同(e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))),
如果相同value覆盖,返回被覆盖的value,
如果不相同,遍历到链表的最后,创建新节点,挂在原链表的最后 p.next = newNode(hash, key, value, null);,长度+1,判断是否需要扩容 (++size > threshold) {resize();}

存储过程中的所有的哈希算法实现,目的都是为了把数据尽量散列的分布在不同的位桶中,减少哈希碰撞,提高效率

十一、Hashtable

11.1 底层结构

哈希表

11.2 HashMap与Hashtable之间的区别:

1.继承体系不同
2.存储键值对中对null值的要求不同
HashMap中null值可以作为键值对
Hashtable中null值不能作为键值对
3.同步情况不同
HashMap线程不安全,不同步
Hashtable线程安全的哈希表
4.初始容量,扩容机制不同
HashMap初始容量16
扩容: 每次扩容原容量的2倍
Hashtable初始容量11
扩容: 每次扩容原容量的2倍+1 int newCapacity = (oldCapacity << 1) + 1;
5.计算key的hash值,与位桶索引的方式不同
HashMap :
int hash = (h = key.hashCode()) ^ (h >>> 16);
int index = (n - 1) & hash;
Hashtable :
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;

11.3 HashMap线程不安全问题：

1.可以使用Hashtable
2.Collections工具类中 synchronizedMap(Map<K,V> m)
3.juc高级并发编程包 ConcurrentHashMap<K,V> --> 推荐

十二、TreeMap

12.1 底层结构

红黑树

12.2 特点

自动做升序排列、是无序的、去重的

12.3 注意

无论是排序还是去重，都是根据键值对的key来计算的

TreeSet底层就是由TreeMap维护的,就是TreeMap键值对的key

十三、Properties

Properties类表示一组持久的属性。 Properties可以保存到流中或从流中加载。属性列表中的每个键及其对应的值都是一个字符串。

Properties常用做配置文件使用

定义使用步骤:
1.src下新建文件 xx.properties
2.创建Properties类型的对象
3.调用load(InputStream|Reader)
4.根据key获取value getProperty(key)

//从流中加载数据
pro.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("db.properties"));

十四、Collections

是一个静态工程类，仅包含对集合进行操作或返回集合的静态方法

Collection和Collections区别

Collection是根的接口

Collections是工具类

一些常用的方法

void sort(List) //对List容器内的元素排序,排序的规则是按照升序进行排序。
void shuffle(List) //对List容器内的元素进行随机排列
void reverse(List) //对List容器内的元素进行逆续排列
void fill(List, Object) //用一个特定的对象重写整个List容器
int binarySearch(List, Object)//对于顺序的List容器，采用折半查找的方法查找特定对象

qq_40876806

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
容器（Container）

一、集合1.1 作用可以储存多个数据1.2 特点其容量可以动态地改变，但只能存储引用数据类型1.3 迭代器 1）获取某一个集合的迭代器 Iterator it = col2.iterator(); 2）是否存在下一个元素 3）获取下一个元素 while(it.hasNext()){ //3)获取下一个元素 Syst...
复制链接

扫一扫