JavaSE(集合框架)

1. 集合框架

Java 集合框架 Java Collection Framework ，又被称为容器 container ，是定义在 java.util 包下的一组接口 interfaces 和其实现类 classes 。其主要表现为将多个元素 element 置于一个单元中，用于对这些元素进行快速、便捷的存储、检索 、管理 。
Collection：是一个接口，包含了大部分容器常用的一些方法。
List：是一个接口，规范了ArrayList 和 LinkedList中要实现的方法，ArrayList：实现了List接口，底层为动态类型顺序表，LinkedList：实现了List接口，底层为双向链表。
Stack：底层是栈，栈是一种特殊的顺序表。
Queue：底层是队列，队列是一种特殊的顺序表。
Deque：是一个接口。
Set：集合，是一个接口，里面放置的是K模型，
HashSet：底层为哈希桶，查询的时间复杂度为O(1)，TreeSet：底层为红黑树，查询的时间复杂度为O(log2N ),关于key有序的。
Map：映射，里面存储的是K-V模型的键值对，HashMap：底层为哈希桶，查询时间复杂度为O(1)，TreeMap：底层为红黑树，查询的时间复杂度为O(log2N )，关于key有序。

2. 泛型

就是适用于许多类型，从代码上讲，就是对类型实现了参数化，泛型的主要目的：就是指定当前的容器，要持有什么类型的对象，让编译器去做检查。此时，就需要把类型作为参数传递，需要什么类型就传入什么类型。
类名后的 代表占位符，表示当前类是一个泛型类，数据类型参数化，编译时自动进行类型检查和转换。

擦除机制：
为什么不能实例化泛型类型数组：
泛型的上界：
通配符：
通配符上界：
通配符下界：

3. 包装类

装箱和拆箱：
自动装箱和自动拆箱：

4. Collection

Collection也是一个接口，该接口中规范了后序容器中常用的一些方法。
Collection中有哪些方法：

5. Iterable

Iterable也是一个接口，表示实现该接口的类是可以逐个元素进行遍历的。

4. List

List是一个接口，并不能直接用来实例化，继承自Collection,List就是一个线性表，即n个具有相同类型元素的有限序列，在该序列上可以执行增删改查以及变量等操作。在集合框架中，ArrayList和LinkedList都实现了List接口。

5. 线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列…
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

6. 顺序表

顺序表是用一段物理地址，连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。顺序表中间/头部的插入删除，时间复杂度为O(N)，增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗，增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。

7. ArrayList

ArrayList实现了RandomAccess接口，支持随机访问，ArrayList实现了Cloneable接口，可以clone，ArrayList实现了Serializable接口，支持序列化，和Vector不同，ArrayList不是线程安全的，在单线程下可以使用，在多线程中可以选择Vector或者CopyOnWriteArrayList，ArrayList底层是一段连续的空间，ArrayList底层使用数组来存储元素并且可以动态扩容，是一个动态类型的顺序表。当在ArrayList任意位置插入或者删除元素时，就需要将后序元素整体往前或者往后搬移，时间复杂度为O(n)，效率比较低，因此ArrayList不适合做任意位置插入和删除比较多的场景。

ArrayList的遍历：
for循环+下标、foreach、使用迭代器。

ArrayList的扩容机制：
ArrayList是一个动态类型的顺序表，即：在插入元素的过程中会自动扩容。
检测是否真正需要扩容，如果是调用grow准备扩容，预估需要库容的大小，初步预估按照1.5倍大小扩容，如果用户所需大小超过预估1.5倍大小，则按照用户所需大小扩容，真正扩容之前检测是否能扩容成功，防止太大导致扩容失败，使用copyOf进行扩容。

7. 链表

链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。链式结构在逻辑上时连续的，但是在物理上不一定连续，现实中的节点一般都是从堆上申请出来的，从堆上申请的空间，是按照一定的策略来分配的，两次申请的空间可能连续也可能不连续。
8种链表结构：单向或者双向，带头或者不带头，循环或者非循环，无头单向非循环链表。
链表的实现：

8. LinkedList

在集合框架中，LinkedList也实现了List接口，LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高，时间复杂度为O(1)。LinkedList没有实现RandomAccess接口，因此LinkedList不支持随机访问，

9. ArrayList和LinkedList的区别

ArrayList：存储空间物理上一定连续，支持随机访问O(1)，头插需要搬移元素，效率低O(N)，插入空间不够时需要扩容，应用场景：元素高效存储+频繁访问。
LinkedList：存储空间逻辑上连续，但物理上不一定连续，不支持随机访问 O(N)，头插只需修改引用的指向，时间复杂度为O(1)，插入是没有容量的概念，应用场景：任意位置插入和删除频繁。

10. 栈

一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。出栈：栈的删除操作叫做出栈。出数据在栈顶。
栈的应用场景：改变元素的序列，将递归转化为循环，

栈、虚拟机栈、栈帧有什么区别呢？

11. 队列

在Java中，Queue是个接口，底层是通过链表实现的。队列是一种先进先出(FIFO)的数据结构，Queue是个接口，在实例化时必须实例化LinkedList的对象，因LinkedList实现了Queue接口。
队列模拟实现
循环队列

双端队列：双端队列（deque）是指允许两端都可以进行入队和出队操作的队列，deque 是 “double ended queue” 的简称。那就说明元素可以从队头出队和入队，也可以从队尾出队和入队。Deque是一个接口，使用时必须创建LinkedList的对象。

12. 哈希表

通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，不经过任何比较，一次直接从表中得到要搜索的元素。插入元素根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放。搜索元素对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功。哈希表的插入/删除/查找时间复杂度是O(1) 。哈希方法中使用的转换函数称为哈希函数，构造出来的结构称为哈希表(HashTable)(或者称散列表)。哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小。

常见哈希函数：
直接定制法：取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B 优点：简单、均匀 缺点：需要事先知道关键字的分布情况 使用场景：适合查找比较小且连续的情况。
除留余数法：设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，按照哈希函数Hash(key) = key% p(p<=m),将关键码转换成哈希地址。
平方取中法：假设关键字为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址； 再比如关键字为4321，对它平方就是18671041，抽取中间的3位671(或710)作为哈希地址 平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况
折叠法：折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这几部分叠加求和，并按散列表表长，取后几位作为散列地址。折叠法适合事先不需要知道关键字的分布，适合关键字位数比较多的情况。
随机数法：选择一个随机函数，取关键字的随机函数值为它的哈希地址，即H(key) = random(key),其中random为随机数函数。通常应用于关键字长度不等时采用此法。
数学分析法：数字分析法通常适合处理关键字位数比较大的情况，如果事先知道关键字的分布且关键字的若干位分布较均匀的情况，哈希函数设计的越精妙，产生哈希冲突的可能性就越低，但是无法避免哈希冲突。

哈希冲突：对于两个数据元素的关键字 和 (i != j)，有 != ，但有：Hash( ) == Hash( )，即：不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。

冲突-避免：冲突的发生是必然的，但我们能做的应该是尽量的降低冲突率，引起哈希冲突的一个原因可能是：哈希函数设计不够合理。 哈希函数设计原则：哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1之间，哈希函数计算出来的地址能均匀分布在整个空间中哈希函数应该比较简单。负载因子调节：所以当冲突率达到一个无法忍受的程度时，我们需要通过降低负载因子来变相的降低冲突率。已知哈希表中已有的关键字个数是不可变的，那我们能调整的就只有哈希表中的数组的大小。

冲突-解决：

闭散列：
也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把key存放到冲突位置中的“下一个” 空位置中去。
方法1：线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。插入：通过哈希函数获取待插入元素在哈希表中的位置，如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探测找到下一个空位置，插入新元素。采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。因此线性探测采用标记的伪删除法来删除一个元素。
方法2：
二次探测：
开散列/哈希桶：
开散列法又叫链地址法(开链法)，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中，开散列中每个桶中放的都是发生哈希冲突的元素。可以认为是把一个在大集合中的搜索问题转化为在小集合中做搜索了。

冲突严重时的解决办法：如果冲突严重，就意味着小集合的搜索性能其实也时不佳的，这个时候我们就可以将这个所谓的小集合搜索问题继续进行转化，例如：每个桶的背后是另一个哈希表，每个桶的背后是一棵搜索树。

HashMap 和 HashSet 是 java 中利用哈希表实现的 Map 和 Set，java 中使用的是哈希桶方式解决冲突的，java 会在冲突链表长度大于一定阈值后，将链表转变为搜索树（红黑树），java 中计算哈希值实际上是调用的类的 hashCode 方法，进行 key 的相等性比较是调用 key 的 equals 方法。所以如果要用自定义类作为 HashMap 的 key 或者 HashSet 的值，必须覆写 hashCode 和 equals 方法，而且要做到 equals 相等的对象，hashCode 一定是一致的

12. 二叉树

树是一种线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。有一个特殊的结点，称为根结点，根结点没有前驱结点，除根结点外，其余结点被分成M(M > 0)个互不相交的集合T1、T2、…、Tm，其中每一个集合 Ti (1 <= i<= m) 又是一棵与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继。树是递归定义的。树形结构中，子树之间不能有交集，否则就不是树形结构。

结点的度：一个结点含有子树的个数称为该结点的度。
树的度：一棵树中，所有结点度的最大值称为树的度。
叶子结点或终端结点：度为0的结点称为叶结点。
双亲结点或父结点：若一个结点含有子结点，则这个结点称为其子结点的父结点。
孩子结点或子结点：一个结点含有的子树的根结点称为该结点的子结点。
根结点：一棵树中，没有双亲结点的结点。
结点的层次：从根开始定义起，根为第1层，根的子结点为第2层，以此类推。
树的高度或深度：树中结点的最大层次；
非终端结点或分支结点：度不为0的结点。
兄弟结点：具有相同父结点的结点互称为兄弟结点；
堂兄弟结点：双亲在同一层的结点互为堂兄弟；
结点的祖先：从根到该结点所经分支上的所有结点。
子孙：以某结点为根的子树中任一结点都称为该结点的子孙。
森林：由m（m>=0）棵互不相交的树组成的集合称为森林。

树的表示形式：双亲表示法，孩子表示法、孩子双亲表示法、孩子兄弟表示法。

二叉树：
一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。
二叉树不存在度大于2的结点，二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树。

二叉树的性质：
若规定根结点的层数为1，则一棵非空二叉树的第i层上最多有 2^i-1(i>0)个结点。
若规定只有根结点的二叉树的深度为1，则深度为K的二叉树的最大结点数是 2^k-1(k>=0)。
对任何一棵二叉树, 如果其叶结点个数为 n0, 度为2的非叶结点个数为 n2,则有n0＝n2＋1。
具有n个结点的完全二叉树的深度k为 log2(n+1) 上取整。
对于具有n个结点的完全二叉树，如果按照从上至下从左至右的顺序对所有节点从0开始编号，则对于序号为i的结点有:若i>0，双亲序号：(i-1)/2；i=0，i为根结点编号，无双亲结点;若2i+1<n，左孩子序号：2i+1，否则无左孩子;若2i+2<n，右孩子序号：2i+2，否则无右孩子。

二叉树的存储：
叉树的存储结构分为：顺序存储和类似于链表的链式存储。
二叉树的链式存储是通过一个一个的节点引用起来的，常见的表示方式有二叉和三叉表示方式。

二叉树的遍历：
前中后序遍历：NLR：前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点—>根的左子树—>根的右子树。LNR：中序遍历(Inorder Traversal)——根的左子树—>根节点—>根的右子树。LRN：后序遍历(Postorder Traversal)——根的左子树—>根的右子树—>根节点。
层序遍历：设二叉树的根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。

满二叉树：一棵二叉树，如果每层的结点数都达到最大值，则这棵二叉树就是满二叉树。也就是说，如果一棵二叉树的层数为K，且结点总数是 ，则它就是满二叉树。

完全二叉树: 完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从0至n-1的结点一一对应时称之为完全二叉树。满二叉树是一种特殊的完全二叉树。

13. 堆

如果有一个关键码的集合K = {k0，k1， k2，…，kn-1}，把它的所有元素按完全二叉树的顺序存储方式存储 在一个一维数组中，并满足：Ki <= K2i+1 且 Ki<= K2i+2 (Ki >= K2i+1 且 Ki >=K2i+2) i = 0，1，2…，则称为 小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。对于非完全二叉树，则不适合使用顺序方式进行存储，因为为了能够还原二叉树，空间中必须要存储空节点，就会导致空间利用率比较低。
堆中某个节点的值总是不大于或不小于其父节点的值；堆总是一棵完全二叉树。
假设i为节点在数组中的下标，则有：如果i为0，则i表示的节点为根节点，否则i节点的双亲节点为 (i - 1)/2；如果2 * i + 1 小于节点个数，则节点i的左孩子下标为2 * i + 1，否则没有左孩子；如果2 * i + 2 小于节点个数，则节点i的右孩子下标为2 * i + 2，否则没有右孩子。

堆的创建：
建堆的时间复杂度为O(N)。

堆向下调整：

堆的插入：

堆的删除：

堆的应用：
用堆作为底层结构封装优先级队列，
堆排序，
Top-k问题：用数据集合中前K个元素来建堆，用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素。

14. 优先级队列

提供两个最基本的操作，一个是返回最高优先级对象，一个是添加新的对象。JDK1.8中的PriorityQueue底层使用了堆的数据结构，而堆实际就是在完全二叉树的基础之上进行了一些元素的调
整。Java集合框架中提供了PriorityQueue和PriorityBlockingQueue两种类型的优先级队列，PriorityQueue是线程不安全的，PriorityBlockingQueue是线程安全的。

使用时必须导入PriorityQueue所在的包，PriorityQueue中放置的元素必须要能够比较大小，不能插入无法比较大小的对象，否则会抛出ClassCastException异常，不能插入null对象，否则会抛出NullPointerException，没有容量限制，可以插入任意多个元素，其内部可以自动扩容，插入和删除元素的时间复杂度为O（log2N）， PriorityQueue底层使用了堆数据结构，PriorityQueue默认情况下是小堆—即每次获取到的元素都是最小的元素。

集合框架中PriorityQueue的比较方式：
PriorityQueue采用了Comparble和Comparator两种方式，Comparble是默认的内部比较方式，如果用户插入自定义类型对象时，该类对象必须要实现Comparble接口，并覆写compareTo方法，用户也可以选择使用比较器对象，如果用户插入自定义类型对象时，必须要提供一个比较器类，让该类实现Comparator接口并覆写compare方法。

优先级队列的构造：

插入/删除/获取优先级最高的元素：

优先级队列的扩容：如果容量小于64时，是按照oldCapacity的2倍方式扩容的，如果容量大于等于64，是按照oldCapacity的1.5倍方式扩容的，如果容量超过MAX_ARRAY_SIZE，按照MAX_ARRAY_SIZE来进行扩容。

优先级队列的应用：top-k问题，

模拟实现PriorityQueue

15. Map

Map中存储的就是key-value的键值对，是一种专门用来进行搜索的容器或者数据结构，其搜索的效率与其具体的实例化子类有关，是一种适合动态查找的集合容器。Map是一个接口类，该类没有继承自Collection，该类中存储的是<K,V>结构的键值对，并且K一定是唯一的，不能重复。Map.Entry<K, V> 是Map内部实现的用来存放<key, value>键值对映射关系的内部类，该内部类中主要提供了<key, value>的获取，value的设置以及Key的比较方式，并没有提供设置Key的方法。Map是一个接口，不能直接实例化对象，如果要实例化对象只能实例化其实现类TreeMap或者HashMap。. Map中存放键值对的Key是唯一的，value是可以重复的。Map中的Key可以全部分离出来，存储到Set中来进行访问(因为Key不能重复)。Map中的value可以全部分离出来，存储在Collection的任何一个子集合中(value可能有重复)。Map中键值对的Key不能直接修改，value可以修改，如果要修改key，只能先将该key删除掉，然后再来进行重新插入。

TreeMap和HashMap的区别：
TreeMap 底层结构是红黑树 ，插入/删除/查找时间复杂度O(log2N),关于Key有序 ,线程不安全，插入/删除/查找需要进行元素比较，key必须能够比较，否则会抛出ClassCastException异常，需要Key有序场景下应用。
HashMap：底层结构哈希桶，插入/删除/查找时间复杂度O(1),无序,线程不安全，插入/删除/查找通过哈希函数计算哈希地址，自定义类型需要覆写equals和hashCode方法，应用场景是Key是否有序不关心，需要更高的时间性能

16. Set

Set是继承自Collection的接口类，Set中只存储了Key，并且要求key一定要唯一，是一种专门用来进行搜索的容器或者数据结构，其搜索的效率与其具体的实例化子类有关，是一种适合动态查找的集合容器。Set的底层是使用Map来实现的，其使用key与Object的一个默认对象作为键值对插入到Map中的。Set最大的功能就是对集合中的元素进行去重，实现Set接口的常用类有TreeSet和HashSet，还有一个LinkedHashSet，LinkedHashSet是在HashSet的基础上维护了一个双向链表来记录元素的插入次序。Set中的Key不能修改，如果要修改，先将原来的删除掉，然后再重新插入。Set中不能插入null的key。

TreeSet和HashSet的区别：
TreeSet底层结构红黑树，插入/删除/查找时间复杂度O(log2N),关于Key有序,线程不安全，插入/删除/查找按照红黑树的特性来进行插入和删除 ，key必须能够比较，否则会抛出ClassCastException异常，应用场景是需要Key有序场景下。
HashSet底层结构哈希桶，插入/删除/查找时间复杂度O(1）,不一定有序,线程不安全,插入/删除/查找先计算key哈希地址然后进行插入和删除,自定义类型需要覆写equals和hashCode方法,应用场景是Key是否有序不关心，需要更高的时间性能。

17. 搜索树

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树：若它的左子树不为空，则左子树上所有节点的值都小于根节点的值，若它的右子树不为空，则右子树上所有节点的值都大于根节点的值，它的左右子树也分别为二叉搜索树。
查找：
插入：
删除：
实现：

最优情况下，二叉搜索树为完全二叉树，其平均比较次数为：log2N,最差情况下，二叉搜索树退化为单支树，其平均比较次数为N/2。

18 . 反射

Java的反射（reflection）机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射（reflection）机制。在日常的第三方应用开发过程中，经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统应用开放，这时候就可以利用Java的反射机制通过反射来获取所需的私有成员或是方法。反射最重要的用途就是开发各种通用框架，比如在spring中，我们将所有的类Bean交给spring容器管理，无论是XML配置Bean还是注解配置，当我们从容器中获取Bean来依赖注入时，容器会读取配置，而配置中给的就是类的信息，spring根据这些信息，需要创建那些Bean，spring就动态的创建这些类。

反射基本信息：
Java程序中许多对象在运行时会出现两种类型：运行时类型(RTTI)和编译时类型，例如Person p = new Student()；这句代码中p在编译时类型为Person，运行时类型为Student。程序需要在运行时发现对象和类的真实信息。而通过使用反射程序就能判断出该对象和类属于哪些类。

反射相关的类：
Class类 ：代表类的实体，在运行的Java应用程序中表示类和接口，Field类 ：代表类的成员变量/类的属性，Method类：代表类的方法，Constructor类 ：代表类的构造方法

Class类：
Java文件被编译后，生成了.class文件，JVM此时就要去解读.class文件 ,被编译后的Java文件.class也被JVM解析为
一个对象，这个对象就是 java.lang.Class .这样当程序在运行时，每个java文件就最终变成了Class类对象的一个实例。我们通过Java的反射机制应用到这个实例，就可以去获得甚至去添加改变这个类的属性和动作，使得这个类成为一个动态的类 。

Class类中的相关方法：
常用获得类相关的方法：
获得类的加载器getClassLoader() ，返回一个数组，数组中包含该类中所有类和接口类的对象(包括私有的)getDeclaredClasses()，根据类名返回类的对象forName(String className) ，创建类的实例newInstance()，获得类的完整路径名字getName()。
常用获得类中属性相关的方法：
获得某个公有的属性对象getField(String name) ，获得所有公有的属性对象getFields()，获得某个属性对象getDeclaredField(String name)，获得所有属性对象getDeclaredFields() 。
获得类中注解相关的方法：
返回该类中与参数类型匹配的公有注解对象getAnnotation(Class annotationClass)；返回该类所有的公有注解对象getAnnotations()，返回该类中与参数类型匹配的所有注解对象getDeclaredAnnotation(Class annotationClass) ，返回该类所有的注解对象getDeclaredAnnotations()。
获得类中构造器相关的方法：
获得该类中与参数类型匹配的公有构造方法getConstructor(Class…<?> parameterTypes)，获得该类的所有公有构造方法getConstructors()，获得该类中与参数类型匹配的构造方法getDeclaredConstructor(Class...<?> parameterTypes) ，获得该类所有构造方法getDeclaredConstructors()。
获得类中方法相关的方法：
获得该类某个公有的方法getMethod(String name, Class…<?> parameterTypes)；获得该类所有公有的方法getMethods()；获得该类某个方法getDeclaredMethod(String name, Class...<?> parameterTypes)；获得该类所有方法getDeclaredMethods() 。

优点：对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法，增加程序的灵活性和扩展性，降低耦合性，提高自适应能力，反射已经运用在了很多流行框架如：Struts、Hibernate、Spring 等等。缺点：使用反射会有效率问题。会导致程序效率降低。反射技术绕过了源代码的技术，因而会带来维护问题。反射代码比相应的直接代码更复杂。文章来源地址https://www.toymoban.com/news/detail-857230.html

到了这里，关于JavaSE(集合框架)的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！