Sorting integers in descending order So, I coded a program which asks you the number of integers and the integers the user wants to sort in descending order. The program works but I feel like it is very inefficient. If I were to receive high amount of numbers the program would have to do so much processing. Therefore, how can I improve my code in simple ways? (Open to any criticism) 

import java.util.Scanner;


public class Main {
private static Scanner scanner = new Scanner(System.in);
private static Scanner scanner2 = new Scanner(System.in);

public static void main(String[] args) {
    System.out.println("How many integers do you want to sort?");
    int[] IntArray = getIntegers(scanner.nextInt());
    IntArray = sortIntegers(IntArray);
    printIntegers(IntArray);

}

public static int[] getIntegers(int number) {
    System.out.println("Enter " + number + " integers.");
    int[] values = new int[number];

    for (int i = 0; i &lt; values.length; i++) {
        values[i] = scanner2.nextInt();
    }
    return values;
}

public static int[] sortIntegers(int[] array){
    int[] unsortedArray = new int[array.length];
    for(int i = 0; i &lt; unsortedArray.length; i++){
        unsortedArray[i] = array[i];
    }

    for(int n = 0; n &lt; unsortedArray.length - 1; n++) {
        for (int j = 0; j &lt; unsortedArray.length - 1; j++) {
            if (unsortedArray[j] &lt; unsortedArray[j + 1]) {
                int k = unsortedArray[j];
                unsortedArray[j] = unsortedArray[j + 1];
                unsortedArray[j + 1] = k;
            }
        }
    }
    return unsortedArray;
}

public static void printIntegers(int[] array){
    for(int i = 0; i &lt; array.length; i++){
        System.out.println(array[i]);
    }
}
}
Extending on @yuri's answer, if you don't have any information relative to the state of "sortedness" of the numbers, quicksort is almost certainly a better option.  If you happen to know that the numbers are almost sorted, it would be more efficient to use insertion sort at that point.  Writing a sorting algorithm as an exercise is fine, but you're likely going to want to prefer to use Collections.sort than write your own unless you have a specific reason not to.  

A few other tips:


IntArray is not a typical variable name in Java.  Variable names should start lowercase.  
There's really no reason to use two Scanner instances.  You can use the same instance to read the initial array amount as well as each value.
While we're at it, there's no reason to specify the number count.  The program would be more robust if you simply used a List (ArrayList implementation would work best here) and added values until you receive a non-number input like "end".  
Generally static class members should really only exist to define constants in your class, and not hold state.  Everything in your program is static, so you don't require state except for the Scanner instance.  Normally you'd simply pass Scanner instance as a parameter to the static method, but you're only using it in the one method getIntegers so you could just instantiate Scanner only in the scope of getIntegers rather than use it as a parameter or class member.
There is already a simple means to print out contents of a List:  List.toString.  
In the off chance that an exception is thrown by Scanner (or any stream), we surround the reading with a try.. finally to ensure that no matter what, the scanner instance is closed properly.
Note that I maintained use of List rather than convert to an array.  This is mostly because ultimately an array is only required to print out.  We can accomplish everything we need using List, and most professional programmers tend to prefer the use of List over arrays except for specific circumstances.


Applying the changes above, we get the following:

public class Main {
    public static void main(String[] args) {
        List&lt;Integer&gt; intList = getIntegers();
        intList = sortIntegers(intList);

        printIntegers(intList);
    }

    public static List&lt;Integer&gt; getIntegers() {
        System.out.println("Please provide integers and 'done' when finished.");

        List&lt;Integer&gt; values = new ArrayList&lt;Integer&gt;();
        Scanner scanner = new Scanner(System.in);
        try {
            while(scanner.hasNextInt()) {
                values.add(scanner.nextInt());
            }
        } finally {
            scanner.close();
        }

        return values;
    }

    public static List&lt;Integer&gt; sortIntegers(List&lt;Integer&gt; list) {
        Collections.sort(list, Collections.reverseOrder());
        return list;
    }

    public static void printIntegers(List&lt;Integer&gt; list) {
        System.out.println(list.toString());
    }
}