Project Euler #70: Time Efficiency Improvement
Several minutes? My stupid approach takes 1.3 second. It uses precomputed factoring of numbers below 1e7, which itself takes 0.3 s.
List&lt;Integer&gt; l = new ArrayList&lt;Integer&gt;();
int[] primes = Helper.getPrimes(10000050);
for (int i = 378; i &gt;= 1; i--) {
    for (int j = 239118; j &gt; i; j--) {
        BigInteger num = BigInteger.valueOf(primes[i]).multiply(BigInteger.valueOf(primes[j]));
        if (num.compareTo(BigInteger.TEN.pow(7)) &lt; 1) {
            int x = num.intValue();
            System.out.println(primes[i] + &quot; * &quot; + primes[j] + &quot; = &quot; + x);
            l.add(x);
        }
    }
}

BigInteger??? That's the culprit. The solution is a few millions and confortable fits into an int. Using long would give me a good feeling. Using Guava's LongMath.checkedMultiply would give a guaranty I'm not computing non-sense. And so would my saturated arithmetic.
BigInteger.valueOf(primes[i])

this should be done before the inner loop,
or better stored in an array

BigInteger.TEN.pow(7)

this is a contant and shouldn't be recomputing again and again

num.compareTo(BigInteger.TEN.pow(7)) &lt; 1
So you want that num is at most 1e7 and are scared of it overflowing 9e18? How should this happen? Not at all as i * j &lt;= 239118**2.
Another inefficiency: Whenever num gets too big, you know it'll be even bigger for a bigger prime. So if you were iterating upwards, you could use a break. For iterating downwards, you could use one division to determine the initial j.
int y = EulerTotient(x);
In order to compute the totient, you need the factorization. But you just have thrown the primes away! Use a map or alike.
Possibly you've lost several minutes already in this part and needn't read any further.

isPermutation
if (String.valueOf(x).length() != String.valueOf(b).length()) {
    return false;

This takes probably more time than the remaining computation, which is fine. I'd go for
    do {
        ++count[x % 10];
        --count[b % 10];
        x /= 10;
        b /= 10;
        if ((x != 0) != (b != 0)) return false; // different lengths
    } while (x != 0); // also b!=0

And I wouldn't call the arguments x and b as it's confusing (there are interchangeable so should be named similarly).
EulerTotient
Method names should start with a lowercase letter. Not even the best mathematicians deserve any exception.
This part is fine, except for that you need no such computation as you actually know the factorization when you create n. For this computation, you could add
n /= primes[i];

to the if-block and gain some speed due to an earlier loop exit.
getPrimes
No problem here. One can argue that in
        for (int j = i; j * i &lt;= maxValue; j++) {
            isPrime[i * j] = false;
        }

the expression i*j gets computed twice or that you could keep the product in a variable and just add i on each iteration, but that's what JIT excels at. So it's fine as it is.