ZonedDateTime是带有时区的，也就是说除了内部的时间戳，还有一个时区字段。他可以指定当前字符串代表的时间是什么时区的时间。

LocalDateTime是不带时区的，他的内部保存的是LocalDate和LocalTime，它使用年、月、日、小时、分钟、秒和纳秒等字段来表示日期和时间的不同部分。LocalDateTime不能指定时区，所以在执行时区转换的时候，需要借助ZonedDateTime。

Date内部是使用一个时间戳表示时间的。在转换成Date的时候需要指定时区，这样转换之后的时间戳才是正确的。

LocalDateTime在生成的时候已经隐式包含了时区（字符串是什么时区的时间他就是什么时区的时间），Date在生成的时候需要指定时区（字符串+指定时区才是Date真正表示的时间），也就是Date可以让同一个字符串用不同的时区进行转换，LocalDateTime则不能。

localDateTime.toEpochSecond(ZoneOffset.of(“+8”)) 是生成时间戳，ZoneOffset的目的是，将时间戳输出为对应时区下，本实例所代表的时间X的时间戳，如果localDateTime是+2时区的时间字符串A，使用ZoneOffset.of(“+8”)之后得到的结果，再以+8时区转换成时间字符串，也是A，也就是抹掉了时区保持不同时区下时间字符串是一样的

回溯算法求全排列

46. 全排列

求下一个字典序更大的排列，先从后面开始遍历找到第一个递减元素位置i，然后再找到比这个元素第一小的那个元素，然后进行交换，最后把这个i位置后面的进行反转，就可以了。
31. 下一个排列

排列组合

1. 所有元素的全排列: ab的全排列是ab, ba(顺序相关)
2. 所有元素的全组合: ab的全组合是a, b, ab(顺序无关)
3. 求n个元素中选取m个元素的排列方式有哪些: abc中选2个元素的排列是ab, ba, ac, ca, bc, cb
4. 求n个元素中选取m个元素的组合方式有哪些: abc中选2个元素的组合是ab, ac, bc
   
   
   求全组合的算法

public static void arranges(char[] c) {
    int length = c.length;
    //nBit相当于2的n次方
    int nBit = 1 << length;
    for (int i = 1; i < nBit; i++) {
        System.out.println("组合数值" + i + "对应编码为：");
        //这里相当于读取i的二进制的1的位置，映射到c数组的元素
        for (int j = 0; j < length; j++) {
            int temp = 1 << j;
            if ((temp & i) != 0) {
                System.out.print(c[j]);
            }
        }
    }
}

基本思路：

求全组合，则假设原有元素n个，则最终组合结果是2ⁿ个。

原因是：

用位操作方法：假设元素原本有：a,b,c三个，则1表示取该元素，0表示不取。故去a则是001，取ab则是011.所以一共三位，每个位上有两个选择0,1.所以是2ⁿ个结果。
这些结果的位图值都是0,1,2…2ⁿ。所以可以类似全真表一样，从值0到值2ⁿ依次输出结果：即 000,001,010,011,100,101,110,111 。对应输出组合结果为：空,a, b ,ab,c,ac,bc,abc. 这个输出顺序刚好跟数字0~2ⁿ结果递增顺序一样
取法的二进制数其实就是从0到2^n-1的十进制数

两个线程轮流打印1到100的实现方式

public class MultiThreadPrint {

    //两个线程交替打印1到100
    //使用lock版本
    private static final Lock lock = new ReentrantLock();
    private static final AtomicInteger sum = new AtomicInteger(0);
    private static final AtomicBoolean flag = new AtomicBoolean(true);

    public void printWithLock() throws InterruptedException {
        Thread threadOne = new Thread(() -> {
            while (sum.get() < 100) {
                if (flag.get()) {
                    try {
                        lock.lock();
                        System.out.println(Thread.currentThread().getName() + ":" + sum.incrementAndGet());
                        flag.getAndSet(!flag.get());
                    } finally {
                        lock.unlock();
                    }
                }
            }
        }, "threadOne-");
        Thread threadTwo = new Thread(() -> {
            while (sum.get() < 100) {
                if (!flag.get()) {
                    try {
                        lock.lock();
                        System.out.println(Thread.currentThread().getName() + ":" + sum.incrementAndGet());
                        flag.getAndSet(!flag.get());
                    } finally {
                        lock.unlock();
                    }
                }
            }
        }, "threadTwo-");
        threadOne.start();
        threadTwo.start();
        threadOne.join();
        threadTwo.join();
    }

    //使用notify()和wait()实现
    public void printWithNotify() throws InterruptedException {
        //这里必须是一个print
        Print print = new Print();
        Thread one = new Thread(print, "ThreadOne-");
        Thread two = new Thread(print, "ThreadTwo-");
        one.start();
        two.start();
        one.join();
        two.join();
    }

    static class Print implements Runnable {
        private volatile int i = 0;

        @Override
        public void run() {
            while (true) {
                synchronized (this) {
                    notify();
                    if (i < 100) {
                        i++;
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                    } else {
                        break;
                    }
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

元素固定，求最大面积，用双指针。仔细想想也是有道理的，每次移动最矮的那个，尽量保证剩下的元素尽可能的高，又要尽可能的长距离。
11. 盛最多水的容器

中心扩展法计算最长回文字符串
5. 最长回文子串

滑动窗口计算最长无重复子串长度
重点是map，要保存的是字符串不重复的位置，也就是当前位置的下一个位置
滑动窗口的start位置一定是比当前重复元素位置要大的，所以有一个重新赋值的判断
3. 无重复字符的最长子串

两数相加，没啥别的办法，就加就行，注意进位。
2. 两数相加

有序数组元素的二分查找
34. 在排序数组中查找元素的第一个和最后一个位置