151.Collection ， List ， Set 和 Map 用法和区别
Collection 接口的接口 对象的集合
├ List 子接口 按进入先后有序保存 可重复
│├ LinkedList 接口实现类 链表 插入删除 没有同步 线程不安全
│├ ArrayList 接口实现类 数组 随机访问 没有同步 线程不安全
│└ Vector 接口实现类 数组 同步 线程安全
│ └ Stack
└ Set 子接口 仅接收一次，并做内部排序
├ HashSet
│ └ LinkedHashSet
└ TreeSet
对于 List ，关心的是顺序， 它保证维护元素特定的顺序（允许有相同元素），使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在 List 中的位置，类似于数组下标）来访问 List 中的元素。
对于 Set ，只关心某元素是否属于 Set （不 允许有相同元素 ），而不关心它的顺序。
Map 接口 键值对的集合
├ Hashtable 接口实现类 同步 线程安全
├ HashMap 接口实现类 没有同步 线程不安全
│├ LinkedHashMap
│└ WeakHashMap
├ TreeMap
└ IdentifyHashMap
对于 Map ，最大的特点是键值映射，且为一一映射，键不能重复，值可以，所以是用键来索引值。 方法 put(Object key, Object value) 添加一个“值” ( 想要得东西 ) 和与“值”相关联的“键” (key) ( 使用它来查找 ) 。方法 get(Object key) 返回与给定“键”相关联的“值”。
Map 同样对每个元素保存一份，但这是基于 " 键 " 的， Map 也有内置的排序，因而不关心元素添加的顺序。如果添加元素的顺序对你很重要，应该使用LinkedHashSet 或者 LinkedHashMap.
对于效率， Map 由于采用了哈希散列，查找元素时明显比 ArrayList 快。
但我有一个自己的原则想法：复杂的问题简单化。即把很多晦涩难懂的问题用通俗直白的话，一下子就看明白了，而不是大段大段的写。不得不指出的是现在部分所谓的“专家”往往把简单的问题复杂化，让人看了生畏，甚至望而却步，以此来显示他的高深莫测，当然也可能有别的用意，那我就不得而知了。
更为精炼的总结：
Collection 是对象集合， Collection 有两个子接口 List 和 Set
List 可以通过下标 (1,2..) 来取得值，值可以重复
而 Set 只能通过游标来取值，并且值是不能重复的
ArrayList ， Vector ， LinkedList 是 List 的实现类
ArrayList 是线程不安全的， Vector 是线程安全的，这两个类底层都是由数组实现的
LinkedList 是线程不安全的，底层是由链表实现的
Map 是键值对集合
HashTable 和 HashMap 是 Map 的实现类
HashTable 是线程安全的，不能存储 null 值
HashMap 不是线程安全的，可以存储 null 值
152.JVM垃圾收集算法及垃圾收集器
http://blog.csdn.net/lzwglory/article/details/48996125
153.jvm 内存参数介绍
-Xmx Java Heap最大值,默认值为物理内存的1/4,最佳设值应该视物理内存大小及计算机内其他内存开销而定;
-Xms Java Heap初始值,Server端JVM最好将-Xms和-Xmx设为相同值,开发测试机JVM可以保留默认值;
-Xmn Java Heap Young区大小,不熟悉最好保留默认值;
-Xss 每个线程的Stack大小,不熟悉最好保留默认值;
154.jvm内存检测的视图工具：
JConsole 和VisualVM
155.类的加载过程：
156.java线程同步的5中方式
public class SynchronizedThread2 {
private static AtomicInteger accountNum=new AtomicInteger(100);
// 使用ThreadLocal类管理共享变量account
private static ThreadLocal<Integer> account = new ThreadLocal<Integer>() {
@Override
protected Integer initialValue() {
return accountNum.get();
}
};
class Bank {
public void save(int money) {
account.set(accountNum.addAndGet(money));
}
public int getAccount() {
return account.get();
}
}
class NewThread implements Runnable {
private Bank bank;
public NewThread(Bank bank) {
this.bank = bank;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
bank.save(10);
System.out.println(i + "账户余额为：" + bank.getAccount());
}
}
}
/**
* 建立线程，调用内部类
*/
public void useThread() {
Bank bank = new Bank();
NewThread new_thread = new NewThread(bank);
System.out.println("线程1");
Thread thread1 = new Thread(new_thread);
thread1.start();
System.out.println("线程2");
Thread thread2 = new Thread(new_thread);
thread2.start();
}
public static void main(String[] args) {
SynchronizedThread2 st = new SynchronizedThread2();
st.useThread();
}
}
public class SynchronizedThread {
class Bank {
private AtomicInteger account=new AtomicInteger(100);
public int getAccount() {
return account.get();
}
/**
* 用同步方法实现
*
* @param money
*/
public void save(int money) {
account.getAndAdd(money);
}
}
class NewThread implements Runnable {
private Bank bank;
public NewThread(Bank bank) {
this.bank = bank;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
bank.save(10);
System.out.println(i + "账户余额为：" + bank.getAccount());
}
}
}
/**
* 建立线程，调用内部类
*/
public void useThread() {
Bank bank = new Bank();
NewThread new_thread = new NewThread(bank);
System.out.println("线程1");
Thread thread1 = new Thread(new_thread);
thread1.start();
System.out.println("线程2");
Thread thread2 = new Thread(new_thread);
thread2.start();
}
public static void main(String[] args) {
SynchronizedThread st = new SynchronizedThread();
st.useThread();
}
}
157.java并发的3种特性：
原子性、可见性、有序性
158.Executors的常用线程池
1. newSingleThreadExecutor
创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。
2.newFixedThreadPool
创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。
3. newCachedThreadPool
创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，
那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。
4.newScheduledThreadPool
创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。
159.线程池与队列的关系
ExecutorService newFixedThreadPool(int nThreads):固定大小线程池。
可以看到，corePoolSize和maximumPoolSize的大小是一样的（实际上，后面会介绍，如果使用无界queue的话maximumPoolSize参数是没有意义的），keepAliveTime和unit的设值表名什么？-就是该实现不想keep alive！最后的BlockingQueue选择了LinkedBlockingQueue，该queue有一个特点，他是无界的。
- public static ExecutorService newFixedThreadPool(int nThreads) {
- return new ThreadPoolExecutor(nThreads, nThreads,
- 0L, TimeUnit.MILLISECONDS,
- new LinkedBlockingQueue<Runnable>());
- }
ExecutorService newSingleThreadExecutor()：单线程。
可以看到，与fixedThreadPool很像，只不过fixedThreadPool中的入参直接退化为1
- public static ExecutorService newSingleThreadExecutor() {
- return new FinalizableDelegatedExecutorService
- (new ThreadPoolExecutor(1, 1,
- 0L, TimeUnit.MILLISECONDS,
- new LinkedBlockingQueue<Runnable>()));
- }
ExecutorService newCachedThreadPool()：无界线程池，可以进行自动线程回收。
这个实现就有意思了。首先是无界的线程池，所以我们可以发现maximumPoolSize为big big。其次BlockingQueue的选择上使用SynchronousQueue。可能对于该BlockingQueue有些陌生，简单说：该QUEUE中，每个插入操作必须等待另一个
线程的对应移除操作。比如，我先添加一个元素，接下来如果继续想尝试添加则会阻塞，直到另一个线程取走一个元素，反之亦然。（想到什么？就是缓冲区为1的生产者消费者模式^_^）
注意到介绍中的自动回收线程的特性吗，为什么呢？先不说，但注意到该实现中corePoolSize和maximumPoolSize的大小不同。
- public static ExecutorService newCachedThreadPool() {
- return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
- 60L, TimeUnit.SECONDS,
- new SynchronousQueue<Runnable>());
- }
160.什么是java序列化，如何实现java序列化?
序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。
序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。
161.3.dubbo与http 传统掉接口的方法的优势
Dubbo通过长连接减少握手，通过NIO及线程池在单连接上并发拼包处理消息，通过二进制流压缩数据，比常规HTTP等短连接协议更快。在阿里巴巴内部，每天支撑2000多个服务，30多亿访问量，最大单机支撑每天近1亿访问量。
162.dubbo连接注册中心和直连的区别
在开发及测试环境下，经常需要绕过注册中心，只测试指定服务提供者，这时候可能需要点对点直连，
点对点直联方式，将以服务接口为单位，忽略注册中心的提供者列表，
A接口配置点对点，不影响B接口从注册中心获取列表
163.transient的作用
Java的serialization提供了一种持久化对象实例的机制。当持久化对象时，可能有一个特殊的对象数据成员，我们不想用 serialization机制来保存它。为了在一个特定对象的一个域上关闭serialization，可以在这个域前加上关键字transient。 当一个对象被序列化的时候，transient型变量的值不包括在序列化的表示中，然而非transient型的变量是被包括进去的。
164.null可以做map的key吗？
可以做为hashmap的key，不可以做为hashtable的key
165.map 的iterate 里面移除里面的key 再获得map.get()会拿到值吗
在使用iterator.hasNext()操作迭代器的时候，如果此时迭代的对象发生改变，比如插入了新数据，或者有数据被删除。
则使用会报以下异常：
java.util.ConcurrentModificationException
at java.util.HashMap$HashIterator.nextEntry(HashMap.java:793)
at java.util.HashMap$KeyIterator.next(HashMap.java:828)
例如以下程序（转自互联网）：
- mport java.util.*;
- public class Main
- {
- public static void main(String args[])
- {
- Main main = new Main();
- main.test();
- }
- public void test()
- {
- Map bb = new HashMap();
- bb.put("1", "wj");
- bb.put("2", "ry");
- Iterator it = bb.keySet().iterator();
- while(it.hasNext()) {
- Object ele = it.next();
- bb.remove(ele); //wrong
- }
- System.out.println("Success!");
- }
- }
原因：http://blog.csdn.net/lzwglory/article/details/49358039
http://blog.csdn.net/lzwglory/article/details/49358313
解决办法：
1) 使用Iterator的remove方法 不可以针对多线程
public class Main2 {
public static void main(String args[]) {
Main2 main = new Main2();
main.test();
}
public void test() {
Map bb = new HashMap();
bb.put("1", "wj");
bb.put("2", "ry");
Iterator it = bb.keySet().iterator();
while (it.hasNext()) {
Object ele = it.next();
it.remove();
// bb.remove(ele); // wrong
}
System.out.println("Success!");
}
} 2） 使用“ConcurrentHashMap”替换HashMap，ConcurrentHashMap会自己检查修改操作，对其加锁，也可针对插入操作。也可以只对多线程。
对于ArrayList的Iterator防止出现java.util.ConcurrentModificationException问题可以用CopyOnWriteArrayList，他也可以针对多线程。
165.Student类可以做map的key值吗 如果能请写出Student的类
先看代码：
import java.util.HashMap;
import java.util.Map;
class Student{
private String name;
private int age;
public Student(){
}
public Student(String name,int age){
this.age = age;
this.name = name;
}
}
public class Test {
public static void main(String[] args) {
Map<Student,String> map = new HashMap<Student,String>();
Student stu1 = new Student("张三",20);
Student stu = new Student("张三",20);
Student stu2 = new Student("李四",22);
Student stu3 = new Student("王五",23);
map.put(stu1,"学生张三");
map.put(stu2,"学生李四");
map.put(stu3,"学生王五");
String s = map.get(stu);
System.out.print(s);
}
}
上面代码输出结果是null，其实我是想输出”学生张三“。上面map的key可以设置为student类型，但是也产生一个问题，就是在执行get操作的时候，相同的内容，不同的对象，get出来的结果是不一样的。上面的stu和stu1虽然是不同对象，但是内容是一样的，如果我想在map.get（stu）的时候也输出”学生张三“（在没有把stu put进map里面的前提下），大神们可有什么办法不？
这个需要重写Student类的hashCode和equals方法。这两个方法是集成自超类Object的。
HashMap默认是使用hashCode对比传入的key是否一致，如果hashCode一致会用equals进行对比，如果还是一致那么认为是同一个key。
你的Student类有age和name两个成员变量，可以根据这两个变量设定hashCode和equals方法。
public int hashCode(){
return name.hashCode() + age;
}
public boolean equals(Object o){
return (o instanceof Student) &&
(age ==((Student)o).age) &&
(name == null && ((Student)o).name == null ||
name.equals(((Student)o).name)
);
}
166.逆序排列一个字符串考虑效能
StringBuilder sb=new StringBuilder("abc");
sb.reverse();
167.什么时候选择用 ReentrantLock 代替 synchronized
既然如此，我们什么时候才应该使用 ReentrantLock 呢？答案非常简单 —— 在确实需要一些 synchronized 所没有的特性的时候，比如时间锁等候、可中断锁等候、无块结构锁、多个条件变量或者锁投票。 ReentrantLock 还具有可伸缩性的好处，应当在高度争用的情况下使用它，但是请记住，大多数 synchronized 块几乎从来没有出现过争用，所以可以把高度争用放在一边。我建议用 synchronized 开发，直到确实证明 synchronized 不合适，而不要仅仅是假设如果使用 ReentrantLock “性能会更好”。请记住，这些是供高级用户使用的高级工具。（而且，真正的高级用户喜欢选择能够找到的最简单工具，直到他们认为简单的工具不适用为止。）。一如既往，首先要把事情做好，然后再考虑是不是有必要做得更快。
Lock 框架是同步的兼容替代品，它提供了 synchronized 没有提供的许多特性，它的实现在争用下提供了更好的性能。但是，这些明显存在的好处，还不足以成为用 ReentrantLock 代替 synchronized 的理由。相反，应当根据您是否 需要 ReentrantLock 的能力来作出选择。大多数情况下，您不应当选择它 —— synchronized 工作得很好，可以在所有 JVM 上工作，更多的开发人员了解它，而且不太容易出错。只有在真正需要 Lock 的时候才用它。在这些情况下，您会很高兴拥有这款工具。
168.死锁形成原因
Java线程死锁
Java线程死锁是一个经典的多线程问题，因为不同的线程都在等待那些根本不可能被释放的锁，从而导致所有的工作都无法完成。假设有两个线程，分别代表两个饥饿的人，他们必须共享刀叉并轮流吃饭。他们都需要获得两个锁：共享刀和共享叉的锁。
假如线程 “A”获得了刀，而线程“B”获得了叉。线程“A”就会进入阻塞状态来等待获得叉，而线程“B”则阻塞来等待“A”所拥有的刀。这只是人为设计的例子，但尽管在运行时很难探测到，这类情况却时常发生。虽然要探测或推敲各种情况是非常困难的，但只要按照下面几条规则去设计系统，就能够避免Java线程死锁问题：
让所有的线程按照同样的顺序获得一组锁。这种方法消除了 X 和 Y 的拥有者分别等待对方的资源的问题。
将多个锁组成一组并放到同一个锁下。前面Java线程死锁的例子中，可以创建一个银器对象的锁。于是在获得刀或叉之前都必须获得这个银器的锁。
将那些不会阻塞的可获得资源用变量标志出来。当某个线程获得银器对象的锁时，就可以通过检查变量来判断是否整个银器集合中的对象锁都可获得。如果是，它就可以获得相关的锁，否则，就要释放掉银器这个锁并稍后再尝试。
class Deadlocker {
static int field_1;
private static Object lock_1 = new int[1];
static int field_2;
private static Object lock_2 = new int[1];
public static void method1(int value) throws InterruptedException {
synchronized (lock_1) {
TimeUnit.SECONDS.sleep(1);
synchronized (lock_2) {
field_1 = 0;
field_2 = 0;
}
}
}
public static void method2(int value) throws InterruptedException {
synchronized (lock_2) {
TimeUnit.SECONDS.sleep(1);
synchronized (lock_1) {
field_1 = 0;
field_2 = 0;
}
}
}
public static void main(String[] args) {
ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
newCachedThreadPool.execute(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
try {
method1(1);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
newCachedThreadPool.execute(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
try {
method2(2);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}
}
168.不公平锁与公平锁的区别：
公平情况下，操作会排一个队按顺序执行，来保证执行顺序。（会消耗更多的时间来排队）
不公平情况下，是无序状态允许插队，jvm会自动计算如何处理更快速来调度插队。（如果不关心顺序，这个速度会更快）
169.ReentrantLock 和synchronized的区别
相同：ReentrantLock提供了synchronized类似的功能和内存语义。
不同：
1.ReentrantLock功能性方面更全面，比如时间锁等候，可中断锁等候，锁投票等，因此更有扩展性。在多个条件变量和高度竞争锁的地方，用ReentrantLock更合适，ReentrantLock还提供了Condition，对线程的等待和唤醒等操作更加灵活，一个ReentrantLock可以有多个Condition实例，所以更有扩展性。
2.ReentrantLock必须在finally中释放锁，否则后果很严重，编码角度来说使用synchronized更加简单，不容易遗漏或者出错。
3.ReentrantLock 的性能比synchronized会好点。
4.ReentrantLock提供了可轮询的锁请求，他可以尝试的去取得锁，如果取得成功则继续处理，取得不成功，可以等下次运行的时候处理，所以不容易产生死锁，而synchronized则一旦进入锁请求要么成功，要么一直阻塞，所以更容易产生死锁。
1、Lock的某些方法可以决定多长时间内尝试获取锁，如果获取不到就抛异常，这样就可以一定程度上减轻死锁的可能性。
如果锁被另一个线程占据了，synchronized只会一直等待，很容易错序死锁
2、synchronized的话，锁的范围是整个方法或synchronized块部分；而Lock因为是方法调用，可以跨方法，灵活性更大
3、便于测试，单元测试时，可以模拟Lock，确定是否获得了锁，而synchronized就没办法了
ReentrantLock比synchronized 强大在哪儿？
简单说：
1、ReentrantLock可以实现fair lock
public ReentrantLock(boolean fair) {
sync = (fair)? new FairSync() : new NonfairSync();
}
所谓fair lock就是看获得锁的顺序是不是和申请锁的时间的顺序是一致的
2、ReentrantLock支持中断处理
public final void acquireInterruptibly(int arg) throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
if (!tryAcquire(arg))
doAcquireInterruptibly(arg);
}
就是说那些持有锁的线程一直不释放，正在等待的线程可以放弃等待。
3、ReentrantLock可以和condition结合使用
public boolean hasWaiters(Condition condition) {
if (condition == null)
throw new NullPointerException();
if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
throw new IllegalArgumentException("not owner");
return sync.hasWaiters((AbstractQueuedSynchronizer.ConditionObject)condition);
}
public int getWaitQueueLength(Condition condition) {
if (condition == null)
throw new NullPointerException();
if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
throw new IllegalArgumentException("not owner");
return sync.getWaitQueueLength((AbstractQueuedSynchronizer.ConditionObject)condition);
}
170.Dubbo在安全机制方面是如何解决的
Dubbo主要针对内部服务，对外的服务，阿里有开放平台来处理安全和流控，所以Dubbo在安全方面实现的功能较少，基本上只防君子不防小人，只防止误调用。
Dubbo通过Token令牌防止用户绕过注册中心直连，然后在注册中心上管理授权。Dubbo还提供服务黑白名单，来控制服务所允许的调用方。
171.restful的优点
透明性，暴露资源存在。
充分利用 HTTP 协议本身语义。
无状态，这点非常重要。在调用一个接口（访问、操作资源）的时候，可以不用考虑上下文，不用考虑当前状态，极大的降低了复杂度。
172.http请求的过程
HTTP通信机制是在一次完整的HTTP通信过程中，Web浏览器与Web服务器之间将完成下列7个步骤：
1. 建立TCP连接
在HTTP工作开始之前，Web浏览器首先要通过网络与Web服务器建立连接，该连接是通过TCP来完成的，该协议与IP协议共同构建Internet，即著名的TCP/IP协议族，因此Internet又被称作是TCP/IP网络。HTTP是比TCP更高层次的应用层协议，根据规则，只有低层协议建立之后才能进行更高层协议的连接，因此，首先要建立TCP连接，一般TCP连接的端口号是80。
2. Web浏览器向Web服务器发送请求命令
一旦建立了TCP连接，Web浏览器就会向Web服务器发送请求命令。例如：GET/sample/hello.jsp HTTP/1.1。
3. Web浏览器发送请求头信息
浏览器发送其请求命令之后，还要以头信息的形式向Web服务器发送一些别的信息，之后浏览器发送了一空白行来通知服务器，它已经结束了该头信息的发送。
4. Web服务器应答
客户机向服务器发出请求后，服务器会客户机回送应答， HTTP/1.1 200 OK ，应答的第一部分是协议的版本号和应答状态码。
5. Web服务器发送应答头信息
正如客户端会随同请求发送关于自身的信息一样，服务器也会随同应答向用户发送关于它自己的数据及被请求的文档。
6. Web服务器向浏览器发送数据
Web服务器向浏览器发送头信息后，它会发送一个空白行来表示头信息的发送到此为结束，接着，它就以Content-Type应答头信息所描述的格式发送用户所请求的实际数据。
7. Web服务器关闭TCP连接
一般情况下，一旦Web服务器向浏览器发送了请求数据，它就要关闭TCP连接，然后如果浏览器或者服务器在其头信息加入了这行代码：Connection:keep-alive
TCP连接在发送后将仍然保持打开状态，于是，浏览器可以继续通过相同的连接发送请求。保持连接节省了为每个请求建立新连接所需的时间，还节约了网络带宽。
173.反应器模式（Reactor pattern）与观察者模式（Observer pattern）
将事件多路分用
将事件分派到各自相应的事件处理程序
分布式系统中的服务器应用程序必须处理多个向它们发送服务请求的客户机。然而，在调用特定的服务之前，服务器应用程序必须将每个传入请求多路分用并分派到 各自相应的服务提供者。反应器模式正好适用于这一功能。它允许事件驱动应用程序将服务请求多路分用并进行分派，然后，这些服务请求被并发地从一个或多个客 户机传送到应用程序。
反应器模式（Reactor pattern）与观察者模式（Observer pattern）在这个方面极为相似：当一个主体发生改变时，所有依属体都得到通知。不过，观察者模式与单个事件源关联，而反应器模式则与多个事件源关联 。
174.序列化的应用场景
tomcat关闭以后会把session对象序列化到SESSIONS.ser文件中，等下次启动的时候就把这些session再加载到内存里面来。
一般的，如果一个用户打开一个浏览器，服务器就会分配一个sessionid，通过session.getId()函数可以返回session的id;
但是如果一旦关闭服务器后，再重启服务器，刷新页面，则服务器会重新分配一个新的sessionid;
如果我们想要保留原有的id，则可以通过序列化方式保存sessionid。
实现的效果是这样的：
1.打开一个网页，网页的目的是输出session id；
2.关闭tomcat，则在temp文件夹下会出现一个临时文件；
3.重新启动tomcat；
4.刷新页面，session id不变；
Java序列化的作用
有的时候我们想要把一个Java对象变成字节流的形式传出去，有的时候我们想要从一个字节流中恢复一个Java对象。例如，有的时候我们想要
把一个Java对象写入到硬盘或者传输到网路上面的其它计算机，这时我们就需要自己去通过java把相应的对象写成转换成字节流。对于这种通用
的操作，我们为什么不使用统一的格式呢？没错，这里就出现了java的序列化的概念。在Java的OutputStream类下面的子类ObjectOutput-
Stream类就有对应的WriteObject(Object object) 其中要求对应的object实现了java的序列化的接口。
为了更好的理解java序列化的应用，我举两个自己在开发项目中遇到的例子:
1)在使用tomcat开发JavaEE相关项目的时候，我们关闭tomcat后，相应的session中的对象就存储在了硬盘上，如果我们想要在tomcat重启的
时候能够从tomcat上面读取对应session中的内容，那么保存在session中的内容就必须实现相关的序列化操作。
2)如果我们使用的java对象要在分布式中使用或者在rmi远程调用的网络中使用的话，那么相关的对象必须实现java序列化接口。
175.序列化介绍
Java对象的序列化有两种方式。
a.是相应的对象实现了序列化接口Serializable，这个使用的比较多，对于序列化接口Serializable接口是一个空的接口，它的主要作用就是
b.实现序列化的第二种方式为实现接口Externalizable
没错，Externlizable接口继承了java的序列化接口，并增加了两个方法:
void writeExternal(ObjectOutput out) throws IOException;
void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
首先，我们在序列化对象的时候，由于这个类实现了Externalizable 接口，在writeExternal()方法里定义了哪些属性可以序列化，
哪些不可以序列化，所以，对象在经过这里就把规定能被序列化的序列化保存文件，不能序列化的不处理，然后在反序列的时候自动调
用readExternal()方法，根据序列顺序挨个读取进行反序列，并自动封装成对象返回，然后在测试类接收，就完成了反序列。
所以说Exterinable的是Serializable的一个扩展。
首先，我们在序列化UserInfo对象的时候，由于这个类实现了Externalizable 接口，在writeExternal()方法里定义了哪些属性可
以序列化，哪些不可以序列化，所以，对象在经过这里就把规定能被序列化的序列化保存文件，不能序列化的不处理，然后在反序列
的时候自动调用readExternal()方法，根据序列顺序挨个读取进行反序列，并自动封装成对象返回，然后在测试类接收，就完成了反
序列。
***对于实现Java的序列化接口需要注意一下几点:
1.java中的序列化时transient变量(这个关键字的作用就是告知JAVA我不可以被序列化)和静态变量不会被序列
化(下面是一个测试的例子)
2.也是最应该注意的，如果你先序列化对象A后序列化B，那么在反序列化的时候一定记着JAVA规定先读到的对象
是先被序列化的对象，不要先接收对象B，那样会报错.尤其在使用上面的Externalizable的时候一定要注意读取
的先后顺序。
3.实现序列化接口的对象并不强制声明唯一的serialVersionUID，是否声明serialVersionUID对于对象序列化的向
上向下的兼容性有很大的影响。我们来做个测试：
扫一扫
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
