Popularity
2.4
Growing
Activity
3.7
Declining
48
3
1

Description

SneakyThrow is a Java library to ignore checked exceptions. You can also used inside of Java 8 streams.

Programming language: Java
Tags: Development     Java     Exception Handling    
Latest version: v1.2.0

SneakyThrow alternatives and similar libraries

Based on the "Development" category

Do you think we are missing an alternative of SneakyThrow or a related project?

Add another 'Development' Library
Monitoring and distributed tracing for Java apps. 14-day free trial.
More from our partner

Popular Comparisons

SaaSHub - Software Alternatives and Reviews
More from our team

README

SneakyThrow

Build Status Coverage Status MIT Licence Maven Central Javadocs

SneakyThrow is a Java library to ignore checked exceptions. You can integrate it using maven:

<dependency>
  <groupId>com.rainerhahnekamp</groupId>
  <artifactId>sneakythrow</artifactId>
  <version>1.2.0</version>
</dependency>

SneakyThrow Usage GIF

Usage

Without SneakyThrow:

URL url;
try {
  url = new URL("https://www.hahnekamp.com");
} catch (MalformedURLException mue) {
  throw new RuntimeException(mue);
}

With SneakyThrow:

URL url = sneak(() -> new URL("https://www.hahnekamp.com"));

Usage with Java 8 Streams

private URL createURL(String url) throws MalformedURLException {
  return new URL(url);
}

The function above used within a Stream without SneakyThrow:

Stream
  .of("https://www.hahnekamp.com", "https://www.austria.info")
  .map(url -> {
    try {
      return this.createURL(url);
    } catch (MalformedURLException mue) {
      throw new RuntimeException(mue);
    }
  })  
  .collect(Collectors.toList());

Again with SneakyThrow:

Stream
  .of("https://www.hahnekamp.com", "https://www.austria.info")
  .map(sneaked(this::createURL))
  .collect(Collectors.toList());

The static method sneaked wraps each function, that has the same signature as a functional interface (java.util.functional).

Please note the difference between sneak and sneaked.

How it works

This project is heavily influenced by ThrowingFunction.

In SneakyThrow, each functional interface, defined in java.util.function, has an equivalent one with the same signature. The only difference is, that these "Sneaky Functional Interfaces" throw exceptions. This gives us the possibility to write lambdas or similar code that also throws exceptions.

Both sneak and sneaked wrap the passed "Sneaky Functional Interfaces" into a try/catch clause and return the equivalent java.util.function interface. In the case of sneak, execution and the return of the result is done immediately.


*Note that all licence references and agreements mentioned in the SneakyThrow README section above are relevant to that project's source code only.