DEV Community: Praphul Kolte

Ways to filter list in java

Praphul Kolte — Sun, 23 Apr 2023 17:32:08 +0000

List is commonly used Collection in Java. Many times List needs to be filtered by some attribute or property. Example: Filter the Employee list to get list of permanent employees only. There are many ways to filter list. This blog focus on filtering list with different criteria.

For filtering example we are considering list of Apples. List has mix of apples with red and green color with different weight and taste.

Lets create Apple class with color, weight and taste with getter and setters implemented.

package com.filter.fruits;

public class Apple {
    private int weight;
    private String color;
    private String taste;


    public Apple() {
        super();
    }

    public Apple(int weight, String color, String taste) {
        super();
        this.weight = weight;
        this.color = color;
        this.taste = taste;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getTaste() {
        return taste;
    }

    public void setTaste(String taste) {
        this.taste = taste;
    }

    @Override
    public String toString() {
        return "Apple [weight=" + weight + ", color=" + color + ", taste=" + taste + "]";
    }

}

Lets create a utils class to get List of mixed Apples.

package com.filter.fruits;

import java.util.ArrayList;
import java.util.List;
//This class create methods for getting pre-filled list of apples
public class AppleUtils {
    public static List<Apple> getAppleList() {
        List<Apple> applesList = new ArrayList<>();
        applesList.add(new Apple(100, "Green", "Sour"));
        applesList.add(new Apple(200, "Red", "Sweet"));
        applesList.add(new Apple(150, "Green", "Sour"));
        applesList.add(new Apple(250, "Red", "Sweet"));
        applesList.add(new Apple(150, "Green", "Sour"));
        applesList.add(new Apple(150, "Red", "Sweet"));
        applesList.add(new Apple(200, "Green", "Sour"));
        return applesList;
    }

}

Now, we need to create methods to filter out apples.
AppleFilterUtils has methods as below.

filterByRedColor methods filters by "Red" color which is not flexible
filterByGreenColor methods filters by "Gree" color which is not flexible
filterByColor methods filters by color which is passed from outside. This method can be used for green as red apple filtering
filterByColorAndWeight methods filters by color and weight by passing them from outside
filterByCritera methods filters criteria passed using Predicate class. Predicate class define criteria.

package com.filter.fruits;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;

public class AppleFilterUtils {
    public static List<Apple> filterByRedColor(List<Apple> appleList){
        List<Apple> filteredList = new ArrayList<>();
        for(Apple apple : appleList) {
            if("Red".equals(apple.getColor())) {
                filteredList.add(apple);
            }
        }
        return filteredList;
    }

    public static List<Apple> filterByGreenColor(List<Apple> appleList){
        List<Apple> filteredList = new ArrayList<>();
        for(Apple apple : appleList) {
            if("Green".equals(apple.getColor())) {
                filteredList.add(apple);
            }
        }
        return filteredList;
    }

    public static List<Apple> filterByColor(List<Apple> appleList, String color){
        List<Apple> filteredList = new ArrayList<>();
        for(Apple apple : appleList) {
            if(color.equals(apple.getColor())) {
                filteredList.add(apple);
            }
        }
        return filteredList;
    }

    public static List<Apple> filterByColorAndWeight(List<Apple> appleList, String color, int weight){
        List<Apple> filteredList = new ArrayList<>();
        for(Apple apple : appleList) {
            if(color.equals(apple.getColor()) && weight >= apple.getWeight()) {
                filteredList.add(apple);
            }
        }
        return filteredList;
    }


    public static List<Apple> filterByCritera(List<Apple> appleList, Predicate<Apple> predicate){
        List<Apple> filteredList = new ArrayList<>();
        for(Apple apple : appleList) {
            if(predicate.test(apple)) {
                filteredList.add(apple);
            }
        }
        return filteredList;
    }

}

Custom Predicates can be created by inheriting Predicate class.

Lets create Predicate for Green apples and another for filtering apples having weight more than 150g

package com.filter.fruits.predicates;

import java.util.function.Predicate;

import com.acts.fruits.Apple;

public class AppleColorPredicate implements Predicate<Apple>{


    @Override
    public boolean test(Apple t) {
        return "Green".equals(t.getColor());
    }

}

package com.filter.fruits.predicates;

import java.util.function.Predicate;

import com.acts.fruits.Apple;

public class AppleWeightPredicate implements Predicate<Apple>{

    @Override
    public boolean test(Apple t) {
        return t.getWeight() > 150;
    }

}

Lets take look at below Tester class to test Filter methods from AppleFilterUtils class

package com.acts.fruits.tester;

import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

import com.filter.fruits.Apple;
import com.filter.fruits.AppleFilterUtils;
import com.filter.fruits.AppleUtils;
import com.filter.fruits.predicates.AppleColorPredicate;
import com.filter.fruits.predicates.AppleWeightPredicate;

public class AppleFilterTester {

    public static void main(String[] args) {
        //Getting apple list from utils class
        List<Apple> applesList = AppleUtils.getAppleList();
        System.out.println("1.All Apples\n" + applesList);

        //Filter By Red color
        List<Apple> filteredList1 = AppleFilterUtils.filterByRedColor(applesList);
        System.out.println("2.Red apples\n" + filteredList1);

        //Filter By Green color
        List<Apple> filteredList2 = AppleFilterUtils.filterByGreenColor(applesList);
        System.out.println("3.Green apples\n" + filteredList2);

        //Passing color as parameter
        //Filter By color: Red
        List<Apple> filteredList3 = AppleFilterUtils.filterByColor(applesList, "Red");
        System.out.println("4.Red apples\n" + filteredList3);

        //Filter By color: Green
        List<Apple> filteredList4 = AppleFilterUtils.filterByColor(applesList, "Green");
        System.out.println("5.Green apples\n" + filteredList4);

        //Filter By color: Green and weight >150
        List<Apple> filteredList5 = AppleFilterUtils.filterByColorAndWeight(applesList, "Green", 150);
        System.out.println("6.Green apples\n" + filteredList5);

        // Using predicate from java8
        Predicate<Apple> appleColorPredicate =  new AppleColorPredicate();
        //Filter By color: Green  using predicate
        List<Apple> filteredList6 = AppleFilterUtils.filterByCritera(applesList, appleColorPredicate);
        System.out.println("7.Green apples\n" + filteredList6);

        // Using predicate from java8
        Predicate<Apple> appleWeightPredicate =  new AppleWeightPredicate();
        //Filter By weight > =150  using predicate
        List<Apple> filteredList7 = AppleFilterUtils.filterByCritera(applesList, appleWeightPredicate);
        System.out.println("8.With Weight apples\n" + filteredList7);

        // Using predicate from java8
        Predicate<Apple> predicate = (apple) ->  apple.getColor().equals("Red") && apple.getWeight() > 200;
        List<Apple> filteredList8 = AppleFilterUtils.filterByCritera(applesList, predicate);
        System.out.println("9.Red With Weight apples\n" + filteredList8);

        // Using predicate and stream api from java8
        List<Apple> filteredList9 = applesList.stream()
        .filter(predicate)
        .collect(Collectors.toList());
        System.out.println("10.Red With Weight apples\n" + filteredList9);


        // Using Stream and predicate on the fly and stream api from java8
        List<Apple> filteredList10 = applesList.stream()
                .filter((apple) ->  apple.getColor().equals("Green") && apple.getWeight() > 150)
                .collect(Collectors.toList());
        System.out.println("11.Freen With Weight apples\n" + filteredList10);

        // Using Stream and predicate on the fly and stream api from java8
        List<Apple> filteredList11 = applesList.stream()
                .filter((apple) ->  apple.getColor().equals("Green"))
                .filter((apple) ->  apple.getTaste().equals("Sweet"))
                .collect(Collectors.toList());
        System.out.println("12.Green With Taste apples\n" + filteredList11);


    }

}

Allocating dynamic memory to 3D array

Praphul Kolte — Sat, 22 Apr 2023 17:50:48 +0000

Arrays are commonly used containers to store data for processing. Array stores homogeneous elements in contiguous memory. Array indexes start from zero and we can navigate to any elements by using indexes. Base on structure of array there are 2 type

Single or One Dimensional Array : only one dimension

1D Declaration in C++ : int arr[5];

Multi-dimensional Array : More than one dimension

2D Declaration in C++ : int arr[3][5];

3D Declaration in C++ : int arr[3][3][5];
1D array is collection of elements
2D array is collection of 1D arrays
3D array is collection of 2D arrays
similarly we can say nD array is collection of (n-1)D arrays

As per language rules array sizes has to be constants which lead to shortage or excess of memory. Developer can allocate memory dynamically at runtime to avoid memory wastage.

Lets see how to allocate memory for 3D. Why 3D because 3D memory allocation has memory allocation for 1D, 2D and 3D arrays also as 3D arrays is collection of 2D and 2D is collection of 1D.

Lets start with declaring pointer for 3D array. Pointer to represent 3D array int ***p;

Lets create separate C++ function to allocate memory by supplying dimensions. Here n, r and c are dimensions.

allocateMemory function first allocates memory to n number of 2D arrays the allocate for r number of 1D array and then allocate memory for elements Or 1D



int *** allocateMemory(int n, int r, int c)
{
    int ***p = new int**[n]; // for n numbers of 2D arrays

    for(int i=0;i<n;i++)
    {
        p[i] = new int*[r]; // for r numbers of 1D arrays
    }

    for(int i=0;i<n;i++)
    {
        for(int j=0; j< r;j++)
        {
            p[i][j] = new int[c]; // for c numbers of elements
        }
    }
    return p;
}

Lets create separate C++ function to accept array elements from user. This function receives pointer to memory which already allocated to array.



void acceptInput(int ***p, int n, int r, int c )
{
    for(int i =0;i<n;i++)
    {
        for(int j =0;j<r;j++)
        {
            for(int k =0;k< c;k++)
            {
                cin>>p[i][j][k];
            }
        }
    }
}

Lets create separate C++ function to Print Array elements on console.



void printArray(int ***p, int n, int r, int c )
{
    for(int i =0;i<n;i++)
    {
        for(int j =0;j<r;j++)
        {
            for(int k =0;k<c;k++)
             {
                cout<<p[i][j][k]<<" ";
             }
        }
    }
}

Lets create separate C++ function to deallocate memory by supplying dimensions and pointer of allocated memory.



void deallocateMemory(int ***p, int n, int r, int c)
{
    for(int i=0;i<n;i++)
    {
        for(int j=0; j< r;j++)
        {
        delete[] p[i][j];
        }
    }

    for(int i=0;i<n;i++)
    {
    delete[] p[i];
    }

    delete[] p;
}

Now we have created functions to allocate memory , fill data in memory, read memory and finally delete the allocated memory.
Its time to write main function and try calling functions



#include <iostream>
using namespace std;

int main()
{
    int n,r,c;
    int ***p = NULL;
    //Read user input
    cout<<"\n Enter first dimension:"<<endl;
    cin>>n;
    cout<<"\n Enter second dimension:"<<endl;
    cin>>r;
    cout<<"\n Enter third dimension:"<<endl;
    cin>>c;

    //Allocating memory
    p = allocateMemory(n, r, c);

    //Read array elements
    cout<<"\n Enter " << n*r*c << " elements :"<<endl;
    acceptInput(p,n, r, c);

    //Print array elements
    cout<<"\n Array elements are :";
    printArray(p,n, r, c);

    //Deleting/free up memory
    deallocateMemory(p,n, r, c);

    return 0;
}

Sample run output:

Enter first dimension:
2

Enter second dimension:
2

Enter third dimension:
2

Enter 8 elements :
11
22
33
44
55
66
77
88

Array elements are :
11 22 33 44 55 66 77 88

Pointers and Constants

Praphul Kolte — Fri, 21 Apr 2023 17:03:10 +0000

Pointer stores address of variable and it can be referenced and dereferenced. Pointers are powerful which enable developers to play at memory level operations. Sometimes developers may make accidental modifications to values pointed by pointers. To impose restriction on pointers const keyword can be used. Based on usage of const, there are 3 possible scenarios as below

Pointer to Constant : Value pointed by pointer to constant can not be changed but pointer can changed. This type of pointers are used to restrict accidental modifications to value. It provide read only access to value to functions when passed as argument.

Pointer to constant can be declared by placing const keyword before data type.
Example. const int *p = NULL;

Below code snippet demonstrates restriction on value change.

#include<iostream>
using namespace std;
int main()
{
    const int k=20;
    const int *p = &k;
    cout<<*p;
    p = NULL; // can be changed
    p = p+1; // can be changed
    //*p =100; // Error assignment of read-only location '* p'
     //This error comes as pointer is declared as pointer to const
    return 0;
}

Constant pointer to variable : Value pointed by constant pointer can be changed but pointer can not be changed. This type of pointer can hold same address for life time and it can not be changed to point to other variable. Constant pointers needs to be initialized where it is declared.

Constant Pointer can be declared by placing const keyword after * and before pointer name.
Example.
int a =10 ;
int * const p = &a;

Below code snippet demonstrates restriction on changing pointer.

#include<iostream>
using namespace std;
int main()
{
    int k=20;
    int * const p = &k;
    cout<<*p<<endl;
    //p = NULL;// can  not be changed
    //p = p+1; // can  not be changed
    *p =100; // value ( *p) can be changed   
    cout<<*p<<endl;
    return 0;
}

Array name is internally a constant pointer to first element of array and it stores base address of array. Function name is also internally constant pointer.

Below snippet demonstrates array and function names restriction.

#include<iostream>
using namespace std;
int add(int a, int b)
{  
    return a+b; 
}

int main()
{
    char name[50]= "Priyanka";
    //name++; //error: lvalue required as increment operand
    //add = add+1; //error: assignment of function 'int add(int, int)'
    cout<<name;
    return 0;
}

Constant pointer to constant : Value pointed by constant pointer to constant can not be changed also pointer can not be changed. Here pointer and value both are read only. Its used to pass or insert this pointer in member functions of class.

Constant Pointer to constant can be declared by placing const keyword before datatype as well as const after * and before pointer name.
Example.
const int a =10 ;
const int * const p = &a

#include<iostream>
using namespace std;
int main()
{
    const int k=20;
    const int *const p = &k;
    cout<<*p<<endl;
    p = NULL; // Can not be changed error: assignment of read-only variable 'p'
    p = p+1; // Can not be changed error: assignment of read-only variable 'p'
    *p =100; // Can not be changed error: assignment of read-only location '*(const int*)p'
    cout<<*p<<endl;
    return 0;
}

Conclusion : Pointers are flexible and they support fastest data operations by directly working on addresses. While working with pointer if developers make use of const keyword they control write access to data.