前言
今天实习面试（2022.7.6）的时候问到了集合类的各个类特点和具体使用，记得不太熟悉了，所以复习一下
文章目录
List，Set，Map接口的区别
- List ：集合中对象按照索引位置排序，可以有重复对象，允许按照对象在集合中的索引位置检索对象，例如通过list.get(i)方法来获取集合中的元素；
- Map ：中的每一个元素包含一个键和一个值，成对出现，键对象不可以重复，值对象可以重复；
- Set： 集合中的对象不按照特定的方式排序，并且没有重复对象，但它的实现类能对集合中的对象按照特定的方式排序，例如 Tree Set 类，可以按照默认顺序，也可以通过实现 Comparator< Type >接口来自定义排序方式。
（1）List接口
ArrayList的特点
- 底层数据结构是数组
- ArrayList可以存放重复元素，
- 可以存放null值，
- 存入取出是有序的
List<Object> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(new Student("bx"));
list.add(4);
list.add(5);
list.add(5);
list.add(null);
System.out.println(list);遍历方式
//使用迭代器
Iterator<Object> iterator = list.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
//for循环
for (Object o:list) {
System.out.println(o);
}LinkedList的特点
- 底层数据结构是双向链表
- LinkedList可以存放重复元素
- 可以存放null值
- 存入取出是有序的
- 可以当作队列使用，在刷题中常用
LinkedList<Object> linkedList = new LinkedList<>();
linkedList.add(1);
linkedList.add(1);
linkedList.add("bx");
linkedList.add(null);
linkedList.add(null);
linkedList.add(new Student("qiqi"));
linkedList.add(new Student("qiqi"));遍历方式
//使用迭代器
Iterator<Object> iterator = linkedList.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
//for循环
for (Object o:linkedList) {
System.out.println(o);
}（2）Set接口
Hashset的特点
- 底层数据结构是hash表（数组+链表）
- Hashset不能存放重复值
- Hashset取出值是无序的,无序是指存储和取出顺序不一样,但可能取出的结果顺序有序
HashSet<Object> hashSet = new HashSet<>();
hashSet.add("a");
hashSet.add(2);
hashSet.add(7);
hashSet.add(3);
hashSet.add("b");
hashSet.add(1);
hashSet.add("two");
hashSet.add(4);
hashSet.add("three");
hashSet.add(6);
hashSet.add("one");
hashSet.add(5);
System.out.println(hashSet);
//输出结果
[a, 1, 2, b, 3, 4, 5, 6, 7, one, two, three]遍历方式
//迭代器遍历
Iterator<Object> iterators = hashSet.iterator();
while (iterators.hasNext()){
System.out.println(iterators.next());
}
//for循环遍历
for (Object objects:hashSet){
System.out.println(objects);
}LinkedHashSet的特点
- 底层数据结构是数组+双向链表
- LinkedHashset不能存放重复值
- LinkedHashset取出值是有序的
LinkedHashSet<Object> hashSet = new LinkedHashSet<>();
hashSet.add("a");
hashSet.add("a");
hashSet.add(2);
hashSet.add(7);
hashSet.add(3);
hashSet.add("b");
hashSet.add(1);
hashSet.add("two");
hashSet.add(4);
hashSet.add("three");
hashSet.add(6);
hashSet.add("one");
hashSet.add(5);
System.out.println(hashSet);
//输出结果
[a, 2, 7, 3, b, 1, two, 4, three, 6, one, 5]遍历方式
//迭代器遍历
Iterator<Object> iterators = hashSet.iterator();
while (iterators.hasNext()){
System.out.println(iterators.next());
}
//for循环遍历
for (Object objects:hashSet){
System.out.println(objects);
}Treeset的特点
- 底层数据结构是二叉树
- 可以自定义排序顺序（实现Comparator接口，重写compare方法）
- 只能放引用类型，默认自然排序（按二叉树排序），是无序的
- 无法插入重复值
TreeSet<Student> treeSet = new TreeSet(new Comparator<Student>(
) {
@Override
public int compare(Student o1, Student o2) {
return o1.getAge()-o2.getAge();
}
});
treeSet.add(new Student("卢锡安",20));
treeSet.add(new Student("劫",39));
treeSet.add(new Student("安妮",9));
treeSet.add(new Student("塞纳",28));
System.out.println(treeSet);
//输出结果
[ Student{name='安妮', age=9}
, Student{name='卢锡安', age=20}
, Student{name='塞纳', age=28}
, Student{name='劫', age=39}
]
//完成了按年龄排序遍历方式
//迭代器
Iterator<Student> iterator = treeSet.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
//for循环
for(Student student:treeSet){
System.out.println(student);
}（3）Map接口
HashMap的特点
- 底层数据结构是数组+单向链表
- hashmap是无序的，
- k-v都可以为null
HashMap<Object, Object> HashMap = new HashMap<>();
HashMap.put(1,"one");
HashMap.put(4,"four");
HashMap.put(3,"three");
HashMap.put(2,"two");
HashMap.put(null,null);
System.out.println(HashMap);
//输出结果
{null=null, 1=one, 2=two, 3=three, 4=four}遍历方式
//for循环，得到key，通过key得到value
for (Object key:HashMap.keySet()){
System.out.println(key+"->"+HashMap.get(key));
}
//for循环,得到键值对
for (Entry<Object, Object> objects:HashMap.entrySet()){
System.out.println(objects);
}
//迭代器：得到entryset
Iterator<Entry<Object, Object>> iterator = HashMap.entrySet().iterator();
while (iterator.hasNext()){
Entry<Object, Object> entry = iterator.next();
System.out.println(entry.getKey()+"->"+entry.getValue());
}LinkedHashMap的特点
- LinkedHashMap是有序的
- k-v都可以为null
- 遍历方式与hashmap一致
LinkedHashMap<Object, Object> map = new LinkedHashMap<>();
map.put(6,"six");
map.put(9,"nine");
map.put(5,"five");
map.put(2,"two");
System.out.println(map);
//输出结果
{6=six, 9=nine, 5=five, 2=two}HashTable的特点
- 底层数据结构为Entry数组（数组+单向链表）
- 线程安全的，方法上加synchronized锁
- hashtable是无序的，
- k-v都不能为null
- 遍历方式与hashmap一致
TreeMap的特点
- 底层数据结构为红黑树
- 可以自定义排序，否则是无序的，输出结果默认按照 k 的升序排列
- 遍历方式与hashmap一致
TreeMap<Student, Integer> treeMap = new TreeMap(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o1.getAge()-o2.getAge();
}
});
treeMap.put(new Student("卢锡安",20),1);
treeMap.put(new Student("劫",15),2);
treeMap.put(new Student("劫",39),3);
treeMap.put(new Student("塞纳",28),4);
treeMap.put(new Student("提莫",1),5);
System.out.println(treeMap);
//输出结果
{
Student{name='提莫', age=1}=5,
Student{name='劫', age=15}=2,
Student{name='卢锡安', age=20}=1,
Student{name='塞纳', age=28}=4,
Student{name='劫', age=39}=3
}
//输出结果 按年龄排序！注意：只能让Key为条件进行排序
应用：
（1）如何将ArrayList去重
存入LinkedHashSet，还能保持有序
ArrayList arrayList = new ArrayList(); arrayList.add(1); arrayList.add(1); arrayList.add(2); arrayList.add(2); arrayList.add(4); arrayList.add(4); arrayList.add(3); arrayList.add(3); LinkedHashSet linkedHashSet = new LinkedHashSet(); linkedHashSet.addAll(arrayList); System.out.println(linkedHashSet);//输出结果：[1, 2, 4, 3]
后序会更新更多问题
1240
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
