Throw exception if invald input

[shashank dwivedi]

I want to achieve something like this in functional way. Any help ?

public static Function<String[],Void> validateLength3 = (String[] input) -> { if(input.length != 3) throw new  Exception("length not equals 3");}

[Al Hobbs]

looks like a lambda already

[Campbell Ritchie]

It isn't possible to do that in a functional way. The functional style doesn't allow side‑effects, which forbids you to throw an exception.
Maybe you could convert that to a Predicate:-

Predicate<String> length3Predicate = s -> s.length() == 3;
// ...
if (length3Predicate.test(text))
{
   doSomething();
}
else
{
   throw new IllegalArgumentAxception(...);
}

[Stephan van Hulst]

What is functional, according to you?

It doesn't really make sense to create a field of a functional interface. Just write it as a method, and you can just pass the method handle to whatever higher-level function you're calling.

private static void assertLengthOf3(Object[] array) {
  if (array.length != 3)
    throw new IllegalArgumentException(String.format("The length of the array must be 3, but was %d instead.", array.length));
}

...

arrays.stream().peek(MyClass::assertLengthOf3)

You can also create a method that takes the length that needs to be asserted and partially applies it to create a function:

private static Consumer<Object[]> assertLengthOf(int length) {
  return array -> {
    if (array.length != length)
      throw new IllegalArgumentException(String.format("The length of the array must be %d, but was %d instead.", length, array.length));
  };
}

...

arrays.stream().peek(assertLengthOf(3));

If you're looking for a way to throw the exception as part of an expression (so without using an if-statement), then I'm afraid that's not possible in Java, as of version 11.

[Rob Spoor]

A little off-topic, but you usually shouldn't use Void in any of the out-of-the-box functional interfaces. For most situations, there's an alternative that makes the Void superfluous. For instance, a Function<Void, X> can be replaced by a Supplier<X>, and a Function<String[], Void> by a Consumer<String[]>. The latter has as advantage that it doesn't need to return anything. Even with Void, you need to return something. Since you can't instantiate Void, that means you need to return null. By switching to a Consumer<String[]> you no longer have to, the functional interface's method already has void as return type.