Java 8 - Revision history

Rasimsen at 15:20, 19 October 2018

2018-10-19T15:20:29Z

Rasimsen: /* Predicate */

2018-10-05T14:54:08Z

‎Predicate

Show changes

Rasimsen at 16:55, 11 August 2018

2018-08-11T16:55:06Z

Rasimsen at 16:54, 11 August 2018

2018-08-11T16:54:14Z

Rasimsen at 17:26, 23 July 2018

2018-07-23T17:26:03Z

Rasimsen: /* Functional Interfaces In Java */

2018-07-13T20:44:03Z

‎Functional Interfaces In Java

Rasimsen: /* Functional Interfaces In Java */

2018-07-13T20:28:45Z

‎Functional Interfaces In Java

Rasimsen: /* StreamAPI - Parallelism */

2018-07-13T13:44:26Z

‎StreamAPI - Parallelism

Rasimsen at 13:27, 13 July 2018

2018-07-13T13:27:26Z

Rasimsen: /* StreamAPI - Parallelism */

2018-07-11T16:03:58Z

‎StreamAPI - Parallelism

← Older revision		Revision as of 15:20, 19 October 2018
Line 1:		Line 1:
		+	<source>
		+	@FunctionalInterface :
		+	- Consumer<T> : no return value. accept(void), andThen(default)
		+	- Function<T,R> : it returns value, R apply(T t); // t-> r
		+	- Predicate<T> : it returns true/false. boolean test(T t);
		+	- Supplier<T> : no parameter. supplier.get();
		+
		+	CompletableFuture - Asenkron yapilar / threads
		+
		+	System.out::println : Obje::statikMetot seklinde kullanim metot referans ornegi
		+	</source>
		+
	==What are the new features introduced in JAVA 8?==		==What are the new features introduced in JAVA 8?==
	There are dozens of features added to Java 8, the most significant ones are mentioned below −		There are dozens of features added to Java 8, the most significant ones are mentioned below −

@@ Line 602: / Line 602: @@
-===Java Type Inference===
+==Java Type Inference==
 Type inference is a feature of Java which provides ability to compiler to look at each method invocation and corresponding declaration to determine the type of arguments.
@@ Line 620: / Line 620: @@
 </source>
-====Improved Type Inference====
+===Improved Type Inference===
 In Java 8, you can call specialized method without explicitly mentioning of type of arguments.
 <source>
@@ Line 626: / Line 626: @@
 </source>
-====Java Type Inference Example====
+===Java Type Inference Example===
 You can use type inference with generic classes and methods.

← Older revision		Revision as of 16:54, 11 August 2018
Line 600:		Line 600:

	https://www.logicbig.com/tutorials/core-java-tutorial/java-util-stream/side-effects.html		https://www.logicbig.com/tutorials/core-java-tutorial/java-util-stream/side-effects.html
		+
		+
		+	===Java Type Inference===
		+
		+	Type inference is a feature of Java which provides ability to compiler to look at each method invocation and corresponding declaration to determine the type of arguments.
		+
		+	Java provides improved version of type inference in Java 8. the following example explains, how we can use type inference in our code:
		+
		+	Here, we are creating arraylist by mentioning integer type explicitly at both side. The following approach is used earlier versions of Java.
		+
		+	<source>
		+	List<Integer> list = new ArrayList<Integer>();
		+	</source>
		+
		+	In the following declaration, we are mentioning type of arraylist at one side. This approach was introduce in Java 7. Here, you can left second side as blank diamond and compiler will infer type of it by type of reference variable.
		+
		+	<source>
		+	List<Integer> list2 = new ArrayList<>();
		+	</source>
		+
		+	====Improved Type Inference====
		+	In Java 8, you can call specialized method without explicitly mentioning of type of arguments.
		+	<source>
		+	showList(new ArrayList<>());
		+	</source>
		+
		+	====Java Type Inference Example====
		+	You can use type inference with generic classes and methods.
		+
		+	<syntaxhighlight lang="java">
		+	import java.util.ArrayList;
		+	import java.util.List;
		+	public class TypeInferenceExample {
		+	public static void showList(List<Integer>list){
		+	if(!list.isEmpty()){
		+	list.forEach(System.out::println);
		+	}else System.out.println("list is empty");
		+	}
		+	public static void main(String[] args) {
		+	// An old approach(prior to Java 7) to create a list
		+	List<Integer> list1 = new ArrayList<Integer>();
		+	list1.add(11);
		+	showList(list1);
		+	// Java 7
		+	List<Integer> list2 = new ArrayList<>(); // You can left it blank, compiler can infer type
		+	list2.add(12);
		+	showList(list2);
		+	// Compiler infers type of ArrayList, in Java 8
		+	showList(new ArrayList<>());
		+	}
		+	}
		+	</syntaxhighlight>
		+
		+	Output:
		+
		+	<source>
		+	11
		+	12
		+	list is empty
		+	</source>
		+
		+	You can also create your own custom generic class and methods. In the following example, we are creating our own generic class and method.
		+
		+	Java Type Inference Example 2
		+
		+	<syntaxhighlight lang="java">
		+	class GenericClass<X> {
		+	X name;
		+	public void setName(X name){
		+	this.name = name;
		+	}
		+	public X getName(){
		+	returnname;
		+	}
		+	public String genericMethod(GenericClass<String> x){
		+	x.setName("John");
		+	returnx.name;
		+	}
		+	}
		+
		+	public class TypeInferenceExample {
		+	public static void main(String[] args) {
		+	GenericClass<String> genericClass = new GenericClass<String>();
		+	genericClass.setName("Peter");
		+	System.out.println(genericClass.getName());
		+
		+	GenericClass<String> genericClass2 = new GenericClass<>();
		+	genericClass2.setName("peter");
		+	System.out.println(genericClass2.getName());
		+
		+	// New improved type inference
		+	System.out.println(genericClass2.genericMethod(new GenericClass<>()));
		+	}
		+	}
		+	</syntaxhighlight>
		+
		+	Output:
		+
		+	<source>
		+	Peter
		+	peter
		+	John
		+	</source>
		+

	==Java with Questions==		==Java with Questions==

← Older revision		Revision as of 17:26, 23 July 2018
Line 12:		Line 12:

	Along with these new featuers, lots of feature enhancements are done under-the-hood, at both compiler and JVM level.		Along with these new featuers, lots of feature enhancements are done under-the-hood, at both compiler and JVM level.
		+
		+	==Java 8 & Dependency Injection/Annotation Enhancement==
		+	===TYPE ANNOTATIONS===
		+	The place for an annnotation before Java 8 is only before a declaration.
		+	In Java 8, '''the place for an annotation could be where a type is used'''. This kind of annotation is often called '''type annotation'''. For example, you can '''annotate the return type of a method''', '''generic types''', '''including generic type parameter bounds''' and '''generic type arguments'''.
		+	Type annotations are important because they enhance Java type system and enable tools to perform additional checks on type systems to help prevent errors during compilation.
		+
		+
		+	A type annotation must include ElementType.TYPE_USE or ElementType.TYPE_PARAM as a target. An example to declare type annotation is:
		+	<source>
		+	@Target(ElementType.TYPE_USE)
		+	@interface typeAnnotation { ... }
		+	</source>
		+	When applying typeAnnotation, it must be placed before the type annotated.
		+	<source>
		+	void method() throws @typeAnnotation NullPointerException {...}
		+	</source>
		+	An example for annotation of type parameter is
		+	<source>
		+	@Target(ElementType.TYPE_PARAMETER)
		+	@interface typeParameterAnnotation { ... }
		+	</source>
		+
		+	Now typeParameterAnnotation can apply to a type parameter:
		+	<source>
		+	class typeAnnotationClass<@typeParameterAnnotation T> {...}
		+	</source>
		+
		+	===REPEATABLE ANNOTATIONS===
		+	Java 8 also provides a new annotation feature, which enables an annotation to be repeated on the same element. This is called repeatable annotations and must be annotated with the @Repeatable annotation defined in java.lang.annotation. Its value field specifies the container type for the repeatable annotation. The container is specified as an annotation for which the value field is an array of the repeatable annotation type. An example of a repeatable annotation is:
		+
		+	<syntaxhighlight lang="java">
		+	@Repeatable(myRepeatedAnnotations.class)
		+	@interface myAnnotation {
		+	String str();
		+	int val();
		+	}
		+	// container annotation.
		+	@Retention(RetentionPolicy.RUNTIME)
		+	@interface myRepeatedAnnotations {
		+	myAnnotation[] value();
		+	}
		+	class repeatAnnotation {
		+	@myAnnotation(str = "First", val = 1)
		+	@myAnnotation(str = "Second", val = 2)
		+	public static void method() {}
		+	}
		+	</syntaxhighlight>
		+	To retrieve the value of repeated myAnnotation, we must first retrieve the container annotation myRepeatedAnnotations, and then extract each repeated annotation from its value array.
		+
		+	===FUNCTIONAL INTERFACE ANNOTATION===
		+	Java 8 addsa new general purpose built-in annotation @FunctionalInterface, which is an informative annotation type used to indicate that an interface type declaration is intended to be a functional interface, that is, an interface only has single abstract method. An example using @FunctionalInterface is:
		+
		+	<syntaxhighlight lang="java">
		+	@FunctionalInterface
		+	public interface myFunctionalInterface{
		+	void myFunction();
		+	}
		+	</syntaxhighlight>
		+

	==Functional Interfaces In Java==		==Functional Interfaces In Java==

@@ Line 146: / Line 146: @@
 Geek2
 </source>
 '''Important Points/Observations:'''

← Older revision		Revision as of 20:28, 13 July 2018
Line 41:		Line 41:
	</syntaxhighlight>		</syntaxhighlight>

		+	===@FunctionalInterface Annotation===
		+
		+	@FunctionalInterface annotation is used to ensure that the functional interface can’t have more than one abstract method. In case more than one abstract methods are present, the compiler flags an ‘Unexpected @FunctionalInterface annotation’ message. However, it is not mandatory to use this annotation.
		+
		+
		+	<syntaxhighlight lang="java">
		+	// Java program to demonstrate lamda expressions to implement
		+	// a user defined functional interface.
		+
		+	@FunctionalInterface
		+	interface Square
		+	{
		+	int calculate(int x);
		+	}
		+
		+	class Test
		+	{
		+	public static void main(String args[])
		+	{
		+	int a = 5;
		+
		+	// lambda expression to define the calculate method
		+	Square s = (int x)->x*x;
		+
		+	// parameter passed and return type must be
		+	// same as defined in the prototype
		+	int ans = s.calculate(a);
		+	System.out.println(ans);
		+	}
		+	}
		+	</syntaxhighlight>
		+
		+	Output:
		+
		+	<source>
		+	25
		+	</source>
		+
		+	===java.util.function Package:===
		+	The java.util.function package in Java 8 contains many builtin functional interfaces like:
		+	====Predicate====
		+	The Predicate interface has an abstract method test which gives a Boolean value as a result for the specified argument. Its prototype is
		+
		+	<syntaxhighlight lang="java">
		+	public Predicate
		+	{
		+	public boolean test(T t);
		+	}
		+	</syntaxhighlight>
		+
		+	====BinaryOperator====
		+	The BinaryOperator interface has an abstract method apply which takes two argument and returns a result of same type. Its prototype is
		+
		+	<syntaxhighlight lang="java">
		+	public interface BinaryOperator
		+	{
		+	public T apply(T x, T y);
		+	}
		+	</syntaxhighlight>
		+
		+	====Function====
		+	The Function interface has an abstract method apply which takes argument of type T and returns a result of type R. Its prototype is
		+	<syntaxhighlight lang="java">
		+	public interface Function
		+	{
		+	public R apply(T t);
		+	}
		+	</syntaxhighlight>
		+
		+	A simple program to demonstrate the use of '''predicate interface'''
		+
		+	<syntaxhighlight lang="java">
		+	import java.util.*;
		+	import java.util.function.Predicate;
		+
		+	class Test
		+	{
		+	public static void main(String args[])
		+	{
		+
		+	// create a list of strings
		+	List<String> names =
		+	Arrays.asList("Geek","GeeksQuiz","g1","QA","Geek2");
		+
		+	// declare the predicate type as string and use
		+	// lambda expression to create object
		+	Predicate<String> p = (s)->s.startsWith("G");
		+
		+	// Iterate through the list
		+	for (String st:names)
		+	{
		+	// call the test method
		+	if (p.test(st))
		+	System.out.println(st);
		+	}
		+	}
		+	}
		+	</syntaxhighlight>
		+
		+	Output:
		+	<source>
		+	Geek
		+	GeeksQuiz
		+	Geek2
		+	</source>
		+
		+	'''Important Points/Observations:'''
		+	*A functional interface has only one abstract method but it can have multiple default methods.
		+	*@FunctionalInterface annotation is used to ensure an interface can’t have more than one abstract method. The use of this annotation is optional.
		+	*The java.util.function package contains many builtin functional interfaces in Java 8.

	==[[StreamAPI - Parallelism]]==		==[[StreamAPI - Parallelism]]==

← Older revision		Revision as of 13:44, 13 July 2018
Line 43:		Line 43:

	==[[StreamAPI - Parallelism]]==		==[[StreamAPI - Parallelism]]==
		+
		+	'''Stream source''' : Streams can be ceated from Collections, Lists, Sets, ints, longs, doubles, lines of a file.
		+
		+	Stream operation are either intermediate or terminal.
		+
		+	===Intermediate Operations===
		+	Intermediate Operations such as filter, map, sort return a stream so we can chain multiple intermediate operations.
		+	*anyMatch()
		+	*distinct()
		+	*filter()
		+	*findFirst()
		+	*FlatMap()
		+	*map()
		+	*skip()
		+	*sorted()
		+
		+	notes:
		+	*'''Zero or more intermediate operations are allowed'''.
		+
		+	*Order matters for large datasets: '''filter first, then sort or map'''
		+
		+	*for very large datasets use '''ParallelStream to enable multiple threads'''
		+
		+
		+	===Terminal Operations===
		+	Terminal Operations such as forEach, collect or reduce are either void or return a non-stream result.
		+
		+	*one terminal operation is allowed
		+	*forEach applies the same function to each element
		+	*collect saves the elements into a Collection
		+	*other options reduce the stream to a single summary element
		+	** count()
		+	** max()
		+	** min()
		+	** reduce()
		+	** summaryStatistics()
		+
		+
		+	===Parallelism===
		+
	Parallel computing involves dividing a problem into subproblems, solving those problems simultaneously (in parallel, with each subproblem running in a separate thread), and then combining the results of the solutions to the subproblems.		Parallel computing involves dividing a problem into subproblems, solving those problems simultaneously (in parallel, with each subproblem running in a separate thread), and then combining the results of the solutions to the subproblems.

← Older revision		Revision as of 13:27, 13 July 2018
Line 12:		Line 12:

	Along with these new featuers, lots of feature enhancements are done under-the-hood, at both compiler and JVM level.		Along with these new featuers, lots of feature enhancements are done under-the-hood, at both compiler and JVM level.
		+
		+	==Functional Interfaces In Java==
		+	Any interface with a SAM('''Single Abstract Method''') is a functional interface.
		+
		+	'''A functional interface is an interface that contains only one abstract method'''. They can have only one functionality to exhibit. From Java 8 onwards, '''lambda expressions can be used to represent the instance of a functional interface'''.
		+
		+	'''A functional interface can have any number of default methods'''. '''Runnable''', '''ActionListener''', '''Comparable''' are some of the examples of functional interfaces.
		+	Before Java 8, we had to create anonymous inner class objects or implement these interfaces.
		+
		+	<syntaxhighlight lang="java">
		+	// Java program to demonstrate functional interface
		+
		+	class Test
		+	{
		+	public static void main(String args[])
		+	{
		+	// create anonymous inner class object
		+	new Thread(new Runnable()
		+	{
		+	@Override
		+	public void run()
		+	{
		+	System.out.println("New thread created");
		+	}
		+	}).start();
		+	}
		+	}
		+	</syntaxhighlight>
		+

	==[[StreamAPI - Parallelism]]==		==[[StreamAPI - Parallelism]]==

@@ Line 194: / Line 194: @@
 ====Laziness====
 ====Stateful Lambda Expressions====
 ==Java with Questions==