+ * As much as is reasonably practical, the hashCode method defined by + * class {@code Object} does return distinct integers for distinct + * objects. (This is typically implemented by converting the internal + * address of the object into an integer, but this implementation + * technique is not required by the + * Java™ programming language.) + * + * @return a hash code value for this object. + * @see java.lang.Object#equals(java.lang.Object) + * @see java.lang.System#identityHashCode + */ + public native int hashCode(); +``` + +散列表存储的是键值对(key-value)，它的特点是：能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码！（可以快速找到所需要的对象） + +### 为什么要有hashCode + + +**我们以“HashSet如何检查重复”为例子来说明为什么要有hashCode：** + +当你把对象加入HashSet时，HashSet会先计算对象的hashcode值来判断对象加入的位置，同时也会与其他已经加入的对象的hashcode值作比较，如果没有相符的hashcode，HashSet会假设对象没有重复出现。但是如果发现有相同hashcode值的对象，这时会调用equals（）方法来检查hashcode相等的对象是否真的相同。如果两者相同，HashSet就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。（摘自我的Java启蒙书《Head fist java》第二版）。这样我们就大大减少了equals的次数，相应就大大提高了执行速度。 + + + +### hashCode（）与equals（）的相关规定 + +1. 如果两个对象相等，则hashcode一定也是相同的 +2. 两个对象相等,对两个对象分别调用equals方法都返回true +3. 两个对象有相同的hashcode值，它们也不一定是相等的 +4. **因此，equals方法被覆盖过，则hashCode方法也必须被覆盖** +5. hashCode()的默认行为是对堆上的对象产生独特值。如果没有重写hashCode()，则该class的两个对象无论如何都不会相等（即使这两个对象指向相同的数据） + +### 为什么两个对象有相同的hashcode值，它们也不一定是相等的？ + +在这里解释一位小伙伴的问题。以下内容摘自《Head Fisrt Java》。 + +因为hashCode() 所使用的杂凑算法也许刚好会让多个对象传回相同的杂凑值。越糟糕的杂凑算法越容易碰撞，但这也与数据值域分布的特性有关（所谓碰撞也就是指的是不同的对象得到相同的 hashCode）。 + +我们刚刚也提到了 HashSet,如果 HashSet 在对比的时候，同样的 hashcode 有多个对象，它会使用 equals() 来判断是否真的相同。也就是说 hashcode 只是用来缩小查找成本。 + +参考： + +[https://blog.csdn.net/zhzhao999/article/details/53449504](https://blog.csdn.net/zhzhao999/article/details/53449504) + +[https://www.cnblogs.com/skywang12345/p/3324958.html](https://www.cnblogs.com/skywang12345/p/3324958.html) + +[https://www.cnblogs.com/skywang12345/p/3324958.html](https://www.cnblogs.com/skywang12345/p/3324958.html) + +[https://www.cnblogs.com/Eason-S/p/5524837.html](https://www.cnblogs.com/Eason-S/p/5524837.html) + From ea129c1dbd1d714bfd33d5051848f6471ba1b4da Mon Sep 17 00:00:00 2001 From: Snailclimb Date: Fri, 8 Mar 2019 19:03:53 +0800 Subject: [PATCH 077/232] =?UTF-8?q?Create=20=E7=AC=AC=E4=BA=8C=E5=91=A8(20?= =?UTF-8?q?18-8-13).md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 修改文件夹名字 --- ...254\344\272\214\345\221\250(2018-8-13).md" | 200 ++++++++++++++++++ 1 file changed, 200 insertions(+) create mode 100644 "\351\235\242\350\257\225\345\277\205\345\244\207/MostCommonJavaInterviewQuestions/\347\254\254\344\272\214\345\221\250(2018-8-13).md" diff --git "a/\351\235\242\350\257\225\345\277\205\345\244\207/MostCommonJavaInterviewQuestions/\347\254\254\344\272\214\345\221\250(2018-8-13).md" "b/\351\235\242\350\257\225\345\277\205\345\244\207/MostCommonJavaInterviewQuestions/\347\254\254\344\272\214\345\221\250(2018-8-13).md" new file mode 100644 index 00000000000..426498cb2d9 --- /dev/null +++ "b/\351\235\242\350\257\225\345\277\205\345\244\207/MostCommonJavaInterviewQuestions/\347\254\254\344\272\214\345\221\250(2018-8-13).md" @@ -0,0 +1,200 @@ + +### String和StringBuffer、StringBuilder的区别是什么？String为什么是不可变的？ + +#### String和StringBuffer、StringBuilder的区别 + +**可变性** +　 + +简单的来说：String 类中使用 final 关键字字符数组保存字符串，`private　final　char　value[]`，所以 String 对象是不可变的。而StringBuilder 与 StringBuffer 都继承自 AbstractStringBuilder 类，在 AbstractStringBuilder 中也是使用字符数组保存字符串`char[]value` 但是没有用 final 关键字修饰，所以这两种对象都是可变的。 + +StringBuilder 与 StringBuffer 的构造方法都是调用父类构造方法也就是 AbstractStringBuilder 实现的，大家可以自行查阅源码。 + +AbstractStringBuilder.java + +```java +abstract class AbstractStringBuilder implements Appendable, CharSequence { + char[] value; + int count; + AbstractStringBuilder() { + } + AbstractStringBuilder(int capacity) { + value = new char[capacity]; + } +``` + + +**线程安全性** + +String 中的对象是不可变的，也就可以理解为常量，线程安全。AbstractStringBuilder 是 StringBuilder 与 StringBuffer 的公共父类，定义了一些字符串的基本操作，如 expandCapacity、append、insert、indexOf 等公共方法。StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder 并没有对方法进行加同步锁，所以是非线程安全的。 +　　 + +**性能** + +每次对 String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象。StringBuffer 每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下使用 StirngBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险。 + +**对于三者使用的总结：** +1. 操作少量的数据 = String +2. 单线程操作字符串缓冲区下操作大量数据 = StringBuilder +3. 多线程操作字符串缓冲区下操作大量数据 = StringBuffer + +#### String为什么是不可变的吗？ +简单来说就是String类利用了final修饰的char类型数组存储字符，源码如下图所以： + +```java + /** The value is used for character storage. */ + private final char value[]; +``` + +#### String真的是不可变的吗？ +我觉得如果别人问这个问题的话，回答不可变就可以了。 +下面只是给大家看两个有代表性的例子： + +**1) String不可变但不代表引用不可以变** +```java + String str = "Hello"; + str = str + " World"; + System.out.println("str=" + str); +``` +结果： +``` +str=Hello World +``` +解析： + +实际上，原来String的内容是不变的，只是str由原来指向"Hello"的内存地址转为指向"Hello World"的内存地址而已，也就是说多开辟了一块内存区域给"Hello World"字符串。 + +**2) 通过反射是可以修改所谓的“不可变”对象** + +```java + // 创建字符串"Hello World"， 并赋给引用s + String s = "Hello World"; + + System.out.println("s = " + s); // Hello World + + // 获取String类中的value字段 + Field valueFieldOfString = String.class.getDeclaredField("value"); + + // 改变value属性的访问权限 + valueFieldOfString.setAccessible(true); + + // 获取s对象上的value属性的值 + char[] value = (char[]) valueFieldOfString.get(s); + + // 改变value所引用的数组中的第5个字符 + value[5] = '_'; + + System.out.println("s = " + s); // Hello_World +``` + +结果： + +``` +s = Hello World +s = Hello_World +``` + +解析： + +用反射可以访问私有成员， 然后反射出String对象中的value属性， 进而改变通过获得的value引用改变数组的结构。但是一般我们不会这么做，这里只是简单提一下有这个东西。 + +### 什么是反射机制？反射机制的应用场景有哪些？ + +#### 反射机制介绍 + +JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 + +#### 静态编译和动态编译 + +- **静态编译：**在编译时确定类型，绑定对象 +- **动态编译：**运行时确定类型，绑定对象 + +#### 反射机制优缺点 + +- **优点：** 运行期类型的判断，动态加载类，提高代码灵活度。 +- **缺点：** 性能瓶颈：反射相当于一系列解释操作，通知 JVM 要做的事情，性能比直接的java代码要慢很多。 + +#### 反射的应用场景 + +反射是框架设计的灵魂。 + +在我们平时的项目开发过程中，基本上很少会直接使用到反射机制，但这不能说明反射机制没有用，实际上有很多设计、开发都与反射机制有关，例如模块化的开发，通过反射去调用对应的字节码；动态代理设计模式也采用了反射机制，还有我们日常使用的 Spring／Hibernate 等框架也大量使用到了反射机制。 + +举例：①我们在使用JDBC连接数据库时使用Class.forName()通过反射加载数据库的驱动程序；②Spring框架也用到很多反射机制，最经典的就是xml的配置模式。Spring 通过 XML 配置模式装载 Bean 的过程：1) 将程序内所有 XML 或 Properties 配置文件加载入内存中; + 2)Java类里面解析xml或properties里面的内容，得到对应实体类的字节码字符串以及相关的属性信息; 3)使用反射机制，根据这个字符串获得某个类的Class实例; 4)动态配置实例的属性 + +**推荐阅读：** + +- [Reflection：Java反射机制的应用场景](https://segmentfault.com/a/1190000010162647?utm_source=tuicool&utm_medium=referral) +- [Java基础之—反射（非常重要）](https://blog.csdn.net/sinat_38259539/article/details/71799078) +### 什么是JDK?什么是JRE？什么是JVM？三者之间的联系与区别 + +这几个是Java中很基本很基本的东西，但是我相信一定还有很多人搞不清楚！为什么呢？因为我们大多数时候在使用现成的编译工具以及环境的时候，并没有去考虑这些东西。 + +**JDK:** 顾名思义它是给开发者提供的开发工具箱,是给程序开发者用的。它除了包括完整的JRE（Java Runtime Environment），Java运行环境，还包含了其他供开发者使用的工具包。 + +**JRE:** 普通用户而只需要安装JRE（Java Runtime Environment）来运行Java程序。而程序开发者必须安装JDK来编译、调试程序。 + +**JVM：** 当我们运行一个程序时，JVM负责将字节码转换为特定机器代码，JVM提供了内存管理/垃圾回收和安全机制等。这种独立于硬件和操作系统，正是java程序可以一次编写多处执行的原因。 + +**区别与联系：** + + 1. JDK用于开发，JRE用于运行java程序 ； + 2. JDK和JRE中都包含JVM ； + 3. JVM是java编程语言的核心并且具有平台独立性。 + +### 什么是字节码？采用字节码的最大好处是什么？ + +**先看下java中的编译器和解释器：** 　　 + +Java中引入了虚拟机的概念，即在机器和编译程序之间加入了一层抽象的虚拟的机器。这台虚拟的机器在任何平台上都提供给编译程序一个的共同的接口。编译程序只需要面向虚拟机，生成虚拟机能够理解的代码，然后由解释器来将虚拟机代码转换为特定系统的机器码执行。在Java中，这种供虚拟机理解的代码叫做`字节码`（即扩展名为`.class`的文件），它不面向任何特定的处理器，只面向虚拟机。每一种平台的解释器是不同的，但是实现的虚拟机是相同的。Java源程序经过编译器编译后变成字节码，字节码由虚拟机解释执行，虚拟机将每一条要执行的字节码送给解释器，解释器将其翻译成特定机器上的机器码，然后在特定的机器上运行。这也就是解释了Java的编译与解释并存的特点。 + + Java源代码---->编译器---->jvm可执行的Java字节码(即虚拟指令)---->jvm---->jvm中解释器----->机器可执行的二进制机器码---->程序运行。 + +**采用字节码的好处：** 　　 + +Java语言通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题，同时又保留了解释型语言可移植的特点。所以Java程序运行时比较高效，而且，由于字节码并不专对一种特定的机器，因此，Java程序无须重新编译便可在多种不同的计算机上运行。 + +### Java和C++的区别 + +我知道很多人没学过C++，但是面试官就是没事喜欢拿咱们Java和C++比呀！没办法！！！就算没学过C++，也要记下来！ + +- 都是面向对象的语言，都支持封装、继承和多态 +- Java不提供指针来直接访问内存，程序内存更加安全 +- Java的类是单继承的，C++支持多重继承；虽然Java的类不可以多继承，但是接口可以多继承。 +- Java有自动内存管理机制，不需要程序员手动释放无用内存 + + +### 接口和抽象类的区别是什么？ + +1. 接口的方法默认是public，所有方法在接口中不能有实现，抽象类可以有非抽象的方法 +2. 接口中的实例变量默认是final类型的，而抽象类中则不一定 +3. 一个类可以实现多个接口，但最多只能实现一个抽象类 +4. 一个类实现接口的话要实现接口的所有方法，而抽象类不一定 +5. 接口不能用new实例化，但可以声明，但是必须引用一个实现该接口的对象 从设计层面来说，抽象是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为的规范。 + +注意：Java8 后接口可以有默认实现( default )。 + +### 成员变量与局部变量的区别有那些？ + +1. 从语法形式上，看成员变量是属于类的，而局部变量是在方法中定义的变量或是方法的参数；成员变量可以被public,private,static等修饰符所修饰，而局部变量不能被访问控制修饰符及static所修饰；但是，成员变量和局部变量都能被final所修饰； +2. 从变量在内存中的存储方式来看，成员变量是对象的一部分，而对象存在于堆内存，局部变量存在于栈内存 +3. 从变量在内存中的生存时间上看，成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动消失。 +4. 成员变量如果没有被赋初值，则会自动以类型的默认值而赋值（一种情况例外被final修饰但没有被static修饰的成员变量必须显示地赋值）；而局部变量则不会自动赋值。 + +### 重载和重写的区别 + +**重载：** 发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同，发生在编译时。 　　 + +**重写：** 发生在父子类中，方法名、参数列表必须相同，返回值范围小于等于父类，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类；如果父类方法访问修饰符为private则子类就不能重写该方法。 + +### 字符型常量和字符串常量的区别 +1) 形式上: +字符常量是单引号引起的一个字符 +字符串常量是双引号引起的若干个字符 +2) 含义上: +字符常量相当于一个整形值(ASCII值),可以参加表达式运算 +字符串常量代表一个地址值(该字符串在内存中存放位置) +3) 占内存大小 +字符常量只占一个字节 +字符串常量占若干个字节(至少一个字符结束标志) From bc4cec733f38fe334223369ba8d2a6e3aea36e9e Mon Sep 17 00:00:00 2001 From: Snailclimb Date: Fri, 8 Mar 2019 19:03:58 +0800 Subject: [PATCH 078/232] =?UTF-8?q?Create=20=E7=AC=AC=E5=9B=9B=E5=91=A8(20?= =?UTF-8?q?18-8-30).md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 修改文件夹名字 --- ...254\345\233\233\345\221\250(2018-8-30).md" | 195 ++++++++++++++++++ 1 file changed, 195 insertions(+) create mode 100644 "\351\235\242\350\257\225\345\277\205\345\244\207/MostCommonJavaInterviewQuestions/\347\254\254\345\233\233\345\221\250(2018-8-30).md" diff --git "a/\351\235\242\350\257\225\345\277\205\345\244\207/MostCommonJavaInterviewQuestions/\347\254\254\345\233\233\345\221\250(2018-8-30).md" "b/\351\235\242\350\257\225\345\277\205\345\244\207/MostCommonJavaInterviewQuestions/\347\254\254\345\233\233\345\221\250(2018-8-30).md" new file mode 100644 index 00000000000..3cb02d73d5b --- /dev/null +++ "b/\351\235\242\350\257\225\345\277\205\345\244\207/MostCommonJavaInterviewQuestions/\347\254\254\345\233\233\345\221\250(2018-8-30).md" @@ -0,0 +1,195 @@ + +## 1. 简述线程，程序、进程的基本概念。以及他们之间关系是什么？ + +**线程**与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。 + +**程序**是含有指令和数据的文件，被存储在磁盘或其他的数据存储设备中，也就是说程序是静态的代码。 + +**进程**是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。简单来说，一个进程就是一个执行中的程序，它在计算机中一个指令接着一个指令地执行着，同时，每个进程还占有某些系统资源如CPU时间，内存空间，文件，文件，输入输出设备的使用权等等。换句话说，当程序在执行时，将会被操作系统载入内存中。 + +**线程** 是 **进程** 划分成的更小的运行单位。线程和进程最大的不同在于基本上各进程是独立的，而各线程则不一定，因为同一进程中的线程极有可能会相互影响。从另一角度来说，进程属于操作系统的范畴，主要是同一段时间内，可以同时执行一个以上的程序，而线程则是在同一程序内几乎同时执行一个以上的程序段。 + +**线程上下文的切换比进程上下文切换要快很多** + +- 进程切换时，涉及到当前进程的CPU环境的保存和新被调度运行进程的CPU环境的设置。 +- 线程切换仅需要保存和设置少量的寄存器内容，不涉及存储管理方面的操作。 + +## 2. 线程有哪些基本状态？这些状态是如何定义的? + +1. **新建(new)**：新创建了一个线程对象。 +2. **可运行(runnable)**：线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获 取cpu的使用权。 +3. **运行(running)**：可运行状态(runnable)的线程获得了cpu时间片（timeslice），执行程序代码。 +4. **阻塞(block)**：阻塞状态是指线程因为某种原因放弃了cpu使用权，也即让出了cpu timeslice，暂时停止运行。直到线程进入可运行(runnable)状态，才有 机会再次获得cpu timeslice转到运行(running)状态。阻塞的情况分三种： + - **(一). 等待阻塞**：运行(running)的线程执行o.wait()方法，JVM会把该线程放 入等待队列(waiting queue)中。 + - **(二). 同步阻塞**：运行(running)的线程在获取对象的同步锁时，若该同步 锁 被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。 + - **(三). 其他阻塞**: 运行(running)的线程执行Thread.sleep(long ms)或t.join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入可运行(runnable)状态。 +5. **死亡(dead)**：线程run()、main()方法执行结束，或者因异常退出了run()方法，则该线程结束生命周期。死亡的线程不可再次复生。 + + + +备注： 可以用早起坐地铁来比喻这个过程（下面参考自牛客网某位同学的回答）： + +1. 还没起床：sleeping +2. 起床收拾好了，随时可以坐地铁出发：Runnable +3. 等地铁来：Waiting +4. 地铁来了，但要排队上地铁：I/O阻塞 +5. 上了地铁，发现暂时没座位：synchronized阻塞 +6. 地铁上找到座位：Running +7. 到达目的地：Dead + + +## 3. 何为多线程？ + +多线程就是多个线程同时运行或交替运行。单核CPU的话是顺序执行，也就是交替运行。多核CPU的话，因为每个CPU有自己的运算器，所以在多个CPU中可以同时运行。 + + +## 4. 为什么多线程是必要的？ + +1. 使用线程可以把占据长时间的程序中的任务放到后台去处理。 +2. 用户界面可以更加吸引人，这样比如用户点击了一个按钮去触发某些事件的处理，可以弹出一个进度条来显示处理的进度。 +3. 程序的运行速度可能加快。 + +## 5 使用多线程常见的三种方式 + +### ①继承Thread类 + +MyThread.java + +```java +public class MyThread extends Thread { + @Override + public void run() { + super.run(); + System.out.println("MyThread"); + } +} +``` +Run.java + +```java +public class Run { + + public static void main(String[] args) { + MyThread mythread = new MyThread(); + mythread.start(); + System.out.println("运行结束"); + } + +} + +``` +运行结果： + +从上面的运行结果可以看出：线程是一个子任务，CPU以不确定的方式，或者说是以随机的时间来调用线程中的run方法。 + +### ②实现Runnable接口 +推荐实现Runnable接口方式开发多线程，因为Java单继承但是可以实现多个接口。 + +MyRunnable.java + +```java +public class MyRunnable implements Runnable { + @Override + public void run() { + System.out.println("MyRunnable"); + } +} +``` + +Run.java + +```java +public class Run { + + public static void main(String[] args) { + Runnable runnable=new MyRunnable(); + Thread thread=new Thread(runnable); + thread.start(); + System.out.println("运行结束！"); + } + +} +``` +运行结果： + + +### ③使用线程池 + +**在《阿里巴巴Java开发手册》“并发处理”这一章节，明确指出线程资源必须通过线程池提供，不允许在应用中自行显示创建线程。** + +**为什么呢？** + +> **使用线程池的好处是减少在创建和销毁线程上所消耗的时间以及系统资源开销，解决资源不足的问题。如果不使用线程池，有可能会造成系统创建大量同类线程而导致消耗完内存或者“过度切换”的问题。** + +**另外《阿里巴巴Java开发手册》中强制线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险** + +> Executors 返回线程池对象的弊端如下： +> +> - **FixedThreadPool 和 SingleThreadExecutor** ： 允许请求的队列长度为 Integer.MAX_VALUE,可能堆积大量的请求，从而导致OOM。 +> - **CachedThreadPool 和 ScheduledThreadPool** ： 允许创建的线程数量为 Integer.MAX_VALUE ，可能会创建大量线程，从而导致OOM。 + +对于线程池感兴趣的可以查看我的这篇文章：[《Java多线程学习（八）线程池与Executor 框架》](http://mp.weixin.qq.com/s?__biz=MzU4NDQ4MzU5OA==&mid=2247484042&idx=1&sn=541dbf2cb969a151d79f4a4f837ee1bd&chksm=fd9854ebcaefddfd1876bb96ab218be3ae7b12546695a403075d4ed22e5e17ff30ebdabc8bbf#rd) 点击阅读原文即可查看到该文章的最新版。 + + +## 6 线程的优先级 + +每个线程都具有各自的优先级，**线程的优先级可以在程序中表明该线程的重要性，如果有很多线程处于就绪状态，系统会根据优先级来决定首先使哪个线程进入运行状态**。但这个并不意味着低 +优先级的线程得不到运行，而只是它运行的几率比较小，如垃圾回收机制线程的优先级就比较低。所以很多垃圾得不到及时的回收处理。 + +**线程优先级具有继承特性。** 比如A线程启动B线程，则B线程的优先级和A是一样的。 + +**线程优先级具有随机性。** 也就是说线程优先级高的不一定每一次都先执行完。 + +Thread类中包含的成员变量代表了线程的某些优先级。如**Thread.MIN_PRIORITY（常数1）**，**Thread.NORM_PRIORITY（常数5）**, +**Thread.MAX_PRIORITY（常数10）**。其中每个线程的优先级都在**Thread.MIN_PRIORITY（常数1）** 到**Thread.MAX_PRIORITY（常数10）** 之间，在默认情况下优先级都是**Thread.NORM_PRIORITY（常数5）**。 + +学过操作系统这门课程的话，我们可以发现多线程优先级或多或少借鉴了操作系统对进程的管理。 + + +## 7 Java多线程分类 + +### 用户线程 + +运行在前台，执行具体的任务，如程序的主线程、连接网络的子线程等都是用户线程 + +### 守护线程 + +运行在后台，为其他前台线程服务.也可以说守护线程是JVM中非守护线程的 **“佣人”**。 + + +- **特点：** 一旦所有用户线程都结束运行，守护线程会随JVM一起结束工作 +- **应用：** 数据库连接池中的检测线程，JVM虚拟机启动后的检测线程 +- **最常见的守护线程：** 垃圾回收线程 + + +**如何设置守护线程？** + +可以通过调用 Thead 类的 `setDaemon(true)` 方法设置当前的线程为守护线程。 + +注意事项： + + 1. setDaemon(true)必须在start（）方法前执行，否则会抛出IllegalThreadStateException异常 + 2. 在守护线程中产生的新线程也是守护线程 + 3. 不是所有的任务都可以分配给守护线程来执行，比如读写操作或者计算逻辑 + + +## 8 sleep()方法和wait()方法简单对比 + +- 两者最主要的区别在于：**sleep方法没有释放锁，而wait方法释放了锁** 。 +- 两者都可以暂停线程的执行。 +- Wait通常被用于线程间交互/通信，sleep通常被用于暂停执行。 +- wait()方法被调用后，线程不会自动苏醒，需要别的线程调用同一个对象上的notify()或者notifyAll()方法。sleep()方法执行完成后，线程会自动苏醒。 + + +## 9 为什么我们调用start()方法时会执行run()方法，为什么我们不能直接调用run()方法？ + +这是另一个非常经典的java多线程面试问题，而且在面试中会经常被问到。很简单，但是很多人都会答不上来！ + +new一个Thread，线程进入了新建状态;调用start()方法，会启动一个线程并使线程进入了就绪状态，当分配到时间片后就可以开始运行了。 +start()会执行线程的相应准备工作，然后自动执行run()方法的内容，这是真正的多线程工作。 而直接执行run()方法，会把run方法当成一个mian线程下的普通方法去执行，并不会在某个线程中执行它，所以这并不是多线程工作。 + +**总结： 调用start方法方可启动线程并使线程进入就绪状态，而run方法只是thread的一个普通方法调用，还是在主线程里执行。** + + + + From 5a62e9024d9191092fc4b21172fa3470ad724950 Mon Sep 17 00:00:00 2001 From: Snailclimb Date: Fri, 8 Mar 2019 19:04:10 +0800 Subject: [PATCH 079/232] =?UTF-8?q?Delete=20=E7=AC=AC=E4=B8=80=E5=91=A8?= =?UTF-8?q?=EF=BC=882018-8-7=EF=BC=89.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...21\250\357\274\2102018-8-7\357\274\211.md" | 253 ------------------ 1 file changed, 253 deletions(-) delete mode 100644 "\351\235\242\350\257\225\345\277\205\345\244\207/\346\234\200\346\234\200\346\234\200\345\270\270\350\247\201\347\232\204Java\351\235\242\350\257\225\351\242\230\346\200\273\347\273\223/\347\254\254\344\270\200\345\221\250\357\274\2102018-8-7\357\274\211.md" diff --git "a/\351\235\242\350\257\225\345\277\205\345\244\207/\346\234\200\346\234\200\346\234\200\345\270\270\350\247\201\347\232\204Java\351\235\242\350\257\225\351\242\230\346\200\273\347\273\223/\347\254\254\344\270\200\345\221\250\357\274\2102018-8-7\357\274\211.md" "b/\351\235\242\350\257\225\345\277\205\345\244\207/\346\234\200\346\234\200\346\234\200\345\270\270\350\247\201\347\232\204Java\351\235\242\350\257\225\351\242\230\346\200\273\347\273\223/\347\254\254\344\270\200\345\221\250\357\274\2102018-8-7\357\274\211.md" deleted file mode 100644 index 4ca58dbfff6..00000000000 --- "a/\351\235\242\350\257\225\345\277\205\345\244\207/\346\234\200\346\234\200\346\234\200\345\270\270\350\247\201\347\232\204Java\351\235\242\350\257\225\351\242\230\346\200\273\347\273\223/\347\254\254\344\270\200\345\221\250\357\274\2102018-8-7\357\274\211.md" +++ /dev/null @@ -1,253 +0,0 @@ - - -## 一 为什么 Java 中只有值传递？ - - -首先回顾一下在程序设计语言中有关将参数传递给方法（或函数）的一些专业术语。**按值调用(call by value)表示方法接收的是调用者提供的值，而按引用调用（call by reference)表示方法接收的是调用者提供的变量地址。一个方法可以修改传递引用所对应的变量值，而不能修改传递值调用所对应的变量值。** 它用来描述各种程序设计语言（不只是Java)中方法参数传递方式。 - -**Java程序设计语言总是采用按值调用。也就是说，方法得到的是所有参数值的一个拷贝，也就是说，方法不能修改传递给它的任何参数变量的内容。** - -**下面通过 3 个例子来给大家说明** - -### example 1 - - -```java -public static void main(String[] args) { - int num1 = 10; - int num2 = 20; - - swap(num1, num2); - - System.out.println("num1 = " + num1); - System.out.println("num2 = " + num2); -} - -public static void swap(int a, int b) { - int temp = a; - a = b; - b = temp; - - System.out.println("a = " + a); - System.out.println("b = " + b); -} -``` - -**结果：** - -``` -a = 20 -b = 10 -num1 = 10 -num2 = 20 -``` - -**解析：** - - - -在swap方法中，a、b的值进行交换，并不会影响到 num1、num2。因为，a、b中的值，只是从 num1、num2 的复制过来的。也就是说，a、b相当于num1、num2 的副本，副本的内容无论怎么修改，都不会影响到原件本身。 - -**通过上面例子，我们已经知道了一个方法不能修改一个基本数据类型的参数，而对象引用作为参数就不一样，请看 example2.** - - -### example 2 - -```java - public static void main(String[] args) { - int[] arr = { 1, 2, 3, 4, 5 }; - System.out.println(arr[0]); - change(arr); - System.out.println(arr[0]); - } - - public static void change(int[] array) { - // 将数组的第一个元素变为0 - array[0] = 0; - } -``` - -**结果：** - -``` -1 -0 -``` - -**解析：** - - - -array 被初始化 arr 的拷贝也就是一个对象的引用，也就是说 array 和 arr 指向的时同一个数组对象。 因此，外部对引用对象的改变会反映到所对应的对象上。 - - -**通过 example2 我们已经看到，实现一个改变对象参数状态的方法并不是一件难事。理由很简单，方法得到的是对象引用的拷贝，对象引用及其他的拷贝同时引用同一个对象。** - -**很多程序设计语言（特别是，C++和Pascal)提供了两种参数传递的方式：值调用和引用调用。有些程序员（甚至本书的作者）认为Java程序设计语言对对象采用的是引用调用，实际上，这种理解是不对的。由于这种误解具有一定的普遍性，所以下面给出一个反例来详细地阐述一下这个问题。** - - -### example 3 - -```java -public class Test { - - public static void main(String[] args) { - // TODO Auto-generated method stub - Student s1 = new Student("小张"); - Student s2 = new Student("小李"); - Test.swap(s1, s2); - System.out.println("s1:" + s1.getName()); - System.out.println("s2:" + s2.getName()); - } - - public static void swap(Student x, Student y) { - Student temp = x; - x = y; - y = temp; - System.out.println("x:" + x.getName()); - System.out.println("y:" + y.getName()); - } -} -``` - -**结果：** - -``` -x:小李 -y:小张 -s1:小张 -s2:小李 -``` - -**解析：** - -交换之前： - - - -交换之后： - - - - -通过上面两张图可以很清晰的看出： **方法并没有改变存储在变量 s1 和 s2 中的对象引用。swap方法的参数x和y被初始化为两个对象引用的拷贝，这个方法交换的是这两个拷贝** - -### 总结 - -Java程序设计语言对对象采用的不是引用调用，实际上，对象引用是按 -值传递的。 - -下面再总结一下Java中方法参数的使用情况： - -- 一个方法不能修改一个基本数据类型的参数（即数值型或布尔型》 -- 一个方法可以改变一个对象参数的状态。 -- 一个方法不能让对象参数引用一个新的对象。 - - -### 参考： - -《Java核心技术卷Ⅰ》基础知识第十版第四章4.5小节 - -## 二 ==与equals(重要) - -**==** : 它的作用是判断两个对象的地址是不是相等。即，判断两个对象是不是同一个对象。(基本数据类型==比较的是值，引用数据类型==比较的是内存地址) - -**equals()** : 它的作用也是判断两个对象是否相等。但它一般有两种使用情况： - -- 情况1：类没有覆盖equals()方法。则通过equals()比较该类的两个对象时，等价于通过“==”比较这两个对象。 -- 情况2：类覆盖了equals()方法。一般，我们都覆盖equals()方法来两个对象的内容相等；若它们的内容相等，则返回true(即，认为这两个对象相等)。 - - -**举个例子：** - -```java -public class test1 { - public static void main(String[] args) { - String a = new String("ab"); // a 为一个引用 - String b = new String("ab"); // b为另一个引用,对象的内容一样 - String aa = "ab"; // 放在常量池中 - String bb = "ab"; // 从常量池中查找 - if (aa == bb) // true - System.out.println("aa==bb"); - if (a == b) // false，非同一对象 - System.out.println("a==b"); - if (a.equals(b)) // true - System.out.println("aEQb"); - if (42 == 42.0) { // true - System.out.println("true"); - } - } -} -``` - -**说明：** - -- String中的equals方法是被重写过的，因为object的equals方法是比较的对象的内存地址，而String的equals方法比较的是对象的值。 -- 当创建String类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象，如果有就把它赋给当前引用。如果没有就在常量池中重新创建一个String对象。 - - - -## 三 hashCode与equals（重要） - -面试官可能会问你：“你重写过 hashcode 和 equals 么，为什么重写equals时必须重写hashCode方法？” - -### hashCode（）介绍 -hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。hashCode() 定义在JDK的Object.java中，这就意味着Java中的任何类都包含有hashCode() 函数。另外需要注意的是： Object 的 hashcode 方法是本地方法，也就是用 c 语言或 c++ 实现的，该方法通常用来将对象的 内存地址 转换为整数之后返回。 - -```java - /** - * Returns a hash code value for the object. This method is - * supported for the benefit of hash tables such as those provided by - * {@link java.util.HashMap}. - *

- * As much as is reasonably practical, the hashCode method defined by - * class {@code Object} does return distinct integers for distinct - * objects. (This is typically implemented by converting the internal - * address of the object into an integer, but this implementation - * technique is not required by the - * Java™ programming language.) - * - * @return a hash code value for this object. - * @see java.lang.Object#equals(java.lang.Object) - * @see java.lang.System#identityHashCode - */ - public native int hashCode(); -``` - -散列表存储的是键值对(key-value)，它的特点是：能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码！（可以快速找到所需要的对象） - -### 为什么要有hashCode - - -**我们以“HashSet如何检查重复”为例子来说明为什么要有hashCode：** - -当你把对象加入HashSet时，HashSet会先计算对象的hashcode值来判断对象加入的位置，同时也会与其他已经加入的对象的hashcode值作比较，如果没有相符的hashcode，HashSet会假设对象没有重复出现。但是如果发现有相同hashcode值的对象，这时会调用equals（）方法来检查hashcode相等的对象是否真的相同。如果两者相同，HashSet就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。（摘自我的Java启蒙书《Head fist java》第二版）。这样我们就大大减少了equals的次数，相应就大大提高了执行速度。 - - - -### hashCode（）与equals（）的相关规定 - -1. 如果两个对象相等，则hashcode一定也是相同的 -2. 两个对象相等,对两个对象分别调用equals方法都返回true -3. 两个对象有相同的hashcode值，它们也不一定是相等的 -4. **因此，equals方法被覆盖过，则hashCode方法也必须被覆盖** -5. hashCode()的默认行为是对堆上的对象产生独特值。如果没有重写hashCode()，则该class的两个对象无论如何都不会相等（即使这两个对象指向相同的数据） - -### 为什么两个对象有相同的hashcode值，它们也不一定是相等的？ - -在这里解释一位小伙伴的问题。以下内容摘自《Head Fisrt Java》。 - -因为hashCode() 所使用的杂凑算法也许刚好会让多个对象传回相同的杂凑值。越糟糕的杂凑算法越容易碰撞，但这也与数据值域分布的特性有关（所谓碰撞也就是指的是不同的对象得到相同的 hashCode）。 - -我们刚刚也提到了 HashSet,如果 HashSet 在对比的时候，同样的 hashcode 有多个对象，它会使用 equals() 来判断是否真的相同。也就是说 hashcode 只是用来缩小查找成本。 - -参考： - -[https://blog.csdn.net/zhzhao999/article/details/53449504](https://blog.csdn.net/zhzhao999/article/details/53449504) - -[https://www.cnblogs.com/skywang12345/p/3324958.html](https://www.cnblogs.com/skywang12345/p/3324958.html) - -[https://www.cnblogs.com/skywang12345/p/3324958.html](https://www.cnblogs.com/skywang12345/p/3324958.html) - -[https://www.cnblogs.com/Eason-S/p/5524837.html](https://www.cnblogs.com/Eason-S/p/5524837.html) - From 04f11194c62ff4c0dd161da077aecb239f21284b Mon Sep 17 00:00:00 2001 From: Snailclimb Date: Fri, 8 Mar 2019 19:04:16 +0800 Subject: [PATCH 080/232] =?UTF-8?q?Delete=20=E7=AC=AC=E4=BA=8C=E5=91=A8(20?= =?UTF-8?q?18-8-13).md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 修改文件夹名字 --- ...254\344\272\214\345\221\250(2018-8-13).md" | 200 ------------------ 1 file changed, 200 deletions(-) delete mode 100644 "\351\235\242\350\257\225\345\277\205\345\244\207/\346\234\200\346\234\200\346\234\200\345\270\270\350\247\201\347\232\204Java\351\235\242\350\257\225\351\242\230\346\200\273\347\273\223/\347\254\254\344\272\214\345\221\250(2018-8-13).md" diff --git "a/\351\235\242\350\257\225\345\277\205\345\244\207/\346\234\200\346\234\200\346\234\200\345\270\270\350\247\201\347\232\204Java\351\235\242\350\257\225\351\242\230\346\200\273\347\273\223/\347\254\254\344\272\214\345\221\250(2018-8-13).md" "b/\351\235\242\350\257\225\345\277\205\345\244\207/\346\234\200\346\234\200\346\234\200\345\270\270\350\247\201\347\232\204Java\351\235\242\350\257\225\351\242\230\346\200\273\347\273\223/\347\254\254\344\272\214\345\221\250(2018-8-13).md" deleted file mode 100644 index 426498cb2d9..00000000000 --- "a/\351\235\242\350\257\225\345\277\205\345\244\207/\346\234\200\346\234\200\346\234\200\345\270\270\350\247\201\347\232\204Java\351\235\242\350\257\225\351\242\230\346\200\273\347\273\223/\347\254\254\344\272\214\345\221\250(2018-8-13).md" +++ /dev/null @@ -1,200 +0,0 @@ - -### String和StringBuffer、StringBuilder的区别是什么？String为什么是不可变的？ - -#### String和StringBuffer、StringBuilder的区别 - -**可变性** -　 - -简单的来说：String 类中使用 final 关键字字符数组保存字符串，`private　final　char　value[]`，所以 String 对象是不可变的。而StringBuilder 与 StringBuffer 都继承自 AbstractStringBuilder 类，在 AbstractStringBuilder 中也是使用字符数组保存字符串`char[]value` 但是没有用 final 关键字修饰，所以这两种对象都是可变的。 - -StringBuilder 与 StringBuffer 的构造方法都是调用父类构造方法也就是 AbstractStringBuilder 实现的，大家可以自行查阅源码。 - -AbstractStringBuilder.java - -```java -abstract class AbstractStringBuilder implements Appendable, CharSequence { - char[] value; - int count; - AbstractStringBuilder() { - } - AbstractStringBuilder(int capacity) { - value = new char[capacity]; - } -``` - - -**线程安全性** - -String 中的对象是不可变的，也就可以理解为常量，线程安全。AbstractStringBuilder 是 StringBuilder 与 StringBuffer 的公共父类，定义了一些字符串的基本操作，如 expandCapacity、append、insert、indexOf 等公共方法。StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder 并没有对方法进行加同步锁，所以是非线程安全的。 -　　 - -**性能** - -每次对 String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象。StringBuffer 每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下使用 StirngBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险。 - -**对于三者使用的总结：** -1. 操作少量的数据 = String -2. 单线程操作字符串缓冲区下操作大量数据 = StringBuilder -3. 多线程操作字符串缓冲区下操作大量数据 = StringBuffer - -#### String为什么是不可变的吗？ -简单来说就是String类利用了final修饰的char类型数组存储字符，源码如下图所以： - -```java - /** The value is used for character storage. */ - private final char value[]; -``` - -#### String真的是不可变的吗？ -我觉得如果别人问这个问题的话，回答不可变就可以了。 -下面只是给大家看两个有代表性的例子： - -**1) String不可变但不代表引用不可以变** -```java - String str = "Hello"; - str = str + " World"; - System.out.println("str=" + str); -``` -结果： -``` -str=Hello World -``` -解析： - -实际上，原来String的内容是不变的，只是str由原来指向"Hello"的内存地址转为指向"Hello World"的内存地址而已，也就是说多开辟了一块内存区域给"Hello World"字符串。 - -**2) 通过反射是可以修改所谓的“不可变”对象** - -```java - // 创建字符串"Hello World"， 并赋给引用s - String s = "Hello World"; - - System.out.println("s = " + s); // Hello World - - // 获取String类中的value字段 - Field valueFieldOfString = String.class.getDeclaredField("value"); - - // 改变value属性的访问权限 - valueFieldOfString.setAccessible(true); - - // 获取s对象上的value属性的值 - char[] value = (char[]) valueFieldOfString.get(s); - - // 改变value所引用的数组中的第5个字符 - value[5] = '_'; - - System.out.println("s = " + s); // Hello_World -``` - -结果： - -``` -s = Hello World -s = Hello_World -``` - -解析： - -用反射可以访问私有成员， 然后反射出String对象中的value属性， 进而改变通过获得的value引用改变数组的结构。但是一般我们不会这么做，这里只是简单提一下有这个东西。 - -### 什么是反射机制？反射机制的应用场景有哪些？ - -#### 反射机制介绍 - -JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 - -#### 静态编译和动态编译 - -- **静态编译：**在编译时确定类型，绑定对象 -- **动态编译：**运行时确定类型，绑定对象 - -#### 反射机制优缺点 - -- **优点：** 运行期类型的判断，动态加载类，提高代码灵活度。 -- **缺点：** 性能瓶颈：反射相当于一系列解释操作，通知 JVM 要做的事情，性能比直接的java代码要慢很多。 - -#### 反射的应用场景 - -反射是框架设计的灵魂。 - -在我们平时的项目开发过程中，基本上很少会直接使用到反射机制，但这不能说明反射机制没有用，实际上有很多设计、开发都与反射机制有关，例如模块化的开发，通过反射去调用对应的字节码；动态代理设计模式也采用了反射机制，还有我们日常使用的 Spring／Hibernate 等框架也大量使用到了反射机制。 - -举例：①我们在使用JDBC连接数据库时使用Class.forName()通过反射加载数据库的驱动程序；②Spring框架也用到很多反射机制，最经典的就是xml的配置模式。Spring 通过 XML 配置模式装载 Bean 的过程：1) 将程序内所有 XML 或 Properties 配置文件加载入内存中; - 2)Java类里面解析xml或properties里面的内容，得到对应实体类的字节码字符串以及相关的属性信息; 3)使用反射机制，根据这个字符串获得某个类的Class实例; 4)动态配置实例的属性 - -**推荐阅读：** - -- [Reflection：Java反射机制的应用场景](https://segmentfault.com/a/1190000010162647?utm_source=tuicool&utm_medium=referral) -- [Java基础之—反射（非常重要）](https://blog.csdn.net/sinat_38259539/article/details/71799078) -### 什么是JDK?什么是JRE？什么是JVM？三者之间的联系与区别 - -这几个是Java中很基本很基本的东西，但是我相信一定还有很多人搞不清楚！为什么呢？因为我们大多数时候在使用现成的编译工具以及环境的时候，并没有去考虑这些东西。 - -**JDK:** 顾名思义它是给开发者提供的开发工具箱,是给程序开发者用的。它除了包括完整的JRE（Java Runtime Environment），Java运行环境，还包含了其他供开发者使用的工具包。 - -**JRE:** 普通用户而只需要安装JRE（Java Runtime Environment）来运行Java程序。而程序开发者必须安装JDK来编译、调试程序。 - -**JVM：** 当我们运行一个程序时，JVM负责将字节码转换为特定机器代码，JVM提供了内存管理/垃圾回收和安全机制等。这种独立于硬件和操作系统，正是java程序可以一次编写多处执行的原因。 - -**区别与联系：** - - 1. JDK用于开发，JRE用于运行java程序 ； - 2. JDK和JRE中都包含JVM ； - 3. JVM是java编程语言的核心并且具有平台独立性。 - -### 什么是字节码？采用字节码的最大好处是什么？ - -**先看下java中的编译器和解释器：** 　　 - -Java中引入了虚拟机的概念，即在机器和编译程序之间加入了一层抽象的虚拟的机器。这台虚拟的机器在任何平台上都提供给编译程序一个的共同的接口。编译程序只需要面向虚拟机，生成虚拟机能够理解的代码，然后由解释器来将虚拟机代码转换为特定系统的机器码执行。在Java中，这种供虚拟机理解的代码叫做`字节码`（即扩展名为`.class`的文件），它不面向任何特定的处理器，只面向虚拟机。每一种平台的解释器是不同的，但是实现的虚拟机是相同的。Java源程序经过编译器编译后变成字节码，字节码由虚拟机解释执行，虚拟机将每一条要执行的字节码送给解释器，解释器将其翻译成特定机器上的机器码，然后在特定的机器上运行。这也就是解释了Java的编译与解释并存的特点。 - - Java源代码---->编译器---->jvm可执行的Java字节码(即虚拟指令)---->jvm---->jvm中解释器----->机器可执行的二进制机器码---->程序运行。 - -**采用字节码的好处：** 　　 - -Java语言通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题，同时又保留了解释型语言可移植的特点。所以Java程序运行时比较高效，而且，由于字节码并不专对一种特定的机器，因此，Java程序无须重新编译便可在多种不同的计算机上运行。 - -### Java和C++的区别 - -我知道很多人没学过C++，但是面试官就是没事喜欢拿咱们Java和C++比呀！没办法！！！就算没学过C++，也要记下来！ - -- 都是面向对象的语言，都支持封装、继承和多态 -- Java不提供指针来直接访问内存，程序内存更加安全 -- Java的类是单继承的，C++支持多重继承；虽然Java的类不可以多继承，但是接口可以多继承。 -- Java有自动内存管理机制，不需要程序员手动释放无用内存 - - -### 接口和抽象类的区别是什么？ - -1. 接口的方法默认是public，所有方法在接口中不能有实现，抽象类可以有非抽象的方法 -2. 接口中的实例变量默认是final类型的，而抽象类中则不一定 -3. 一个类可以实现多个接口，但最多只能实现一个抽象类 -4. 一个类实现接口的话要实现接口的所有方法，而抽象类不一定 -5. 接口不能用new实例化，但可以声明，但是必须引用一个实现该接口的对象 从设计层面来说，抽象是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为的规范。 - -注意：Java8 后接口可以有默认实现( default )。 - -### 成员变量与局部变量的区别有那些？ - -1. 从语法形式上，看成员变量是属于类的，而局部变量是在方法中定义的变量或是方法的参数；成员变量可以被public,private,static等修饰符所修饰，而局部变量不能被访问控制修饰符及static所修饰；但是，成员变量和局部变量都能被final所修饰； -2. 从变量在内存中的存储方式来看，成员变量是对象的一部分，而对象存在于堆内存，局部变量存在于栈内存 -3. 从变量在内存中的生存时间上看，成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动消失。 -4. 成员变量如果没有被赋初值，则会自动以类型的默认值而赋值（一种情况例外被final修饰但没有被static修饰的成员变量必须显示地赋值）；而局部变量则不会自动赋值。 - -### 重载和重写的区别 - -**重载：** 发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同，发生在编译时。 　　 - -**重写：** 发生在父子类中，方法名、参数列表必须相同，返回值范围小于等于父类，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类；如果父类方法访问修饰符为private则子类就不能重写该方法。 - -### 字符型常量和字符串常量的区别 -1) 形式上: -字符常量是单引号引起的一个字符 -字符串常量是双引号引起的若干个字符 -2) 含义上: -字符常量相当于一个整形值(ASCII值),可以参加表达式运算 -字符串常量代表一个地址值(该字符串在内存中存放位置) -3) 占内存大小 -字符常量只占一个字节 -字符串常量占若干个字节(至少一个字符结束标志) From 11dea93f0ef3173df10affa3cb7791e95caf2153 Mon Sep 17 00:00:00 2001 From: Snailclimb Date: Fri, 8 Mar 2019 19:04:20 +0800 Subject: [PATCH 081/232] =?UTF-8?q?Delete=20=E7=AC=AC=E5=9B=9B=E5=91=A8(20?= =?UTF-8?q?18-8-30).md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 修改文件夹名字 --- ...254\345\233\233\345\221\250(2018-8-30).md" | 195 ------------------ 1 file changed, 195 deletions(-) delete mode 100644 "\351\235\242\350\257\225\345\277\205\345\244\207/\346\234\200\346\234\200\346\234\200\345\270\270\350\247\201\347\232\204Java\351\235\242\350\257\225\351\242\230\346\200\273\347\273\223/\347\254\254\345\233\233\345\221\250(2018-8-30).md" diff --git "a/\351\235\242\350\257\225\345\277\205\345\244\207/\346\234\200\346\234\200\346\234\200\345\270\270\350\247\201\347\232\204Java\351\235\242\350\257\225\351\242\230\346\200\273\347\273\223/\347\254\254\345\233\233\345\221\250(2018-8-30).md" "b/\351\235\242\350\257\225\345\277\205\345\244\207/\346\234\200\346\234\200\346\234\200\345\270\270\350\247\201\347\232\204Java\351\235\242\350\257\225\351\242\230\346\200\273\347\273\223/\347\254\254\345\233\233\345\221\250(2018-8-30).md" deleted file mode 100644 index 3cb02d73d5b..00000000000 --- "a/\351\235\242\350\257\225\345\277\205\345\244\207/\346\234\200\346\234\200\346\234\200\345\270\270\350\247\201\347\232\204Java\351\235\242\350\257\225\351\242\230\346\200\273\347\273\223/\347\254\254\345\233\233\345\221\250(2018-8-30).md" +++ /dev/null @@ -1,195 +0,0 @@ - -## 1. 简述线程，程序、进程的基本概念。以及他们之间关系是什么？ - -**线程**与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。 - -**程序**是含有指令和数据的文件，被存储在磁盘或其他的数据存储设备中，也就是说程序是静态的代码。 - -**进程**是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。简单来说，一个进程就是一个执行中的程序，它在计算机中一个指令接着一个指令地执行着，同时，每个进程还占有某些系统资源如CPU时间，内存空间，文件，文件，输入输出设备的使用权等等。换句话说，当程序在执行时，将会被操作系统载入内存中。 - -**线程** 是 **进程** 划分成的更小的运行单位。线程和进程最大的不同在于基本上各进程是独立的，而各线程则不一定，因为同一进程中的线程极有可能会相互影响。从另一角度来说，进程属于操作系统的范畴，主要是同一段时间内，可以同时执行一个以上的程序，而线程则是在同一程序内几乎同时执行一个以上的程序段。 - -**线程上下文的切换比进程上下文切换要快很多** - -- 进程切换时，涉及到当前进程的CPU环境的保存和新被调度运行进程的CPU环境的设置。 -- 线程切换仅需要保存和设置少量的寄存器内容，不涉及存储管理方面的操作。 - -## 2. 线程有哪些基本状态？这些状态是如何定义的? - -1. **新建(new)**：新创建了一个线程对象。 -2. **可运行(runnable)**：线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获 取cpu的使用权。 -3. **运行(running)**：可运行状态(runnable)的线程获得了cpu时间片（timeslice），执行程序代码。 -4. **阻塞(block)**：阻塞状态是指线程因为某种原因放弃了cpu使用权，也即让出了cpu timeslice，暂时停止运行。直到线程进入可运行(runnable)状态，才有 机会再次获得cpu timeslice转到运行(running)状态。阻塞的情况分三种： - - **(一). 等待阻塞**：运行(running)的线程执行o.wait()方法，JVM会把该线程放 入等待队列(waiting queue)中。 - - **(二). 同步阻塞**：运行(running)的线程在获取对象的同步锁时，若该同步 锁 被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。 - - **(三). 其他阻塞**: 运行(running)的线程执行Thread.sleep(long ms)或t.join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入可运行(runnable)状态。 -5. **死亡(dead)**：线程run()、main()方法执行结束，或者因异常退出了run()方法，则该线程结束生命周期。死亡的线程不可再次复生。 - - - -备注： 可以用早起坐地铁来比喻这个过程（下面参考自牛客网某位同学的回答）： - -1. 还没起床：sleeping -2. 起床收拾好了，随时可以坐地铁出发：Runnable -3. 等地铁来：Waiting -4. 地铁来了，但要排队上地铁：I/O阻塞 -5. 上了地铁，发现暂时没座位：synchronized阻塞 -6. 地铁上找到座位：Running -7. 到达目的地：Dead - - -## 3. 何为多线程？ - -多线程就是多个线程同时运行或交替运行。单核CPU的话是顺序执行，也就是交替运行。多核CPU的话，因为每个CPU有自己的运算器，所以在多个CPU中可以同时运行。 - - -## 4. 为什么多线程是必要的？ - -1. 使用线程可以把占据长时间的程序中的任务放到后台去处理。 -2. 用户界面可以更加吸引人，这样比如用户点击了一个按钮去触发某些事件的处理，可以弹出一个进度条来显示处理的进度。 -3. 程序的运行速度可能加快。 - -## 5 使用多线程常见的三种方式 - -### ①继承Thread类 - -MyThread.java - -```java -public class MyThread extends Thread { - @Override - public void run() { - super.run(); - System.out.println("MyThread"); - } -} -``` -Run.java - -```java -public class Run { - - public static void main(String[] args) { - MyThread mythread = new MyThread(); - mythread.start(); - System.out.println("运行结束"); - } - -} - -``` -运行结果： - -从上面的运行结果可以看出：线程是一个子任务，CPU以不确定的方式，或者说是以随机的时间来调用线程中的run方法。 - -### ②实现Runnable接口 -推荐实现Runnable接口方式开发多线程，因为Java单继承但是可以实现多个接口。 - -MyRunnable.java - -```java -public class MyRunnable implements Runnable { - @Override - public void run() { - System.out.println("MyRunnable"); - } -} -``` - -Run.java - -```java -public class Run { - - public static void main(String[] args) { - Runnable runnable=new MyRunnable(); - Thread thread=new Thread(runnable); - thread.start(); - System.out.println("运行结束！"); - } - -} -``` -运行结果： - - -### ③使用线程池 - -**在《阿里巴巴Java开发手册》“并发处理”这一章节，明确指出线程资源必须通过线程池提供，不允许在应用中自行显示创建线程。** - -**为什么呢？** - -> **使用线程池的好处是减少在创建和销毁线程上所消耗的时间以及系统资源开销，解决资源不足的问题。如果不使用线程池，有可能会造成系统创建大量同类线程而导致消耗完内存或者“过度切换”的问题。** - -**另外《阿里巴巴Java开发手册》中强制线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险** - -> Executors 返回线程池对象的弊端如下： -> -> - **FixedThreadPool 和 SingleThreadExecutor** ： 允许请求的队列长度为 Integer.MAX_VALUE,可能堆积大量的请求，从而导致OOM。 -> - **CachedThreadPool 和 ScheduledThreadPool** ： 允许创建的线程数量为 Integer.MAX_VALUE ，可能会创建大量线程，从而导致OOM。 - -对于线程池感兴趣的可以查看我的这篇文章：[《Java多线程学习（八）线程池与Executor 框架》](http://mp.weixin.qq.com/s?__biz=MzU4NDQ4MzU5OA==&mid=2247484042&idx=1&sn=541dbf2cb969a151d79f4a4f837ee1bd&chksm=fd9854ebcaefddfd1876bb96ab218be3ae7b12546695a403075d4ed22e5e17ff30ebdabc8bbf#rd) 点击阅读原文即可查看到该文章的最新版。 - - -## 6 线程的优先级 - -每个线程都具有各自的优先级，**线程的优先级可以在程序中表明该线程的重要性，如果有很多线程处于就绪状态，系统会根据优先级来决定首先使哪个线程进入运行状态**。但这个并不意味着低 -优先级的线程得不到运行，而只是它运行的几率比较小，如垃圾回收机制线程的优先级就比较低。所以很多垃圾得不到及时的回收处理。 - -**线程优先级具有继承特性。** 比如A线程启动B线程，则B线程的优先级和A是一样的。 - -**线程优先级具有随机性。** 也就是说线程优先级高的不一定每一次都先执行完。 - -Thread类中包含的成员变量代表了线程的某些优先级。如**Thread.MIN_PRIORITY（常数1）**，**Thread.NORM_PRIORITY（常数5）**, -**Thread.MAX_PRIORITY（常数10）**。其中每个线程的优先级都在**Thread.MIN_PRIORITY（常数1）** 到**Thread.MAX_PRIORITY（常数10）** 之间，在默认情况下优先级都是**Thread.NORM_PRIORITY（常数5）**。 - -学过操作系统这门课程的话，我们可以发现多线程优先级或多或少借鉴了操作系统对进程的管理。 - - -## 7 Java多线程分类 - -### 用户线程 - -运行在前台，执行具体的任务，如程序的主线程、连接网络的子线程等都是用户线程 - -### 守护线程 - -运行在后台，为其他前台线程服务.也可以说守护线程是JVM中非守护线程的 **“佣人”**。 - - -- **特点：** 一旦所有用户线程都结束运行，守护线程会随JVM一起结束工作 -- **应用：** 数据库连接池中的检测线程，JVM虚拟机启动后的检测线程 -- **最常见的守护线程：** 垃圾回收线程 - - -**如何设置守护线程？** - -可以通过调用 Thead 类的 `setDaemon(true)` 方法设置当前的线程为守护线程。 - -注意事项： - - 1. setDaemon(true)必须在start（）方法前执行，否则会抛出IllegalThreadStateException异常 - 2. 在守护线程中产生的新线程也是守护线程 - 3. 不是所有的任务都可以分配给守护线程来执行，比如读写操作或者计算逻辑 - - -## 8 sleep()方法和wait()方法简单对比 - -- 两者最主要的区别在于：**sleep方法没有释放锁，而wait方法释放了锁** 。 -- 两者都可以暂停线程的执行。 -- Wait通常被用于线程间交互/通信，sleep通常被用于暂停执行。 -- wait()方法被调用后，线程不会自动苏醒，需要别的线程调用同一个对象上的notify()或者notifyAll()方法。sleep()方法执行完成后，线程会自动苏醒。 - - -## 9 为什么我们调用start()方法时会执行run()方法，为什么我们不能直接调用run()方法？ - -这是另一个非常经典的java多线程面试问题，而且在面试中会经常被问到。很简单，但是很多人都会答不上来！ - -new一个Thread，线程进入了新建状态;调用start()方法，会启动一个线程并使线程进入了就绪状态，当分配到时间片后就可以开始运行了。 -start()会执行线程的相应准备工作，然后自动执行run()方法的内容，这是真正的多线程工作。 而直接执行run()方法，会把run方法当成一个mian线程下的普通方法去执行，并不会在某个线程中执行它，所以这并不是多线程工作。 - -**总结： 调用start方法方可启动线程并使线程进入就绪状态，而run方法只是thread的一个普通方法调用，还是在主线程里执行。** - - - - From a79c561a15d0d80f4fc7564297325db760a7a418 Mon Sep 17 00:00:00 2001 From: Snailclimb Date: Fri, 8 Mar 2019 19:07:55 +0800 Subject: [PATCH 082/232] Update change file name MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 修改文件夹名字 --- .../JavaInterviewGithub.md | 0 .../JavaProgrammerNeedKnow.md | 0 ...54\344\270\200\345\221\250\357\274\2102018-8-7\357\274\211.md" | 0 .../\347\254\254\344\272\214\345\221\250(2018-8-13).md" | 0 .../\347\254\254\345\233\233\345\221\250(2018-8-30).md" | 0 .../books.md" => EssentialContentForInterview/books.md | 0 .../interviewPrepare.md | 0 ...50\264\250\351\207\217\347\232\204\347\256\200\345\216\206.md" | 0 ...47\232\204\347\256\200\345\216\206\344\271\213\351\201\223.md" | 0 .../\347\256\200\345\216\206\346\250\241\346\235\277.md" | 0 ...50\247\201\351\227\256\351\242\230\346\200\273\347\273\223.md" | 0 ...51\224\201\344\270\216\346\202\262\350\247\202\351\224\201.md" | 0 12 files changed, 0 insertions(+), 0 deletions(-) rename "\351\235\242\350\257\225\345\277\205\345\244\207/JavaInterviewGithub.md" => EssentialContentForInterview/JavaInterviewGithub.md (100%) rename "\351\235\242\350\257\225\345\277\205\345\244\207/JavaProgrammerNeedKnow.md" => EssentialContentForInterview/JavaProgrammerNeedKnow.md (100%) rename "\351\235\242\350\257\225\345\277\205\345\244\207/MostCommonJavaInterviewQuestions/\347\254\254\344\270\200\345\221\250\357\274\2102018-8-7\357\274\211.md" => "EssentialContentForInterview/MostCommonJavaInterviewQuestions/\347\254\254\344\270\200\345\221\250\357\274\2102018-8-7\357\274\211.md" (100%) rename "\351\235\242\350\257\225\345\277\205\345\244\207/MostCommonJavaInterviewQuestions/\347\254\254\344\272\214\345\221\250(2018-8-13).md" => "EssentialContentForInterview/MostCommonJavaInterviewQuestions/\347\254\254\344\272\214\345\221\250(2018-8-13).md" (100%) rename "\351\235\242\350\257\225\345\277\205\345\244\207/MostCommonJavaInterviewQuestions/\347\254\254\345\233\233\345\221\250(2018-8-30).md" => "EssentialContentForInterview/MostCommonJavaInterviewQuestions/\347\254\254\345\233\233\345\221\250(2018-8-30).md" (100%) rename "\351\235\242\350\257\225\345\277\205\345\244\207/books.md" => EssentialContentForInterview/books.md (100%) rename "\351\235\242\350\257\225\345\277\205\345\244\207/interviewPrepare.md" => EssentialContentForInterview/interviewPrepare.md (100%) rename "\351\235\242\350\257\225\345\277\205\345\244\207/\346\211\213\346\212\212\346\211\213\346\225\231\344\275\240\347\224\250Markdown\345\206\231\344\270\200\344\273\275\351\253\230\350\264\250\351\207\217\347\232\204\347\256\200\345\216\206.md" => "EssentialContentForInterview/\346\211\213\346\212\212\346\211\213\346\225\231\344\275\240\347\224\250Markdown\345\206\231\344\270\200\344\273\275\351\253\230\350\264\250\351\207\217\347\232\204\347\256\200\345\216\206.md" (100%) rename "\351\235\242\350\257\225\345\277\205\345\244\207/\347\250\213\345\272\217\345\221\230\347\232\204\347\256\200\345\216\206\344\271\213\351\201\223.md" => "EssentialContentForInterview/\347\250\213\345\272\217\345\221\230\347\232\204\347\256\200\345\216\206\344\271\213\351\201\223.md" (100%) rename "\351\235\242\350\257\225\345\277\205\345\244\207/\347\256\200\345\216\206\346\250\241\346\235\277.md" => "EssentialContentForInterview/\347\256\200\345\216\206\346\250\241\346\235\277.md" (100%) rename "\351\235\242\350\257\225\345\277\205\345\244\207/\347\276\216\345\233\242\351\235\242\350\257\225\345\270\270\350\247\201\351\227\256\351\242\230\346\200\273\347\273\223.md" => "EssentialContentForInterview/\347\276\216\345\233\242\351\235\242\350\257\225\345\270\270\350\247\201\351\227\256\351\242\230\346\200\273\347\273\223.md" (100%) rename "\351\235\242\350\257\225\345\277\205\345\244\207/\351\235\242\350\257\225\345\277\205\345\244\207\344\271\213\344\271\220\350\247\202\351\224\201\344\270\216\346\202\262\350\247\202\351\224\201.md" => "EssentialContentForInterview/\351\235\242\350\257\225\345\277\205\345\244\207\344\271\213\344\271\220\350\247\202\351\224\201\344\270\216\346\202\262\350\247\202\351\224\201.md" (100%) diff --git "a/\351\235\242\350\257\225\345\277\205\345\244\207/JavaInterviewGithub.md" b/EssentialContentForInterview/JavaInterviewGithub.md similarity index 100% rename from "\351\235\242\350\257\225\345\277\205\345\244\207/JavaInterviewGithub.md" rename to EssentialContentForInterview/JavaInterviewGithub.md diff --git "a/\351\235\242\350\257\225\345\277\205\345\244\207/JavaProgrammerNeedKnow.md" b/EssentialContentForInterview/JavaProgrammerNeedKnow.md similarity index 100% rename from "\351\235\242\350\257\225\345\277\205\345\244\207/JavaProgrammerNeedKnow.md" rename to EssentialContentForInterview/JavaProgrammerNeedKnow.md diff --git "a/\351\235\242\350\257\225\345\277\205\345\244\207/MostCommonJavaInterviewQuestions/\347\254\254\344\270\200\345\221\250\357\274\2102018-8-7\357\274\211.md" "b/EssentialContentForInterview/MostCommonJavaInterviewQuestions/\347\254\254\344\270\200\345\221\250\357\274\2102018-8-7\357\274\211.md" similarity index 100% rename from "\351\235\242\350\257\225\345\277\205\345\244\207/MostCommonJavaInterviewQuestions/\347\254\254\344\270\200\345\221\250\357\274\2102018-8-7\357\274\211.md" rename to "EssentialContentForInterview/MostCommonJavaInterviewQuestions/\347\254\254\344\270\200\345\221\250\357\274\2102018-8-7\357\274\211.md" diff --git "a/\351\235\242\350\257\225\345\277\205\345\244\207/MostCommonJavaInterviewQuestions/\347\254\254\344\272\214\345\221\250(2018-8-13).md" "b/EssentialContentForInterview/MostCommonJavaInterviewQuestions/\347\254\254\344\272\214\345\221\250(2018-8-13).md" similarity index 100% rename from "\351\235\242\350\257\225\345\277\205\345\244\207/MostCommonJavaInterviewQuestions/\347\254\254\344\272\214\345\221\250(2018-8-13).md" rename to "EssentialContentForInterview/MostCommonJavaInterviewQuestions/\347\254\254\344\272\214\345\221\250(2018-8-13).md" diff --git "a/\351\235\242\350\257\225\345\277\205\345\244\207/MostCommonJavaInterviewQuestions/\347\254\254\345\233\233\345\221\250(2018-8-30).md" "b/EssentialContentForInterview/MostCommonJavaInterviewQuestions/\347\254\254\345\233\233\345\221\250(2018-8-30).md" similarity index 100% rename from "\351\235\242\350\257\225\345\277\205\345\244\207/MostCommonJavaInterviewQuestions/\347\254\254\345\233\233\345\221\250(2018-8-30).md" rename to "EssentialContentForInterview/MostCommonJavaInterviewQuestions/\347\254\254\345\233\233\345\221\250(2018-8-30).md" diff --git "a/\351\235\242\350\257\225\345\277\205\345\244\207/books.md" b/EssentialContentForInterview/books.md similarity index 100% rename from "\351\235\242\350\257\225\345\277\205\345\244\207/books.md" rename to EssentialContentForInterview/books.md diff --git "a/\351\235\242\350\257\225\345\277\205\345\244\207/interviewPrepare.md" b/EssentialContentForInterview/interviewPrepare.md similarity index 100% rename from "\351\235\242\350\257\225\345\277\205\345\244\207/interviewPrepare.md" rename to EssentialContentForInterview/interviewPrepare.md diff --git "a/\351\235\242\350\257\225\345\277\205\345\244\207/\346\211\213\346\212\212\346\211\213\346\225\231\344\275\240\347\224\250Markdown\345\206\231\344\270\200\344\273\275\351\253\230\350\264\250\351\207\217\347\232\204\347\256\200\345\216\206.md" "b/EssentialContentForInterview/\346\211\213\346\212\212\346\211\213\346\225\231\344\275\240\347\224\250Markdown\345\206\231\344\270\200\344\273\275\351\253\230\350\264\250\351\207\217\347\232\204\347\256\200\345\216\206.md" similarity index 100% rename from "\351\235\242\350\257\225\345\277\205\345\244\207/\346\211\213\346\212\212\346\211\213\346\225\231\344\275\240\347\224\250Markdown\345\206\231\344\270\200\344\273\275\351\253\230\350\264\250\351\207\217\347\232\204\347\256\200\345\216\206.md" rename to "EssentialContentForInterview/\346\211\213\346\212\212\346\211\213\346\225\231\344\275\240\347\224\250Markdown\345\206\231\344\270\200\344\273\275\351\253\230\350\264\250\351\207\217\347\232\204\347\256\200\345\216\206.md" diff --git "a/\351\235\242\350\257\225\345\277\205\345\244\207/\347\250\213\345\272\217\345\221\230\347\232\204\347\256\200\345\216\206\344\271\213\351\201\223.md" "b/EssentialContentForInterview/\347\250\213\345\272\217\345\221\230\347\232\204\347\256\200\345\216\206\344\271\213\351\201\223.md" similarity index 100% rename from "\351\235\242\350\257\225\345\277\205\345\244\207/\347\250\213\345\272\217\345\221\230\347\232\204\347\256\200\345\216\206\344\271\213\351\201\223.md" rename to "EssentialContentForInterview/\347\250\213\345\272\217\345\221\230\347\232\204\347\256\200\345\216\206\344\271\213\351\201\223.md" diff --git "a/\351\235\242\350\257\225\345\277\205\345\244\207/\347\256\200\345\216\206\346\250\241\346\235\277.md" "b/EssentialContentForInterview/\347\256\200\345\216\206\346\250\241\346\235\277.md" similarity index 100% rename from "\351\235\242\350\257\225\345\277\205\345\244\207/\347\256\200\345\216\206\346\250\241\346\235\277.md" rename to "EssentialContentForInterview/\347\256\200\345\216\206\346\250\241\346\235\277.md" diff --git "a/\351\235\242\350\257\225\345\277\205\345\244\207/\347\276\216\345\233\242\351\235\242\350\257\225\345\270\270\350\247\201\351\227\256\351\242\230\346\200\273\347\273\223.md" "b/EssentialContentForInterview/\347\276\216\345\233\242\351\235\242\350\257\225\345\270\270\350\247\201\351\227\256\351\242\230\346\200\273\347\273\223.md" similarity index 100% rename from "\351\235\242\350\257\225\345\277\205\345\244\207/\347\276\216\345\233\242\351\235\242\350\257\225\345\270\270\350\247\201\351\227\256\351\242\230\346\200\273\347\273\223.md" rename to "EssentialContentForInterview/\347\276\216\345\233\242\351\235\242\350\257\225\345\270\270\350\247\201\351\227\256\351\242\230\346\200\273\347\273\223.md" diff --git "a/\351\235\242\350\257\225\345\277\205\345\244\207/\351\235\242\350\257\225\345\277\205\345\244\207\344\271\213\344\271\220\350\247\202\351\224\201\344\270\216\346\202\262\350\247\202\351\224\201.md" "b/EssentialContentForInterview/\351\235\242\350\257\225\345\277\205\345\244\207\344\271\213\344\271\220\350\247\202\351\224\201\344\270\216\346\202\262\350\247\202\351\224\201.md" similarity index 100% rename from "\351\235\242\350\257\225\345\277\205\345\244\207/\351\235\242\350\257\225\345\277\205\345\244\207\344\271\213\344\271\220\350\247\202\351\224\201\344\270\216\346\202\262\350\247\202\351\224\201.md" rename to "EssentialContentForInterview/\351\235\242\350\257\225\345\277\205\345\244\207\344\271\213\344\271\220\350\247\202\351\224\201\344\270\216\346\202\262\350\247\202\351\224\201.md" From d62a018043df7b2df8ef733d5221e85f4a55a040 Mon Sep 17 00:00:00 2001 From: Snailclimb Date: Fri, 8 Mar 2019 19:11:51 +0800 Subject: [PATCH 083/232] Update change file name --- .../{ => PreparingForInterview}/JavaProgrammerNeedKnow.md | 0 EssentialContentForInterview/{ => PreparingForInterview}/books.md | 0 .../{ => PreparingForInterview}/interviewPrepare.md | 0 ...47\232\204\347\256\200\345\216\206\344\271\213\351\201\223.md" | 0 ...50\247\201\351\227\256\351\242\230\346\200\273\347\273\223.md" | 0 5 files changed, 0 insertions(+), 0 deletions(-) rename EssentialContentForInterview/{ => PreparingForInterview}/JavaProgrammerNeedKnow.md (100%) rename EssentialContentForInterview/{ => PreparingForInterview}/books.md (100%) rename EssentialContentForInterview/{ => PreparingForInterview}/interviewPrepare.md (100%) rename "EssentialContentForInterview/\347\250\213\345\272\217\345\221\230\347\232\204\347\256\200\345\216\206\344\271\213\351\201\223.md" => "EssentialContentForInterview/PreparingForInterview/\347\250\213\345\272\217\345\221\230\347\232\204\347\256\200\345\216\206\344\271\213\351\201\223.md" (100%) rename "EssentialContentForInterview/\347\276\216\345\233\242\351\235\242\350\257\225\345\270\270\350\247\201\351\227\256\351\242\230\346\200\273\347\273\223.md" => "EssentialContentForInterview/PreparingForInterview/\347\276\216\345\233\242\351\235\242\350\257\225\345\270\270\350\247\201\351\227\256\351\242\230\346\200\273\347\273\223.md" (100%) diff --git a/EssentialContentForInterview/JavaProgrammerNeedKnow.md b/EssentialContentForInterview/PreparingForInterview/JavaProgrammerNeedKnow.md similarity index 100% rename from EssentialContentForInterview/JavaProgrammerNeedKnow.md rename to EssentialContentForInterview/PreparingForInterview/JavaProgrammerNeedKnow.md diff --git a/EssentialContentForInterview/books.md b/EssentialContentForInterview/PreparingForInterview/books.md similarity index 100% rename from EssentialContentForInterview/books.md rename to EssentialContentForInterview/PreparingForInterview/books.md diff --git a/EssentialContentForInterview/interviewPrepare.md b/EssentialContentForInterview/PreparingForInterview/interviewPrepare.md similarity index 100% rename from EssentialContentForInterview/interviewPrepare.md rename to EssentialContentForInterview/PreparingForInterview/interviewPrepare.md diff --git "a/EssentialContentForInterview/\347\250\213\345\272\217\345\221\230\347\232\204\347\256\200\345\216\206\344\271\213\351\201\223.md" "b/EssentialContentForInterview/PreparingForInterview/\347\250\213\345\272\217\345\221\230\347\232\204\347\256\200\345\216\206\344\271\213\351\201\223.md" similarity index 100% rename from "EssentialContentForInterview/\347\250\213\345\272\217\345\221\230\347\232\204\347\256\200\345\216\206\344\271\213\351\201\223.md" rename to "EssentialContentForInterview/PreparingForInterview/\347\250\213\345\272\217\345\221\230\347\232\204\347\256\200\345\216\206\344\271\213\351\201\223.md" diff --git "a/EssentialContentForInterview/\347\276\216\345\233\242\351\235\242\350\257\225\345\270\270\350\247\201\351\227\256\351\242\230\346\200\273\347\273\223.md" "b/EssentialContentForInterview/PreparingForInterview/\347\276\216\345\233\242\351\235\242\350\257\225\345\270\270\350\247\201\351\227\256\351\242\230\346\200\273\347\273\223.md" similarity index 100% rename from "EssentialContentForInterview/\347\276\216\345\233\242\351\235\242\350\257\225\345\270\270\350\247\201\351\227\256\351\242\230\346\200\273\347\273\223.md" rename to "EssentialContentForInterview/PreparingForInterview/\347\276\216\345\233\242\351\235\242\350\257\225\345\270\270\350\247\201\351\227\256\351\242\230\346\200\273\347\273\223.md" From 75ee47edf8ee406f9ed6d1d653d0503d76c70f39 Mon Sep 17 00:00:00 2001 From: SnailClimb Date: Fri, 8 Mar 2019 19:20:01 +0800 Subject: [PATCH 084/232] Update link MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 修改了文件夹的名字故修改链接地址 --- README.md | 23 ++++++++++------------- 1 file changed, 10 insertions(+), 13 deletions(-) diff --git a/README.md b/README.md index 8aef7455edf..fda9aefffd9 100644 --- a/README.md +++ b/README.md @@ -161,25 +161,22 @@ * [8 张图读懂大型网站技术架构](https://github.com/Snailclimb/JavaGuide/blob/master/架构/8%20张图读懂大型网站技术架构.md) * [【面试精选】关于大型网站系统架构你不得不懂的10个问题](https://github.com/Snailclimb/JavaGuide/blob/master/架构/【面试精选】关于大型网站系统架构你不得不懂的10个问题.md) -## :musical_note: 面试必备 +## :musical_note: 面试必备(Essential content for the interview) ### 备战面试 -* [【备战面试1】程序员的简历就该这样写](https://github.com/Snailclimb/Java-Guide/blob/master/面试必备/程序员的简历之道.md) -* [【备战面试2】初出茅庐的程序员该如何准备面试？](https://github.com/Snailclimb/Java-Guide/blob/master/面试必备/interviewPrepare.md) -* [【备战面试3】7个大部分程序员在面试前很关心的问题](https://github.com/Snailclimb/JavaGuide/blob/master/面试必备/JavaProgrammerNeedKnow.md) -* [【备战面试4】Java程序员必备书单](https://github.com/Snailclimb/Java-Guide/blob/master/面试必备/books.md) -* [【备战面试5】美团面试常见问题总结（附详解答案）](https://github.com/Snailclimb/Java-Guide/blob/master/面试必备/美团面试常见问题总结.md) +* [【备战面试1】程序员的简历就该这样写](https://github.com/Snailclimb/JavaGuide/blob/master/EssentialContentForInterview/PreparingForInterview/程序员的简历之道.md) +* [【备战面试2】初出茅庐的程序员该如何准备面试？](https://github.com/Snailclimb/Java-Guide/blob/master/EssentialContentForInterview/PreparingForInterview/interviewPrepare.md) +* [【备战面试3】7个大部分程序员在面试前很关心的问题](https://github.com/Snailclimb/JavaGuide/blob/master/EssentialContentForInterview/PreparingForInterview/JavaProgrammerNeedKnow.md) +* [【备战面试4】Java程序员必备书单](https://github.com/Snailclimb/Java-Guide/blob/master/EssentialContentForInterview/PreparingForInterview/books.md) +* [【备战面试5】美团面试常见问题总结（附详解答案）](https://github.com/Snailclimb/Java-Guide/blob/master/EssentialContentForInterview/PreparingForInterview/美团面试常见问题总结.md) +### 最常见的Java面试题总结 -### 最最最常见的Java面试题总结 - -这里会分享一些出现频率极其极其高的面试题，初定周更一篇，什么时候更完什么时候停止。 - -* [第一周（2018-8-7）](https://github.com/Snailclimb/Java-Guide/blob/master/面试必备/最最最常见的Java面试题总结/第一周（2018-8-7）.md) (为什么 Java 中只有值传递、==与equals、 hashCode与equals) -* [第二周（2018-8-13）](https://github.com/Snailclimb/Java-Guide/blob/master/面试必备/最最最常见的Java面试题总结/第二周(2018-8-13).md)(String和StringBuffer、StringBuilder的区别是什么？String为什么是不可变的？、什么是反射机制？反射机制的应用场景有哪些？......) +* [第一周（2018-8-7）](https://github.com/Snailclimb/Java-Guide/blob/master/EssentialContentForInterview/MostCommonJavaInterviewQuestions/第一周（2018-8-7）.md) (为什么 Java 中只有值传递、==与equals、 hashCode与equals) +* [第二周（2018-8-13）](https://github.com/Snailclimb/Java-Guide/blob/master/EssentialContentForInterview/MostCommonJavaInterviewQuestions/第二周(2018-8-13).md)(String和StringBuffer、StringBuilder的区别是什么？String为什么是不可变的？、什么是反射机制？反射机制的应用场景有哪些？......) * [第三周（2018-08-22）](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/这几道Java集合框架面试题几乎必问.md) （Arraylist 与 LinkedList 异同、ArrayList 与 Vector 区别、HashMap的底层实现、HashMap 和 Hashtable 的区别、HashMap 的长度为什么是2的幂次方、HashSet 和 HashMap 区别、ConcurrentHashMap 和 Hashtable 的区别、ConcurrentHashMap线程安全的具体实现方式/底层具体实现、集合框架底层数据结构总结） -* [第四周(2018-8-30).md](https://github.com/Snailclimb/Java-Guide/blob/master/面试必备/最最最常见的Java面试题总结/第四周(2018-8-30).md) （主要内容是几道面试常问的多线程基础题。） +* [第四周(2018-8-30).md](https://github.com/Snailclimb/Java-Guide/blob/master/EssentialContentForInterview/MostCommonJavaInterviewQuestions/第四周(2018-8-30).md) （主要内容是几道面试常问的多线程基础题。） ### Java学习/面试开源仓库推荐 From 564a90c8b01263156d88e474530942cead383b07 Mon Sep 17 00:00:00 2001 From: Snailclimb Date: Fri, 8 Mar 2019 19:31:41 +0800 Subject: [PATCH 085/232] Update Modify file name and directory address --- .../JavaInterviewLibrary.md} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename EssentialContentForInterview/{JavaInterviewGithub.md => PreparingForInterview/JavaInterviewLibrary.md} (100%) diff --git a/EssentialContentForInterview/JavaInterviewGithub.md b/EssentialContentForInterview/PreparingForInterview/JavaInterviewLibrary.md similarity index 100% rename from EssentialContentForInterview/JavaInterviewGithub.md rename to EssentialContentForInterview/PreparingForInterview/JavaInterviewLibrary.md From 40752e158e283534fa247aa8b5f2a0e3c5acbef2 Mon Sep 17 00:00:00 2001 From: SnailClimb Date: Fri, 8 Mar 2019 19:32:23 +0800 Subject: [PATCH 086/232] Update README.md --- README.md | 17 +++++++---------- 1 file changed, 7 insertions(+), 10 deletions(-) diff --git a/README.md b/README.md index fda9aefffd9..ca7dee83a1b 100644 --- a/README.md +++ b/README.md @@ -39,9 +39,9 @@ * [Redis](#redis) * [:punch: 架构](#punch-架构) * [:musical_note: 面试必备](#musical_note-面试必备) - * [备战面试](#备战面试) - * [最最最常见的Java面试题总结](#最最最常见的java面试题总结) - * [Java学习/面试开源仓库推荐](#java学习面试开源仓库推荐) +* [:musical_note: 面试必备\(Essential content for the interview\)](#musical_note-面试必备essential-content-for-the-interview) + * [备战面试\(Preparing for an interview\)](#备战面试preparing-for-an-interview) + * [最常见的Java面试题总结\(Summary of the most common Java interview questions\)](#最常见的java面试题总结summary-of-the-most-common-java-interview-questions) * [:art: 闲谈](#art-闲谈) * [:envelope: 说明](#envelope-说明) @@ -163,25 +163,22 @@ ## :musical_note: 面试必备(Essential content for the interview) -### 备战面试 +### 备战面试(Preparing for an interview) * [【备战面试1】程序员的简历就该这样写](https://github.com/Snailclimb/JavaGuide/blob/master/EssentialContentForInterview/PreparingForInterview/程序员的简历之道.md) * [【备战面试2】初出茅庐的程序员该如何准备面试？](https://github.com/Snailclimb/Java-Guide/blob/master/EssentialContentForInterview/PreparingForInterview/interviewPrepare.md) * [【备战面试3】7个大部分程序员在面试前很关心的问题](https://github.com/Snailclimb/JavaGuide/blob/master/EssentialContentForInterview/PreparingForInterview/JavaProgrammerNeedKnow.md) * [【备战面试4】Java程序员必备书单](https://github.com/Snailclimb/Java-Guide/blob/master/EssentialContentForInterview/PreparingForInterview/books.md) -* [【备战面试5】美团面试常见问题总结（附详解答案）](https://github.com/Snailclimb/Java-Guide/blob/master/EssentialContentForInterview/PreparingForInterview/美团面试常见问题总结.md) +* [【备战面试5】Github上开源的Java面试/学习相关的仓库推荐](https://github.com/Snailclimb/Java-Guide/blob/master/EssentialContentForInterview/PreparingForInterview/JavaInterviewLibrary.md) +* [【备战面试6】美团面试常见问题总结（附详解答案）](https://github.com/Snailclimb/Java-Guide/blob/master/EssentialContentForInterview/PreparingForInterview/美团面试常见问题总结.md) -### 最常见的Java面试题总结 +### 最常见的Java面试题总结(Summary of the most common Java interview questions) * [第一周（2018-8-7）](https://github.com/Snailclimb/Java-Guide/blob/master/EssentialContentForInterview/MostCommonJavaInterviewQuestions/第一周（2018-8-7）.md) (为什么 Java 中只有值传递、==与equals、 hashCode与equals) * [第二周（2018-8-13）](https://github.com/Snailclimb/Java-Guide/blob/master/EssentialContentForInterview/MostCommonJavaInterviewQuestions/第二周(2018-8-13).md)(String和StringBuffer、StringBuilder的区别是什么？String为什么是不可变的？、什么是反射机制？反射机制的应用场景有哪些？......) * [第三周（2018-08-22）](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/这几道Java集合框架面试题几乎必问.md) （Arraylist 与 LinkedList 异同、ArrayList 与 Vector 区别、HashMap的底层实现、HashMap 和 Hashtable 的区别、HashMap 的长度为什么是2的幂次方、HashSet 和 HashMap 区别、ConcurrentHashMap 和 Hashtable 的区别、ConcurrentHashMap线程安全的具体实现方式/底层具体实现、集合框架底层数据结构总结） * [第四周(2018-8-30).md](https://github.com/Snailclimb/Java-Guide/blob/master/EssentialContentForInterview/MostCommonJavaInterviewQuestions/第四周(2018-8-30).md) （主要内容是几道面试常问的多线程基础题。） -### Java学习/面试开源仓库推荐 - -* [盘点一下Github上开源的Java面试/学习相关的仓库，看完弄懂薪资至少增加10k](https://github.com/Snailclimb/Java-Guide/blob/master/面试必备/JavaInterviewGithub.md) - ## :art: 闲谈 * [选择技术方向都要考虑哪些因素](https://github.com/Snailclimb/Java-Guide/blob/master/闲谈/选择技术方向都要考虑哪些因素.md) From a51182bdd6f30c52d981222fc5156a06a4e53cdd Mon Sep 17 00:00:00 2001 From: SnailClimb Date: Fri, 8 Mar 2019 19:36:56 +0800 Subject: [PATCH 087/232] Update directory error --- README.md | 1 - 1 file changed, 1 deletion(-) diff --git a/README.md b/README.md index ca7dee83a1b..520b34e30b7 100644 --- a/README.md +++ b/README.md @@ -38,7 +38,6 @@ * [MySQL](#mysql) * [Redis](#redis) * [:punch: 架构](#punch-架构) -* [:musical_note: 面试必备](#musical_note-面试必备) * [:musical_note: 面试必备\(Essential content for the interview\)](#musical_note-面试必备essential-content-for-the-interview) * [备战面试\(Preparing for an interview\)](#备战面试preparing-for-an-interview) * [最常见的Java面试题总结\(Summary of the most common Java interview questions\)](#最常见的java面试题总结summary-of-the-most-common-java-interview-questions) From 8923dd0b2c1ff6b311f679a3933279df6531ebac Mon Sep 17 00:00:00 2001 From: SnailClimb Date: Fri, 8 Mar 2019 20:13:27 +0800 Subject: [PATCH 088/232] Update directory --- README.md | 40 ++++++++++++++++++++-------------------- 1 file changed, 20 insertions(+), 20 deletions(-) diff --git a/README.md b/README.md index 520b34e30b7..b99489456e2 100644 --- a/README.md +++ b/README.md @@ -16,33 +16,33 @@ ## 目录 -* [:coffee: Java](#coffee-java) +* [Java](#java) * [Java/J2EE 基础](#javaj2ee-基础) * [Java 集合框架](#java-集合框架) * [Java 多线程](#java-多线程) * [Java BIO,NIO,AIO](#java-bionioaio) * [Java 虚拟机 jvm](#java-虚拟机-jvm) * [设计模式](#设计模式) -* [:open_file_folder: 数据结构与算法](#open_file_folder-数据结构与算法) +* [数据结构与算法](#数据结构与算法) * [数据结构](#数据结构) * [算法](#算法) -* [:computer: 计算机网络与数据通信](#computer-计算机网络与数据通信) +* [计算机网络与数据通信](#计算机网络与数据通信) * [网络相关](#网络相关) * [数据通信\(RESTful,RPC,消息队列\)总结](#数据通信restfulrpc消息队列总结) -* [:iphone: 操作系统](#iphone-操作系统) +* [操作系统](#操作系统) * [Linux相关](#linux相关) -* [:pencil2: 主流框架/软件](#pencil2-主流框架软件) +* [主流框架/软件](#主流框架软件) * [Spring](#spring) * [ZooKeeper](#zookeeper) -* [:floppy_disk: 数据存储](#floppy_disk-数据存储) +* [数据存储](#数据存储) * [MySQL](#mysql) * [Redis](#redis) -* [:punch: 架构](#punch-架构) -* [:musical_note: 面试必备\(Essential content for the interview\)](#musical_note-面试必备essential-content-for-the-interview) +* [架构](#架构) +* [面试必备\(Essential content for the interview\)](#面试必备essential-content-for-the-interview) * [备战面试\(Preparing for an interview\)](#备战面试preparing-for-an-interview) * [最常见的Java面试题总结\(Summary of the most common Java interview questions\)](#最常见的java面试题总结summary-of-the-most-common-java-interview-questions) -* [:art: 闲谈](#art-闲谈) -* [:envelope: 说明](#envelope-说明) +* [闲谈](#闲谈) +* [说明](#说明) ## 待办 @@ -52,7 +52,7 @@ * [ ] Netty 总结 * [ ] 数据结构总结重构 -## :coffee: Java +## Java ### Java/J2EE 基础 @@ -94,7 +94,7 @@ * [设计模式系列文章](https://github.com/Snailclimb/Java_Guide/blob/master/Java相关/设计模式.md) -## :open_file_folder: 数据结构与算法 +## 数据结构与算法 ### 数据结构 @@ -107,7 +107,7 @@ * [算法总结——几道常见的子符串算法题 ](https://github.com/Snailclimb/Java_Guide/blob/master/数据结构与算法/搞定BAT面试——几道常见的子符串算法题.md) * [算法总结——几道常见的链表算法题 ](https://github.com/Snailclimb/Java_Guide/blob/master/数据结构与算法/Leetcode-LinkList1.md) -## :computer: 计算机网络与数据通信 +## 计算机网络与数据通信 ### 网络相关 @@ -122,13 +122,13 @@ * [消息队列总结：新手也能看懂，消息队列其实很简单](https://github.com/Snailclimb/Java-Guide/blob/master/计算机网络与数据通信/message-queue.md) * [一文搞懂 RabbitMQ 的重要概念以及安装](https://github.com/Snailclimb/Java-Guide/blob/master/计算机网络与数据通信/rabbitmq.md) -## :iphone: 操作系统 +## 操作系统 ### Linux相关 * [后端程序员必备的 Linux 基础知识](https://github.com/Snailclimb/Java-Guide/blob/master/操作系统/后端程序员必备的Linux基础知识.md) * [Shell 编程入门](https://github.com/Snailclimb/Java-Guide/blob/master/操作系统/Shell.md) -## :pencil2: 主流框架/软件 +## 主流框架/软件 ### Spring @@ -141,7 +141,7 @@ * [可能是把 ZooKeeper 概念讲的最清楚的一篇文章](https://github.com/Snailclimb/Java_Guide/blob/master/主流框架/ZooKeeper.md) * [ZooKeeper 数据模型和常见命令了解一下，速度收藏！](https://github.com/Snailclimb/Java_Guide/blob/master/主流框架/ZooKeeper数据模型和常见命令.md) -## :floppy_disk: 数据存储 +## 数据存储 ### MySQL @@ -154,13 +154,13 @@ * [Redlock分布式锁](https://github.com/Snailclimb/Java_Guide/blob/master/数据存储/Redis/Redlock分布式锁.md) * [如何做可靠的分布式锁，Redlock真的可行么](https://github.com/Snailclimb/Java_Guide/blob/master/数据存储/Redis/如何做可靠的分布式锁，Redlock真的可行么.md) -## :punch: 架构 +## 架构 * [一文读懂分布式应该学什么](https://github.com/Snailclimb/Java_Guide/blob/master/架构/分布式.md) * [8 张图读懂大型网站技术架构](https://github.com/Snailclimb/JavaGuide/blob/master/架构/8%20张图读懂大型网站技术架构.md) * [【面试精选】关于大型网站系统架构你不得不懂的10个问题](https://github.com/Snailclimb/JavaGuide/blob/master/架构/【面试精选】关于大型网站系统架构你不得不懂的10个问题.md) -## :musical_note: 面试必备(Essential content for the interview) +## 面试必备(Essential content for the interview) ### 备战面试(Preparing for an interview) @@ -178,7 +178,7 @@ * [第三周（2018-08-22）](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/这几道Java集合框架面试题几乎必问.md) （Arraylist 与 LinkedList 异同、ArrayList 与 Vector 区别、HashMap的底层实现、HashMap 和 Hashtable 的区别、HashMap 的长度为什么是2的幂次方、HashSet 和 HashMap 区别、ConcurrentHashMap 和 Hashtable 的区别、ConcurrentHashMap线程安全的具体实现方式/底层具体实现、集合框架底层数据结构总结） * [第四周(2018-8-30).md](https://github.com/Snailclimb/Java-Guide/blob/master/EssentialContentForInterview/MostCommonJavaInterviewQuestions/第四周(2018-8-30).md) （主要内容是几道面试常问的多线程基础题。） -## :art: 闲谈 +## 闲谈 * [选择技术方向都要考虑哪些因素](https://github.com/Snailclimb/Java-Guide/blob/master/闲谈/选择技术方向都要考虑哪些因素.md) * [结束了我短暂的秋招，说点自己的感受](https://github.com/Snailclimb/JavaGuide/blob/master/闲谈/2018%20%E7%A7%8B%E6%8B%9B.md) @@ -187,7 +187,7 @@ *** -## :envelope: 说明 +## 说明 ### 介绍 From 852bf52cef0040573a27c14694851335da48de19 Mon Sep 17 00:00:00 2001 From: Snailclimb Date: Fri, 8 Mar 2019 20:18:26 +0800 Subject: [PATCH 089/232] =?UTF-8?q?Create=205=E9=9D=A2=E9=98=BF=E9=87=8C,?= =?UTF-8?q?=E7=BB=88=E8=8E=B7offer.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...\207\214,\347\273\210\350\216\267offer.md" | 79 +++++++++++++++++++ 1 file changed, 79 insertions(+) create mode 100644 "EssentialContentForInterview/BATJrealInterviewExperience/5\351\235\242\351\230\277\351\207\214,\347\273\210\350\216\267offer.md" diff --git "a/EssentialContentForInterview/BATJrealInterviewExperience/5\351\235\242\351\230\277\351\207\214,\347\273\210\350\216\267offer.md" "b/EssentialContentForInterview/BATJrealInterviewExperience/5\351\235\242\351\230\277\351\207\214,\347\273\210\350\216\267offer.md" new file mode 100644 index 00000000000..2a7a0431f35 --- /dev/null +++ "b/EssentialContentForInterview/BATJrealInterviewExperience/5\351\235\242\351\230\277\351\207\214,\347\273\210\350\216\267offer.md" @@ -0,0 +1,79 @@ +# 联系方式 + +- 手机： +- Email： +- 微信： + +# 个人信息 + + - 姓名/性别/出生日期 + - 本科/xxx计算机系xxx专业/英语六级 + - 技术博客：[http://snailclimb.top/](http://snailclimb.top/) + - 荣誉奖励：获得了什么奖（获奖时间） + - Github：[https://github.com/Snailclimb ](https://github.com/Snailclimb) + - Github Resume: [http://resume.github.io/?Snailclimb](http://resume.github.io/?Snailclimb) + - 期望职位：Java 研发程序员/大数据工程师(Java后台开发为首选) + - 期望城市：xxx城市 + + +# 项目经历 + +## xxx项目 + +### 项目描述 + +介绍该项目是做什么的、使用到了什么技术以及你对项目整体设计的一个感受 + +### 责任描述 + +主要可以从下面三点来写： + +1. 在这个项目中你负责了什么、做了什么、担任了什么角色 +2. 从这个项目中你学会了那些东西，使用到了那些技术，学会了那些新技术的使用 +3. 另外项目描述中，最好可以体现自己的综合素质，比如你是如何协调项目组成员协同开发的或者在遇到某一个棘手的问题的时候你是如何解决的。 + +# 开源项目和技术文章 + +## 开源项目 + +- [Java-Guide](https://github.com/Snailclimb/Java-Guide) ：一份涵盖大部分Java程序员所需要掌握的核心知识。Star:3.9K; Fork:0.9k。 + + +## 技术文章推荐 + +- [可能是把Java内存区域讲的最清楚的一篇文章](https://juejin.im/post/5b7d69e4e51d4538ca5730cb) +- [搞定JVM垃圾回收就是这么简单](https://juejin.im/post/5b85ea54e51d4538dd08f601) +- [前端&后端程序员必备的Linux基础知识](https://juejin.im/post/5b3b19856fb9a04fa42f8c71) +- [可能是把Docker的概念讲的最清楚的一篇文章](https://juejin.im/post/5b260ec26fb9a00e8e4b031a) + + +# 校园经历（可选） + +## 2016-2017 + +担任学校社团-致深社副会长，主要负责团队每周活动的组建以及每周例会的主持。 + +## 2017-2018 + 担任学校传媒组织：“长江大学在线信息传媒”的副站长以及安卓组成员。主要负责每周例会主持、活动策划以及学校校园通APP的研发工作。 + + +# 技能清单 + +以下均为我熟练使用的技能 + +- Web开发：PHP/Hack/Node +- Web框架：ThinkPHP/Yaf/Yii/Lavarel/LazyPHP +- 前端框架：Bootstrap/AngularJS/EmberJS/HTML5/Cocos2dJS/ionic +- 前端工具：Bower/Gulp/SaSS/LeSS/PhoneGap +- 数据库相关：MySQL/PgSQL/PDO/SQLite +- 版本管理、文档和自动化部署工具：Svn/Git/PHPDoc/Phing/Composer +- 单元测试：PHPUnit/SimpleTest/Qunit +- 云和开放平台：SAE/BAE/AWS/微博开放平台/微信应用开发 + +# 自我评价（可选） + +自我发挥。切记不要过度自夸！！！ + + +### 感谢您花时间阅读我的简历，期待能有机会和您共事。 + From 5814035bcf2e1254f8df050e2615fda5754d9b61 Mon Sep 17 00:00:00 2001 From: Snailclimb Date: Fri, 8 Mar 2019 20:21:51 +0800 Subject: [PATCH 090/232] =?UTF-8?q?Update=205=E9=9D=A2=E9=98=BF=E9=87=8C,?= =?UTF-8?q?=E7=BB=88=E8=8E=B7offer.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...\207\214,\347\273\210\350\216\267offer.md" | 171 ++++++++++-------- 1 file changed, 92 insertions(+), 79 deletions(-) diff --git "a/EssentialContentForInterview/BATJrealInterviewExperience/5\351\235\242\351\230\277\351\207\214,\347\273\210\350\216\267offer.md" "b/EssentialContentForInterview/BATJrealInterviewExperience/5\351\235\242\351\230\277\351\207\214,\347\273\210\350\216\267offer.md" index 2a7a0431f35..7772891d20d 100644 --- "a/EssentialContentForInterview/BATJrealInterviewExperience/5\351\235\242\351\230\277\351\207\214,\347\273\210\350\216\267offer.md" +++ "b/EssentialContentForInterview/BATJrealInterviewExperience/5\351\235\242\351\230\277\351\207\214,\347\273\210\350\216\267offer.md" @@ -1,79 +1,92 @@ -# 联系方式 - -- 手机： -- Email： -- 微信： - -# 个人信息 - - - 姓名/性别/出生日期 - - 本科/xxx计算机系xxx专业/英语六级 - - 技术博客：[http://snailclimb.top/](http://snailclimb.top/) - - 荣誉奖励：获得了什么奖（获奖时间） - - Github：[https://github.com/Snailclimb ](https://github.com/Snailclimb) - - Github Resume: [http://resume.github.io/?Snailclimb](http://resume.github.io/?Snailclimb) - - 期望职位：Java 研发程序员/大数据工程师(Java后台开发为首选) - - 期望城市：xxx城市 - - -# 项目经历 - -## xxx项目 - -### 项目描述 - -介绍该项目是做什么的、使用到了什么技术以及你对项目整体设计的一个感受 - -### 责任描述 - -主要可以从下面三点来写： - -1. 在这个项目中你负责了什么、做了什么、担任了什么角色 -2. 从这个项目中你学会了那些东西，使用到了那些技术，学会了那些新技术的使用 -3. 另外项目描述中，最好可以体现自己的综合素质，比如你是如何协调项目组成员协同开发的或者在遇到某一个棘手的问题的时候你是如何解决的。 - -# 开源项目和技术文章 - -## 开源项目 - -- [Java-Guide](https://github.com/Snailclimb/Java-Guide) ：一份涵盖大部分Java程序员所需要掌握的核心知识。Star:3.9K; Fork:0.9k。 - - -## 技术文章推荐 - -- [可能是把Java内存区域讲的最清楚的一篇文章](https://juejin.im/post/5b7d69e4e51d4538ca5730cb) -- [搞定JVM垃圾回收就是这么简单](https://juejin.im/post/5b85ea54e51d4538dd08f601) -- [前端&后端程序员必备的Linux基础知识](https://juejin.im/post/5b3b19856fb9a04fa42f8c71) -- [可能是把Docker的概念讲的最清楚的一篇文章](https://juejin.im/post/5b260ec26fb9a00e8e4b031a) - - -# 校园经历（可选） - -## 2016-2017 - -担任学校社团-致深社副会长，主要负责团队每周活动的组建以及每周例会的主持。 - -## 2017-2018 - 担任学校传媒组织：“长江大学在线信息传媒”的副站长以及安卓组成员。主要负责每周例会主持、活动策划以及学校校园通APP的研发工作。 - - -# 技能清单 - -以下均为我熟练使用的技能 - -- Web开发：PHP/Hack/Node -- Web框架：ThinkPHP/Yaf/Yii/Lavarel/LazyPHP -- 前端框架：Bootstrap/AngularJS/EmberJS/HTML5/Cocos2dJS/ionic -- 前端工具：Bower/Gulp/SaSS/LeSS/PhoneGap -- 数据库相关：MySQL/PgSQL/PDO/SQLite -- 版本管理、文档和自动化部署工具：Svn/Git/PHPDoc/Phing/Composer -- 单元测试：PHPUnit/SimpleTest/Qunit -- 云和开放平台：SAE/BAE/AWS/微博开放平台/微信应用开发 - -# 自我评价（可选） - -自我发挥。切记不要过度自夸！！！ - - -### 感谢您花时间阅读我的简历，期待能有机会和您共事。 - +> 作者：ppxyn。本文来自读者投稿，同时也欢迎各位投稿，**对于不错的原创文章我根据你的选择给予现金(50-200)、付费专栏或者任选书籍进行奖励！所以，快提 pr 或者邮件的方式（邮件地址在主页）给我投稿吧！** 当然，我觉得奖励是次要的，最重要的是你可以从自己整理知识点的过程中学习到很多知识。 + +在接触 Java 之前我接触的比较多的是硬件方面，用的比较多的语言就是C和C++。到了大三我才正式选择 Java 方向，到目前为止使用Java到现在大概有一年多的时间，所以Java算不上很好。刚开始投递的时候，实习刚辞职，也没准备笔试面试，很多东西都忘记了。所以，刚开始我并没有直接就投递阿里，毕竟心里还是有一点点小害怕的。于是，我就先投递了几个不算大的公司来练手，就是想着刷刷经验而已或者说是练练手（ps：还是挺对不起那些公司的）。面了一个月其他公司后，我找了我实验室的学长内推我，后面就有了这5次面试。 + +下面简单的说一下我的这5次面试：4次技术面+1次HR面，希望我的经历能对你有所帮助。 + + + +- [一面\(技术面\)](#一面技术面) +- [二面\(技术面\)](#二面技术面) +- [三面\(技术面\)](#三面技术面) +- [四面\(半个技术面\)](#四面半个技术面) +- [五面\(HR面\)](#五面hr面) +- [总结](#总结) + + + + +### 一面(技术面) + +1. 自我介绍（主要讲自己会的技术细节，项目经验，经历那些就一语带过，后面面试官会问你的）。 +2. 聊聊项目（就是一个很普通的分布式商城，自己做了一些改进），让我画了整个项目的架构图，然后针对项目抛了一系列的提高性能的问题，还问了我做项目的过程中遇到了那些问题，如何解决的，差不读就这些吧。 +3. 可能是我前面说了我会数据库优化，然后面试官就开始问索引、事务隔离级别、悲观锁和乐观锁、索引、ACID、MVVC这些问题。 +4. 浏览器输入URL发生了什么? TCP和UDP区别? TCP如何保证传输可靠性? +5. 讲下跳表怎么实现的?哈夫曼编码是怎么回事？非递归且不用额外空间（不用栈），如何遍历二叉树 +6. 后面又问了很多JVM方面的问题，比如Java内存模型、常见的垃圾回收器、双亲委派模型这些 +7. 你有什么问题要问吗？ + +### 二面(技术面) + +1. 自我介绍（主要讲自己会的技术细节，项目经验，经历那些就一语带过，后面面试官会问你的）。 +2. 操作系统的内存管理机制 +3. 进程和线程的区别 +4. 说下你对线程安全的理解 +5. volatile 有什么作用 ，sychronized和lock有什么区别 +6. ReentrantLock实现原理 +7. 用过CountDownLatch么？什么场景下用的？ +8. AQS底层原理。 +9. 造成死锁的原因有哪些，如何预防？ +10. 加锁会带来哪些性能问题。如何解决？ +11. HashMap、ConcurrentHashMap源码。HashMap是线程安全的吗？Hashtable呢？ConcurrentHashMap有了解吗？ +12. 是否可以实习？ +13. 你有什么问题要问吗？ + +### 三面(技术面) + +1. 有没有参加过 ACM 或者他竞赛，有没有拿过什么奖？（ 我说我没参加过ACM，本科参加过数学建模竞赛，名次并不好，没拿过什么奖。面试官好像有点失望，然后我又赶紧补充说我和老师一起做过一个项目，目前已经投入使用。面试官还比较感兴趣，后面又和他聊了一下这个项目。） +2. 研究生期间，做过什么项目，发过论文吗？有什么成果吗？ +3. 你觉得你有什么优点和缺点？你觉得你相比于那些比你更优秀的人欠缺什么？ +4. 有读过什么源码吗？（我说我读过 Java 集合框架和 Netty 的，面试官说 Java 集合前几面一定问的差不多，就不问了，然后就问我 Netty的，我当时很慌啊！） +5. 介绍一下自己对 Netty 的认识，为什么要用。说说业务中，Netty 的使用场景。什么是TCP 粘包/拆包,解决办法。Netty线程模型。Dubbo 在使用 Netty 作为网络通讯时候是如何避免粘包与半包问题？讲讲Netty的零拷贝？巴拉巴拉问了好多，我记得有好几个我都没回答上来，心里想着凉凉了啊。 +6. 用到了那些开源技术、在开源领域做过贡献吗？ +7. 常见的排序算法及其复杂度，现场写了快排。 +8. 红黑树，B树的一些问题。 +9. 讲讲算法及数据结构在实习项目中的用处。 +10. 自己的未来规划（就简单描述了一下自己未来的设想啊，说的还挺诚恳，面试官好像还挺满意的） +11. 你有什么问题要问吗？ + +### 四面(半个技术面) + +三面面完当天，晚上9点接到面试电话，感觉像是部门或者项目主管。 这个和之前的面试不大相同，感觉面试官主要考察的是你解决问题的能力、学习能力和团队协作能力。 + +1. 让我讲一个自己觉得最不错的项目。然后就巴拉巴拉的聊，我记得主要是问了项目是如何进行协作的、遇到问题是如何解决的、与他人发生冲突是如何解决的这些。感觉聊了挺久。 +2. 出现 OOM 后你会怎么排查问题？ +3. 自己平时是如何学习新技术的？除了 Java 还回去了解其他技术吗? +4. 上一段实习经历的收获。 +5. NginX如何做负载均衡、常见的负载均衡算法有哪些、一致性哈希的一致性是什么意思、一致性哈希是如何做哈希的 +6. 你有什么问题问我吗？ +7. 还有一些其他的，想不起来了，感觉这一面不是偏向技术来问。 + +## 五面(HR面) + +1. 自我介绍（主要讲能突出自己的经历，会的编程技术一语带过）。 +2. 你觉得你有什么优点和缺点？如何克服这些缺点？ +3. 说一件大学里你自己比较有成就感的一件事情，为此付出了那些努力。 +4. 你前面跟其他面试官讲过一些你做的项目吧？可以给我讲讲吗？你要考虑到我不是一个做技术的人，怎么让我也听得懂。项目中有什么问题，你怎么解决的？你最大的收获是什么？ +5. 你目前有面试过其他公司吗？如果让你选，这些公司和阿里，你选哪个？（送分题，回答不好可能送命） +6. 你期望的工作地点是哪里？ +7. 你有什么问题吗？ + +### 总结 + +1. 可以看出面试官问我的很多问题都是比较常见的问题，所以记得一定要提前准备，还要深入准备，不要回答的太皮毛。很多时候一个问题可能会牵扯出很多问题，遇到不会的问题不要慌，冷静分析，如果你真的回答不上来，也不要担心自己是不是就要挂了，很可能这个问题本身就比较难。 +2. 表达能力和沟通能力太重要了，一定要提前练一下，我自身就是一个不太会说话的人，所以，面试前我对于自我介绍、项目介绍和一些常见问题都在脑子里练了好久，确保面试的时候能够很清晰和简洁的说出来。 +3. 等待面试的过程和面试的过程真的好熬人，那段时间我压力也比较大，好在我私下找到学长聊了很多，心情也好了很多。 +4. 面试之后及时总结，面的好的话，不要得意，尽快准备下一场面试吧！ + +我觉得我还算是比较幸运的，最后也祝大家都能获得心仪的Offer。 + + + + \ No newline at end of file From 519ff1590a2af28fe3b7c51df190cf6c613af3ee Mon Sep 17 00:00:00 2001 From: SnailClimb Date: Fri, 8 Mar 2019 20:28:23 +0800 Subject: [PATCH 091/232] =?UTF-8?q?Add=20BATJ=E7=9C=9F=E5=AE=9E=E9=9D=A2?= =?UTF-8?q?=E7=BB=8F:5=E9=9D=A2=E9=98=BF=E9=87=8C,=E7=BB=88=E8=8E=B7offer?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index b99489456e2..03222e69ca6 100644 --- a/README.md +++ b/README.md @@ -40,6 +40,7 @@ * [架构](#架构) * [面试必备\(Essential content for the interview\)](#面试必备essential-content-for-the-interview) * [备战面试\(Preparing for an interview\)](#备战面试preparing-for-an-interview) + * [BATJ真实面经\(BATJ real interview experience\)](#batj真实面经batj-real-interview-experience) * [最常见的Java面试题总结\(Summary of the most common Java interview questions\)](#最常见的java面试题总结summary-of-the-most-common-java-interview-questions) * [闲谈](#闲谈) * [说明](#说明) @@ -60,7 +61,6 @@ * [J2EE 基础知识回顾](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/J2EE基础知识.md) * [Java常见关键字总结：static、final、this、super](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/final、static、this、super.md) - ### Java 集合框架 * [这几道Java集合框架面试题几乎必问](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/这几道Java集合框架面试题几乎必问.md) @@ -171,6 +171,10 @@ * [【备战面试5】Github上开源的Java面试/学习相关的仓库推荐](https://github.com/Snailclimb/Java-Guide/blob/master/EssentialContentForInterview/PreparingForInterview/JavaInterviewLibrary.md) * [【备战面试6】美团面试常见问题总结（附详解答案）](https://github.com/Snailclimb/Java-Guide/blob/master/EssentialContentForInterview/PreparingForInterview/美团面试常见问题总结.md) +### BATJ真实面经(BATJ real interview experience) + +* [5面阿里,终获offer(2018年秋招)](https://github.com/Snailclimb/JavaGuide/blob/master/EssentialContentForInterview/BATJrealInterviewExperience/5面阿里,终获offer.md) + ### 最常见的Java面试题总结(Summary of the most common Java interview questions) * [第一周（2018-8-7）](https://github.com/Snailclimb/Java-Guide/blob/master/EssentialContentForInterview/MostCommonJavaInterviewQuestions/第一周（2018-8-7）.md) (为什么 Java 中只有值传递、==与equals、 hashCode与equals) From aec4e80a75e2b1b121eb8a8036484ff4f4c46e7f Mon Sep 17 00:00:00 2001 From: SnailClimb Date: Fri, 8 Mar 2019 20:31:48 +0800 Subject: [PATCH 092/232] =?UTF-8?q?Update=205=E9=9D=A2=E9=98=BF=E9=87=8C,?= =?UTF-8?q?=E7=BB=88=E8=8E=B7offer.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...277\351\207\214,\347\273\210\350\216\267offer.md" | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git "a/EssentialContentForInterview/BATJrealInterviewExperience/5\351\235\242\351\230\277\351\207\214,\347\273\210\350\216\267offer.md" "b/EssentialContentForInterview/BATJrealInterviewExperience/5\351\235\242\351\230\277\351\207\214,\347\273\210\350\216\267offer.md" index 7772891d20d..9efac14f6d4 100644 --- "a/EssentialContentForInterview/BATJrealInterviewExperience/5\351\235\242\351\230\277\351\207\214,\347\273\210\350\216\267offer.md" +++ "b/EssentialContentForInterview/BATJrealInterviewExperience/5\351\235\242\351\230\277\351\207\214,\347\273\210\350\216\267offer.md" @@ -1,11 +1,10 @@ > 作者：ppxyn。本文来自读者投稿，同时也欢迎各位投稿，**对于不错的原创文章我根据你的选择给予现金(50-200)、付费专栏或者任选书籍进行奖励！所以，快提 pr 或者邮件的方式（邮件地址在主页）给我投稿吧！** 当然，我觉得奖励是次要的，最重要的是你可以从自己整理知识点的过程中学习到很多知识。 -在接触 Java 之前我接触的比较多的是硬件方面，用的比较多的语言就是C和C++。到了大三我才正式选择 Java 方向，到目前为止使用Java到现在大概有一年多的时间，所以Java算不上很好。刚开始投递的时候，实习刚辞职，也没准备笔试面试，很多东西都忘记了。所以，刚开始我并没有直接就投递阿里，毕竟心里还是有一点点小害怕的。于是，我就先投递了几个不算大的公司来练手，就是想着刷刷经验而已或者说是练练手（ps：还是挺对不起那些公司的）。面了一个月其他公司后，我找了我实验室的学长内推我，后面就有了这5次面试。 - -下面简单的说一下我的这5次面试：4次技术面+1次HR面，希望我的经历能对你有所帮助。 +**目录** +- [前言](#前言) - [一面\(技术面\)](#一面技术面) - [二面\(技术面\)](#二面技术面) - [三面\(技术面\)](#三面技术面) @@ -15,6 +14,11 @@ +### 前言 + +在接触 Java 之前我接触的比较多的是硬件方面，用的比较多的语言就是C和C++。到了大三我才正式选择 Java 方向，到目前为止使用Java到现在大概有一年多的时间，所以Java算不上很好。刚开始投递的时候，实习刚辞职，也没准备笔试面试，很多东西都忘记了。所以，刚开始我并没有直接就投递阿里，毕竟心里还是有一点点小害怕的。于是，我就先投递了几个不算大的公司来练手，就是想着刷刷经验而已或者说是练练手（ps：还是挺对不起那些公司的）。面了一个月其他公司后，我找了我实验室的学长内推我，后面就有了这5次面试。 + +下面简单的说一下我的这5次面试：4次技术面+1次HR面，希望我的经历能对你有所帮助。 ### 一面(技术面) @@ -89,4 +93,4 @@ - \ No newline at end of file + From 9dc44e6efa2ab107a708c864aca166552e80ba36 Mon Sep 17 00:00:00 2001 From: SnailClimb Date: Sat, 9 Mar 2019 12:42:45 +0800 Subject: [PATCH 093/232] Update README.md --- README.md | 7 ------- 1 file changed, 7 deletions(-) diff --git a/README.md b/README.md index 03222e69ca6..97dfe496f46 100644 --- a/README.md +++ b/README.md @@ -12,7 +12,6 @@ 3. **《Java面试突击》:** 由本文档衍生的专为面试而生的《Java面试突击》V2.0 PDF 版本[公众号](#公众号)后台回复 **"Java面试突击"** 即可免费领取！ 4. **关于贡献者:** 对本仓库提过有价值的 issue 或 pr 的小伙伴将出现在 [Contributor](#Contributor) 这里。 5. **欢迎投稿：** 由于我个人能力有限，很多知识点我可能没有涉及到，所以你可以对其他知识点进行补充。**对于不错的原创文章我根据你的选择给予现金(50-300)、付费专栏或者任选书籍进行奖励！所以，快提 pr 或者邮件的方式（邮件地址在主页）给我投稿吧！** 当然，我觉得奖励是次要的，最重要的是你可以从自己整理知识点的过程中学习到很多知识。 -4. **【限时福利】** 极客时间[《Java 并发编程面试必备》](#Java并发编程专栏)专栏限时特惠，购买之后的小伙伴加 [我的微信](#联系我) 报上自己的极客时间大名可以找我会把24元返现退给大家，减轻各位学习成本。 ## 目录 @@ -221,12 +220,6 @@  -### Java并发编程专栏 - -微信扫描下方二维码，购买之后我会将自己得到的24元返现都还给你，减轻各位的学习成本！ - - - ### Contributor 下面是笔主收集的一些对本仓库提过有价值的pr或者issue的朋友，人数较多，如果你也对本仓库提过不错的pr或者issue的话，你可以加我的微信与我联系。下面的排名不分先后！ From f1d9128962625affecbab2084d7a105af0fd205f Mon Sep 17 00:00:00 2001 From: haiqiang <43314997+Goose9527@users.noreply.github.com> Date: Sun, 10 Mar 2019 08:52:06 +0800 Subject: [PATCH 094/232] =?UTF-8?q?fix=20grow()=E6=96=B9=E6=B3=95=E6=8F=8F?= =?UTF-8?q?=E8=BF=B0=E4=B8=8D=E5=A4=9F=E4=B8=A5=E8=B0=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- "Java\347\233\270\345\205\263/ArrayList-Grow.md" | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git "a/Java\347\233\270\345\205\263/ArrayList-Grow.md" "b/Java\347\233\270\345\205\263/ArrayList-Grow.md" index d763cb83492..87c695192f6 100644 --- "a/Java\347\233\270\345\205\263/ArrayList-Grow.md" +++ "b/Java\347\233\270\345\205\263/ArrayList-Grow.md" @@ -145,7 +145,7 @@ } ``` -**int newCapacity = oldCapacity + (oldCapacity >> 1),所以 ArrayList 每次扩容之后容量都会变为原来的 1.5 倍！** 记清楚了！不是网上很多人说的 1.5 倍+1！ +**int newCapacity = oldCapacity + (oldCapacity >> 1),所以在capacity是偶数的情况下，ArrayList 每次扩容之后容量都会变为原来的 1.5 倍，当capacity为奇数时(自己初始化容量时可能出现)，第一次扩容容量变为oldCapacity + (oldCapacity - 1) / 2(在计算机运算的情况下减一除和直接除没有差别，对于整数会自动舍掉小数位),也就是说每次扩容相当于计算机中的1.5倍。 ！** 记清楚了！不是网上很多人说的 1.5 倍+1！当然了，第一次扩容以后capacity会变为偶数，之后的每次扩容都会是原容量的1.5倍了。 > ">>"（移位运算符）：>>1 右移一位相当于除2，右移n位相当于除以 2 的 n 次方。这里 oldCapacity 明显右移了1位所以相当于oldCapacity /2。对于大数据的2进制运算,位移运算符比那些普通运算符的运算要快很多,因为程序仅仅移动一下而已,不去计算,这样提高了效率,节省了资源 　 From 89f31e168c1e5205d25c4b089b519bcb2b568464 Mon Sep 17 00:00:00 2001 From: Snailclimb Date: Sun, 10 Mar 2019 11:50:44 +0800 Subject: [PATCH 095/232] Update file name --- .../ArrayList-Grow.md" => Java/ArrayList-Grow.md | 0 "Java\347\233\270\345\205\263/ArrayList.md" => Java/ArrayList.md | 0 .../BIO,NIO,AIO summary.md" => Java/BIO,NIO,AIO summary.md | 0 "Java\347\233\270\345\205\263/HashMap.md" => Java/HashMap.md | 0 .../J2EE\345\237\272\347\241\200\347\237\245\350\257\206.md" | 0 .../Java IO\344\270\216NIO.md" | 0 .../Java\345\237\272\347\241\200\347\237\245\350\257\206.md" | 0 ...231\232\346\213\237\346\234\272\357\274\210jvm\357\274\211.md" | 0 ...51\235\242\350\257\225\351\242\230\346\200\273\347\273\223.md" | 0 .../LinkedList.md" => Java/LinkedList.md | 0 .../Multithread/AQS.md" => Java/Multithread/AQS.md | 0 .../Multithread/Atomic.md" => Java/Multithread/Atomic.md | 0 ...47\272\277\347\250\213\351\235\242\350\257\225\351\242\230.md" | 0 ...45\217\221\345\256\271\345\231\250\346\200\273\347\273\223.md" | 0 .../final\343\200\201static\343\200\201this\343\200\201super.md" | 0 .../synchronized.md" => Java/synchronized.md | 0 ...47\232\204\344\270\200\347\257\207\346\226\207\347\253\240.md" | 0 ...45\244\232\347\272\277\347\250\213\347\263\273\345\210\227.md" | 0 ...46\230\257\350\277\231\344\271\210\347\256\200\345\215\225.md" | 0 .../\350\256\276\350\256\241\346\250\241\345\274\217.md" | 0 ...51\242\230\345\207\240\344\271\216\345\277\205\351\227\256.md" | 0 21 files changed, 0 insertions(+), 0 deletions(-) rename "Java\347\233\270\345\205\263/ArrayList-Grow.md" => Java/ArrayList-Grow.md (100%) rename "Java\347\233\270\345\205\263/ArrayList.md" => Java/ArrayList.md (100%) rename "Java\347\233\270\345\205\263/BIO,NIO,AIO summary.md" => Java/BIO,NIO,AIO summary.md (100%) rename "Java\347\233\270\345\205\263/HashMap.md" => Java/HashMap.md (100%) rename "Java\347\233\270\345\205\263/J2EE\345\237\272\347\241\200\347\237\245\350\257\206.md" => "Java/J2EE\345\237\272\347\241\200\347\237\245\350\257\206.md" (100%) rename "Java\347\233\270\345\205\263/Java IO\344\270\216NIO.md" => "Java/Java IO\344\270\216NIO.md" (100%) rename "Java\347\233\270\345\205\263/Java\345\237\272\347\241\200\347\237\245\350\257\206.md" => "Java/Java\345\237\272\347\241\200\347\237\245\350\257\206.md" (100%) rename "Java\347\233\270\345\205\263/Java\350\231\232\346\213\237\346\234\272\357\274\210jvm\357\274\211.md" => "Java/Java\350\231\232\346\213\237\346\234\272\357\274\210jvm\357\274\211.md" (100%) rename "Java\347\233\270\345\205\263/Java\351\233\206\345\220\210\346\241\206\346\236\266\345\270\270\350\247\201\351\235\242\350\257\225\351\242\230\346\200\273\347\273\223.md" => "Java/Java\351\233\206\345\220\210\346\241\206\346\236\266\345\270\270\350\247\201\351\235\242\350\257\225\351\242\230\346\200\273\347\273\223.md" (100%) rename "Java\347\233\270\345\205\263/LinkedList.md" => Java/LinkedList.md (100%) rename "Java\347\233\270\345\205\263/Multithread/AQS.md" => Java/Multithread/AQS.md (100%) rename "Java\347\233\270\345\205\263/Multithread/Atomic.md" => Java/Multithread/Atomic.md (100%) rename "Java\347\233\270\345\205\263/Multithread/BATJ\351\203\275\347\210\261\351\227\256\347\232\204\345\244\232\347\272\277\347\250\213\351\235\242\350\257\225\351\242\230.md" => "Java/Multithread/BATJ\351\203\275\347\210\261\351\227\256\347\232\204\345\244\232\347\272\277\347\250\213\351\235\242\350\257\225\351\242\230.md" (100%) rename "Java\347\233\270\345\205\263/Multithread/\345\271\266\345\217\221\345\256\271\345\231\250\346\200\273\347\273\223.md" => "Java/Multithread/\345\271\266\345\217\221\345\256\271\345\231\250\346\200\273\347\273\223.md" (100%) rename "Java\347\233\270\345\205\263/final\343\200\201static\343\200\201this\343\200\201super.md" => "Java/final\343\200\201static\343\200\201this\343\200\201super.md" (100%) rename "Java\347\233\270\345\205\263/synchronized.md" => Java/synchronized.md (100%) rename "Java\347\233\270\345\205\263/\345\217\257\350\203\275\346\230\257\346\212\212Java\345\206\205\345\255\230\345\214\272\345\237\237\350\256\262\347\232\204\346\234\200\346\270\205\346\245\232\347\232\204\344\270\200\347\257\207\346\226\207\347\253\240.md" => "Java/\345\217\257\350\203\275\346\230\257\346\212\212Java\345\206\205\345\255\230\345\214\272\345\237\237\350\256\262\347\232\204\346\234\200\346\270\205\346\245\232\347\232\204\344\270\200\347\257\207\346\226\207\347\253\240.md" (100%) rename "Java\347\233\270\345\205\263/\345\244\232\347\272\277\347\250\213\347\263\273\345\210\227.md" => "Java/\345\244\232\347\272\277\347\250\213\347\263\273\345\210\227.md" (100%) rename "Java\347\233\270\345\205\263/\346\220\236\345\256\232JVM\345\236\203\345\234\276\345\233\236\346\224\266\345\260\261\346\230\257\350\277\231\344\271\210\347\256\200\345\215\225.md" => "Java/\346\220\236\345\256\232JVM\345\236\203\345\234\276\345\233\236\346\224\266\345\260\261\346\230\257\350\277\231\344\271\210\347\256\200\345\215\225.md" (100%) rename "Java\347\233\270\345\205\263/\350\256\276\350\256\241\346\250\241\345\274\217.md" => "Java/\350\256\276\350\256\241\346\250\241\345\274\217.md" (100%) rename "Java\347\233\270\345\205\263/\350\277\231\345\207\240\351\201\223Java\351\233\206\345\220\210\346\241\206\346\236\266\351\235\242\350\257\225\351\242\230\345\207\240\344\271\216\345\277\205\351\227\256.md" => "Java/\350\277\231\345\207\240\351\201\223Java\351\233\206\345\220\210\346\241\206\346\236\266\351\235\242\350\257\225\351\242\230\345\207\240\344\271\216\345\277\205\351\227\256.md" (100%) diff --git "a/Java\347\233\270\345\205\263/ArrayList-Grow.md" b/Java/ArrayList-Grow.md similarity index 100% rename from "Java\347\233\270\345\205\263/ArrayList-Grow.md" rename to Java/ArrayList-Grow.md diff --git "a/Java\347\233\270\345\205\263/ArrayList.md" b/Java/ArrayList.md similarity index 100% rename from "Java\347\233\270\345\205\263/ArrayList.md" rename to Java/ArrayList.md diff --git "a/Java\347\233\270\345\205\263/BIO,NIO,AIO summary.md" b/Java/BIO,NIO,AIO summary.md similarity index 100% rename from "Java\347\233\270\345\205\263/BIO,NIO,AIO summary.md" rename to Java/BIO,NIO,AIO summary.md diff --git "a/Java\347\233\270\345\205\263/HashMap.md" b/Java/HashMap.md similarity index 100% rename from "Java\347\233\270\345\205\263/HashMap.md" rename to Java/HashMap.md diff --git "a/Java\347\233\270\345\205\263/J2EE\345\237\272\347\241\200\347\237\245\350\257\206.md" "b/Java/J2EE\345\237\272\347\241\200\347\237\245\350\257\206.md" similarity index 100% rename from "Java\347\233\270\345\205\263/J2EE\345\237\272\347\241\200\347\237\245\350\257\206.md" rename to "Java/J2EE\345\237\272\347\241\200\347\237\245\350\257\206.md" diff --git "a/Java\347\233\270\345\205\263/Java IO\344\270\216NIO.md" "b/Java/Java IO\344\270\216NIO.md" similarity index 100% rename from "Java\347\233\270\345\205\263/Java IO\344\270\216NIO.md" rename to "Java/Java IO\344\270\216NIO.md" diff --git "a/Java\347\233\270\345\205\263/Java\345\237\272\347\241\200\347\237\245\350\257\206.md" "b/Java/Java\345\237\272\347\241\200\347\237\245\350\257\206.md" similarity index 100% rename from "Java\347\233\270\345\205\263/Java\345\237\272\347\241\200\347\237\245\350\257\206.md" rename to "Java/Java\345\237\272\347\241\200\347\237\245\350\257\206.md" diff --git "a/Java\347\233\270\345\205\263/Java\350\231\232\346\213\237\346\234\272\357\274\210jvm\357\274\211.md" "b/Java/Java\350\231\232\346\213\237\346\234\272\357\274\210jvm\357\274\211.md" similarity index 100% rename from "Java\347\233\270\345\205\263/Java\350\231\232\346\213\237\346\234\272\357\274\210jvm\357\274\211.md" rename to "Java/Java\350\231\232\346\213\237\346\234\272\357\274\210jvm\357\274\211.md" diff --git "a/Java\347\233\270\345\205\263/Java\351\233\206\345\220\210\346\241\206\346\236\266\345\270\270\350\247\201\351\235\242\350\257\225\351\242\230\346\200\273\347\273\223.md" "b/Java/Java\351\233\206\345\220\210\346\241\206\346\236\266\345\270\270\350\247\201\351\235\242\350\257\225\351\242\230\346\200\273\347\273\223.md" similarity index 100% rename from "Java\347\233\270\345\205\263/Java\351\233\206\345\220\210\346\241\206\346\236\266\345\270\270\350\247\201\351\235\242\350\257\225\351\242\230\346\200\273\347\273\223.md" rename to "Java/Java\351\233\206\345\220\210\346\241\206\346\236\266\345\270\270\350\247\201\351\235\242\350\257\225\351\242\230\346\200\273\347\273\223.md" diff --git "a/Java\347\233\270\345\205\263/LinkedList.md" b/Java/LinkedList.md similarity index 100% rename from "Java\347\233\270\345\205\263/LinkedList.md" rename to Java/LinkedList.md diff --git "a/Java\347\233\270\345\205\263/Multithread/AQS.md" b/Java/Multithread/AQS.md similarity index 100% rename from "Java\347\233\270\345\205\263/Multithread/AQS.md" rename to Java/Multithread/AQS.md diff --git "a/Java\347\233\270\345\205\263/Multithread/Atomic.md" b/Java/Multithread/Atomic.md similarity index 100% rename from "Java\347\233\270\345\205\263/Multithread/Atomic.md" rename to Java/Multithread/Atomic.md diff --git "a/Java\347\233\270\345\205\263/Multithread/BATJ\351\203\275\347\210\261\351\227\256\347\232\204\345\244\232\347\272\277\347\250\213\351\235\242\350\257\225\351\242\230.md" "b/Java/Multithread/BATJ\351\203\275\347\210\261\351\227\256\347\232\204\345\244\232\347\272\277\347\250\213\351\235\242\350\257\225\351\242\230.md" similarity index 100% rename from "Java\347\233\270\345\205\263/Multithread/BATJ\351\203\275\347\210\261\351\227\256\347\232\204\345\244\232\347\272\277\347\250\213\351\235\242\350\257\225\351\242\230.md" rename to "Java/Multithread/BATJ\351\203\275\347\210\261\351\227\256\347\232\204\345\244\232\347\272\277\347\250\213\351\235\242\350\257\225\351\242\230.md" diff --git "a/Java\347\233\270\345\205\263/Multithread/\345\271\266\345\217\221\345\256\271\345\231\250\346\200\273\347\273\223.md" "b/Java/Multithread/\345\271\266\345\217\221\345\256\271\345\231\250\346\200\273\347\273\223.md" similarity index 100% rename from "Java\347\233\270\345\205\263/Multithread/\345\271\266\345\217\221\345\256\271\345\231\250\346\200\273\347\273\223.md" rename to "Java/Multithread/\345\271\266\345\217\221\345\256\271\345\231\250\346\200\273\347\273\223.md" diff --git "a/Java\347\233\270\345\205\263/final\343\200\201static\343\200\201this\343\200\201super.md" "b/Java/final\343\200\201static\343\200\201this\343\200\201super.md" similarity index 100% rename from "Java\347\233\270\345\205\263/final\343\200\201static\343\200\201this\343\200\201super.md" rename to "Java/final\343\200\201static\343\200\201this\343\200\201super.md" diff --git "a/Java\347\233\270\345\205\263/synchronized.md" b/Java/synchronized.md similarity index 100% rename from "Java\347\233\270\345\205\263/synchronized.md" rename to Java/synchronized.md diff --git "a/Java\347\233\270\345\205\263/\345\217\257\350\203\275\346\230\257\346\212\212Java\345\206\205\345\255\230\345\214\272\345\237\237\350\256\262\347\232\204\346\234\200\346\270\205\346\245\232\347\232\204\344\270\200\347\257\207\346\226\207\347\253\240.md" "b/Java/\345\217\257\350\203\275\346\230\257\346\212\212Java\345\206\205\345\255\230\345\214\272\345\237\237\350\256\262\347\232\204\346\234\200\346\270\205\346\245\232\347\232\204\344\270\200\347\257\207\346\226\207\347\253\240.md" similarity index 100% rename from "Java\347\233\270\345\205\263/\345\217\257\350\203\275\346\230\257\346\212\212Java\345\206\205\345\255\230\345\214\272\345\237\237\350\256\262\347\232\204\346\234\200\346\270\205\346\245\232\347\232\204\344\270\200\347\257\207\346\226\207\347\253\240.md" rename to "Java/\345\217\257\350\203\275\346\230\257\346\212\212Java\345\206\205\345\255\230\345\214\272\345\237\237\350\256\262\347\232\204\346\234\200\346\270\205\346\245\232\347\232\204\344\270\200\347\257\207\346\226\207\347\253\240.md" diff --git "a/Java\347\233\270\345\205\263/\345\244\232\347\272\277\347\250\213\347\263\273\345\210\227.md" "b/Java/\345\244\232\347\272\277\347\250\213\347\263\273\345\210\227.md" similarity index 100% rename from "Java\347\233\270\345\205\263/\345\244\232\347\272\277\347\250\213\347\263\273\345\210\227.md" rename to "Java/\345\244\232\347\272\277\347\250\213\347\263\273\345\210\227.md" diff --git "a/Java\347\233\270\345\205\263/\346\220\236\345\256\232JVM\345\236\203\345\234\276\345\233\236\346\224\266\345\260\261\346\230\257\350\277\231\344\271\210\347\256\200\345\215\225.md" "b/Java/\346\220\236\345\256\232JVM\345\236\203\345\234\276\345\233\236\346\224\266\345\260\261\346\230\257\350\277\231\344\271\210\347\256\200\345\215\225.md" similarity index 100% rename from "Java\347\233\270\345\205\263/\346\220\236\345\256\232JVM\345\236\203\345\234\276\345\233\236\346\224\266\345\260\261\346\230\257\350\277\231\344\271\210\347\256\200\345\215\225.md" rename to "Java/\346\220\236\345\256\232JVM\345\236\203\345\234\276\345\233\236\346\224\266\345\260\261\346\230\257\350\277\231\344\271\210\347\256\200\345\215\225.md" diff --git "a/Java\347\233\270\345\205\263/\350\256\276\350\256\241\346\250\241\345\274\217.md" "b/Java/\350\256\276\350\256\241\346\250\241\345\274\217.md" similarity index 100% rename from "Java\347\233\270\345\205\263/\350\256\276\350\256\241\346\250\241\345\274\217.md" rename to "Java/\350\256\276\350\256\241\346\250\241\345\274\217.md" diff --git "a/Java\347\233\270\345\205\263/\350\277\231\345\207\240\351\201\223Java\351\233\206\345\220\210\346\241\206\346\236\266\351\235\242\350\257\225\351\242\230\345\207\240\344\271\216\345\277\205\351\227\256.md" "b/Java/\350\277\231\345\207\240\351\201\223Java\351\233\206\345\220\210\346\241\206\346\236\266\351\235\242\350\257\225\351\242\230\345\207\240\344\271\216\345\277\205\351\227\256.md" similarity index 100% rename from "Java\347\233\270\345\205\263/\350\277\231\345\207\240\351\201\223Java\351\233\206\345\220\210\346\241\206\346\236\266\351\235\242\350\257\225\351\242\230\345\207\240\344\271\216\345\277\205\351\227\256.md" rename to "Java/\350\277\231\345\207\240\351\201\223Java\351\233\206\345\220\210\346\241\206\346\236\266\351\235\242\350\257\225\351\242\230\345\207\240\344\271\216\345\277\205\351\227\256.md" From 4fa37666687eb84b10b96109b25718163cc084a4 Mon Sep 17 00:00:00 2001 From: SnailClimb Date: Sun, 10 Mar 2019 11:53:33 +0800 Subject: [PATCH 096/232] Update link --- README.md | 34 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/README.md b/README.md index 97dfe496f46..a86a23e1eee 100644 --- a/README.md +++ b/README.md @@ -56,33 +56,33 @@ ### Java/J2EE 基础 -* [Java 基础知识回顾](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/Java基础知识.md) -* [J2EE 基础知识回顾](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/J2EE基础知识.md) +* [Java 基础知识回顾](https://github.com/Snailclimb/Java-Guide/blob/master/Java/Java基础知识.md) +* [J2EE 基础知识回顾](https://github.com/Snailclimb/Java-Guide/blob/master/Java/J2EE基础知识.md) * [Java常见关键字总结：static、final、this、super](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/final、static、this、super.md) ### Java 集合框架 -* [这几道Java集合框架面试题几乎必问](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/这几道Java集合框架面试题几乎必问.md) -* [Java 集合框架常见面试题总结](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/Java集合框架常见面试题总结.md) -* [ArrayList 源码学习](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/ArrayList.md) -* [【面试必备】透过源码角度一步一步带你分析 ArrayList 扩容机制](https://github.com/Snailclimb/JavaGuide/blob/master/Java相关/ArrayList-Grow.md) -* [LinkedList 源码学习](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/LinkedList.md) -* [HashMap(JDK1.8)源码学习](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/HashMap.md) +* [这几道Java集合框架面试题几乎必问](https://github.com/Snailclimb/Java-Guide/blob/master/Java/这几道Java集合框架面试题几乎必问.md) +* [Java 集合框架常见面试题总结](https://github.com/Snailclimb/Java-Guide/blob/master/Java/Java集合框架常见面试题总结.md) +* [ArrayList 源码学习](https://github.com/Snailclimb/Java-Guide/blob/master/Java/ArrayList.md) +* [【面试必备】透过源码角度一步一步带你分析 ArrayList 扩容机制](https://github.com/Snailclimb/JavaGuide/blob/master/Java/ArrayList-Grow.md) +* [LinkedList 源码学习](https://github.com/Snailclimb/Java-Guide/blob/master/Java/LinkedList.md) +* [HashMap(JDK1.8)源码学习](https://github.com/Snailclimb/Java-Guide/blob/master/Java/HashMap.md) ### Java 多线程 -* [并发编程面试必备：synchronized 关键字使用、底层原理、JDK1.6 之后的底层优化以及 和ReenTrantLock 的对比](https://github.com/Snailclimb/Java_Guide/blob/master/Java相关/synchronized.md) -* [并发编程面试必备：乐观锁与悲观锁](https://github.com/Snailclimb/Java-Guide/blob/master/面试必备/面试必备之乐观锁与悲观锁.md) -* [并发编程面试必备：JUC 中的 Atomic 原子类总结](https://github.com/Snailclimb/Java_Guide/blob/master/Java相关/Multithread/Atomic.md) -* [并发编程面试必备：AQS 原理以及 AQS 同步组件总结](https://github.com/Snailclimb/Java_Guide/blob/master/Java相关/Multithread/AQS.md) -* [BATJ都爱问的多线程面试题](https://github.com/Snailclimb/Java_Guide/blob/master/Java相关/Multithread/BATJ都爱问的多线程面试题.md) -* [并发容器总结](https://github.com/Snailclimb/Java_Guide/blob/master/Java相关/Multithread/并发容器总结.md) +* [并发编程面试必备：synchronized 关键字使用、底层原理、JDK1.6 之后的底层优化以及 和ReenTrantLock 的对比](https://github.com/Snailclimb/Java_Guide/blob/master/Java/synchronized.md) +* [并发编程面试必备：乐观锁与悲观锁](https://github.com/Snailclimb/Java-Guide/blob/master/EssentialContentForInterview/面试必备之乐观锁与悲观锁.md) +* [并发编程面试必备：JUC 中的 Atomic 原子类总结](https://github.com/Snailclimb/Java_Guide/blob/master/Java/Multithread/Atomic.md) +* [并发编程面试必备：AQS 原理以及 AQS 同步组件总结](https://github.com/Snailclimb/Java_Guide/blob/master/Java/Multithread/AQS.md) +* [BATJ都爱问的多线程面试题](https://github.com/Snailclimb/Java_Guide/blob/master/Java/Multithread/BATJ都爱问的多线程面试题.md) +* [并发容器总结](https://github.com/Snailclimb/Java_Guide/blob/master/Java/Multithread/并发容器总结.md) ### Java 虚拟机 jvm -* [可能是把Java内存区域讲的最清楚的一篇文章](https://github.com/Snailclimb/Java_Guide/blob/master/Java相关/可能是把Java内存区域讲的最清楚的一篇文章.md) -* [搞定JVM垃圾回收就是这么简单](https://github.com/Snailclimb/Java_Guide/blob/master/Java相关/搞定JVM垃圾回收就是这么简单.md) -* [《深入理解Java虚拟机》第2版学习笔记](https://github.com/Snailclimb/Java_Guide/blob/master/Java相关/Java虚拟机（jvm）.md) +* [可能是把Java内存区域讲的最清楚的一篇文章](https://github.com/Snailclimb/Java_Guide/blob/master/Java/可能是把Java内存区域讲的最清楚的一篇文章.md) +* [搞定JVM垃圾回收就是这么简单](https://github.com/Snailclimb/Java_Guide/blob/master/Java/搞定JVM垃圾回收就是这么简单.md) +* [《深入理解Java虚拟机》第2版学习笔记](https://github.com/Snailclimb/Java_Guide/blob/master/Java/Java虚拟机（jvm）.md) ### Java BIO,NIO,AIO From d49e98a9221a990fc0bb2ed6a359136333e63de2 Mon Sep 17 00:00:00 2001 From: SnailClimb Date: Sun, 10 Mar 2019 11:54:31 +0800 Subject: [PATCH 097/232] Fix link error --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index a86a23e1eee..77133eaa8cf 100644 --- a/README.md +++ b/README.md @@ -58,7 +58,7 @@ * [Java 基础知识回顾](https://github.com/Snailclimb/Java-Guide/blob/master/Java/Java基础知识.md) * [J2EE 基础知识回顾](https://github.com/Snailclimb/Java-Guide/blob/master/Java/J2EE基础知识.md) -* [Java常见关键字总结：static、final、this、super](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/final、static、this、super.md) +* [Java常见关键字总结：static、final、this、super](https://github.com/Snailclimb/Java-Guide/blob/master/Java/final、static、this、super.md) ### Java 集合框架 From 64bd23ed2be89a56652780871dfe784d55a15683 Mon Sep 17 00:00:00 2001 From: Snailclimb Date: Sun, 10 Mar 2019 12:04:58 +0800 Subject: [PATCH 098/232] Update README.md --- README.md | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index 97dfe496f46..b446cbd00f5 100644 --- a/README.md +++ b/README.md @@ -62,12 +62,14 @@ ### Java 集合框架 -* [这几道Java集合框架面试题几乎必问](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/这几道Java集合框架面试题几乎必问.md) -* [Java 集合框架常见面试题总结](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/Java集合框架常见面试题总结.md) -* [ArrayList 源码学习](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/ArrayList.md) -* [【面试必备】透过源码角度一步一步带你分析 ArrayList 扩容机制](https://github.com/Snailclimb/JavaGuide/blob/master/Java相关/ArrayList-Grow.md) -* [LinkedList 源码学习](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/LinkedList.md) -* [HashMap(JDK1.8)源码学习](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/HashMap.md) +* **常见问题总结：** + * [这几道Java集合框架面试题几乎必问](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/这几道Java集合框架面试题几乎必问.md) + * [Java 集合框架常见面试题总结](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/Java集合框架常见面试题总结.md) +* **源码分析：** + * [ArrayList 源码学习](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/ArrayList.md) + * [【面试必备】透过源码角度一步一步带你分析 ArrayList 扩容机制](https://github.com/Snailclimb/JavaGuide/blob/master/Java相关/ArrayList-Grow.md) + * [LinkedList 源码学习](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/LinkedList.md) + * [HashMap(JDK1.8)源码学习](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/HashMap.md) ### Java 多线程 From 67f4458fa96d4af029f495135d0451945b6fa21f Mon Sep 17 00:00:00 2001 From: SnailClimb Date: Sun, 10 Mar 2019 14:38:21 +0800 Subject: [PATCH 099/232] Update link error --- README.md | 42 +++++++++++++++++++++--------------------- 1 file changed, 21 insertions(+), 21 deletions(-) diff --git a/README.md b/README.md index b446cbd00f5..35d96d7251c 100644 --- a/README.md +++ b/README.md @@ -56,44 +56,44 @@ ### Java/J2EE 基础 -* [Java 基础知识回顾](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/Java基础知识.md) -* [J2EE 基础知识回顾](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/J2EE基础知识.md) -* [Java常见关键字总结：static、final、this、super](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/final、static、this、super.md) +* [Java 基础知识回顾](https://github.com/Snailclimb/Java-Guide/blob/master/Java/Java基础知识.md) +* [J2EE 基础知识回顾](https://github.com/Snailclimb/Java-Guide/blob/master/Java/J2EE基础知识.md) +* [Java常见关键字总结：static、final、this、super](https://github.com/Snailclimb/Java-Guide/blob/master/Java/final、static、this、super.md) ### Java 集合框架 * **常见问题总结：** - * [这几道Java集合框架面试题几乎必问](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/这几道Java集合框架面试题几乎必问.md) - * [Java 集合框架常见面试题总结](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/Java集合框架常见面试题总结.md) + * [这几道Java集合框架面试题几乎必问](https://github.com/Snailclimb/Java-Guide/blob/master/Java/这几道Java集合框架面试题几乎必问.md) + * [Java 集合框架常见面试题总结](https://github.com/Snailclimb/Java-Guide/blob/master/Java/Java集合框架常见面试题总结.md) * **源码分析：** - * [ArrayList 源码学习](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/ArrayList.md) - * [【面试必备】透过源码角度一步一步带你分析 ArrayList 扩容机制](https://github.com/Snailclimb/JavaGuide/blob/master/Java相关/ArrayList-Grow.md) - * [LinkedList 源码学习](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/LinkedList.md) - * [HashMap(JDK1.8)源码学习](https://github.com/Snailclimb/Java-Guide/blob/master/Java相关/HashMap.md) + * [ArrayList 源码学习](https://github.com/Snailclimb/Java-Guide/blob/master/Java/ArrayList.md) + * [【面试必备】透过源码角度一步一步带你分析 ArrayList 扩容机制](https://github.com/Snailclimb/JavaGuide/blob/master/Java/ArrayList-Grow.md) + * [LinkedList 源码学习](https://github.com/Snailclimb/Java-Guide/blob/master/Java/LinkedList.md) + * [HashMap(JDK1.8)源码学习](https://github.com/Snailclimb/Java-Guide/blob/master/Java/HashMap.md) ### Java 多线程 -* [并发编程面试必备：synchronized 关键字使用、底层原理、JDK1.6 之后的底层优化以及 和ReenTrantLock 的对比](https://github.com/Snailclimb/Java_Guide/blob/master/Java相关/synchronized.md) -* [并发编程面试必备：乐观锁与悲观锁](https://github.com/Snailclimb/Java-Guide/blob/master/面试必备/面试必备之乐观锁与悲观锁.md) -* [并发编程面试必备：JUC 中的 Atomic 原子类总结](https://github.com/Snailclimb/Java_Guide/blob/master/Java相关/Multithread/Atomic.md) -* [并发编程面试必备：AQS 原理以及 AQS 同步组件总结](https://github.com/Snailclimb/Java_Guide/blob/master/Java相关/Multithread/AQS.md) -* [BATJ都爱问的多线程面试题](https://github.com/Snailclimb/Java_Guide/blob/master/Java相关/Multithread/BATJ都爱问的多线程面试题.md) -* [并发容器总结](https://github.com/Snailclimb/Java_Guide/blob/master/Java相关/Multithread/并发容器总结.md) +* [并发编程面试必备：synchronized 关键字使用、底层原理、JDK1.6 之后的底层优化以及 和ReenTrantLock 的对比](https://github.com/Snailclimb/Java_Guide/blob/master/Java/synchronized.md) +* [并发编程面试必备：乐观锁与悲观锁](https://github.com/Snailclimb/Java-Guide/blob/master/EssentialContentForInterview/面试必备之乐观锁与悲观锁.md) +* [并发编程面试必备：JUC 中的 Atomic 原子类总结](https://github.com/Snailclimb/Java_Guide/blob/master/Java/Multithread/Atomic.md) +* [并发编程面试必备：AQS 原理以及 AQS 同步组件总结](https://github.com/Snailclimb/Java_Guide/blob/master/Java/Multithread/AQS.md) +* [BATJ都爱问的多线程面试题](https://github.com/Snailclimb/Java_Guide/blob/master/Java/Multithread/BATJ都爱问的多线程面试题.md) +* [并发容器总结](https://github.com/Snailclimb/Java_Guide/blob/master/Java/Multithread/并发容器总结.md) ### Java 虚拟机 jvm -* [可能是把Java内存区域讲的最清楚的一篇文章](https://github.com/Snailclimb/Java_Guide/blob/master/Java相关/可能是把Java内存区域讲的最清楚的一篇文章.md) -* [搞定JVM垃圾回收就是这么简单](https://github.com/Snailclimb/Java_Guide/blob/master/Java相关/搞定JVM垃圾回收就是这么简单.md) -* [《深入理解Java虚拟机》第2版学习笔记](https://github.com/Snailclimb/Java_Guide/blob/master/Java相关/Java虚拟机（jvm）.md) +* [可能是把Java内存区域讲的最清楚的一篇文章](https://github.com/Snailclimb/Java_Guide/blob/master/Java/可能是把Java内存区域讲的最清楚的一篇文章.md) +* [搞定JVM垃圾回收就是这么简单](https://github.com/Snailclimb/Java_Guide/blob/master/Java/搞定JVM垃圾回收就是这么简单.md) +* [《深入理解Java虚拟机》第2版学习笔记](https://github.com/Snailclimb/Java_Guide/blob/master/Java/Java虚拟机（jvm）.md) ### Java BIO,NIO,AIO -* [BIO,NIO,AIO 总结 ](https://github.com/Snailclimb/JavaGuide/blob/master/Java%E7%9B%B8%E5%85%B3/BIO%2CNIO%2CAIO%20summary.md) -* [Java IO 与 NIO系列文章](https://github.com/Snailclimb/Java_Guide/blob/master/Java相关/Java%20IO与NIO.md) +* [BIO,NIO,AIO 总结 ](https://github.com/Snailclimb/JavaGuide/blob/master/Java/BIO%2CNIO%2CAIO%20summary.md) +* [Java IO 与 NIO系列文章](https://github.com/Snailclimb/Java_Guide/blob/master/Java/Java%20IO与NIO.md) ### 设计模式 -* [设计模式系列文章](https://github.com/Snailclimb/Java_Guide/blob/master/Java相关/设计模式.md) +* [设计模式系列文章](https://github.com/Snailclimb/Java_Guide/blob/master/Java/设计模式.md) ## 数据结构与算法 From 5053edca3ac5071f5e8f3db84f21d6acca795091 Mon Sep 17 00:00:00 2001 From: haiqiang <43314997+Goose9527@users.noreply.github.com> Date: Sun, 10 Mar 2019 19:50:05 +0800 Subject: [PATCH 100/232] 0.0.1 Snapshot --- .../What's New in JDK8/README.md" | 24 +++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 "Java\347\233\270\345\205\263/What's New in JDK8/README.md" diff --git "a/Java\347\233\270\345\205\263/What's New in JDK8/README.md" "b/Java\347\233\270\345\205\263/What's New in JDK8/README.md" new file mode 100644 index 00000000000..3206a31e4fd --- /dev/null +++ "b/Java\347\233\270\345\205\263/What's New in JDK8/README.md" @@ -0,0 +1,24 @@ +JDK8新特性总结 +====== +总结了部分JDK8新特性，另外一些新特性可以通过Oracle的官方文档查看，毕竟是官方文档，各种新特性都会介绍，有兴趣的可以去看。
+[Oracle官方文档:What's New in JDK8](https://www.oracle.com/technetwork/java/javase/8-whats-new-2157071.html) +----- +- [Java语言特性]() + - [Lambda表达式是一个新的语言特性，已经在JDK8中加入。它是一个可以传递的代码块，你也可以把它们当做方法参数。 + Lambda表达式允许您更紧凑地创建单虚方法接口（称为功能接口）的实例。]() + + - [方法引用为已经存在的具名方法提供易于阅读的Lambda表达式]() + + - [默认方法允许将新功能添加到库的接口，并确保与为这些接口的旧版本编写的代码的二进制兼容性。]() + + - [改进的类型推断。]() + + - [方法参数反射。]() + +- [流(stream)]() + - [新java.util.stream包中的类提供Stream API以支持对元素流的功能样式操作。流(stream)和I/O里的流不是同一个概念 + ，使用stream API可以更方便的操作集合。]() + +- [国际化]() + - 代办 +- 代办 From 2b204632274dc2119ab2d0d0a76e1ff3b83190e0 Mon Sep 17 00:00:00 2001 From: haiqiang <43314997+Goose9527@users.noreply.github.com> Date: Sun, 10 Mar 2019 21:27:08 +0800 Subject: [PATCH 101/232] =?UTF-8?q?Create=20Lambda=E8=A1=A8=E8=BE=BE?= =?UTF-8?q?=E5=BC=8F.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...da\350\241\250\350\276\276\345\274\217.md" | 64 +++++++++++++++++++ 1 file changed, 64 insertions(+) create mode 100644 "Java\347\233\270\345\205\263/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" diff --git "a/Java\347\233\270\345\205\263/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" "b/Java\347\233\270\345\205\263/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" new file mode 100644 index 00000000000..0d1b89981f6 --- /dev/null +++ "b/Java\347\233\270\345\205\263/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" @@ -0,0 +1,64 @@ +JDK8--Lambda表达式 +=== +## 1.什么是Lambda表达式 +**Lambda表达式实质上是一个可传递的代码块，Lambda又称为闭包或者匿名函数，是函数式编程语法，让方法可以像普通参数一样传递** + +## 2.Lambda表达式语法 +```(参数列表) -> {执行代码块}``` +
参数列表可以为空```()->{}``` +
可以加类型声明比如```(String para1, int para2) -> {return para1 + para2;}```我们可以看到，lambda同样可以有返回值. +
在编译器可以推断出类型的时候，可以将类型声明省略，比如```(para1, para2) -> {return para1 + para2;}``` +
(lambda有点像动态类型语言，并且lambda在字节码层面是用invokedynamic实现的，而这条指令就是为了让JVM更好的支持运行在其上的动态类型语言) + +## 3.函数式接口 +在了解Lambda表达式之前，有必要先了解什么是函数式接口```(@FunctionalInterface)```
+**函数式接口指的是有且只有一个抽象(abstract)方法的接口**
+当需要一个函数式接口的对象时，就可以用Lambda表达式来实现，举个常用的例子: +
+``` + Thread thread = new Thread(() -> { + System.out.println("This is JDK8's Lambda!"); + }); +``` +这段代码和函数式接口有啥关系？我们回忆一下，Thread类的构造函数里是不是有一个以Runnable接口为参数的？ +``` +public Thread(Runnable target) {...} + +/** + * Runnable Interface + */ +@FunctionalInterface +public interface Runnable { + public abstract void run(); +} +``` +到这里大家可能已经明白了，**Lambda表达式相当于一个匿名类或者说是一个匿名方法**。上面Thread的例子相当于 +``` + Thread thread = new Thread(new Runnable() { + @Override + public void run() { + System.out.println("Anonymous class"); + } + }); +``` +也就是说，上面的lambda表达式相当于实现了这个run()方法，然后当做参数传入(个人感觉可以这么理解,lambda表达式就是一个函数，只不过它的返回值、参数列表都 +由编译器帮我们推断，因此可以减少很多代码量)。 +
至此大家应该明白什么是函数式接口以及函数式接口和lambda表达式之间的关系了。在JDK8中修改了接口的规范， +目的是为了在给接口添加新的功能时保持向前兼容(个人理解)，比如一个已经定义了的函数式接口，某天我们想给它添加新功能，那么就不能保持向前兼容了， +因为在旧的接口规范下，添加新功能必定会破坏这个函数式接口[(JDK8中接口规范)]() +
+除了上面说的Runnable接口之外，JDK中已经存在了很多函数式接口 +比如(当然不止这些): +- ```java.util.concurrent.Callable``` +- ```java.util.Comparator``` +- ```java.io.FileFilter``` +
**关于JDK中的预定义的函数式接口** + +- JDK在```java.util.function```下预定义了很多函数式接口 + - ```Function {R apply(T t);}``` 接受一个T对象，然后返回一个R对象，就像普通的函数。 + - ```Consumer {void accept(T t);}``` 消费者 接受一个T对象，没有返回值。 + - ```Predicate {boolean test(T t);}``` 判断，接受一个T对象，返回一个布尔值。 + - ```Supplier {T get();} 提供者(工厂)``` 返回一个T对象。 + - 其他的跟上面的相似，大家可以看一下function包下的具体接口。 + +## 4.[方法引用]() From d1c564bb84bc4f6821f8c6ab1f38f1198c07be13 Mon Sep 17 00:00:00 2001 From: haiqiang <43314997+Goose9527@users.noreply.github.com> Date: Sun, 10 Mar 2019 21:27:51 +0800 Subject: [PATCH 102/232] Update README.md --- "Java\347\233\270\345\205\263/What's New in JDK8/README.md" | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git "a/Java\347\233\270\345\205\263/What's New in JDK8/README.md" "b/Java\347\233\270\345\205\263/What's New in JDK8/README.md" index 3206a31e4fd..b7612fa4183 100644 --- "a/Java\347\233\270\345\205\263/What's New in JDK8/README.md" +++ "b/Java\347\233\270\345\205\263/What's New in JDK8/README.md" @@ -5,7 +5,7 @@ JDK8新特性总结 ----- - [Java语言特性]() - [Lambda表达式是一个新的语言特性，已经在JDK8中加入。它是一个可以传递的代码块，你也可以把它们当做方法参数。 - Lambda表达式允许您更紧凑地创建单虚方法接口（称为功能接口）的实例。]() + Lambda表达式允许您更紧凑地创建单虚方法接口（称为功能接口）的实例。](https://github.com/Goose9527/JavaGuide/blob/master/Java%E7%9B%B8%E5%85%B3/What's%20New%20in%20JDK8/Lambda%E8%A1%A8%E8%BE%BE%E5%BC%8F.md) - [方法引用为已经存在的具名方法提供易于阅读的Lambda表达式]() From cfbc8c45cf4ec466c8bd8e79a547e3018c3ec09a Mon Sep 17 00:00:00 2001 From: haiqiang <43314997+Goose9527@users.noreply.github.com> Date: Sun, 10 Mar 2019 22:44:54 +0800 Subject: [PATCH 103/232] =?UTF-8?q?Create=20JDK8=E6=8E=A5=E5=8F=A3?= =?UTF-8?q?=E8=A7=84=E8=8C=83.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...45\345\217\243\350\247\204\350\214\203.md" | 164 ++++++++++++++++++ 1 file changed, 164 insertions(+) create mode 100644 "Java\347\233\270\345\205\263/What's New in JDK8/JDK8\346\216\245\345\217\243\350\247\204\350\214\203.md" diff --git "a/Java\347\233\270\345\205\263/What's New in JDK8/JDK8\346\216\245\345\217\243\350\247\204\350\214\203.md" "b/Java\347\233\270\345\205\263/What's New in JDK8/JDK8\346\216\245\345\217\243\350\247\204\350\214\203.md" new file mode 100644 index 00000000000..0332ecced69 --- /dev/null +++ "b/Java\347\233\270\345\205\263/What's New in JDK8/JDK8\346\216\245\345\217\243\350\247\204\350\214\203.md" @@ -0,0 +1,164 @@ +JDK8接口规范 +=== +在JDK8中引入了lambda表达式，因此出现了函数式接口的概念，为了保持向前兼容性(比如泛型也是为了保持兼容性而失去了在一些别的语言泛型拥有的功能)， +Java接口规范发生了一些改变。 +--- +## 1.JDK8以前的接口规范 +- JDK8以前接口可以定义的变量和方法 + - 所有变量(Field)不论是否显式 的声明为```public static final```，它实际上都是```public static final```的。 + - 所有方法(Method)不论是否显示 的声明为```public abstract```，它实际上都是```public abstract```的。 +```java +public interface AInterfaceBeforeJDK8 { + int FIELD = 0; + void simpleMethod(); +} +``` +以上接口信息反编译以后可以看到字节码信息里Filed是public static final的，而方法是public abstract的，即是你没有显示的去声明它。 +```java +{ + public static final int FIELD; + descriptor: I + flags: (0x0019) ACC_PUBLIC, ACC_STATIC, ACC_FINAL + ConstantValue: int 0 + + public abstract void simpleMethod(); + descriptor: ()V + flags: (0x0401) ACC_PUBLIC, ACC_ABSTRACT +} +``` +## 2.JDK8之后的接口规范 +- JDK8之后接口可以定义的变量和方法 + - 变量(Field)仍然必须是 ```java public static final```的 + - 方法(Method)除了可以是public abstract之外，还可以是public static或者是default(相当于仅public修饰的实例方法)的。 +从以上改变不难看出，修改接口的规范主要是为了能在扩展接口时保持向前兼容。 +
下面是一个JDK8之后的接口例子 +```java +public interface AInterfaceInJDK8 { + int simpleFiled = 0; + static int staticField = 1; + + public static void main(String[] args) { + } + static void staticMethod(){} + + default void defaultMethod(){} + + void simpleMethod() throws IOException; + +} +``` +进行反编译(去除了一些没用信息) +```java +{ + public static final int simpleFiled; + flags: (0x0019) ACC_PUBLIC, ACC_STATIC, ACC_FINAL + + public static final int staticField; + flags: (0x0019) ACC_PUBLIC, ACC_STATIC, ACC_FINAL + + public static void main(java.lang.String[]); + flags: (0x0009) ACC_PUBLIC, ACC_STATIC + + public static void staticMethod(); + flags: (0x0009) ACC_PUBLIC, ACC_STATIC + + public void defaultMethod(); + flags: (0x0001) ACC_PUBLIC + + public abstract void simpleMethod() throws java.io.IOException; + flags: (0x0401) ACC_PUBLIC, ACC_ABSTRACT + Exceptions: + throws java.io.IOException +} +``` +可以看到 default关键字修饰的方法是像实例方法一样定义的，所以我们来定义一个只有default的方法并且实现一下试一试。 +```java +interface Default { + default int defaultMethod() { + return 4396; + } +} + +public class DefaultMethod implements Default { + public static void main(String[] args) { + DefaultMethod defaultMethod = new DefaultMethod(); + System.out.println(defaultMethod.defaultMethod()); + //compile error : Non-static method 'defaultMethod()' cannot be referenced from a static context + //! DefaultMethod.defaultMethod(); + } +} +``` +可以看到default方法确实像实例方法一样，必须有实例对象才能调用，并且子类在实现接口时，可以不用实现default方法，也可以覆盖该方法。 +这有点像子类继承父类实例方法。 +
+接口静态方法就像是类静态方法，唯一的区别是**接口静态方法只能通过接口名调用，而类静态方法既可以通过类名调用也可以通过实例调用** +```java +interface Static { + static int staticMethod() { + return 4396; + } +} + ... main(String...args) + //!compile error: Static method may be invoked on containing interface class only + //!aInstanceOfStatic.staticMethod(); + ... +``` +另一个问题是多继承问题，大家知道Java中类是不支持多继承的，但是接口是多继承和多实现(implements后跟多个接口)的， +那么如果一个接口继承另一个接口，两个接口都有同名的default方法会怎么样呢？答案是会像类继承一样覆写(@Override)，以下代码在IDE中可以顺利编译 +```java +interface Default { + default int defaultMethod() { + return 4396; + } +} +interface Default2 extends Default { + @Override + default int defaultMethod() { + return 9527; + } +} +public class DefaultMethod implements Default,Default2 { + public static void main(String[] args) { + DefaultMethod defaultMethod = new DefaultMethod(); + System.out.println(defaultMethod.defaultMethod()); + } +} + +输出 : 9527 +``` +出现上面的情况时，会优先找继承树上近的方法，类似于“短路优先”。 +
+那么如果一个类实现了两个没有继承关系的接口，且这两个接口有同名方法的话会怎么样呢？IDE会要求你重写这个冲突的方法，让你自己选择去执行哪个方法，因为IDE它 +还没智能到你不告诉它，它就知道你想执行哪个方法。可以通过```java 接口名.super```指针来访问接口中定义的实例(default)方法。 +```java +interface Default { + default int defaultMethod() { + return 4396; + } +} + +interface Default2 { + default int defaultMethod() { + return 9527; + } +} +//如果不重写 +//compile error : defaults.DefaultMethod inherits unrelated defaults for defaultMethod() from types defaults.Default and defaults.Default2 +public class DefaultMethod implements Default,Default2 { +@Override + public int defaultMethod() { + System.out.println(Default.super.defaultMethod()); + System.out.println(Default2.super.defaultMethod()); + return 996; + } + public static void main(String[] args) { + DefaultMethod defaultMethod = new DefaultMethod(); + System.out.println(defaultMethod.defaultMethod()); + } +} + +运行输出 : +4396 +9527 +996 +``` From 2fa0457b87a30b203064ffdf9551a01f41872d01 Mon Sep 17 00:00:00 2001 From: haiqiang <43314997+Goose9527@users.noreply.github.com> Date: Sun, 10 Mar 2019 22:45:36 +0800 Subject: [PATCH 104/232] =?UTF-8?q?Update=20Lambda=E8=A1=A8=E8=BE=BE?= =?UTF-8?q?=E5=BC=8F.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../Lambda\350\241\250\350\276\276\345\274\217.md" | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git "a/Java\347\233\270\345\205\263/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" "b/Java\347\233\270\345\205\263/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" index 0d1b89981f6..ab1c75be2e9 100644 --- "a/Java\347\233\270\345\205\263/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" +++ "b/Java\347\233\270\345\205\263/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" @@ -15,13 +15,13 @@ JDK8--Lambda表达式 **函数式接口指的是有且只有一个抽象(abstract)方法的接口**
当需要一个函数式接口的对象时，就可以用Lambda表达式来实现，举个常用的例子:
-``` +```java Thread thread = new Thread(() -> { System.out.println("This is JDK8's Lambda!"); }); ``` 这段代码和函数式接口有啥关系？我们回忆一下，Thread类的构造函数里是不是有一个以Runnable接口为参数的？ -``` +```java public Thread(Runnable target) {...} /** @@ -33,7 +33,7 @@ public interface Runnable { } ``` 到这里大家可能已经明白了，**Lambda表达式相当于一个匿名类或者说是一个匿名方法**。上面Thread的例子相当于 -``` +```java Thread thread = new Thread(new Runnable() { @Override public void run() { From e929c8ba24a8df808febea51ee00f7ce7aa35ac7 Mon Sep 17 00:00:00 2001 From: haiqiang <43314997+Goose9527@users.noreply.github.com> Date: Sun, 10 Mar 2019 22:51:13 +0800 Subject: [PATCH 105/232] =?UTF-8?q?Update=20Lambda=E8=A1=A8=E8=BE=BE?= =?UTF-8?q?=E5=BC=8F.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../Lambda\350\241\250\350\276\276\345\274\217.md" | 2 -- 1 file changed, 2 deletions(-) diff --git "a/Java\347\233\270\345\205\263/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" "b/Java\347\233\270\345\205\263/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" index ab1c75be2e9..bf27300f1bd 100644 --- "a/Java\347\233\270\345\205\263/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" +++ "b/Java\347\233\270\345\205\263/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" @@ -60,5 +60,3 @@ public interface Runnable { - ```Predicate {boolean test(T t);}``` 判断，接受一个T对象，返回一个布尔值。 - ```Supplier {T get();} 提供者(工厂)``` 返回一个T对象。 - 其他的跟上面的相似，大家可以看一下function包下的具体接口。 - -## 4.[方法引用]() From 36147197d7d5de1809b872d8a654719e26653df8 Mon Sep 17 00:00:00 2001 From: haiqiang <43314997+Goose9527@users.noreply.github.com> Date: Sun, 10 Mar 2019 22:52:06 +0800 Subject: [PATCH 106/232] =?UTF-8?q?Update=20Lambda=E8=A1=A8=E8=BE=BE?= =?UTF-8?q?=E5=BC=8F.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...da\350\241\250\350\276\276\345\274\217.md" | 26 +++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git "a/Java\347\233\270\345\205\263/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" "b/Java\347\233\270\345\205\263/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" index bf27300f1bd..a7ef7f93cd0 100644 --- "a/Java\347\233\270\345\205\263/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" +++ "b/Java\347\233\270\345\205\263/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" @@ -60,3 +60,29 @@ public interface Runnable { - ```Predicate {boolean test(T t);}``` 判断，接受一个T对象，返回一个布尔值。 - ```Supplier {T get();} 提供者(工厂)``` 返回一个T对象。 - 其他的跟上面的相似，大家可以看一下function包下的具体接口。 +## 4.变量作用域 +```java +public class VaraibleHide { + @FunctionalInterface + interface IInner { + void printInt(int x); + } + public static void main(String[] args) { + int x = 20; + IInner inner = new IInner() { + int x = 10; + @Override + public void printInt(int x) { + System.out.println(x); + } + }; + inner.printInt(30); + inner = (s) -> { + //!int x = 10; + //!x= 50; error + System.out.print(x); + }; + inner.printInt(30); + } +} +``` From 38e568cbe590866e2cf220bad0aafe9c34169df9 Mon Sep 17 00:00:00 2001 From: haiqiang <43314997+Goose9527@users.noreply.github.com> Date: Sun, 10 Mar 2019 22:58:23 +0800 Subject: [PATCH 107/232] =?UTF-8?q?Update=20Lambda=E8=A1=A8=E8=BE=BE?= =?UTF-8?q?=E5=BC=8F.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../Lambda\350\241\250\350\276\276\345\274\217.md" | 7 +++++++ 1 file changed, 7 insertions(+) diff --git "a/Java\347\233\270\345\205\263/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" "b/Java\347\233\270\345\205\263/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" index a7ef7f93cd0..eb97bcc06ef 100644 --- "a/Java\347\233\270\345\205\263/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" +++ "b/Java\347\233\270\345\205\263/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" @@ -78,6 +78,7 @@ public class VaraibleHide { }; inner.printInt(30); inner = (s) -> { + //Variable used in lambda expression should be final or effectively final //!int x = 10; //!x= 50; error System.out.print(x); @@ -85,4 +86,10 @@ public class VaraibleHide { inner.printInt(30); } } +输出 : +30 +20 ``` +lambda表达式和内部类一样，对外部变量捕获时，外部变量必须为final或者是最终变量(effectively final)的，也就是说这个变量初始化后就不能为它赋新值， +同时lambda不像内部类/匿名类，lambda表达式与外围嵌套块有着相同的作用域，因此对变量命名的有关规则对lambda同样适用。 +## 5.[方法引用]() From a771278b56db2dfb96e1d1a766dab00ef870eda1 Mon Sep 17 00:00:00 2001 From: haiqiang <43314997+Goose9527@users.noreply.github.com> Date: Sun, 10 Mar 2019 22:59:10 +0800 Subject: [PATCH 108/232] =?UTF-8?q?Create=20=E6=96=B9=E6=B3=95=E5=BC=95?= =?UTF-8?q?=E7=94=A8.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../\346\226\271\346\263\225\345\274\225\347\224\250.md" | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 "Java\347\233\270\345\205\263/What's New in JDK8/\346\226\271\346\263\225\345\274\225\347\224\250.md" diff --git "a/Java\347\233\270\345\205\263/What's New in JDK8/\346\226\271\346\263\225\345\274\225\347\224\250.md" "b/Java\347\233\270\345\205\263/What's New in JDK8/\346\226\271\346\263\225\345\274\225\347\224\250.md" new file mode 100644 index 00000000000..e8f2fcb9f94 --- /dev/null +++ "b/Java\347\233\270\345\205\263/What's New in JDK8/\346\226\271\346\263\225\345\274\225\347\224\250.md" @@ -0,0 +1,2 @@ +JDK8-Lambda-方法引用 +=== From 8213beabc8d0a925f2777815646879b7fbb57521 Mon Sep 17 00:00:00 2001 From: Snailclimb Date: Mon, 11 Mar 2019 09:06:13 +0800 Subject: [PATCH 109/232] =?UTF-8?q?Create=20=E5=A6=82=E6=9E=9C=E9=9D=A2?= =?UTF-8?q?=E8=AF=95=E5=AE=98=E9=97=AE=E4=BD=A0=E2=80=9C=E4=BD=A0=E6=9C=89?= =?UTF-8?q?=E4=BB=80=E4=B9=88=E9=97=AE=E9=A2=98=E9=97=AE=E6=88=91=E5=90=97?= =?UTF-8?q?=EF=BC=9F=E2=80=9D=E6=97=B6=EF=BC=8C=E4=BD=A0=E8=AF=A5=E5=A6=82?= =?UTF-8?q?=E4=BD=95=E5=9B=9E=E7=AD=94.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...02\344\275\225\345\233\236\347\255\224.md" | 64 +++++++++++++++++++ 1 file changed, 64 insertions(+) create mode 100644 "EssentialContentForInterview/PreparingForInterview/\345\246\202\346\236\234\351\235\242\350\257\225\345\256\230\351\227\256\344\275\240\342\200\234\344\275\240\346\234\211\344\273\200\344\271\210\351\227\256\351\242\230\351\227\256\346\210\221\345\220\227\357\274\237\342\200\235\346\227\266\357\274\214\344\275\240\350\257\245\345\246\202\344\275\225\345\233\236\347\255\224.md" diff --git "a/EssentialContentForInterview/PreparingForInterview/\345\246\202\346\236\234\351\235\242\350\257\225\345\256\230\351\227\256\344\275\240\342\200\234\344\275\240\346\234\211\344\273\200\344\271\210\351\227\256\351\242\230\351\227\256\346\210\221\345\220\227\357\274\237\342\200\235\346\227\266\357\274\214\344\275\240\350\257\245\345\246\202\344\275\225\345\233\236\347\255\224.md" "b/EssentialContentForInterview/PreparingForInterview/\345\246\202\346\236\234\351\235\242\350\257\225\345\256\230\351\227\256\344\275\240\342\200\234\344\275\240\346\234\211\344\273\200\344\271\210\351\227\256\351\242\230\351\227\256\346\210\221\345\220\227\357\274\237\342\200\235\346\227\266\357\274\214\344\275\240\350\257\245\345\246\202\344\275\225\345\233\236\347\255\224.md" new file mode 100644 index 00000000000..d4d6b64b0a5 --- /dev/null +++ "b/EssentialContentForInterview/PreparingForInterview/\345\246\202\346\236\234\351\235\242\350\257\225\345\256\230\351\227\256\344\275\240\342\200\234\344\275\240\346\234\211\344\273\200\344\271\210\351\227\256\351\242\230\351\227\256\346\210\221\345\220\227\357\274\237\342\200\235\346\227\266\357\274\214\344\275\240\350\257\245\345\246\202\344\275\225\345\233\236\347\255\224.md" @@ -0,0 +1,64 @@ +我还记得当时我去参加面试的时候，几乎每一场面试，特别是HR面和高管面的时候，面试官总是会在结尾问我:“问了你这么多问题了，你有什么问题问我吗？”。这个时候很多人内心就会陷入短暂的纠结中:我该问吗？不问的话面试官会不会对我影响不好？问什么问题？问这个问题会不会让面试官对我的影响不好啊？ + + + +### 这个问题对最终面试结果的影响到底大不大? + +就技术面试而言，回答这个问题的时候，只要你不是触碰到你所面试的公司的雷区，那么我觉得这对你能不能拿到最终offer来说影响确实是不大的。我说这些并不代表你就可以直接对面试官说：“我没问题了。”，笔主当时面试的时候确实也说过挺多次“没问题要问了。”，最终也没有导致笔主被pass掉（可能是前面表现比较好，哈哈，自恋一下）。我现在回想起来，觉得自己当时做法其实挺不对的。面试本身就是一个双向选择的过程，你对这个问题的回答也会侧面反映出你对这次面试的上心程度，你的问题是否有价值，也影响了你最终的选择与公司是否选择你。 + +面试官在技术面试中主要考察的还是你这样个人到底有没有胜任这个工作的能力以及你是否适合公司未来的发展需要，很多公司还需要你认同它的文化，我觉得你只要不是太笨，应该不会栽在这里。除非你和另外一个人在能力上相同，但是只能在你们两个人中选一个，那么这个问题才对你能不能拿到offer至关重要。有准备总比没准备好，给面试官留一个好的影响总归是没错的。 + +但是，就非技术面试来说，我觉得好好回答这个问题对你最终的结果还是比较重要的。 + +总的来说不管是技术面试还是非技术面试，如果你想赢得公司的青睐和尊重，我觉得我们都应该重视这个问题。 + +### 真诚一点,不要问太 Low 的问题 + +回答这个问题很重要的一点就是你没有必要放低自己的姿态问一些很虚或者故意讨好面试官的问题，也不要把自己从面经上学到的东西照搬下来使用。面试官也不是傻子，特别是那种特别有经验的面试官，你是真心诚意的问问题，还是从别处照搬问题来讨好面试官，人家可能一听就听出来了。总的来说，还是要真诚。除此之外，不要问太Low的问题，会显得你整个人格局比较小或者说你根本没有准备（侧面反映你对这家公司不伤心，既然你不上心，为什么要要你呢）。举例几个比较 Low 的问题，大家看看自己有没有问过其中的问题： + +- 贵公司的主要业务是什么？（面试之前自己不知道提前网上查一下吗？） +- 贵公司的男女比例如何？（考虑脱单？记住你是来工作的！） +- 贵公司一年搞几次外出旅游？（你是来工作的，这些娱乐活动先别放在心上！） +- ...... + +### 有哪些有价值的问题值得问? + +针对这个问题。笔主专门找了几个专门做HR工作的小哥哥小姐姐们询问并且查阅了挺多前辈们的回答，然后结合自己的实际经历，我概括了下面几个比较适合问的问题。 + +#### 面对HR或者其他Level比较低的面试官时 + +1. **能不能谈谈你作为一个公司老员工对公司的感受?** (这个问题比较容易回答，不会让面试官陷入无话可说的尴尬境地。另外，从面试官的回答中你可以加深对这个公司的了解，让你更加清楚这个公司到底是不是你想的那样或者说你是否能适应这个公司的文化。除此之外，这样的问题在某种程度上还可以拉进你与面试官的距离。) +2. **能不能问一下，你当时因为什么原因选择加入这家公司的呢或者说这家公司有哪些地方吸引你?有什么地方你觉得还不太好或者可以继续完善吗？** （类似第一个问题，都是问面试官个人对于公司的看法，） +3. **我觉得我这次表现的不是太好，你有什么建议或者评价给我吗？**(这个是我常问的。我觉得说自己表现不好只是这个语境需要这样来说，这样可以显的你比较谦虚好学上进。) +4. **接下来我会有一段空档期，有什么值得注意或者建议学习的吗？** （体现出你对工作比较上心，自助学习意识比较强。） +5. **这个岗位为什么还在招人？** (岗位真实性和价值咨询) +6. **大概什么时候能给我回复呢？** (终面的时候，如果面试官没有说的话，可以问一下) +7. ...... + + + +#### 面对部门领导 + +1. **部门的主要人员分配以及对应的主要工作能简单介绍一下吗？** +2. **未来如果我要加入这个团队，你对我的期望是什么？** （部门领导一般情况下是你的直属上级了，你以后和他打交道的机会应该是最多的。你问这个问题，会让他感觉你是一个对他的部门比较上心，比较有团体意识，并且愿意倾听的候选人。） +3. **公司对新入职的员工的培养机制是什么样的呢？** （正规的公司一般都有培养机制，提前问一下是对你自己的负责也会显的你比较上心） +4. **以您来看，这个岗位未来在公司内部的发展如何？** (在我看来，问这个问题也是对你自己的负责吧，谁不想发展前景更好的岗位呢？) +5. **团队现在面临的最大挑战是什么？** (这样的问题不会暴露你对公司的不了解，并且也能让你对未来工作的挑战或困难有一个提前的预期。) + + + +#### 面对Level比较高的(比如总裁,老板) + +1. **贵公司的发展目标和方向是什么？** （看下公司的发展是否满足自己的期望） +2. **与同行业的竞争者相比，贵公司的核心竞争优势在什么地方？** （充分了解自己的优势和劣势） +3. **公司现在面临的最大挑战是什么？** + +### 来个补充,顺便送个祝福给大家 + +薪酬待遇和相关福利问题一般在终面的时候（最好不要在前面几面的时候就问到这个问题），面试官会提出来或者在面试完之后以邮件的形式告知你。一般来说，如果面试官很愿意为你回答问题，对你的问题也比较上心的话，那他肯定是觉得你就是他们要招的人。 + +大家在面试的时候，可以根据自己对于公司或者岗位的了解程度，对上面提到的问题进行适当修饰或者修改。上面提到的一些问题只是给没有经验的朋友一个参考，如果你还有其他比较好的问题的话，那当然也更好啦！ + +金三银四。过了二月就到了面试高峰期或者说是黄金期。几份惊喜几份愁，愿各位能始终不忘初心！每个人都有每个人的难处。引用一句《阿甘正传》里面的台词：“生活就像一盒巧克力，你永远不知道下一块是什么味道“。 + + \ No newline at end of file From ab1e546f7afa852d0c2b5c3f1f076948bcda1a43 Mon Sep 17 00:00:00 2001 From: SnailClimb Date: Mon, 11 Mar 2019 09:10:17 +0800 Subject: [PATCH 110/232] =?UTF-8?q?Add=20=E5=A6=82=E6=9E=9C=E9=9D=A2?= =?UTF-8?q?=E8=AF=95=E5=AE=98=E9=97=AE=E4=BD=A0=E2=80=9C=E4=BD=A0=E6=9C=89?= =?UTF-8?q?=E4=BB=80=E4=B9=88=E9=97=AE=E9=A2=98=E9=97=AE=E6=88=91=E5=90=97?= =?UTF-8?q?=EF=BC=9F=E2=80=9D=E6=97=B6=EF=BC=8C=E4=BD=A0=E8=AF=A5=E5=A6=82?= =?UTF-8?q?=E4=BD=95=E5=9B=9E=E7=AD=94?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 35d96d7251c..8968159cd4d 100644 --- a/README.md +++ b/README.md @@ -30,7 +30,7 @@ * [数据通信\(RESTful,RPC,消息队列\)总结](#数据通信restfulrpc消息队列总结) * [操作系统](#操作系统) * [Linux相关](#linux相关) -* [主流框架/软件](#主流框架软件) +* [主流框架](#主流框架) * [Spring](#spring) * [ZooKeeper](#zookeeper) * [数据存储](#数据存储) @@ -129,7 +129,8 @@ * [后端程序员必备的 Linux 基础知识](https://github.com/Snailclimb/Java-Guide/blob/master/操作系统/后端程序员必备的Linux基础知识.md) * [Shell 编程入门](https://github.com/Snailclimb/Java-Guide/blob/master/操作系统/Shell.md) -## 主流框架/软件 + +## 主流框架 ### Spring @@ -170,7 +171,8 @@ * [【备战面试3】7个大部分程序员在面试前很关心的问题](https://github.com/Snailclimb/JavaGuide/blob/master/EssentialContentForInterview/PreparingForInterview/JavaProgrammerNeedKnow.md) * [【备战面试4】Java程序员必备书单](https://github.com/Snailclimb/Java-Guide/blob/master/EssentialContentForInterview/PreparingForInterview/books.md) * [【备战面试5】Github上开源的Java面试/学习相关的仓库推荐](https://github.com/Snailclimb/Java-Guide/blob/master/EssentialContentForInterview/PreparingForInterview/JavaInterviewLibrary.md) -* [【备战面试6】美团面试常见问题总结（附详解答案）](https://github.com/Snailclimb/Java-Guide/blob/master/EssentialContentForInterview/PreparingForInterview/美团面试常见问题总结.md) +* [【备战面试6】如果面试官问你“你有什么问题问我吗？”时，你该如何回答](https://github.com/Snailclimb/Java-Guide/blob/master/EssentialContentForInterview/PreparingForInterview/如果面试官问你“你有什么问题问我吗？”时，你该如何回答.md) +* [【备战面试7】美团面试常见问题总结（附详解答案）](https://github.com/Snailclimb/Java-Guide/blob/master/EssentialContentForInterview/PreparingForInterview/美团面试常见问题总结.md) ### BATJ真实面经(BATJ real interview experience) From 311b0bdc85e6a39e014c5457efc4a0d34bba0263 Mon Sep 17 00:00:00 2001 From: haiqiang <43314997+Goose9527@users.noreply.github.com> Date: Mon, 11 Mar 2019 09:53:20 +0800 Subject: [PATCH 111/232] =?UTF-8?q?Update=20JDK8=E6=8E=A5=E5=8F=A3?= =?UTF-8?q?=E8=A7=84=E8=8C=83.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../JDK8\346\216\245\345\217\243\350\247\204\350\214\203.md" | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git "a/Java\347\233\270\345\205\263/What's New in JDK8/JDK8\346\216\245\345\217\243\350\247\204\350\214\203.md" "b/Java\347\233\270\345\205\263/What's New in JDK8/JDK8\346\216\245\345\217\243\350\247\204\350\214\203.md" index 0332ecced69..ee1dd8c2448 100644 --- "a/Java\347\233\270\345\205\263/What's New in JDK8/JDK8\346\216\245\345\217\243\350\247\204\350\214\203.md" +++ "b/Java\347\233\270\345\205\263/What's New in JDK8/JDK8\346\216\245\345\217\243\350\247\204\350\214\203.md" @@ -1,7 +1,6 @@ JDK8接口规范 === -在JDK8中引入了lambda表达式，因此出现了函数式接口的概念，为了保持向前兼容性(比如泛型也是为了保持兼容性而失去了在一些别的语言泛型拥有的功能)， -Java接口规范发生了一些改变。 +在JDK8中引入了lambda表达式，出现了函数式接口的概念，为了在扩展接口时保持向前兼容性(比如泛型也是为了保持兼容性而失去了在一些别的语言泛型拥有的功能)，Java接口规范发生了一些改变。。 --- ## 1.JDK8以前的接口规范 - JDK8以前接口可以定义的变量和方法 From 2d5923274436535adc33b9d02822b5b3de15eb5a Mon Sep 17 00:00:00 2001 From: haiqiang <43314997+Goose9527@users.noreply.github.com> Date: Mon, 11 Mar 2019 10:18:17 +0800 Subject: [PATCH 112/232] Update ArrayList-Grow.md --- "Java\347\233\270\345\205\263/ArrayList-Grow.md" | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git "a/Java\347\233\270\345\205\263/ArrayList-Grow.md" "b/Java\347\233\270\345\205\263/ArrayList-Grow.md" index 87c695192f6..d763cb83492 100644 --- "a/Java\347\233\270\345\205\263/ArrayList-Grow.md" +++ "b/Java\347\233\270\345\205\263/ArrayList-Grow.md" @@ -145,7 +145,7 @@ } ``` -**int newCapacity = oldCapacity + (oldCapacity >> 1),所以在capacity是偶数的情况下，ArrayList 每次扩容之后容量都会变为原来的 1.5 倍，当capacity为奇数时(自己初始化容量时可能出现)，第一次扩容容量变为oldCapacity + (oldCapacity - 1) / 2(在计算机运算的情况下减一除和直接除没有差别，对于整数会自动舍掉小数位),也就是说每次扩容相当于计算机中的1.5倍。 ！** 记清楚了！不是网上很多人说的 1.5 倍+1！当然了，第一次扩容以后capacity会变为偶数，之后的每次扩容都会是原容量的1.5倍了。 +**int newCapacity = oldCapacity + (oldCapacity >> 1),所以 ArrayList 每次扩容之后容量都会变为原来的 1.5 倍！** 记清楚了！不是网上很多人说的 1.5 倍+1！ > ">>"（移位运算符）：>>1 右移一位相当于除2，右移n位相当于除以 2 的 n 次方。这里 oldCapacity 明显右移了1位所以相当于oldCapacity /2。对于大数据的2进制运算,位移运算符比那些普通运算符的运算要快很多,因为程序仅仅移动一下而已,不去计算,这样提高了效率,节省了资源 　 From c336e45ead8b26b029891b2309994e4a11ceabf7 Mon Sep 17 00:00:00 2001 From: HaiQiang <540911185@qq.com> Date: Mon, 11 Mar 2019 10:28:27 +0800 Subject: [PATCH 113/232] Update --- .../JDK8\346\216\245\345\217\243\350\247\204\350\214\203.md" | 0 .../Lambda\350\241\250\350\276\276\345\274\217.md" | 0 .../README.md" => Java/What's New in JDK8/README.md | 0 .../\346\226\271\346\263\225\345\274\225\347\224\250.md" | 0 4 files changed, 0 insertions(+), 0 deletions(-) rename "Java\347\233\270\345\205\263/What's New in JDK8/JDK8\346\216\245\345\217\243\350\247\204\350\214\203.md" => "Java/What's New in JDK8/JDK8\346\216\245\345\217\243\350\247\204\350\214\203.md" (100%) rename "Java\347\233\270\345\205\263/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" => "Java/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" (100%) rename "Java\347\233\270\345\205\263/What's New in JDK8/README.md" => Java/What's New in JDK8/README.md (100%) rename "Java\347\233\270\345\205\263/What's New in JDK8/\346\226\271\346\263\225\345\274\225\347\224\250.md" => "Java/What's New in JDK8/\346\226\271\346\263\225\345\274\225\347\224\250.md" (100%) diff --git "a/Java\347\233\270\345\205\263/What's New in JDK8/JDK8\346\216\245\345\217\243\350\247\204\350\214\203.md" "b/Java/What's New in JDK8/JDK8\346\216\245\345\217\243\350\247\204\350\214\203.md" similarity index 100% rename from "Java\347\233\270\345\205\263/What's New in JDK8/JDK8\346\216\245\345\217\243\350\247\204\350\214\203.md" rename to "Java/What's New in JDK8/JDK8\346\216\245\345\217\243\350\247\204\350\214\203.md" diff --git "a/Java\347\233\270\345\205\263/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" "b/Java/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" similarity index 100% rename from "Java\347\233\270\345\205\263/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" rename to "Java/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" diff --git "a/Java\347\233\270\345\205\263/What's New in JDK8/README.md" b/Java/What's New in JDK8/README.md similarity index 100% rename from "Java\347\233\270\345\205\263/What's New in JDK8/README.md" rename to Java/What's New in JDK8/README.md diff --git "a/Java\347\233\270\345\205\263/What's New in JDK8/\346\226\271\346\263\225\345\274\225\347\224\250.md" "b/Java/What's New in JDK8/\346\226\271\346\263\225\345\274\225\347\224\250.md" similarity index 100% rename from "Java\347\233\270\345\205\263/What's New in JDK8/\346\226\271\346\263\225\345\274\225\347\224\250.md" rename to "Java/What's New in JDK8/\346\226\271\346\263\225\345\274\225\347\224\250.md" From 70257619d65aca5262008f42e09a964c53efe977 Mon Sep 17 00:00:00 2001 From: haiqiang <43314997+Goose9527@users.noreply.github.com> Date: Mon, 11 Mar 2019 10:51:18 +0800 Subject: [PATCH 114/232] =?UTF-8?q?Update=20Lambda=E8=A1=A8=E8=BE=BE?= =?UTF-8?q?=E5=BC=8F.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...ambda\350\241\250\350\276\276\345\274\217.md" | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git "a/Java/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" "b/Java/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" index eb97bcc06ef..8351f9f8652 100644 --- "a/Java/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" +++ "b/Java/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" @@ -8,7 +8,7 @@ JDK8--Lambda表达式
参数列表可以为空```()->{}```
可以加类型声明比如```(String para1, int para2) -> {return para1 + para2;}```我们可以看到，lambda同样可以有返回值.
在编译器可以推断出类型的时候，可以将类型声明省略，比如```(para1, para2) -> {return para1 + para2;}``` -
(lambda有点像动态类型语言，并且lambda在字节码层面是用invokedynamic实现的，而这条指令就是为了让JVM更好的支持运行在其上的动态类型语言) +
(lambda有点像动态类型语言语法。lambda在字节码层面是用invokedynamic实现的，而这条指令就是为了让JVM更好的支持运行在其上的动态类型语言) ## 3.函数式接口 在了解Lambda表达式之前，有必要先了解什么是函数式接口```(@FunctionalInterface)```
@@ -43,6 +43,11 @@ public interface Runnable { ``` 也就是说，上面的lambda表达式相当于实现了这个run()方法，然后当做参数传入(个人感觉可以这么理解,lambda表达式就是一个函数，只不过它的返回值、参数列表都 由编译器帮我们推断，因此可以减少很多代码量)。 +
Lambda也可以这样用 : +```java + Runnable runnable = () -> {...}; +``` +其实这和上面的用法没有什么本质上的区别。
至此大家应该明白什么是函数式接口以及函数式接口和lambda表达式之间的关系了。在JDK8中修改了接口的规范， 目的是为了在给接口添加新的功能时保持向前兼容(个人理解)，比如一个已经定义了的函数式接口，某天我们想给它添加新功能，那么就不能保持向前兼容了， 因为在旧的接口规范下，添加新功能必定会破坏这个函数式接口[(JDK8中接口规范)]() @@ -77,6 +82,7 @@ public class VaraibleHide { } }; inner.printInt(30); + inner = (s) -> { //Variable used in lambda expression should be final or effectively final //!int x = 10; @@ -90,6 +96,8 @@ public class VaraibleHide { 30 20 ``` -lambda表达式和内部类一样，对外部变量捕获时，外部变量必须为final或者是最终变量(effectively final)的，也就是说这个变量初始化后就不能为它赋新值， -同时lambda不像内部类/匿名类，lambda表达式与外围嵌套块有着相同的作用域，因此对变量命名的有关规则对lambda同样适用。 -## 5.[方法引用]() +对于lambda表达式```java inner = (s) -> {System.out.print(x);};```,变量x并不是在lambda表达式中定义的，像这样并不是在lambda中定义或者通过lambda的参数列表()获取的变量成为自由变量，它是被lambda表达式捕获的。 +
lambda表达式和内部类一样，对外部自由变量捕获时，外部自由变量必须为final或者是最终变量(effectively final)的，也就是说这个变量初始化后就不能为它赋新值， +同时lambda不像内部类/匿名类，lambda表达式与外围嵌套块有着相同的作用域，因此对变量命名的有关规则对lambda同样适用。大家阅读上面的代码对这些概念应该 +不难理解。 +## 5.[方法引用](../方法引用.md) From 72050e60a14e28cdf0281020380a750b7e5bc450 Mon Sep 17 00:00:00 2001 From: haiqiang <43314997+Goose9527@users.noreply.github.com> Date: Mon, 11 Mar 2019 10:54:49 +0800 Subject: [PATCH 115/232] =?UTF-8?q?Rename=20JDK8=E6=8E=A5=E5=8F=A3?= =?UTF-8?q?=E8=A7=84=E8=8C=83.md=20to=20JDK8=E6=8E=A5=E5=8F=A3=E8=A7=84?= =?UTF-8?q?=E8=8C=83-=E9=9D=99=E6=80=81=E3=80=81=E9=BB=98=E8=AE=A4?= =?UTF-8?q?=E6=96=B9=E6=B3=95.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...43\200\201\351\273\230\350\256\244\346\226\271\346\263\225.md" | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename "Java/What's New in JDK8/JDK8\346\216\245\345\217\243\350\247\204\350\214\203.md" => "Java/What's New in JDK8/JDK8\346\216\245\345\217\243\350\247\204\350\214\203-\351\235\231\346\200\201\343\200\201\351\273\230\350\256\244\346\226\271\346\263\225.md" (100%) diff --git "a/Java/What's New in JDK8/JDK8\346\216\245\345\217\243\350\247\204\350\214\203.md" "b/Java/What's New in JDK8/JDK8\346\216\245\345\217\243\350\247\204\350\214\203-\351\235\231\346\200\201\343\200\201\351\273\230\350\256\244\346\226\271\346\263\225.md" similarity index 100% rename from "Java/What's New in JDK8/JDK8\346\216\245\345\217\243\350\247\204\350\214\203.md" rename to "Java/What's New in JDK8/JDK8\346\216\245\345\217\243\350\247\204\350\214\203-\351\235\231\346\200\201\343\200\201\351\273\230\350\256\244\346\226\271\346\263\225.md" From 98a085c9f0e1b458cb5aaf40d5aa0788ad9c4d0d Mon Sep 17 00:00:00 2001 From: haiqiang <43314997+Goose9527@users.noreply.github.com> Date: Mon, 11 Mar 2019 14:49:31 +0800 Subject: [PATCH 116/232] =?UTF-8?q?JDK8=20Lambda=E8=A1=A8=E8=BE=BE?= =?UTF-8?q?=E5=BC=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 0.0.1 SNAPSHOT --- ...da\350\241\250\350\276\276\345\274\217.md" | 134 +++++++++++++++++- 1 file changed, 133 insertions(+), 1 deletion(-) diff --git "a/Java/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" "b/Java/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" index 8351f9f8652..359c4714473 100644 --- "a/Java/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" +++ "b/Java/What's New in JDK8/Lambda\350\241\250\350\276\276\345\274\217.md" @@ -100,4 +100,136 @@ public class VaraibleHide {
lambda表达式和内部类一样，对外部自由变量捕获时，外部自由变量必须为final或者是最终变量(effectively final)的，也就是说这个变量初始化后就不能为它赋新值， 同时lambda不像内部类/匿名类，lambda表达式与外围嵌套块有着相同的作用域，因此对变量命名的有关规则对lambda同样适用。大家阅读上面的代码对这些概念应该 不难理解。 -## 5.[方法引用](../方法引用.md) +## 5.方法引用 +**只需要提供方法的名字，具体的调用过程由Lambda和函数式接口来确定，这样的方法调用成为方法引用。** +
下面的例子会打印list中的每个元素: +```java +List list = new ArrayList<>(); + for (int i = 0; i < 10; ++i) { + list.add(i); + } + list.forEach(System.out::println); +``` +其中```System.out::println```这个就是一个方法引用，等价于Lambda表达式 ```(para)->{System.out.println(para);}``` +
我们看一下List#forEach方法 ```default void forEach(Consumer action)```可以看到它的参数是一个Consumer接口，该接口是一个函数式接口 +```java +@FunctionalInterface +public interface Consumer { + void accept(T t); +``` +大家能发现这个函数接口的方法和```System.out::println```有什么相似的么？没错，它们有着相似的参数列表和返回值。 +
我们自己定义一个方法，看看能不能像标准输出的打印函数一样被调用 +```java +public class MethodReference { + public static void main(String[] args) { + List list = new ArrayList<>(); + for (int i = 0; i < 10; ++i) { + list.add(i); + } + list.forEach(MethodReference::myPrint); + } + + static void myPrint(int i) { + System.out.print(i + ", "); + } +} + +输出: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, +``` +可以看到，我们自己定义的方法也可以当做方法引用。 +
到这里大家多少对方法引用有了一定的了解，我们再来说一下方法引用的形式。 +- 方法引用 + - 类名::静态方法名 + - 类名::实例方法名 + - 类名::new (构造方法引用) + - 实例名::实例方法名 +可以看出，方法引用是通过(方法归属名)::(方法名)来调用的。通过上面的例子已经讲解了一个`类名::静态方法名`的使用方法了，下面再依次介绍其余的几种 +方法引用的使用方法。
+**类名::实例方法名**
+先来看一段代码 +```java + String[] strings = new String[10]; + Arrays.sort(strings, String::compareToIgnoreCase); +``` +**上面的String::compareToIgnoreCase等价于(x, y) -> {return x.compareToIgnoreCase(y);}**
+我们看一下`Arrays#sort`方法`public static void sort(T[] a, Comparator c)`, +可以看到第二个参数是一个Comparator接口，该接口也是一个函数式接口，其中的抽象方法是`int compare(T o1, T o2);`，再看一下 +`String#compareToIgnoreCase`方法,`public int compareToIgnoreCase(String str)`，这个方法好像和上面讲方法引用中`类名::静态方法名`不大一样啊，它 +的参数列表和函数式接口的参数列表不一样啊，虽然它的返回值一样？ +
是的，确实不一样但是别忘了，String类的这个方法是个实例方法，而不是静态方法，也就是说，这个方法是需要有一个接收者的。所谓接收者就是 +instance.method(x)中的instance， +它是某个类的实例，有的朋友可能已经明白了。上面函数式接口的`compare(T o1, T o2)`中的第一个参数作为了实例方法的接收者，而第二个参数作为了实例方法的 +参数。我们再举一个自己实现的例子: +```java +public class MethodReference { + static Random random = new Random(47); + public static void main(String[] args) { + MethodReference[] methodReferences = new MethodReference[10]; + Arrays.sort(methodReferences, MethodReference::myCompare); + } + int myCompare(MethodReference o) { + return random.nextInt(2) - 1; + } +} +``` +上面的例子可以在IDE里通过编译，大家有兴趣的可以模仿上面的例子自己写一个程序，打印出排序后的结果。 +
**构造器引用**
+构造器引用仍然需要与特定的函数式接口配合使用，并不能像下面这样直接使用。IDE会提示String不是一个函数式接口 +```java + //compile error : String is not a functional interface + String str = String::new; +``` +下面是一个使用构造器引用的例子，可以看出构造器引用可以和这种工厂型的函数式接口一起使用的。 +```java + interface IFunctional { + T func(); +} + +public class ConstructorReference { + + public ConstructorReference() { + } + + public static void main(String[] args) { + Supplier supplier0 = () -> new ConstructorReference(); + Supplier supplier1 = ConstructorReference::new; + IFunctional functional = () -> new ConstructorReference(); + IFunctional functional1 = ConstructorReference::new; + } +} +``` +下面是一个JDK官方的例子 +```java + public static , DEST extends Collection> + DEST transferElements( + SOURCE sourceCollection, + Supplier collectionFactory) { + + DEST result = collectionFactory.get(); + for (T t : sourceCollection) { + result.add(t); + } + return result; + } + + ... + + Set rosterSet = transferElements( + roster, HashSet::new); +``` + +**实例::实例方法** +
+其实开始那个例子就是一个实例::实例方法的引用 +```java +List list = new ArrayList<>(); + for (int i = 0; i < 10; ++i) { + list.add(i); + } + list.forEach(System.out::println); +``` +其中System.out就是一个实例，println是一个实例方法。相信不用再给大家做解释了。 +## 总结 +Lambda表达式是JDK8引入Java的函数式编程语法，使用Lambda需要直接或者间接的与函数式接口配合，在开发中使用Lambda可以减少代码量， +但是并不是说必须要使用Lambda(虽然它是一个很酷的东西)。有些情况下使用Lambda会使代码的可读性急剧下降，并且也节省不了多少代码， +所以在实际开发中还是需要仔细斟酌是否要使用Lambda。和Lambda相似的还有JDK10中加入的var类型推断，同样对于这个特性需要斟酌使用。 From bcb8ba35822827c04cf10b1bbcb254a58fa43bd9 Mon Sep 17 00:00:00 2001 From: HaiQiang <540911185@qq.com> Date: Mon, 11 Mar 2019 14:55:53 +0800 Subject: [PATCH 117/232] =?UTF-8?q?Delete=20=E6=96=B9=E6=B3=95=E5=BC=95?= =?UTF-8?q?=E7=94=A8.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../\346\226\271\346\263\225\345\274\225\347\224\250.md" | 2 -- 1 file changed, 2 deletions(-) delete mode 100644 "Java/What's New in JDK8/\346\226\271\346\263\225\345\274\225\347\224\250.md" diff --git "a/Java/What's New in JDK8/\346\226\271\346\263\225\345\274\225\347\224\250.md" "b/Java/What's New in JDK8/\346\226\271\346\263\225\345\274\225\347\224\250.md" deleted file mode 100644 index e8f2fcb9f94..00000000000 --- "a/Java/What's New in JDK8/\346\226\271\346\263\225\345\274\225\347\224\250.md" +++ /dev/null @@ -1,2 +0,0 @@ -JDK8-Lambda-方法引用 -=== From 89e2be28e17f922f1dd7e5567299d44b3e52582a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=BD=AD=E6=99=A8?= Date: Mon, 11 Mar 2019 15:01:24 +0800 Subject: [PATCH 118/232] Update Redis.md MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 修正参考文档链接格式 --- .../Redis/Redis.md" | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git "a/\346\225\260\346\215\256\345\255\230\345\202\250/Redis/Redis.md" "b/\346\225\260\346\215\256\345\255\230\345\202\250/Redis/Redis.md" index 5732c156825..a53a6481a00 100644 --- "a/\346\225\260\346\215\256\345\255\230\345\202\250/Redis/Redis.md" +++ "b/\346\225\260\346\215\256\345\255\230\345\202\250/Redis/Redis.md" @@ -262,7 +262,7 @@ Redis 通过 MULTI、EXEC、WATCH 等命令来实现事务(transaction)功能。 参考： -- https://blog.csdn.net/zeb_perfect/article/details/54135506[enter link description here](https://blog.csdn.net/zeb_perfect/article/details/54135506) +- [https://blog.csdn.net/zeb_perfect/article/details/54135506](https://blog.csdn.net/zeb_perfect/article/details/54135506) ### 如何解决 Redis 的并发竞争 Key 问题 From 9e07a4c7b98e4190c03b17e8c08505bcb3324351 Mon Sep 17 00:00:00 2001 From: yangzheng Date: Tue, 12 Mar 2019 11:52:42 +0800 Subject: [PATCH 119/232] =?UTF-8?q?=E5=88=A0=E9=99=A4=E5=A4=9A=E4=BD=99?= =?UTF-8?q?=EF=BC=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Java/LinkedList.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Java/LinkedList.md b/Java/LinkedList.md index 31f5f4838e9..b8083232ab2 100644 --- a/Java/LinkedList.md +++ b/Java/LinkedList.md @@ -186,7 +186,7 @@ public void addLast(E e) { } ``` ### 根据位置取数据的方法 -**get(int index)：**：根据指定索引返回数据 +**get(int index)：** 根据指定索引返回数据 ```java public E get(int index) { //检查index范围是否在size之内 From 29cf2d235c6513372858c1fb8fa49753ed1d0ee7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=9D=B3=E9=98=B3?= <260893248@qq.com> Date: Tue, 12 Mar 2019 12:51:08 +0800 Subject: [PATCH 120/232] =?UTF-8?q?=E9=94=99=E5=88=AB=E5=AD=97=E4=BF=AE?= =?UTF-8?q?=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 错别字修改 --- Java/synchronized.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Java/synchronized.md b/Java/synchronized.md index b0b0700ad8e..d415152ac48 100644 --- a/Java/synchronized.md +++ b/Java/synchronized.md @@ -12,7 +12,7 @@ Github 地址：[https://github.com/Snailclimb/JavaGuide/edit/master/Java相关/ 下面我已一个常见的面试题为例讲解一下 synchronized 关键字的具体使用。 -面试中面试官经常会说：“单例模式了解吗？来给我手写一下！给我解释一下双重检验锁方式实现单利模式的原理呗！” +面试中面试官经常会说：“单例模式了解吗？来给我手写一下！给我解释一下双重检验锁方式实现单例模式的原理呗！” From 056b37e3eae2d7932b2c13e07df4579de53a9f80 Mon Sep 17 00:00:00 2001 From: yangzheng Date: Tue, 12 Mar 2019 14:17:08 +0800 Subject: [PATCH 121/232] =?UTF-8?q?=E6=B7=BB=E5=8A=A0//=20=E6=B3=A8?= =?UTF-8?q?=E9=87=8A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Java/LinkedList.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Java/LinkedList.md b/Java/LinkedList.md index b8083232ab2..983c1fae0d0 100644 --- a/Java/LinkedList.md +++ b/Java/LinkedList.md @@ -220,7 +220,7 @@ public E peekFirst() { getFirst(),element(),peek(),peekFirst() 这四个获取头结点方法的区别在于对链表为空时的处理，是抛出异常还是返回null，其中**getFirst()** 和**element()** 方法将会在链表为空时，抛出异常 -element()方法的内部就是使用getFirst()实现的。它们会在链表为空时，抛出NoSuchElementException +element()方法的内部就是使用getFirst()实现的。它们会在链表为空时，抛出NoSuchElementException **获取尾节点（index=-1）数据方法:** ```java public E getLast() { @@ -359,7 +359,7 @@ E unlink(Node x) { //删除前驱指针 if (prev == null) { - first = next;如果删除的节点是头节点,令头节点指向该节点的后继节点 + first = next;//如果删除的节点是头节点,令头节点指向该节点的后继节点 } else { prev.next = next;//将前驱节点的后继节点指向后继节点 x.prev = null; From 3731f4d51401f320abb89cce1d91520fe731fff3 Mon Sep 17 00:00:00 2001 From: Snailclimb Date: Tue, 12 Mar 2019 17:08:30 +0800 Subject: [PATCH 122/232] Create Java8Tutorial.md MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Java8新特性总结，翻译自https://github.com/winterbe/java8-tutorial，在原文增加了一些内容 --- Java/What's New in JDK8/Java8Tutorial.md | 888 +++++++++++++++++++++++ 1 file changed, 888 insertions(+) create mode 100644 Java/What's New in JDK8/Java8Tutorial.md diff --git a/Java/What's New in JDK8/Java8Tutorial.md b/Java/What's New in JDK8/Java8Tutorial.md new file mode 100644 index 00000000000..80736282cfa --- /dev/null +++ b/Java/What's New in JDK8/Java8Tutorial.md @@ -0,0 +1,888 @@ +随着 Java 8 的普及度越来越高，很多人都提到面试中关于Java 8 也是非常常问的知识点。应各位要求和需要，我打算对这部分知识做一个总结。本来准备自己总结的，后面看到Github 上有一个相关的仓库，地址： +[https://github.com/winterbe/java8-tutorial](https://github.com/winterbe/java8-tutorial)。这个仓库是英文的，我对其进行了翻译并添加和修改了部分内容，下面是正文了。 + +# Java 8 + +欢迎阅读我对Java 8的介绍。本教程将逐步指导您完成所有新语言功能。 在简短的代码示例的基础上，您将学习如何使用默认接口方法，lambda表达式，方法引用和可重复注释。 在本文的最后，您将熟悉最新的 API 更改，如流，函数式接口(Functional Interfaces)，Map 类的扩展和新的 Date API。 没有大段枯燥的文字，只有一堆注释的代码片段。 + + +### 接口的默认方法(Default Methods for Interfaces) + +Java 8使我们能够通过使用 `default` 关键字向接口添加非抽象方法实现。 此功能也称为[虚拟扩展方法](http://stackoverflow.com/a/24102730)。 + +第一个例子： + +```java +interface Formula{ + + double calculate(int a); + + default double sqrt(int a) { + return Math.sqrt(a); + } + +} +``` + +Formula 接口中除了抽象方法计算接口公式还定义了默认方法 `sqrt`。 实现该接口的类只需要实现抽象方法 `calculate`。 默认方法`sqrt` 可以直接使用。当然你也可以直接通过接口创建对象，然后实现接口中的默认方法就可以了，我们通过代码演示一下这种方式。 + +```java +public class Main { + + public static void main(String[] args) { + // TODO 通过匿名内部类方式访问接口 + Formula formula = new Formula() { + @Override + public double calculate(int a) { + return sqrt(a * 100); + } + }; + + System.out.println(formula.calculate(100)); // 100.0 + System.out.println(formula.sqrt(16)); // 4.0 + + } + +} +``` + + formula 是作为匿名对象实现的。该代码非常容易理解，6行代码实现了计算 `sqrt(a * 100)`。在下一节中，我们将会看到在 Java 8 中实现单个方法对象有一种更好更方便的方法。 + +**译者注：** 不管是抽象类还是接口，都可以通过匿名内部类的方式访问。不能通过抽象类或者接口直接创建对象。对于上面通过匿名内部类方式访问接口，我们可以这样理解：一个内部类实现了接口里的抽象方法并且返回一个内部类对象，之后我们让接口的引用来指向这个对象。 + +### Lambda表达式(Lambda expressions) + +首先看看在老版本的Java中是如何排列字符串的： + +```java +List names = Arrays.asList("peter", "anna", "mike", "xenia"); + +Collections.sort(names, new Comparator() { + @Override + public int compare(String a, String b) { + return b.compareTo(a); + } +}); +``` + +只需要给静态方法` Collections.sort` 传入一个 List 对象以及一个比较器来按指定顺序排列。通常做法都是创建一个匿名的比较器对象然后将其传递给 `sort` 方法。 + +在Java 8 中你就没必要使用这种传统的匿名对象的方式了，Java 8提供了更简洁的语法，lambda表达式： + +```java +Collections.sort(names, (String a, String b) -> { + return b.compareTo(a); +}); +``` + +可以看出，代码变得更段且更具有可读性，但是实际上还可以写得更短： + +```java +Collections.sort(names, (String a, String b) -> b.compareTo(a)); +``` + +对于函数体只有一行代码的，你可以去掉大括号{}以及return关键字，但是你还可以写得更短点： + +```java +names.sort((a, b) -> b.compareTo(a)); +``` + +List 类本身就有一个 `sort` 方法。并且Java编译器可以自动推导出参数类型，所以你可以不用再写一次类型。接下来我们看看lambda表达式还有什么其他用法。 + +### 函数式接口(Functional Interfaces) + +**译者注：**原文对这部分解释不太清楚，故做了修改！ + +Java 语言设计者们投入了大量精力来思考如何使现有的函数友好地支持Lambda。最终采取的方法是：增加函数式接口的概念。**“函数式接口”是指仅仅只包含一个抽象方法,但是可以有多个非抽象方法(也就是上面提到的默认方法)的接口。** 像这样的接口，可以被隐式转换为lambda表达式。`java.lang.Runnable` 与 `java.util.concurrent.Callable` 是函数式接口最典型的两个例子。Java 8增加了一种特殊的注解`@FunctionalInterface`,但是这个注解通常不是必须的(某些情况建议使用)，只要接口只包含一个抽象方法，虚拟机会自动判断该接口为函数式接口。一般建议在接口上使用`@FunctionalInterface` 注解进行声明，这样的话，编译器如果发现你标注了这个注解的接口有多于一个抽象方法的时候会报错的，如下图所示 + + + +示例： + +```java +@FunctionalInterface +public interface Converter { + T convert(F from); +} +``` + +```java + // TODO 将数字字符串转换为整数类型 + Converter converter = (from) -> Integer.valueOf(from); + Integer converted = converter.convert("123"); + System.out.println(converted.getClass()); //class java.lang.Integer +``` + +**译者注：**大部分函数式接口都不用我们自己写，Java8都给我们实现好了，这些接口都在java.util.function包里。 + +### 方法和构造函数引用(Method and Constructor References) + +前一节中的代码还可以通过静态方法引用来表示： + +```java + Converter converter = Integer::valueOf; + Integer converted = converter.convert("123"); + System.out.println(converted.getClass()); //class java.lang.Integer +``` +Java 8允许您通过`::`关键字传递方法或构造函数的引用。 上面的示例显示了如何引用静态方法。 但我们也可以引用对象方法： + +```java +class Something { + String startsWith(String s) { + return String.valueOf(s.charAt(0)); + } +} +``` + +```java +Something something = new Something(); +Converter converter = something::startsWith; +String converted = converter.convert("Java"); +System.out.println(converted); // "J" +``` + +接下来看看构造函数是如何使用`::`关键字来引用的，首先我们定义一个包含多个构造函数的简单类： + +```java +class Person { + String firstName; + String lastName; + + Person() {} + + Person(String firstName, String lastName) { + this.firstName = firstName; + this.lastName = lastName; + } +} +``` +接下来我们指定一个用来创建Person对象的对象工厂接口： + +```java +interface PersonFactory

{ + P create(String firstName, String lastName); +} +``` + +这里我们使用构造函数引用来将他们关联起来，而不是手动实现一个完整的工厂： + +```java +PersonFactory personFactory = Person::new; +Person person = personFactory.create("Peter", "Parker"); +``` +我们只需要使用 `Person::new` 来获取Person类构造函数的引用，Java编译器会自动根据`PersonFactory.create`方法的参数类型来选择合适的构造函数。 + +### Lamda 表达式作用域(Lambda Scopes) + +#### 访问局部变量 + +我们可以直接在 lambda 表达式中访问外部的局部变量： + +```java +final int num = 1; +Converter stringConverter = + (from) -> String.valueOf(from + num); + +stringConverter.convert(2); // 3 +``` + +但是和匿名对象不同的是，这里的变量num可以不用声明为final，该代码同样正确： + +```java +int num = 1; +Converter stringConverter = + (from) -> String.valueOf(from + num); + +stringConverter.convert(2); // 3 +``` + +不过这里的 num 必须不可被后面的代码修改（即隐性的具有final的语义），例如下面的就无法编译： + +```java +int num = 1; +Converter stringConverter = + (from) -> String.valueOf(from + num); +num = 3;//在lambda表达式中试图修改num同样是不允许的。 +``` + +#### 访问字段和静态变量 + +与局部变量相比，我们对lambda表达式中的实例字段和静态变量都有读写访问权限。 该行为和匿名对象是一致的。 + +```java +class Lambda4 { + static int outerStaticNum; + int outerNum; + + void testScopes() { + Converter stringConverter1 = (from) -> { + outerNum = 23; + return String.valueOf(from); + }; + + Converter stringConverter2 = (from) -> { + outerStaticNum = 72; + return String.valueOf(from); + }; + } +} +``` + +#### 访问默认接口方法 + +还记得第一节中的 formula 示例吗？ `Formula` 接口定义了一个默认方法`sqrt`，可以从包含匿名对象的每个 formula 实例访问该方法。 这不适用于lambda表达式。 + +无法从 lambda 表达式中访问默认方法,故以下代码无法编译： + +```java +Formula formula = (a) -> sqrt(a * 100); +``` + +### 内置函数式接口(Built-in Functional Interfaces) + +JDK 1.8 API包含许多内置函数式接口。 其中一些借口在老版本的 Java 中是比较常见的比如： `Comparator` 或`Runnable`，这些接口都增加了`@FunctionalInterface`注解以便能用在 lambda 表达式上。 + +但是 Java 8 API 同样还提供了很多全新的函数式接口来让你的编程工作更加方便，有一些接口是来自 [Google Guava](https://code.google.com/p/guava-libraries/) 库里的，即便你对这些很熟悉了，还是有必要看看这些是如何扩展到lambda上使用的。 + +#### Predicates + +Predicate 接口是只有一个参数的返回布尔类型值的 **断言型** 接口。该接口包含多种默认方法来将 Predicate 组合成其他复杂的逻辑（比如：与，或，非）： + +**译者注：**Predicate 接口源码如下 + +```java +package java.util.function; +import java.util.Objects; + +@FunctionalInterface +public interface Predicate { + + // 该方法是接受一个传入类型,返回一个布尔值.此方法应用于判断. + boolean test(T t); + + //and方法与关系型运算符"&&"相似，两边都成立才返回true + default Predicate and(Predicate other) { + Objects.requireNonNull(other); + return (t) -> test(t) && other.test(t); + } + // 与关系运算符"!"相似，对判断进行取反 + default Predicate negate() { + return (t) -> !test(t); + } + //or方法与关系型运算符"||"相似，两边只要有一个成立就返回true + default Predicate or(Predicate other) { + Objects.requireNonNull(other); + return (t) -> test(t) || other.test(t); + } + // 该方法接收一个Object对象,返回一个Predicate类型.此方法用于判断第一个test的方法与第二个test方法相同(equal). + static Predicate isEqual(Object targetRef) { + return (null == targetRef) + ? Objects::isNull + : object -> targetRef.equals(object); + } +``` + +示例： + +```java +Predicate predicate = (s) -> s.length() > 0; + +predicate.test("foo"); // true +predicate.negate().test("foo"); // false + +Predicate nonNull = Objects::nonNull; +Predicate isNull = Objects::isNull; + +Predicate isEmpty = String::isEmpty; +Predicate isNotEmpty = isEmpty.negate(); +``` + +#### Functions + +Function 接口接受一个参数并生成结果。默认方法可用于将多个函数链接在一起（compose, andThen）： + +**译者注：**Function 接口源码如下 + +```java + +package java.util.function; + +import java.util.Objects; + +@FunctionalInterface +public interface Function { + + //将Function对象应用到输入的参数上，然后返回计算结果。 + R apply(T t); + //将两个Function整合，并返回一个能够执行两个Function对象功能的Function对象。 + default Function compose(Function before) { + Objects.requireNonNull(before); + return (V v) -> apply(before.apply(v)); + } + // + default Function andThen(Function after) { + Objects.requireNonNull(after); + return (T t) -> after.apply(apply(t)); + } + + static Function identity() { + return t -> t; + } +} +``` + + + +```java +Function toInteger = Integer::valueOf; +Function backToString = toInteger.andThen(String::valueOf); +backToString.apply("123"); // "123" +``` + +#### Suppliers + +Supplier 接口产生给定泛型类型的结果。 与 Function 接口不同，Supplier 接口不接受参数。 + +```java +Supplier personSupplier = Person::new; +personSupplier.get(); // new Person +``` + +#### Consumers + +Consumer 接口表示要对单个输入参数执行的操作。 + +```java +Consumer greeter = (p) -> System.out.println("Hello, " + p.firstName); +greeter.accept(new Person("Luke", "Skywalker")); +``` + +#### Comparators + +Comparator 是老Java中的经典接口， Java 8在此之上添加了多种默认方法： + +```java +Comparator comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName); + +Person p1 = new Person("John", "Doe"); +Person p2 = new Person("Alice", "Wonderland"); + +comparator.compare(p1, p2); // > 0 +comparator.reversed().compare(p1, p2); // < 0 +``` + +## Optionals + +Optionals不是函数式接口，而是用于防止 NullPointerException 的漂亮工具。这是下一节的一个重要概念，让我们快速了解一下Optionals的工作原理。 + +Optional 是一个简单的容器，其值可能是null或者不是null。在Java 8之前一般某个函数应该返回非空对象但是有时却什么也没有返回，而在Java 8中，你应该返回 Optional 而不是 null。 + +译者注：示例中每个方法的作用已经添加。 + +```java +//of（）：为非null的值创建一个Optional +Optional optional = Optional.of("bam"); +// isPresent（）： 如果值存在返回true，否则返回false +optional.isPresent(); // true +//get()：如果Optional有值则将其返回，否则抛出NoSuchElementException +optional.get(); // "bam" +//orElse（）：如果有值则将其返回，否则返回指定的其它值 +optional.orElse("fallback"); // "bam" +//ifPresent（）：如果Optional实例有值则为其调用consumer，否则不做处理 +optional.ifPresent((s) -> System.out.println(s.charAt(0))); // "b" +``` + +推荐阅读：[[Java8]如何正确使用Optional](https://blog.kaaass.net/archives/764) + +## Streams(流) + +`java.util.Stream` 表示能应用在一组元素上一次执行的操作序列。Stream 操作分为中间操作或者最终操作两种，最终操作返回一特定类型的计算结果，而中间操作返回Stream本身，这样你就可以将多个操作依次串起来。Stream 的创建需要指定一个数据源，比如` java.util.Collection` 的子类，List 或者 Set， Map 不支持。Stream 的操作可以串行执行或者并行执行。 + +首先看看Stream是怎么用，首先创建实例代码的用到的数据List： + +```java +List stringCollection = new ArrayList<>(); +stringCollection.add("ddd2"); +stringCollection.add("aaa2"); +stringCollection.add("bbb1"); +stringCollection.add("aaa1"); +stringCollection.add("bbb3"); +stringCollection.add("ccc"); +stringCollection.add("bbb2"); +stringCollection.add("ddd1"); +``` + +Java 8扩展了集合类，可以通过 Collection.stream() 或者 Collection.parallelStream() 来创建一个Stream。下面几节将详细解释常用的Stream操作： + +### Filter(过滤) + +过滤通过一个predicate接口来过滤并只保留符合条件的元素，该操作属于**中间操作**，所以我们可以在过滤后的结果来应用其他Stream操作（比如forEach）。forEach需要一个函数来对过滤后的元素依次执行。forEach是一个最终操作，所以我们不能在forEach之后来执行其他Stream操作。 + +```java + // 测试 Filter(过滤) + stringList + .stream() + .filter((s) -> s.startsWith("a")) + .forEach(System.out::println);//aaa2 aaa1 +``` + +forEach 是为 Lambda 而设计的，保持了最紧凑的风格。而且 Lambda 表达式本身是可以重用的，非常方便。 + +### Sorted(排序) + +排序是一个 **中间操作**，返回的是排序好后的 Stream。**如果你不指定一个自定义的 Comparator 则会使用默认排序。** + +```java + // 测试 Sort (排序) + stringList + .stream() + .sorted() + .filter((s) -> s.startsWith("a")) + .forEach(System.out::println);// aaa1 aaa2 +``` + +需要注意的是，排序只创建了一个排列好后的Stream，而不会影响原有的数据源，排序之后原数据stringCollection是不会被修改的： + +```java + System.out.println(stringList);// ddd2, aaa2, bbb1, aaa1, bbb3, ccc, bbb2, ddd1 +``` + +### Map(映射) + +中间操作 map 会将元素根据指定的 Function 接口来依次将元素转成另外的对象。 + +下面的示例展示了将字符串转换为大写字符串。你也可以通过map来讲对象转换成其他类型，map返回的Stream类型是根据你map传递进去的函数的返回值决定的。 + +```java + // 测试 Map 操作 + stringList + .stream() + .map(String::toUpperCase) + .sorted((a, b) -> b.compareTo(a)) + .forEach(System.out::println);// "DDD2", "DDD1", "CCC", "BBB3", "BBB2", "AAA2", "AAA1" +``` + + + +### Match(匹配) + +Stream提供了多种匹配操作，允许检测指定的Predicate是否匹配整个Stream。所有的匹配操作都是 **最终操作** ，并返回一个 boolean 类型的值。 + +```java + // 测试 Match (匹配)操作 + boolean anyStartsWithA = + stringList + .stream() + .anyMatch((s) -> s.startsWith("a")); + System.out.println(anyStartsWithA); // true + + boolean allStartsWithA = + stringList + .stream() + .allMatch((s) -> s.startsWith("a")); + + System.out.println(allStartsWithA); // false + + boolean noneStartsWithZ = + stringList + .stream() + .noneMatch((s) -> s.startsWith("z")); + + System.out.println(noneStartsWithZ); // true +``` + + + +### Count(计数) + +计数是一个 **最终操作**，返回Stream中元素的个数，**返回值类型是 long**。 + +```java + //测试 Count (计数)操作 + long startsWithB = + stringList + .stream() + .filter((s) -> s.startsWith("b")) + .count(); + System.out.println(startsWithB); // 3 +``` + +### Reduce(规约) + +这是一个 **最终操作** ，允许通过指定的函数来讲stream中的多个元素规约为一个元素，规约后的结果是通过Optional 接口表示的： + +```java + //测试 Reduce (规约)操作 + Optional reduced = + stringList + .stream() + .sorted() + .reduce((s1, s2) -> s1 + "#" + s2); + + reduced.ifPresent(System.out::println);//aaa1#aaa2#bbb1#bbb2#bbb3#ccc#ddd1#ddd2 +``` + + + +**译者注：** 这个方法的主要作用是把 Stream 元素组合起来。它提供一个起始值（种子），然后依照运算规则（BinaryOperator），和前面 Stream 的第一个、第二个、第 n 个元素组合。从这个意义上说，字符串拼接、数值的 sum、min、max、average 都是特殊的 reduce。例如 Stream 的 sum 就相当于`Integer sum = integers.reduce(0, (a, b) -> a+b);`也有没有起始值的情况，这时会把 Stream 的前面两个元素组合起来，返回的是 Optional。 + +```java +// 字符串连接，concat = "ABCD" +String concat = Stream.of("A", "B", "C", "D").reduce("", String::concat); +// 求最小值，minValue = -3.0 +double minValue = Stream.of(-1.5, 1.0, -3.0, -2.0).reduce(Double.MAX_VALUE, Double::min); +// 求和，sumValue = 10, 有起始值 +int sumValue = Stream.of(1, 2, 3, 4).reduce(0, Integer::sum); +// 求和，sumValue = 10, 无起始值 +sumValue = Stream.of(1, 2, 3, 4).reduce(Integer::sum).get(); +// 过滤，字符串连接，concat = "ace" +concat = Stream.of("a", "B", "c", "D", "e", "F"). + filter(x -> x.compareTo("Z") > 0). + reduce("", String::concat); +``` + +上面代码例如第一个示例的 reduce()，第一个参数（空白字符）即为起始值，第二个参数（String::concat）为 BinaryOperator。这类有起始值的 reduce() 都返回具体的对象。而对于第四个示例没有起始值的 reduce()，由于可能没有足够的元素，返回的是 Optional，请留意这个区别。更多内容查看： [IBM：Java 8 中的 Streams API 详解](https://www.ibm.com/developerworks/cn/java/j-lo-java8streamapi/index.html) + +## Parallel Streams(并行流) + +前面提到过Stream有串行和并行两种，串行Stream上的操作是在一个线程中依次完成，而并行Stream则是在多个线程上同时执行。 + +下面的例子展示了是如何通过并行Stream来提升性能： + +首先我们创建一个没有重复元素的大表： + +```java +int max = 1000000; +List values = new ArrayList<>(max); +for (int i = 0; i < max; i++) { + UUID uuid = UUID.randomUUID(); + values.add(uuid.toString()); +} +``` + +我们分别用串行和并行两种方式对其进行排序，最后看看所用时间的对比。 + +### Sequential Sort(串行排序) + +```java +//串行排序 +long t0 = System.nanoTime(); +long count = values.stream().sorted().count(); +System.out.println(count); + +long t1 = System.nanoTime(); + +long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0); +System.out.println(String.format("sequential sort took: %d ms", millis)); +``` + +``` +1000000 +sequential sort took: 709 ms//串行排序所用的时间 +``` + +### Parallel Sort(并行排序) + +```java +//并行排序 +long t0 = System.nanoTime(); + +long count = values.parallelStream().sorted().count(); +System.out.println(count); + +long t1 = System.nanoTime(); + +long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0); +System.out.println(String.format("parallel sort took: %d ms", millis)); + +``` + +```java +1000000 +parallel sort took: 475 ms//串行排序所用的时间 +``` + +上面两个代码几乎是一样的，但是并行版的快了 50% 左右，唯一需要做的改动就是将 `stream()` 改为`parallelStream()`。 + +## Maps + +前面提到过，Map 类型不支持 streams，不过Map提供了一些新的有用的方法来处理一些日常任务。Map接口本身没有可用的 `stream（）`方法，但是你可以在键，值上创建专门的流或者通过 `map.keySet().stream()`,`map.values().stream()`和`map.entrySet().stream()`。 + +此外,Maps 支持各种新的和有用的方法来执行常见任务。 + +```java +Map map = new HashMap<>(); + +for (int i = 0; i < 10; i++) { + map.putIfAbsent(i, "val" + i); +} + +map.forEach((id, val) -> System.out.println(val));//val0 val1 val2 val3 val4 val5 val6 val7 val8 val9 +``` + +`putIfAbsent` 阻止我们在null检查时写入额外的代码;`forEach`接受一个 consumer 来对 map 中的每个元素操作。 + +此示例显示如何使用函数在 map 上计算代码： + +```java +map.computeIfPresent(3, (num, val) -> val + num); +map.get(3); // val33 + +map.computeIfPresent(9, (num, val) -> null); +map.containsKey(9); // false + +map.computeIfAbsent(23, num -> "val" + num); +map.containsKey(23); // true + +map.computeIfAbsent(3, num -> "bam"); +map.get(3); // val33 +``` + +接下来展示如何在Map里删除一个键值全都匹配的项： + +```java +map.remove(3, "val3"); +map.get(3); // val33 +map.remove(3, "val33"); +map.get(3); // null +``` + +另外一个有用的方法： + +```java +map.getOrDefault(42, "not found"); // not found +``` + +对Map的元素做合并也变得很容易了： + +```java +map.merge(9, "val9", (value, newValue) -> value.concat(newValue)); +map.get(9); // val9 +map.merge(9, "concat", (value, newValue) -> value.concat(newValue)); +map.get(9); // val9concat +``` + +Merge 做的事情是如果键名不存在则插入，否则则对原键对应的值做合并操作并重新插入到map中。 + +## Data API(日期相关API) + +Java 8在 `java.time` 包下包含一个全新的日期和时间API。新的Date API与Joda-Time库相似，但它们不一样。以下示例涵盖了此新 API 的最重要部分。译者对这部分内容参考相关书籍做了大部分修改。 + +**译者注(总结)：** + +- Clock 类提供了访问当前日期和时间的方法，Clock 是时区敏感的，可以用来取代 `System.currentTimeMillis()` 来获取当前的微秒数。某一个特定的时间点也可以使用 `Instant` 类来表示，`Instant` 类也可以用来创建旧版本的`java.util.Date` 对象。 + +- 在新API中时区使用 ZoneId 来表示。时区可以很方便的使用静态方法of来获取到。 抽象类`ZoneId`（在`java.time`包中）表示一个区域标识符。 它有一个名为`getAvailableZoneIds`的静态方法，它返回所有区域标识符。 + +- jdk1.8中新增了 LocalDate 与 LocalDateTime等类来解决日期处理方法，同时引入了一个新的类DateTimeFormatter 来解决日期格式化问题。可以使用Instant代替 Date，LocalDateTime代替 Calendar，DateTimeFormatter 代替 SimpleDateFormat。 + + + +### Clock + +Clock 类提供了访问当前日期和时间的方法，Clock 是时区敏感的，可以用来取代 `System.currentTimeMillis()` 来获取当前的微秒数。某一个特定的时间点也可以使用 `Instant` 类来表示，`Instant` 类也可以用来创建旧版本的`java.util.Date` 对象。 + +```java +Clock clock = Clock.systemDefaultZone(); +long millis = clock.millis(); +System.out.println(millis);//1552379579043 +Instant instant = clock.instant(); +System.out.println(instant); +Date legacyDate = Date.from(instant); //2019-03-12T08:46:42.588Z +System.out.println(legacyDate);//Tue Mar 12 16:32:59 CST 2019 +``` + +### Timezones(时区) + +在新API中时区使用 ZoneId 来表示。时区可以很方便的使用静态方法of来获取到。 抽象类`ZoneId`（在`java.time`包中）表示一个区域标识符。 它有一个名为`getAvailableZoneIds`的静态方法，它返回所有区域标识符。 + +```java +//输出所有区域标识符 +System.out.println(ZoneId.getAvailableZoneIds()); + +ZoneId zone1 = ZoneId.of("Europe/Berlin"); +ZoneId zone2 = ZoneId.of("Brazil/East"); +System.out.println(zone1.getRules());// ZoneRules[currentStandardOffset=+01:00] +System.out.println(zone2.getRules());// ZoneRules[currentStandardOffset=-03:00] +``` + +### LocalTime(本地时间) + +LocalTime 定义了一个没有时区信息的时间，例如 晚上10点或者 17:30:15。下面的例子使用前面代码创建的时区创建了两个本地时间。之后比较时间并以小时和分钟为单位计算两个时间的时间差： + +```java +LocalTime now1 = LocalTime.now(zone1); +LocalTime now2 = LocalTime.now(zone2); +System.out.println(now1.isBefore(now2)); // false + +long hoursBetween = ChronoUnit.HOURS.between(now1, now2); +long minutesBetween = ChronoUnit.MINUTES.between(now1, now2); + +System.out.println(hoursBetween); // -3 +System.out.println(minutesBetween); // -239 +``` + +LocalTime 提供了多种工厂方法来简化对象的创建，包括解析时间字符串. + +```java +LocalTime late = LocalTime.of(23, 59, 59); +System.out.println(late); // 23:59:59 +DateTimeFormatter germanFormatter = + DateTimeFormatter + .ofLocalizedTime(FormatStyle.SHORT) + .withLocale(Locale.GERMAN); + +LocalTime leetTime = LocalTime.parse("13:37", germanFormatter); +System.out.println(leetTime); // 13:37 +``` + +### LocalDate(本地日期) + +LocalDate 表示了一个确切的日期，比如 2014-03-11。该对象值是不可变的，用起来和LocalTime基本一致。下面的例子展示了如何给Date对象加减天/月/年。另外要注意的是这些对象是不可变的，操作返回的总是一个新实例。 + +```java +LocalDate today = LocalDate.now();//获取现在的日期 +System.out.println("今天的日期: "+today);//2019-03-12 +LocalDate tomorrow = today.plus(1, ChronoUnit.DAYS); +System.out.println("明天的日期: "+tomorrow);//2019-03-13 +LocalDate yesterday = tomorrow.minusDays(2); +System.out.println("昨天的日期: "+yesterday);//2019-03-11 +LocalDate independenceDay = LocalDate.of(2019, Month.MARCH, 12); +DayOfWeek dayOfWeek = independenceDay.getDayOfWeek(); +System.out.println("今天是周几:"+dayOfWeek);//TUESDAY +``` + +从字符串解析一个 LocalDate 类型和解析 LocalTime 一样简单,下面是使用 `DateTimeFormatter` 解析字符串的例子： + +```java + String str1 = "2014==04==12 01时06分09秒"; + // 根据需要解析的日期、时间字符串定义解析所用的格式器 + DateTimeFormatter fomatter1 = DateTimeFormatter + .ofPattern("yyyy==MM==dd HH时mm分ss秒"); + + LocalDateTime dt1 = LocalDateTime.parse(str1, fomatter1); + System.out.println(dt1); // 输出 2014-04-12T01:06:09 + + String str2 = "2014$$$四月$$$13 20小时"; + DateTimeFormatter fomatter2 = DateTimeFormatter + .ofPattern("yyy$$$MMM$$$dd HH小时"); + LocalDateTime dt2 = LocalDateTime.parse(str2, fomatter2); + System.out.println(dt2); // 输出 2014-04-13T20:00 + +``` + +再来看一个使用 `DateTimeFormatter` 格式化日期的示例 + +```java +LocalDateTime rightNow=LocalDateTime.now(); +String date=DateTimeFormatter.ISO_LOCAL_DATE_TIME.format(rightNow); +System.out.println(date);//2019-03-12T16:26:48.29 +DateTimeFormatter formatter=DateTimeFormatter.ofPattern("YYYY-MM-dd HH:mm:ss"); +System.out.println(formatter.format(rightNow));//2019-03-12 16:26:48 +``` + +### LocalDateTime(本地日期时间) + +LocalDateTime 同时表示了时间和日期，相当于前两节内容合并到一个对象上了。LocalDateTime 和 LocalTime还有 LocalDate 一样，都是不可变的。LocalDateTime 提供了一些能访问具体字段的方法。 + +```java +LocalDateTime sylvester = LocalDateTime.of(2014, Month.DECEMBER, 31, 23, 59, 59); + +DayOfWeek dayOfWeek = sylvester.getDayOfWeek(); +System.out.println(dayOfWeek); // WEDNESDAY + +Month month = sylvester.getMonth(); +System.out.println(month); // DECEMBER + +long minuteOfDay = sylvester.getLong(ChronoField.MINUTE_OF_DAY); +System.out.println(minuteOfDay); // 1439 +``` + +只要附加上时区信息，就可以将其转换为一个时间点Instant对象，Instant时间点对象可以很容易的转换为老式的`java.util.Date`。 + +```java +Instant instant = sylvester + .atZone(ZoneId.systemDefault()) + .toInstant(); + +Date legacyDate = Date.from(instant); +System.out.println(legacyDate); // Wed Dec 31 23:59:59 CET 2014 +``` + +格式化LocalDateTime和格式化时间和日期一样的，除了使用预定义好的格式外，我们也可以自己定义格式： + +```java +DateTimeFormatter formatter = + DateTimeFormatter + .ofPattern("MMM dd, yyyy - HH:mm"); +LocalDateTime parsed = LocalDateTime.parse("Nov 03, 2014 - 07:13", formatter); +String string = formatter.format(parsed); +System.out.println(string); // Nov 03, 2014 - 07:13 +``` + +和java.text.NumberFormat不一样的是新版的DateTimeFormatter是不可变的，所以它是线程安全的。 +关于时间日期格式的详细信息在[这里](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html)。 + +## Annotations(注解) + +在Java 8中支持多重注解了，先看个例子来理解一下是什么意思。 +首先定义一个包装类Hints注解用来放置一组具体的Hint注解： + +```java +@interface Hints { + Hint[] value(); +} +@Repeatable(Hints.class) +@interface Hint { + String value(); +} +``` + +Java 8允许我们把同一个类型的注解使用多次，只需要给该注解标注一下`@Repeatable`即可。 + +例 1: 使用包装类当容器来存多个注解（老方法） + +```java +@Hints({@Hint("hint1"), @Hint("hint2")}) +class Person {} +``` + +例 2：使用多重注解（新方法） + +```java +@Hint("hint1") +@Hint("hint2") +class Person {} +``` + +第二个例子里java编译器会隐性的帮你定义好@Hints注解，了解这一点有助于你用反射来获取这些信息： + +```java +Hint hint = Person.class.getAnnotation(Hint.class); +System.out.println(hint); // null +Hints hints1 = Person.class.getAnnotation(Hints.class); +System.out.println(hints1.value().length); // 2 + +Hint[] hints2 = Person.class.getAnnotationsByType(Hint.class); +System.out.println(hints2.length); // 2 +``` + +即便我们没有在 `Person`类上定义 `@Hints`注解，我们还是可以通过 `getAnnotation(Hints.class) `来获取 `@Hints`注解，更加方便的方法是使用 `getAnnotationsByType` 可以直接获取到所有的`@Hint`注解。 +另外Java 8的注解还增加到两种新的target上了： + +```java +@Target({ElementType.TYPE_PARAMETER, ElementType.TYPE_USE}) +@interface MyAnnotation {} +``` + + + +## Whete to go from here? + +关于Java 8的新特性就写到这了，肯定还有更多的特性等待发掘。JDK 1.8里还有很多很有用的东西，比如`Arrays.parallelSort`, `StampedLock`和`CompletableFuture`等等。 + +### 参考 + +- https://www.jb51.net/article/48304.htm +- https://github.com/winterbe/java8-tutorial#predicates + From 51a958df288cb8ea56f54ddfc42a9682e0a77b24 Mon Sep 17 00:00:00 2001 From: SnailClimb Date: Tue, 12 Mar 2019 17:12:50 +0800 Subject: [PATCH 123/232] Update ToDoList --- README.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 8968159cd4d..25248313c65 100644 --- a/README.md +++ b/README.md @@ -44,9 +44,10 @@ * [闲谈](#闲谈) * [说明](#说明) -## 待办 +## ToDoList(待办清单) -* [ ] Java 8 新特性总结 +* [x] Java 8 新特性总结 +* [ ] Java 8 新特性详解 * [ ] Java 多线程类别知识重构 * [x] BIO,NIO,AIO 总结 * [ ] Netty 总结 From 31471256a869bcb3ede9cda899684f5efd2ce5ea Mon Sep 17 00:00:00 2001 From: SnailClimb Date: Tue, 12 Mar 2019 17:17:47 +0800 Subject: [PATCH 124/232] Update category --- README.md | 23 +++++++++++++---------- 1 file changed, 13 insertions(+), 10 deletions(-) diff --git a/README.md b/README.md index 25248313c65..c8e2bc5ecf1 100644 --- a/README.md +++ b/README.md @@ -16,11 +16,12 @@ ## 目录 * [Java](#java) - * [Java/J2EE 基础](#javaj2ee-基础) - * [Java 集合框架](#java-集合框架) - * [Java 多线程](#java-多线程) - * [Java BIO,NIO,AIO](#java-bionioaio) - * [Java 虚拟机 jvm](#java-虚拟机-jvm) + * [基础](#基础) + * [集合框架](#集合框架) + * [多线程](#多线程) + * [BIO,NIO,AIO](#bionioaio) + * [JVM](#jvm) + * [Java8 New Features](#java8-new-features) * [设计模式](#设计模式) * [数据结构与算法](#数据结构与算法) * [数据结构](#数据结构) @@ -55,13 +56,13 @@ ## Java -### Java/J2EE 基础 +### 基础 * [Java 基础知识回顾](https://github.com/Snailclimb/Java-Guide/blob/master/Java/Java基础知识.md) * [J2EE 基础知识回顾](https://github.com/Snailclimb/Java-Guide/blob/master/Java/J2EE基础知识.md) * [Java常见关键字总结：static、final、this、super](https://github.com/Snailclimb/Java-Guide/blob/master/Java/final、static、this、super.md) -### Java 集合框架 +### 集合框架 * **常见问题总结：** * [这几道Java集合框架面试题几乎必问](https://github.com/Snailclimb/Java-Guide/blob/master/Java/这几道Java集合框架面试题几乎必问.md) @@ -72,7 +73,7 @@ * [LinkedList 源码学习](https://github.com/Snailclimb/Java-Guide/blob/master/Java/LinkedList.md) * [HashMap(JDK1.8)源码学习](https://github.com/Snailclimb/Java-Guide/blob/master/Java/HashMap.md) -### Java 多线程 +### 多线程 * [并发编程面试必备：synchronized 关键字使用、底层原理、JDK1.6 之后的底层优化以及 和ReenTrantLock 的对比](https://github.com/Snailclimb/Java_Guide/blob/master/Java/synchronized.md) * [并发编程面试必备：乐观锁与悲观锁](https://github.com/Snailclimb/Java-Guide/blob/master/EssentialContentForInterview/面试必备之乐观锁与悲观锁.md) @@ -81,17 +82,19 @@ * [BATJ都爱问的多线程面试题](https://github.com/Snailclimb/Java_Guide/blob/master/Java/Multithread/BATJ都爱问的多线程面试题.md) * [并发容器总结](https://github.com/Snailclimb/Java_Guide/blob/master/Java/Multithread/并发容器总结.md) -### Java 虚拟机 jvm +### JVM * [可能是把Java内存区域讲的最清楚的一篇文章](https://github.com/Snailclimb/Java_Guide/blob/master/Java/可能是把Java内存区域讲的最清楚的一篇文章.md) * [搞定JVM垃圾回收就是这么简单](https://github.com/Snailclimb/Java_Guide/blob/master/Java/搞定JVM垃圾回收就是这么简单.md) * [《深入理解Java虚拟机》第2版学习笔记](https://github.com/Snailclimb/Java_Guide/blob/master/Java/Java虚拟机（jvm）.md) -### Java BIO,NIO,AIO +### BIO,NIO,AIO * [BIO,NIO,AIO 总结 ](https://github.com/Snailclimb/JavaGuide/blob/master/Java/BIO%2CNIO%2CAIO%20summary.md) * [Java IO 与 NIO系列文章](https://github.com/Snailclimb/Java_Guide/blob/master/Java/Java%20IO与NIO.md) +### Java8 New Features + ### 设计模式 * [设计模式系列文章](https://github.com/Snailclimb/Java_Guide/blob/master/Java/设计模式.md) From f432ca69a1f2c3ca7bd9ae7340ea2441524c1cee Mon Sep 17 00:00:00 2001 From: SnailClimb Date: Tue, 12 Mar 2019 17:38:20 +0800 Subject: [PATCH 125/232] Update Java8Tutorial.md --- Java/What's New in JDK8/Java8Tutorial.md | 5 ----- 1 file changed, 5 deletions(-) diff --git a/Java/What's New in JDK8/Java8Tutorial.md b/Java/What's New in JDK8/Java8Tutorial.md index 80736282cfa..86a8750ee8b 100644 --- a/Java/What's New in JDK8/Java8Tutorial.md +++ b/Java/What's New in JDK8/Java8Tutorial.md @@ -881,8 +881,3 @@ System.out.println(hints2.length); // 2 关于Java 8的新特性就写到这了，肯定还有更多的特性等待发掘。JDK 1.8里还有很多很有用的东西，比如`Arrays.parallelSort`, `StampedLock`和`CompletableFuture`等等。 -### 参考 - -- https://www.jb51.net/article/48304.htm -- https://github.com/winterbe/java8-tutorial#predicates - From 2f846de80c743f7d55e08742b42a125c814ef9b0 Mon Sep 17 00:00:00 2001 From: SnailClimb Date: Tue, 12 Mar 2019 17:41:20 +0800 Subject: [PATCH 126/232] =?UTF-8?q?Add=20Java8=E6=96=B0=E7=89=B9=E6=80=A7?= =?UTF-8?q?=E6=80=BB=E7=BB=93?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index c8e2bc5ecf1..7f2b0773f43 100644 --- a/README.md +++ b/README.md @@ -95,6 +95,8 @@ ### Java8 New Features +* [Java 8 新特性总结](https://github.com/Snailclimb/JavaGuide/blob/master/Java/What's%20New%20in%20JDK8/Java8Tutorial.md) + ### 设计模式 * [设计模式系列文章](https://github.com/Snailclimb/Java_Guide/blob/master/Java/设计模式.md) From 16987cfe4ccf9cffea6bf34d8f061febaa45a8d4 Mon Sep 17 00:00:00 2001 From: SnailClimb Date: Tue, 12 Mar 2019 17:44:19 +0800 Subject: [PATCH 127/232] Add category --- Java/What's New in JDK8/Java8Tutorial.md | 83 ++++++++++++++++++------ 1 file changed, 62 insertions(+), 21 deletions(-) diff --git a/Java/What's New in JDK8/Java8Tutorial.md b/Java/What's New in JDK8/Java8Tutorial.md index 86a8750ee8b..3aa3901409c 100644 --- a/Java/What's New in JDK8/Java8Tutorial.md +++ b/Java/What's New in JDK8/Java8Tutorial.md @@ -1,7 +1,48 @@ 随着 Java 8 的普及度越来越高，很多人都提到面试中关于Java 8 也是非常常问的知识点。应各位要求和需要，我打算对这部分知识做一个总结。本来准备自己总结的，后面看到Github 上有一个相关的仓库，地址： [https://github.com/winterbe/java8-tutorial](https://github.com/winterbe/java8-tutorial)。这个仓库是英文的，我对其进行了翻译并添加和修改了部分内容，下面是正文了。 -# Java 8 + + +- [Java 8 Tutorial](#java-8-tutorial) + - [接口的默认方法\(Default Methods for Interfaces\)](#接口的默认方法default-methods-for-interfaces) + - [Lambda表达式\(Lambda expressions\)](#lambda表达式lambda-expressions) + - [函数式接口\(Functional Interfaces\)](#函数式接口functional-interfaces) + - [方法和构造函数引用\(Method and Constructor References\)](#方法和构造函数引用method-and-constructor-references) + - [Lamda 表达式作用域\(Lambda Scopes\)](#lamda-表达式作用域lambda-scopes) + - [访问局部变量](#访问局部变量) + - [访问字段和静态变量](#访问字段和静态变量) + - [访问默认接口方法](#访问默认接口方法) + - [内置函数式接口\(Built-in Functional Interfaces\)](#内置函数式接口built-in-functional-interfaces) + - [Predicates](#predicates) + - [Functions](#functions) + - [Suppliers](#suppliers) + - [Consumers](#consumers) + - [Comparators](#comparators) + - [Optionals](#optionals) + - [Streams\(流\)](#streams流) + - [Filter\(过滤\)](#filter过滤) + - [Sorted\(排序\)](#sorted排序) + - [Map\(映射\)](#map映射) + - [Match\(匹配\)](#match匹配) + - [Count\(计数\)](#count计数) + - [Reduce\(规约\)](#reduce规约) + - [Parallel Streams\(并行流\)](#parallel-streams并行流) + - [Sequential Sort\(串行排序\)](#sequential-sort串行排序) + - [Parallel Sort\(并行排序\)](#parallel-sort并行排序) + - [Maps](#maps) + - [Data API\(日期相关API\)](#data-api日期相关api) + - [Clock](#clock) + - [Timezones\(时区\)](#timezones时区) + - [LocalTime\(本地时间\)](#localtime本地时间) + - [LocalDate\(本地日期\)](#localdate本地日期) + - [LocalDateTime\(本地日期时间\)](#localdatetime本地日期时间) + - [Annotations\(注解\)](#annotations注解) + - [Whete to go from here?](#whete-to-go-from-here) + + + + +# Java 8 Tutorial 欢迎阅读我对Java 8的介绍。本教程将逐步指导您完成所有新语言功能。 在简短的代码示例的基础上，您将学习如何使用默认接口方法，lambda表达式，方法引用和可重复注释。 在本文的最后，您将熟悉最新的 API 更改，如流，函数式接口(Functional Interfaces)，Map 类的扩展和新的 Date API。 没有大段枯燥的文字，只有一堆注释的代码片段。 @@ -29,19 +70,19 @@ Formula 接口中除了抽象方法计算接口公式还定义了默认方法 `s ```java public class Main { - public static void main(String[] args) { - // TODO 通过匿名内部类方式访问接口 - Formula formula = new Formula() { - @Override - public double calculate(int a) { - return sqrt(a * 100); - } - }; + public static void main(String[] args) { + // TODO 通过匿名内部类方式访问接口 + Formula formula = new Formula() { + @Override + public double calculate(int a) { + return sqrt(a * 100); + } + }; - System.out.println(formula.calculate(100)); // 100.0 - System.out.println(formula.sqrt(16)); // 4.0 + System.out.println(formula.calculate(100)); // 100.0 + System.out.println(formula.sqrt(16)); // 4.0 - } + } } ``` @@ -102,15 +143,15 @@ Java 语言设计者们投入了大量精力来思考如何使现有的函数友 ```java @FunctionalInterface public interface Converter { - T convert(F from); + T convert(F from); } ``` ```java - // TODO 将数字字符串转换为整数类型 - Converter converter = (from) -> Integer.valueOf(from); - Integer converted = converter.convert("123"); - System.out.println(converted.getClass()); //class java.lang.Integer + // TODO 将数字字符串转换为整数类型 + Converter converter = (from) -> Integer.valueOf(from); + Integer converted = converter.convert("123"); + System.out.println(converted.getClass()); //class java.lang.Integer ``` **译者注：**大部分函数式接口都不用我们自己写，Java8都给我们实现好了，这些接口都在java.util.function包里。 @@ -120,9 +161,9 @@ public interface Converter { 前一节中的代码还可以通过静态方法引用来表示： ```java - Converter converter = Integer::valueOf; - Integer converted = converter.convert("123"); - System.out.println(converted.getClass()); //class java.lang.Integer + Converter converter = Integer::valueOf; + Integer converted = converter.convert("123"); + System.out.println(converted.getClass()); //class java.lang.Integer ``` Java 8允许您通过`::`关键字传递方法或构造函数的引用。 上面的示例显示了如何引用静态方法。 但我们也可以引用对象方法： @@ -755,7 +796,7 @@ System.out.println("今天是周几:"+dayOfWeek);//TUESDAY 从字符串解析一个 LocalDate 类型和解析 LocalTime 一样简单,下面是使用 `DateTimeFormatter` 解析字符串的例子： ```java - String str1 = "2014==04==12 01时06分09秒"; + String str1 = "2014==04==12 01时06分09秒"; // 根据需要解析的日期、时间字符串定义解析所用的格式器 DateTimeFormatter fomatter1 = DateTimeFormatter .ofPattern("yyyy==MM==dd HH时mm分ss秒"); From 5e796c129c97f489a7fe66abca1973813dbf8806 Mon Sep 17 00:00:00 2001 From: SnailClimb Date: Tue, 12 Mar 2019 19:07:17 +0800 Subject: [PATCH 128/232] Update Java8Tutorial.md --- Java/What's New in JDK8/Java8Tutorial.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/Java/What's New in JDK8/Java8Tutorial.md b/Java/What's New in JDK8/Java8Tutorial.md index 3aa3901409c..4dd12ecf063 100644 --- a/Java/What's New in JDK8/Java8Tutorial.md +++ b/Java/What's New in JDK8/Java8Tutorial.md @@ -132,7 +132,7 @@ List 类本身就有一个 `sort` 方法。并且Java编译器可以自动推导 ### 函数式接口(Functional Interfaces) -**译者注：**原文对这部分解释不太清楚，故做了修改！ +**译者注：** 原文对这部分解释不太清楚，故做了修改！ Java 语言设计者们投入了大量精力来思考如何使现有的函数友好地支持Lambda。最终采取的方法是：增加函数式接口的概念。**“函数式接口”是指仅仅只包含一个抽象方法,但是可以有多个非抽象方法(也就是上面提到的默认方法)的接口。** 像这样的接口，可以被隐式转换为lambda表达式。`java.lang.Runnable` 与 `java.util.concurrent.Callable` 是函数式接口最典型的两个例子。Java 8增加了一种特殊的注解`@FunctionalInterface`,但是这个注解通常不是必须的(某些情况建议使用)，只要接口只包含一个抽象方法，虚拟机会自动判断该接口为函数式接口。一般建议在接口上使用`@FunctionalInterface` 注解进行声明，这样的话，编译器如果发现你标注了这个注解的接口有多于一个抽象方法的时候会报错的，如下图所示 @@ -154,7 +154,7 @@ public interface Converter { System.out.println(converted.getClass()); //class java.lang.Integer ``` -**译者注：**大部分函数式接口都不用我们自己写，Java8都给我们实现好了，这些接口都在java.util.function包里。 +**译者注：** 大部分函数式接口都不用我们自己写，Java8都给我们实现好了，这些接口都在java.util.function包里。 ### 方法和构造函数引用(Method and Constructor References) @@ -289,7 +289,7 @@ JDK 1.8 API包含许多内置函数式接口。 其中一些借口在老版本 Predicate 接口是只有一个参数的返回布尔类型值的 **断言型** 接口。该接口包含多种默认方法来将 Predicate 组合成其他复杂的逻辑（比如：与，或，非）： -**译者注：**Predicate 接口源码如下 +**译者注：** Predicate 接口源码如下 ```java package java.util.function; @@ -342,7 +342,7 @@ Predicate isNotEmpty = isEmpty.negate(); Function 接口接受一个参数并生成结果。默认方法可用于将多个函数链接在一起（compose, andThen）： -**译者注：**Function 接口源码如下 +**译者注：** Function 接口源码如下 ```java From 2d8be9a186ef989943fe482346ab8dd6acfad136 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=9D=B3=E9=98=B3?= <260893248@qq.com> Date: Tue, 12 Mar 2019 20:01:35 +0800 Subject: [PATCH 129/232] =?UTF-8?q?=E7=9C=8B=E8=B5=B7=E6=9D=A5=E5=83=8F?= =?UTF-8?q?=E6=98=AF=E6=8B=BC=E5=86=99=E9=94=99=E8=AF=AF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 看起来像是拼写错误 --- ...\247\201\351\227\256\351\242\230\346\200\273\347\273\223.md" | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git "a/EssentialContentForInterview/PreparingForInterview/\347\276\216\345\233\242\351\235\242\350\257\225\345\270\270\350\247\201\351\227\256\351\242\230\346\200\273\347\273\223.md" "b/EssentialContentForInterview/PreparingForInterview/\347\276\216\345\233\242\351\235\242\350\257\225\345\270\270\350\247\201\351\227\256\351\242\230\346\200\273\347\273\223.md" index 422d9402f12..0efdd618688 100644 --- "a/EssentialContentForInterview/PreparingForInterview/\347\276\216\345\233\242\351\235\242\350\257\225\345\270\270\350\247\201\351\227\256\351\242\230\346\200\273\347\273\223.md" +++ "b/EssentialContentForInterview/PreparingForInterview/\347\276\216\345\233\242\351\235\242\350\257\225\345\270\270\350\247\201\351\227\256\351\242\230\346\200\273\347\273\223.md" @@ -238,7 +238,7 @@ HTTP响应报文主要由状态行、响应头部、响应正文3部分组成 1. 避免 where 子句中对字段施加函数，这会造成无法命中索引。 2. 在使用InnoDB时使用与业务无关的自增主键作为主键，即使用逻辑主键，而不要使用业务主键。 3. 将打算加索引的列设置为 NOT NULL ，否则将导致引擎放弃使用索引而进行全表扫描 -4. 删除长期未使用的索引，不用的索引的存在会造成不必要的性能损耗 MySQL 5.7 可以通过查询 sys 库的 chema_unused_indexes 视图来查询哪些索引从未被使用 +4. 删除长期未使用的索引，不用的索引的存在会造成不必要的性能损耗 MySQL 5.7 可以通过查询 sys 库的 schema_unused_indexes 视图来查询哪些索引从未被使用 5. 在使用 limit offset 查询缓慢时，可以借助索引来提高性能 **Mysql索引主要使用的哪两种数据结构？** From 5fd6855a0ee82c39a723828a23ffd5e30652c4cc Mon Sep 17 00:00:00 2001 From: SnailClimb Date: Tue, 12 Mar 2019 21:36:59 +0800 Subject: [PATCH 130/232] Add a contributor --- README.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/README.md b/README.md index 7f2b0773f43..65162db7d38 100644 --- a/README.md +++ b/README.md @@ -260,6 +260,9 @@ + + + ### 公众号 From 46901e584de16f70bf6aeba5fc41961680d313af Mon Sep 17 00:00:00 2001 From: haiqiang <43314997+Goose9527@users.noreply.github.com> Date: Tue, 12 Mar 2019 23:39:38 +0800 Subject: [PATCH 131/232] Update README.md MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 在README.md添加部分特性总结 - 在README.md维护链接，本页面内跳转 --- Java/What's New in JDK8/README.md | 550 +++++++++++++++++++++++++++++- 1 file changed, 541 insertions(+), 9 deletions(-) diff --git a/Java/What's New in JDK8/README.md b/Java/What's New in JDK8/README.md index b7612fa4183..fa71e907410 100644 --- a/Java/What's New in JDK8/README.md +++ b/Java/What's New in JDK8/README.md @@ -3,22 +3,554 @@ JDK8新特性总结 总结了部分JDK8新特性，另外一些新特性可以通过Oracle的官方文档查看，毕竟是官方文档，各种新特性都会介绍，有兴趣的可以去看。
[Oracle官方文档:What's New in JDK8](https://www.oracle.com/technetwork/java/javase/8-whats-new-2157071.html) ----- -- [Java语言特性]() +- [Java语言特性](#JavaProgrammingLanguage) - [Lambda表达式是一个新的语言特性，已经在JDK8中加入。它是一个可以传递的代码块，你也可以把它们当做方法参数。 - Lambda表达式允许您更紧凑地创建单虚方法接口（称为功能接口）的实例。](https://github.com/Goose9527/JavaGuide/blob/master/Java%E7%9B%B8%E5%85%B3/What's%20New%20in%20JDK8/Lambda%E8%A1%A8%E8%BE%BE%E5%BC%8F.md) + Lambda表达式允许您更紧凑地创建单虚方法接口（称为功能接口）的实例。](#LambdaExpressions) - - [方法引用为已经存在的具名方法提供易于阅读的Lambda表达式]() + - [方法引用为已经存在的具名方法提供易于阅读的Lambda表达式](#MethodReferences) - - [默认方法允许将新功能添加到库的接口，并确保与为这些接口的旧版本编写的代码的二进制兼容性。]() + - [默认方法允许将新功能添加到库的接口，并确保与为这些接口的旧版本编写的代码的二进制兼容性。](#DefaultMethods) - - [改进的类型推断。]() + - [改进的类型推断。](#ImprovedTypeInference) - - [方法参数反射。]() + - [方法参数反射(通过反射获得方法参数信息)](#MethodParameterReflection) -- [流(stream)]() +- [流(stream)](#stream) - [新java.util.stream包中的类提供Stream API以支持对元素流的功能样式操作。流(stream)和I/O里的流不是同一个概念 ，使用stream API可以更方便的操作集合。]() - [国际化]() - - 代办 -- 代办 + - 待办 +- 待办 +___ + + + + + + + +## 　　　　　　　　　　　　　Lambda表达式 +### 1.什么是Lambda表达式 +**Lambda表达式实质上是一个可传递的代码块，Lambda又称为闭包或者匿名函数，是函数式编程语法，让方法可以像普通参数一样传递** + +### 2.Lambda表达式语法 +```(参数列表) -> {执行代码块}``` +
参数列表可以为空```()->{}``` +
可以加类型声明比如```(String para1, int para2) -> {return para1 + para2;}```我们可以看到，lambda同样可以有返回值. +
在编译器可以推断出类型的时候，可以将类型声明省略，比如```(para1, para2) -> {return para1 + para2;}``` +
(lambda有点像动态类型语言语法。lambda在字节码层面是用invokedynamic实现的，而这条指令就是为了让JVM更好的支持运行在其上的动态类型语言) + +### 3.函数式接口 +在了解Lambda表达式之前，有必要先了解什么是函数式接口```(@FunctionalInterface)```
+**函数式接口指的是有且只有一个抽象(abstract)方法的接口**
+当需要一个函数式接口的对象时，就可以用Lambda表达式来实现，举个常用的例子: +
+```java + Thread thread = new Thread(() -> { + System.out.println("This is JDK8's Lambda!"); + }); +``` +这段代码和函数式接口有啥关系？我们回忆一下，Thread类的构造函数里是不是有一个以Runnable接口为参数的？ +```java +public Thread(Runnable target) {...} + +/** + * Runnable Interface + */ +@FunctionalInterface +public interface Runnable { + public abstract void run(); +} +``` +到这里大家可能已经明白了，**Lambda表达式相当于一个匿名类或者说是一个匿名方法**。上面Thread的例子相当于 +```java + Thread thread = new Thread(new Runnable() { + @Override + public void run() { + System.out.println("Anonymous class"); + } + }); +``` +也就是说，上面的lambda表达式相当于实现了这个run()方法，然后当做参数传入(个人感觉可以这么理解,lambda表达式就是一个函数，只不过它的返回值、参数列表都 +由编译器帮我们推断，因此可以减少很多代码量)。 +
Lambda也可以这样用 : +```java + Runnable runnable = () -> {...}; +``` +其实这和上面的用法没有什么本质上的区别。 +
至此大家应该明白什么是函数式接口以及函数式接口和lambda表达式之间的关系了。在JDK8中修改了接口的规范， +目的是为了在给接口添加新的功能时保持向前兼容(个人理解)，比如一个已经定义了的函数式接口，某天我们想给它添加新功能，那么就不能保持向前兼容了， +因为在旧的接口规范下，添加新功能必定会破坏这个函数式接口[(JDK8中接口规范)]() +
+除了上面说的Runnable接口之外，JDK中已经存在了很多函数式接口 +比如(当然不止这些): +- ```java.util.concurrent.Callable``` +- ```java.util.Comparator``` +- ```java.io.FileFilter``` +
**关于JDK中的预定义的函数式接口** + +- JDK在```java.util.function```下预定义了很多函数式接口 + - ```Function {R apply(T t);}``` 接受一个T对象，然后返回一个R对象，就像普通的函数。 + - ```Consumer {void accept(T t);}``` 消费者 接受一个T对象，没有返回值。 + - ```Predicate {boolean test(T t);}``` 判断，接受一个T对象，返回一个布尔值。 + - ```Supplier {T get();} 提供者(工厂)``` 返回一个T对象。 + - 其他的跟上面的相似，大家可以看一下function包下的具体接口。 +### 4.变量作用域 +```java +public class VaraibleHide { + @FunctionalInterface + interface IInner { + void printInt(int x); + } + public static void main(String[] args) { + int x = 20; + IInner inner = new IInner() { + int x = 10; + @Override + public void printInt(int x) { + System.out.println(x); + } + }; + inner.printInt(30); + + inner = (s) -> { + //Variable used in lambda expression should be final or effectively final + //!int x = 10; + //!x= 50; error + System.out.print(x); + }; + inner.printInt(30); + } +} +输出 : +30 +20 +``` +对于lambda表达式```java inner = (s) -> {System.out.print(x);};```,变量x并不是在lambda表达式中定义的，像这样并不是在lambda中定义或者通过lambda +的参数列表()获取的变量成为自由变量，它是被lambda表达式捕获的。 +
lambda表达式和内部类一样，对外部自由变量捕获时，外部自由变量必须为final或者是最终变量(effectively final)的，也就是说这个变量初始化后就不能为它赋新值，同时lambda不像内部类/匿名类，lambda表达式与外围嵌套块有着相同的作用域，因此对变量命名的有关规则对lambda同样适用。大家阅读上面的代码对这些概念应该不难理解。 + +### 5.方法引用 +**只需要提供方法的名字，具体的调用过程由Lambda和函数式接口来确定，这样的方法调用成为方法引用。** +
下面的例子会打印list中的每个元素: +```java +List list = new ArrayList<>(); + for (int i = 0; i < 10; ++i) { + list.add(i); + } + list.forEach(System.out::println); +``` +其中```System.out::println```这个就是一个方法引用，等价于Lambda表达式 ```(para)->{System.out.println(para);}``` +
我们看一下List#forEach方法 ```default void forEach(Consumer action)```可以看到它的参数是一个Consumer接口，该接口是一个函数式接口 +```java +@FunctionalInterface +public interface Consumer { + void accept(T t); +``` +大家能发现这个函数接口的方法和```System.out::println```有什么相似的么？没错，它们有着相似的参数列表和返回值。 +
我们自己定义一个方法，看看能不能像标准输出的打印函数一样被调用 +```java +public class MethodReference { + public static void main(String[] args) { + List list = new ArrayList<>(); + for (int i = 0; i < 10; ++i) { + list.add(i); + } + list.forEach(MethodReference::myPrint); + } + + static void myPrint(int i) { + System.out.print(i + ", "); + } +} + +输出: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, +``` +可以看到，我们自己定义的方法也可以当做方法引用。 +
到这里大家多少对方法引用有了一定的了解，我们再来说一下方法引用的形式。 +- 方法引用 + - 类名::静态方法名 + - 类名::实例方法名 + - 类名::new (构造方法引用) + - 实例名::实例方法名 +可以看出，方法引用是通过(方法归属名)::(方法名)来调用的。通过上面的例子已经讲解了一个`类名::静态方法名`的使用方法了，下面再依次介绍其余的几种 +方法引用的使用方法。
+**类名::实例方法名**
+先来看一段代码 +```java + String[] strings = new String[10]; + Arrays.sort(strings, String::compareToIgnoreCase); +``` +**上面的String::compareToIgnoreCase等价于(x, y) -> {return x.compareToIgnoreCase(y);}**
+我们看一下`Arrays#sort`方法`public static void sort(T[] a, Comparator c)`, +可以看到第二个参数是一个Comparator接口，该接口也是一个函数式接口，其中的抽象方法是`int compare(T o1, T o2);`，再看一下 +`String#compareToIgnoreCase`方法,`public int compareToIgnoreCase(String str)`，这个方法好像和上面讲方法引用中`类名::静态方法名`不大一样啊，它 +的参数列表和函数式接口的参数列表不一样啊，虽然它的返回值一样？ +
是的，确实不一样但是别忘了，String类的这个方法是个实例方法，而不是静态方法，也就是说，这个方法是需要有一个接收者的。所谓接收者就是 +instance.method(x)中的instance， +它是某个类的实例，有的朋友可能已经明白了。上面函数式接口的`compare(T o1, T o2)`中的第一个参数作为了实例方法的接收者，而第二个参数作为了实例方法的 +参数。我们再举一个自己实现的例子: +```java +public class MethodReference { + static Random random = new Random(47); + public static void main(String[] args) { + MethodReference[] methodReferences = new MethodReference[10]; + Arrays.sort(methodReferences, MethodReference::myCompare); + } + int myCompare(MethodReference o) { + return random.nextInt(2) - 1; + } +} +``` +上面的例子可以在IDE里通过编译，大家有兴趣的可以模仿上面的例子自己写一个程序，打印出排序后的结果。 +
**构造器引用**
+构造器引用仍然需要与特定的函数式接口配合使用，并不能像下面这样直接使用。IDE会提示String不是一个函数式接口 +```java + //compile error : String is not a functional interface + String str = String::new; +``` +下面是一个使用构造器引用的例子，可以看出构造器引用可以和这种工厂型的函数式接口一起使用的。 +```java + interface IFunctional { + T func(); +} + +public class ConstructorReference { + + public ConstructorReference() { + } + + public static void main(String[] args) { + Supplier supplier0 = () -> new ConstructorReference(); + Supplier supplier1 = ConstructorReference::new; + IFunctional functional = () -> new ConstructorReference(); + IFunctional functional1 = ConstructorReference::new; + } +} +``` +下面是一个JDK官方的例子 +```java + public static , DEST extends Collection> + DEST transferElements( + SOURCE sourceCollection, + Supplier collectionFactory) { + + DEST result = collectionFactory.get(); + for (T t : sourceCollection) { + result.add(t); + } + return result; + } + + ... + + Set rosterSet = transferElements( + roster, HashSet::new); +``` + +**实例::实例方法** +
+其实开始那个例子就是一个实例::实例方法的引用 +```java +List list = new ArrayList<>(); + for (int i = 0; i < 10; ++i) { + list.add(i); + } + list.forEach(System.out::println); +``` +其中System.out就是一个实例，println是一个实例方法。相信不用再给大家做解释了。 +### 总结 +Lambda表达式是JDK8引入Java的函数式编程语法，使用Lambda需要直接或者间接的与函数式接口配合，在开发中使用Lambda可以减少代码量， +但是并不是说必须要使用Lambda(虽然它是一个很酷的东西)。有些情况下使用Lambda会使代码的可读性急剧下降，并且也节省不了多少代码， +所以在实际开发中还是需要仔细斟酌是否要使用Lambda。和Lambda相似的还有JDK10中加入的var类型推断，同样对于这个特性需要斟酌使用。 + + +___ + + +## 　　　　　　　　　　　　　JDK8接口规范 +### 在JDK8中引入了lambda表达式，出现了函数式接口的概念，为了在扩展接口时保持向前兼容性(JDK8之前扩展接口会使得实现了该接口的类必须实现添加的方法，否则会报错。为了保持兼容性而做出妥协的特性还有泛型，泛型也是为了保持兼容性而失去了在一些别的语言泛型拥有的功能)，Java接口规范发生了一些改变。 +### 1.JDK8以前的接口规范 +- JDK8以前接口可以定义的变量和方法 + - 所有变量(Field)不论是否显式 的声明为```public static final```，它实际上都是```public static final```的。 + - 所有方法(Method)不论是否显示 的声明为```public abstract```，它实际上都是```public abstract```的。 +```java +public interface AInterfaceBeforeJDK8 { + int FIELD = 0; + void simpleMethod(); +} +``` +以上接口信息反编译以后可以看到字节码信息里Filed是public static final的，而方法是public abstract的，即是你没有显示的去声明它。 +```java +{ + public static final int FIELD; + descriptor: I + flags: (0x0019) ACC_PUBLIC, ACC_STATIC, ACC_FINAL + ConstantValue: int 0 + + public abstract void simpleMethod(); + descriptor: ()V + flags: (0x0401) ACC_PUBLIC, ACC_ABSTRACT +} +``` +### 2.JDK8之后的接口规范 +- JDK8之后接口可以定义的变量和方法 + - 变量(Field)仍然必须是 ```java public static final```的 + - 方法(Method)除了可以是public abstract之外，还可以是public static或者是default(相当于仅public修饰的实例方法)的。 +从以上改变不难看出，修改接口的规范主要是为了能在扩展接口时保持向前兼容。 +
下面是一个JDK8之后的接口例子 +```java +public interface AInterfaceInJDK8 { + int simpleFiled = 0; + static int staticField = 1; + + public static void main(String[] args) { + } + static void staticMethod(){} + + default void defaultMethod(){} + + void simpleMethod() throws IOException; + +} +``` +进行反编译(去除了一些没用信息) +```java +{ + public static final int simpleFiled; + flags: (0x0019) ACC_PUBLIC, ACC_STATIC, ACC_FINAL + + public static final int staticField; + flags: (0x0019) ACC_PUBLIC, ACC_STATIC, ACC_FINAL + + public static void main(java.lang.String[]); + flags: (0x0009) ACC_PUBLIC, ACC_STATIC + + public static void staticMethod(); + flags: (0x0009) ACC_PUBLIC, ACC_STATIC + + public void defaultMethod(); + flags: (0x0001) ACC_PUBLIC + + public abstract void simpleMethod() throws java.io.IOException; + flags: (0x0401) ACC_PUBLIC, ACC_ABSTRACT + Exceptions: + throws java.io.IOException +} +``` +可以看到 default关键字修饰的方法是像实例方法(就是普通类中定义的普通方法)一样定义的，所以我们来定义一个只有default方法的接口并且实现一下这个接口试一 +试。 +```java +interface Default { + default int defaultMethod() { + return 4396; + } +} + +public class DefaultMethod implements Default { + public static void main(String[] args) { + DefaultMethod defaultMethod = new DefaultMethod(); + System.out.println(defaultMethod.defaultMethod()); + //compile error : Non-static method 'defaultMethod()' cannot be referenced from a static context + //! DefaultMethod.defaultMethod(); + } +} +``` +可以看到default方法确实像实例方法一样，必须有实例对象才能调用，并且子类在实现接口时，可以不用实现default方法，也可以选择覆盖该方法。 +这有点像子类继承父类实例方法。 +
+接口静态方法就像是类静态方法，唯一的区别是**接口静态方法只能通过接口名调用，而类静态方法既可以通过类名调用也可以通过实例调用** +```java +interface Static { + static int staticMethod() { + return 4396; + } +} + ... main(String...args) + //!compile error: Static method may be invoked on containing interface class only + //!aInstanceOfStatic.staticMethod(); + ... +``` +另一个问题是多继承问题，大家知道Java中类是不支持多继承的，但是接口是多继承和多实现(implements后跟多个接口)的， +那么如果一个接口继承另一个接口，两个接口都有同名的default方法会怎么样呢？答案是会像类继承一样覆写(@Override)，以下代码在IDE中可以顺利编译 +```java +interface Default { + default int defaultMethod() { + return 4396; + } +} +interface Default2 extends Default { + @Override + default int defaultMethod() { + return 9527; + } +} +public class DefaultMethod implements Default,Default2 { + public static void main(String[] args) { + DefaultMethod defaultMethod = new DefaultMethod(); + System.out.println(defaultMethod.defaultMethod()); + } +} + +输出 : 9527 +``` +出现上面的情况时，会优先找继承树上近的方法，类似于“短路优先”。 +
+那么如果一个类实现了两个没有继承关系的接口，且这两个接口有同名方法的话会怎么样呢？IDE会要求你重写这个冲突的方法，让你自己选择去执行哪个方法，因为IDE它还没智能到你不告诉它，它就知道你想执行哪个方法。可以通过```java 接口名.super```指针来访问接口中定义的实例(default)方法。 +```java +interface Default { + default int defaultMethod() { + return 4396; + } +} + +interface Default2 { + default int defaultMethod() { + return 9527; + } +} +//如果不重写 +//compile error : defaults.DefaultMethod inherits unrelated defaults for defaultMethod() from types defaults.Default and defaults.Default2 +public class DefaultMethod implements Default,Default2 { +@Override + public int defaultMethod() { + System.out.println(Default.super.defaultMethod()); + System.out.println(Default2.super.defaultMethod()); + return 996; + } + public static void main(String[] args) { + DefaultMethod defaultMethod = new DefaultMethod(); + System.out.println(defaultMethod.defaultMethod()); + } +} + +运行输出 : +4396 +9527 +996 +``` + + +___ + + +## 　　　　　　　　　　　　　改进的类型推断 +### 1.什么是类型推断 +类型推断就像它的字面意思一样，编译器根据你显示声明的已知的信息 推断出你没有显示声明的类型，这就是类型推断。 +看过《Java编程思想 第四版》的朋友可能还记得里面讲解泛型一章的时候，里面很多例子是下面这样的: +```java + Map map = new Map(); +``` +而我们平常写的都是这样的: +```java + Map map = new Map<>(); +``` +这就是类型推断，《Java编程思想 第四版》这本书出书的时候最新的JDK只有1.6(JDK7推出的类型推断)，在Java编程思想里Bruce Eckel大叔还提到过这个问题 +(可能JDK的官方人员看了Bruce Eckel大叔的Thinking in Java才加的类型推断，☺)，在JDK7中推出了上面这样的类型推断，可以减少一些无用的代码。 +(Java编程思想到现在还只有第四版，是不是因为Bruce Eckel大叔觉得Java新推出的语言特性“然并卵”呢？/滑稽) +
+在JDK7中，类型推断只有上面例子的那样的能力，即只有在使用**赋值语句**时才能自动推断出泛型参数信息(即<>里的信息)，下面的官方文档里的例子在JDK7里会编译 +错误 +```java + List stringList = new ArrayList<>(); + stringList.add("A"); + //error : addAll(java.util.Collection)in List cannot be applied to (java.util.List) + stringList.addAll(Arrays.asList()); +``` +但是上面的代码在JDK8里可以通过，也就说，JDK8里，类型推断不仅可以用于赋值语句，而且可以根据代码中上下文里的信息推断出更多的信息，因此我们需要些的代码 +会更少。加强的类型推断还有一个就是用于Lambda表达式了。 +
+大家其实不必细究类型推断，在日常使用中IDE会自动判断，当IDE自己无法推断出足够的信息时，就需要我们额外做一下工作，比如在<>里添加更多的类型信息， +相信随着Java的进化，这些便利的功能会越来越强大。 + + +____ + + +## 　　　　　　　　　　　　　通过反射获得方法的参数信息 +JDK8之前 .class文件是不会存储方法参数信息的，因此也就无法通过反射获取该信息(想想反射获取类信息的入口是什么？当然就是Class类了)。即是是在JDK11里 +也不会默认生成这些信息，可以通过在javac加上-parameters参数来让javac生成这些信息(javac就是java编译器，可以把java文件编译成.class文件)。生成额外 +的信息(运行时非必须信息)会消耗内存并且有可能公布敏感信息(某些方法参数比如password，JDK文档里这么说的)，并且确实很多信息javac并不会为我们生成，比如 +LocalVariableTable，javac就不会默认生成，需要你加上 -g:vars来强制让编译器生成，同样的，方法参数信息也需要加上 +-parameters来让javac为你在.class文件中生成这些信息，否则运行时反射是无法获取到这些信息的。在讲解Java语言层面的方法之前，先看一下javac加上该 +参数和不加生成的信息有什么区别(不感兴趣想直接看运行代码的可以跳过这段)。下面是随便写的一个类。 +```java +public class ByteCodeParameters { + public String simpleMethod(String canUGetMyName, Object yesICan) { + return "9527"; + } +} +``` +先来不加参数编译和反编译一下这个类javac ByteCodeParameters.java , javap -v ByteCodeParameters: +```java + //只截取了部分信息 + public java.lang.String simpleMethod(java.lang.String, java.lang.Object); + descriptor: (Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/String; + flags: (0x0001) ACC_PUBLIC + Code: + stack=1, locals=3, args_size=3 + 0: ldc #2 // String 9527 + 2: areturn + LineNumberTable: + line 5: 0 + //这个方法的描述到这里就结束了 +``` +接下来我们加上参数javac -parameters ByteCodeParameters.java 再来看反编译的信息: +```java + public java.lang.String simpleMethod(java.lang.String, java.lang.Object); + descriptor: (Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/String; + flags: (0x0001) ACC_PUBLIC + Code: + stack=1, locals=3, args_size=3 + 0: ldc #2 // String 9527 + 2: areturn + LineNumberTable: + line 8: 0 + MethodParameters: + Name Flags + canUGetMyName + yesICan +``` +可以看到.class文件里多了一个MethodParameters信息，这就是参数的名字，可以看到默认是不保存的。 +
下面看一下在Intelj Idea里运行的这个例子，我们试一下通过反射获取方法名 : +```java +public class ByteCodeParameters { + public String simpleMethod(String canUGetMyName, Object yesICan) { + return "9527"; + } + + public static void main(String[] args) throws NoSuchMethodException { + Class clazz = ByteCodeParameters.class; + Method simple = clazz.getDeclaredMethod("simpleMethod", String.class, Object.class); + Parameter[] parameters = simple.getParameters(); + for (Parameter p : parameters) { + System.out.println(p.getName()); + } + } +} +输出 : +arg0 +arg1 +``` +？？？说好的方法名呢？？？？别急，哈哈。前面说了，默认是不生成参数名信息的，因此我们需要做一些配置，我们找到IDEA的settings里的Java Compiler选项，在 +Additional command line parameters:一行加上-parameters(Eclipse 也是找到Java Compiler选中Stoer information about method parameters)，或者自 +己编译一个.class文件放在IDEA的out下，然后再来运行 : +```java +输出 : +canUGetMyName +yesICan +``` +这样我们就通过反射获取到参数信息了。想要了解更多的同学可以自己研究一下 [官方文档] +(https://docs.oracle.com/javase/tutorial/reflect/member/methodparameterreflection.html) +
+## 总结与补充 +在JDK8之后，可以通过-parameters参数来让编译器生成参数信息然后在运行时通过反射获取方法参数信息，其实在SpringFramework +里面也有一个LocalVariableTableParameterNameDiscoverer对象可以获取方法参数名信息，有兴趣的同学可以自行百度(这个类在打印日志时可能会比较有用吧，个人感觉)。 + +____ + + + + +___ From dfa077245bae741398de561fba402a024fb12f30 Mon Sep 17 00:00:00 2001 From: haiqiang <43314997+Goose9527@users.noreply.github.com> Date: Tue, 12 Mar 2019 23:42:34 +0800 Subject: [PATCH 132/232] =?UTF-8?q?Create=20=E6=94=B9=E8=BF=9B=E7=9A=84?= =?UTF-8?q?=E7=B1=BB=E5=9E=8B=E6=8E=A8=E6=96=AD.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 与README.md同步 --- ...73\345\236\213\346\216\250\346\226\255.md" | 30 +++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 "Java/What's New in JDK8/\346\224\271\350\277\233\347\232\204\347\261\273\345\236\213\346\216\250\346\226\255.md" diff --git "a/Java/What's New in JDK8/\346\224\271\350\277\233\347\232\204\347\261\273\345\236\213\346\216\250\346\226\255.md" "b/Java/What's New in JDK8/\346\224\271\350\277\233\347\232\204\347\261\273\345\236\213\346\216\250\346\226\255.md" new file mode 100644 index 00000000000..b5cff7bb0c0 --- /dev/null +++ "b/Java/What's New in JDK8/\346\224\271\350\277\233\347\232\204\347\261\273\345\236\213\346\216\250\346\226\255.md" @@ -0,0 +1,30 @@ +## 　　　　　　　　　　　　　改进的类型推断 +### 1.什么是类型推断 +类型推断就像它的字面意思一样，编译器根据你显示声明的已知的信息 推断出你没有显示声明的类型，这就是类型推断。 +看过《Java编程思想 第四版》的朋友可能还记得里面讲解泛型一章的时候，里面很多例子是下面这样的: +```java + Map map = new Map(); +``` +而我们平常写的都是这样的: +```java + Map map = new Map<>(); +``` +这就是类型推断，《Java编程思想 第四版》这本书出书的时候最新的JDK只有1.6(JDK7推出的类型推断)，在Java编程思想里Bruce Eckel大叔还提到过这个问题 +(可能JDK的官方人员看了Bruce Eckel大叔的Thinking in Java才加的类型推断，☺)，在JDK7中推出了上面这样的类型推断，可以减少一些无用的代码。 +(Java编程思想到现在还只有第四版，是不是因为Bruce Eckel大叔觉得Java新推出的语言特性“然并卵”呢？/滑稽) +
+在JDK7中，类型推断只有上面例子的那样的能力，即只有在使用**赋值语句**时才能自动推断出泛型参数信息(即<>里的信息)，下面的官方文档里的例子在JDK7里会编译 +错误 +```java + List stringList = new ArrayList<>(); + stringList.add("A"); + //error : addAll(java.util.Collection)in List cannot be applied to (java.util.List) + stringList.addAll(Arrays.asList()); +``` +但是上面的代码在JDK8里可以通过，也就说，JDK8里，类型推断不仅可以用于赋值语句，而且可以根据代码中上下文里的信息推断出更多的信息，因此我们需要些的代码 +会更少。加强的类型推断还有一个就是用于Lambda表达式了。 +
+大家其实不必细究类型推断，在日常使用中IDE会自动判断，当IDE自己无法推断出足够的信息时，就需要我们额外做一下工作，比如在<>里添加更多的类型信息， +相信随着Java的进化，这些便利的功能会越来越强大。 + + From 954966afc487932dccd0af066492285bb8066279 Mon Sep 17 00:00:00 2001 From: haiqiang <43314997+Goose9527@users.noreply.github.com> Date: Tue, 12 Mar 2019 23:43:39 +0800 Subject: [PATCH 133/232] =?UTF-8?q?Create=20=E9=80=9A=E8=BF=87=E5=8F=8D?= =?UTF-8?q?=E5=B0=84=E8=8E=B7=E5=BE=97=E6=96=B9=E6=B3=95=E7=9A=84=E5=8F=82?= =?UTF-8?q?=E6=95=B0=E4=BF=A1=E6=81=AF.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 与README.md同步 --- ...02\346\225\260\344\277\241\346\201\257.md" | 79 +++++++++++++++++++ 1 file changed, 79 insertions(+) create mode 100644 "Java/What's New in JDK8/\351\200\232\350\277\207\345\217\215\345\260\204\350\216\267\345\276\227\346\226\271\346\263\225\347\232\204\345\217\202\346\225\260\344\277\241\346\201\257.md" diff --git "a/Java/What's New in JDK8/\351\200\232\350\277\207\345\217\215\345\260\204\350\216\267\345\276\227\346\226\271\346\263\225\347\232\204\345\217\202\346\225\260\344\277\241\346\201\257.md" "b/Java/What's New in JDK8/\351\200\232\350\277\207\345\217\215\345\260\204\350\216\267\345\276\227\346\226\271\346\263\225\347\232\204\345\217\202\346\225\260\344\277\241\346\201\257.md" new file mode 100644 index 00000000000..a1d91c4b2fe --- /dev/null +++ "b/Java/What's New in JDK8/\351\200\232\350\277\207\345\217\215\345\260\204\350\216\267\345\276\227\346\226\271\346\263\225\347\232\204\345\217\202\346\225\260\344\277\241\346\201\257.md" @@ -0,0 +1,79 @@ +## 　　　　　　　　　　　　　通过反射获得方法的参数信息 +JDK8之前 .class文件是不会存储方法参数信息的，因此也就无法通过反射获取该信息(想想反射获取类信息的入口是什么？当然就是Class类了)。即是是在JDK11里 +也不会默认生成这些信息，可以通过在javac加上-parameters参数来让javac生成这些信息(javac就是java编译器，可以把java文件编译成.class文件)。生成额外 +的信息(运行时非必须信息)会消耗内存并且有可能公布敏感信息(某些方法参数比如password，JDK文档里这么说的)，并且确实很多信息javac并不会为我们生成，比如 +LocalVariableTable，javac就不会默认生成，需要你加上 -g:vars来强制让编译器生成，同样的，方法参数信息也需要加上 +-parameters来让javac为你在.class文件中生成这些信息，否则运行时反射是无法获取到这些信息的。在讲解Java语言层面的方法之前，先看一下javac加上该 +参数和不加生成的信息有什么区别(不感兴趣想直接看运行代码的可以跳过这段)。下面是随便写的一个类。 +```java +public class ByteCodeParameters { + public String simpleMethod(String canUGetMyName, Object yesICan) { + return "9527"; + } +} +``` +先来不加参数编译和反编译一下这个类javac ByteCodeParameters.java , javap -v ByteCodeParameters: +```java + //只截取了部分信息 + public java.lang.String simpleMethod(java.lang.String, java.lang.Object); + descriptor: (Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/String; + flags: (0x0001) ACC_PUBLIC + Code: + stack=1, locals=3, args_size=3 + 0: ldc #2 // String 9527 + 2: areturn + LineNumberTable: + line 5: 0 + //这个方法的描述到这里就结束了 +``` +接下来我们加上参数javac -parameters ByteCodeParameters.java 再来看反编译的信息: +```java + public java.lang.String simpleMethod(java.lang.String, java.lang.Object); + descriptor: (Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/String; + flags: (0x0001) ACC_PUBLIC + Code: + stack=1, locals=3, args_size=3 + 0: ldc #2 // String 9527 + 2: areturn + LineNumberTable: + line 8: 0 + MethodParameters: + Name Flags + canUGetMyName + yesICan +``` +可以看到.class文件里多了一个MethodParameters信息，这就是参数的名字，可以看到默认是不保存的。 +
下面看一下在Intelj Idea里运行的这个例子，我们试一下通过反射获取方法名 : +```java +public class ByteCodeParameters { + public String simpleMethod(String canUGetMyName, Object yesICan) { + return "9527"; + } + + public static void main(String[] args) throws NoSuchMethodException { + Class clazz = ByteCodeParameters.class; + Method simple = clazz.getDeclaredMethod("simpleMethod", String.class, Object.class); + Parameter[] parameters = simple.getParameters(); + for (Parameter p : parameters) { + System.out.println(p.getName()); + } + } +} +输出 : +arg0 +arg1 +``` +？？？说好的方法名呢？？？？别急，哈哈。前面说了，默认是不生成参数名信息的，因此我们需要做一些配置，我们找到IDEA的settings里的Java Compiler选项，在 +Additional command line parameters:一行加上-parameters(Eclipse 也是找到Java Compiler选中Stoer information about method parameters)，或者自 +己编译一个.class文件放在IDEA的out下，然后再来运行 : +```java +输出 : +canUGetMyName +yesICan +``` +这样我们就通过反射获取到参数信息了。想要了解更多的同学可以自己研究一下 [官方文档] +(https://docs.oracle.com/javase/tutorial/reflect/member/methodparameterreflection.html) +
+## 总结与补充 +在JDK8之后，可以通过-parameters参数来让编译器生成参数信息然后在运行时通过反射获取方法参数信息，其实在SpringFramework +里面也有一个LocalVariableTableParameterNameDiscoverer对象可以获取方法参数名信息，有兴趣的同学可以自行百度(这个类在打印日志时可能会比较有用吧，个人感觉)。 From 27b4a0e0c10564bc7642a71862ac9e15c96a5155 Mon Sep 17 00:00:00 2001 From: SnailClimb Date: Wed, 13 Mar 2019 11:03:26 +0800 Subject: [PATCH 134/232] Add SpecialSponsors --- README.md | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/README.md b/README.md index 65162db7d38..2088aa851c5 100644 --- a/README.md +++ b/README.md @@ -5,6 +5,14 @@