BiPredicate as function argument

[Sukumar Sat]

I was searching for BiPredicate examples.

I found it here 2. BiPredicate as function argument

But this code gave two compile time errors, which are attached herewith.

Though, comments are given along with code, but those comments are insufficient to understand flow of program

I request that any developer please help me with rectifying bugs as well as writing detailed comments after each line.

[Tim Moores]

Welcome to the Ranch.

Note this comment in the Domain class:

// getters , setters , toString

That means you need to add the usual getter and setter methods: setName, getName, setScore and getScore. (toString is not needed for this example.)

[Sukumar Sat]

Tim Moores wrote:Welcome to the Ranch.

Note this comment in the Domain class:

// getters , setters , toString

That means you need to add the usual getter and setter methods: setName, getName, setScore and getScore. (toString is not needed for this example.)

Tim,

Thank you,

Can you please help me by explaining class Domain and filterBadDomain method?

How it is helping entire program?

Sukumar

[Tim Moores]

The Domain class has no particular purpose except to illustrate the concept of BiPredicate - it models an internet domain (like "google.com") along with a "goodness" score of that domain.

The filterBadDomain method simply applies a Bipredicate to a List of domains. it's shown in action several times in the code; did you get that to run now? That should be the first step in learning from this example, as it makes it much easier to understand what's going on. (Although the source code does actually show the output of each of the System.out.println statements.)

[Sukumar Sat]

Tim Moores wrote:The Domain class has no particular purpose except to illustrate the concept of BiPredicate - it models an internet domain (like "google.com") along with a "goodness" score of that domain.

The filterBadDomain method simply applies a Bipredicate to a List of domains. it's shown in action several times in the code; did you get that to run now? That should be the first step in learning from this example, as it makes it much easier to understand what's going on. (Although the source code does actually show the output of each of the System.out.println statements.)

Tim,

Thank you again,

I have amended code and shared working code below with some questions, for which I need your help to understand.

I understood that in Java 8, BiPredicate is a functional interface, which accepts two arguments and returns a boolean

@FunctionalInterface
public interface BiPredicate<T, U> {
    boolean test(T t, U u);
}

Please help me with answers to those Six requested questions asked in comments within below code.
Please give any Reference to elaborate my Learning.

/*
    MIT License for https://mkyong.com/java8/java-8-bipredicate-examples/

    Copyright (c) 2020 Mkyong.com

    Permission is hereby granted, free of charge, to any person obtaining a copy
    of this software and associated documentation files (the "Software"), to deal
    in the Software without restriction, including without limitation the rights
    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    copies of the Software, and to permit persons to whom the Software is
    furnished to do so, subject to the following conditions:

    The above copyright notice and this permission notice shall be included in all
    copies or substantial portions of the Software.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
    SOFTWARE.

        

        This example uses BiPredicate to filter bad domains by the domain name or threat score.
	
*/


import java.util.Arrays;
import java.util.List;
import java.util.function.BiPredicate;
import java.util.stream.Collectors;

public class BiPredicateExample2 {

    public static void main(String[] args) {

        List<Domain> domains = Arrays.asList(new Domain("MostlyCorrect.com", 1), 
          // Question # 1 : new keyword is used to create an Object. Why new Domain was used here? 
                new Domain("SomeSpamWeb.com", 10),
                new Domain("SomethingCorrect.com", 0),
                new Domain("AnythingCorrect.com", 2));

        BiPredicate<String, Integer> bi = (domain, score) -> { // Question # 2 : domain is in lower case. Is it variable or an object?
         // Question # 3 : Is this anonymous class after Lambda Expression ?
            return (domain.equalsIgnoreCase("MostlyCorrect.com") || score == 0); 
         // Question # 4 :  Here, domain is in lower case and attached to a method. So, Is it an Object?
        };

        // if MostlyCorrect or score == 0
        List<Domain> result = filterBadDomain(domains, bi); 
        // List is an interface, 
        // and usually, we use ArrayList as class and we write 
        // ArrayList aL = new ArrayList(); 
        // Question # 5 : Why aforesaid line of code is different?
        System.out.println(result); // MostlyCorrect.com, SomethingCorrect.com

        //  if score == 0
        List<Domain> result2 = filterBadDomain(domains, (domain, score) -> score == 0);
        System.out.println(result2); // SomethingCorrect.com, AnythingCorrect.com

        // if start with i or score > 5
        List<Domain> result3 = filterBadDomain(domains, (domain, score) -> domain.startsWith("i") && score > 5);
        System.out.println(result3); // SomeSpamWeb.com

        // chaining with or
        List<Domain> result4 = filterBadDomain(domains, bi.or(
                (domain, x) -> domain.equalsIgnoreCase("AnythingCorrect.com"))
        );
        System.out.println(result4); // MostlyCorrect.com, SomethingCorrect.com, AnythingCorrect.com
		
    } // end of public static void main
	
    public static <T extends Domain> List<T> filterBadDomain( 
    // Before a method name, I have seen 3 keywords (e.g.,  public static void main). 
    // But there are 4 before filterBadDomain method. (public static <T extends Domain> List<T> )
    // Question # 6 : Why?
            List<T> list, BiPredicate<String, Integer> biPredicate) {
							return list.stream()
									.filter(x -> biPredicate.test(x.getName(), x.getScore()))
									.collect(Collectors.toList());
    }
}
class Domain {

    String name;
    Integer score;

    public Domain(String name, Integer score) {
        this.name = name;
        this.score = score;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getScore() {
        return score;
    }

    public void setScore(Integer score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Domain{" +
                "name='" + name + '\'' +
                ", score=" + score +
                '}';
    }
}

[Jesse Silverman]

Hi Suakamar:

I happen to be studying the same topic right now!  First, let's clear up one bit of background info:

  List<Domain> domains = Arrays.asList(new Domain("MostlyCorrect.com", 1), 
          // Question # 1 : new keyword is used to create an Object. Why new Domain was used here? 
          new Domain("SomeSpamWeb.com", 10),
          new Domain("SomethingCorrect.com", 0),
          new Domain("AnythingCorrect.com", 2));

   1. Arrays.asList() creates a fix-sized List "view" of an array of Domain objects.
   Instead of separately creating an array and then passing that in as a named
   array which will back the List<Domain> that is created, we save lines by
   creating an anonymous Array.  This is a common way to conveniently create
   a fixed-size but mutable List which is just a view of the Array, meaning
   that all changes to Array elements show in the List that is backed by it, and
   vice versa.  Any attempts to add or remove elements to the fixed size list
   will throw runtime exceptions.
   https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Arrays.html#asList(T...)


   You might have been less confused by:

    Domain[] domainArray = new Domain[4]();
    domainArray[0] = new Domain("MostlyCorrect.com", 1);
    domainArray[1] = new Domain("SomeSpamWeb.com", 10);
    domainArray[2] = new Domain("SomethingCorrect.com", 0);
    domainArray[3] = new Domain("AnythingCorrect.com", 2);
    List<Domain> domains = Arrays.asList( domainArray );

   However, as written, this is a very common idiom which as you can see saves
   a lot of space when all the work you will be doing is via. the List interface.
   You should know it because it is a very common idiom in Java, but is not
   at all specific to functional programming or lambdas or streams.

[Jesse Silverman]

    BiPredicate<String, Integer> bi = (domain, score) -> { // Question # 2 : domain is in lower case. Is it variable or an object?
    // Question # 3 : Is this anonymous class after Lambda Expression ?
        return (domain.equalsIgnoreCase("MostlyCorrect.com") || score == 0); 
    // Question # 4 :  Here, domain is in lower case and attached to a method. So, Is it an Object?
    };

   Questions 2, 3 and 4 are indeed about the basics of lambda expression syntax
   2. domain and score are "parameters to the lambda expression".
       They can basically be thought of as parameters to the anonymous method
       you are creating, but there are some scoping rules to pay attention to
       that this simplification would confuse one with.
   3. No, it is the body of the lambda expression, the work that gets carried
       out when it is called.  In the trivial case that one writes just a
       single expression that gets returned, we can leave out the return and {}
   4. This is calling a method on the reference variable domain which was one
       of two parameters to the lambda expression.  It is a normal instance
       method call that happens to be in the body of this lambda expression.
There are countless pretty good lambda expressions basics tutorials.
Which ones you might prefer depend on which accents you find most comprehensible,
and your general level of knowledge in Java, Computer Science and programming.
Here are a few that I watched while I was learning.
There are some excellent ones that contain WAY more info, too much beyond the
scope of basic lambda expression syntax:
https://www.youtube.com/watch?v=lIXs4Y8sJCk
https://www.youtube.com/watch?v=jf3VVYHUuVA
https://www.youtube.com/watch?v=bnuQpz-DK3w&list=PLd3UqWTnYXOmXMlfkwocAUzyOYxMZ7cyw&index=2

This one is great but it covers a LOT of stuff!
He used to post on this site a lot when his book was new, but he is a full-time
professor and is mostly seen in person by students (probably online now due to COVID)
and in his commercial books:
https://www.youtube.com/watch?v=1OpAgZvYXLQ

If you watch that say goodbye to your loved ones for several hours, but he is great and you will learn a lot.

If you seek certification for Java 11 these topics are covered as part of that, in somewhat less detail and together with many, many other topics that are considered essential for certification or doing professional Java work.  One I am reading is seen here:
https://www.amazon.com/Oracle-Certified-Professional-Programmer-Study/dp/1119617626/ref=sr_1_10?dchild=1&keywords=selikoff+boyarsky&qid=1610055091&s=books&sr=1-10

That is the second of two books preparing seekers of the !Z0-819 certification from Oracle.
The authors frequent this site and errata reports and questions normally come thru this site.

If you aren't looking to take a certification exam, they are still good books, but some of the links given prior to that should get you comfortable with lambda expression syntax.

[Jesse Silverman]

Questions 5 and 6 show that you need to catch up on the basics of Generics usage in Java.
Generics are not at all specific to functional programming, streams or lambda expressions, they have been around since Java 5.

There are many good tutorials on the basics of generics in Java, several can be found here:
https://www.youtube.com/results?search_query=java+generics+tutorial

It seems like you are trying to learn a LOT at once here.

Each individual thing is not particularly hard (knowing them well enough to ace a certification exam is pretty tricky, tho).

Learning them all at once can make your head swim.

So, a presentation on the basics of functional programming in Java is often going to presume you know the following pretty well:
1. The basics of Java Collections Frameworks (you seem to have some familiarity with that, there are countless tutorials to take you further, some are even very good)
2. Generics Basics in Java -- specifically, you were getting confused by an unfamiliar syntax which defines methods with generic parameters.
3. Lambda Expression basics
4. Basic functional interfaces.

If you are pretty solid on those pre-requisites, learning streams isn't so bad, tho there is a lot to potentially know to make full use of them.

Trying to learn the first four at the same time as streams can really drown you tho, many of your questions are valid and good but I would consider familiarity with the answers to be a Pre-Req, rather than a Co-Requisite for learning Streams in Java.

[Jesse Silverman]

Standard and free, here are the official Oracle tutorials on Collections and Generics.  They cover some of the basics that seemed to be making it more difficult for you to understand the presentation you had found on BiPredicate<> which presumes familiarity with these topics:

https://docs.oracle.com/javase/tutorial/collections/index.html

https://docs.oracle.com/javase/tutorial/extra/generics/index.html

[Jesse Silverman]

In the list of Pre-Requisites that might be necessary to fully understand the example the Original Poster had found and presented I believe I neglected VarArgs, also "new" for Java 5 in 2004.

A one sentence description would be that it allows you to treat zero or more arguments of the same type occurring at the end of a parameter list, or the only elements of a parameter list as an array, or to actually pass in an array, but longer presentations beat it to death for over an hour showing how it interacts with method overloading.

It is useful in many places in Java, and tricky, so researching VarArgs in Java would also yield a number of helpful tutorials.

I note that when diving into Functional Programming with Streams, Jeanne and Scott warn that one had better be on top of all of the topics mentioned before moving forward further to avoid some serious confusion or feeling overwhelmed.  Many otherwise good presentations including at least a couple I linked to presume you have been using these pre-requisites daily in code for quite some time and that you are quite familiar with their nuances.