java8新特性高频面试题总结（附答案）


目录

1.介绍

2.Java语言新特性


2.1 Lambda表达式

2.2 接口的默认方法与静态方法 

2.3 方法引用

2.4 重复注解

2.5 更好的类型推测机制

2.6 扩展注解的支持

3. Java编译器的新特性


3.1 参数名字


4. Java 类库的新特性


4.1 Optional

4.2 Stream

4.3 Date/Time API (JSR 310)

4.4 JavaScript引擎Nashorn

4.5 Base64

4.6 并行（parallel）数组

4.7 并发（Concurrency）

5. 新的Java工具


5.1 Nashorn引擎: jjs

5.2 类依赖分析器jdeps

6. Java虚拟机（JVM）的新特性


7. 总结

详细解析

1.介绍

毫无疑问，Java 8发行版是自Java 5（发行于2004，已经过了相当一段时间了）以来最具革命性的版本。Java 8 为Java语言、编译器、类库、开发工具与JVM（Java虚拟机）带来了大量新特性。在这篇教程中，我们将一一探索这些变化，并用真实的例子说明它们适用的场景。

这篇教程由以下几部分组成，它们分别涉及到Java平台某一特定方面的内容：

Java语言
编译器
类库
工具
Java运行时（JVM）

2.Java语言新特性

2.1 Lambda表达式

Lambda表达式（也称为闭包）是整个Java 8发行版中最受期待的在Java语言层面上的改变，Lambda允许把函数作为一个方法的参数（函数作为参数传递进方法中），或者把代码看成数据：函数式程序员对这一概念非常熟悉。在JVM平台上的很多语言（Groovy，Scala，……）从一开始就有Lambda，但是Java程序员不得不使用毫无新意的匿名类来代替lambda。

关于Lambda设计的讨论占用了大量的时间与社区的努力。可喜的是，最终找到了一个平衡点，使得可以使用一种即简洁又紧凑的新方式来构造Lambdas。在最简单的形式中，一个lambda可以由用逗号分隔的参数列表、–>符号与函数体三部分表示。例如： 

Arrays.asList( "a", "b", "d" ).forEach( e -> System.out.println( e ) );


请注意参数e的类型是由编译器推测出来的。同时，你也可以通过把参数类型与参数包括在括号中的形式直接给出参数的类型： 

Arrays.asList( "a", "b", "d" ).forEach( ( String e ) -> System.out.println( e ) );

在某些情况下lambda的函数体会更加复杂，这时可以把函数体放到在一对花括号中，就像在Java中定义普通函数一样。例如： 

		
    
			
			
  1. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						Arrays.asList( "a", "b", "d" ).forEach( e -> {
					
    

				
    

			

			
  2. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    System.out.print( e );
					
    

				
    

			

			
  3. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    System.out.print( e );
					
    

				
    

			

			
  4. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						} );


Lambda可以引用类的成员变量与局部变量（如果这些变量不是final的话，它们会被隐含的转为final，这样效率更高）。例如，下面两个代码片段是等价的： 

		
    
			
			
  1. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						String separator = ",";
					
    

				
    

			

			
  2. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						Arrays.asList( "a", "b", "d" ).forEach( 
					
    

				
    

			

			
  3. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    ( String e ) -> System.out.print( e + separator ) );


和： 

		
    
			
			
  1. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						final String separator = ",";
					
    

				
    

			

			
  2. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						Arrays.asList( "a", "b", "d" ).forEach( 
					
    

				
    

			

			
  3. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    ( String e ) -> System.out.print( e + separator ) );
					
    

				
    

			

			
  4.

Lambda可能会返回一个值。返回值的类型也是由编译器推测出来的。如果lambda的函数体只有一行的话，那么没有必要显式使用return语句。下面两个代码片段是等价的： 

Arrays.asList( "a", "b", "d" ).sort( ( e1, e2 ) -> e1.compareTo( e2 ) );


和： 

		
    
			
			
  1. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						Arrays.asList( "a", "b", "d" ).sort( ( e1, e2 ) -> {
					
    

				
    

			

			
  2. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    int result = e1.compareTo( e2 );
					
    

				
    

			

			
  3. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    return result;
					
    

				
    

			

			
  4. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						} );


语言设计者投入了大量精力来思考如何使现有的函数友好地支持lambda。最终采取的方法是：增加函数式接口的概念。函数式接口就是一个具有一个方法的普通接口。像这样的接口，可以被隐式转换为lambda表达式。java.lang.Runnable与java.util.concurrent.Callable是函数式接口最典型的两个例子。在实际使用过程中，函数式接口是容易出错的：如有某个人在接口定义中增加了另一个方法，这时，这个接口就不再是函数式的了，并且编译过程也会失败。为了克服函数式接口的这种脆弱性并且能够明确声明接口作为函数式接口的意图，Java 8增加了一种特殊的注解@FunctionalInterface（Java 8中所有类库的已有接口都添加了@FunctionalInterface注解）。让我们看一下这种函数式接口的定义： 

		
    
			
			
  1. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						@FunctionalInterface
					
    

				
    

			

			
  2. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						public interface Functional {
					
    

				
    

			

			
  3. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    void method();
					
    

				
    

			

			
  4. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						}


需要记住的一件事是：默认方法与静态方法并不影响函数式接口的契约，可以任意使用： 

		
    
			
			
  1. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						@FunctionalInterface
					
    

				
    

			

			
  2. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						public interface FunctionalDefaultMethods {
					
    

				
    

			

			
  3. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    void method();
					
    

				
    

			

			
  4. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						         
					
    

				
    

			

			
  5. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    default void defaultMethod() {            
					
    

				
    

			

			
  6. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    }        
					
    

				
    

			

			
  7. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						}


Lambda是Java 8最大的卖点。它具有吸引越来越多程序员到Java平台上的潜力，并且能够在纯Java语言环境中提供一种优雅的方式来支持函数式编程。更多详情可以参考官方文档。

一下是一个字符串排序的例子，test1是没用lamada表达式的写法，test2是用lamada表达式的写法 

		
    
			
			
  1. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						package lamada;
					
    

				
    

			

			
  2. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						
					
    

				
    

			

			
  3. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						import org.junit.jupiter.api.Test;
					
    

				
    

			

			
  4. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						
					
    

				
    

			

			
  5. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						import java.util.Arrays;
					
    

				
    

			

			
  6. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						import java.util.Collections;
					
    

				
    

			

			
  7. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						import java.util.Comparator;
					
    

				
    

			

			
  8. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						import java.util.List;
					
    

				
    

			

			
  9. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						
					
    

				
    

			

			
  10. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						public class LamadaTest {
					
    

				
    

			

			
  11. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						
					
    

				
    

			

			
  12. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						@Test
					
    

				
    

			

			
  13. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						public void test1() {
					
    

				
    

			

			
  14. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						List names = Arrays.asList("peter", "anna", "mike", "xenia");
					
    

				
    

			

			
  15. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						
					
    

				
    

			

			
  16. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						Collections.sort(names, new Comparator<String>() {
					
    

				
    

			

			
  17. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						@Override
					
    

				
    

			

			
  18. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						public int compare(String a, String b) {
					
    

				
    

			

			
  19. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						return b.compareTo(a);
					
    

				
    

			

			
  20. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						}
					
    

				
    

			

			
  21. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						});
					
    

				
    

			

			
  22. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						System.out.println(Arrays.toString(names.toArray()));
					
    

				
    

			

			
  23. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						}
					
    

				
    

			

			
  24. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						
					
    

				
    

			

			
  25. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						@Test
					
    

				
    

			

			
  26. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						public void test2() {
					
    

				
    

			

			
  27. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");
					
    

				
    

			

			
  28. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						
					
    

				
    

			

			
  29. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						Collections.sort(names, (String a, String b) -> {
					
    

				
    

			

			
  30. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						return b.compareTo(a);
					
    

				
    

			

			
  31. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						});
					
    

				
    

			

			
  32. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						
					
    

				
    

			

			
  33. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						Collections.sort(names, (String a, String b) -> b.compareTo(a));
					
    

				
    

			

			
  34. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						
					
    

				
    

			

			
  35. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						Collections.sort(names, (a, b) -> b.compareTo(a));
					
    

				
    

			

			
  36. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						System.out.println(Arrays.toString(names.toArray()));
					
    

				
    

			

			
  37. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						}
					
    

				
    

			

			
  38. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						
					
    

				
    

			

			
  39. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						static void add(double a,String b) {
					
    

				
    

			

			
  40. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						System.out.println(a + b);
					
    

				
    

			

			
  41. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						}
					
    

				
    

			

			
  42. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						@Test
					
    

				
    

			

			
  43. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						public void test5() {
					
    

				
    

			

			
  44. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						D d = (a,b) -> add(a,b);
					
    

				
    

			

			
  45. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						//        interface D {
					
    

				
    

			

			
  46. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						//            void get(int i,String j);
					
    

				
    

			

			
  47. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						//        }
					
    

				
    

			

			
  48. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						这里要求，add的两个参数和get的两个参数吻合并且返回类型也要相等，否则报错
					
    

				
    

			

			
  49. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						//        static void add(double a,String b) {
					
    

				
    

			

			
  50. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						//            System.out.println(a + b);
					
    

				
    

			

			
  51. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						//        }
					
    

				
    

			

			
  52. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						}
					
    

				
    

			

			
  53. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						
					
    

				
    

			

			
  54. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						@FunctionalInterface
					
    

				
    

			

			
  55. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						interface D {
					
    

				
    

			

			
  56. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						void get(int i,String j);
					
    

				
    

			

			
  57. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						}
					
    

				
    

			

			
  58. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						
					
    

				
    

			

			
  59. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						}

2.2 接口的默认方法与静态方法 

Java 8用默认方法与静态方法这两个新概念来扩展接口的声明。默认方法使接口有点像Traits（Scala中特征(trait)类似于Java中的Interface，但它可以包含实现代码，也就是目前Java8新增的功能），但与传统的接口又有些不一样，它允许在已有的接口中添加新方法，而同时又保持了与旧版本代码的兼容性。

默认方法与抽象方法不同之处在于抽象方法必须要求实现，但是默认方法则没有这个要求。相反，每个接口都必须提供一个所谓的默认实现，这样所有的接口实现者将会默认继承它（如果有必要的话，可以覆盖这个默认实现）。让我们看看下面的例子： 

		
    
			
			
  1. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						private interface Defaulable {
					
    

				
    

			

			
  2. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    // Interfaces now allow default methods, the implementer may or 
					
    

				
    

			

			
  3. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    // may not implement (override) them.
					
    

				
    

			

			
  4. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    default String notRequired() { 
					
    

				
    

			

			
  5. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						        return "Default implementation"; 
					
    

				
    

			

			
  6. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    }        
					
    

				
    

			

			
  7. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						}
					
    

				
    

			

			
  8. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						         
					
    

				
    

			

			
  9. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						private static class DefaultableImpl implements Defaulable {
					
    

				
    

			

			
  10. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						}
					
    

				
    

			

			
  11. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						     
					
    

				
    

			

			
  12. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						private static class OverridableImpl implements Defaulable {
					
    

				
    

			

			
  13. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    @Override
					
    

				
    

			

			
  14. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    public String notRequired() {
					
    

				
    

			

			
  15. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						        return "Overridden implementation";
					
    

				
    

			

			
  16. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    }
					
    

				
    

			

			
  17. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						}


Defaulable接口用关键字default声明了一个默认方法notRequired()，Defaulable接口的实现者之一DefaultableImpl实现了这个接口，并且让默认方法保持原样。Defaulable接口的另一个实现者OverridableImpl用自己的方法覆盖了默认方法。

Java 8带来的另一个有趣的特性是接口可以声明（并且可以提供实现）静态方法。例如： 

		
    
			
			
  1. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						private interface DefaulableFactory {
					
    

				
    

			

			
  2. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    // Interfaces now allow static methods
					
    

				
    

			

			
  3. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    static Defaulable create( Supplier< Defaulable > supplier ) {
					
    

				
    

			

			
  4. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						        return supplier.get();
					
    

				
    

			

			
  5. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    }
					
    

				
    

			

			
  6. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						}


下面的一小段代码片段把上面的默认方法与静态方法黏合到一起。 

		
    
			
			
  1. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						public static void main( String[] args ) {
					
    

				
    

			

			
  2. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    Defaulable defaulable = DefaulableFactory.create( DefaultableImpl::new );
					
    

				
    

			

			
  3. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    System.out.println( defaulable.notRequired() );
					
    

				
    

			

			
  4. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						         
					
    

				
    

			

			
  5. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    defaulable = DefaulableFactory.create( OverridableImpl::new );
					
    

				
    

			

			
  6. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    System.out.println( defaulable.notRequired() );
					
    

				
    

			

			
  7. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						}


这个程序的控制台输出如下： 

		
    
			
			
  1. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						Default implementation
					
    

				
    

			

			
  2. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						Overridden implementation


在JVM中，默认方法的实现是非常高效的，并且通过字节码指令为方法调用提供了支持。默认方法允许继续使用现有的Java接口，而同时能够保障正常的编译过程。这方面好的例子是大量的方法被添加到java.util.Collection接口中去：stream()，parallelStream()，forEach()，removeIf()，……

尽管默认方法非常强大，但是在使用默认方法时我们需要小心注意一个地方：在声明一个默认方法前，请仔细思考是不是真的有必要使用默认方法，因为默认方***带给程序歧义，并且在复杂的继承体系中容易产生编译错误。更多详情请参考官方文档。

2.3 方法引用

方法引用提供了非常有用的语法，可以直接引用已有Java类或对象（实例）的方法或构造器。与lambda联合使用，方法引用可以使语言的构造更紧凑简洁，减少冗余代码。

下面，我们以定义了4个方法的Car这个类作为例子，区分Java中支持的4种不同的方法引用。 

		
    
			
			
  1. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						public static class Car {
					
    

				
    

			

			
  2. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    public static Car create( final Supplier< Car > supplier ) {
					
    

				
    

			

			
  3. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						        return supplier.get();
					
    

				
    

			

			
  4. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    }              
					
    

				
    

			

			
  5. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						         
					
    

				
    

			

			
  6. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    public static void collide( final Car car ) {
					
    

				
    

			

			
  7. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						        System.out.println( "Collided " + car.toString() );
					
    

				
    

			

			
  8. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    }
					
    

				
    

			

			
  9. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						         
					
    

				
    

			

			
  10. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    public void follow( final Car another ) {
					
    

				
    

			

			
  11. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						        System.out.println( "Following the " + another.toString() );
					
    

				
    

			

			
  12. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    }
					
    

				
    

			

			
  13. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						         
					
    

				
    

			

			
  14. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    public void repair() {   
					
    

				
    

			

			
  15. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						        System.out.println( "Repaired " + this.toString() );
					
    

				
    

			

			
  16. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    }
					
    

				
    

			

			
  17. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						}


第一种方法引用是构造器引用，它的语法是Class::new，或者更一般的Class< T >::new。请注意构造器没有参数。 

		
    
			
			
  1. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						final Car car = Car.create( Car::new );
					
    

				
    

			

			
  2. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						final List< Car > cars = Arrays.asList( car );


第二种方法引用是静态方法引用，它的语法是Class::static_method。请注意这个方法接受一个Car类型的参数。 

cars.forEach( Car::collide );


第三种方法引用是特定类的任意对象的方法引用，它的语法是Class::method。请注意，这个方法没有参数。 

cars.forEach( Car::repair );


最后，第四种方法引用是特定对象的方法引用，它的语法是instance::method。请注意，这个方法接受一个Car类型的参数 

		
    
			
			
  1. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						final Car police = Car.create( Car::new );
					
    

				
    

			

			
  2. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						cars.forEach( police::follow );


运行上面的Java程序在控制台上会有下面的输出（Car的实例可能不一样）： 

		
    
			
			
  1. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						Collided com.javacodegeeks.java8.method.references.MethodReferences$Car@7a81197d
					
    

				
    

			

			
  2. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						Repaired com.javacodegeeks.java8.method.references.MethodReferences$Car@7a81197d
					
    

				
    

			

			
  3. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						Following the com.javacodegeeks.java8.method.references.MethodReferences$Car@7a81197d


关于方法引用的更多详情请参考官方文档。

2.4 重复注解


自从Java 5引入了注解机制，这一特性就变得非常流行并且广为使用。然而，使用注解的一个限制是相同的注解在同一位置只能声明一次，不能声明多次。Java 8打破了这条规则，引入了重复注解机制，这样相同的注解可以在同一地方声明多次。

重复注解机制本身必须用@Repeatable注解。事实上，这并不是语言层面上的改变，更多的是编译器的技巧，底层的原理保持不变。让我们看一个快速入门的例子： 

		
    
			
			
  1. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						
					
    

				
    

			

			
  2. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						package com.javacodegeeks.java8.repeatable.annotations;
					
    

				
    

			

			
  3. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						 
					
    

				
    

			

			
  4. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						import java.lang.annotation.ElementType;
					
    

				
    

			

			
  5. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						import java.lang.annotation.Repeatable;
					
    

				
    

			

			
  6. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						import java.lang.annotation.Retention;
					
    

				
    

			

			
  7. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						import java.lang.annotation.RetentionPolicy;
					
    

				
    

			

			
  8. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						import java.lang.annotation.Target;
					
    

				
    

			

			
  9. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						 
					
    

				
    

			

			
  10. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						public class RepeatingAnnotations {
					
    

				
    

			

			
  11. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    @Target( ElementType.TYPE )
					
    

				
    

			

			
  12. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    @Retention( RetentionPolicy.RUNTIME )
					
    

				
    

			

			
  13. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    public @interface Filters {
					
    

				
    

			

			
  14. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						        Filter[] value();
					
    

				
    

			

			
  15. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    }
					
    

				
    

			

			
  16. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						     
					
    

				
    

			

			
  17. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    @Target( ElementType.TYPE )
					
    

				
    

			

			
  18. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    @Retention( RetentionPolicy.RUNTIME )
					
    

				
    

			

			
  19. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    @Repeatable( Filters.class )
					
    

				
    

			

			
  20. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    public @interface Filter {
					
    

				
    

			

			
  21. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						        String value();
					
    

				
    

			

			
  22. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    };
					
    

				
    

			

			
  23. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						     
					
    

				
    

			

			
  24. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    @Filter( "filter1" )
					
    

				
    

			

			
  25. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    @Filter( "filter2" )
					
    

				
    

			

			
  26. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    public interface Filterable {        
					
    

				
    

			

			
  27. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    }
					
    

				
    

			

			
  28. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						     
					
    

				
    

			

			
  29. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    public static void main(String[] args) {
					
    

				
    

			

			
  30. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						        for( Filter filter: Filterable.class.getAnnotationsByType( Filter.class ) ) {
					
    

				
    

			

			
  31. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						            System.out.println( filter.value() );
					
    

				
    

			

			
  32. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						        }
					
    

				
    

			

			
  33. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    }
					
    

				
    

			

			
  34. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						}


正如我们看到的，这里有个使用@Repeatable( Filters.class )注解的注解类Filter，Filters仅仅是Filter注解的数组，但Java编译器并不想让程序员意识到Filters的存在。这样，接口Filterable就拥有了两次Filter（并没有提到Filter）注解。

同时，反射相关的API提供了新的函数getAnnotationsByType()来返回重复注解的类型（请注意Filterable.class.getAnnotation( Filters.class )经编译器处理后将会返回Filters的实例）。

程序输出结果如下： 

		
    
			
			
  1. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						filter1
					
    

				
    

			

			
  2. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						filter2


更多详情请参考官方文档

2.5 更好的类型推测机制


Java 8在类型推测方面有了很大的提高。在很多情况下，编译器可以推测出确定的参数类型，这样就能使代码更整洁。让我们看一个例子：

  

		
    
			
			
  1. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						package com.javacodegeeks.java8.type.inference;
					
    

				
    

			

			
  2. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						 
					
    

				
    

			

			
  3. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						public class Value< T > {
					
    

				
    

			

			
  4. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    public static< T > T defaultValue() { 
					
    

				
    

			

			
  5. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						        return null; 
					
    

				
    

			

			
  6. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    }
					
    

				
    

			

			
  7. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						     
					
    

				
    

			

			
  8. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    public T getOrDefault( T value, T defaultValue ) {
					
    

				
    

			

			
  9. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						        return ( value != null ) ? value : defaultValue;
					
    

				
    

			

			
  10. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    }
					
    

				
    

			

			
  11. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						}


这里是Value< String >类型的用法。 

		
    
			
			
  1. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						package com.javacodegeeks.java8.type.inference;
					
    

				
    

			

			
  2. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						 
					
    

				
    

			

			
  3. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						public class TypeInference {
					
    

				
    

			

			
  4. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    public static void main(String[] args) {
					
    

				
    

			

			
  5. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						        final Value< String > value = new Value<>();
					
    

				
    

			

			
  6. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						        value.getOrDefault( "22", Value.defaultValue() );
					
    

				
    

			

			
  7. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    }
					
    

				
    

			

			
  8. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						}


Value.defaultValue()的参数类型可以被推测出，所以就不必明确给出。在Java 7中，相同的例子将不会通过编译，正确的书写方式是 Value.< String >defaultValue()。

2.6 扩展注解的支持


Java 8扩展了注解的上下文。现在几乎可以为任何东西添加注解：局部变量、泛型类、父类与接口的实现，就连方法的异常也能添加注解。下面演示几个例子：

  

		
    
			
			
  1. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						package com.javacodegeeks.java8.annotations;
					
    

				
    

			

			
  2. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						 
					
    

				
    

			

			
  3. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						import java.lang.annotation.ElementType;
					
    

				
    

			

			
  4. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						import java.lang.annotation.Retention;
					
    

				
    

			

			
  5. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						import java.lang.annotation.RetentionPolicy;
					
    

				
    

			

			
  6. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						import java.lang.annotation.Target;
					
    

				
    

			

			
  7. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						import java.util.ArrayList;
					
    

				
    

			

			
  8. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						import java.util.Collection;
					
    

				
    

			

			
  9. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						 
					
    

				
    

			

			
  10. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						public class Annotations {
					
    

				
    

			

			
  11. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    @Retention( RetentionPolicy.RUNTIME )
					
    

				
    

			

			
  12. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    @Target( { ElementType.TYPE_USE, ElementType.TYPE_PARAMETER } )
					
    

				
    

			

			
  13. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    public @interface NonEmpty {        
					
    

				
    

			

			
  14. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    }
					
    

				
    

			

			
  15. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						         
					
    

				
    

			

			
  16. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    public static class Holder< @NonEmpty T > extends @NonEmpty Object {
					
    

				
    

			

			
  17. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						        public void method() throws @NonEmpty Exception {           
					
    

				
    

			

			
  18. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						        }
					
    

				
    

			

			
  19. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    }
					
    

				
    

			

			
  20. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						         
					
    

				
    

			

			
  21. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    @SuppressWarnings( "unused" )
					
    

				
    

			

			
  22. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    public static void main(String[] args) {
					
    

				
    

			

			
  23. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						        final Holder< String > holder = new @NonEmpty Holder< String >();       
					
    

				
    

			

			
  24. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						        @NonEmpty Collection< @NonEmpty String > strings = new ArrayList<>();       
					
    

				
    

			

			
  25. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    }
					
    

				
    

			

			
  26. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						}


ElementType.TYPE_USE和ElementType.TYPE_PARAMETER是两个新添加的用于描述适当的注解上下文的元素类型。在Java语言中，注解处理API也有小的改动来识别新增的类型注解。

3. Java编译器的新特性

3.1 参数名字


很长一段时间里，Java程序员一直在发明不同的方式使得方法参数的名字能保留在Java字节码中，并且能够在运行时获取它们（比如，Paranamer类库）。最终，在Java 8中把这个强烈要求的功能添加到语言层面（通过反射API与Parameter.getName()方法）与字节码文件（通过新版的javac的–parameters选项）中。 

		
    
			
			
  1. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						
					
    

				
    

			

			
  2. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						package com.javacodegeeks.java8.parameter.names;
					
    

				
    

			

			
  3. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						 
					
    

				
    

			

			
  4. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						import java.lang.reflect.Method;
					
    

				
    

			

			
  5. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						import java.lang.reflect.Parameter;
					
    

				
    

			

			
  6. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						 
					
    

				
    

			

			
  7. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						public class ParameterNames {
					
    

				
    

			

			
  8. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    public static void main(String[] args) throws Exception {
					
    

				
    

			

			
  9. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						        Method method = ParameterNames.class.getMethod( "main", String[].class );
					
    

				
    

			

			
  10. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						        for( final Parameter parameter: method.getParameters() ) {
					
    

				
    

			

			
  11. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						            System.out.println( "Parameter: " + parameter.getName() );
					
    

				
    

			

			
  12. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						        }
					
    

				
    

			

			
  13. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    }
					
    

				
    

			

			
  14. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						}


如果不使用–parameters参数来编译这个类，然后运行这个类，会得到下面的输出： 

Parameter: arg0


如果使用–parameters参数来编译这个类，程序的结构会有所不同（参数的真实名字将会显示出来）： 

Parameter: args


对于有经验的Maven用户，通过maven-compiler-plugin的配置可以将-parameters参数添加到编译器中去。 

		
    
			
			
  1. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						<plugin>
					
    

				
    

			

			
  2. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    <groupId>org.apache.maven.plugins</groupId>
					
    

				
    

			

			
  3. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    <artifactId>maven-compiler-plugin</artifactId>
					
    

				
    

			

			
  4. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    <version>3.1</version>
					
    

				
    

			

			
  5. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    <configuration>
					
    

				
    

			

			
  6. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						        <compilerArgument>-parameters</compilerArgument>
					
    

				
    

			

			
  7. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						        <source>1.8</source>
					
    

				
    

			

			
  8. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						        <target>1.8</target>
					
    

				
    

			

			
  9. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						    </configuration>
					
    

				
    

			

			
  10. 
				
				
    
					
					
    
						
					
    

				
    

				
    
					
					
    
						</plugin>


针对Java 8最新发布的Eclipse Kepler SR2（请检查这里的下载说明）提供了非常实用的配置选项，可以通过下图的配置方式来控制编译器行为


图1. 配置Eclipse工程使之支持Java 8编译器的新特性——parameters参数

此外，Parameter类有一个很方便的方法isNamePresent()来验证是否可以获取参数的名字。

篇幅原因，不能一一展现。以上完整题目答案资料，及更多java大小厂面经真题分享： 点赞 评论 ：学习
感谢大家阅读，本人见识有限，写的博客难免有错误或者疏忽的地方，还望各位大佬指点，在此表示感激不尽。文章持续更新中…....

#笔试题目##面经##Java##技术栈##读书笔记##题解#
全部评论
感谢楼主分享，现在这种描述资料才是最重要的
点赞 回复 分享
发布于 2022-05-10 20:02
楼主这排版需要更新下，这中间跨度太大了
点赞 回复 分享
发布于 2022-05-11 10:29
楼主求更新！
点赞 回复 分享
发布于 04-03 12:19 江西

相关推荐

昨天 16:49
门头沟学院 Java
点赞 评论 收藏
分享
11-20 23:13
武汉工程大学 销售工程师
点赞 评论 收藏
分享
头像
10-16 16:19
第一拖拉机制造厂拖拉机学院 Java
新大陆oc
秋招第一个oc
牛客771574427号：恭喜你，华杰
点赞 评论 收藏
分享
11-20 16:47
华中科技大学 光通信工程师
秋招就到这儿吧。
秋招真的是一场持久战，每一天都有不同的心情。。。随着华为的审批保温，差不多整个秋招也就结束了。BG：双九，保研，本硕都是电子信息类（光电方向），研究方向是光通信这一块。&nbsp;秋招一共投递了17家公司，我的想法很明确，最后的最后的最后是希望能够做解决方案一类，也就是技术+销售结合的事儿。但这样的岗要求很高，基本很少校招，都是社招或内部研发输出一线这样的模式。所以我投递的岗包括技术岗和非技术岗。收到面试邀请9家，获得offer（含保温）9家，已拿到8offer，预计9offer。面试通过率100%。所有的面经都在主页了，欢迎各位大佬指正批评。🙇&nbsp;5月准备华为客经实习开始陆续了解秋招的相关事宜。秋招前...
zachsun：华科硕士给13级？有点逆天了吧
25届秋招总结
点赞 评论 收藏
分享
点赞 5 评论
分享

招聘动态

查看更多

杉川机器人

2025校园招聘

字节跳动

2025校园招聘

字节跳动Data

2025校园招聘

快手Star

2025届招聘

快手

销售类投递专区

库洛游戏

全站热榜

正在热议
# 晒一晒我的offer #
9716447次浏览 104886人参与
# 学历or实习经历，哪个更重要 #
39521次浏览 286人参与
# 北方华创开奖 #
21631次浏览 247人参与
# 地方国企笔面经互助 #
2231次浏览 6人参与
# 应届生被毁约被毁意向了怎么办 #
25084次浏览 233人参与
# 你最想要的公司福利是？ #
37111次浏览 65人参与
# 查收我的offer竞争力报告 #
14467次浏览 205人参与
# 机械应届生薪资要多少才合适？ #
12034次浏览 58人参与
# 一觉醒来，我觉醒了超级打工人系统 #
2429次浏览 32人参与
# 我的工作日记 #
20663次浏览 269人参与
# 你觉得第一学历对求职有影响吗？ #
14644次浏览 120人参与
# 寒假躺平还是提前实习 #
57400次浏览 419人参与
# 总结:哪家公司面试体验感最差 #
24110次浏览 117人参与
# 公司情报交流地 #
31275次浏览 221人参与
# 选完offer后，你后悔学本专业吗 #
7587次浏览 47人参与
# 实习，投递多份简历没人回复怎么办 #
2384870次浏览 34218人参与
# 00后45度躺现状 #
36606次浏览 305人参与
# 机械人，签完三方你在忙什么？ #
23401次浏览 121人参与
# 秋招OC许愿 #
224859次浏览 1857人参与
# 得物求职进展汇总 #
62946次浏览 664人参与
# 不给转正的实习，你还去吗 #
1513674次浏览 16943人参与
牛客网
牛客企业服务