Well it looks like you just want:

for(int i = 10; i >= 0; i--){
    System.out.println(i);
    System.out.println(10 - i);
} 

Is that the case? Personally I'd normally write this as an increasing loop, as I find it easier to think about that:

for (int i = 0; i <= 10; i++) {
    System.out.println(10 - i);
    System.out.println(i);
} 

Note that your string example is really inefficient, by the way - far more so than introducing an extra variable. Given that you know the lengths involved to start with, you can just start with two char[] of the right size, and populate the right index each time. Then create a string from each afterwards. Again, I'd do this with an increasing loop:

char[] forwardChars = new char[str.length()];
char[] reverseChars = new char[str.length()];
for (int i = 0; i < str.length(); i++) {
    forwardChars[i] = str.charAt(i);
    reverseChars[reverseChars.length - i - 1] = str.charAt(i);
}
String forwardString = new String(forwardChars);
String reverseString = new String(reverseChars);

(Of course forwardString will just be equal to str in this case anyway...)

I recommend the following because comparison against zero is optimized at the byte code level.

for(int idx=(len-1); idx>=0; idx--) {...}

This is a suggestion from Java Performance Tuning by Jack Shirazi

e is the exponent and that while loop is doubling the value of the number until the exponent is less than or equal to 0.

It will remain the value of i unless it is decremented.

You could also convert it into a for loop like so

for (int e = i; e > 0; e--) { 
    result *= 2;
} 

I understand if this is a learning exercise, but the Math.pow function could do the same thing.

You want to decrease the loop values in incremental of 1 right? Here you need to update the code as below.

public class Loop {

    public static void main(String[] args) {

        int x=50, y= 1;
        do {

          System.out.println("X is = " + x);             
          if (x >= 0) {
            x -=y++;
          }
        }while(x>=40);
    }
}

In above example,
For decrement I've used x and for increment I've used y so loop will turn from 50 - 40 and y will helpfull to decrese values in Incremental form.

Updated answer

@Goion has suggested, you can use for-loop

public class Loop {

    public static void main(String[] args) {

        int y= 1; //To decrese 'x' in incremental order of `y`

        for(int x=50; x>=40; x-=y++){
          System.out.println("X: " + x);
        }
    }
}

I think you mean > instead of <:

for (int i = 10; i > 0; --i) {

If you want the values of i to be the same as in the original code except in reverse order (i.e. 9, 8, 7, ..., 1, 0) then you also need to change the boundaries:

for (int i = 9; i >= 0; --i) {

This is because in bytecode comparison with 0 is a different operation than comparison with a non-zero number. Actually i < 10001 requires to first load the number on stack then execute comparison, while i > 0 is executed as one operation. Of course there will be no speed difference in most cases because of JVM optimizations. But we can try to make it visible by running the code with -Xint option (interpreted mode execution only).

Each for loop can be replaced with a while loop. The initializing statement (1st part of for) comes first, then the conditional loop (condition: 2nd part of for), and the loop statement (3rd part of for) is executed right before the loop repeats.

Your loop:

    for (i = n; i >= 1; --i)
    {
        printf("%d ", i);
    }

is equivalent to:

    i = n;
    while (i>=1)
    {
        printf("%d ", i);
        --i;
    }

So the output is correct, and your expectation is wrong.

But why has the for loop the loop statement in its parentheses, so that some beginners assume it executes before the loop body?

This shows the coherence between all the loop's parts. Consider a loop body of multiple lines. The trailing loop statement (for example, increment the index) would be far away from the leading initialization statement and the condition. And this is more work for your brain to grasp.