第12章：随堂复习与企业真题（集合框架）

发布于：2024-04-20 ⋅ 阅读:(33) ⋅ 点赞:(0)

一、随堂复习

1. 数组存储数据方面的特点和弊端

   数组存储多个数据方面的特点：
   > 数组一旦初始化，其长度就是确定的。
   > 数组中的多个元素是依次紧密排列的，有序的，可重复的
   > (优点) 数组一旦初始化完成，其元素的类型就是确定的。不是此类型的元素，就不能添加到此数组中。
      int[] arr = new int[10];
      arr[0] = 1;
      arr[1] = "AA";//编译报错
​
      Object[] arr1 = new Object[10];
      arr1[0] = new String();
      arr1[1] = new Date();
   > (优点)元素的类型既可以是基本数据类型，也可以是引用数据类型。
​
   数组存储多个数据方面的弊端：
   > 数组一旦初始化，其长度就不可变了。
   > 数组中存储数据特点的单一性。对于无序的、不可重复的场景的多个数据就无能为力了。
   > 数组中可用的方法、属性都极少。具体的需求，都需要自己来组织相关的代码逻辑。
   > 针对于数组中元素的删除、插入操作，性能较差。

2. 集合框架概述

java.util.Collection:存储一个一个的数据
    |-----子接口：List:存储有序的、可重复的数据 ("动态"数组)
           |---- ArrayList(主要实现类)、LinkedList、Vector
​
    |-----子接口：Set:存储无序的、不可重复的数据(高中学习的集合)
           |---- HashSet(主要实现类)、LinkedHashSet、TreeSet
​
​
java.util.Map:存储一对一对的数据(key-value键值对，(x1,y1)、(x2,y2) --> y=f(x),类似于高中的函数)
    |---- HashMap(主要实现类)、LinkedHashMap、TreeMap、Hashtable、Properties
学习的程度把握：
层次1：针对于具体特点的多个数据，知道选择相应的适合的接口的主要实现类，会实例化，会调用常用的方法。
层次2：区分接口中不同的实现类的区别。
*****************
层次3：① 针对于常用的实现类，需要熟悉底层的源码 ② 熟悉常见的数据结构 （第14章讲）

3. Collection的常用方法

3.1 常用方法
add(Object obj)
addAll(Collection coll)
clear()
isEmpty()
size()
contains(Object obj)
containsAll(Collection coll)
retainAll(Collection coll)
remove(Object obj)
removeAll(Collection coll)
hashCode()
equals()
toArray()
**************
iterator() ---> 引出了迭代器接口
向Collection中添加元素的要求：
> 要求元素所属的类一定要重写equals()!
集合与数组的相互转换：
集合 ---> 数组：toArray()
数组 ---> 集合：调用Arrays的静态方法asList(Object ... objs)，返回一个List
3.2 迭代器接口

  • 设计模式的一种

  • 迭代器不负责数据的存储；负责对集合类的遍历

1. 如何获取迭代器(Iterator)对象？
Iterator iterator = coll.iterator();
​
2. 如何实现遍历(代码实现)
while(iterator.hasNext()){
    System.out.println(iterator.next()); //next():①指针下移 ② 将下移以后集合位置上的元素返回
}

4. Collection的子接口：List

  • 常用方法

小结：
    增
        add(Object obj)
        addAll(Collection coll)
    删
        remove(Object obj)
        remove(int index)
    改
        set(int index, Object ele)
    查
        get(int index)
    插
        add(int index, Object ele)
        addAll(int index, Collection eles)
    长度
        size()
    遍历
        iterator() ：使用迭代器进行遍历
        增强for循环
        一般的for循环
List及其实现类特点
java.util.Collection:存储一个一个的数据
    |-----子接口：List:存储有序的、可重复的数据 ("动态"数组)
           |---- ArrayList:List的主要实现类；线程不安全的、效率高；底层使用Object[]数组存储
                           在添加数据、查找数据时，效率较高；在插入、删除数据时，效率较低
           |---- LinkedList:底层使用双向链表的方式进行存储；在对集合中的数据进行频繁的删除、插入操作时，建议                            使用此类在插入、删除数据时，效率较高；在添加数据、查找数据时，效率较低；
           |---- Vector:List的古老实现类；线程安全的、效率低；底层使用Object[]数组存储
​
[面试题] ArrayList、Vector的区别？  ArrayList、LinkedList的区别？

5. Collection的子接口：Set

  • Set中的常用的方法都是Collection中声明的方法，没有新增的方法

  • 常见的实现类的对比

java.util.Collection:存储一个一个的数据
    |-----子接口：Set:存储无序的、不可重复的数据(高中学习的集合)
           |---- HashSet：主要实现类；底层使用的是HashMap，即使用数组+单向链表+红黑树结构进行存储。（jdk8中）
                |---- LinkedHashSet：是HashSet的子类；在现有的数组+单向链表+红黑树结构的基础上，又添加了
                                     一组双向链表，用于记录添加元素的先后顺序。即：我们可以按照添加元素的顺                                    序实现遍历。便于频繁的查询操作。
           |---- TreeSet：底层使用红黑树存储。可以按照添加的元素的指定的属性的大小顺序进行遍历。

  • 难点： Set中无序性、不可重复性的理解（以HashSet及其子类为例说明）

>无序性： != 随机性。
         添加元素的顺序和遍历元素的顺序不一致,是不是就是无序性呢？ No!
         到底什么是无序性？与添加的元素的位置有关，不像ArrayList一样是依次紧密排列的。
         这里是根据添加的元素的哈希值，计算的其在数组中的存储位置。此位置不是依次排列的，表现为无序性。
​
>不可重复性：添加到Set中的元素是不能相同的。
          比较的标准，需要判断hashCode()得到的哈希值以及equals()得到的boolean型的结果。
          哈希值相同且equals()返回true，则认为元素是相同的。
添加到HashSet/LinkedHashSet中元素的要求:
>要求元素所在的类要重写两个方法：equals() 和 hashCode()。
>同时，要求equals() 和 hashCode()要保持一致性！我们只需要在IDEA中自动生成两个方法的重写即可，即能保证两个方法的一致性。

  • 了解TreeSet的使用

6. Map接口

  • 常用的方法

增：
    put(Object key,Object value)
    putAll(Map m)
删：
    Object remove(Object key)
改：
    put(Object key,Object value)
    putAll(Map m)
查：
    Object get(Object key)
长度：
    size()
遍历：
   遍历key集：Set keySet()
   遍历value集：Collection values()
   遍历entry集：Set entrySet()

  • 常用的实现类

java.util.Map:存储一对一对的数据(key-value键值对，(x1,y1)、(x2,y2) --> y=f(x),类似于高中的函数)
    |---- HashMap:主要实现类;线程不安全的，效率高;可以添加null的key和value值;底层使用数组+单向链表+红黑树结构存储（jdk8）
        |---- LinkedHashMap:是HashMap的子类；在HashMap使用的数据结构的基础上，增加了一对双向链表，用于记录添加的元素的先后顺序，进而我们在遍历元素时，就可以按照添加的顺序显示。开发中，对于频繁的遍历操作，建议使用此类。
    |---- TreeMap:底层使用红黑树存储;可以按照添加的key-value中的key元素的指定的属性的大小顺序进行遍历。需要考虑使用①自然排序 ②定制排序。
    |---- Hashtable:古老实现类;线程安全的，效率低;不可以添加null的key或value值;底层使用数组+单向链表结构存储（jdk8）
        |---- Properties:其key和value都是String类型。常用来处理属性文件。
​
​
[面试题] 区别HashMap和Hashtable、区别HashMap和LinkedHashMap、HashMap的底层实现（① new HashMap() ② put(key,value)）
HashMap中元素的特点:
> HashMap中的所有的key彼此之间是不可重复的、无序的。所有的key就构成一个Set集合。--->key所在的类要重写hashCode()和equals()
> HashMap中的所有的value彼此之间是可重复的、无序的。所有的value就构成一个Collection集合。--->value所在的类要重写equals()
> HashMap中的一个key-value,就构成了一个entry。
> HashMap中的所有的entry彼此之间是不可重复的、无序的。所有的entry就构成了一个Set集合。

  • （了解）TreeMap的使用

  • （重要）Properties的使用

    public class PropertiesTest {
    @Test
    public void test() throws IOException { //注意：因为设计到流的操作，为了确保流能关闭，建议使用try-catch-finally
        //方式1：数据和代码耦合度高；如果修改的话，需要重写的编译代码、打包发布，繁琐
        //数据
//        String name = "Tom";
//        String password = "abc123";
​
        //代码：用于操作name,password
        //...
​
        //方式2：将数据封装到具体的配置文件中，在程序中读取配置文件中的信息。实现了
        //数据和代码的解耦；由于我们没有修改代码，就省去了重新编译和打包的过程。
        File file = new File("info.properties"); //注意，要提前创建好
//        System.out.println(file.getAbsolutePath());
        FileInputStream fis = new FileInputStream(file);
​
        Properties pros = new Properties();
        pros.load(fis); //加载流中的文件中的数据
​
        //读取数据
        String name = pros.getProperty("name");
        String pwd = pros.getProperty("password");
​
        System.out.println(name + ":" + pwd);
​
        fis.close();
    }
​
}

7. Collections工具类的使用

区分Collection 和 Collections
Collection：集合框架中的用于存储一个一个元素的接口，又分为List和Set等子接口。
Collections：用于操作集合框架的一个工具类。此时的集合框架包括：Set、List、Map

  • 熟悉常用的Collections中的方法即可。

二、企业真题

2.1 集合概述

1. List，Set，Map是否继承自collection接口？（北京中*译咨询、思*贸易）

Map不是。

java.util.Collection:存储一个一个的数据
    |-----子接口：List:存储有序的、可重复的数据 ("动态"数组)
           |---- ArrayList(主要实现类)、LinkedList、Vector
​
    |-----子接口：Set:存储无序的、不可重复的数据(高中学习的集合)
           |---- HashSet(主要实现类)、LinkedHashSet、TreeSet
​
​
java.util.Map:存储一对一对的数据(key-value键值对，(x1,y1)、(x2,y2) --> y=f(x),类似于高中的函数)
    |---- HashMap(主要实现类)、LinkedHashMap、TreeMap、Hashtable、Properties
2. 说说List,Set,Map三者的区别(民*银行)
类似问题：
> Map与Set、List的区别（纬*）
java.util.Collection:存储一个一个的数据
    |-----子接口：List:存储有序的、可重复的数据 ("动态"数组)
           |---- ArrayList(主要实现类)、LinkedList、Vector
​
    |-----子接口：Set:存储无序的、不可重复的数据(高中学习的集合)
           |---- HashSet(主要实现类)、LinkedHashSet、TreeSet
​
​
java.util.Map:存储一对一对的数据(key-value键值对，(x1,y1)、(x2,y2) --> y=f(x),类似于高中的函数)
    |---- HashMap(主要实现类)、LinkedHashMap、TreeMap、Hashtable、Properties
3. 写出list、map、set接口的实现类，并说出其特点（华**为）
类似问题：
> 集合有哪些， 各自有哪些特点， 各自的API有哪些？（湖**利软件）
> List Map Set三个接口在存储元素时个有什么特点（*软）

List的实现类是ArrayList

Map的实现类是HashMap

Set的实现类是HashSet

ArrayList:List的主要实现类；线程不安全的、效率高；底层使用Object[]数组存储                           在添加数据、查找数据时，效率较高；在插入、删除数据时，效率较低

HashMap:主要实现类;线程不安全的，效率高;可以添加null的key和value值;底层使用数组+单向链表+红黑树结构存储（jdk8）

> HashMap中的所有的key彼此之间是不可重复的、无序的。所有的key就构成一个Set集合。--->key所在的类要重写hashCode()和equals()
> HashMap中的所有的value彼此之间是可重复的、无序的。所有的value就构成一个Collection集合。--->value所在的类要重写equals()
> HashMap中的一个key-value,就构成了一个entry。
> HashMap中的所有的entry彼此之间是不可重复的、无序的。所有的entry就构成了一个Set集合。

HashSet：主要实现类；底层使用的是HashMap，即使用数组+单向链表+红黑树结构进行存储。（jdk8中）

>无序性： != 随机性。
         添加元素的顺序和遍历元素的顺序不一致,是不是就是无序性呢？ No!
         到底什么是无序性？与添加的元素的位置有关，不像ArrayList一样是依次紧密排列的。
         这里是根据添加的元素的哈希值，计算的其在数组中的存储位置。此位置不是依次排列的，表现为无序性。
​
>不可重复性：添加到Set中的元素是不能相同的。
          比较的标准，需要判断hashCode()得到的哈希值以及equals()得到的boolean型的结果。
          哈希值相同且equals()返回true，则认为元素是相同的。
添加到HashSet/LinkedHashSet中元素的要求:
>要求元素所在的类要重写两个方法：equals() 和 hashCode()。
>同时，要求equals() 和 hashCode()要保持一致性！我们只需要在IDEA中自动生成两个方法的重写即可，即能保证两个方法的一致性。
4. 常见集合类的区别和适用场景（饿**）

5. 集合的父类是谁？哪些安全的？（北京中**信）

Map的实现类是HashMap，HashMap的父类是AbstractSet。 不安全：ArrayList、HashMap、HashSet ； 安全：Vector、Hashtable

6. 集合说一下哪些是线程不安全的（*科软）

ArrayList、HashMap、HashSet

7. 遍历集合的方式有哪些？（恒*电子）

  • 迭代器Iterator用来遍历Collection，不能用来遍历Map！

  • 增强for

  • 一般的for：可以用来遍历List

2.2 List接口

1. List下面有哪些实现（软**力）

ArrayList(主要实现类)、LinkedList、Vector

2. ArrayList与LinkedList区别？(O**O、滴*、汇*天下、拓*软件、博纳**软件、上海*进天下，北京永生**信息、*联、在*途游)
类似问题：
> ArrayList跟LinkedList的区别详细说出？（阿*校招、*东）

|---- ArrayList:List的主要实现类；线程不安全的、效率高；底层使用Object[]数组存储，在添加数据、查找数据时，效率较高；在插入、删除数据时，效率较低          

|---- LinkedList:底层使用双向链表的方式进行存储；在对集合中的数据进行频繁的删除、插入操作时，建议 使用此类在插入、删除数据时，效率较高；在添加数据、查找数据时，效率较低；

 补充上第14章中的源码（底层的数据结构）

3. ArrayList与Vector区别呢？为什么要用ArrayList取代Vector呢？(湖**利软件)

Vector效率低。

|---- ArrayList:List的主要实现类；线程不安全的、效率高；底层使用Object[]数组存储，在添加数据、查找数据时，效率较高；在插入、删除数据时，效率较低

|---- Vector:List的古老实现类；线程安全的、效率低；底层使用Object[]数组存储 ​

4. Java.util.ArrayList常用的方法有哪些？（华**为）
第1波：Collection中声明的15个方法。
add(Object obj)
addAll(Collection coll)
clear()
isEmpty()
size()
contains(Object obj)
containsAll(Collection coll)
retainAll(Collection coll)
remove(Object obj)
removeAll(Collection coll)
hashCode()
equals()
toArray()
*********
iterator()


第2波：因为List是有序的，进而就有索引，进而就会增加一些针对索引操作的方法。

- 插入元素
  - `void add(int index, Object ele)`:在index位置插入ele元素
  - boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
- 获取元素
  - `Object get(int index)`:获取指定index位置的元素
  - List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
- 获取元素索引
  - int indexOf(Object obj):返回obj在集合中首次出现的位置
  - int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
- 删除和替换元素
  - `Object remove(int index)`:移除指定index位置的元素，并返回此元素
  - `Object set(int index, Object ele)`:设置指定index位置的元素为ele

小结：
    增
        add(Object obj)
        addAll(Collection coll)
    删
        remove(Object obj)
        remove(int index)
    改
        set(int index, Object ele)
    查
        get(int index)
    插
        add(int index, Object ele)
        addAll(int index, Collection eles)
    长度
        size()
    遍历
        iterator() ：使用迭代器进行遍历
        增强for循环
        一般的for循环
5. Arraylist 是有序还是无序？为什么？（蜜*信息）

有序；底层使用数组：Object[]

2.3 Set接口

1. Set集合有哪些实现类，分别有什么特点？（拓*软件）
类似问题：
> Set的实现类有哪些？（博*科技）
|---- HashSet：主要实现类；底层使用的是HashMap，即使用数组+单向链表+红黑树结构进行存储。（jdk8中）
|---- LinkedHashSet：是HashSet的子类；在现有的数组+单向链表+红黑树结构的基础上，又添加了一组双向链表，用于记录添加元素的先后顺序。即：我们可以按照添加元素的顺                                    序实现遍历。便于频繁的查询操作。
|---- TreeSet：底层使用红黑树存储。可以按照添加的元素的指定的属性的大小顺序进行遍历。
2. List集合和Set集合的区别？（亚*科技、*海*翼科技，*华电*系统，达*贷）
Collection:存储一个一个的数据
    |-----子接口：List:存储有序的、可重复的数据 ("动态"数组)
           |---- ArrayList(主要实现类)、LinkedList、Vector

    |-----子接口：Set:存储无序的、不可重复的数据(高中学习的集合)
           |---- HashSet(主要实现类)、LinkedHashSet、TreeSet
3. Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别?（鸿*网络）
类似问题：
> 1.HashSet如何检查重复(创*科技)
> 3.Set使用哪个区分不能重复的元素的？（北京创**荣信息）
要求元素所在的类要重写两个方法：equals() 和 hashCode()。
同时，要求equals() 和 hashCode()要保持一致性！我们只需要在IDEA中自动生成两个方法的重写即可，即能保证两个方法的一致性。
4. TreeSet两种排序方式在使用的时候怎么起作用？（拓*软件）

在添加新的元素时，需要调用compareTo() 或 compare()

5. TreeSet的数据结构（*米）

红黑树

2.4 Map接口

1. 说一下Java的集合Map有哪些Map？（奥*医药）
|---- HashMap:主要实现类;线程不安全的，效率高;可以添加null的key和value值;底层使用数组+单向链表+红黑树结构存储（jdk8）
        |---- LinkedHashMap:是HashMap的子类；在HashMap使用的数据结构的基础上，增加了一对双向链表，用于记录添加的元素的先后顺序，
                            进而我们在遍历元素时，就可以按照添加的顺序显示。
                            开发中，对于频繁的遍历操作，建议使用此类。
    |---- TreeMap:底层使用红黑树存储;可以按照添加的key-value中的key元素的指定的属性的大小顺序进行遍历。需要考虑使用①自然排序 ②定制排序。
    |---- Hashtable:古老实现类;线程安全的，效率低;不可以添加null的key或value值;底层使用数组+单向链表结构存储（jdk8）
        |---- Properties:其key和value都是String类型。常用来处理属性文件。
2. final怎么用，修饰Map可以继续添加数据吗？（*深蓝）

final HashMap map = new HashMap();

map.put("AA",123);

可以！

3. Set和Map的比较（亚*科技）

HashSet底层就是HashMap

LinkedHashSet底层就是LinkedHashMap

TreeSet底层就是TreeMap

4. HashMap说一下，线程安全吗？（*米）
类似问题：
> HashMap为什么线程不安全？（微*银行）
> HashMap是线程安全的吗？为什么不安全？（*团、*东、顺*）

不安全

5. HashMap和Hashbable的区别？(银*数据、阿**巴芝麻信用、*众银行、爱*信、杭州*智公司)
类似问题：
> HashMap 和 HashTable 有什么区别，以及如何使用，以及他的一些方法？（阿*校招、*东、*度校招、顺*）
|---- HashMap:主要实现类;线程不安全的，效率高;可以添加null的key和value值;底层使用数组+单向链表+红黑树结构存储（jdk8）
|---- Hashtable:古老实现类;线程安全的，效率低;不可以添加null的key或value值;底层使用数组+单向链表结构存储（jdk8）
6. Hashtable是怎么实现的，为什么线程安全？（迪*创新）

数组+单向链表；底层方法使用synchronized修饰

7. HashMap和LinkedHashMap的区别（北京*晨阳光）
|---- HashMap:主要实现类;线程不安全的，效率高;可以添加null的key和value值;底层使用数组+单向链表+红黑树结构存储（jdk8）
|---- LinkedHashMap:是HashMap的子类；在HashMap使用的数据结构的基础上，增加了一对双向链表，用于记录添加的元素的先后顺序，进而我们在遍历元素时，就可以按照添加的顺序显示。开发中，对于频繁的遍历操作，建议使用此类。
8. HashMap 和 TreeMap 的区别（*度，太极**、*线途游、阿*校招）

底层的数据结构截然不同。

9. HashMap里面实际装的是什么？（惠*）

JDK7：HashMap内部声明了Entry，实现了Map中的Entry接口。（key，value作为Entry的两个属性出现）

JDK8：HashMap内部声明了Node，实现了Map中的Entry接口。（key，value作为Node的两个属性出现）

10. HashMap的key存储在哪里？和value存储在一起吗？那么value存储在哪里？说具体点？（湖**利软件、天*伟业）

数组+链表+红黑树。 key、value作为Node的属性出现

11. 自定义类型可以作为Key么？（阿*）

可以！ 要重写hashCode() 和equals()

Collections

1. 集合类的工具类是谁？用过工具类哪些方法？（顺*）

Collections。

add(Object obj)
addAll(Collection coll)
clear()
isEmpty()
size()
contains(Object obj)
containsAll(Collection coll)
retainAll(Collection coll)
remove(Object obj)
removeAll(Collection coll)
hashCode()
equals()
toArray()
*********
iterator()
2. Collection 和 Collections的区别？（平*金服、*软）
Collection：集合框架中的用于存储一个一个元素的接口，又分为List和Set等子接口。
Collections：用于操作集合框架的一个工具类。此时的集合框架包括：Set、List、Map
3. ArrayList 如何实现排序（阿*）

Collections.sort(list) 或 Collections.sort(list,comparator)

4. HashMap是否线程安全，怎样解决HashMap的线程不安全（中*卫星）
类似问题：
> 怎么实现HashMap线程安全？（*团、*东、顺*）
HashMap:线程不安全的
使用.synchronizedMap(map)方法，该方法可使将指定集合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全问题

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布