How to check whether value is not present or just has no value?

I am new to Java and Optional. Here I have an unsorted array of primes.

List<Integer> primes = Arrays.asList(3, 7, 5, 2, 13, 11);
int getPrime()
{
 primes.sort(); //using Comparator
 return (primes.stream()
            .filter(prime -> prime>15)
            .findFirst()
            .orElseThrow(() -> new NoSuchElementException("No such number")));
}

Case A : I want to return the first prime number > 7 - works well.

Case B : I want to return the first prime number > 15

Case C : The list is empty / for some reason, it is not able to access list.

In case B & C ; the same NoSuchElementException is thrown. There is a difference between totally failing to fetch and being able to fetch but not get a valid number.

How can I change this code without it being too complicated such that these cases are checked?

You could first check for any element and throw an exception otherwise and them filter the stream.

int getPrime() {
    if (primes.isEmpty()) 
        throw new NoSuchElementException("Empty list is given.")));

    primes.sort(); //using Comparator

    return (primes.stream()
            .filter(prime -> prime > 15)
            .findFirst()
            .orElseThrow(() -> new NoSuchElementException("Element could not be found.")));
}

You can try

if(primes.size() == 0) throw new MyExcceptionForFailedToFetch();

But you better throw exception from fetching code.

I don't agree with your statement:

> There is a difference between totally failing to fetch and being able
> to fetch but not get a valid number.

Let me explain.

A guideline for exceptions is that behaviour within the contract of a method should produce appropriate return values, and cases where the method cannot fulfill its contract result in an exception.

So, what's the "contract" of your method? You want it to search for the smallest prime greater than a given threshold (at least, that's how I understand it). And my reasoning is based on that abstraction.

Mathematically, there will always exist such a prime number, so an ideal implementation of that contract would always have an answer. The given implementation has its limitations, so there are cases where it cannot fulfill its contract. In these cases, throwing an exception is the right thing to do.

You are listing two distinct cases of failure, the primes list being empty (or inaccessible - a rare situation already throwing its own exception, so we can ignore that for the rest of the discussion) vs. the list not containing a prime bigger than your threshold.

Two me, this distinction doesn't matter. In both cases the primes list is too short for the requested threshold, with zero elements just being an extreme case of "too short". In both cases, it would be wrong to return a value, instead, an exception should be thrown, so the caller knows the question hasn't been answered. You're already doing this.

The caller might be interested in the failure reason (most of the time, he just needs to know that the call failed and doesn't care why). That's expressed in the exception type plus its message. For my understanding, a NoSuchElementException is not the choice that best expresses the failure reason. It's documented as "Thrown by various accessor methods to indicate that the element being requested does not exist." In the context of search for the smallest prime greater than a given threshold I can imagine two different interpretations of applying that specification:

• "element" to mean the mathematical prime. As we said, it surely exists, so we'd result in a false statement "Thrown ... to indicate that the next higher prime does not exist."
• "element" to mean the element in the list of prime numbers. Then the statement is correct ("Thrown ... to indicate that the appropriate element in the primes list does not exist"). But it's irrelevant to a caller, as it talks about some implementation detail that should the caller should not even know about: the fact that the method uses a predefined prime-numbers list in its computation.

I'd prefer an UnsupportedOperationException (documented as "Thrown to indicate that the requested operation is not supported.", which in my opinion perfectly matches the failure.

So, the only thing I'd change in your code would be throwing a new UnsupportedOperationException("primes list too short") instead of the NoSuchElementException.

I hope this could fix your problem, without using streams.

public static void main(String[] args) {
		List<Integer> primes = Arrays.asList(3, 7, 5, 2, 13, 11);
		if(!primes.isEmpty()) {
			 Collections.sort(primes);
			 for(int i : primes) {
				 if(i > 15) {
					 System.out.println(i);
						 break;
				 }
			 }
		}else {
			System.out.println("Empty list is given");
		}
    }