Java Basic Archives - Page 9 of 13

map() method of Optional object in Java

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

filter() 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, then continue to check whether its value meets a certain condition or not? If satisfied, it returns an Optional object containing this value, otherwise returns an empty Optional object. For… Read More

ifPresentOrElse() method of Optional object in Java

8 years ago by Khanh NguyenJava Basic

This method was introduced from Java 9. This method is similar to the ifPresent() method which I introduced in this tutorial, but here is a difference since we have one more Runnable parameter, so that in-case if the Optional object is empty, the object of the… Read More

ifPresent() method of Optional object in Java

8 years ago by Khanh NguyenJava Basic

This method is used to check whether an Optional object is empty or not? If not, then do the operations with this object, otherwise do not do anything. The parameter of this method is an object of the Consumer interface. You can see more about… Read More

Or() methods of Optional object in Java

8 years ago by Khanh NguyenJava Basic

The Optional object in Java has three methods with name start with or(). In this tutorial, we will together learn about them and what is the difference between them. First, I might mention the orElse() method. This method is used to return a default value in… Read More

Learn about Supplier Functional Interface in Java

8 years ago by Khanh NguyenJava Basic

Supplier is a Functional Interface, so it only contains an abstract method as follows:

package java.util.function;

/**
 * Represents a supplier of results.
 *
 * <p>There is no requirement that a new or distinct result be returned each
 * time the supplier is invoked.
 *
 * <p>This is a <a href="package-summary.html">functional interface</a>
 * whose functional method is {@link #get()}.
 *
 * @param <T> the type of results supplied by this supplier
 *
 * @since 1.8
 */
@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

package java.util.function;

/**

* Represents a supplier of results.

* <p>There is no requirement that a new or distinct result be returned each

* time the supplier is invoked.

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

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

* @param <T> the type of results supplied by this supplier

* @since 1.8

@FunctionalInterface

public interface Supplier<T> {

/**

* Gets a result.

* @return a result

T get();

}

This interface simply returns the value in the context that is being used by the get() method. For example, we have the following list:

List<String> s = Arrays.asList("Khanh", "Quan");

1	List<String> s = Arrays.asList("Khanh", "Quan");

Now that I want to… Read More

Learn about Consumer Functional Interface in Java

8 years ago by Khanh NguyenJava Basic

Java 8 introduces a new package containing Functional Interfaces called java.util.function. In this package, we have many interfaces like Consumer, Supplier, Predicate, … In this tutorial, we will learn about Consumer Functional Interface. The content of this interface is as follows:

package java.util.function;

import java.util.Objects;

/**
 * Represents an operation that accepts a single input argument and returns no
 * result. Unlike most other functional interfaces, {@code Consumer} is expected
 * to operate via side-effects.
 *
 * <p>This is a <a href="package-summary.html">functional interface</a>
 * whose functional method is {@link #accept(Object)}.
 *
 * @param <T> the type of the input to the operation
 *
 * @since 1.8
 */
@FunctionalInterface
public interface Consumer<T> {

    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);

    /**
     * Returns a composed {@code Consumer} that performs, in sequence, this
     * operation followed by the {@code after} operation. If performing either
     * operation throws an exception, it is relayed to the caller of the
     * composed operation.  If performing this operation throws an exception,
     * the {@code after} operation will not be performed.
     *
     * @param after the operation to perform after this operation
     * @return a composed {@code Consumer} that performs in sequence this
     * operation followed by the {@code after} operation
     * @throws NullPointerException if {@code after} is null
     */
    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

package java.util.function;

import java.util.Objects;

/**

* Represents an operation that accepts a single input argument and returns no

* result. Unlike most other functional interfaces, {@code Consumer} is expected

* to operate via side-effects.

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

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

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

* @since 1.8

@FunctionalInterface

public interface Consumer<T> {

/**

* Performs this operation on the given argument.

* @param t the input argument

void accept(T t);

/**

* Returns a composed {@code Consumer} that performs, in sequence, this

* operation followed by the {@code after} operation. If performing either

* operation throws an exception, it is relayed to the caller of the

* composed operation. If performing this operation throws an exception,

* the {@code after} operation will not be performed.

* @param after the operation to perform after this operation

* @return a composed {@code Consumer} that performs in sequence this

* operation followed by the {@code after} operation

* @throws NullPointerException if {@code after} is null

default Consumer<T> andThen(Consumer<? super T> after) {

Objects.requireNonNull(after);

return (T t) -> { accept(t); after.accept(t); };

}

Because the Consumer… Read More

stream() method of Optional object in Java

8 years ago by Khanh NguyenJava Basic

This method is supported since Java 9. This method is used to create a new Stream object from an Optional object in Java. If the Optional object contains a value, this method will return the Stream object containing that value, otherwise, it returns an empty… Read More

Learn about Server Push in Java

8 years ago by Khanh NguyenJava Basic

Server Push is a new performance enhancement feature for Web applications defined in HTTP/2 standards. It allows us to push images, CSS files, Javascript files, and other resources to the client before requests from the client are processed. So, as soon as the response from… Read More

Talking about transient variable in Java

8 years ago by Khanh NguyenJava Basic

In the previous tutorial, you learned about Serialization that allows us to store the state of a Java object. All of the properties of the Java object are stored somewhere so that other processes can retrieve it to reuse. But in reality, sometimes we need… Read More