package com.sk.demos;
import java.util.function.Predicate;
public class JoiningPredicates {
public static void main(String[] args) {
int a[] = { 0, 5, 10, 15, 12, 20, 25, 30 };
//1st predicate will check number is number even or not
//2nd predicate will check number>10
Predicate<Integer> p1 = e -> e % 2 == 0;
Predicate<Integer> p2 = e -> e > 10;
for (Integer intCheck : a) {
if (p1.and(p2).test(intCheck)) {
System.out.println(intCheck);
}
}
}
}
package com.sk.demos;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
public class StreamApiTesting {
public static void main(String[] args) {
String s="vikatakavi";
// Using Stream API to remove duplicates
String removeDuplicates = s.chars() // Convert string to IntStream (ASCII values)
.distinct() // Remove duplicates
.mapToObj(c -> String.valueOf((char) c)) // Convert back to characters
.collect(Collectors.joining()); // Collect into a single string
// Properly formatted output
System.out.println("Removed duplicates from string: " + removeDuplicates);
}
}
Output:
===============
Remove duplicates from string: vikat
Stream API is a newly added feature to the Collections API in Java 8. A stream represents a sequence of elements and supports different operations (Filter, Sort, Map, and Collect) from a collection. Stream API in Java is a toolset for processing sequences of elements in a functional programming style.
package com.sk.demos;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
public class StreamApiTesting {
public static void main(String[] args) {
List<String> list = Arrays.asList("sk", "kr", "ar", "an", "ch", "ra");
System.out.println("Stream api tesing for this list...." + list);
List<String> filterList = list.stream().filter(p -> p.equals("an")).collect(Collectors.toList());
System.out.println("using filter with stream api");
System.out.println(filterList);
System.out.println("========================");
List<String> mapList = list.stream().map(i -> i.equals("sk") ? (String) "SureshK" : (String) i)
.collect(Collectors.toList());
System.out.println("using map with stream api");
System.out.println(mapList);
System.out.println("========================");
List<Student> listStd = Arrays.asList(new Student("ravi", 1, 60), new Student("suri", 2, 80),
new Student("kavi", 3, 90), new Student("mani", 4, 50), new Student("suvi", 5, 70));
Optional<Student> listStd1 = listStd.stream().max(Comparator.comparing(Student::getMarks));
System.out.println(listStd1.get());
// Sorting students by marks in ascending order
List<Student> sortedByMarksAsc = listStd.stream().sorted(Comparator.comparingInt(Student::getMarks))
.collect(Collectors.toList());
System.out.println("Students sorted by marks (ascending):" + sortedByMarksAsc);
List<Student> sortedByMarksDesc = listStd.stream()
.sorted((s1, s2) -> Integer.compare(s2.getMarks(), s1.getMarks())) // Reverse the order for descending
.collect(Collectors.toList());
System.out.println("Students sorted by marks (descending):" + sortedByMarksDesc);
}
}
Output:
===============
Stream api tesing for this list....[sk, kr, ar, an, ch, ra]
using filter with stream api
[an]
========================
using map with stream api
[SureshK, kr, ar, an, ch, ra]
========================
Student [studenName=kavi, studentId=3, marks=90]
Students sorted by marks (ascending):[Student [studenName=mani, studentId=4, marks=50], Student [studenName=ravi, studentId=1, marks=60], Student [studenName=suvi, studentId=5, marks=70], Student [studenName=suri, studentId=2, marks=80], Student [studenName=kavi, studentId=3, marks=90]]
Students sorted by marks (descending):[Student [studenName=kavi, studentId=3, marks=90], Student [studenName=suri, studentId=2, marks=80], Student [studenName=suvi, studentId=5, marks=70], Student [studenName=ravi, studentId=1, marks=60], Student [studenName=mani, studentId=4, marks=50]]
import java.util.*;
import java.util.stream.*;
public class SortListDescending {
public static void main(String[] args) {
// Sample list of strings
List<String> list = Arrays.asList("Su", "Anu", "Aru", "kris");
List<String> sortedList = list.stream()
.sorted(Comparator.reverseOrder()) // Sort using reverse order (descending)
.collect(Collectors.toList()); // Collect the sorted elements into a list
// Output the sorted list
System.out.println(sortedList);
}
}
Output:
[kris, Su, Aru, Anu]
import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;
class StreamApiTesting{
public static void main(String[] args) {
System.out.println("Stream api start here....");
System.out.println("************************");
String s = "Anushaaaha";
// Using Stream API to remove duplicates
String result = s.chars() // Convert the string to an IntStream of characters
.mapToObj(c -> (char) c) // Convert each int to a Character object
.distinct() // Remove duplicate characters
.map(String::valueOf) // Convert characters back to String
.collect(Collectors.joining());
System.out.println("Stream using filter removing dublicates::"+result);
System.out.println("==========================");
List<String> list = Arrays.asList("Su","Anu","Aru","kris");
System.out.println("list of elements::"+list);
List filterList= list.stream().filter(i->i.equals("Su")).collect(Collectors.toList());
System.out.println("using filters::"+filterList);
System.out.println("==========================");
List mapList= list.stream().map(f->f.equals("Su")?"suresh":f).collect(Collectors.toList());
System.out.println("using map::"+mapList);
System.out.println("==========================");
// Sorting the list using Stream API with a custom Comparator
List<String> sortedList = list.stream()
.sorted(Comparator.naturalOrder()) // Sort using natural order (alphabetical)
.collect(Collectors.toList()); // Collect the sorted elements into a list
System.out.println("using sort::"+sortedList);
System.out.println("==========================");
}
}
Output:
========
Stream api start here....
************************
Stream using filter removing dublicates::Anusha
==========================
list of elements::[Su, Anu, Aru, kris]
using filters::[Su]
==========================
using map::[suresh, Anu, Aru, kris]
==========================
using sort::[Anu, Aru, Su, kris]
==========================
The Singleton pattern is a creational design pattern that ensures that only one instance of a class can be created and that the same instance is used every time the object is requested.
class Singleton {
// Static variable reference of single_instance
// of type Singleton
private static Singleton single_instance = null;
// Declaring a variable of type String
public String s;
// Constructor
// Here we will be creating private constructor
// restricted to this class itself
private Singleton()
{
s = "Hello I am a string part of Singleton class";
}
// Static method
// Static method to create instance of Singleton class
public static synchronized Singleton getInstance()
{
if (single_instance == null)
single_instance = new Singleton();
return single_instance;
}
}
// Class 2
// Main class
class TestingSinglTon {
// Main driver method
public static void main(String args[])
{
// Instantiating Singleton class with variable x
Singleton x = Singleton.getInstance();
// Instantiating Singleton class with variable y
Singleton y = Singleton.getInstance();
// Instantiating Singleton class with variable z
Singleton z = Singleton.getInstance();
// Printing the hash code for above variable as
// declared
System.out.println("Hashcode of x is " + x.hashCode());
System.out.println("Hashcode of y is "+ y.hashCode());
System.out.println("Hashcode of z is "+ z.hashCode());
// Condition check
if (x == y && y == z) {
// Print statement
System.out.println(
"Three objects point to the same memory location on the heap i.e, to the same object");
} else {
// Print statement
System.out.println(
"Three objects DO NOT point to the same memory location on the heap");
}
}
}
Output:
====================================
Hashcode of x is 558638686
Hashcode of y is 558638686
Hashcode of z is 558638686
Three objects point to the same memory location on the heap i.e, to the same object
