Goldbach's Conjecture using Sieve of Eratosthenes
Efficiency

Post-processing the results from the Sieve of Eratosthenes (isComposite) to produce primes is actually counterproductive.  If the findPairs() code just has a list of primes to work with, then it cannot quickly answer "is n a prime?" for any given n.  Hence, you need to try all pairs of primes, making findPairs() O(|P|2), where |P| is the size of the set of primes.  And that's in addition to the work needed to find those primes.

You would be better off using the raw isComposite array.  Then, for any given p, you can immediately find out whether input - p is also prime.

In your Sieve of Eratosthenes loop, you can use addition instead of multiplication.

Code organization

Mixing input/output code with computation code is poor practice.  I suggest using an Iterator&lt;Integer&gt; to iterate through the results.  Then you can use a nice simple loop in main() to print the results.

Instead of System.out.println(… + … + … + …), use System.out.printf(), which is more readable.  (Actually, System.err would be a better place to send diagnostic output.)

Suggested solution

import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Scanner;

public class GoldbachSums implements Iterable&lt;Integer&gt; {
    private final int sum;
    private final boolean[] ineligible;

    public GoldbachSums(int sum) {
        if (sum &lt;= 2) {
            throw new IllegalArgumentException("Number must be greater than 2.");
        }
        if (sum % 2 &gt; 0) {
            throw new IllegalArgumentException("Number must be even.");
        }
        this.sum = sum;
        this.ineligible = oddSieveOfEratosthenes(sum);
    }

    private static boolean[] oddSieveOfEratosthenes(int max) {
        boolean[] ineligible = new boolean[max];
        ineligible[1] = true;
        for (int i = 3; i * i &lt; max; i += 2) {
            if (! ineligible[i]) {
                for (int j = i * i; j &lt; max; j += i) {
                    ineligible[j] = true;
                }
            }
        }
        return ineligible; 
    }

    @Override
    public Iterator&lt;Integer&gt; iterator() {
        return new Iterator&lt;Integer&gt;() {
            // 4 is the only sum whose decomposition involves an even prime
            private Integer n = (sum == 4) ? 2 : computeNext(sum - 1);
            private final int halfSum = sum / 2;

            private Integer computeNext(int n) {
                for (int i = n; i &gt;= halfSum; i -= 2) {
                    if (!ineligible[i] &amp;&amp; !ineligible[sum - i]) {
                        return sum - i;
                    }
                }
                return null;
            }

            @Override
            public boolean hasNext() {
                return n != null;
            }

            @Override
            public Integer next() {
                if (n == null) {
                    throw new NoSuchElementException();
                } else try {
                    return n;
                } finally {
                    n = computeNext(sum - n - 2);
                }
            }

            // For compatibility with Java &lt; 8
            public void remove() {
                throw new UnsupportedOperationException();
            }
        };
    }

    public static void main(String[] args) {
        try (Scanner scan = new Scanner(System.in)) {
            System.out.print("Please input an integer to decompose as the sum of two primes: ");
            int input = scan.nextInt();

            long startTime = System.nanoTime();
            GoldbachSums goldbach = new GoldbachSums(input);
            long duration = System.nanoTime() - startTime;
            System.err.printf("\nSieve of Eratosthenes took: %d ns or %f seconds.\n",
                              duration, duration * 1e-9);
            duration = System.nanoTime() - startTime;
            for (int addend : goldbach) {
                System.out.printf("%d + %d = %d\n", input - addend, addend, input);
            };
            System.err.printf("\nThis program took: %d ns or %f seconds.\n",
                              duration, duration * 1e-9);
        } catch (IllegalArgumentException badInput) {
            System.out.println(badInput.getMessage());
        }
    }
}