/**
 * The number of key-value mappings contained in this map.
 */
transient int size;

public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;··············①
}

final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    if ((tab = table) != null && (n = tab.length) > 0 &&························②
        (first = tab[(n - 1) & hash]) != null) {································③④
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))·········⑤
            return first;
        if ((e = first.next) != null) {
            if (first instanceof TreeNode)······································⑥
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);···········⑦
            do {
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))·····⑧
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

final int getState();
final void setState();
final boolean compareAndSetState();

public abstract class AbstractOwnableSynchronizer implements java.io.Serializable {
    private static final long serialVersionUID = 3737899427754241961L;
    protected AbstractOwnableSynchronizer() { }

    /**
     * 目前持有独占锁的线程
     * The current owner of exclusive mode synchronization.
     */
    private transient Thread exclusiveOwnerThread;

    /**
     * 此项用于设置上述属性的值
     * Sets the thread that currently owns exclusive access.
     * A {@code null} argument indicates that no thread owns access.
     * This method does not otherwise impose any synchronization or
     * {@code volatile} field accesses.
     * @param thread the owner thread
     */
    protected final void setExclusiveOwnerThread(Thread thread) {
        exclusiveOwnerThread = thread; 
    }

    /**
     * 此项用于获取上述属性的值
     * Returns the thread last set by {@code setExclusiveOwnerThread},
     * or {@code null} if never set.  This method does not otherwise
     * impose any synchronization or {@code volatile} field accesses.
     * @return the owner thread
     */
    protected final Thread getExclusiveOwnerThread() {
        return exclusiveOwnerThread;
    }
}

public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer
    implements java.io.Serializable {

    private static final long serialVersionUID = 7373984972572414691L;

    protected AbstractQueuedSynchronizer() { }

    /**
     * Head of the wait queue, lazily initialized.  Except for
     * initialization, it is modified only via method setHead.  Note:
     * If head exists, its waitStatus is guaranteed not to be
     * CANCELLED.
     */
    private transient volatile Node head;

    /**
     * Tail of the wait queue, lazily initialized.  Modified only via
     * method enq to add new wait node.
     */
    private transient volatile Node tail;

    /**
     * The synchronization state.
     */
    private volatile int state;

    /**
     * Returns the current value of synchronization state.
     * This operation has memory semantics of a {@code volatile} read.
     * @return current state value
     */
    protected final int getState() {
        return state;
    }

    /**
     * Sets the value of synchronization state.
     * This operation has memory semantics of a {@code volatile} write.
     * @param newState the new state value
     */
    protected final void setState(int newState) {
        state = newState;
    }

    /**
     * Atomically sets synchronization state to the given updated
     * value if the current state value equals the expected value.
     * This operation has memory semantics of a {@code volatile} read
     * and write.
     *
     * @param expect the expected value
     * @param update the new value
     * @return {@code true} if successful. False return indicates that the actual
     *         value was not equal to the expected value.
     */
    protected final boolean compareAndSetState(int expect, int update) {
        // See below for intrinsics setup to support this
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
    }

    // Queuing utilities

    /**
     * The number of nanoseconds for which it is faster to spin
     * rather than to use timed park. A rough estimate suffices
     * to improve responsiveness with very short timeouts.
     */
    static final long spinForTimeoutThreshold = 1000L;
    
}

static final class Node {
    /** 共享 -- 共享锁 */
    static final Node SHARED = new Node();
    /** 排他 -- 独占锁 */     
    static final Node EXCLUSIVE = null;
    /** 当前等待的线程可能因为其他原因而取消 */
    static final int CANCELLED =  1;
    /** 下一个节点需要被唤醒 */
    static final int SIGNAL    = -1;

    /** 用于条件队列 */
    static final int CONDITION = -2;
    /** 用于共享锁 */
    static final int PROPAGATE = -3;

    volatile int waitStatus; // 初始化为0，枚举值使用上面的值

    /**
     * 前驱节点
     */
    volatile Node prev;

    /**
     * 后继节点
     */
    volatile Node next;

    /**
     * The thread that enqueued this node.  Initialized on
     * construction and nulled out after use.
     */
    volatile Thread thread;

    /**
     * 在条件队列指向的是下一个指针
     * 在同步队列中指向的是我们当前节点想获取的是共享锁还是排他锁
     */
    Node nextWaiter;

    /**
     * Returns true if node is waiting in shared mode.
     */
    final boolean isShared() {
        return nextWaiter == SHARED;
    }

    /**
     * Returns previous node, or throws NullPointerException if null.
     * Use when predecessor cannot be null.  The null check could
     * be elided, but is present to help the VM.
     *
     * @return the predecessor of this node
     */
    final Node predecessor() throws NullPointerException {
        Node p = prev;
        if (p == null)
            throw new NullPointerException();
        else
            return p;
    }

    Node() {    // Used to establish initial head or SHARED marker
    }

    Node(Thread thread, Node mode) {     // Used by addWaiter
        this.nextWaiter = mode;
        this.thread = thread;
    }

    Node(Thread thread, int waitStatus) { // Used by Condition
        this.waitStatus = waitStatus;
        this.thread = thread;
    }
}

Lock lock = new ReentrantLock();
lock.lock();

public void lock() {
    sync.lock();
}

static final class NonfairSync extends Sync {
    private static final long serialVersionUID = 7316153563782823691L;

    /**
    * Performs lock.  Try immediate barge, backing up to normal
    * acquire on failure.
    */
    final void lock() {
        if (compareAndSetState(0, 1)) // expect: 0（无锁）  update: 1（已经有一个线程加锁）如果大于1，则代表同一个线程多次加锁
            setExclusiveOwnerThread(Thread.currentThread()); // 如果成功获取锁，那么把当前线程设置为 持有锁的线程
        else
            acquire(1);// 如果获取锁失败，我们知道，如果一个线程多次获取锁，其实就是一个自增的情况（每次加 1）
    }

    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

protected boolean tryAcquire(int arg) {
    throw new UnsupportedOperationException();
}

final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread(); // 拿到当前线程
    int c = getState(); // 拿到状态
    if (c == 0) { 		// 没有加锁（state == 0）
        if (compareAndSetState(0, acquires)) { // 通过尝试使用CAS加锁
            setExclusiveOwnerThread(current);  // 设置当前线程持有锁
            return true;// 获取成功
        }
    }
    // 判断是不是重入锁，如果 当前持有锁的线程 是 当前线程
    else if (current == getExclusiveOwnerThread()) {
        // 尝试重入，在ReentrantLock中 acquire 其实就是1，有一次重入就加一
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            // 为什么会出现这个问题呢，因为如果重入次数过多超过int的最大值，此时再加1就会变成最小值（负数）
            throw new Error("Maximum lock count exceeded");
        setState(nextc); // 设置重入值
        return true;
    }
    return false;
}

// 方法签名
acquireQueued(addWaiter(Node.EXCLUSIVE), arg)

// 没有打包的节点会被封装保存到队列里面
private Node addWaiter(Node mode) {
    Node node = new Node(Thread.currentThread(), mode);
    // Try the fast path of enq; backup to full enq on failure
    Node pred = tail; // AQS的尾指针
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    enq(node);
    return node;
}
// 如果尾结点为空
private Node enq(final Node node) {
    // 死循环，不断自旋
    for (;;) {
        Node t = tail;
        if (t == null) { // Must initialize
            if (compareAndSetHead(new Node())) // 通过CAS将虚拟头节点设置为头节点
                tail = head;
        } else {
            node.prev = t;
            if (compareAndSetTail(t, node)) {  // 还是要通过CAS的方式设置尾指针
                t.next = node;
                return t; // 不断自旋，只有进入了else分支才会return出去
            }
        }
    }
}

// 方法定义（其实就是把获取锁失败的线程node给添加同步队列里面去）
final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;			 // 是否获取锁成功
    try {
        boolean interrupted = false; // 在获取锁期间是否发送中断
        for (;;) {
            final Node p = node.predecessor();  // 前驱节点
            if (p == head && tryAcquire(arg)) { // 是否为头节点
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            if (shouldParkAfterFailedAcquire(p, node) && // 不可响应中断
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

/** 当前等待的线程可能因为其他原因而取消 */
static final int CANCELLED =  1;
/** 下一个节点需要被唤醒 */
static final int SIGNAL    = -1;
/** 用于条件队列 */
static final int CONDITION = -2;
/** 用于共享锁 */
static final int PROPAGATE = -3;

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL) // 前驱节点是SIGNAL则阻塞当前操作
        /*
         * This node has already set status asking a release
         * to signal it, so it can safely park.
         */
        return true;
    if (ws > 0) { // 不是多余的，因为其他的锁实现也是要走当前情况的
        /*
         * Predecessor was cancelled. Skip over predecessors and
         * indicate retry.
         */
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        /*
         * waitStatus must be 0 or PROPAGATE.  Indicate that we
         * need a signal, but don't park yet.  Caller will need to
         * retry to make sure it cannot acquire before parking.
         */
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

// Interface
public interface IHello {
    public void hello();
    public void bye();
}

// Implement
public class HelloImpl implements IHello{
    @Override
    public void hello() {
        System.out.println("Hello");
    }
    @Override
    public void bye() {
        System.out.println("Bye");
    }
}

public class ProxyHandler implements InvocationHandler {
    private Object target; // 目标类

    public ProxyHandler(Object target) {
        this.target = target; // $Proxy01: hello()  Bye()
    }
    // 生成代理对象方法
    public Object createProxy(){
        // JDK中提供了 Proxy类, 有一个方法专门用于根据接口生成代理类对象的方法
        Object proxy = Proxy.newProxyInstance(ProxyHandler.class.getClassLoader(),
                target.getClass().getInterfaces(),
                this);
        return proxy;  // $Proxy01  Hello()  Bye()
    }

    /**
     * @param proxy 代理对象 $Proxy01
     * @param method 调用的方法   hello()
     * @param args 方法的参数值
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 解释  @Pointcut("execution(* com.hang..add*(..))")
        if(method.getName().equalsIgnoreCase("hello")){
            // 增强
            showTime();
        }
        // 利用反射机制调用目标类的目标方法
        Object reflectObj = method.invoke(target, args); //  HelloImpl.Hello()   目标类的方法

        return reflectObj;
    }
    // 增强的方法
    private void showTime() {
        System.out.println("当前时间为: " + new Date());
    }
}

public class Main {
    public static void main(String[] args) {
        // 在本地生成代理对象字节码文件
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
        IHello target = new HelloImpl();  // 目标类
        ProxyHandler handler = new ProxyHandler(target);
        // 生成代理类
        Object proxy = handler.createProxy();
        System.out.println(proxy); // Proxy0对象

        IHello obj = (IHello) proxy;
        obj.hello();  // $ Proxy0.Hello()
        obj.bye();
    }
}

System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");

public final class $Proxy0 extends Proxy implements IHello {
    private static Method m1;
    private static Method m4;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final void bye() throws  {
        try {
            super.h.invoke(this, m4, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void hello() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
	// 省略equals,toString,hashCode三方法同上(为默认生成)

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m4 = Class.forName("com.hang.IHello").getMethod("bye");
            m3 = Class.forName("com.hang.IHello").getMethod("hello");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

List<String> ns= Arrays.asList("calyee blog","cal","ccaaalyyyyeeee");
ArrayList<String> names = new ArrayList<>(ns);
Predicate<String> predicate = s -> s.length() > 3;  // 谓词
names.removeIf(predicate);

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
    // 仅列出一个 (其他的还有比如或运算)
    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }
}

default void forEach(Consumer<? super T> action) {
    Objects.requireNonNull(action);
    for (T t : this) {
        action.accept(t);
    }
}

// Function
public void loop(Consumer<Integer>before,
                  Consumer<Integer> after){
    recursion(head,before，after);
}
private void recursion(Node curr,
                       Consumer<Integer> before,
                       Consumer<Integer> after){
    if （curr ==null）
        return;
    before.accept(curr.value); // 前置增强
    recursion(curr.next，before，after);
    after.accept(curr.value);  // 后置增强
}
// Test
@Test
public void test(){
    Node node = new Node(); // 假装默认有几个初始化
    node.loop(
    	before->{
            // Operation
        },
        after->{
            // Operation
        }
    )
}

Map<Integer, List<ByYearInnerDataVO>> optimizedData = yearIndicatorData.entrySet().stream()
    .collect(Collectors.toMap(Map.Entry::getKey,
        entry -> {
            Set<String> indicator = yearAndIndicator.keySet(); // 指标对应年份 -- 即补充标准
            return indicator.stream() 		// 创建指标集合的流
                    .map(indicatorName -> { // 对每个指标名进行处理
                        return entry.getValue().stream() // 获取当前年份的内部数据列表的流
                                .filter(i -> indicatorName.equals(i.getIndicatorName())) // 过滤出匹配指标名的数据（按照补充标准）
                                .findFirst()       // 找到第一个匹配的数据(则不需要处理，使用原有数据即可)
                                .orElseGet(() -> { // 如果没有找到，则创建并返回一个新的ByYearInnerDataVO实例
                                    return new ByYearInnerDataVO()
                                            .setIndicatorName(indicatorName) // 设置指标名
                                            .setCount("0")
                                            .setRate("/")
                                            .setIncr("/")
                                            .setValue(0);
                                }); // 补充空数据
                    }).collect(Collectors.toList()); // 将结果收集成列表
        }
    ));

indicator.stream().map(indicatorName -> {
    	Indicator i = new Indicator();
        // 数据处理
    	return i;
    }).collect(Collectors.toList()); // 将结果收集成列表

Map<Integer, List<OurBean>> groupByYear = 
list.stream().collect(Collectors.groupingBy(OurBean::getYear));

int result = IntStream.of(arr).min().getAsInt(); // 通过intstream流获取arr数组的最小值并且获取

// 如果list.get(i)为空，那么就是执行后面的语句
Optional.ofNullable(list.get(i)).orElse(new Obj());
// 如果byId.getIpInfo()不为空，那么则得到创建的ip，否null
blackIP(Optional.ofNullable(byId.getIpInfo()).map(IpInfo::getCreateIp).orElse(null));

// 用法一
BigDecimal a = new BigDecimal(0.01);
// 用法二
BigDecimal b = BigDecimal.valueOf(0.01);

public static BigDecimal valueOf(double val) {
    return new BigDecimal(Double.toString(val));
}

BigDecimal a = new BigDecimal("1.0");
BigDecimal b = new BigDecimal("3.0");

a.divide(b);

BigDecimal c = a.divide(b, 4,RoundingMode.HALF_UP);

BigDecimal a = new BigDecimal("0.01");
BigDecimal b = new BigDecimal("0.010");

a.equals(b)
a.compareTo(b)

@Override
public boolean equals(Object x) {
    if (!(x instanceof BigDecimal))
        return false;
    BigDecimal xDec = (BigDecimal) x;
    if (x == this)
        return true;
    if (scale != xDec.scale) // 如果精度不一样,直接false
        return false;
    long s = this.intCompact;
    long xs = xDec.intCompact;
    if (s != INFLATED) {
        if (xs == INFLATED)
            xs = compactValFor(xDec.intVal);
        return xs == s;
    } else if (xs != INFLATED)
        return xs == compactValFor(this.intVal);

    return this.inflated().equals(xDec.inflated());
}

NumberFormat currency = NumberFormat.getCurrencyInstance(); //建立货币格式化引用
NumberFormat percent = NumberFormat.getPercentInstance();  //建立百分比格式化引用
percent.setMaximumFractionDigits(4); //百分比小数点最多4位
 
BigDecimal loanAmount = new BigDecimal("59988.24"); //金额
BigDecimal interestRate = new BigDecimal("0.007"); //利率
BigDecimal interest = loanAmount.multiply(interestRate); //相乘

System.out.println("金额:\t" + currency.format(loanAmount));
System.out.println("利率:\t" + percent.format(interestRate));
System.out.println("利息:\t" + currency.format(interest));