Joining two predicates in stream API using filters

 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);

}

}

}

}

output:

===========

12

20

30

How to remove duplicates in given string? how to Remove duplicates from String using Stream API?

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

What is Stream API in java8

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.

Java 8 Features - Steam API Filter | MAP | Sort methods examples

 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]]

Stream API using Sort descending order for list

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]

Stream API Examples - filter | map | sort

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]

==========================