public boolean isPresent() {
return object != null;
}
public boolean isPresent() {
return object != null;
}
public class Obscure<T> {
private T object;
public Obscure(T object) {
this.object = object;
}
public class Obscure<T> {
private T value;
public Obscure(T value) {
this.value = value;
}
public T orElseThrow(Exception e) throws Exception {
if (isPresent()) {
return object;
} else {
throw e;
}
}
public class Obscure<T, E extends Exception> {
public T orElseThrow(E e) throws E {
if (isPresent()) {
return object;
} else {
throw e;
}
}
public static <T> Obscure of(T object) {
return new Obscure<>(object);
}
public static <T> Obscure empty() {
return new Obscure<>(null);
}
public static <T> Obscure<T> of(T object) {
return new Obscure<>(object);
}
public static <T> Obscure<T> empty() {
return new Obscure<>(null);
}
public abstract class Math<T extends Number> {
public static <T> T getMaxValueOfThree(T first, T second, T third) {
T[] array = (T[]) new Object[]{first, second, third};
return getMaxValueArray(array);
}
public abstract class Math {
public static <T extends Number> Number getMaxValueOfThree(T first, T second, T third) {
Number[] array = new Number[]{first, second, third};
return getMaxValueArray(array);
}
public class MathTests {
static Stream<Arguments> provideArgumentsGetMaxValueArray() {
return Stream.of(
Arguments.of(new Integer[]{1, 2, 3}, 3),
Arguments.of(new Integer[]{3, 1, 5, 7}, 7),
Arguments.of(new Integer[]{6, 2}, 6)
);
}
@ParameterizedTest
@MethodSource("provideArgumentsGetMaxValueArray")
void testGetMaxValueArray(Integer[] array, int expected) {
int actual = Math.getMaxValueArray(array);
assertEquals(expected, actual);
}
public static <K extends Number> K getMax(K ... numbers) {
// code
}
@ParameterizedTest
@MethodSource("orElseThrowProviderArguments")
void orElseThrowTest(T obscure, String expectedResult) {
Obscure<T> obscure1 = new Obscure<>(obscure);
String actualResult;
try {
actualResult = (String) obscure1.orElseThrow(new Exception("This is NullPointerException"));
} catch (Exception ex) {
actualResult = ex.getMessage();
}
Assertions.assertEquals(actualResult, expectedResult);
}
public static Number getMaxValueInArray(Number[] array) {
sort(array);
Number result = array[array.length - 1];
return result;
}
public class Pair<K, V> {
private K field1;
private V field2;
...
}
public T orElseThrow() {
if (element != null) {
return element;
} else {
throw new NullPointerException("This is NullPointException!");
}
}
public class PairDemo {
public static void main(String[] args) {
Pair<Integer, Integer> pair = new Pair<>(50,60);
System.out.printf("%s %s \n", pair.getK(), pair.getV());
Pair pair1 = pair.getSwapped();
System.out.printf("%s %s \n", pair1.getK(), pair1.getV());
}
}
public abstract class Math<T> {
public static <T> int findMaximum(int value1, int value2, int value3) {
if (value1 > value2 && value1 > value3) {
return value1;
} else if (value2 > value1 && value2 > value3) {
return value2;
} else {
return value3;
}
}
...
}