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...)

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 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.

change the for loop to:

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

i-=2 is an abbreviation for i = i-2
It means that the new value of i will be the old value of i minus 2.
i-- is an abbreviation for i = i-1, which can be also written as i-=1

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).

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) {