Java Basic Archives - Page 8 of 13

Java Basic

Learn about Function Functional Interface in Java

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

isPresent() method of Optional object in Java

8 years ago by Khanh NguyenJava Basic

This method will check whether an Optional object is not empty? If this object is empty, it returns false. For example:

package com.huongdanjava.javaexample;

import java.util.Optional;

public class Example {

	public static void main(String[] args) {
		String s = new String("Khanh");

		Optional<String> opt = Optional.ofNullable(s);
		System.out.println(opt.isPresent());
	}

}

package com.huongdanjava.javaexample;

import java.util.Optional;

public class Example {

public static void main(String[] args) {

String s = new String("Khanh");

Optional<String> opt = Optional.ofNullable(s);

System.out.println(opt.isPresent());

}

Result:

map() method of Optional object in Java

8 years ago by Khanh NguyenJava Basic

This method first will check whether our Optional object is empty or not? If not empty, convert its value to another value. Similar to the filter() method, this method returns an Optional object with a value after conversion. For example:

package com.huongdanjava.javaexample;

import java.util.Optional;

public class Example {

	public static void main(String[] args) {
		String s = new String("Khanh");

		Optional<String> opt = Optional.ofNullable(s);
		opt.map(x -> x.toLowerCase())
			.filter(x -> x.contains("k"))
			.ifPresent(x -> System.out.println("Name: " + x));
	}

}

package com.huongdanjava.javaexample;

import java.util.Optional;

public class Example {

public static void main(String[] args) {

String s = new String("Khanh");

Optional<String> opt = Optional.ofNullable(s);

opt.map(x -> x.toLowerCase())

.filter(x -> x.contains("k"))

.ifPresent(x -> System.out.println("Name: " + x));

}

In the above example,… Read More