ThreadLocal 详解

ThreadLocal 是一个线程的内部存储类，对于被存储的对象，在不同的线程读取的变量是独立的。

实现原理是：对每一个线程都有一个ThreadLocalMap，ThreadLocal维护每个ThreadLocalMap中的值

ThreadLocalMap 内部是一个[]Enter, 不同的ThreadLocal都是存储在线程的同一个ThreadLocalMap中的，只是下标位置不同，

同一个ThreadLocal在不同线程的ThreadLocalMap中的下标值即索引值是相同的。

ThreadLocal 最常用的示例：

在主线程初始化ThreadLocal实例，在各个线程调用set、get，设置、获取存储在各个线程中的值

查看源码

当调用set函数时，会去获取当前线程的ThreadLocalMap对象，该对象是在Threadjava中申明，默认值为null。

当map为null时，则调用createMap,为threadLocals对象赋值，不为null，在调用ThreadLocalMap中的set函数，将值保存到数组中

当调用get方法时，获取当前线程的ThreadLocalMap对象，如果map不为null，则获取map持有的Entry对象，再返回该Entry对象持有的value值。

如果map为null或者获取的Enter对象为null，则会调用setInitialValue，而initialValue的返回值是null。

当map为null时，会调用createMap方法，实例化ThreadLocalMap

上面的set、get都会调用getMap方法，来获取当前线程的ThreadLocalMap实例

threadLocals 是在Threadjava中声明的，默认值为null，也就是说每个线程中都有这个对象，只是默认是null。

在set、get中都会对当前线程的ThreadLocalMap对象判断，当为null时，会调用createMap对ThreadLocalMap对象threadLocals赋值，

getEntry 函数就是获取key对应的节点Entry

在getEntry、set函数中可以看到value存储在[]Entry中的下标位置是由 keythreadLocalHashCode & (len-1)计算得出的。

就是ThreadLocal中的threadLocalHashCode 对[]Entry长度取模

getEntry，通过下标获取e，如果不为null而且再次校验key相等，则返回e

set时，e不为null，而且key相等，代表已存在，则替换evalue，

key不相等，代表不存在，而添加

当Entry[] 中存入的值数量已达到数组长度的3/4；

则会调用resize函数，调整Entry[]的长度，

将新数组长度2，遍历老数组，

重新获取下标h，判断h处是否有值，无值填充，有值则重新获取h，再填充

ThreadLocalMap 的内部类

Entry继承WeakReference，说明ThreadLocal内部存储的类型都是采取弱引用累心存储，当GC时，则会被回收。

这样保证当线程执行完时，当前线程中存储在ThreadLocalMap中的对象会被回收，不会在此处出现内存泄漏

value是调用ThreadLocal保存的值，

MapEntry 是Map中的一个接口，他的用途是表示一个映射项（里面有Key和Value），而Set<MapEntry<K,V>>表示一个映射项的Set。

MapEntry里有相应的getKey和getValue方法，即JavaBean，让我们能够从一个项中取出Key和Value。

扩展资料

因为Map这个类没有继承Iterable接口所以不能直接通过mapiterator来遍历，所以就只能先转化为set类型，用entrySet()方法，其中set中的每一个元素值就是map中的一个键值对，也就是MapEntry<K,V>了，然后就可以遍历了。

MapEntry使用方法介绍：

Set keys = mapkeySet( );

if(keys != null) {

Iterator iterator = keysiterator( );

while(iteratorhasNext( )) {

Object key = iteratornext( );

Object value = mapget(key);

;

;}

}

package MyTest;

import javautilHashMap;

import javautilMap;

import javautilSet;

public class TestEntrySet {

public static void main(String[] args) {

     Map<String,String> map = new HashMap<String,String>();

     mapput("name", "zhangsan");

     mapput("gender", "man");

     Set<MapEntry<String,String>> entry = mapentrySet();

    for(MapEntry<String,String> entry_elem:entry){

        Systemoutprintln(entry_elemgetKey()toString()+":"+entry_elemgetValue()toString());

    }

}

}

简单的理解，就是Entryset是获得一个set集合，并且泛型是MapEntry的对象结果集，这样你就可以通过Set集合来进行遍历，是一种Map功能的增强。使用这种方式你可以在不知道key的情况下遍历Map对象。

具体如下：

1、简介

编程是编写程序的中文简称，就是让计算机代为解决某个问题，对某个计算体系规定一定的运算方式，是计算体系按照该计算方式运行，并最终得到相应结果的过程。

为了使计算机能够理解人的意图，人类就必须将需解决的问题的思路、方法和手段通过计算机能够理解的形式告诉计算机，使得计算机能够根据人的指令一步一步去工作，完成某种特定的任务。这种人和计算体系之间交流的过程就是编程。

2、汇编程序

汇编程序。使用汇编语言编写计算机程序，程序员仍然需要十分熟悉计算机系统的硬件结构，所以从程序设计本身上来看仍然是低效率的、繁琐的。但正是由于汇编语言与计算机硬件系统关系密切，在某些特定的场合，如对时空效率要求很高的系统核心程序以及实时控制程序等，迄今为止汇编语言仍然是十分有效的程序设计工具。

3、执行原理

计算机对除机器语言以外的源程序不能直接识别、理解和执行，都必须通过某种方式转换为计算机能够直接执行的。这种将高级编程硬件程序设计语言编写的源程序转换到机器目标程序的方式有两种:解释方式和编译方式。

java集合里面的函数

java集合里面的函数_java集合1——— 从集合接口框架说起

百里方欣

原创

关注

0点赞·155人阅读

(一) java集合分类

之前大概分为三种，Set，List，Map三种，JDK5之后，增加Queue主要由Collection和Map两个接口衍生出来,同时Collection接口继承Iterable接口，所以我们也可以说java里面的集合类主要是由Iterable和Map两个接口以及他们的子接口或者其实现类组成。我们可以认为Collection接口定义了单列集合的规范，每次只能存储一个元素，而Map接口定义了双列集合的规范，每次能存储一对元素。

Iterable接口:主要是实现遍历功能

Collection接口: 允许重复

Set接口：无序，元素不可重复,访问元素只能通过元素本身来访问。

List接口：有序且可重复，可以根据元素的索引来访问集合中的元素。

Queue接口：队列集合

Map接口：映射关系，简单理解为键值对，Key不可重复，与Collection接口关系不大，只是个别函数使用到。

整个接口框架关系如下(来自百度百科)：

(1) Iterable接口

1 内部定义的方法

java集合最源头的接口，实现这个接口的作用主要是集合对象可以通过迭代器去遍历每一个元素。

源码如下：

// 返回一个内部元素为T类型的迭代器(JDK15只有这个接口)

Iterator iterator();

// 遍历内部元素，action意思为动作，指可以对每个元素进行 *** 作(JDK18添加)

default void forEach(Consumer super T> action) {}

// 创建并返回一个可分割迭代器(JDK18添加)，分割的迭代器主要是提供可以并行遍历元素的迭代器，可以适应现在cpu多核的能力，加快速度。

default Spliterator spliterator() {

return SpliteratorsspliteratorUnknownSize(iterator(), 0);

}

从上面可以看出，foreach迭代以及可分割迭代，都加了default关键字，这个是Java 8 新的关键字，以前接口的所有接口，具体子类都必须实现，而对于deafult关键字标识的方法，其子类可以不用实现，这也是接口规范发生变化的一点。

下面我们分别展示三个接口的调用：

11 iterator方法

public static void iteratorHasNext(){

List list=new ArrayList();

listadd("Jam");

listadd("Jane");

listadd("Sam");

// 返回迭代器

Iterator iterator=listiterator();

// hashNext可以判断是否还有元素

while(iteratorhasNext()){

//next()作用是返回当前指针指向的元素,之后将指针移向下个元素

Systemoutprintln(iteratornext());

}

}

当然也可以使用for-each loop方式遍历

for (String item : list) {

Systemoutprintln(item);

}

但是实际上，这种写法在class文件中也是会转成迭代器形式，这只是一个语法糖。class文件如下：

public class IterableTest {

public IterableTest() { }

public static void main(String[] args) {

iteratorHasNext();

}

public static void iteratorHasNext() {

List list = new ArrayList();

listadd("Jam");

listadd("Jane");

listadd("Sam");

Iterator iterator = listiterator();

Iterator var2 = listiterator();

while(var2hasNext()) {

String item = (String)var2next();

Systemoutprintln(item);

}

}

}

需要注意的一点是，迭代遍历的时候，如果删除或者添加元素，都会抛出修改异常，这是由于快速失败fast-fail机制。

public static void iteratorHasNext(){

List list=new ArrayList();

listadd("Jam");

listadd("Jane");

listadd("Sam");

for (String item : list) {

if(itemequals("Jam")){

listremove(item);

}

Systemoutprintln(item);

}

}

从下面的错误我们可以看出，第一个元素是有被打印出来的，也就是remove *** 作是成功的，只是遍历到第二个元素的时候，迭代器检查，发现被改变了，所以抛出了异常。

Jam

Exception in thread "main" javautilConcurrentModificationException

at javautilArrayList$ItrcheckForComodification(ArrayListjava:909)

at javautilArrayList$Itrnext(ArrayListjava:859)

at IterableTestiteratorHasNext(IterableTestjava:15)

at IterableTestmain(IterableTestjava:7)

12 forEach方法

其实就是把对每一个元素的 *** 作当成了一个对象传递进来，对每一个元素进行处理。

default void forEach(Consumer super T> action) {

ObjectsrequireNonNull(action);

for (T t : this) {

actionaccept(t);

}

}

```java

当然像ArrayList自然也是有自己的实现的，那我们就可以使用这样的写法,简洁优雅。forEach方法在java8中参数是`javautilfunctionConsumer`,可以称为消费行为或者说动作类型。

```java

listforEach(x -> Systemoutprint(x));

同时，我们只要实现Consumer接口，就可以自定义动作，如果不自定义，默认迭代顺序是按照元素的顺序。

public class ConsumerTest {

public static void main(String[] args) {

List list=new ArrayList();

listadd("Jam");

listadd("Jane");

listadd("Sam");

MyConsumer myConsumer = new MyConsumer();

Iterator it = listiterator();

listforEach(myConsumer);

}

static class MyConsumer implements Consumer {

@Override

public void accept(Object t) {

Systemoutprintln("自定义打印：" + t);

}

}

}

输出的结果：

自定义打印：Jam

自定义打印：Jane

自定义打印：Sam

13 spliterator方法

这是一个为了并行遍历数据元素而设计的迭代方法，返回的是Spliterator，是专门并行遍历的迭代器。以发挥多核时代的处理器性能，java默认在集合框架中提供了一个默认的Spliterator实现，底层也就是StreamisParallel()实现的，我们可以看一下源码：

// stream使用的就是spliterator

default Stream stream() {

return StreamSupportstream(spliterator(), false);

}

default Spliterator spliterator() {

return Spliteratorsspliterator(this, 0);

}

public static Stream stream(Spliterator spliterator, boolean parallel) {

ObjectsrequireNonNull(spliterator);

return new ReferencePipelineHead<>(spliterator,

StreamOpFlagfromCharacteristics(spliterator),

parallel);

}

使用的方法如下：

public static void spliterator(){

List list = ArraysasList("1", "2", "3","4","5","6","7","8","9","10");

// 获取可迭代器

Spliterator spliterator = listspliterator();

// 一个一个遍历

Systemoutprintln("tryAdvance: ");

spliteratortryAdvance(item->Systemoutprint(item+" "));

spliteratortryAdvance(item->Systemoutprint(item+" "));

Systemoutprintln("\n-------------------------------------------");

// 依次遍历剩下的

Systemoutprintln("forEachRemaining: ");

spliteratorforEachRemaining(item->Systemoutprint(item+" "));

Systemoutprintln("\n------------------------------------------");

// spliterator1:0~10

Spliterator spliterator1 = listspliterator();

// spliterator1:6~10 spliterator2:0~5

Spliterator spliterator2 = spliterator1trySplit();

// spliterator1:8~10 spliterator3:6~7

Spliterator spliterator3 = spliterator1trySplit();

Systemoutprintln("spliterator1: ");

spliterator1forEachRemaining(item->Systemoutprint(item+" "));

Systemoutprintln("\n------------------------------------------");

Systemoutprintln("spliterator2: ");

spliterator2forEachRemaining(item->Systemoutprint(item+" "));

Systemoutprintln("\n------------------------------------------");

Systemoutprintln("spliterator3: ");

spliterator3forEachRemaining(item->Systemoutprint(item+" "));

}

tryAdvance() 一个一个元素进行遍历

forEachRemaining() 顺序地分块遍历

trySplit()进行分区形成另外的 Spliterator，使用在并行 *** 作中，分出来的是前面一半，就是不断把前面一部分分出来

结果如下：

tryAdvance:

1 2

-------------------------------------------

forEachRemaining:

3 4 5 6 7 8 9 10

------------------------------------------

spliterator1:

8 9 10

------------------------------------------

spliterator2:

1 2 3 4 5

------------------------------------------

spliterator3:

6 7

还有一些其他的用法在这里就不列举了，主要是trySplit()之后，可以用于多线程遍历。理想的时候，可以平均分成两半，有利于并行计算，但是不是一定平分的。

2 Collection接口 extend Iterable

Collection接口可以算是集合类的一个根接口之一，一般不能够直接使用，只是定义了一个规范，定义了添加，删除等管理数据的方法。继承Collection接口的有List，Set,Queue,不过Queue定义了自己的一些接口，相对来说和其他的差异比较大。

21 内部定义的方法

源码如下：

boolean add(Object o) //添加元素

boolean remove(Object o) //移除元素

boolean addAll(Collection c) //批量添加

boolean removeAll(Collection c) //批量移除

void retainAll(Collection c) // 移除在c中不存在的元素

void clear() //清空集合

int size() //集合大小

boolean isEmpty() //是否为空

boolean contains(Object o) //是否包含在集合中

boolean containsAll(Collection c) //是否包含所有的元素

Iterator iterator() // 获取迭代器

Object[] toArray() // 转成数组

default boolean removeIf(Predicate super E> filter) {} // 删除集合中复合条件的元素，删除成功返回true

boolean equals(Object o)

int hashCode()

default Spliterator spliterator() {} //获取可分割迭代器

default Stream stream() {} //获取流

default Stream parallelStream() {} //获取并行流

里面获取并行流的方法parallelStream(),其实就是通过默认的ForkJoinPool(主要用来使用分治法(Divide-and-Conquer Algorithm)来解决问题)，提高多线程任务的速度。我们可以使用ArrayList来演示一下平行处理能力。例如下面的例子，输出的顺序就不一定是1,2,3，可能是乱序的，这是因为任务会被分成多个小任务，任务执行是没有特定的顺序的。

List list = ArraysasList(1, 2, 3, 4, 5, 6, 7, 8, 9);

listparallelStream()

forEach(out::println);

22 继承Collection的主要接口

graph LR;

Collection -->List-有顺序,可重复

List-有顺序,可重复 -->LinkedList-使用链表实现,线程不安全

List-有顺序,可重复 -->ArrayList-数组实现,线程不安全

List-有顺序,可重复 -->Vector-数组实现,线程安全

Vector-数组实现,线程安全 -->Stack-堆栈,先进后出

Collection-->Set-不可重复,内部排序

Set-不可重复,内部排序-->HashSet-hash表存储

HashSet-hash表存储-->LinkHashSet-链表维护插入顺序

Set-不可重复,内部排序-->TreeSet-二叉树实现,排序

Collection-->Queue-队列,先进先出

221 List extend Collection

继承于Collection接口，有顺序，取出的顺序与存入的顺序一致，有索引，可以根据索引获取数据，允许存储重复的元素，可以放入为null的元素。

最常见的三个实现类就是ArrayList，Vector,LinkedList，ArrayList和Vector都是内部封装了对数组的 *** 作，唯一不同的是，Vector是线程安全的，而ArrayList不是，理论上ArrayList *** 作的效率会比Vector好一些。

里面是接口定义的方法：

int size(); //获取大小

boolean isEmpty(); //判断是否为空

boolean contains(Object o); //是否包含某个元素

Iterator iterator(); //获取迭代器

Object[] toArray(); // 转化成为数组(对象)

T[] toArray(T[] a); // 转化为数组(特定位某个类)

boolean add(E e); //添加

boolean remove(Object o); //移除元素

boolean containsAll(Collection> c); // 是否包含所有的元素

boolean addAll(Collection extends E> c); //批量添加

boolean addAll(int index, Collection extends E> c); //批量添加，指定开始的索引

boolean removeAll(Collection> c); //批量移除

boolean retainAll(Collection> c); //将c中不包含的元素移除

default void replaceAll(UnaryOperator operator) {}//替换

default void sort(Comparator super E> c) {}// 排序

void clear();//清除所有的元素

boolean equals(Object o);//是否相等

int hashCode(); //计算获取hash值

E get(int index); //通过索引获取元素

E set(int index, E element);//修改元素

void add(int index, E element);//在指定位置插入元素

E remove(int index);//根据索引移除某个元素

int indexOf(Object o); //根据对象获取索引

int lastIndexOf(Object o); //获取对象元素的最后一个元素

ListIterator listIterator(); // 获取List迭代器

ListIterator listIterator(int index); // 根据索引获取当前的位置的迭代器

List subList(int fromIndex, int toIndex); //截取某一段数据

default Spliterator spliterator(){} //获取可切分迭代器

上面的方法都比较简单，值得一提的是里面出现了ListIterator，这是一个功能更加强大的迭代器，继承于Iterator,只能用于List类型的访问，拓展功能例如：通过调用listIterator()方法获得一个指向List开头的ListIterator，也可以调用listIterator(n)获取一个指定索引为n的元素的ListIterator,这是一个可以双向移动的迭代器。

*** 作数组索引的时候需要注意，由于List的实现类底层很多都是数组，所以索引越界会报错IndexOutOfBoundsException。

说起List的实现子类：

ArrayList：底层存储结构是数组结构，增加删除比较慢，查找比较快，是最常用的List集合。线程不安全。

LinkedList：底层是链表结构，增加删除比较快，但是查找比较慢。线程不安全。

Vector：和ArrayList差不多，但是是线程安全的，即同步。

222 Set extend Collection

Set接口，不允许放入重复的元素，也就是如果相同，则只存储其中一个。

下面是源码方法：

int size(); //获取大小

boolean isEmpty(); //是否为空

boolean contains(Object o); //是否包含某个元素

Iterator iterator(); //获取迭代器

Object[] toArray(); //转化成为数组

T[] toArray(T[] a); //转化为特定类的数组

boolean add(E e); //添加元素

boolean remove(Object o); //移除元素

boolean containsAll(Collection> c); //是否包含所有的元素

boolean addAll(Collection extends E> c); //批量添加

boolean retainAll(Collection> c); //移除所有不存在于c集合中的元素

boolean removeAll(Collection> c); //移除所有在c集合中存在的元素

void clear(); //清空集合

boolean equals(Object o); //是否相等

int hashCode(); //计算hashcode

default Spliterator spliterator() {} //获取可分割迭代器

主要的子类：

HashSet

允许空值

通过HashCode方法计算获取hash值，确定存储位置，无序。

LinkedHashSet

HashSet的子类

有顺序

TreeSet

如果无参数构建Set，则需要实现Comparable方法。

亦可以创建时传入比较方法，用于排序。

223 Queue extend Collection

队列接口，在Collection接口的接触上添加了增删改查接口定义，一般默认是先进先出，即FIFO，除了优先队列和栈，优先队列是自己定义了排序的优先顺序，队列中不允许放入null元素。

下面是源码：

boolean add(E e); //插入一个元素到队列，失败时返回IllegalStateException (如果队列容量不够)

boolean offer(E e); //插入一个元素到队列，失败时返回false

E remove(); //移除队列头的元素并移除

E poll(); //返回并移除队列的头部元素，队列为空时返回null

E element(); //返回队列头元素

E peek(); //返回队列头部的元素，队列为空时返回null

主要的子接口以及实现类有：

Deque(接口):Queue的子接口，双向队列，可以从两边存取

ArrayDeque：Deque的实现类，底层用数组实现，数据存贮在数组中

AbstractQueue：Queue的子接口，仅实现了add、remove和element三个方法

PriorityQueue：按照默认或者自己定义的顺序来排序元素，底层使用堆(完全二叉树)实现，使用动态数组实现，

BlockingQueue： 在javautilconcurrent包中，阻塞队列，满足当前无法处理的 *** 作。

(2) Map接口

定义双列集合的规范Map，每次存储一对元素，即key和value。

key的类型可以和value的类型相同，也可以不同，任意的引用类型都可以。

key是不允许重复的，但是value是可以重复的，所谓重复是指计算的hash值系统。

下面的源码的方法：

V put(K key, V value); // 添加元素

V remove(Object key); // 删除元素

void putAll(Map extends K, extends V> m); // 批量添加

void clear() // 移除所有元素

V get(Object key); // 通过key查询元素

int size(); // 查询集合大小

boolean isEmpty(); // 集合是否为空

boolean containsKey(Object key); // 是否包含某个key

boolean containsValue(Object value); // 是否包含某个value

Set keySet(); // 获取所有key的set集合

Collection values(); // 获取所有的value的set集合

Set> entrySet(); // 返回键值对的set，每一个键值对是一个entry对象

boolean equals(Object o); // 用于比较的函数

int hashCode(); // 计算hashcode

default V getOrDefault(Object key, V defaultValue) // 获取key对应的Value，没有则返回默认值()

default void forEach(BiConsumer super K, super V> action) {} // 遍历

default void replaceAll(BiFunction super K, super V, extends V> function) {} // 批量替换

// 缺少这个key的时候才会添加进去

// 返回值是是key对应的value值，如果不存在，则返回的是刚刚放进去的value

default V putIfAbsent(K key, V value) {}

default boolean remove(Object key, Object value) {} // 移除元素

default boolean replace(K key, V oldValue, V newValue) {} // 替换

default V replace(K key, V value) {} //替换

// 和putIfAbsent有点像，只不过传进去的mappingFunction是映射函数，也就是如果不存在key对应的value，将会执行函数，函数返回值会被当成value添加进去，同时返回新的value值

default V computeIfAbsent(K key,Function super K, extends V> mappingFunction) {}

// 和computeIfAbsent方法相反，只有key存在的时候，才会执行函数，并且返回

default V computeIfPresent(K key,BiFunction super K, super V, extends V> remappingFunction) {}

// 不管如何都会执行映射函数，返回value

default V compute(K key,BiFunction super K, super V, extends V> remappingFunction) {}

default V merge(K key, V value,BiFunction super V, super V, extends V> remappingFunction) {}

值得注意的是，Map里面定义了一个Entry类，其实就是定义了一个存储数据的类型，一个entry就是一个

Map的常用的实现子类：

HashMap：由数组和链表组成，线程不安全，无序。

LinkedHashMap：如果我们需要是有序的，那么就需要它，时间和空间效率没有HashMap那么高，底层是维护一条双向链表，保证了插入的顺序。

ConcurrentHashMap：线程安全，17JDK使用锁分离，每一段Segment都有自己的独立锁，相对来说效率也比较高。JDK18抛弃了Segment，使用Node数组+链表和红黑树实现，在线程安全控制上使用Synchronize和CAS，可以认为是优化的线程安全的HashMap。

HashTable：对比与HashMap主要是使用关键字synchronize，加上同步锁，线程安全。

(二)总结

这些集合原始接口到底是什么？为什么需要？

我想，这些接口其实都是一种规则/规范的定义，如果不这么做也可以，所有的子类自己实现，但是从迭代以及维护的角度来说，这就是一种抽象或者分类，比如定义了Iterator接口，某一些类就可以去继承或者实现，那就得遵守这个规范/契约。可以有所拓展，每个子类的拓展不一样，所以每个类就各有所长，但是都有一个中心，就是原始的集合接口。比如实现Map接口的所有类的中心思想都不变，只是各有所长，各分千秋，形成了大千集合世界。

作者简介：

秦怀，公众号秦怀杂货店作者，技术之路不在一时，山高水长，纵使缓慢，驰而不息。个人写作方向：Java源码解析，JDBC，Mybatis，Spring，redis，分布式，剑指Offer，LeetCode等，认真写好每一篇文章，不喜欢标题党，不喜欢花里胡哨，大多写系列文章，不能保证我写的都完全正确，但是我保证所写的均经过实践或者查找资料。遗漏或者错误之处，还望指正。

平日时间宝贵，只能使用晚上以及周末时间学习写作，关注我，我们一起成长吧~

右侧：mapentrySet()是调用map对象的一个entrySet成员方法，把map转换成集合类型。

左侧：Set<MapEntry<K,V>> entrySet是定义变量entrySet，其类型为一个集合，集合的元素类型是什么呢？是<>包围的MapEntry<K,V>

jsp是不能直接去读取的 需要服务器先读取 enty节点中的值 假设保存在变量 String a中

然后 requestsetAttribute("RESULT",a);

服务器转发至jsp页面 forward方法

读取 el表达式 ${requestScopeRESULT}

Entry是Map中的一个内部累，mapentrySet()可以得到key和value的视图给你一个比较简单的小事例

public static void main(String[] args) {

Map map = new HashMap();

mapput("key1", "value1");

mapput("key2", "value2");

mapput("key3", "value3");

mapput("key4", "value4");

Set set = mapkeySet();//将map的kye放到set里了

Iterator iter = setiterator();

while(iterhasNext()){

String key = (String)iternext();

Systemoutprintln("key=" + key + " value=" + mapget(key));

}

Systemoutprintln("----------------------------------------------------");

Iterator iter1 = mapentrySet()iterator();

while(iter1hasNext()){

MapEntry me = (MapEntry)iter1next();

Systemoutprintln("key=" + megetKey() + " value=" + megetValue());

}

}

运行下这个代码 你就明白了

以上就是关于ThreadLocal 详解全部的内容，包括:ThreadLocal 详解、Map集合中的entry是什么、Java中map的entrySet()方法返回的是什么内容等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！