arrays have no concept of negative indices, if you want to traverse from the last to first then you must START at the LAST index and move to the FIRST.

for(i =3; i>0; i--){

   System.out.println(var[i - 1]);

}

Arrays in Java are indexed from 0 to length - 1, not 1 to length, therefore you should be assign your variable accordingly and use the correct comparison operator.

Your loop should look like this:

for (int counter = myArray.length - 1; counter >= 0; counter--) {

Note that in your first loop, i starts at zero and goes up to - but not equals - the length of the array

for (int i = 0 ; i < myArray.length ; i++) {

so the second loop should also start at this position

for (int i = myArray.length - 1; i>= 0  ; i--) {
    System.out.println(myArray[i]);
}

and should go down to zero

Replace your for loop with this:

String read = null;
for(int i=0; i<buffer.length; i++) {
    read = scan.nextLine();
    if(read.equals("quit")) {
        break;
    } else {
        buffer[i] = read;
    }
}

You want to read the new line at the beginning of the loop, not at the end.

No need for libraries, plain Java will do

new StringBuilder("Bird").reverse().toString();

What's most efficient and what is better are usually not the same thing.

The first question you should ask in this situation is how you ended up needing to traverse your data structure in reverse in the first place. Why can't it be built in the correct order at the start?

It's far easier to fix bad code than it is to work with bad data structures. Don't accept this situation if you don't have to.

If you have to, the next question is do you really want to couple the reversing code with the printing code? The second approach makes much more sense when you decouple them.

List<Integer> listInteger = Arrays.asList(array);
Collections.reverse(listInteger);
media.display(listInteger);

display may send it to system out, or load it up in a gui, or print it on paper, or turn it into part of a web page, or ...

The first approach works when you just want a hard coded quick and dirty way to get it on the screen.

As for which is more 'efficient' the first one reuses existing memory while the second makes a copy. If the array is huge enough for that to matter then fine. But why the hell did you create it backwards in first place?

The first makes the computer happy and leaves me mourning the loss of flexibility. The choice of who to make happy is up to you.

Keep in mind, premature flexibility (see BDUF vs YAGNI) is almost as bad as premature optimization. So whatever you do, realize you've already spent too much time thinking about this.

Also, it turns out there is a better way to implement the second option. It's detailed here.