Java Basic Archives - Page 8 of 13

Java Basic

Learn about Predicate Functional Interface in Java

The Predicate interface is used primarily to filter a Stream object. Using the filter() method with the Predicate interface parameter will allow us to filter the items in the Stream object to satisfy some conditions. The content of this interface is as follows:

/*
 * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
package java.util.function;

import java.util.Objects;

/**
 * Represents a predicate (boolean-valued function) of one argument.
 *
 * <p>This is a <a href="package-summary.html">functional interface</a>
 * whose functional method is {@link #test(Object)}.
 *
 * @param <T> the type of the input to the predicate
 *
 * @since 1.8
 */
@FunctionalInterface
public interface Predicate<T> {

    /**
     * Evaluates this predicate on the given argument.
     *
     * @param t the input argument
     * @return {@code true} if the input argument matches the predicate,
     * otherwise {@code false}
     */
    boolean test(T t);

    /**
     * Returns a composed predicate that represents a short-circuiting logical
     * AND of this predicate and another.  When evaluating the composed
     * predicate, if this predicate is {@code false}, then the {@code other}
     * predicate is not evaluated.
     *
     * <p>Any exceptions thrown during evaluation of either predicate are relayed
     * to the caller; if evaluation of this predicate throws an exception, the
     * {@code other} predicate will not be evaluated.
     *
     * @param other a predicate that will be logically-ANDed with this
     *              predicate
     * @return a composed predicate that represents the short-circuiting logical
     * AND of this predicate and the {@code other} predicate
     * @throws NullPointerException if other is null
     */
    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

    /**
     * Returns a predicate that represents the logical negation of this
     * predicate.
     *
     * @return a predicate that represents the logical negation of this
     * predicate
     */
    default Predicate<T> negate() {
        return (t) -> !test(t);
    }

    /**
     * Returns a composed predicate that represents a short-circuiting logical
     * OR of this predicate and another.  When evaluating the composed
     * predicate, if this predicate is {@code true}, then the {@code other}
     * predicate is not evaluated.
     *
     * <p>Any exceptions thrown during evaluation of either predicate are relayed
     * to the caller; if evaluation of this predicate throws an exception, the
     * {@code other} predicate will not be evaluated.
     *
     * @param other a predicate that will be logically-ORed with this
     *              predicate
     * @return a composed predicate that represents the short-circuiting logical
     * OR of this predicate and the {@code other} predicate
     * @throws NullPointerException if other is null
     */
    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

    /**
     * Returns a predicate that tests if two arguments are equal according
     * to {@link Objects#equals(Object, Object)}.
     *
     * @param <T> the type of arguments to the predicate
     * @param targetRef the object reference with which to compare for equality,
     *               which may be {@code null}
     * @return a predicate that tests if two arguments are equal according
     * to {@link Objects#equals(Object, Object)}
     */
    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }

    /**
     * Returns a predicate that is the negation of the supplied predicate.
     * This is accomplished by returning result of the calling
     * {@code target.negate()}.
     *
     * @param <T>     the type of arguments to the specified predicate
     * @param target  predicate to negate
     *
     * @return a predicate that negates the results of the supplied
     *         predicate
     *
     * @throws NullPointerException if target is null
     *
     * @since 11
     */
    @SuppressWarnings("unchecked")
    static <T> Predicate<T> not(Predicate<? super T> target) {
        Objects.requireNonNull(target);
        return (Predicate<T>)target.negate();
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

* This code is free software; you can redistribute it and/or modify it

* under the terms of the GNU General Public License version 2 only, as

* published by the Free Software Foundation. Oracle designates this

* particular file as subject to the "Classpath" exception as provided

* by Oracle in the LICENSE file that accompanied this code.

* This code is distributed in the hope that it will be useful, but WITHOUT

* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License

* version 2 for more details (a copy is included in the LICENSE file that

* accompanied this code).

* You should have received a copy of the GNU General Public License version

* 2 along with this work; if not, write to the Free Software Foundation,

* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

* or visit www.oracle.com if you need additional information or have any

* questions.

package java.util.function;

import java.util.Objects;

/**

* Represents a predicate (boolean-valued function) of one argument.

* <p>This is a <a href="package-summary.html">functional interface</a>

* whose functional method is {@link #test(Object)}.

* @param <T> the type of the input to the predicate

* @since 1.8

@FunctionalInterface

public interface Predicate<T> {

/**

* Evaluates this predicate on the given argument.

* @param t the input argument

* @return {@code true} if the input argument matches the predicate,

* otherwise {@code false}

boolean test(T t);

/**

* Returns a composed predicate that represents a short-circuiting logical

* AND of this predicate and another. When evaluating the composed

* predicate, if this predicate is {@code false}, then the {@code other}

* predicate is not evaluated.

* <p>Any exceptions thrown during evaluation of either predicate are relayed

* to the caller; if evaluation of this predicate throws an exception, the

* {@code other} predicate will not be evaluated.

* @param other a predicate that will be logically-ANDed with this

* predicate

* @return a composed predicate that represents the short-circuiting logical

* AND of this predicate and the {@code other} predicate

* @throws NullPointerException if other is null

default Predicate<T> and(Predicate<? super T> other) {

Objects.requireNonNull(other);

return (t) -> test(t) && other.test(t);

}

/**

* Returns a predicate that represents the logical negation of this

* predicate.

* @return a predicate that represents the logical negation of this

* predicate

default Predicate<T> negate() {

return (t) -> !test(t);

}

/**

* Returns a composed predicate that represents a short-circuiting logical

* OR of this predicate and another. When evaluating the composed

* predicate, if this predicate is {@code true}, then the {@code other}

* predicate is not evaluated.

* <p>Any exceptions thrown during evaluation of either predicate are relayed

* to the caller; if evaluation of this predicate throws an exception, the

* {@code other} predicate will not be evaluated.

* @param other a predicate that will be logically-ORed with this

* predicate

* @return a composed predicate that represents the short-circuiting logical

* OR of this predicate and the {@code other} predicate

* @throws NullPointerException if other is null

default Predicate<T> or(Predicate<? super T> other) {

Objects.requireNonNull(other);

return (t) -> test(t) || other.test(t);

}

/**

* Returns a predicate that tests if two arguments are equal according

* to {@link Objects#equals(Object, Object)}.

* @param <T> the type of arguments to the predicate

* @param targetRef the object reference with which to compare for equality,

* which may be {@code null}

* @return a predicate that tests if two arguments are equal according

* to {@link Objects#equals(Object, Object)}

static <T> Predicate<T> isEqual(Object targetRef) {

return (null == targetRef)

? Objects::isNull

: object -> targetRef.equals(object);

}

/**

* Returns a predicate that is the negation of the supplied predicate.

* This is accomplished by returning result of the calling

* {@code target.negate()}.

* @param <T> the type of arguments to the specified predicate

* @param target predicate to negate

* @return a predicate that negates the results of the supplied

* predicate

* @throws NullPointerException if target is null

* @since 11

@SuppressWarnings("unchecked")

static <T> Predicate<T> not(Predicate<? super T> target) {

Objects.requireNonNull(target);

return (Predicate<T>)target.negate();

}

As… Read More

Difference between JDK, JRE and JVM

8 years ago by Khanh NguyenJava Basic

Everyone who has been and will be working on the Java language will know the concepts of JDK, JRE and JVM. So do people know what they are and the difference between them? In this tutorial, I will make clear to everyone to have a… Read More

Learn about Function Functional Interface in Java

8 years ago by Khanh NguyenJava Basic

Function interface is used to convert data from input parameters to return results in a different format. To do this, we will implement the apply() abstract method defined in the Function interface. But first, let’s look at the contents of the Function interface.

package java.util.function;

import java.util.Objects;

/**
 * Represents a function that accepts one argument and produces a result.
 *
 * <p>This is a <a href="package-summary.html">functional interface</a>
 * whose functional method is {@link #apply(Object)}.
 *
 * @param <T> the type of the input to the function
 * @param <R> the type of the result of the function
 *
 * @since 1.8
 */
@FunctionalInterface
public interface Function<T, R> {

    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);

    /**
     * Returns a composed function that first applies the {@code before}
     * function to its input, and then applies this function to the result.
     * If evaluation of either function throws an exception, it is relayed to
     * the caller of the composed function.
     *
     * @param <V> the type of input to the {@code before} function, and to the
     *           composed function
     * @param before the function to apply before this function is applied
     * @return a composed function that first applies the {@code before}
     * function and then applies this function
     * @throws NullPointerException if before is null
     *
     * @see #andThen(Function)
     */
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

    /**
     * Returns a composed function that first applies this function to
     * its input, and then applies the {@code after} function to the result.
     * If evaluation of either function throws an exception, it is relayed to
     * the caller of the composed function.
     *
     * @param <V> the type of output of the {@code after} function, and of the
     *           composed function
     * @param after the function to apply after this function is applied
     * @return a composed function that first applies this function and then
     * applies the {@code after} function
     * @throws NullPointerException if after is null
     *
     * @see #compose(Function)
     */
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    /**
     * Returns a function that always returns its input argument.
     *
     * @param <T> the type of the input and output objects to the function
     * @return a function that always returns its input argument
     */
    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

package java.util.function;

import java.util.Objects;

/**

* Represents a function that accepts one argument and produces a result.

* <p>This is a <a href="package-summary.html">functional interface</a>

* whose functional method is {@link #apply(Object)}.

* @param <T> the type of the input to the function

* @param <R> the type of the result of the function

* @since 1.8

@FunctionalInterface

public interface Function<T, R> {

/**

* Applies this function to the given argument.

* @param t the function argument

* @return the function result

R apply(T t);

/**

* Returns a composed function that first applies the {@code before}

* function to its input, and then applies this function to the result.

* If evaluation of either function throws an exception, it is relayed to

* the caller of the composed function.

* @param <V> the type of input to the {@code before} function, and to the

* composed function

* @param before the function to apply before this function is applied

* @return a composed function that first applies the {@code before}

* function and then applies this function

* @throws NullPointerException if before is null

* @see #andThen(Function)

default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {

Objects.requireNonNull(before);

return (V v) -> apply(before.apply(v));

}

/**

* Returns a composed function that first applies this function to

* its input, and then applies the {@code after} function to the result.

* If evaluation of either function throws an exception, it is relayed to

* the caller of the composed function.

* @param <V> the type of output of the {@code after} function, and of the

* composed function

* @param after the function to apply after this function is applied

* @return a composed function that first applies this function and then

* applies the {@code after} function

* @throws NullPointerException if after is null

* @see #compose(Function)

default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {

Objects.requireNonNull(after);

return (T t) -> after.apply(apply(t));

}

/**

* Returns a function that always returns its input argument.

* @param <T> the type of the input and output objects to the function

* @return a function that always returns its input argument

static <T> Function<T, T> identity() {

return t -> t;

}

We… Read More

equals() and hashCode() methods in Java

8 years ago by Khanh NguyenJava Basic

The equals() and hashCode() methods are very important for all objects in Java. In this tutorial, I will present to you all the basic knowledge about these two methods. By default, these methods are defined in Object objects, which are the parent objects of all… Read More

delayedExecutor() method of CompletableFuture object in Java

8 years ago by Khanh NguyenJava Basic

This method was introduced from Java 9. Here we have two overload methods delayedExecutor(), the first method has the following syntax:

static Executor delayedExecutor(long delay, TimeUnit unit)

1	static Executor delayedExecutor(long delay, TimeUnit unit)

This method returns an Executor object from the default Executor object that the CompletableFuture object uses to execute the task, after the delay.… Read More

completeOnTimeout() method of CompletableFuture in Java

8 years ago by Khanh NguyenJava Basic

This method was introduced from Java 9.

CompletableFuture<T> completeOnTimeout(T value, long timeout, TimeUnit unit)

1	CompletableFuture<T> completeOnTimeout(T value, long timeout, TimeUnit unit)

This method is used to: if after a timeout period our task is still unfinished, instead of throwing out the TimeoutException exception like the orTimeout() method, our code will return the value that we passed in this method.… Read More

orTimeout() method of CompletableFuture object in Java

8 years ago by Khanh NguyenJava Basic

This method was introduced from Java 9.

CompletableFuture<T> orTimeout(long timeout, TimeUnit unit)

1	CompletableFuture<T> orTimeout(long timeout, TimeUnit unit)

This method is used to specify that if our task does not complete within a certain period of time, the program will stop and be TimeoutException. In the following example, I want to calculate the sum of… Read More

Group by using Stream and Collectors in Java

8 years ago by Khanh NguyenJava Basic

In SQL, the GROUP BY statement returns the set of records having the same value in particular criteria. For example, you have a table that contains student information, each student coming from a different country. Use the GROUP BY statement according to national criteria, you… Read More

Introduction about CompletableFuture in Java

8 years ago by Khanh NguyenJava Basic

In the previous tutorial, I introduced to you all about the Future object in Java and I also told you that when using the get() method of the Future object, our program will be blocked until when all the tasks completed. To solve this blocking… Read More

flatMap() method of Optional object in Java

8 years ago by Khanh NguyenJava Basic

As you all know, the Optional object is a generic object, its data type can be any object, and therefore, we can meet the case that its data type is also an Optional object, such as: Optional<Optional<String>>. To resolve this problem, Java introduces us to… Read More