java基础补充

流

Java所有的流类位于java.io包中，都分别继承字以下四种抽象流类型。

Type字节流字符流输入流InputStreamReader输出流OutputStreamWriter

继承自InputStream/OutputStream的流都是用于向程序中输入/输出数据，且数据的单位都是字节(byte=8bit)。

继承自Reader/Writer的流都是用于向程序中输入/输出数据，且数据的单位都是字符(2byte=16bit)。

---

异常

Java的异常(包括Exception和Error)分为：

• 可查的异常（checked exceptions）

除了RuntimeException及其子类以外，其他的Exception类及其子类都属于可查异常。这种异常的特点是Java编译器会检查它，也就是说，当程序中可能出现这类异常，要么用try-catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过。

• 不可查的异常（unchecked exceptions）

包括运行时异常（RuntimeException与其子类）和错误（Error）。

运行时异常和非运行时异常：

• RuntimeException

NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。运行时异常的特点是Java编译器不会检查它，也就是说，当程序中可能出现这类异常，即使没有用try-catch语句捕获它，也没有用throws子句声明抛出它，也会编译通过。

• RuntimeException以外的Exception

从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常，一般情况下不自定义检查异常。

返回目录

---

注解

Java SE5内置了三种标准注解：

 @Override，表示当前的方法定义将覆盖超类中的方法。 @Deprecated，使用了注解为它的元素编译器将发出警告，因为注解@Deprecated是不赞成使用的代码，被弃用的代码。 @SuppressWarnings，关闭不当编译器警告信息。

Java还提供了4中注解，专门负责新注解的创建:

• @Target：

表示该注解可以用于什么地方，可能的ElementType参数有：
CONSTRUCTOR：构造器的声明
FIELD：域声明（包括enum实例）
LOCAL_VARIABLE：局部变量声明
METHOD：方法声明
PACKAGE：包声明
PARAMETER：参数声明
TYPE：类、接口（包括注解类型）或enum声明

• @Retention

表示需要在什么级别保存该注解信息。可选的RetentionPolicy参数包括：
SOURCE：注解将被编译器丢弃
CLASS：注解在class文件中可用，但会被VM丢弃
RUNTIME：VM将在运行期间保留注解，因此可以通过反射机制读取注解的信息

• @Document

将注解包含在Javadoc中

• @Inherited

允许子类继承父类中的注解

Example

定义注解：

@Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)public @interface UseCase {    public String id();    public String description() default "no description";}

使用注解：

public class PasswordUtils {     @UseCase(id = 47, description = "Passwords must contain at least one numeric")     public boolean validatePassword(String password) {         return (password.matches("\\w*\\d\\w*"));     }      @UseCase(id = 48)     public String encryptPassword(String password) {         return new StringBuilder(password).reverse().toString();     } }

解析注解：

public static void main(String[] args) {     List<Integer> useCases = new ArrayList<Integer>();     Collections.addAll(useCases, 47, 48, 49, 50);     trackUseCases(useCases, PasswordUtils.class); }  public static void trackUseCases(List<Integer> useCases, Class<?> cl) {     for (Method m : cl.getDeclaredMethods()) {         UseCase uc = m.getAnnotation(UseCase.class);         if (uc != null) {             System.out.println("Found Use Case:" + uc.id() + " "                         + uc.description());             useCases.remove(new Integer(uc.id()));         }     }     for (int i : useCases) {         System.out.println("Warning: Missing use case-" + i);     } } // Found Use Case:47 Passwords must contain at least one numeric // Found Use Case:48 no description // Warning: Missing use case-49 // Warning: Missing use case-50

返回目录

---

安全性

1. 严格遵循面向对象的规范。这样封装了数据细节，只提供接口给用户。增加了数据级的安全性。

2. 无指针运算。java中的操作，除了基本类型都是引用的操作。引用是不能进行增减运算，不能被直接赋予内存地址的，从而增加了内存级的安全性。

3. 数组边界检查。这样就不会出现C/C++中的缓存溢出等安全漏洞。

4. 强制类型转换。非同类型的对象之间不能进行转换，否则会抛出ClassCastException

5. 语言对线程安全的支持。java从语言级支持线程。从而从语法和语言本身做了很多对线程的控制和支持。

6. 垃圾回收。

7. Exception。

返回目录

---

类加载

原理

ClassLoader使用的是双亲委托模型来搜索类的，每个ClassLoader实例都有一个父类加载器的引用（不是继承的关系，是一个包含的关系），虚拟机内置的类加载器（Bootstrap ClassLoader）本身没有父类加载器，但可以用作其它ClassLoader实例的的父类加载器。

当一个ClassLoader实例需要加载某个类时，它会试图亲自搜索某个类之前，先把这个任务委托给它的父类加载器，这个过程是由上至下依次检查的，首先由最顶层的类加载器Bootstrap ClassLoader试图加载，如果没加载到，则把任务转交给Extension ClassLoader试图加载，如果也没加载到，则转交给App ClassLoader 进行加载，如果它也没有加载得到的话，则返回给委托的发起者，由它到指定的文件系统或网络等URL中加载该类。

如果它们都没有加载到这个类时，则抛出ClassNotFoundException异常。否则将这个找到的类生成一个类的定义，并将它加载到内存当中，最后返回这个类在内存中的Class实例对象。

JVM在判定两个class是否相同时，不仅要判断两个类名是否相同，而且要判断是否由同一个类加载器实例加载的。只有两者同时满足的情况下，JVM才认为这两个class是相同的。

加载器

1. BootStrap ClassLoader

启动类加载器，是Java类加载层次中最顶层的类加载器，负责加载JDK中的核心类库，如：rt.jar、resources.jar、charsets.jar等。

   URL[] urls = sun.misc.Launcher.getBootstrapClassPath().getURLs();   for (int i = 0; i < urls.length; i++) {       System.out.println(urls[i].toExternalForm());     }   // 也可以通过sun.boot.class.path获取   System.out.println(System.getProperty("sun.boot.class.path"))

1. Extension ClassLoader

扩展类加载器，负责加载Java的扩展类库，默认加载JAVA_HOME/jre/lib/ext/目下的所有jar。

1. App ClassLoader

系统类加载器，负责加载应用程序classpath目录下的所有jar和class文件

注意：

除了Java默认提供的三个ClassLoader之外，用户还可以根据需要定义自已的ClassLoader，而这些自定义的ClassLoader都必须继承自java.lang.ClassLoader类，也包括Java提供的另外二个ClassLoader（Extension ClassLoader和App ClassLoader）在内。Bootstrap ClassLoader不继承自ClassLoader，因为它不是一个普通的Java类，底层由C++编写，已嵌入到了JVM内核当中，当JVM启动后，Bootstrap ClassLoader也随着启动，负责加载完核心类库后，并构造Extension ClassLoader和App ClassLoader类加载器。

返回目录

---

关键字

strictfp(strict float point)

strictfp 关键字可应用于类、接口或方法。使用strictfp关键字声明一个方法时，该方法中所有的float和double表达式都严格遵守FP-strict的限制,符合IEEE-754规范。当对一个类或接口使用strictfp关键字时，该类中的所有代码，包括嵌套类型中的初始设定值和代码，都将严格地进行计算。严格约束意味着所有表达式的结果都必须是 IEEE 754算法对操作数预期的结果，以单精度和双精度格式表示。

如果你想让你的浮点运算更加精确，而且不会因为不同的硬件平台所执行的结果不一致的话，可以用关键字strictfp。

transiant

变量修饰符，如果用transient声明一个实例变量，当对象存储时，它的值不需要维持。

volatile

作为指令关键字，确保本条指令不会因编译器的优化而省略，修饰变量，保证变量每次都是从内存中重新读取。

final

1. 修饰基础数据成员(as const)

2. 修饰类或对象的引用

3. 修饰方法的final(cannot overwrite)

4. 修饰类或者参数

返回目录

---

初始化

父静态->子静态
父变量->父初始化区->父构造
子变量->子初始化区->子构造

---

多线程

JAVA多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的。

返回目录

---

线程池

concurrent下的线程池：

名称功能ExecutorService真正的线程池接口ScheduledExecutorService能和Timer/TimerTask类似，解决那些需要任务重复执行的问题ThreadPoolExecutorExecutorService的默认实现ScheduledThreadPoolExecutor继承ThreadPoolExecutor的ScheduledExecutorService接口实现，周期性任务调度的类实现

Executors

1. newSingleThreadExecutor

创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

1. newFixedThreadPool

创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

1. newCachedThreadPool

创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，
那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。

1. newScheduledThreadPool

创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。

---

线程安全

线程安全是一个很大的问题，Java 最常见的 HttpServlet 就是单实例多线程，解决这样的问题，有多种方式：

1. ThreadLocal

   ThreadLocal 看下一节的内存图就很好理解，每个线程都有自己的工作内存，ThreadLocal 就是将变量存到线程自己的工作内存中，所以不会有并发问题。

2. Synchronized
   synchronized锁住的是括号里的对象，而不是代码。对于非 static 的 synchronized 方法，锁的就是对象本身也就是 this。该关键字可以加到：

   • 实例方法

   • 静态方法

   • 实例方法中的同步块

   • 静态方法中的同步块

3. ReentrantLock / Condition
   synchronized 不够灵活，例如读写文件，读和读之间不应该互斥，这个时候就可以使用 ReentrantLock 增加并发能力。Condition 是绑定到 Lock 上的，可以用于线程间通信，例如这个面试题，就可以使用 Condition 唤起线程写自己的name 。

   有四个线程1、2、3、4。线程1的功能就是输出1，线程2的功能就是输出2，以此类推.........现在有四个文件ABCD。初始都为空。现要让四个文件呈如下格式：A：1 2 3 4 1 2.... B：2 3 4 1 2 3.... C：3 4 1 2 3 4.... D：4 1 2 3 4 1....

4. 并发容器
   常见的 ConcurrentHashMap CopyOnWriteArrayList 用于多线程下存放数据，Queue BlockingQueue 用于排队消费。

5. Atomic 包
   在 Atomic 包里一共有 12 个类，四种原子更新方式，分别是原子更新基本类型，原子更新数组，原子更新引用和原子更新字段。某些并发问题，需要无锁解决时，就可以考虑使用原子方法。

返回目录

---

内存模型

Java内存模型规定，对于多个线程共享的变量，存储在主内存当中，每个线程都有自己独立的工作内存，线程只能访问自己的工作内存，不可以访问其它线程的 工作内存。工作内存中保存了主内存共享变量的副本，线程要操作这些共享变量，只能通过操作工作内存中的副本来实现，操作完毕之后再同步回到主内存当中。

如何保证多个线程操作主内存的数据完整性是一个难题，Java内存模型也规定了工作内存与主内存之间交互的协议，首先是定义了8种原子操作：

• lock:将主内存中的变量锁定，为一个线程所独占

• unclock:将lock加的锁定解除，此时其它的线程可以有机会访问此变量

• read:将主内存中的变量值读到工作内存当中

• load:将read读取的值保存到工作内存中的变量副本中。

• use:将值传递给线程的代码执行引擎

• assign:将执行引擎处理返回的值重新赋值给变量副本

• store:将变量副本的值存储到主内存中。

• write:将store存储的值写入到主内存的共享变量当中。

内存组成

堆(Heap)

运行时数据区域，所有类实例和数组的内存均从此处分配。Java虚拟机启动时创建。对象的堆内存由称为垃圾回收器 的自动内存管理系统回收。

• News Generation（Young Generation即图中的Eden + From Space + To Space）

  • Eden 存放新生的对象

  • Survivor Space 两个 存放每次垃圾回收后存活的对象

• Old Generation（Tenured Generation 即图中的Old Space） 主要存放应用程序中生命周期长的存活对象

非堆内存

JVM具有一个由所有线程共享的方法区。方法区属于非堆内存。它存储每个类结构，如运行时常数池、字段和方法数据，以及方法和构造方法的代码。它是在Java虚拟机启动时创建的。
除了方法区外，Java虚拟机实现可能需要用于内部处理或优化的内存，这种内存也是非堆内存。例如，JIT编译器需要内存来存储从Java虚拟机代码转换而来的本机代码，从而获得高性能。

• Permanent Generation  （图中的Permanent Space）存放JVM自己的反射对象，比如类对象和方法对象

• native 

1. 如何比较两个字符串？用“=”还是equals

简单来说，“==”是用来检测俩引用是不是指向内存中的同一个对象，而equals()方法则检测的是两个对象的值是否相等。只要你想检测俩字符串是不是相等的，你就必须得用equals()方法。

如果你知道“字符串保留(string intern)”的概念那就更好了。

2. 为什么安全敏感的字符串信息用char[]会比String对象更好？

String对象是不可变的就意味着直到垃圾回收器过来清扫之前它们都不会发生变化的。用数组的话，就可以很明确的修改它任何位置的字符元素。这样的话，如密码等安全敏感的信息就不会出现在系统的任何地方。

3. 字符串对象能否用在switch表达式中？

从JDK7开始的话，我们就可以在switch条件表达式中使用字符串了，也就是说7之前的版本是不可以的。

// java 7 only!switch (str.toLowerCase()) {      case "a":           value = 1;           break;      case "b":           value = 2;           break;}

4. 如何将字符串转换为整型数值？

int n = Integer.parseInt("10");

如此简单，经常使用有偶尔也会被遗忘。

5. 如何用空格去分隔字符串？

我们可以很便捷的使用正则表达式来进行分隔。“\s”就表示空格，还有如””,”\t”,”\r”,”\n”.

String[] strArray = aString.split("\\s+");

6. substring()方法具体是都干了些啥？

在JDK6中，这个方法只会在标识现有字符串的字符数组上 给一个窗口来表示结果字符串，但是不会创建一个新的字符串对象。如果需要创建个新字符串对象，可以这样在结果后面+一个空的字符串：

str.substring(m, n) + ""

这么写的话就会创建一个新的字符数组来表示结果字符串。同时，这么写也有一定的几率让你的代码跑的更快，因为垃圾回收器会吧没有在使用的大字符串回收而留下子字符串。

Oracle JDK7中的substring()方法会创建一个新的字符数组，而不用之前存在的。看看这张图就会明白substring()方法在JDK6和JDK7中的区别。

7. String&StringBuilder&StringBuffer

String vs StringBuilder:StringBuilder是可变的，这就意味你在创建对象之后还可以去修改它的值。StringBuilder vs StringBuffer:StringBuffer是同步的，意味着它是线程安全的，但是就会比StringBuilder慢些。

8. 如何快速重复构造一段字符串？

在Python编程中，只需要用字符串去乘以一个数字就可以 搞定了，那在Java编程中，我们可以使用来自Apache Commons Lang包中的StringUtils类的repeat()方法。

String str = "abcd";String repeated = StringUtils.repeat(str,3);//abcdabcdabcd

9. 如何将时间格式的字符串转换成date对象？

String str = "Sep 17, 2013";Date date = new SimpleDateFormat("MMMM d, yy", Locale.ENGLISH).parse(str);System.out.println(date);//Tue Sep 17 00:00:00 EDT 2013

10. 如何计数一个字符在某个字符串中出现的次数？

使用Apache Commons Lang包中的 StringUtils类就可以完成这个工作。

int n = StringUtils.countMatches("11112222", "1");System.out.printl```  n(n);

为什么String类是不可变的？

1. 只有当字符串是不可变的，字符串池才有可能实现。字符串池的实现可以在运行时节约很多heap空间，因为不同的字符串变量都指向池中的同一个字符串。但如果字符串是可变的，那么String interning将不能实现(译者注：String interning是指对不同的字符串仅仅只保存一个，即不会保存多个相同的字符串。)，因为这样的话，如果变量改变了它的值，那么其它指向这个值的变量的值也会一起改变。
2. 如果字符串是可变的，那么会引起很严重的安全问题。譬如，数据库的用户名、密码都是以字符串的形式传入来获得数据库的连接，或者在socket编程中，主机名和端口都是以字符串的形式传入。因为字符串是不可变的，所以它的值是不可改变的，否则黑客们可以钻到空子，改变字符串指向的对象的值，造成安全漏洞。
3. 因为字符串是不可变的，所以是多线程安全的，同一个字符串实例可以被多个线程共享。这样便不用因为线程安全问题而使用同步。字符串自己便是线程安全的。
4. 类加载器要用到字符串，不可变性提供了安全性，以便正确的类被加载。譬如你想加载java.sql.Connection类，而这个值被改成了myhacked.Connection，那么会对你的数据库造成不可知的破坏。
5. 因为字符串是不可变的，所以在它创建的时候hashcode就被缓存了，不需要重新计算。这就使得字符串很适合作为Map中的键，字符串的处理速度要快过其它的键对象。这就是HashMap中的键往往都使用字符串。

序列化是一种对象持久化的手段。普遍应用在网络传输、RMI等场景中。本文通过分析ArrayList的序列化来介绍Java序列化的相关内容。主要涉及到以下几个问题：

• 怎么实现Java的序列化
• 为什么实现了java.io.Serializable接口才能被序列化
• transient的作用是什么
• 怎么自定义序列化策略
• 自定义的序列化策略是如何被调用的
• ArrayList对序列化的实现有什么好处

Java对象的序列化

Java平台允许我们在内存中创建可复用的Java对象，但一般情况下，只有当JVM处于运行时，这些对象才可能存在，即，这些对象的生命周期不会比JVM的生命周期更长。但在现实应用中，就可能要求在JVM停止运行之后能够保存(持久化)指定的对象，并在将来重新读取被保存的对象。Java对象序列化就能够帮助我们实现该功能。

使用Java对象序列化，在保存对象时，会把其状态保存为一组字节，在未来，再将这些字节组装成对象。必须注意地是，对象序列化保存的是对象的”状态”，即它的成员变量。由此可知， 对象序列化不会关注类中的静态变量 。

除了在持久化对象时会用到对象序列化之外，当使用RMI(远程方法调用)，或在网络中传递对象时，都会用到对象序列化。Java序列化API为处理对象序列化提供了一个标准机制，该API简单易用，在本文的后续章节中将会陆续讲到。

public class ArrayList<E> extends AbstractList<E>        implements List<E>, RandomAccess, Cloneable, java.io.Serializable{    private static final long serialVersionUID = 8683452581122892189L;    transient Object[] elementData; // non-private to simplify nested class access    private int size;}

如何对Java对象进行序列化与反序列化

在Java中，只要一个类实现了 java.io.Serializable 接口，那么它就可以被序列化。这里先来一段代码：

code 1 创建一个User类，用于序列化及反序列化

package com.hollis;import java.io.Serializable;import java.util.Date;/** * Created by hollis on 16/2/2. */public class User implements Serializable{    private String name;    private int age;    private Date birthday;    private transient String gender;    private static final long serialVersionUID = -6849794470754667710L;    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }    public Date getBirthday() {        return birthday;    }    public void setBirthday(Date birthday) {        this.birthday = birthday;    }    public String getGender() {        return gender;    }    public void setGender(String gender) {        this.gender = gender;    }    @Override    public String toString() {        return "User{" +                "name='" + name + '/'' +                ", age=" + age +                ", gender=" + gender +                ", birthday=" + birthday +                '}';    }}

code 2 对User进行序列化及反序列化的Demo

package com.hollis;import org.apache.commons.io.FileUtils;import org.apache.commons.io.IOUtils;import java.io.*;import java.util.Date;/** * Created by hollis on 16/2/2. */public class SerializableDemo {    public static void main(String[] args) {        //Initializes The Object        User user = new User();        user.setName("hollis");        user.setGender("male");        user.setAge(23);        user.setBirthday(new Date());        System.out.println(user);        //Write Obj to File        ObjectOutputStream oos = null;        try {            oos = new ObjectOutputStream(new FileOutputStream("tempFile"));            oos.writeObject(user);        } catch (IOException e) {            e.printStackTrace();        } finally {            IOUtils.closeQuietly(oos);        }        //Read Obj from File        File file = new File("tempFile");        ObjectInputStream ois = null;        try {            ois = new ObjectInputStream(new FileInputStream(file));            User newUser = (User) ois.readObject();            System.out.println(newUser);        } catch (IOException e) {            e.printStackTrace();        } catch (ClassNotFoundException e) {            e.printStackTrace();        } finally {            IOUtils.closeQuietly(ois);            try {                FileUtils.forceDelete(file);            } catch (IOException e) {                e.printStackTrace();            }        }    }}//output //User{name='hollis', age=23, gender=male, birthday=Tue Feb 02 17:37:38 CST 2016}//User{name='hollis', age=23, gender=null, birthday=Tue Feb 02 17:37:38 CST 2016}

序列化及反序列化相关知识

1、在Java中，只要一个类实现了 java.io.Serializable 接口，那么它就可以被序列化。

2、通过 ObjectOutputStream 和 ObjectInputStream 对对象进行序列化及反序列化

3、虚拟机是否允许反序列化，不仅取决于类路径和功能代码是否一致，一个非常重要的一点是两个类的序列化 ID 是否一致（就是 private static final long serialVersionUID ）

4、序列化并不保存静态变量。

5、要想将父类对象也序列化，就需要让父类也实现 Serializable 接口。

6、Transient 关键字的作用是控制变量的序列化，在变量声明前加上该关键字，可以阻止该变量被序列化到文件中，在被反序列化后，transient 变量的值被设为初始值，如 int 型的是 0，对象型的是 null。

7、服务器端给客户端发送序列化对象数据，对象中有一些数据是敏感的，比如密码字符串等，希望对该密码字段在序列化时，进行加密，而客户端如果拥有解密的密钥，只有在客户端进行反序列化时，才可以对密码进行读取，这样可以一定程度保证序列化对象的数据安全。

ArrayList的序列化

在介绍ArrayList序列化之前，先来考虑一个问题：

如何自定义的序列化和反序列化策略

带着这个问题，我们来看 java.util.ArrayList 的源码

code 3

public class ArrayList<E> extends AbstractList<E>        implements List<E>, RandomAccess, Cloneable, java.io.Serializable{    private static final long serialVersionUID = 8683452581122892189L;    transient Object[] elementData; // non-private to simplify nested class access    private int size;}

笔者省略了其他成员变量，从上面的代码中可以知道ArrayList实现了 java.io.Serializable 接口，那么我们就可以对它进行序列化及反序列化。因为elementData是 transient 的，所以我们认为这个成员变量不会被序列化而保留下来。我们写一个Demo，验证一下我们的想法：

code 4

public static void main(String[] args) throws IOException, ClassNotFoundException {        List<String> stringList = new ArrayList<String>();        stringList.add("hello");        stringList.add("world");        stringList.add("hollis");        stringList.add("chuang");        System.out.println("init StringList" + stringList);        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("stringlist"));        objectOutputStream.writeObject(stringList);        IOUtils.close(objectOutputStream);        File file = new File("stringlist");        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(file));        List<String> newStringList = (List<String>)objectInputStream.readObject();        IOUtils.close(objectInputStream);        if(file.exists()){            file.delete();        }        System.out.println("new StringList" + newStringList);    }//init StringList[hello, world, hollis, chuang]//new StringList[hello, world, hollis, chuang]

了解ArrayList的人都知道，ArrayList底层是通过数组实现的。那么数组 elementData 其实就是用来保存列表中的元素的。通过该属性的声明方式我们知道，他是无法通过序列化持久化下来的。那么为什么code 4的结果却通过序列化和反序列化把List中的元素保留下来了呢？

writeObject和readObject方法

在ArrayList中定义了来个方法： writeObject 和 readObject 。

这里先给出结论:

在序列化过程中，如果被序列化的类中定义了writeObject 和 readObject 方法，虚拟机会试图调用对象类里的 writeObject 和 readObject 方法，进行用户自定义的序列化和反序列化。

如果没有这样的方法，则默认调用是 ObjectOutputStream 的 defaultWriteObject 方法以及 ObjectInputStream 的 defaultReadObject 方法。

用户自定义的 writeObject 和 readObject 方法可以允许用户控制序列化的过程，比如可以在序列化的过程中动态改变序列化的数值。

来看一下这两个方法的具体实现：

code 5

private void readObject(java.io.ObjectInputStream s)        throws java.io.IOException, ClassNotFoundException {        elementData = EMPTY_ELEMENTDATA;        // Read in size, and any hidden stuff        s.defaultReadObject();        // Read in capacity        s.readInt(); // ignored        if (size > 0) {            // be like clone(), allocate array based upon size not capacity            ensureCapacityInternal(size);            Object[] a = elementData;            // Read in all elements in the proper order.            for (int i=0; i<size; i++) {                a[i] = s.readObject();            }        }    }

code 6

private void writeObject(java.io.ObjectOutputStream s)        throws java.io.IOException{        // Write out element count, and any hidden stuff        int expectedModCount = modCount;        s.defaultWriteObject();        // Write out size as capacity for behavioural compatibility with clone()        s.writeInt(size);        // Write out all elements in the proper order.        for (int i=0; i<size; i++) {            s.writeObject(elementData[i]);        }        if (modCount != expectedModCount) {            throw new ConcurrentModificationException();        }    }

那么为什么ArrayList要用这种方式来实现序列化呢？

why transient

ArrayList实际上是动态数组，每次在放满以后自动增长设定的长度值，如果数组自动增长长度设为100，而实际只放了一个元素，那就会序列化99个null元素。为了保证在序列化的时候不会将这么多null同时进行序列化，ArrayList把元素数组设置为transient。

why writeObject and readObject

前面说过，为了防止一个包含大量空对象的数组被序列化，为了优化存储，所以，ArrayList使用 transient 来声明 elementData 。

但是，作为一个集合，在序列化过程中还必须保证其中的元素可以被持久化下来，所以，通过重写 writeObject 和 readObject 方法的方式把其中的元素保留下来。

writeObject 方法把 elementData 数组中的元素遍历的保存到输出流（ObjectOutputStream）中。

readObject 方法从输入流（ObjectInputStream）中读出对象并保存赋值到 elementData 数组中。

至此，我们先试着来回答刚刚提出的问题：

如何自定义的序列化和反序列化策略

答：可以通过在被序列化的类中增加writeObject 和 readObject方法。那么问题又来了：

虽然ArrayList中写了writeObject 和 readObject 方法，但是这两个方法并没有显示的被调用啊。

那么如果一个类中包含writeObject 和 readObject 方法，那么这两个方法是怎么被调用的呢?

ObjectOutputStream

从code 4中，我们可以看出，对象的序列化过程通过ObjectOutputStream和ObjectInputputStream来实现的，那么带着刚刚的问题，我们来分析一下ArrayList中的writeObject 和 readObject 方法到底是如何被调用的呢？

为了节省篇幅，这里给出ObjectOutputStream的writeObject的调用栈：

writeObject —> writeObject0 —>writeOrdinaryObject—>writeSerialData—>invokeWriteObject

这里看一下invokeWriteObject：

void invokeWriteObject(Object obj, ObjectOutputStream out)        throws IOException, UnsupportedOperationException    {        if (writeObjectMethod != null) {            try {                writeObjectMethod.invoke(obj, new Object[]{ out });            } catch (InvocationTargetException ex) {                Throwable th = ex.getTargetException();                if (th instanceof IOException) {                    throw (IOException) th;                } else {                    throwMiscException(th);                }            } catch (IllegalAccessException ex) {                // should not occur, as access checks have been suppressed                throw new InternalError(ex);            }        } else {            throw new UnsupportedOperationException();        }    }

其中 writeObjectMethod.invoke(obj, new Object[]{ out }); 是关键，通过反射的方式调用writeObjectMethod方法。官方是这么解释这个writeObjectMethod的：

class-defined writeObject method, or null if none

在我们的例子中，这个方法就是我们在ArrayList中定义的writeObject方法。通过反射的方式被调用了。

至此，我们先试着来回答刚刚提出的问题：

如果一个类中包含writeObject 和 readObject 方法，那么这两个方法是怎么被调用的?

答：在使用ObjectOutputStream的writeObject方法和ObjectInputStream的readObject方法时，会通过反射的方式调用。

至此，我们已经介绍完了ArrayList的序列化方式。那么，不知道有没有人提出这样的疑问：

Serializable明明就是一个空的接口，它是怎么保证只有实现了该接口的方法才能进行序列化与反序列化的呢？

Serializable接口的定义：

public interface Serializable {}

读者可以尝试把code 1中的继承Serializable的代码去掉，再执行code 2，会抛出 java.io.NotSerializableException 。

其实这个问题也很好回答，我们再回到刚刚ObjectOutputStream的writeObject的调用栈：

writeObject —> writeObject0 —>writeOrdinaryObject—>writeSerialData—>invokeWriteObject

writeObject0方法中有这么一段代码：

if (obj instanceof String) {                writeString((String) obj, unshared);            } else if (cl.isArray()) {                writeArray(obj, desc, unshared);            } else if (obj instanceof Enum) {                writeEnum((Enum<?>) obj, desc, unshared);            } else if (obj instanceof Serializable) {                writeOrdinaryObject(obj, desc, unshared);            } else {                if (extendedDebugInfo) {                    throw new NotSerializableException(                        cl.getName() + "/n" + debugInfoStack.toString());                } else {                    throw new NotSerializableException(cl.getName());                }            }

在进行序列化操作时，会判断要被序列化的类是否是Enum、Array和Serializable类型，如果不是则直接抛出 NotSerializableException 。

总结

1、如果一个类想被序列化，需要实现Serializable接口。否则将抛出 NotSerializableException 异常，这是因为，在序列化操作过程中会对类型进行检查，要求被序列化的类必须属于Enum、Array和Serializable类型其中的任何一种。

2、在变量声明前加上该关键字，可以阻止该变量被序列化到文件中。

3、在类中增加writeObject 和 readObject 方法可以实现自定义序列化策略

这是一个挺有意思的讨论话题。

如果你运行下面的代码

Integer a = 1000, b = 1000;      System.out.println(a == b);//1    Integer c = 100, d = 100;      System.out.println(c == d);//2

你会得到

falsetrue

基本知识：我们知道，如果两个引用指向同一个对象，用==表示它们是相等的。如果两个引用指向不同的对象，用==表示它们是不相等的，即使它们的内容相同。

因此，后面一条语句也应该是false 。

这就是它有趣的地方了。如果你看去看 Integer.java 类，你会发现有一个内部私有类，IntegerCache.java，它缓存了从-128到127之间的所有的整数对象。

所以事情就成了，所有的小整数在内部缓存，然后当我们声明类似——

Integer c = 100;

的时候，它实际上在内部做的是

Integer i = Integer.valueOf(100);

现在，如果我们去看valueOf()方法，我们可以看到

public static Integer valueOf(int i) {      if (i >= IntegerCache.low && i          return IntegerCache.cache[i + (-IntegerCache.low)];      return new Integer(i);    }

如果值的范围在-128到127之间，它就从高速缓存返回实例。

所以…

Integer c = 100, d = 100;

指向了同一个对象。

这就是为什么我们写

System.out.println(c == d);

我们可以得到true。

现在你可能会问，为什么这里需要缓存？

合乎逻辑的理由是，在此范围内的“小”整数使用率比大整数要高，因此，使用相同的底层对象是有价值的，可以减少潜在的内存占用。

然而，通过反射API你会误用此功能。

运行下面的代码，享受它的魅力吧

public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {      Class cache = Integer.class.getDeclaredClasses()[0]; //1      Field myCache = cache.getDeclaredField("cache"); //2      myCache.setAccessible(true);//3      Integer[] newCache = (Integer[]) myCache.get(cache); //4      newCache[132] = newCache[133]; //5      int a = 2;      int b = a + a;      System.out.printf("%d + %d = %d", a, a, b); //    }

遍历Map的方式有很多，通常场景下我们需要的是遍历Map中的Key和Value，那么推荐使用的、效率最高的方式是：
public static void main(String[] args){HashMap<String, String> hm = new HashMap<String, String>();hm.put("111", "222");Set<Map.Entry<String, String>> entrySet = hm.entrySet();Iterator<Map.Entry<String, String>> iter = entrySet.iterator(); while (iter.hasNext()){Map.Entry<String, String> entry = iter.next();System.out.println(entry.getKey() + "\t" + entry.getValue());}}
1.Java集合框架是什么？说出一些集合框架的优点？
每种编程语言中都有集合，最初的Java版本包含几种集合类：Vector、Stack、HashTable和Array。随着集合的广泛使用，Java1.2提出了囊括所有集合接口、实现和算法的集合框架。在保证线程安全的情况下使用泛型和并发集合类，Java已经经历了很久。它还包括在Java并发包中，阻塞接口以及它们的实现。集合框架的部分优点如下：
（1）使用核心集合类降低开发成本，而非实现我们自己的集合类。
（2）随着使用经过严格测试的集合框架类，代码质量会得到提高。
（3）通过使用JDK附带的集合类，可以降低代码维护成本。
（4）复用性和可操作性。
2.集合框架中的泛型有什么优点？
Java1.5引入了泛型，所有的集合接口和实现都大量地使用它。泛型允许我们为集合提供一个可以容纳的对象类型，因此，如果你添加其它类型的任何元素，它会在编译时报错。这避免了在运行时出现ClassCastException，因为你将会在编译时得到报错信息。泛型也使得代码整洁，我们不需要使用显式转换和instanceOf操作符。它也给运行时带来好处，因为不会产生类型检查的字节码指令。
3.Java集合框架的基础接口有哪些？
Collection为集合层级的根接口。一个集合代表一组对象，这些对象即为它的元素。Java平台不提供这个接口任何直接的实现。
Set是一个不能包含重复元素的集合。这个接口对数学集合抽象进行建模，被用来代表集合，就如一副牌。
List是一个有序集合，可以包含重复元素。你可以通过它的索引来访问任何元素。List更像长度动态变换的数组。
Map是一个将key映射到value的对象.一个Map不能包含重复的key：每个key最多只能映射一个value。
一些其它的接口有Queue、Dequeue、SortedSet、SortedMap和ListIterator。
4.为何Collection不从Cloneable和Serializable接口继承？
Collection接口指定一组对象，对象即为它的元素。如何维护这些元素由Collection的具体实现决定。例如，一些如List的Collection实现允许重复的元素，而其它的如Set就不允许。很多Collection实现有一个公有的clone方法。然而，把它放到集合的所有实现中也是没有意义的。这是因为Collection是一个抽象表现。重要的是实现。
当与具体实现打交道的时候，克隆或序列化的语义和含义才发挥作用。所以，具体实现应该决定如何对它进行克隆或序列化，或它是否可以被克隆或序列化。
在所有的实现中授权克隆和序列化，最终导致更少的灵活性和更多的限制。特定的实现应该决定它是否可以被克隆和序列化。
5.为何Map接口不继承Collection接口？
尽管Map接口和它的实现也是集合框架的一部分，但Map不是集合，集合也不是Map。因此，Map继承Collection毫无意义，反之亦然。
如果Map继承Collection接口，那么元素去哪儿？Map包含key-value对，它提供抽取key或value列表集合的方法，但是它不适合“一组对象”规范。
6.Iterator是什么？
Iterator接口提供遍历任何Collection的接口。我们可以从一个Collection中使用迭代器方法来获取迭代器实例。迭代器取代了Java集合框架中的Enumeration。迭代器允许调用者在迭代过程中移除元素。
7.Enumeration和Iterator接口的区别？
Enumeration的速度是Iterator的两倍，也使用更少的内存。Enumeration是非常基础的，也满足了基础的需要。但是，与Enumeration相比，Iterator更加安全，因为当一个集合正在被遍历的时候，它会阻止其它线程去修改集合。
迭代器取代了Java集合框架中的Enumeration。迭代器允许调用者从集合中移除元素，而Enumeration不能做到。为了使它的功能更加清晰，迭代器方法名已经经过改善。
8.为何没有像Iterator.add()这样的方法，向集合中添加元素？
语义不明，已知的是，Iterator的协议不能确保迭代的次序。然而要注意，ListIterator没有提供一个add操作，它要确保迭代的顺序。
9.为何迭代器没有一个方法可以直接获取下一个元素，而不需要移动游标？
它可以在当前Iterator的顶层实现，但是它用得很少，如果将它加到接口中，每个继承都要去实现它，这没有意义。
10.Iterater和ListIterator之间有什么区别？
（1）我们可以使用Iterator来遍历Set和List集合，而ListIterator只能遍历List。
（2）Iterator只可以向前遍历，而LIstIterator可以双向遍历。
（3）ListIterator从Iterator接口继承，然后添加了一些额外的功能，比如添加一个元素、替换一个元素、获取前面或后面元素的索引位置。
11.遍历一个List有哪些不同的方式？
List<String> strList = new ArrayList<>();//使用for-each循环for(String obj : strList){  System.out.println(obj);}//using iteratorIterator<String> it = strList.iterator();while(it.hasNext()){  String obj = it.next();  System.out.println(obj);}
使用迭代器更加线程安全，因为它可以确保，在当前遍历的集合元素被更改的时候，它会抛出ConcurrentModificationException。
12.通过迭代器fail-fast属性，你明白了什么？
每次我们尝试获取下一个元素的时候，Iterator fail-fast属性检查当前集合结构里的任何改动。如果发现任何改动，它抛出ConcurrentModificationException。Collection中所有Iterator的实现都是按fail-fast来设计的（ConcurrentHashMap和CopyOnWriteArrayList这类并发集合类除外）。
13.fail-fast与fail-safe有什么区别？
Iterator的fail-fast属性与当前的集合共同起作用，因此它不会受到集合中任何改动的影响。Java.util包中的所有集合类都被设计为fail-fast的，而java.util.concurrent中的集合类都为fail-safe的。Fail-fast迭代器抛出ConcurrentModificationException，而fail-safe迭代器从不抛出ConcurrentModificationException。
14.在迭代一个集合的时候，如何避免ConcurrentModificationException？
在遍历一个集合的时候，我们可以使用并发集合类来避免ConcurrentModificationException，比如使用CopyOnWriteArrayList，而不是ArrayList。
15.为何Iterator接口没有具体的实现？
Iterator接口定义了遍历集合的方法，但它的实现则是集合实现类的责任。每个能够返回用于遍历的Iterator的集合类都有它自己的Iterator实现内部类。
这就允许集合类去选择迭代器是fail-fast还是fail-safe的。比如，ArrayList迭代器是fail-fast的，而CopyOnWriteArrayList迭代器是fail-safe的。
16.UnsupportedOperationException是什么？
UnsupportedOperationException是用于表明操作不支持的异常。在JDK类中已被大量运用，在集合框架java.util.Collections.UnmodifiableCollection将会在所有add和remove操作中抛出这个异常。
17.在Java中，HashMap是如何工作的？
HashMap在Map.Entry静态内部类实现中存储key-value对。HashMap使用哈希算法，在put和get方法中，它使用hashCode()和equals()方法。当我们通过传递key-value对调用put方法的时候，HashMap使用Key hashCode()和哈希算法来找出存储key-value对的索引。Entry存储在LinkedList中，所以如果存在entry，它使用equals()方法来检查传递的key是否已经存在，如果存在，它会覆盖value，如果不存在，它会创建一个新的entry然后保存。当我们通过传递key调用get方法时，它再次使用hashCode()来找到数组中的索引，然后使用equals()方法找出正确的Entry，然后返回它的值。下面的图片解释了详细内容。
其它关于HashMap比较重要的问题是容量、负荷系数和阀值调整。HashMap默认的初始容量是32，负荷系数是0.75。阀值是为负荷系数乘以容量，无论何时我们尝试添加一个entry，如果map的大小比阀值大的时候，HashMap会对map的内容进行重新哈希，且使用更大的容量。容量总是2的幂，所以如果你知道你需要存储大量的key-value对，比如缓存从数据库里面拉取的数据，使用正确的容量和负荷系数对HashMap进行初始化是个不错的做法。
18.hashCode()和equals()方法有何重要性？
HashMap使用Key对象的hashCode()和equals()方法去决定key-value对的索引。当我们试着从HashMap中获取值的时候，这些方法也会被用到。如果这些方法没有被正确地实现，在这种情况下，两个不同Key也许会产生相同的hashCode()和equals()输出，HashMap将会认为它们是相同的，然后覆盖它们，而非把它们存储到不同的地方。同样的，所有不允许存储重复数据的集合类都使用hashCode()和equals()去查找重复，所以正确实现它们非常重要。equals()和hashCode()的实现应该遵循以下规则：
（1）如果o1.equals(o2)，那么o1.hashCode() == o2.hashCode()总是为true的。
（2）如果o1.hashCode() == o2.hashCode()，并不意味着o1.equals(o2)会为true。
19.我们能否使用任何类作为Map的key？
我们可以使用任何类作为Map的key，然而在使用它们之前，需要考虑以下几点：
（1）如果类重写了equals()方法，它也应该重写hashCode()方法。
（2）类的所有实例需要遵循与equals()和hashCode()相关的规则。请参考之前提到的这些规则。
（3）如果一个类没有使用equals()，你不应该在hashCode()中使用它。
（4）用户自定义key类的最佳实践是使之为不可变的，这样，hashCode()值可以被缓存起来，拥有更好的性能。不可变的类也可以确保hashCode()和equals()在未来不会改变，这样就会解决与可变相关的问题了。
比如，我有一个类MyKey，在HashMap中使用它。
//传递给MyKey的name参数被用于equals()和hashCode()中MyKey key = new MyKey('Pankaj'); //assume hashCode=1234myHashMap.put(key, 'Value');// 以下的代码会改变key的hashCode()和equals()值key.setName('Amit'); //assume new hashCode=7890//下面会返回null，因为HashMap会尝试查找存储同样索引的key，而key已被改变了，匹配失败，返回nullmyHashMap.get(new MyKey('Pankaj'));
那就是为何String和Integer被作为HashMap的key大量使用。
20.Map接口提供了哪些不同的集合视图？
Map接口提供三个集合视图：
（1）Set keyset()：返回map中包含的所有key的一个Set视图。集合是受map支持的，map的变化会在集合中反映出来，反之亦然。当一个迭代器正在遍历一个集合时，若map被修改了（除迭代器自身的移除操作以外），迭代器的结果会变为未定义。集合支持通过Iterator的Remove、Set.remove、removeAll、retainAll和clear操作进行元素移除，从map中移除对应的映射。它不支持add和addAll操作。
（2）Collection values()：返回一个map中包含的所有value的一个Collection视图。这个collection受map支持的，map的变化会在collection中反映出来，反之亦然。当一个迭代器正在遍历一个collection时，若map被修改了（除迭代器自身的移除操作以外），迭代器的结果会变为未定义。集合支持通过Iterator的Remove、Set.remove、removeAll、retainAll和clear操作进行元素移除，从map中移除对应的映射。它不支持add和addAll操作。
（3）Set<Map.Entry<K,V>> entrySet()：返回一个map钟包含的所有映射的一个集合视图。这个集合受map支持的，map的变化会在collection中反映出来，反之亦然。当一个迭代器正在遍历一个集合时，若map被修改了（除迭代器自身的移除操作，以及对迭代器返回的entry进行setValue外），迭代器的结果会变为未定义。集合支持通过Iterator的Remove、Set.remove、removeAll、retainAll和clear操作进行元素移除，从map中移除对应的映射。它不支持add和addAll操作。
21.HashMap和HashTable有何不同？
（1）HashMap允许key和value为null，而HashTable不允许。
（2）HashTable是同步的，而HashMap不是。所以HashMap适合单线程环境，HashTable适合多线程环境。
（3）在Java1.4中引入了LinkedHashMap，HashMap的一个子类，假如你想要遍历顺序，你很容易从HashMap转向LinkedHashMap，但是HashTable不是这样的，它的顺序是不可预知的。
（4）HashMap提供对key的Set进行遍历，因此它是fail-fast的，但HashTable提供对key的Enumeration进行遍历，它不支持fail-fast。
（5）HashTable被认为是个遗留的类，如果你寻求在迭代的时候修改Map，你应该使用CocurrentHashMap。
22.如何决定选用HashMap还是TreeMap？
对于在Map中插入、删除和定位元素这类操作，HashMap是最好的选择。然而，假如你需要对一个有序的key集合进行遍历，TreeMap是更好的选择。基于你的collection的大小，也许向HashMap中添加元素会更快，将map换为TreeMap进行有序key的遍历。
23.ArrayList和Vector有何异同点？
ArrayList和Vector在很多时候都很类似。
（1）两者都是基于索引的，内部由一个数组支持。
（2）两者维护插入的顺序，我们可以根据插入顺序来获取元素。
（3）ArrayList和Vector的迭代器实现都是fail-fast的。
（4）ArrayList和Vector两者允许null值，也可以使用索引值对元素进行随机访问。
以下是ArrayList和Vector的不同点。
（1）Vector是同步的，而ArrayList不是。然而，如果你寻求在迭代的时候对列表进行改变，你应该使用CopyOnWriteArrayList。
（2）ArrayList比Vector快，它因为有同步，不会过载。
（3）ArrayList更加通用，因为我们可以使用Collections工具类轻易地获取同步列表和只读列表。
24.Array和ArrayList有何区别？什么时候更适合用Array？
Array可以容纳基本类型和对象，而ArrayList只能容纳对象。
Array是指定大小的，而ArrayList大小是固定的。
Array没有提供ArrayList那么多功能，比如addAll、removeAll和iterator等。尽管ArrayList明显是更好的选择，但也有些时候Array比较好用。
（1）如果列表的大小已经指定，大部分情况下是存储和遍历它们。
（2）对于遍历基本数据类型，尽管Collections使用自动装箱来减轻编码任务，在指定大小的基本类型的列表上工作也会变得很慢。
（3）如果你要使用多维数组，使用[][]比List<List<>>更容易。
25.ArrayList和LinkedList有何区别？
ArrayList和LinkedList两者都实现了List接口，但是它们之间有些不同。
（1）ArrayList是由Array所支持的基于一个索引的数据结构，所以它提供对元素的随机访问，复杂度为O(1)，但LinkedList存储一系列的节点数据，每个节点都与前一个和下一个节点相连接。所以，尽管有使用索引获取元素的方法，内部实现是从起始点开始遍历，遍历到索引的节点然后返回元素，时间复杂度为O(n)，比ArrayList要慢。
（2）与ArrayList相比，在LinkedList中插入、添加和删除一个元素会更快，因为在一个元素被插入到中间的时候，不会涉及改变数组的大小，或更新索引。
（3）LinkedList比ArrayList消耗更多的内存，因为LinkedList中的每个节点存储了前后节点的引用。
26.哪些集合类提供对元素的随机访问？
ArrayList、HashMap、TreeMap和HashTable类提供对元素的随机访问。
27.EnumSet是什么？
java.util.EnumSet是使用枚举类型的集合实现。当集合创建时，枚举集合中的所有元素必须来自单个指定的枚举类型，可以是显示的或隐示的。EnumSet是不同步的，不允许值为null的元素。它也提供了一些有用的方法，比如copyOf(Collection c)、of(E first,E…rest)和complementOf(EnumSet s)。
28.哪些集合类是线程安全的？
Vector、HashTable、Properties和Stack是同步类，所以它们是线程安全的，可以在多线程环境下使用。Java1.5并发API包括一些集合类，允许迭代时修改，因为它们都工作在集合的克隆上，所以它们在多线程环境中是安全的。
29.并发集合类是什么？
Java1.5并发包（java.util.concurrent）包含线程安全集合类，允许在迭代时修改集合。迭代器被设计为fail-fast的，会抛出ConcurrentModificationException。一部分类为：CopyOnWriteArrayList、 ConcurrentHashMap、CopyOnWriteArraySet。
30.BlockingQueue是什么？
Java.util.concurrent.BlockingQueue是一个队列，在进行检索或移除一个元素的时候，它会等待队列变为非空；当在添加一个元素时，它会等待队列中的可用空间。BlockingQueue接口是Java集合框架的一部分，主要用于实现生产者-消费者模式。我们不需要担心等待生产者有可用的空间，或消费者有可用的对象，因为它都在BlockingQueue的实现类中被处理了。Java提供了集中BlockingQueue的实现，比如ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue,、SynchronousQueue等。
31.队列和栈是什么，列出它们的区别？
栈和队列两者都被用来预存储数据。java.util.Queue是一个接口，它的实现类在Java并发包中。队列允许先进先出（FIFO）检索元素，但并非总是这样。Deque接口允许从两端检索元素。
栈与队列很相似，但它允许对元素进行后进先出（LIFO）进行检索。
Stack是一个扩展自Vector的类，而Queue是一个接口。
32.Collections类是什么？
Java.util.Collections是一个工具类仅包含静态方法，它们操作或返回集合。它包含操作集合的多态算法，返回一个由指定集合支持的新集合和其它一些内容。这个类包含集合框架算法的方法，比如折半搜索、排序、混编和逆序等。
33.Comparable和Comparator接口是什么？
如果我们想使用Array或Collection的排序方法时，需要在自定义类里实现Java提供Comparable接口。Comparable接口有compareTo(T OBJ)方法，它被排序方法所使用。我们应该重写这个方法，如果“this”对象比传递的对象参数更小、相等或更大时，它返回一个负整数、0或正整数。但是，在大多数实际情况下，我们想根据不同参数进行排序。比如，作为一个CEO，我想对雇员基于薪资进行排序，一个HR想基于年龄对他们进行排序。这就是我们需要使用Comparator接口的情景，因为Comparable.compareTo(Object o)方法实现只能基于一个字段进行排序，我们不能根据对象排序的需要选择字段。Comparator接口的compare(Object o1, Object o2)方法的实现需要传递两个对象参数，若第一个参数比第二个小，返回负整数；若第一个等于第二个，返回0；若第一个比第二个大，返回正整数。
34.Comparable和Comparator接口有何区别？
Comparable和Comparator接口被用来对对象集合或者数组进行排序。Comparable接口被用来提供对象的自然排序，我们可以使用它来提供基于单个逻辑的排序。
Comparator接口被用来提供不同的排序算法，我们可以选择需要使用的Comparator来对给定的对象集合进行排序。
35.我们如何对一组对象进行排序？
如果我们需要对一个对象数组进行排序，我们可以使用Arrays.sort()方法。如果我们需要排序一个对象列表，我们可以使用Collection.sort()方法。两个类都有用于自然排序（使用Comparable）或基于标准的排序（使用Comparator）的重载方法sort()。Collections内部使用数组排序方法，所有它们两者都有相同的性能，只是Collections需要花时间将列表转换为数组。
36.当一个集合被作为参数传递给一个函数时，如何才可以确保函数不能修改它？
在作为参数传递之前，我们可以使用Collections.unmodifiableCollection(Collection c)方法创建一个只读集合，这将确保改变集合的任何操作都会抛出UnsupportedOperationException。
37.我们如何从给定集合那里创建一个synchronized的集合？
我们可以使用Collections.synchronizedCollection(Collection c)根据指定集合来获取一个synchronized（线程安全的）集合。
38.集合框架里实现的通用算法有哪些？
Java集合框架提供常用的算法实现，比如排序和搜索。Collections类包含这些方法实现。大部分算法是操作List的，但一部分对所有类型的集合都是可用的。部分算法有排序、搜索、混编、最大最小值。
39.大写的O是什么？举几个例子？
大写的O描述的是，就数据结构中的一系列元素而言，一个算法的性能。Collection类就是实际的数据结构，我们通常基于时间、内存和性能，使用大写的O来选择集合实现。比如：例子1：ArrayList的get(index i)是一个常量时间操作，它不依赖list中元素的数量。所以它的性能是O(1)。例子2：一个对于数组或列表的线性搜索的性能是O(n)，因为我们需要遍历所有的元素来查找需要的元素。
40.与Java集合框架相关的有哪些最好的实践？
（1）根据需要选择正确的集合类型。比如，如果指定了大小，我们会选用Array而非ArrayList。如果我们想根据插入顺序遍历一个Map，我们需要使用TreeMap。如果我们不想重复，我们应该使用Set。
（2）一些集合类允许指定初始容量，所以如果我们能够估计到存储元素的数量，我们可以使用它，就避免了重新哈希或大小调整。
（3）基于接口编程，而非基于实现编程，它允许我们后来轻易地改变实现。
（4）总是使用类型安全的泛型，避免在运行时出现ClassCastException。
（5）使用JDK提供的不可变类作为Map的key，可以避免自己实现hashCode()和equals()。
（6）尽可能使用Collections工具类，或者获取只读、同步或空的集合，而非编写自己的实现。它将会提供代码重用性，它有着更好的稳定性和可维护性。

下面是20个非常有用的Java程序片段，希望能对你有用。
1. 字符串有整型的相互转换
String a = String.valueOf(2);   //integer to numeric string  int i = Integer.parseInt(a); //numeric string to an int
2. 向文件末尾添加内容
BufferedWriter out = null;  try {      out = new BufferedWriter(new FileWriter(”filename”, true));      out.write(”aString”);  } catch (IOException e) {      // error processing code  } finally {      if (out != null) {          out.close();      }  }
3. 得到当前方法的名字
String methodName = Thread.currentThread().getStackTrace()[1].getMethodName();
4. 转字符串到日期
java.util.Date = java.text.DateFormat.getDateInstance().parse(date String);
或者是：
SimpleDateFormat format = new SimpleDateFormat( "dd.MM.yyyy" );  Date date = format.parse( myString );
5. 使用JDBC链接Oracle
public class OracleJdbcTest  {      String driverClass = "oracle.jdbc.driver.OracleDriver";      Connection con;      public void init(FileInputStream fs) throws ClassNotFoundException, SQLException, FileNotFoundException, IOException      {          Properties props = new Properties();          props.load(fs);          String url = props.getProperty("db.url");          String userName = props.getProperty("db.user");          String password = props.getProperty("db.password");          Class.forName(driverClass);          con=DriverManager.getConnection(url, userName, password);      }      public void fetch() throws SQLException, IOException      {          PreparedStatement ps = con.prepareStatement("select SYSDATE from dual");          ResultSet rs = ps.executeQuery();          while (rs.next())          {              // do the thing you do          }          rs.close();          ps.close();      }      public static void main(String[] args)      {          OracleJdbcTest test = new OracleJdbcTest();          test.init();          test.fetch();      }  }
6. 把 Java util.Date 转成 sql.Date
java.util.Date utilDate = new java.util.Date();  java.sql.Date sqlDate = new java.sql.Date(utilDate.getTime());
7. 使用NIO进行快速的文件拷贝
public static void fileCopy( File in, File out )              throws IOException      {          FileChannel inChannel = new FileInputStream( in ).getChannel();          FileChannel outChannel = new FileOutputStream( out ).getChannel();          try         {  //          inChannel.transferTo(0, inChannel.size(), outChannel);      // original -- apparently has trouble copying large files on Windows              // magic number for Windows, 64Mb - 32Kb)              int maxCount = (64 * 1024 * 1024) - (32 * 1024);              long size = inChannel.size();              long position = 0;              while ( position < size )              {                 position += inChannel.transferTo( position, maxCount, outChannel );              }          }          finally         {              if ( inChannel != null )              {                 inChannel.close();              }              if ( outChannel != null )              {                  outChannel.close();              }          }      }
8. 创建图片的缩略图
private void createThumbnail(String filename, int thumbWidth, int thumbHeight, int quality, String outFilename)          throws InterruptedException, FileNotFoundException, IOException      {          // load image from filename          Image image = Toolkit.getDefaultToolkit().getImage(filename);          MediaTracker mediaTracker = new MediaTracker(new Container());          mediaTracker.addImage(image, 0);          mediaTracker.waitForID(0);          // use this to test for errors at this point: System.out.println(mediaTracker.isErrorAny());          // determine thumbnail size from WIDTH and HEIGHT          double thumbRatio = (double)thumbWidth / (double)thumbHeight;          int imageWidth = image.getWidth(null);          int imageHeight = image.getHeight(null);          double imageRatio = (double)imageWidth / (double)imageHeight;          if (thumbRatio < imageRatio) {              thumbHeight = (int)(thumbWidth / imageRatio);          } else {              thumbWidth = (int)(thumbHeight * imageRatio);          }          // draw original image to thumbnail image object and          // scale it to the new size on-the-fly          BufferedImage thumbImage = new BufferedImage(thumbWidth, thumbHeight, BufferedImage.TYPE_INT_RGB);          Graphics2D graphics2D = thumbImage.createGraphics();          graphics2D.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);          graphics2D.drawImage(image, 0, 0, thumbWidth, thumbHeight, null);          // save thumbnail image to outFilename          BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(outFilename));          JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);          JPEGEncodeParam param = encoder.getDefaultJPEGEncodeParam(thumbImage);          quality = Math.max(0, Math.min(quality, 100));          param.setQuality((float)quality / 100.0f, false);          encoder.setJPEGEncodeParam(param);          encoder.encode(thumbImage);          out.close();      }
9. 创建 JSON 格式的数据
请先阅读这篇文章 了解一些细节，
并下面这个JAR 文件：json-rpc-1.0.jar (75 kb)
import org.json.JSONObject;  ...  ...  JSONObject json = new JSONObject();  json.put("city", "Mumbai");  json.put("country", "India");  ...  String output = json.toString();  ...
10. 使用iText JAR生成PDF
阅读这篇文章 了解更多细节
import java.io.File;  import java.io.FileOutputStream;  import java.io.OutputStream;  import java.util.Date;  import com.lowagie.text.Document;  import com.lowagie.text.Paragraph;  import com.lowagie.text.pdf.PdfWriter;  public class GeneratePDF {      public static void main(String[] args) {          try {              OutputStream file = new FileOutputStream(new File("C:\\Test.pdf"));              Document document = new Document();              PdfWriter.getInstance(document, file);              document.open();              document.add(new Paragraph("Hello Kiran"));              document.add(new Paragraph(new Date().toString()));              document.close();              file.close();          } catch (Exception e) {              e.printStackTrace();          }      }  }
11. HTTP 代理设置
阅读这篇 文章 了解更多细节。
System.getProperties().put("http.proxyHost", "someProxyURL");  System.getProperties().put("http.proxyPort", "someProxyPort");  System.getProperties().put("http.proxyUser", "someUserName");  System.getProperties().put("http.proxyPassword", "somePassword");
12. 单实例Singleton 示例
请先阅读这篇文章 了解更多信息
public class SimpleSingleton {      private static SimpleSingleton singleInstance =  new SimpleSingleton();      //Marking default constructor private      //to avoid direct instantiation.      private SimpleSingleton() {      }      //Get instance for class SimpleSingleton      public static SimpleSingleton getInstance() {          return singleInstance;      }  }
另一种实现
public enum SimpleSingleton {      INSTANCE;      public void doSomething() {      }  }  //Call the method from Singleton:  SimpleSingleton.INSTANCE.doSomething();
13. 抓屏程序
阅读这篇文章 获得更多信息。
import java.awt.Dimension;  import java.awt.Rectangle;  import java.awt.Robot;  import java.awt.Toolkit;  import java.awt.image.BufferedImage;  import javax.imageio.ImageIO;  import java.io.File;  ...  public void captureScreen(String fileName) throws Exception {     Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();     Rectangle screenRectangle = new Rectangle(screenSize);     Robot robot = new Robot();     BufferedImage image = robot.createScreenCapture(screenRectangle);     ImageIO.write(image, "png", new File(fileName));  }  ...
14. 列出文件和目录
File dir = new File("directoryName");    String[] children = dir.list();    if (children == null) {        // Either dir does not exist or is not a directory    } else {        for (int i=0; i < children.length; i++) {            // Get filename of file or directory            String filename = children[i];        }    }    // It is also possible to filter the list of returned files.    // This example does not return any files that start with `.'.    FilenameFilter filter = new FilenameFilter() {        public boolean accept(File dir, String name) {            return !name.startsWith(".");        }    };    children = dir.list(filter);    // The list of files can also be retrieved as File objects    File[] files = dir.listFiles();    // This filter only returns directories    FileFilter fileFilter = new FileFilter() {        public boolean accept(File file) {            return file.isDirectory();        }    };    files = dir.listFiles(fileFilter);
15. 创建ZIP和JAR文件
import java.util.zip.*;  import java.io.*;  public class ZipIt {      public static void main(String args[]) throws IOException {          if (args.length < 2) {              System.err.println("usage: java ZipIt Zip.zip file1 file2 file3");              System.exit(-1);          }          File zipFile = new File(args[0]);          if (zipFile.exists()) {              System.err.println("Zip file already exists, please try another");              System.exit(-2);          }          FileOutputStream fos = new FileOutputStream(zipFile);          ZipOutputStream zos = new ZipOutputStream(fos);          int bytesRead;          byte[] buffer = new byte[1024];          CRC32 crc = new CRC32();          for (int i=1, n=args.length; i < n; i++) {              String name = args[i];              File file = new File(name);              if (!file.exists()) {                  System.err.println("Skipping: " + name);                  continue;              }              BufferedInputStream bis = new BufferedInputStream(                  new FileInputStream(file));              crc.reset();              while ((bytesRead = bis.read(buffer)) != -1) {                  crc.update(buffer, 0, bytesRead);              }              bis.close();              // Reset to beginning of input stream              bis = new BufferedInputStream(                  new FileInputStream(file));              ZipEntry entry = new ZipEntry(name);              entry.setMethod(ZipEntry.STORED);              entry.setCompressedSize(file.length());              entry.setSize(file.length());              entry.setCrc(crc.getValue());              zos.putNextEntry(entry);              while ((bytesRead = bis.read(buffer)) != -1) {                  zos.write(buffer, 0, bytesRead);              }              bis.close();          }          zos.close();      }  }
16. 解析/读取XML 文件
XML文件
<?xml version="1.0"?> <students>     <student>         <name>John</name>         <grade>B</grade>         <age>12</age>     </student>     <student>         <name>Mary</name>         <grade>A</grade>         <age>11</age>     </student>     <student>         <name>Simon</name>         <grade>A</grade>         <age>18</age>     </student> </students>
Java代码
package net.viralpatel.java.xmlparser;  import java.io.File;  import javax.xml.parsers.DocumentBuilder;  import javax.xml.parsers.DocumentBuilderFactory;  import org.w3c.dom.Document;  import org.w3c.dom.Element;  import org.w3c.dom.Node;  import org.w3c.dom.NodeList;  public class XMLParser {      public void getAllUserNames(String fileName) {          try {              DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();              DocumentBuilder db = dbf.newDocumentBuilder();              File file = new File(fileName);              if (file.exists()) {                  Document doc = db.parse(file);                  Element docEle = doc.getDocumentElement();                  // Print root element of the document                  System.out.println("Root element of the document: "                         + docEle.getNodeName());                  NodeList studentList = docEle.getElementsByTagName("student");                  // Print total student elements in document                  System.out                          .println("Total students: " + studentList.getLength());                  if (studentList != null && studentList.getLength() > 0) {                      for (int i = 0; i < studentList.getLength(); i++) {                          Node node = studentList.item(i);                          if (node.getNodeType() == Node.ELEMENT_NODE) {                              System.out                                      .println("=====================");                              Element e = (Element) node;                              NodeList nodeList = e.getElementsByTagName("name");                              System.out.println("Name: "                                     + nodeList.item(0).getChildNodes().item(0)                                              .getNodeValue());                              nodeList = e.getElementsByTagName("grade");                              System.out.println("Grade: "                                     + nodeList.item(0).getChildNodes().item(0)                                              .getNodeValue());                              nodeList = e.getElementsByTagName("age");                              System.out.println("Age: "                                     + nodeList.item(0).getChildNodes().item(0)                                              .getNodeValue());                          }                      }                  } else {                      System.exit(1);                  }              }          } catch (Exception e) {              System.out.println(e);          }      }      public static void main(String[] args) {          XMLParser parser = new XMLParser();          parser.getAllUserNames("c:\\test.xml");      }  }
17. 把 Array 转换成 Map 
import java.util.Map;  import org.apache.commons.lang.ArrayUtils;  public class Main {    public static void main(String[] args) {      String[][] countries = { { "United States", "New York" }, { "United Kingdom", "London" },          { "Netherland", "Amsterdam" }, { "Japan", "Tokyo" }, { "France", "Paris" } };      Map countryCapitals = ArrayUtils.toMap(countries);      System.out.println("Capital of Japan is " + countryCapitals.get("Japan"));      System.out.println("Capital of France is " + countryCapitals.get("France"));    }  }
18. 发送邮件
import javax.mail.*;  import javax.mail.internet.*;  import java.util.*;  public void postMail( String recipients[ ], String subject, String message , String from) throws MessagingException  {      boolean debug = false;       //Set the host smtp address       Properties props = new Properties();       props.put("mail.smtp.host", "smtp.example.com");      // create some properties and get the default Session      Session session = Session.getDefaultInstance(props, null);      session.setDebug(debug);      // create a message      Message msg = new MimeMessage(session);      // set the from and to address      InternetAddress addressFrom = new InternetAddress(from);      msg.setFrom(addressFrom);      InternetAddress[] addressTo = new InternetAddress[recipients.length];      for (int i = 0; i < recipients.length; i++)      {          addressTo[i] = new InternetAddress(recipients[i]);      }      msg.setRecipients(Message.RecipientType.TO, addressTo);      // Optional : You can also set your custom headers in the Email if you Want      msg.addHeader("MyHeaderName", "myHeaderValue");      // Setting the Subject and Content Type      msg.setSubject(subject);      msg.setContent(message, "text/plain");      Transport.send(msg);  }
19. 发送代数据的HTTP 请求
import java.io.BufferedReader;  import java.io.InputStreamReader;  import java.net.URL;  public class Main {      public static void main(String[] args)  {          try {              URL my_url = new URL("http://coolshell.cn/");              BufferedReader br = new BufferedReader(new InputStreamReader(my_url.openStream()));              String strTemp = "";              while(null != (strTemp = br.readLine())){              System.out.println(strTemp);          }          } catch (Exception ex) {              ex.printStackTrace();          }      }  }
20. 改变数组的大小
/** * Reallocates an array with a new size, and copies the contents * of the old array to the new array. * @param oldArray  the old array, to be reallocated. * @param newSize   the new array size. * @return          A new array with the same contents. */ private static Object resizeArray (Object oldArray, int newSize) {     int oldSize = java.lang.reflect.Array.getLength(oldArray);     Class elementType = oldArray.getClass().getComponentType();     Object newArray = java.lang.reflect.Array.newInstance(           elementType,newSize);     int preserveLength = Math.min(oldSize,newSize);     if (preserveLength > 0)        System.arraycopy (oldArray,0,newArray,0,preserveLength);     return newArray;  }  // Test routine for resizeArray().  public static void main (String[] args) {     int[] a = {1,2,3};     a = (int[])resizeArray(a,5);     a[3] = 4;     a[4] = 5;     for (int i=0; i<a.length; i++)        System.out.println (a[i]);  }
Comparable 简介
Comparable 是排序接口。
若一个类实现了Comparable接口，就意味着“该类支持排序”。  即然实现Comparable接口的类支持排序，假设现在存在“实现Comparable接口的类的对象的List列表(或数组)”，则该List列表(或数组)可以通过 Collections.sort（或 Arrays.sort）进行排序。
此外，“实现Comparable接口的类的对象”可以用作“有序映射(如TreeMap)”中的键或“有序集合(TreeSet)”中的元素，而不需要指定比较器。
Comparable 定义
Comparable 接口仅仅只包括一个函数，它的定义如下：
package java.lang;import java.util.*;public interface Comparable<T> {    public int compareTo(T o);}
说明：
假设我们通过 x.compareTo(y) 来“比较x和y的大小”。若返回“负数”，意味着“x比y小”；返回“零”，意味着“x等于y”；返回“正数”，意味着“x大于y”。
Comparator 简介
Comparator 是比较器接口。
我们若需要控制某个类的次序，而该类本身不支持排序(即没有实现Comparable接口)；那么，我们可以建立一个“该类的比较器”来进行排序。这个“比较器”只需要实现Comparator接口即可。
也就是说，我们可以通过“实现Comparator类来新建一个比较器”，然后通过该比较器对类进行排序。
Comparator 定义
Comparator 接口仅仅只包括两个个函数，它的定义如下：
package java.util;public interface Comparator<T> {    int compare(T o1, T o2);    boolean equals(Object obj);}
说明：
(01) 若一个类要实现Comparator接口：它一定要实现compareTo(T o1, T o2) 函数，但可以不实现 equals(Object obj) 函数。
为什么可以不实现 equals(Object obj) 函数呢？ 因为任何类，默认都是已经实现了equals(Object obj)的。 Java中的一切类都是继承于java.lang.Object，在Object.java中实现了equals(Object obj)函数；所以，其它所有的类也相当于都实现了该函数。
(02) int compare(T o1, T o2) 是“比较o1和o2的大小”。返回“负数”，意味着“o1比o2小”；返回“零”，意味着“o1等于o2”；返回“正数”，意味着“o1大于o2”。
Comparator 和 Comparable 比较
Comparable是排序接口；若一个类实现了Comparable接口，就意味着“该类支持排序”。
而Comparator是比较器；我们若需要控制某个类的次序，可以建立一个“该类的比较器”来进行排序。
我们不难发现：Comparable相当于“内部比较器”，而Comparator相当于“外部比较器”。
我们通过一个测试程序来对这两个接口进行说明。源码如下：
import java.util.*;import java.lang.Comparable;/** * @desc "Comparator"和“Comparable”的比较程序。 *   (01) "Comparable" *   它是一个排序接口，只包含一个函数compareTo()。 *   一个类实现了Comparable接口，就意味着“该类本身支持排序”，它可以直接通过Arrays.sort() 或 Collections.sort()进行排序。 *   (02) "Comparator" *   它是一个比较器接口，包括两个函数：compare() 和 equals()。 *   一个类实现了Comparator接口，那么它就是一个“比较器”。其它的类，可以根据该比较器去排序。 * *   综上所述：Comparable是内部比较器，而Comparator是外部比较器。 *   一个类本身实现了Comparable比较器，就意味着它本身支持排序；若它本身没实现Comparable，也可以通过外部比较器Comparator进行排序。 */public class CompareComparatorAndComparableTest{    public static void main(String[] args) {        // 新建ArrayList(动态数组)        ArrayList<Person> list = new ArrayList<Person>();        // 添加对象到ArrayList中        list.add(new Person("ccc", 20));        list.add(new Person("AAA", 30));        list.add(new Person("bbb", 10));        list.add(new Person("ddd", 40));        // 打印list的原始序列        System.out.printf("Original  sort, list:%s\n", list);        // 对list进行排序        // 这里会根据“Person实现的Comparable<String>接口”进行排序，即会根据“name”进行排序        Collections.sort(list);        System.out.printf("Name      sort, list:%s\n", list);        // 通过“比较器(AscAgeComparator)”，对list进行排序        // AscAgeComparator的排序方式是：根据“age”的升序排序        Collections.sort(list, new AscAgeComparator());        System.out.printf("Asc(age)  sort, list:%s\n", list);        // 通过“比较器(DescAgeComparator)”，对list进行排序        // DescAgeComparator的排序方式是：根据“age”的降序排序        Collections.sort(list, new DescAgeComparator());        System.out.printf("Desc(age) sort, list:%s\n", list);        // 判断两个person是否相等        testEquals();    }    /**     * @desc 测试两个Person比较是否相等。     *   由于Person实现了equals()函数：若两person的age、name都相等，则认为这两个person相等。     *   所以，这里的p1和p2相等。     *     *   TODO：若去掉Person中的equals()函数，则p1不等于p2     */    private static void testEquals() {        Person p1 = new Person("eee", 100);        Person p2 = new Person("eee", 100);        if (p1.equals(p2)) {            System.out.printf("%s EQUAL %s\n", p1, p2);        } else {            System.out.printf("%s NOT EQUAL %s\n", p1, p2);        }    }    /**     * @desc Person类。     *       Person实现了Comparable接口，这意味着Person本身支持排序     */    private static class Person implements Comparable<Person>{        int age;        String name;        public Person(String name, int age) {            this.name = name;            this.age = age;        }        public String getName() {            return name;        }        public int getAge() {            return age;        }        public String toString() {            return name + " - " +age;        }        /**         * 比较两个Person是否相等：若它们的name和age都相等，则认为它们相等         */        boolean equals(Person person) {            if (this.age == person.age && this.name == person.name)                return true;            return false;        }        /**         * @desc 实现 “Comparable<String>” 的接口，即重写compareTo<T t>函数。         *  这里是通过“person的名字”进行比较的         */        @Override        public int compareTo(Person person) {            return name.compareTo(person.name);            //return this.name - person.name;        }    }    /**     * @desc AscAgeComparator比较器     *       它是“Person的age的升序比较器”     */    private static class AscAgeComparator implements Comparator<Person> {        @Override         public int compare(Person p1, Person p2) {            return p1.getAge() - p2.getAge();        }    }    /**     * @desc DescAgeComparator比较器     *       它是“Person的age的升序比较器”     */    private static class DescAgeComparator implements Comparator<Person> {        @Override         public int compare(Person p1, Person p2) {            return p2.getAge() - p1.getAge();        }    }}
下面对这个程序进行说明。
a) Person类定义。如下：
private static class Person implements Comparable<Person>{    int age;    String name;        ...    /**      * @desc 实现 “Comparable<String>” 的接口，即重写compareTo<T t>函数。     *  这里是通过“person的名字”进行比较的     */    @Override    public int compareTo(Person person) {        return name.compareTo(person.name);        //return this.name - person.name;    }   }
说明：
(01) Person类代表一个人，Persong类中有两个属性：age(年纪) 和 name“人名”。
(02) Person类实现了Comparable接口，因此它能被排序。
b) 在main()中，我们创建了Person的List数组(list)。如下：
// 新建ArrayList(动态数组)ArrayList<Person> list = new ArrayList<Person>();// 添加对象到ArrayList中list.add(new Person("ccc", 20));list.add(new Person("AAA", 30));list.add(new Person("bbb", 10));list.add(new Person("ddd", 40));
c) 接着，我们打印出list的全部元素。如下：
// 打印list的原始序列System.out.printf("Original sort, list:%s\n", list);
d) 然后，我们通过Collections的sort()函数，对list进行排序。
由于Person实现了Comparable接口，因此通过sort()排序时，会根据Person支持的排序方式，即 compareTo(Person person) 所定义的规则进行排序。如下：
// 对list进行排序// 这里会根据“Person实现的Comparable<String>接口”进行排序，即会根据“name”进行排序Collections.sort(list);System.out.printf("Name sort, list:%s\n", list);
e) 对比Comparable和Comparator
我们定义了两个比较器 AscAgeComparator 和 DescAgeComparator，来分别对Person进行 升序 和 降低 排序。
e.1) AscAgeComparator比较器
它是将Person按照age进行升序排序。代码如下：
/** * @desc AscAgeComparator比较器 *       它是“Person的age的升序比较器” */private static class AscAgeComparator implements Comparator<Person> {    @Override    public int compare(Person p1, Person p2) {        return p1.getAge() - p2.getAge();    }}
e.2) DescAgeComparator比较器
它是将Person按照age进行降序排序。代码如下：
/** * @desc DescAgeComparator比较器 *       它是“Person的age的升序比较器” */private static class DescAgeComparator implements Comparator<Person> {    @Override    public int compare(Person p1, Person p2) {        return p2.getAge() - p1.getAge();    }}
f) 运行结果
运行程序，输出如下：
Original  sort, list:[ccc - 20, AAA - 30, bbb - 10, ddd - 40]Name      sort, list:[AAA - 30, bbb - 10, ccc - 20, ddd - 40]Asc(age)  sort, list:[bbb - 10, ccc - 20, AAA - 30, ddd - 40]Desc(age) sort, list:[ddd - 40, AAA - 30, ccc - 20, bbb - 10]eee - 100 EQUAL eee - 100

5、CyclicBarrier和CountDownLatch的区别
两个看上去有点像的类，都在java.util.concurrent下，都可以用来表示代码运行到某个点上，二者的区别在于：
（1）CyclicBarrier的某个线程运行到某个点上之后，该线程即停止运行，直到所有的线程都到达了这个点，所有线程才重新运行；CountDownLatch则不是，某线程运行到某个点上之后，只是给某个数值-1而已，该线程继续运行
（2）CyclicBarrier只能唤起一个任务，CountDownLatch可以唤起多个任务
（3）CyclicBarrier可重用，CountDownLatch不可重用，计数值为0该CountDownLatch就不可再用了
6、Volatile关键字的作用
一个非常重要的问题，是每个学习、应用多线程的Java程序员都必须掌握的。理解volatile关键字的作用的前提是要理解Java内存模型，这里就不讲Java内存模型了，可以参见第31点，volatile关键字的作用主要有两个：
（1）多线程主要围绕可见性和原子性两个特性而展开，使用volatile关键字修饰的变量，保证了其在多线程之间的可见性，即每次读取到volatile变量，一定是最新的数据
（2）代码底层执行不像我们看到的高级语言—-Java程序这么简单，它的执行是Java代码–>字节码–>根据字节码执行对应的C/C++代码–>C/C++代码被编译成汇编语言–>和硬件电路交互，现实中，为了获取更好的性能JVM可能会对指令进行重排序，多线程下可能会出现一些意想不到的问题。使用volatile则会对禁止语义重排序，当然这也一定程度上降低了代码执行效率
从实践角度而言，volatile的一个重要作用就是和CAS结合，保证了原子性，详细的可以参见java.util.concurrent.atomic包下的类，比如AtomicInteger。
Java中有5种创建对象的方式，下面给出它们的例子还有它们的字节码
使用new关键字} → 调用了构造函数使用Class类的newInstance方法} → 调用了构造函数使用Constructor类的newInstance方法} → 调用了构造函数使用clone方法} → 没有调用构造函数使用反序列化} → 没有调用构造函数

集合类是Java API的核心，但是我觉得要用好它们是一种艺术。我总结了一些个人的经验，譬如使用ArrayList能够提高性能，而不再需要过时的Vector了，等等。JDK 1.5引入了一些好用的并发集合类，它们对于大型的、要求低延迟的电子商务系统来说非常的有用。这篇文章中将会看看ConcurrentHashMap和Hashtable之间的区别。

这篇文章是HashMap的工作原理以及HashMap和Hashtable的区别的后续。如果你已经读过的话，那么我相信你读完本篇之后会有所收获。

为什么我们需要ConcurrentHashMap和CopyOnWriteArrayList

同步的集合类（Hashtable和Vector），同步的封装类（使用Collections.synchronizedMap()方法和Collections.synchronizedList()方法返回的对象）可以创建出线程安全的Map和List。但是有些因素使得它们不适合高并发的系统。它们仅有单个锁，对整个集合加锁，以及为了防止ConcurrentModificationException异常经常要在迭代的时候要将集合锁定一段时间，这些特性对可扩展性来说都是障碍。

ConcurrentHashMap和CopyOnWriteArrayList保留了线程安全的同时，也提供了更高的并发性。ConcurrentHashMap和CopyOnWriteArrayList并不是处处都需要用，大部分时候你只需要用到HashMap和ArrayList，它们用于应对一些普通的情况。

ConcurrentHashMap和Hashtable的区别

Hashtable和ConcurrentHashMap有什么分别呢？它们都可以用于多线程的环境，但是当Hashtable的大小增加到一定的时候，性能会急剧下降，因为迭代时需要被锁定很长的时间。因为ConcurrentHashMap引入了分割(segmentation)，不论它变得多么大，仅仅需要锁定map的某个部分，而其它的线程不需要等到迭代完成才能访问map。简而言之，在迭代的过程中，ConcurrentHashMap仅仅锁定map的某个部分，而Hashtable则会锁定整个map。