Shulou(Shulou.com)06/01 Report--

This article mainly explains "what are the grammatical sugars in Java and how to use them". Interested friends may wish to have a look. The method introduced in this paper is simple, fast and practical. Let's let the editor take you to learn "what are the grammatical sweets in Java and how to use them?"

Grammatical Sugar in Java

Switch supports String and enumerations

Generics

Automatic packing and unpacking

Method variable length parameter

Enumerate

Inner class

Conditional compilation

Assertion

Numerical literal quantity

For-each

Try-with-resource

Lambda expression

String + sign.

Switch support for String and enumerated classes

Switch's support for enumerations is similar to that of String. Switch native support can only support comparing integer types. If switch is followed by a String type, the compiler converts it to the hashCode value of String, so it is actually comparing the hashcode value of String. If switch is followed by Enum, the compiler converts it to the subscript (ordinal) defined by this enumeration. In fact, they all end up with the type of integers that are compared. Here is a list of Stirng.

source code

Public class switchDemoString {public static void main (String [] args) {String str = "world"; switch (str) {case "hello": System.out.println ("hello"); break; case "world": System.out.println ("world"); break Default: break;}

Decompiled code

Public class switchDemoString {public switchDemoString () {} public static void main (String args []) {String str = "world"; String s; switch ((s = str) .hashCode ()) {default: break; case 99162322: if (s.equals ("hello")) System.out.println ("hello") Break; case 113318802: if (s.equals ("world")) System.out.println ("world"); break;}}

Through decompilation, you can find that the switch is actually a hash, and then do a security check by comparing it with the equals method, which is necessary because the hash may collide. So its performance is not as good as using enumerations for switch or using pure integer constants.

Support for generics

In JDK1.5, the Java language introduces generics. But this generics mechanism is implemented through type erasure, that is, generics in Java are only valid in the program source code (type checking is provided in the source code phase) and are automatically replaced by forced type conversions in the compiled bytecode. In other words, the generics mechanism in Java is actually a grammatical candy, and its generics implementation is not so elegant compared with C++ and C#.

/ * there are generics in the source code * / public static void main (String [] args) {Map map = new HashMap (); map.put ("hello", "Hello"); String hello = map.get ("hello"); System.out.println (hello);}

Compiled code

Public static void main (String [] args) {HashMap map = new HashMap (); / / Type erase map.put ("hello", "Hello"); String hello = (String) map.get ("hello"); / / cast System.out.println (hello);}

Through the above decompiled code, we find that there are no generics in the virtual machine, only ordinary classes and common methods, the type parameters of all generic classes are erased at compile time, and generic classes do not have their own unique Class class objects.

Automatic packing and unpacking of packing types

We know that the eight basic types in Java and the corresponding wrapper types can be assigned to each other (this process is called boxing and unpacking). In fact, the principle behind this is that the compiler has been optimized. As in the following code, assigning a primitive type to a wrapper class actually calls the wrapper class's valueOf () method to create a wrapper class and assign a value to the primitive type. The wrapper class assigns a value to the primitive type by calling the wrapper class's xxxValue () method to get the primitive data type and then assigning the value.

Public static void main (String [] args) {Integer a = 1; int b = 2; int c = a + b; System.out.println (c);}

Compiled code

Public static void main (String [] args) {Integer a = Integer.valueOf (1); / / Auto-packing byte b = 2; int c = a.intValue () + b-System.out.println (c);} variable length method parameters

The variable length parameter feature is introduced in JDK1.5. There are two conditions for using the variable length parameter: one is that the variable length part of the parameter has the same type, and the other is that the variable length parameter must be at the end of the method parameter list. The variable length parameter is also the syntax sugar in Java, and its internal implementation is that the compiler converts the variable length parameter part into a Java array when compiling the source code.

Enumerate

The definition of classes in java uses class, and the definition of enumerated classes uses enum. In the bytecode structure of Java, there is no enumerated type, the enumerated type is just a syntax sugar, which is compiled into a normal class after compilation, and is also modified with Class. This class inherits from java.lang.Enum and is modified by the final keyword.

Public enum Fruit {APPLE,ORINGE}

Decompile the class file of Fruit

/ / inherits java.lang.Enum and declares it as finalpublic final class Fruit extends Enum {public static Fruit [] values () {return (Fruit []) $VALUES.clone ();} public static Fruit valueOf (String s) {return (Fruit) Enum.valueOf (Fruit, s);} private Fruit (String s, int I) {super (s, I);} / enumerated type constant public static final Fruit APPLE Public static final Fruit ORANGE; private static final Fruit $VALUES []; / / use arrays to maintain static {APPLE = new Fruit ("APPLE", 0); ORANGE = new Fruit ("ORANGE", 1); $VALUES = (new Fruit [] {APPLE, ORANGE});}}

From the above decompiled code, we know that when we use enmu to define an enumerated type, the compiler will automatically create a class of final type for us to inherit from the Enum class, so enumerated types cannot be inherited.

Inner class

Inner classes are introduced in the Java language because sometimes a class only wants to be useful in one class, and we don't want it to be used in another place. The inner class is syntactic sugar because it is just a compile-time concept, and once compiled, the compiler generates a separate class file called outer$innter.class for the inner class.

Public class Outer {class Inner {}}

After compiling with javac, two class files, Outer.class and Outer$Inner.class, are generated, and the contents of Outer$Inner.class are as follows:

Class Outer$Inner {Outer$Inner (Outer var1) {this.this$0 = var1;}} conditional compilation

In general, all lines in the source program participate in compilation. But sometimes you want to compile part of the content only when certain conditions are met, that is, to specify the compilation conditions for part of the content, which is called conditional compilation (conditional compile).

Conditional compilation in Java is achieved through the optimization principles of the compiler:

If the condition of if is false, the if statement is ignored at compile time.

Ignore unused variables.

Public class ConditionalCompilation02 {public static void main (String [] args) {if (CompilationConfig.DEBUG_MODE) {System.out.println ("[DEBUG MODE] You can print sth");} else {System.out.println ("[RELEASE MODE] You can print sth");}

Therefore, the conditional compilation of Java syntax is realized by if statements that judge that the condition is constant. According to whether the condition is true or false according to if, the compiler directly eliminates the block of code whose branch is false. Conditional compilation implemented in this way must be implemented in the method body, not on the structure of the entire Java class or on the properties of the class.

Assertion

In Java, the assert keyword was introduced from JAVA SE 1.4. to avoid errors caused by the use of the assert keyword in older versions of Java code, Java defaults to not starting assertion checking when executing. (at this point, all assertion statements are ignored! ).

If you want to turn on assertion checking, you need to turn it on with the switch-enableassertions or-ea.

In fact, the underlying implementation of the assertion is the if language. If the assertion result is true, then nothing is done and the program continues to execute. If the assertion result is false, the program throws an AssertError to interrupt the execution of the program.

Numerical literal quantity

The following numeric literals are supported in Java

Decimal: default

Octal: the integer is represented by the number 0

Hexadecimal: add "0x" or "0X" before integers

Binary (newly added): add "0b" or "0B" before an integer

In addition, in jdk7, numeric literals, whether integers or floating-point numbers, allow any number of underscores to be inserted between numbers. These underscores have no effect on the literal value and are intended to be easy to read. For example:

1_500_000

5_6.3_4

89_3___1

The underscore can only appear in the middle of the number, and it must be a number before and after. So "_ 100" and "0b_101" are illegal and cannot be compiled. The motivation for this limitation is to reduce the complexity of the implementation. With this limitation, the Java compiler only needs to delete the underscores in the middle of the numbers it finds when scanning the source code. If this restriction is not added, the compiler needs parsing before it can make a judgment. For example: _ 100, which may be an integer face value of 100 or a variable name. This requires the implementation of the compiler to make more complex changes.

For-each

The object that enhances the for loop is either an array or implements the Iterable interface. This syntax sugar is mainly used to traverse an array or collection, and it cannot change the size of the set during the loop. The enhanced for loop mainly makes the code more concise, and the principle behind it is that the compiler converts the enhanced for loop into a normal for loop.

Public static void main (String [] args) {String [] params = new String [] {"hello", "world"}; / / enhanced for loop object is array for (String str: params) {System.out.println (str);} List lists = Arrays.asList ("hello", "world"); / / enhanced for loop object implements Iterable interface for (String str: lists) {System.out.println (str) }}

Code compiled by the compiler

Public static void main (String [] args) {String [] params = new String [] {"hello", "world"}; String [] lists = params; int var3 = params.length; / / array form of enhanced for degenerates to normal for for (int str = 0; str)

< var3; ++str) { String str1 = lists[str]; System.out.println(str1); } List var6 = Arrays.asList(new String[]{"hello", "world"}); Iterator var7 = var6.iterator(); //实现Iterable接口的增强for使用iterator接口进行遍历 while(var7.hasNext()) { String var8 = (String)var7.next(); System.out.println(var8); }}try-with-resource 当一个外部资源的句柄对象实现了AutoCloseable接口，JDK7中便可以利用try-with-resource语法更优雅的关闭资源，消除板式代码。 public static void main(String[] args) { try (FileInputStream inputStream = new FileInputStream(new File("test"))) { System.out.println(inputStream.read()); } catch (IOException e) { throw new RuntimeException(e.getMessage(), e); }} 将外部资源的句柄对象的创建放在try关键字后面的括号中，当这个try-catch代码块执行完毕后，Java会确保外部资源的close方法被调用。代码是不是瞬间简洁许多！try-with-resource并不是JVM虚拟机的新增功能，只是JDK实现了一个语法糖，当你将上面代码反编译后会发现，其实对JVM虚拟机而言，它看到的依然是之前的写法： public static void main(String[] args) { try { FileInputStream inputStream = new FileInputStream(new File("test")); Throwable var2 = null; try { System.out.println(inputStream.read()); } catch (Throwable var12) { var2 = var12; throw var12; } finally { if (inputStream != null) { if (var2 != null) { try { inputStream.close(); } catch (Throwable var11) { var2.addSuppressed(var11); } } else { inputStream.close(); } } } } catch (IOException var14) { throw new RuntimeException(var14.getMessage(), var14); }} 其实背后的原理也很简单，那些我们没有做的关闭资源的操作，编译器都帮我们做了。 Lambda表达式 Lambda表达式虽然看着很先进，但其实Lambda表达式的本质只是一个"语法糖",由编译器推断并帮你转换包装为常规的代码,因此你可以使用更少的代码来实现同样的功能。本人建议不要乱用,因为这就和某些很高级的黑客写的代码一样,简洁,难懂,难以调试,维护人员想骂娘。 lambda表达式允许你通过表达式来代替功能接口。Lambda表达式还增强了集合库。 Java SE 8添加了2个对集合数据进行批量操作的包: java.util.function 包以及java.util.stream 包。 流(stream)就如同迭代器(iterator),但附加了许多额外的功能。 总的来说,lambda表达式和 stream 是自Java语言添加泛型(Generics)和注解(annotation)以来最大的变化。 Lambda表达式的语法基本语法:(parameters) ->

Expression or (parameters)-> {statements;}

Some simple columns of Lambda expressions

/ / 1. No parameters are required, and the return value is 5 ()-> 5 / / 2. Receives a parameter (numeric type) and returns twice its value x-> 2 * x / / 3. Take 2 parameters (numbers) and return their difference (x, y)-> x-y / / 4. Receive 2 int integers and return their sum (int x, int y)-> x + y / / 5. Accepts a string object and prints it on the console without returning any value (looks like returning void) (String s)-> System.out.print (s) basic Lambda example (implementing functional interface) String [] atp = {"Rafael Nadal", "Novak Djokovic", "Stanislas Wawrinka", "David Ferrer", "Roger Federer", "Andy Murray", "Tomas Berdych" "Juan Martin Del Potro"} List players = Arrays.asList (atp); / / implement functional interface players.forEach ((String player)-> {System.out.println (player);}); Runnable runnable = ()-> {System.out.println ("l am a new thread...");}; new Thread (runnable) .start () Use Lambdas to sort the collection players.sort (new Comparator () {@ Override public int compare (String o1MagneString O2) {return o1.compareTo (O2);}}); Comparator comparator = (String o1dString O2)-> {return o1.compareTo (O2);}; players.sort (comparator); using Lambdas and Streams

Stream is a wrapper around a collection and is usually used with lambda. Using lambdas can support many operations, such as map, filter, limit, sorted, count, min, max, sum, collect, and so on. Similarly, Stream use lazy operations, they don't really read all the data, and encounter a method like getFirst () that ends the chained syntax.

Support for string pair + sign String slotted characters + "abc"; System.out.println (s)

The output of the code above?

String concatenation principle: at run time, the splicing of two strings str1, str2 will first call String.valueOf (obj), this Obj is str1, while the implementation in String.valueOf (Obj) is return obj = = null? "null": obj.toString (), then generate StringBuilder, call the StringBuilder (str1) constructor, initialize the StringBuilder with a length of str1.length () + 16, and call append (str1)! Next, call StringBuilder.append (str2), concatenate the second string, and then call StringBuilder.toString to return the result!

So the answer is: StringBuilder ("null"). Append ("abc"). ToString (); / / nullabc

At this point, I believe you have a deeper understanding of "what are the grammatical sweets in Java and how to use them?" you might as well do it in practice. Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.