public class TestDemo {
    
    @Test
    public void test01() {
        String str1 = new StringBuilder("hello").append("World").toString();
        System.out.println(str1.intern());
        System.out.println(str1 == str1.intern());

        String str2 = new StringBuilder("ja").append("va").toString();
        System.out.println(str2.intern());
        System.out.println(str2 == str2.intern());

        String str3 = new StringBuilder("hello").toString();
        System.out.println(str3.intern());
        System.out.println(str3 == str3.intern());
    }
    
}

helloWorld 
true // 因为str1被存入了常量池。左侧是new出来的对象，右侧常量池中存的也是new出来的对象
java
false // 因为"java"本来就存在与常量池中，左侧是new出来的对象，右侧是已经存在在常量池中的对象
hello
false // 因为hello此前已经存在常量池中，左侧是new出来的对象，右侧是在前面已经存在在常量池中的对象

"a" + "b" + "c"得到的"abc"也在常量池中。

String st1 = "ab";
String st2 = "abc";
String st3 = st1 + "c";
此时st3并非常量池中的"abc"，任何数据和字符串进行加号（+）运算，最终得到是一个拼接的新的字符串。这个拼接的原理是由StringBuilder或者StringBuffer类和里面的append方法实现拼接，然后调用toString（）把拼接的对象转换成字符串对象，最后把得到字符串对象的地址赋值给变量。

private int hash; // Default to 0
public int hashCode() {
    int h = hash;
    if (h == 0 && value.length > 0) {
        char val[] = value;

        for (int i = 0; i < value.length; i++) {
            h = 31 * h + val[i];
        }
        hash = h;
    }
    return h;
}

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

对称性: 如果x.equals(y)返回是true，那么y.equals(x)也应该返回是true。
反射性: x.equals(x)必须返回是true。
类推性: 如果x.equals(y)返回是true，而且y.equals(z)返回是true，那么z.equals(x)也应该返回是true。
一致性: 如果x.equals(y)返回是true，只要x和y内容一直不变，不管你重复x.equals(y)多少次，返回都是true。
非空性: x.equals(null)，永远返回是false；x.equals(和x不同类型的对象)永远返回是false。

在一个Java应用的执行期间，如果一个对象提供给equals做比较的信息没有被修改的话，该对象多次调用hashCode()方法，该方法必须始终如一返回同一个integer。
如果两个对象根据equals(Object)方法是相等的，那么调用二者各自的hashCode()方法必须产生同一个integer结果。
并不要求根据equals(java.lang.Object)方法不相等的两个对象，调用二者各自的hashCode()方法必须产生不同的integer结果。然而，程序员应该意识到对于不同的对象产生不同的integer结果，有可能会提高hash table的性能。

构造器                   描述
BigDecimal(int)       创建一个具有参数所指定整数值的对象。
BigDecimal(double)    创建一个具有参数所指定双精度值的对象。
BigDecimal(long)      创建一个具有参数所指定长整数值的对象。
BigDecimal(String)    创建一个具有参数所指定以字符串表示的数值的对象。

函数：
方法                    描述
add(BigDecimal)       BigDecimal对象中的值相加，然后返回这个对象。
subtract(BigDecimal)  BigDecimal对象中的值相减，然后返回这个对象。
multiply(BigDecimal)  BigDecimal对象中的值相乘，然后返回这个对象。
divide(BigDecimal)    BigDecimal对象中的值相除，然后返回这个对象。
toString()            将BigDecimal对象的数值转换成字符串。
doubleValue()         将BigDecimal对象中的值以双精度数返回。
floatValue()          将BigDecimal对象中的值以单精度数返回。
longValue()           将BigDecimal对象中的值以长整数返回。
intValue()            将BigDecimal对象中的值以整数返回。

Object():构造方法
registerNatives():为了使JVM发现本机功能，它们被一定的方式命名。例如，对于java.lang.Object.registerNatives，对应的C函数命名为Java_java_lang_Object_registerNatives。通过使用registerNatives（或者更确切地说，JNI函数RegisterNatives），可以命名任何你想要你的C函数。
clone():用来另存一个当前存在的对象。只有实现了Cloneable接口才可以调用该方法，否则抛出CloneNotSupportedException异常。
getClass():final方法，用于获得运行时的类型。该方法返回的是此Object对象的类对象/运行时类对象Class。效果与Object.class相同。
equals():用来比较两个对象的内容是否相等。默认情况下(继承自Object类)，equals和==是一样的，除非被覆写(override)了。
hashCode():用来返回其所在对象的物理地址（哈希码值），常会和equals方法同时重写，确保相等的两个对象拥有相等的hashCode。作用是获取哈希码，也称为散列码；它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。
toString():返回该对象的字符串表示。
wait():导致当前的线程等待，直到其他线程调用此对象的notify()方法或notifyAll()方法。
wait(long timeout):导致当前的线程等待，直到其他线程调用此对象的notify()方法或notifyAll()方法，或者超过指定的时间量。
wait(long timeout, int nanos):导致当前的线程等待，直到其他线程调用此对象的notify()方法或notifyAll()方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量。
notify():唤醒在此对象监视器上等待的单个线程。
notifyAll():唤醒在此对象监视器上等待的所有线程。
finalize():当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。

// Comparable
public class Domain implements Comparable<Domain>{
   private String str;

   public Domain(String str){
       this.str = str;
   }

   public int compareTo(Domain domain){
       if (this.str.compareTo(domain.str) > 0)
           return 1;
       else if (this.str.compareTo(domain.str) == 0)
           return 0;
       else 
           return -1;
   }

   public String getStr(){
       return str;
   }
}

// Comparator
public class DomainComparator implements Comparator<Domain>{
   public int compare(Domain domain1, Domain domain2){
       if (domain1.getStr().compareTo(domain2.getStr()) > 0)
           return 1;
       else if (domain1.getStr().compareTo(domain2.getStr()) == 0)
           return 0;
       else 
           return -1;
   }
}

public class StringBuilderDemo {

    public static void main(String[] args) throws InterruptedException {
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < 10; i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 1000; j++){
                        stringBuilder.append("a");
                    }
                }
            }).start();
        }

        Thread.sleep(100);
        System.out.println(stringBuilder.length());
    }
}

//存储字符串的具体内容
char[] value;
//已经使用的字符数组的数量
int count;

@Override
public StringBuilder append(String str) {
    super.append(str);
    return this;
}

public AbstractStringBuilder append(String str) {
    if (str == null)
        return appendNull();
    int len = str.length();
    ensureCapacityInternal(count + len);
    str.getChars(0, len, value, count);
    count += len;
    return this;
}

private void ensureCapacityInternal(int minimumCapacity) {
        // overflow-conscious code
    if (minimumCapacity - value.length > 0)
        expandCapacity(minimumCapacity);
}
void expandCapacity(int minimumCapacity) {
    //计算新的容量
    int newCapacity = value.length * 2 + 2;
    //中间省略了一些检查逻辑
    ...
    value = Arrays.copyOf(value, newCapacity);
}
public static char[] copyOf(char[] original, int newLength) {
    char[] copy = new char[newLength];
    //拷贝数组
    System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
    return copy;
}
public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {
    //中间省略了一些检查
    ...   
    System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
}

Teacher teacher = new Teacher("Taylor",26);
Teacher otherteacher = teacher;

Teacher teacher = new Teacher("Swift",26); 
Teacher otherteacher = (Teacher)teacher.clone(); 

ByteArrayInputStream，StringBufferInputStream，FileInputStream，三种基本的介质流它们分别从Byte数组、StringBuffer、和本地文件中读取数据。
PipedInputStream从与其它线程共用的管道中读取数据。

ObjectInputStream和所有FilterInputStream的子类都是装饰流。
FilterInputStream子类包括BufferedInputStream能为输入流提供缓冲区，DataInputStream可以从输入流中读取Java基本类型数据，PushBackInputStream可以把读取到的字节重新推回到InputStream中。

ByteArrayOutputStream、FileOutputStream是两种基本的介质流，它们分别向Byte数组和本地文件中写入数据。
PipedOutputStream是向与其它线程共用的管道中写入数据。

ObjectOutputStream 和所有FilterOutputStream的子类都是装饰流。FilterOutputStream子类包括BufferedOutputStream、DataOutputStream。
PrintStream

public class IOTest {
     public static void write(File file) throws IOException {
      // 缓冲字节流，提高了效率
      BufferedOutputStream bis = new BufferedOutputStream(new FileOutputStream(file, true));
    
      // 要写入的字符串
      String string = "松下问童子，言师采药去。只在此山中，云深不知处。";
      // 写入文件
      bis.write(string.getBytes());
      // 关闭流
      bis.close();
     }
    
     public static String read(File file) throws IOException {
      BufferedInputStream fis = new BufferedInputStream(new FileInputStream(file));
    
      // 一次性取多少个字节
      byte[] bytes = new byte[1024];
      // 用来接收读取的字节数组
      StringBuilder sb = new StringBuilder();
      // 读取到的字节数组长度，为-1时表示没有数据
      int length = 0;
      // 循环取数据
      while ((length = fis.read(bytes)) != -1) {
       // 将读取的内容转换成字符串
       sb.append(new String(bytes, 0, length));
      }
      // 关闭流
      fis.close();
    
      return sb.toString();
     }
}    

FileReader, ByteArrayReader, PipedReader
BufferedReader, InputStreamReader

FileWriter, ByteArrayWriter, PipedWriter
BufferedWriter, InputStreamWriter, PrintWriter

public class IOTest {
     public static void write(File file) throws IOException {
      // BufferedWriter fw = new BufferedWriter(new OutputStreamWriter(new
      // FileOutputStream(file, true), "UTF-8"));
      // FileWriter可以大幅度简化代码
      BufferedWriter bw = new BufferedWriter(new FileWriter(file, true));
    
      // 要写入的字符串
      String string = "松下问童子，言师采药去。只在此山中，云深不知处。";
      bw.write(string);
      bw.close();
     }
    
     public static String read(File file) throws IOException {
      BufferedReader br = new BufferedReader(new FileReader(file));
      // 用来接收读取的字节数组
      StringBuilder sb = new StringBuilder();
    
      // 按行读数据
      String line;
      // 循环取数据
      while ((line = br.readLine()) != null) {
       // 将读取的内容转换成字符串
       sb.append(line);
      }
      // 关闭流
      br.close();
    
      return sb.toString();
     }
}

createNewFile()在指定位置创建一个空文件，成功就返回true，如果已存在就不创建，然后返回false。
mkdir() 在指定位置创建一个单级文件夹。
mkdirs() 在指定位置创建一个多级文件夹。
renameTo(File dest)如果目标文件与源文件是在同一个路径下，那么renameTo的作用是重命名， 如果目标文件与源文件不是在同一个路径下，那么renameTo的作用就是剪切，而且还不能操作文件夹。

delete() 删除文件或者一个空文件夹，不能删除非空文件夹，马上删除文件，返回一个布尔值。
deleteOnExit()jvm退出时删除文件或者文件夹，用于删除临时文件，无返回值。

exists() 文件或文件夹是否存在。
isFile() 是否是一个文件，如果不存在，则始终为false。
isDirectory() 是否是一个目录，如果不存在，则始终为false。
isHidden() 是否是一个隐藏的文件或是否是隐藏的目录。
isAbsolute() 测试此抽象路径名是否为绝对路径名。

getName() 获取文件或文件夹的名称，不包含上级路径。
getAbsolutePath()获取文件的绝对路径，与文件是否存在没关系
length() 获取文件的大小（字节数），如果文件不存在则返回0L，如果是文件夹也返回0L。
getParent() 返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回null。
lastModified()获取最后一次被修改的时间。

static File[] listRoots()列出所有的根目录（Window中就是所有系统的盘符）
list() 返回目录下的文件或者目录名，包含隐藏文件。对于文件这样操作会返回null。
listFiles() 返回目录下的文件或者目录对象（File类实例），包含隐藏文件。对于文件这样操作会返回null。
list(FilenameFilter filter)返回指定当前目录中符合过滤条件的子文件或子目录。对于文件这样操作会返回null。
listFiles(FilenameFilter filter)返回指定当前目录中符合过滤条件的子文件或子目录。对于文件这样操作会返回null。

public class FileTest {
 public static void main(String[] args) throws IOException {
  File file = new File("C:/fileTest.txt");

  // 判断文件是否存在
  if (!file.exists()) {
   // 不存在则创建
   file.createNewFile();
  }
  System.out.println("文件的绝对路径：" + file.getAbsolutePath());
  System.out.println("文件的大小：" + file.length());

  // 刪除文件
  file.delete();
 }
}

public class ObjectOutputStreamDemo { //序列化
    public static void main(String[] args) throws Exception {
        //序列化后生成指定文件路径
        File file = new File("D:" + File.separator + "person.ser");
        ObjectOutputStream oos = null;
        //装饰流（流）
        oos = new ObjectOutputStream(new FileOutputStream(file));

        //实例化类，需要实现Serializabel接口
        Person per = new Person("张三", 30);
        oos.writeObject(per); //把类对象序列化
        oos.close();
    }
}

Protobuf
结构化数据存储格式（xml,json等）
高性能编解码技术
语言和平台无关，扩展性好，支持java、C++、Python三种语言。
Google开源

Thrift
支持多种语言（C++、C#、Cocoa、Erlang、Haskell、java、Ocami、Perl、PHP、Python、Ruby和SmallTalk）
使用了组建大型数据交换及存储工具，对于大型系统中的内部数据传输，相对于Json和xml在性能上和传输大小上都有明显的优势。
支持通用二进制编码，压缩二进制编码，优化的可选字段压缩编解码等三种方式。
FaceBook开源

Jackson
Jackson所依赖的jar包较少，简单易用并且性能也要相对高些。
对于复杂类型的json转换bean会出现问题，一些集合Map，List的转换出现问题。
Jackson对于复杂类型的bean转换Json，转换的json格式不是标准的Json格式

Gson
Gson是目前功能最全的Json解析神器
Gson的应用主要为toJson与fromJson两个转换函数，无依赖，不需要例外额外的jar
类里面只要有get和set方法，Gson完全可以将复杂类型的json到bean或bean到json的转换，是JSON解析的神器

FastJson
无依赖，不需要例外额外的jar，能够直接跑在JDK上。
FastJson在复杂类型的Bean转换Json上会出现一些问题，可能会出现引用的类型，导致Json转换出错，需要制定引用。
FastJson采用独创的算法，将parse的速度提升到极致，超过所有json库。
频繁爆漏洞，被相当部分公司禁止使用

File file = new File("test.zip");
RandomAccessFile raf = new RandomAccessFile(file, "rw");
FileChannel fileChannel = raf.getChannel();
SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("", 1234));
// 直接使用了transferTo()进行通道间的数据传输
fileChannel.transferTo(0, fileChannel.size(), socketChannel);

较大，读写较慢，追求速度
内存不足，不能加载太大数据
带宽不够，即存在其他程序或线程存在大量的IO操作，导致带宽本来就小

File file = new File("test.zip");
RandomAccessFile raf = new RandomAccessFile(file, "rw");
FileChannel fileChannel = raf.getChannel();
MappedByteBuffer buffer = fileChannel.map(FileChannel.MapMode.READ_ONLY, 0, fileChannel.size());

// 或者
public class MappedByteBufferTest {  
  
    public static void main(String[] args) throws Exception {  
        File file = new File("D://db.txt");  
        long len = file.length();  
        byte[] ds = new byte[(int) len];  
        MappedByteBuffer mappedByteBuffer = new FileInputStream(file).getChannel().map(FileChannel.MapMode.READ_ONLY, 0,  len);  
        for (int offset = 0; offset < len; offset++) {  
            byte b = mappedByteBuffer.get();  
            ds[offset] = b;  
        }  
        Scanner scan = new Scanner(new ByteArrayInputStream(ds)).useDelimiter(" ");  
        while (scan.hasNext()) {  
            System.out.print(scan.next() + " ");  
        }  
    }  
}

(a)BIO：阻塞。如果服务端连接多个客户端，则需要多个线程分别从套接字读取数据。
(b)NIO：非阻塞。NIO = I/O多路复用 + 非阻塞式I/O
(c)AIO：一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理。

(a)Reactor单线程模型：由一个线程监听连接事件、读写事件，并完成数据读写。
(b)Reactor多线程模型：一个Acceptor线程专门监听各种事件，再由专门的线程池负责处理真正的IO数据读写。
(c)主从Reactor多线程模型：一个线程监听连接事件，线程池的多个线程监听已经建立连接的套接字的数据读写事件，另外和多线程模型一样有专门的线程池处理真正的IO操作。

try – 用于监听。将要被监听的代码(可能抛出异常的代码)放在try语句块之内，当try语句块内发生异常时，异常就被抛出。
catch – 用于捕获异常。catch用来捕获try语句块中发生的异常。
finally – finally语句块总是会被执行。它主要用于回收在try块里打开的物理资源(如数据库连接、网络连接和磁盘文件)。只有finally块，执行完成之后，才会回来执行try或者catch块中的return或者throw语句，如果finally中使用了return或者throw等终止方法的语句，则就不会跳回执行，直接停止。
throw – 用在方法内部，只能用于抛出一种异常，用来抛出方法或代码块中的异常，受查异常和非受查异常都可以被抛出。
throws – 用在方法签名中，用于声明该方法可能抛出的异常。

是否能解决异常？
    是 --> 捕获异常
    否 --> 调用者是否必须处理（是否受检异常）？
        是 --> 声明受检异常
        否 --> 抛出运行时异常

public static int getInt() {
    int a = 10;
    try {
        System.out.println(a / 0);
        a = 20;
    } catch (ArithmeticException e) {
        a = 30;
        return a;
        /*
         * return a 在程序执行到这一步的时候，这里不是return a 而是 return 30；这个返回路径就形成了
         * 但是呢，它发现后面还有finally，所以继续执行finally的内容，a=40
         * 再次回到以前的路径,继续走return 30，形成返回路径之后，这里的a就不是a变量了，而是常量30
         */
    } finally {
        a = 40;
    }
 return a;
}

public static int getInt() {
    int a = 10;
    try {
        System.out.println(a / 0);
        a = 20;
    } catch (ArithmeticException e) {
        a = 30;
        return a;
    } finally {
        a = 40;
        //如果这样，就又重新形成了一条返回路径，由于只能通过1个return返回，所以这里直接返回40
        return a; 
    }

}

private  static void tryWithResourceTest(){
    try (Scanner scanner = new Scanner(new FileInputStream("c:/abc"),"UTF-8")){
        // code
    } catch (IOException e){
        // handle exception
    }
}

bype/char/short/int/long/boolean/float/double.class及void.class
数组int[].class及String[].class
对象MyObject.class

Class clazz = Class.forName("some.package.MyClassName"); // className必须为全名，也就是得包含包名
Object obj= clazz.newInstance(); //如果类有无参数公共构造函数，直接可以使用类的字节码实例就创建对象的实例。否则用constructor对象调用newInstance(Object... initargs)

//--------------------------- Class对象的方法（即clazz的方法）---------------------------
// 构造器Constructor有newInstance方法
Constructor getConstructor(Class[] params) //根据指定参数获得public构造器
Constructor[] getConstructors() //获得public的所有构造器
Constructor getDeclaredConstructor(Class[] params) //根据指定参数获得public和非public的构造器
Constructor[] getDeclaredConstructors() //获得public和非public的所有构造器

// 方法Method有invoke方法
Method getMethod(String name, Class[] params) //根据方法名，参数类型获得方法
Method[] getMethods() //获得所有的public方法
Method getDeclaredMethod(String name, Class[] params) //根据方法名和参数类型，获得public和非public的方法
Method[] getDeclaredMethods() //获得所有的public和非public方法

// 属性Field有get,set方法
Field getField(String name) //根据变量名得到相应的public变量
Field[] getFields() //获得类中所有public的方法
Field getDeclaredField(String name) //根据方法名获得public和非public变量
Field[] getDeclaredFields() //获得类中所有的public和非public方法

public interface Command {  
    public void execute();  
}

public class TurnOnCommand implements Command {
    public void execute() {  
        System.out.println("Trun on....");
    }  
}

public class TurnOffCommand implements Command {
    public void execute() {  
        System.out.println("Trun off....");
    }  
}

com.abc.spi.TurnOnCommand
com.abc.spi.TurnOffCommand

public class Test {
    public static void main(String[] args) {
        // 加载jdk的spi接口Command.class
        ServiceLoader<Command> serviceLoader=ServiceLoader.load(Command.class);
        // 遍历加载的jdk的接口
        for(Command command:serviceLoader){
            command.execute();  
        }  
    }
}

public interface ComputeService {
     int add(int num1, int num2);
}

public class ComputeServiceImpl implements ComputeService {

    @Override
    public int add(int num1, int num2) {
        int sum = num1 + num2;
        System.out.println("结果：" + sum);
        return sum;
    }
}

public class JDKProxySample implements InvocationHandler {

    private Object target;

    /**
     * 绑定原实现类
     * @param target 原实现类
     * @return 代理类
     */
    public Object bind(Object target){
        this.target = target;
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }

    /**
     * 定义代理类执行逻辑
     * @param proxy bind方法生成的代理对象
     * @param method 当前调度方法
     * @param args 调度方法的参数
     * @return 方法返回值
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before method");
        // 这里的ret是方法实际的返回值
        Object ret = method.invoke(target,args);
        System.out.println("after method");
        return ret;
    }
}

public class Test1 {

    public static void main(String[] args){
        ComputeService proxy =(ComputeService) new JDKProxySample().bind(new ComputeServiceImpl());
        proxy.add(1,4);
    }
}

public class CglibProxySample implements MethodInterceptor {

    public Object bind(Object target){
        Enhancer enhancer = new Enhancer();
        // 设置父类
        enhancer.setSuperclass(target.getClass());
        // 设置回调，在调用父类方法时，回调 this.intercept()
        enhancer.setCallback(this);
        // 创建代理对象
        return enhancer.create();
    }

    /**
     *
     * @param o 代理对象
     * @param method 方法
     * @param objects 方法参数
     * @param methodProxy 方法代理
     * @return 返回值
     * @throws Throwable
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("before method");
        Object ret = methodProxy.invokeSuper(o,objects);
        System.out.println("after method");
        return ret;
    }
}

public class Test2 {

    public static void main(String[] args){
        ComputeService proxy =(ComputeService) new CglibProxySample().bind(new ComputeServiceImpl());
        proxy.add(1,4);
    }
}

@Documented – 注解是否将包含在JavaDoc中
@Retention – 什么时候使用该注解
@Target – 注解用于什么地方
@Inherited – 是否允许子类继承该注解

RetentionPolicy.SOURCE : 在编译阶段丢弃。这些注解在编译结束之后就不再有任何意义，所以它们不会写入字节码。@Override, @SuppressWarnings都属于这类注解。
RetentionPolicy.CLASS : 在类加载的时候丢弃。在字节码文件的处理中有用。注解默认使用这种方式。
RetentionPolicy.RUNTIME : 始终不会丢弃，运行期也保留该注解，因此可以使用反射机制读取该注解的信息。我们自定义的注解通常使用这种方式。

ElementType.CONSTRUCTOR: 用于描述构造器
ElementType.FIELD: 成员变量、对象、属性（包括enum实例）
ElementType.LOCAL_VARIABLE: 用于描述局部变量
ElementType.METHOD: 用于描述方法
ElementType.PACKAGE: 用于描述包
ElementType.PARAMETER: 用于描述参数
ElementType.TYPE: 用于描述类、接口(包括注解类型) 或enum声明

/**
 * 水果名称注解
 */
@Target(FIELD)
@Retention(RUNTIME)
@Documented
public @interface FruitName {
    String value() default "";
}

/**
 * 水果颜色注解
 */
@Target(FIELD)
@Retention(RUNTIME)
@Documented
public @interface FruitColor {
    /**
     * 颜色枚举
     */
    public enum Color{BLUE,RED,GREEN};

    /**
     * 颜色属性
     */
    Color fruitColor() default Color.GREEN;

}

/**
 * 水果供应者注解
 */
@Target(FIELD)
@Retention(RUNTIME)
@Documented
public @interface FruitProvider {
    /**
     * 供应商编号
     */
    public int id() default -1;

    /**
     * 供应商名称
     */
    public String name() default "";

    /**
     * 供应商地址
     */
    public String address() default "";
}

/**
 * 注解处理器
 */
public class FruitInfoUtil {
    public static void getFruitInfo(Class<?> clazz){

        String strFruitName=" 水果名称：";
        String strFruitColor=" 水果颜色：";
        String strFruitProvicer="供应商信息：";

        Field[] fields = clazz.getDeclaredFields();

        for(Field field :fields){
            if(field.isAnnotationPresent(FruitName.class)){
                FruitName fruitName = (FruitName) field.getAnnotation(FruitName.class);
                strFruitName=strFruitName+fruitName.value();
                System.out.println(strFruitName);
            }
            else if(field.isAnnotationPresent(FruitColor.class)){
                FruitColor fruitColor= (FruitColor) field.getAnnotation(FruitColor.class);
                strFruitColor=strFruitColor+fruitColor.fruitColor().toString();
                System.out.println(strFruitColor);
            }
            else if(field.isAnnotationPresent(FruitProvider.class)){
                FruitProvider fruitProvider= (FruitProvider) field.getAnnotation(FruitProvider.class);
                strFruitProvicer=" 供应商编号："+fruitProvider.id()+" 供应商名称："+fruitProvider.name()+" 供应商地址："+fruitProvider.address();
                System.out.println(strFruitProvicer);
            }
        }
    }
}

/**
 * 注解使用
 */
public class Apple {

    @FruitName("Apple")
    private String appleName;

    @FruitColor(fruitColor=Color.RED)
    private String appleColor;

    @FruitProvider(id=1,name="陕西红富士集团",address="陕西省西安市延安路89号红富士大厦")
    private String appleProvider;

    public void setAppleColor(String appleColor) {
        this.appleColor = appleColor;
    }
    public String getAppleColor() {
        return appleColor;
    }

    public void setAppleName(String appleName) {
        this.appleName = appleName;
    }
    public String getAppleName() {
        return appleName;
    }

    public void setAppleProvider(String appleProvider) {
        this.appleProvider = appleProvider;
    }
    public String getAppleProvider() {
        return appleProvider;
    }

    public void displayName(){
        System.out.println("水果的名字是：苹果");
    }
}

/**
 * 输出结果
 */
public class FruitRun {
    public static void main(String[] args) {
        FruitInfoUtil.getFruitInfo(Apple.class);
    }
}

运行结果是：

水果名称：Apple
水果颜色：RED
供应商编号：1 供应商名称：陕西红富士集团 供应商地址：陕西省西安市延安路89号红富士大厦

(1)page:代表页面上下文，范围是一个页面及其静态包含的内容。
(2)request:代表请求上下文，范围是一个请求涉及的几个页面，通常是一个页面和其包含的内容以及forward动作转向的页面。
(3)session:代表客户的一次会话上下文，范围是一个用户在会话有效期内多次请求所涉及的页面。
(4)application:全局作用域，代表Web应用程序上下文，范围是整个Web应用中所有请求所涉及的页面。

pageContext:网页的属性在这里管理。
page：表示从该页面产生的一个servlet实例。
out：是javax.jsp.JspWriter的一个实例，并提供了几个方法使你能用于向浏览器回送输出结果。
config：表示一个javax.servlet.ServletConfig对象，该对象用于存取servlet实例的初始化参数。
request:表示HttpServletRequest对象，它包含了有关浏览器请求的信息，并且提供了几个用于获取cookie,header和session数据的有用方法。
response:表示HttpServletResponse对象，并提供了几个用于设置送回浏览器的响应的方法（如cookies,头信息等。）
session：表示一个请求的javax.servlet.http.HttpSession对象，session可以存储用户的状态信息。
application:表示一个javax.servlet.ServletContext对象，这有助于查找有关servlet引擎和servlet环境的信息。
exception：针对错误网页，未捕捉的例外。

Filter1.doFilter()的chain.doFilter(request, response)之前逻辑
Filter2.doFilter()的chain.doFilter(request, response)之前逻辑
Interceptor1.preHandle()
Interceptor2.preHandle()
正常业务逻辑
Interceptor2.postHandle()
Interceptor1.postHandle()
Interceptor2.afterCompletion()
Interceptor1.afterCompletion()
Filter2.doFilter()的chain.doFilter(request, response)之后逻辑
Filter1.doFilter()的chain.doFilter(request, response)之后逻辑

<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
    version="2.4">
    <servlet>
            <servlet-name>ShoppingServlet</servlet-name>
            <servlet-class>com.myTest.ShoppingServlet</servlet-class>
    </servlet>

    <servlet-mapping>
            <servlet-name>ShoppingServlet</servlet-name>
            <url-pattern>/shop/ShoppingServlet</url-pattern>
    </servlet-mapping>
</web-app>

// 扩展 HttpServlet 类
public class ShoppingServlet extends HttpServlet {

  public void doGet(HttpServletRequest request,
                    HttpServletResponse response)
            throws ServletException, IOException{
   
  }
  
  public void doPost(HttpServletRequest request,
                    HttpServletResponse response)
            throws ServletException, IOException{
   
  }
}

package cn.zhanghao90.wsserver.service;

import javax.jws.WebMethod;

@javax.jws.WebService
public interface WebService {
	@WebMethod
	String sayHello(String word);
}

package cn.zhanghao90.wsserver.service;

@javax.jws.WebService
public class WebServiceImpl implements WebService {

	@Override
	public String sayHello(String word) {
		String ret = "hello " + word;
		return ret;
	}

}

package cn.zhanghao90.wsserver.controller;

import javax.xml.ws.Endpoint;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class HomeController {
	
	@RequestMapping("/index")
	public String index() {
		return "demo";
	}
	
	@RequestMapping("/publish")
	public void publish(){
		String address = "http://localhost:8082/wsserver/webservice";
		Endpoint.publish(address,new cn.zhanghao90.wsserver.service.WebServiceImpl());
		System.out.println("success publish");
	}
	
}

wsimport -s D:\zhanghao\work\spare\workspace\ws_spare\wsclient\src\main\java -p cn.zhanghao90.wsclient.ws -keep http://localhost:8082/wsserver/webservice?wsdl

package cn.zhanghao90.wsclient.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import cn.zhanghao90.wsclient.util.JsonUtil;
import cn.zhanghao90.wsclient.ws.WebServiceImpl;
import cn.zhanghao90.wsclient.ws.WebServiceImplService;
import cn.zhanghao90.wsclient.wsglfil.FileSendManageWSImpl;
import cn.zhanghao90.wsclient.wsglfil.FileSendManageWSImplService;

@Controller
public class HomeController {

	@RequestMapping("/call")
	public String call(String ret){
		WebServiceImplService webServiceImplService = new WebServiceImplService();
		WebServiceImpl port = webServiceImplService.getWebServiceImplPort();
		String retString = port.sayHello("world");
		return retString;
	}	
}

ofNullable()
of()
isPresent()
orElse()
get()

import java.util.Optional;

public class Java8Tester {
    public static void main(String args[]){
    
          Java8Tester java8Tester = new Java8Tester();
          Integer value1 = null;
          Integer value2 = new Integer(10);
            
          // Optional.ofNullable - 允许传递为 null 参数
          Optional<Integer> a = Optional.ofNullable(value1);
            
          // Optional.of - 如果传递的参数是 null，抛出异常 NullPointerException
          Optional<Integer> b = Optional.of(value2);
          System.out.println(java8Tester.sum(a,b));
    }
    
    public Integer sum(Optional<Integer> a, Optional<Integer> b){
    
          // Optional.isPresent - 判断值是否存在
            
          System.out.println("第一个参数值存在: " + a.isPresent());
          System.out.println("第二个参数值存在: " + b.isPresent());
            
          // Optional.orElse - 如果值存在，返回它，否则返回默认值
          Integer value1 = a.orElse(new Integer(0));
            
          //Optional.get - 获取值，值需要存在
          Integer value2 = b.get();
          return value1 + value2;
    }
}

@Test
public void listDistinctByStreamDistinct() {
  // 1. 对于 String 列表去重
  List<String> stringList = new ArrayList<String>() ;
  out.print("去重前：");
  for (String s : stringList) {
    out.print(s);
  }
  out.println();
  stringList = stringList.stream().distinct().collect(Collectors.toList());
  out.print("去重后：");
  for (String s : stringList) {
    out.print(s);
  }
  out.println();
}

@Data
public class Student {
  private String stuNo;
  private String name;
}

@Test
public void listDistinctByStreamDistinct() throws JsonProcessingException {
    ObjectMapper objectMapper = new ObjectMapper();
    // 1. 对于Student列表去重
    List<Student> studentList = getStudentList();
    out.print("去重前：");
    out.println(objectMapper.writeValueAsString(studentList));
    studentList = studentList.stream().distinct().collect(Collectors.toList());
    out.print("去重后：");
    out.println(objectMapper.writeValueAsString(studentList));
 }

(a)stream不存储数据，而是按照特定的规则对数据进行计算，一般会输出结果；
(b)stream不会改变数据源，通常情况下会产生一个新的集合；
(c)stream具有延迟执行特性，只有调用终端操作时，中间操作才会执行。
(d)对stream操作分为终端操作和中间操作，那么这两者分别代表什么呢？终端操作：会消费流，这种操作会产生一个结果的，如果一个流被消费过了，那它就不能被重用的。中间操作：中间操作会产生另一个流。因此中间操作可以用来创建执行一系列动作的管道。一个特别需要注意的点是：中间操作不是立即发生的。相反，当在中间操作创建的新流上执行完终端操作后，中间操作指定的操作才会发生。所以中间操作是延迟发生的，中间操作的延迟行为主要是让流API能够更加高效地执行。
(e)stream不可复用，对一个已经进行过终端操作的流再次调用，会抛出异常。

public static void main(String[] args) {
    //1.通过Arrays.stream
    //1.1基本类型
    int[] arr = new int[]{1,2,34,5};
    IntStream intStream = Arrays.stream(arr);
    //1.2引用类型
    Student[] studentArr = new Student[]{new Student("s1",29),new Student("s2",27)};
    Stream<Student> studentStream = Arrays.stream(studentArr);
    //2.通过Stream.of
    Stream<Integer> stream1 = Stream.of(1,2,34,5,65);
    //注意生成的是int[]的流
    Stream<int[]> stream2 = Stream.of(arr,arr);
    stream2.forEach(System.out::println);
}

public static void main(String[] args) {
    List<String> strs = Arrays.asList("11212","dfd","2323","dfhgf");
    //创建普通流
    Stream<String> stream  = strs.stream();
    //创建并行流
    Stream<String> stream1 = strs.parallelStream();
}

// 普通类型筛选
 List<Integer> collect = intList.stream().filter(x -> x > 7).collect(Collectors.toList());
// 引用类型筛选
 List<Person> collect = personList.stream().filter(x -> x.getSalary() > 8000).collect(Collectors.toList());
 // 匹配第一个
 Optional<Integer> findFirst = list.stream().filter(x -> x > 6).findFirst();
 // 匹配任意（适用于并行流）
 Optional<Integer> findAny = list.parallelStream().filter(x -> x > 6).findAny();
 // 是否包含
 boolean anyMatch = list.stream().anyMatch(x -> x < 6);

// 获取String集合中最长的元素
Optional<String> max = list.stream().max(Comparator.comparing(String::length));
// 获取Integer集合中的最大值
Optional<Integer> reduce = list.stream().max(new Comparator<Integer>() {
  @Override
  public int compare(Integer o1, Integer o2) {
      return o1.compareTo(o2);
  }
 });
// 对象集合最值（Person见演示数据）
Optional<Person> max = list.stream().max(Comparator.comparingInt(Person::getSalary));
// count
long count = list.stream().filter(x -> x > 6).count();

////////////////////////////////////////////////////////
// 缩减操作，就是把一个流缩减成一个值，比如对一个集合求和、求乘积等。
List<Integer> list = Arrays.asList(1, 3, 2);
// 求和
Integer sum = list.stream().reduce(1, (x, y) -> x + y);
// 结果是7，也就是list元素求和再加上1
System.out.println(sum);
// 写法2
Integer sum2 = list.stream().reduce(1, Integer::sum);
System.out.println(sum2);  // 结果：7
   
// 求最值
Integer max = list.stream().reduce(6, (x, y) -> x > y ? x : y);
System.out.println(max);  // 结果：6
// 写法2
Integer max2 = list.stream().reduce(1, Integer::max);
System.out.println(max2); // 结果：3

// 对象集合求和、求最值：
System.out.println(personList.stream().map(Person::getSalary).reduce(Integer::sum));
// 求最值-方式1
Person person = personList.stream().reduce((p1, p2) -> p1.getSalary() > p2.getSalary() ? p1 : p2).get();
// 预期结果：Lily:9000
System.out.println(person.getName() + ":" + person.getSalary());
// 求最值-方式2
System.out.println(personList.stream().map(Person::getSalary).reduce(Integer::max));
// 求最值-方式3：
System.out.println(personList.stream().max(Comparator.comparingInt(Person::getSalary)).get().getSalary());

////////////////////////////////////////////////////////
// 收集（collect）
// averaging系列，averagingDouble、averagingInt、averagingLong三个方法处理过程是相同的，都是返回stream的平均值，只是返回结果的类型不同。
Double averageSalary = personList.stream().collect(Collectors.averagingDouble(Person::getSalary));

// summarizing系列，summarizingDouble、summarizingInt、summarizingLong三个方法可以返回stream的一个统计结果map，不同之处也是结果map中的value类型不一样，分别是double、int、long类型。
DoubleSummaryStatistics collect = personList.stream().collect(Collectors.summarizingDouble(Person::getSalary));
System.out.println(collect);
// 输出结果：
// DoubleSummaryStatistics{count=3, sum=24900.000000, min=7000.000000, average=8300.000000, max=9000.000000}

//joining，joining可以将stream中的元素用特定的连接符（没有的话，则直接连接）连接成一个字符串。
String names = personList.stream().map(p -> p.getName()).collect(Collectors.joining(","));

// reduce
Integer sumSalary = personList.stream().collect(Collectors.reducing(0, Person::getSalary, (i, j) -> i + j));
Optional<Integer> sumSalary2 = list.stream().map(Person::getSalary).reduce(Integer::sum);

//groupingBy方法可以将stream中的元素按照规则进行分组，类似mysql中groupBy语句。 
// 单级分组
Map<String, List<Person>> group = personList.stream().collect(Collectors.groupingBy(Person::getName));
// 多级分组：先以name分组，再以salary分组：
Map<String, Map<Integer, List<Person>>> group2 = personList.stream().collect(Collectors.groupingBy(Person::getName, Collectors.groupingBy(Person::getSalary)));

//Collectors内置的toList等方法可以十分便捷地将stream中的元素收集成想要的集合，是一个非常常用的功能，通常会配合filter、map等方法使用。
// toList
List<String> names = personList.stream().map(Person::getName).collect(Collectors.toList());
// toSet
Set<String> names2 = personList.stream().map(Person::getName).collect(Collectors.toSet());
// toMap
Map<String, Person> personMap = personList.stream().collect(Collectors.toMap(Person::getName, p -> p));

// 数据>>数据
Arrays.stream(strArr).map(x -> x.toUpperCase()).forEach(System.out::println);
// 对象集合>>数据
personList.stream().map(person -> person.getSalary()).forEach(System.out::println);
// 对象集合>>对象集合
// 这种写法改变了原有的personList。
List<Person> collect = personList.stream().map(person -> {
    person.setName(person.getName());
    person.setSalary(person.getSalary() + 10000);
    return person;
}).collect(Collectors.toList());
System.out.println(collect.get(0).getSalary());
System.out.println(personList.get(0).getSalary());
// 这种写法并未改变原有personList。
List<Person> collect2 = personList.stream().map(person -> {
    Person personNew = new Person(null, 0);
    personNew.setName(person.getName());
    personNew.setSalary(person.getSalary() + 10000);
    return personNew;
}).collect(Collectors.toList());
System.out.println(collect2.get(0).getSalary());
System.out.println(personList.get(0).getSalary());

// 自然排序
Arrays.stream(strArr).sorted().collect(Collectors.toList())
// 自定义排序
// 1、按长度自然排序，即长度从小到大
Arrays.stream(strArr).sorted(Comparator.comparing(String::length)).forEach(System.out::println);
// 2、按长度倒序，即长度从大到小
Arrays.stream(strArr).sorted(Comparator.comparing(String::length).reversed()).forEach(System.out::println);
// 3、首字母倒序
Arrays.stream(strArr).sorted(Comparator.reverseOrder()).forEach(System.out::println);
// 4、首字母自然排序
Arrays.stream(strArr).sorted(Comparator.naturalOrder()).forEach(System.out::println);

// 可以把两个stream合并成一个stream（合并的stream类型必须相同）,只能两两合并
Stream.concat(stream1,stream2).distinct().forEach(System.out::println);
// limit，限制从流中获得前n个数据
Stream.iterate(1,x->x+2).limit(10).forEach(System.out::println);
// skip，跳过前n个数据
Stream.iterate(1,x->x+2).skip(1).limit(5).forEach(System.out::println);