Java Functional Interface with one argument can apply to no argument method?

References

• https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/function/package-summary.html
• https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/lang/String.html#isEmpty()
• https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/function/ToIntFunction.html
• https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/lang/Integer.html#intValue()

This is Predicate Functional Interface's abstract method. It gets one argument T t and return boolean.

boolean 	test​(T t) 	
    Evaluates this predicate on the given argument.

But, in this example, String::isEmpty does not get any argument but it is instance method of String.

Predicate<String> p = String::isEmpty;

I can infer that in Java, this type of method can apply to Functional Interface with one argument.

And, is there any examples of one argument Functional Interface with the function has one argument not like upper example?

You can do Function<T, R> where R is the return type and T is the argument type.<br>
So R result = fnc.apply(k) where k is of type T.

Function<Integer, List<Integer>> fnc =  n-> new ArrayList<>(List.of(n));
List<Integer> list = fnc.apply(23);
System.out.println(list);

prints

[23]

But you can also do this, just like in your example.

Function<Integer, List<Integer>> fnc2 = fnc::apply;
fnc2.apply(44); // returns a list which contains 44

EXTRA DETAILS

Consider the following class. One static and one instance method.

class TestClass {
	public int prod(int a) {
		return a * 33;
	}
	
	public static int mult(int a) {
		return a * 44;
	}
}

To create a Lambda for the static, do the following:

// use unaryOperator since return type are argument are the same
UnaryOperator<Integer> fnc = TestClass::mult;
int result = fnc.apply(10); // returns 440

Now do an instance version.

UnaryOperator<Integer> inst = tc::prod;
inst.apply(10);
result = inst.apply(10); // returns 330

Now a special case using a static type reference.<br>
to an instance method.

// This requires 2 arguments. The instance
// and the argument to the method.a

BiFunction<TestClass, Integer, Integer> stat = TestClass::prod
result = stat.apply(tc, 12); // result is 396

</details>



# 答案2
**得分**: 0

以下是翻译好的内容：

有三种形式的谓词（Predicate）可用。以下是在字符串上针对 `isEmpty` 使用的形式：

1- 一个正式的函数式接口：

    Predicate<String> somePredicate = new Predicate<String>() {
        @Override
        public boolean test(String s) {
            return s.isEmpty();
        }
    };

2- 一个lambda表达式：

    (String s) -> s.isEmpty()

3- 一个方法引用

    String::isEmpty

它们具有相同的功能，每个都可以在需要 `Predicate<String>` 的情况下传递。

如果底层函数不是对象上的方法，则不适用于第三种情况。

<details>
<summary>英文:</summary>

There are three forms that a Predicate can take.  Here they are for `isEmpty` on a String:

1- A formal functional interface:

    Predicate&lt;String&gt; somePredicate = new Predicate&lt;String&gt;() {
        @Override
        public boolean test(String s) {
            return s.isEmpty();
        }
    };

2- A lambda:

    (String s) -&gt; s.isEmpty()

3- A method reference

    String::isEmpty

These have identical function and can each be passed when a `Predicate&lt;String&gt;` is required.

The third doesn&#39;t apply if the underlying function is not a method on an object.


</details>