JAVA基础 容器
我们之前了解了数组，数组是一个存储多个是相同数据类型的有序集合，是一个定长的引用数据类型，根据索引操作数组效率高。
而我们今天说的容器是可以变长，并且操作灵活，能够存储多个不同数据类型的数据。注意存储的数据只能是引用数据类型的，因此如果想要存储基本数据类型，就要改成相应的引用数据类型。
Collection
/ \
List Set
/ \ / \
ArrayList LinkedList TreeSet HashSet
Map
/ \
HashMap TreeMap
Collection 是容器体系的上层接口
可以使用 类 来实现Collection接口，也可以用Collection接口的多态。
其中ArrayList 就是一个有Collection接口的实现类，是有序可以重复的。 Collection col = new ArrayList();//接口多态
常用方法
add 添加
col.add(“zhangsan”);
addAll() 可以将集合的元素添加到容器中。
clear 清除
从此集合中删除所有元素
//col.clear();
isEmpty()
如果此集合不包含任何元素，则返回 true 。是否为空
contains(Object o)
是否包含指定的元素，是返回true
containsAll 是否包含指定集合
remove 移除
从此集合中移除指定元素的单个实例（如果存在
removeAll 删除包含指定集合的元素
retainAll
仅保留此集合中包含在指定集合中的元素。交集
toArray()
返回包含此集合中所有元素的数组。
遍历
for each 遍历
for(Object obj:col2){
System.out.println(obj);
}
iterator 迭代器遍历
//iterator() 返回此集合中元素的迭代器。
//1.获取操作某一个集合迭代器
Iterator it = col.iterator();
//2.hashNext() 是否存在下一个元素
while(it.hasNext()){
//3.获取下一个元素next()
System.out.println(it.next());
}
List
是列表的意思，也就是有顺序可以重复的。
新增功能: 一些根据索引操作的方法 of(…)创建集合的同时添加数据,集合不可变 subList()
遍历方式： foreach，iterator迭代器， for ，列表迭代器 ListIterator
List运用
List list = new ArrayList<>();
<泛式> 尖括号中的是泛式，是引用数据类型，默认是Object 。自定义引用类型不能省略。
规范存储数据的数据类型，泛型可以提高代码的可读性,稳定性,帮助检查存储数据的类型。
add
list.add(1);//默认是添加到结尾的
list.add(1,10);//第一个是索引，第二个是值
remove
删除索引的值
indexOf，clear，equals，isEmpty，replace
indexOf返回第一个出现的索引
clear清除
equals比较
isEmpty是否为空
replace替换
get
返回此列表中指定位置的元素。
of
返回包含元素的不可修改列表List。
size
返回列表的元素数
toArray
以适当的顺序（从第一个元素到最后一个元素）返回包含此列表中所有元素的数组。
subList
返回指定区间的List。
遍历
主要讲下 for 和 列表迭代器 ListIterator。另外的2种和Collection中的基本相同。
for循环遍历
//i作为集合的索引
for(int i=0;i<= list.size()-1;i++){
System.out.println(ls.get(i));
}
ListIterator遍历
//1.获取操作这个集合的迭代器
ListIterator<String> lt = list.listIterator();
//2.判断是否存在下一个元素
while(lt.hasNext()){
String str = lt.next(); //因为存在泛型,素有可以使用String类型接收
System.out.println(str);
}
ArrayList
底层数据结构: 数组|可变数组 (数组:内存中一段连续的内存空间) (Object[] elementData)
优点 : 查询,遍历效率高(根据索引)
缺点 : 添加,删除数据效率较低,创建新数组,数据拷贝
应用场景 : 大量做查询的时候,少量做修改的时候,适合使用ArrayList存储数据
ArrayList() 构造一个初始容量为10的空列表。 *** ->不确定集合中存储多少数据,使用
ArrayList(int initialCapacity) 构造具有指定初始容量的空列表。 ->当确定集合中存储数据的个数范围的时候,可以选择使用
ArrayList(Collection<? extends E> c) 按照集合的迭代器返回的顺序构造一个包含指定集合元素的列表。
方法:操作内容,根据索引进行操作
扩容：根据空构造构建ArrayList,初始默认空数组,第一次添加数据默认容量为10,存不下了才扩容,每次扩容原容量的1.5倍
Vector 向量 与 ArrayList 区别
共同点: 底层结构也是数组,特点一样
不同定:
1)Vector线程安全,ArrayList线程不安全
2)扩容:Vector每次扩容原容量的2倍 而ArrayList是1.5倍,所以ArrayList更有利于节省内存
使用：
//创建集合
ArrayList list = new ArrayList();
方法和List差别不大。
Vector
Vector 向量 与 ArrayList 区别
共同点: 底层结构也是数组,特点一样
不同定:
1)Vector线程安全,ArrayList线程不安全
2)扩容:Vector每次扩容原容量的2倍 而ArrayList是1.5倍,所以ArrayList更有利于节省内存
**LinkedList **
链表。有序可重复，底层是双向链表结构。 增删效率高，但查询效率低，一般用在大量做增删，少量做查询的场景。
方法: 新增了一些操作链表头尾的方法
使用
LinkedList list = new LinkedList<>();
addFirst ，addLast
addFirst 在列表的开头插入指定元素
addLast 将指定的元素追加到此列表的末尾。
element，peekFirst
element() 检索但不删除此列表的头部（第一个元素）
peekFirst() 检索但不删除此列表的第一个元素，如果此列表为空，则返回 null 。
Set
List 与 Set之间的区别:
都是Collection接口的子接口,可以存储多个数据,但是每个数据只能为一个值
都继承了Collection的能力
List 有序可重复,拥有一些可以根据索引操作的方法
Set 无序不可重复
去重逻辑: e1.equals(e2)的返回值决定,和最多一个null元素。
TreeSet
TreeSet --> TreeMap --> TreeSet是由TreeMap维护的,是Map的key
底层结构: 红黑树结构
特点: 数据会升序排序,去重
使用：TreeSet tree = new TreeSet<>();
tree.add(5);
注意
TreeSet 存储数据是默认升序排序
但是要求: 数据是能够比较大小的
存储数据,可以指定当前使用哪种比较规则(外部比较器),如果没有指定默认使用找内部比较规则(内部比较器),如果内部外部都没有就抛出异常
ClassCastException : 类型转换异常
去重和排序都是根据比较负责决定
Set遍历方式都与Collection方式相同
内部比较器
Comparable 自然排序|内部比较器|自然比较器|默认比较规则:
此接口对实现它的每个类的对象强加一个总排序。 这种排序被称为类的自然顺序 ，类的compareTo方法被称为其自然比较方法 。
使用方式:一个自定义的引用数据类型实现Comparable接口,重写compareTo,在重写方法中指定当前类型数据的比较规则
注意: 内部比较器属于硬编码编程习惯,每次要修改都要修改javabean类的源码,不够灵活,没办法在不同的业务员下根据不同的规则比较
public class Employee implements Comparable<Employee>{
//............代码块..........
@Override
public int compareTo(Employee o) {
//return this.height-o.height; //升序
return o.height-this.height; //降序
}
外部比较器
外部比较器|定制排序
比较规则定义值javabean类的外部
实现方式: 实现类实现Compatator接口,重写int compare(T o1, T o2) 比较它的两个参数的顺序。定制比较规则
推荐使用: 软编码习惯
//外部比较器,比较员工类,根据员工的姓名比较员工信息
class Demo implements Comparator<Employee>{
@Override
public int compare(Employee o1, Employee o2) {
return o2.getName().compareTo(o1.getName());
}
}
外部比较器: 通过Comparator接口的实现类重写compare方法定义比较规则,这个实现类没有类原本自己的作用,可以选择使用匿名内部类简化
lambda可以用来简化匿名内部类:
前提: 接口为函数式接口@FunctionalInterface
(参数列表)->{重写的方法体}
注意: 要对自定义引用数据类型进行 排序的位置,都需要指定比较规则|比较器问题
HashSet
HashSet ->是由HashMap维护的
多个数据每个数据是单个值, 无序,去重
底层: 哈希表(数组+链表+红黑树)
优点: 查询,增删效率高
缺点: 无序
去重: 需要类型中重写hashcode和equals方法,根据对象的内容计算,而非地址计算hashcode和equals
hashcode和equals之间的规律特点:
equals相等的hashcode肯定相等
hashcode相等的equals不一定相等
使用：Set set = new HashSet<>();
set.add(“张三”);
Map
Map<K,V> 接口
存储键值对类型的数据
K-V(键值对) 之间存在映射关系
K : 唯一的,无序的 --> Set
V : 可重复,无序的 --> Collection
K,V 都可以为任意数据类型
注意:
Map的去重,根据key做去重的
添加数据,如果key相同,value会覆盖
key,与 value都可以赋值为null
一个key只能对应一个value,但是可以把多个value值放入集合中,一个key对应一个集合
使用：
HashMap<String,Integer> map = new HashMap<>();
//V get(Object key) 返回指定键映射到的值，如果此映射不包含键的映射，则返回 null 。
//V put(K key, V value) 将指定的值与此映射中的指定键相关联（可选操作）。
//containsKey(Object key) 如果此映射包含指定键的映射，则返回 true 。
//containsValue(Object value) 如果此映射包含指定 值 的映射，则返回 true
//remove(Object key) 删除key为参数的键值对,返回value
遍历：
1.keySet() 返回当前map集合中的所有键值对的key
Set<String> set = map.keySet();
for(String key:set){
System.out.println("key = "+key+",value = "+map.get(key));
map.put(key,12);
}
2.values() 获取当前集合中所有键值对的value值
Collection<Integer> col = map.values();
Iterator<Integer> it = col.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
3.entrySet() 把map中的每一个键值对返回成为一个Map.Entry类型的数据放入set集合
//Set<Map.Entry<K,V>> entrySet() 返回此映射中包含的映射的Set视图。
Set<Map.Entry<String,Integer>> set2 = map.entrySet();
for(Map.Entry<String,Integer> entry:set2){
System.out.println(entry.getKey()+"-->"+entry.getValue());
}
HashMap
底层实现: 哈希表
特点: 查询,增删效率高
初始容量: 内部位桶数组的大小 16
加载因子loadFactor : 0.75
threshold :临界值(阀值) = 容量*加载因子
size: 集合中存储键值对的个数
扩容: 每次扩容原容量2倍
可以存储null值作为key和value,但线程不安全（不同步）。
Hashtable
线程安全的Hash表,与HashMap非常像
Hashtable是同步的|线程安全的。 如果不需要线程安全实现，建议使用HashMap代替Hashtable 。 如果需要线程安全的高度并发实现，则建议使用ConcurrentHashMap代替Hashtable 。
不能存储null值作为key和value
初始容量为11 ,加载因子0.75, 每次扩容原容量的2倍+1
public static void main(String[] args) {
HashMap map = new HashMap<>();
map.put(null,null);
}
TreeMap
TreeMap --> TreeSet是由TreeMap的key维护的
底层: 红黑树
特点: 自动根据key做升序排序
去重存储: 如果存储的是java提供的引用类型,java提供比较规则,不用管直接用
如果存储的是自定义提供的引用类型,自己实现比较规则
注意:Map的去重…都是根据键值对的key操作
比较规则:
内部比较器 Comparable
初始容量为11 ,加载因子0.75, 每次扩容原容量的2倍+1
public static void main(String[] args) {
HashMap map = new HashMap<>();
map.put(null,null);
}
TreeMap
TreeMap --> TreeSet是由TreeMap的key维护的
底层: 红黑树
特点: 自动根据key做升序排序
去重存储: 如果存储的是java提供的引用类型,java提供比较规则,不用管直接用
如果存储的是自定义提供的引用类型,自己实现比较规则
注意:Map的去重…都是根据键值对的key操作
比较规则:
内部比较器 Comparable
外部比较器 Comparator
14万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
