- Interface methods by default;
- Lambda expressions;
- Functional interfaces;
- References to methods and constructors;
- Repeatable annotations
- Annotations on data types;
- Reflection for method parameters;
- Stream API for working with collections;
- Parallel sorting of arrays;
- New API for working with dates and times;
- New JavaScript Nashorn Engine ;
- Added several new classes for thread safe operation;
- Added a new API for
CalendarandLocale; - Added support for Unicode 6.2.0 ;
- Added a standard class for working with Base64 ;
- Added support for unsigned arithmetic;
- Improved constructor
java.lang.String(byte[], *)and method performancejava.lang.String.getBytes(); - A new implementation
AccessController.doPrivilegedthat allows you to set a subset of privileges without having to check all * other access levels; - Password-based algorithms have become more robust;
- Added support for SSL / TLS Server Name Indication (NSI) in JSSE Server ;
- Improved keystore (KeyStore);
- Added SHA-224 algorithm;
- Removed JDBC Bridge - ODBC;
- PermGen is removed , the method for storing meta-data of classes is changed;
- Ability to create profiles for the Java SE platform, which include not the entire platform, but some part of it;
- Tools
- Added utility
jjsfor using JavaScript Nashorn; - The command
javacan run JavaFX applications; - Added utility
jdepsfor analyzing .class files.
- Added utility
Java 8 interface changes include static methods and default methods in interfaces. Prior to Java 8, we could have only method declarations in the interfaces. But from Java 8, we can have default methods and static methods in the interfaces.
What is the structure and features of using a lambda expression? A lambda is a set of instructions that can be separated into a separate variable and then repeatedly called in various places of the program.
The basis of the lambda expression is the lambda operator , which represents the arrow ->. This operator divides the lambda expression into two parts: the left side contains a list of expression parameters, and the right actually represents the body of the lambda expression, where all actions are performed.
The lambda expression is not executed by itself, but forms the implementation of the method defined in the functional interface. It is important that the functional interface should contain only one single method without implementation.
interface Operationable {
int calculate ( int x , int y );
}
public static void main ( String [] args) {
Operationable operation = (x, y) - > x + y;
int result = operation.calculate ( 10 , 20 );
System.out.println (result); // 30
}In fact, lambda expressions are in some way a shorthand form of internal anonymous classes that were previously used in Java.
-
Deferred execution lambda expressions - it is defined once in one place of the program, it is called if necessary, any number of times and in any place of the program.
-
The parameters of the lambda expression must correspond in type to the parameters of the functional interface method:
operation = ( int x, int y) - > x + y;
// When writing the lambda expression itself, the parameter type is allowed not to be specified:
(x, y) - > x + y;
// If the method does not accept any parameters, then empty brackets are written, for example:
() - > 30 + 20 ;
// If the method accepts only one parameter, then the brackets can be omitted:
n - > n * n;- Trailing lambda expressions are not required to return any value.
interface Printable {
void print( String s );
}
public static void main ( String [] args) {
Printable printer = s - > System.out.println(s);
printer.print("Hello, world");
}
// _ Block lambda - expressions_ are surrounded by curly braces . The modular lambda - expressions can be used inside nested blocks, loops, `design the if ` ` switch statement ', create variables, and so on . d . If you block a lambda - expression must return a value, it explicitly applies `statement return statement ' :
Operationable operation = ( int x, int y) - > {
if (y == 0 ) {
return 0 ;
}
else {
return x / y;
}
};- Passing a lambda expression as a method parameter
interface Condition {
boolean isAppropriate ( int n );
}
private static int sum ( int [] numbers, Condition condition) {
int result = 0 ;
for ( int i : numbers) {
if (condition.isAppropriate(i)) {
result + = i;
}
}
return result;
}
public static void main ( String [] args) {
System.out.println(sum ( new int [] { 0 , 1 , 0 , 3 , 0 , 5 , 0 , 7 , 0 , 9 }, (n) - > n ! = 0 ));
} Access to external scope variables from a lambda expression is very similar to access from anonymous objects.
- immutable ( effectively final - not necessarily marked as final) local variables;
- class fields
- static variables.
The default methods of the implemented functional interface are not allowed to be accessed inside the lambda expression.
public static List < String > sort ( List < String > list) {
Collections.sort(list, (a, b) -> a.compareTo(b));
return list;
}If the method existing in the class already does everything that is necessary, then you can use the method reference mechanism (method reference) to directly pass this method. The result will be exactly the same as in the case of defining a lambda expression that calls this method.
private interface Measurable {
public int length ( String string );
}
public static void main ( String [] args) {
Measurable a = String::length;
System.out.println(a.length("abc"));
}Method references are potentially more efficient than using lambda expressions. In addition, they provide the compiler with better information about the type, and if you can choose between using a reference to an existing method and using a lambda expression, you should always use a method reference.
- on the static method;
- per instance method;
- to the constructor.
The specified expression illustrates passing a reference to a static method of a println()class System.out.
A functional interface is an interface that defines only one abstract method.
To accurately determine the interface as functional, an annotation has been added @FunctionalInterface that works on the principle of @Override. It will designate a plan and will not allow to define the second abstract method in the interface.
An interface can include as many default methods as you like while remaining functional, because default methods are not abstract.
The class is StringJoinerused to create a sequence of strings separated by a separator with the ability to append a prefix and suffix to the resulting string:
StringJoiner joiner = new StringJoiner ( " . " , " Prefix- " , " -suffix " );
for ( String s : " Hello the brave world " . split ( " " )) {
, joiner, . add (s);
}
System.out.println(joiner); // prefix-Hello.the.brave.world-suffixJava 8 allows you to add non-abstract method implementations to an interface using the keyword default:
interface Example {
int process ( int a );
default void show () {
System.out.println("default show ()");
}
}- If a class implements an interface, it can, but does not have to, implement the default methods already implemented in the * interface. The class inherits the default implementation.
- If a class implements several interfaces that have the same default method, then the class must implement the method with the same signature on its own. The situation is similar if one interface has a default method, and in the other the same method is abstract - no class default implementation is inherited.
- The default method cannot override the class method
java.lang.Object. - They help implement interfaces without fear of disrupting other classes.
- Avoid creating utility classes, since all the necessary methods can be represented in the interfaces themselves.
- They give classes the freedom to choose the method to be redefined.
- One of the main reasons for introducing default methods is the ability of collections in Java 8 to use lambda expressions.
Using the keyword superalong with the interface name:
interface Paper {
default void show () {
System.out.println(" default show ()");
}
}
class License implements Paper {
public void show () {
Paper.super.show();
}
}Static interface methods are similar to default methods, except that there is no way to override them in classes that implement the interface.
- Static methods in the interface are part of the interface without the ability to use them for objects of the implementation class
- Class methods
java.lang.Objectcannot be overridden as static - Static methods in the interface are used to provide helper methods, for example, checking for null, sorting collections, etc.
Using the interface name:
interface Paper {
static void show () {
System.out.println( " static show () " );
}
}
class License {
public void showPaper () {
Paper.show ();
}
}An optional value Optionalis a container for an object that may or may not contain a value null. Such a wrapper is a convenient means of prevention NullPointerException, as has some higher-order functions, eliminating the need for repeating if null/notNullchecks:
Optional < String > optional = Optional . of ( " hello " );
optional.isPresent(); // true
optional.ifPresent(s -> System.out.println(s . length ())); // 5
optional.get(); // "hello"
optional.orElse( " ops ... " ); // "hello"An interface java.util.Stream is a sequence of elements on which various operations can be performed.
Operations on streams can be either intermediate (intermediate) or final (terminal) . Final operations return a result of a certain type, and intermediate operations return the same stream. Thus, you can build chains of several operations on the same stream.
A stream can have any number of calls to intermediate operations and the last call to the final operation. At the same time, all intermediate operations are performed lazily and until the final operation is called, no actions actually happen (similar to creating an object Threador Runnable, without a call start()).
Streams are created based on sources of some, for example, classes from java.util.Collection.
Associative arrays (maps), for example HashMap, are not supported.
Operations on streams can be performed both sequentially and in parallel.
Streams cannot be reused. As soon as some final operation has been called, the flow is closed.
In addition to the universal object, there are special types of streams to work with primitive data types int, longand double: IntStream, LongStreamand DoubleStream. These primitive streams work just like regular object streams, but with the following differences:
- use specialized lambda expressions, for example,
IntFunctionorIntPredicateinstead ofFunctionandPredicate; - support additional end operations
sum(),average(),mapToObj().
- Using collection:
Stream < String > fromCollection = Arrays.asList ( " x " , " y " , " z " ).stream ();- Using set of values:
Stream < String > fromValues = Stream.of( " x " , " y " , " z " );- Using Array
Stream < String > fromArray = Arrays.stream( new String [] { " x " , " y " , " z " });- Using file (each line in the file will be a separate element in the stream):
Stream < String > fromFile = Files.lines( Paths.get(" input.txt "));- From the line:
IntStream fromString = " 0123456789 " . chars ();- With the help of
Stream.builder():
Stream < String > fromBuilder = Stream.builder().add (" z ").add(" y ").add(" z ").build ();- Using
Stream.iterate()(infinite):
Stream < Integer > fromIterate = Stream.iterate ( 1 , n - > n + 1 );- Using
Stream.generate()(infinite):
Stream < String > fromGenerate = Stream.generate(() -> " 0 " );Collections allow you to work with elements separately, while streams do not allow this, but instead provides the ability to perform functions on data as one.
A method collect()is the final operation that is used to represent the result as a collection or some other data structure.
collect()accepts an input that contains four stages:
- supplier — initialization of the battery,
- accumulator — processing of each element,
- combiner — connection of two accumulators in parallel execution,
- [finisher] —a non-mandatory method of the last processing of the accumulator.
In Java 8, the class Collectors implements several common collectors:
toList(),toCollection(),toSet()- present stream in the form of a list, collection or set;toConcurrentMap(),toMap()- allow you to convert the stream toMap;averagingInt(),averagingDouble(),averagingLong()- return the average value;summingInt(),summingDouble(),summingLong()- returns the sum;summarizingInt(),summarizingDouble(),summarizingLong()- return SummaryStatisticswith different values of the aggregate;partitioningBy()- divides the collection into two parts according to the condition and returns them asMap<Boolean, List>;groupingBy()- divides the collection into several parts and returnsMap<N, List<T>>;mapping()- Additional value conversions for complex Collectors.
There is also the possibility of creating your own collector through Collector.of():
Collector < String , a List < String > , a List < String > > toList = Collector.of (
ArrayList :: new ,
List :: add,
(l1, l2) -> {l1 . addAll (l2); return l1; }
);forEach()applies a function to each stream object; ordering in parallel execution is not guaranteed;forEachOrdered()applies a function to each stream object while maintaining the order of the elements.
The method map()is an intermediate operation, which transforms each element of the stream in a specified way.
mapToInt(), mapToDouble(), mapToLong()- analogues map(), returns the corresponding numerical stream (ie the stream of numerical primitives):
Stream
.of ( " 12 " , " 22 " , " 4 " , " 444 " , " 123 " )
.mapToInt ( Integer :: parseInt)
.toArray (); // [12, 22, 4, 444, 123]The method filter() is an intermediate operation receiving a predicate that filters all elements, returning only those that match the condition.
The method limit()is an intermediate operation, which allows you to limit the selection to a certain number of first elements.
The method sorted()is an intermediate operation, which allows you to sort the values either in natural order or by setting Comparator.
The order of the elements in the original collection remains untouched - sorted()it just creates its sorted representation.
The method flatMap() is similar to map, but can create several from one element. Thus, each object will be converted to zero, one or more other objects supported by the stream. The most obvious way to use this operation is to convert container elements using functions that return containers.
Stream
.of ( " Hello " , " world! " )
.flatMap ((p) -> Arrays.stream (p . split ( " , " )))
.toArray ( String [] :: new ); // ["H", "e", "l", "l", "o", "w", "o", "r", "l", "d", "!"]flatMapToInt(), flatMapToDouble(), flatMapToLong()- are analogues flatMap(), returns the corresponding numerical stream.
Streams can be sequential and parallel. Operations on sequential streams are performed in one processor thread, on parallel streams - using several processor threads. Parallel streams use the shared stream ForkJoinPoolthrough the static ForkJoinPool.commonPool()method. In this case, if the environment is not multi-core, then the stream will be executed as sequential. In fact, the use of parallel streams is reduced to the fact that the data in the streams will be divided into parts, each part is processed on a separate processor core, and in the end these parts are connected, and final operations are performed on them.
You can also use the parallelStream()interface method to create a parallel stream from the collection Collection.
To make a regular sequential stream parallel, you must call the Streammethod on the object parallel(). The method isParallel()allows you to find out if the stream is parallel.
Using, methods parallel()and sequential()it is possible to determine which operations can be parallel, and which only sequential. You can also make a parallel stream from any sequential stream and vice versa:
collection
.stream ()
.peek ( ... ) // operation is sequential
.parallel ()
.map ( ... ) // the operation can be performed in parallel,
.sequential ()
.reduce ( ... ) // operation is sequential againAs a rule, elements are transferred to the stream in the same order in which they are defined in the data source. When working with parallel streams, the system preserves the sequence of elements. An exception is a method forEach()that can output elements in random order. And in order to maintain the order, it is necessary to apply the method forEachOrdered().
- Criteria that may affect performance in parallel streams:
- Data size - the more data, the more difficult it is to separate the data first, and then combine them.
- The number of processor cores. Theoretically, the more cores in a computer, the faster the program will work. If the machine has one core, it makes no sense to use parallel threads.
- The simpler the data structure the stream works with, the faster operations will occur. For example, data from is
ArrayListeasy to use, since the structure of this collection assumes a sequence of unrelated data. But a type collectionLinkedListis not the best option, since in a sequential list all the elements are connected with previous / next. And such data is difficult to parallelize. - Operations with primitive types will be faster than with class objects.
- It is highly recommended that you do not use parallel streams for any long operations (for example, network connections), since all parallel streams work with one
ForkJoinPool, such long operations can stop all parallel streams in the JVM due to the lack of available threads in the pool, etc. e. parallel streams should be used only for short operations where the count goes for milliseconds, but not for those where the count can go for seconds and minutes; - Saving order in parallel streams increases execution costs, and if order is not important, it is possible to disable its saving and thereby increase productivity by using an intermediate operation
unordered():
collection.parallelStream ()
.sorted ()
.unordered ()
.collect ( Collectors . toList ());findFirst()returns the first elementfindAny()returns any suitable itemcollect()presentation of results in the form of collections and other data structurescount()returns the number of elementsanyMatch()returns trueif the condition is satisfied for at least one elementnoneMatch()returns trueif the condition is not satisfied for any elementallMatch()returns trueif the condition is satisfied for all elementsmin()returns the minimum element, using as a condition Comparatormax()returns the maximum element, using as a condition ComparatorforEach()applies a function to each object (order is not guaranteed in parallel execution)forEachOrdered()applies a function to each object while preserving the order of elementstoArray()returns an array of valuesreduce()allows you to perform aggregate functions and return a single result.sum()returns the sum of all numbersaverage()returns the arithmetic mean of all numbers.
filter()filters records, returning only records matching the condition;skip()allows you to skip a certain number of elements at the beginning;distinct()returns a stream without duplicates (for a methodequals());map()converts each element;peek()returns the same stream, applying a function to each element;limit()allows you to limit the selection to a certain number of first elements;sorted()allows you to sort values either in natural order or by settingComparator;mapToInt(),mapToDouble(),mapToLong()- analoguesmap()return stream numeric primitives;flatMap(),flatMapToInt(),flatMapToDouble(),flatMapToLong()- similar tomap(), but can create a single element more.
For numerical streams, an additional method is available mapToObj()that converts the numerical stream back to the object stream.
( new Random ())
.ints ()
.limit ( 10 )
.forEach ( System . out :: println);Stream
.of ( 1 , 2 , 3 , 2 , 1 )
.map (s -> s * s)
.distinct ()
.collect ( Collectors . toList ())
.forEach ( System . out :: println);System.out.println (
Stream
.of ( " Hello " , " " , " , " , " world " , " ! " )
.filter ( String :: isEmpty)
.count ());( new Random ())
.ints ()
.limit ( 10 )
.sorted ()
.forEach ( System . out :: println);Stream
.of ( 5 , 3 , 4 , 55 , 2 )
.mapToInt (a -> a)
.max ()
.getAsInt (); // 55Stream
.of ( 5 , 3 , 4 , 55 , 2 )
.mapToInt (a -> a)
.min ()
.getAsInt (); // 2Stream
.of( 5 , 3 , 4 , 55 , 2 )
.mapToInt()
.sum(); // 69Stream
.of ( 5 , 3 , 4 , 55 , 2 )
.mapToInt (a -> a)
.average ()
.getAsDouble (); // 13.8putIfAbsent()adds a key-value pair only if the key was missing:
map.putIfAbsent("a", "Aa");forEach()accepts a function that performs an operation on each element:
map.forEach((k, v) -> System.out.println(v));compute()creates or updates the current value to the result of the calculation (it is possible to use the key and the current value):
map.compute("a", (k, v) -> String.valueOf(k).concat(v)); //["a", "aAa"]computeIfPresent()if the key exists, updates the current value to the result of the calculation (it is possible to use the key and the current value):
map.computeIfPresent("a", (k, v) -> k.concat(v));computeIfAbsent()if the key is missing, creates it with the value that is calculated (it is possible to use the key):
map.computeIfAbsent("a", k -> "A".concat(k)); //["a","Aa"]getOrDefault()if there is no key, returns the passed value by default:
map.getOrDefault("a", "not found");merge()accepts a key, a value, and a function that combines the transmitted and current values. If there is no value under the specified key, then it writes the transmitted value there.
map.merge("a", "z", (value, newValue) -> value.concat(newValue)); //["a","Aaz"]LocalDateTimecombines together LocaleDateand LocalTimecontains the date and time in the calendar system ISO-8601 without reference to the time zone. Time is stored accurate to the nanosecond. It contains many convenient methods such as plusMinutes, plusHours, isAfter, toSecondOfDay, etc.
java.time.ZonedDateTime- an analogue java.util.Calendar, a class with the most complete amount of information about the temporary context in the calendar system ISO-8601. It includes a time zone, therefore, this class carries out all operations with time shifts taking into account it.
LocalDate as.now();LocalDate as.now ().plusWeeks ( 1 );
LocalDate as.now ().plusMonths ( 1 );
LocalDate as.now ().plusYears ( 1 );
LocalDate as.now ().plus ( 1 , ChronoUnit.DECADES );LocalDate as.now().with( TemporalAdjusters.next ( DayOfWeek.TUESDAY ));new Date ().toInstant ();LocalDate
.of ( LocalDate.Now ().GetYear (), LocalDate.Now ().GetMonth (), 1 )
.with ( TemporalAdjusters.nextOrSame ( DayOfWeek.SATURDAY ))
.with ( TemporalAdjusters.next ( DayOfWeek.SATURDAY ));LocalDateTime.ofInstant ( new Date().toInstant(), ZoneId.systemDefault());To define a repeatable annotation, you must create a container annotation for the list of repeatable annotations and designate a repeatable meta annotation @Repeatable:
@interface Schedulers {
Scheduler [] value ();
}
@Repeatable ( Schedulers . Class)
@interface Scheduler {
String birthday () default "Jan 8 2000";
}Nashorn is a JavaScript engine developed in Java by Oracle. Designed to provide the ability to embed JavaScript code in Java applications. Compared to Rhino , which is supported by the Mozilla Foundation, Nashorn provides 2 to 10 times better performance, as it compiles code and transfers bytecode to the Java virtual machine directly in memory. Nashorn can compile JavaScript code and generate Java classes that are loaded with a special loader. It is also possible to call Java code directly from JavaScript.
jjs - This is a command line utility that allows you to execute JavaScript programs directly in the console.
Base64- a thread-safe class that implements a data encoder and decoder using a base64 encoding scheme according to RFC 4648 and RFC 2045 .
Base64 contains 6 basic methods:
getEncoder() / getDecoder()- returns a base64 encoder / decoder conforming to the RFC 4648 standard ; getUrlEncoder()/ getUrlDecoder()- returns URL-safe base64 encoder / decoder conforming to RFC 4648 standard ;
getMimeEncoder() / getMimeDecoder()- returns a MIME encoder / decoder conforming to RFC 2045 .
// Encode
String b64 = Base64.getEncoder().encodeToString ( " input " . getBytes ( " utf-8 " )); // aW5wdXQ ==
// Decode
new String ( Base64.getDecoder().decode ( " aW5wdXQ == " ), " utf-8 " ); // inputQ. What are the functional interfaces Function<T,R>, DoubleFunction<R>, IntFunction<R> and LongFunction<R>?
Function<T, R>- the interface with which a function is implemented that receives an instance of the class T and returns an instance of the class at the output R.
Default methods can be used to build call chains ( compose, andThen).
Function < String , Integer > toInteger = Integer :: valueOf;
Function < String , String > backToString = toInteger.andThen ( String :: valueOf);
backToString.apply("123"); // "123"DoubleFunction<R>- a function that receives inputDoubleand returns an instance of the class at the outputR;IntFunction<R>- a function that receives inputIntegerand returns an instance of the class at the outputR;LongFunction<R>- a function that receives inputLongand returns an instance of the class at the outputR.
Q. What are the functional interfaces UnaryOperator<T>, DoubleUnaryOperator, IntUnaryOperatorand LongUnaryOperator?
UnaryOperator<T>(unary operator) takes an object of type as a parameter T, performs operations on them and returns the result of operations in the form of an object of type T:
UnaryOperator < Integer > operator = x - > x * x;
System.out.println(operator.apply ( 5 )); // 25DoubleUnaryOperator- unary operator receiving inputDouble;IntUnaryOperator- unary operator receiving inputInteger;LongUnaryOperator- unary operator receiving inputLong.
Q. What are the functional interfaces BinaryOperator<T>, DoubleBinaryOperator, IntBinaryOperatorand LongBinaryOperator?
BinaryOperator<T>(binary operator) - an interface through which a function is implemented that receives two instances of the class Tand returns an instance of the class at the output T.
BinaryOperator < Integer > operator = (a, b) -> a + b;
System.out.println(operator.apply ( 1 , 2 )); // 3DoubleBinaryOperator- binary operator receiving input Double;IntBinaryOperator- binary operator receiving input Integer;LongBinaryOperator- binary operator receiving input Long.
Predicate<T>(predicate) - the interface with which a function is implemented that receives an instance of the class as input Tand returns the type value at the output boolean.
The interface contains a variety of methods by default, allow to build complex conditions ( and, or, negate).
Predicate < String > predicate = (s) -> s.length () > 0 ;
predicate.test("foo"); // true
predicate.negate().test("foo"); // falseDoublePredicate- predicate receiving inputDouble;IntPredicate- predicate receiving inputInteger;LongPredicate- predicate receiving inputLong.
Consumer<T>(consumer) - the interface through which a function is implemented that receives an instance of the class as an input T, performs some action with it, and returns nothing.
Consumer<String> hello = (name) -> System.out.println( " Hello, " + name);
hello.accept( " world " );DoubleConsumer- the consumer receiving the inputDouble;IntConsumer- the consumer receiving the inputInteger;LongConsumer- the consumer receiving the inputLong.
Q. What are the functional interfaces Supplier<T>, BooleanSupplier, DoubleSupplier, IntSupplierand LongSupplier?
Supplier<T>(provider) - the interface through which a function is implemented that takes nothing to the input, but returns the result of the class to the output T;
Supplier < LocalDateTime > now = LocalDateTime::now;
now.get();DoubleSupplier- the supplier is returningDouble;IntSupplier- the supplier is returningInteger;LongSupplier- the supplier is returningLong.