Add files via upload

Author: gowthamrajk

StreamCollectors/CollectStreamElementsToArray.java

@@ -0,0 +1,19 @@
+package StreamCollectors;
+
+import java.util.Arrays;
+import java.util.stream.Stream;
+import java.util.List;
+
+public class CollectStreamElementsToArray 
+{
+	public static void main(String[] args) 
+	{
+		List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
+		Stream<Integer> stream = list.stream();
+        Integer[] evenNumbersArr = stream.filter(i -> i%2 == 0).toArray(Integer[]::new);
+        for(Integer num:evenNumbersArr)
+        {
+        	System.out.print(num+" ");
+        }
+	}
+}

StreamCollectors/CollectStreamElementsToMap.java

@@ -0,0 +1,62 @@
+package StreamCollectors;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+class Student
+{
+	private int ID;
+	private String Name;
+	Student(int ID,String Name)
+	{
+		this.ID=ID;
+		this.Name=Name;
+	}
+	public int getID() 
+	{
+		return ID;
+	}
+	public void setID(int iD)
+	{
+		ID = iD;
+	}
+	public String getName() 
+	{
+		return Name;
+	}
+	public void setName(String name) 
+	{
+		Name = name;
+	}
+}
+
+public class CollectStreamElementsToMap 
+{
+	public static void main(String[] args) 
+	{
+		Stream<Student> stream = Stream.of(new Student(1,"Ram"),new Student(2,"Arjun"),new Student(3,"Kavi"),new Student(4,"Sanju"),new Student(5,"Ajay"));
+		Map<Integer,String> map = stream.collect(Collectors.toMap(Student::getID,Student::getName));
+		
+		System.out.println("Original Value:");
+		for(Map.Entry<Integer,String> m:map.entrySet())
+		{
+			System.out.println(m.getKey()+" "+m.getValue());
+		}
+		
+		//sort map based on key
+		Map<Integer,String> result1 = new LinkedHashMap<>();
+        map.entrySet().stream()
+                .sorted(Map.Entry.comparingByKey())
+                .forEachOrdered(x -> result1.put(x.getKey(), x.getValue()));
+		System.out.println("Sort By Key:" + result1);
+		
+		//sort map based on Value
+		Map<Integer,String> result2 = new LinkedHashMap<>();
+		map.entrySet().stream()
+                .sorted(Map.Entry.comparingByValue())
+                .forEachOrdered(x -> result2.put(x.getKey(), x.getValue()));
+		System.out.println("Sort By Value:" + result2);
+	}
+}

StreamCollectors/CollectStreamElementsToSet.java

@@ -0,0 +1,47 @@
+package StreamCollectors;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.LinkedHashSet;
+import java.util.HashSet;
+import java.util.TreeSet;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+
+public class CollectStreamElementsToSet 
+{
+	public static void main(String[] args)
+	{
+		
+		//convert stream to set
+		List<Integer> list = Arrays.asList(1,2,3,4,5,4,5,8,9,10);
+		Stream<Integer> stream = list.stream();
+        
+		Set<Integer> set = stream.collect(Collectors.toSet());
+        System.out.println(set);
+        
+        //convert stream to an array and them array into set
+        List<Integer> list1 = Arrays.asList(1,2,4,3,5,4,5,8,8,7);
+		Stream<Integer> stream1 = list1.stream();
+		
+		Integer[] arr = stream1.toArray(Integer[]::new);
+		
+		//random order set
+		Set<Integer> set1 = new HashSet<>();
+		Collections.addAll(set1, arr);
+		System.out.println(set1);
+		
+		//insertion order set
+		Set<Integer> set2 = new LinkedHashSet<>();
+		Collections.addAll(set2, arr);
+		System.out.println(set2);
+		
+		//sorted order set
+		Set<Integer> set3 = new TreeSet<>();
+		Collections.addAll(set3, arr);
+		System.out.println(set3);
+	}
+}

StreamCollectors/CollectsreamElementsToList.java

@@ -0,0 +1,18 @@
+package StreamCollectors;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Stream;
+import java.util.stream.Collectors;
+
+public class CollectsreamElementsToList 
+{
+	public static void main(String[] args)
+	{
+		List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
+		Stream<Integer> stream = list.stream();
+
+		List<Integer> evenNumbersList = stream.collect(Collectors.toList());
+        System.out.print(evenNumbersList);
+	}
+}

StreamCollectors/SortingStream.java

@@ -0,0 +1,25 @@
+package StreamCollectors;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import java.util.stream.Stream;
+
+public class SortingStream 
+{
+	public static void main(String[] args) 
+	{
+		//convert stream into set
+		List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
+		Stream<Integer> stream1 = list.stream();
+		Stream<Integer> stream2 = list.stream();
+        
+        //ascending sort
+		stream1.sorted().forEach(e -> System.out.print(e+" "));
+		System.out.println();
+		
+		//descending sort
+		stream2.sorted(Comparator.reverseOrder()).forEach(e -> System.out.print(e+" "));
+		System.out.println();
+	}
+}

StreamExamples/DistinctByKeys.java

@@ -0,0 +1,34 @@
+package StreamExamples;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import StudentClass.Student;
+
+public class DistinctByKeys
+{
+	public static void main(String[] args)
+	{
+		 Stream.of(new Student(1,"Ram"),new Student(2,"Arjun"),new Student(3,"Kavi"),new Student(4,"Sanju"),new Student(5,"Ajay"))
+                .filter(distinctByKeys(Student::getID, Student::getName))
+                .collect(Collectors.toList()).forEach(System.out::println);
+         System.out.println();
+	}
+	
+	private static <T> Predicate<T> distinctByKeys(Function<? super T, ?>... keyExtractors) 
+	{
+	    final Map<List<?>, Boolean> seen = new ConcurrentHashMap<>();
+	    return t -> 
+	    {
+	      final List<?> keys = Arrays.stream(keyExtractors)
+	                  .map(ke -> ke.apply(t))
+	                  .collect(Collectors.toList());
+	      return seen.putIfAbsent(keys, Boolean.TRUE) == null;
+	    };
+	}
+}

StreamExamples/DistinctByMultipleProperties.java

@@ -0,0 +1,27 @@
+package StreamExamples;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import StudentClass.CustomKey;
+import StudentClass.Student;
+
+public class DistinctByMultipleProperties
+{
+	public static void main(String[] args) 
+	{
+        Stream.of(new Student(1,"Ram"),new Student(2,"Arjun"),new Student(3,"Kavi"),new Student(4,"Sanju"),new Student(5,"Ajay"))
+	              .filter(distinctByKey(CustomKey::new))
+	              .collect(Collectors.toList()).forEach(System.out::println);
+        System.out.println();
+        
+	 }
+	 public static <T> Predicate<T> distinctByKey(Function<? super T, Object> keyExtractor) 
+	 {
+	     Map<Object, Boolean> seen = new ConcurrentHashMap<>();
+	     return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
+	 }
+}

StreamExamples/FindLastElement.java

@@ -0,0 +1,24 @@
+package StreamExamples;
+
+import java.util.Arrays;
+import java.util.stream.Stream;
+
+public class FindLastElement 
+{
+	public static void main(String[] args)
+	{
+		
+		//using stream.reduce()
+		Stream<Integer> stream1 = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9).stream();
+        Integer lastElement1 = stream1.reduce((first, second) -> second).orElse(-1);
+        System.out.println(lastElement1); 
+        
+        //or
+        
+        Stream<Integer> emptyStream = Stream.empty(); 
+        Integer lastElement2 = emptyStream.reduce((first, second) -> second)
+                        .orElseThrow(() -> new IllegalStateException("no last element"));
+        System.out.println(lastElement2); 
+        
+	}
+}

StreamExamples/FixedLengthStream.java

@@ -0,0 +1,17 @@
+package StreamExamples;
+
+import java.util.stream.Stream;
+
+public class FixedLengthStream 
+{
+	public static void main(String[] args)
+	{
+		Stream.Builder<Integer> streamBuilder = Stream.builder();
+	    streamBuilder.accept(1);
+	    streamBuilder.accept(2);
+	    streamBuilder.accept(3);
+	    streamBuilder.accept(4);
+	    streamBuilder.accept(5);
+	    streamBuilder.build().forEach(e->System.out.print(e+" ")); 
+	}
+}

StreamExamples/InfiniteStream.java

@@ -0,0 +1,27 @@
+package StreamExamples;
+
+import java.util.List;
+import java.util.Random;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import StudentClass.Student;
+
+public class InfiniteStream 
+{
+	public static void main(String[] args) 
+	{
+		
+		//Infinite stream of random numbers
+		List<Integer> randomNumbers = Stream.generate(() -> (new Random()).nextInt(100))
+                .limit(10).collect(Collectors.toList());
+        System.out.println(randomNumbers);
+        
+        //infinite stream of Custom Objects
+        List<Student> students = Stream.generate(Student::create)
+                .limit(5).collect(Collectors.toList());
+        for(Student student:students)
+        {
+        	System.out.println("Student ID : "+student.getID()+" , Student Name : "+student.getName());
+        }
+	}
+}

StreamExamples/IntPredicateExamples.java

@@ -0,0 +1,43 @@
+package StreamExamples;
+
+import java.util.function.IntPredicate;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class IntPredicateExamples
+{
+	public static void main(String[] args)
+	{
+	
+		//Java IntPredicate interface is a predicate of one int-valued argument. 
+		//It can be considered an operator or function that returns a value either true or false based on certain evaluation on the argument int value.
+        //IntPredicate is a functional interface whose functional method is boolean test(int a).
+		
+		IntPredicate isOdd = argument -> argument % 2 == 1;
+		 
+		
+        //Use predicate directly
+        System.out.println(isOdd.test(9));    //true
+        System.out.println(isOdd.test(10));   //false
+         
+        
+        //Use predicate in filters
+        IntStream.range(1, 10).filter(isOdd).boxed()
+                   .collect(Collectors.toList()).forEach(e->System.out.print(e+" "));
+        System.out.println();
+        
+        
+        //complex IntPredicate -> using logical AND, OR, etc...
+        IntPredicate isOddNumber = argument -> argument % 2 == 1;
+        IntStream.range(1, 20).filter(isOddNumber.and(IntPredicateExamples::isPrime))
+                 .boxed()
+                 .collect(Collectors.toList()).forEach(e->System.out.print(e+" "));
+        
+	}
+	
+	public static boolean isPrime(int i) 
+    {
+        IntPredicate isDivisible = index -> i % index == 0;
+        return i > 1 && IntStream.range(2, i).noneMatch(isDivisible);
+    }
+}