Heap Sort with Max and Min Order

import java.util.*;

public class Heap {
    private int data[];
    private int size;
    private SortType sType;

    public enum SortType {
        HEAP_MAX, HEAP_MIN
    }

    public Heap(int data[], SortType t) {
        this.data = data;
        size = data.length;
        sType = t;
        System.out.printf("orig order: %s\n", Arrays.toString(data));
        System.out.printf("total len: %d\n", size);
        for (int i=size/2; i>=0; i--) {
            if (sType == SortType.HEAP_MAX)
                heapifyMax(i);
            else
                heapifyMin(i);
        }
    }

    public void sort() {
        for (int i=data.length-1; i>=0; i--) {
            int nextItem = removeNext();
            data[i] = nextItem;
        }
    }

    public int removeNext() throws NoSuchElementException {
        int root = data[0];

        if (size == 0) {
            throw new NoSuchElementException();
        }
        data[0] = data[--size];
        if (sType == SortType.HEAP_MAX)
            heapifyMax(0);
        else
            heapifyMin(0);
     
        System.out.printf("heap len: %d, removed item %d\n", size, root);
     
        return root;
    }

    private int leftChild(int i) { return 2*i+1; }
    private int rightChild(int i) { return 2*i+2; }
    private void heapifyMax(int i) {
        int l=leftChild(i);
        int r=rightChild(i);
        int largestElementIdx = -1;

        if (l <= size-1 && data[i] < data[l]) {
            largestElementIdx = l;
        } else {
            largestElementIdx = i;
        }
        if (r <= size-1 && data[largestElementIdx] < data[r]) {
            largestElementIdx = r;
        }
        if (largestElementIdx != i) {
            int temp = data[i];
            data[i] = data[largestElementIdx];
            data[largestElementIdx] = temp;

            heapifyMax(largestElementIdx);
        }
    }

    private void heapifyMin(int i) {
        int l=leftChild(i);
        int r=rightChild(i);
        int largestElementIdx = -1;

        if (l <= size-1 && data[i] > data[l]) {
            largestElementIdx = l;
        } else {
            largestElementIdx = i;
        }
        if (r <= size-1 && data[largestElementIdx] > data[r]) {
            largestElementIdx = r;
        }
        if (largestElementIdx != i) {
            int temp = data[i];
            data[i] = data[largestElementIdx];
            data[largestElementIdx] = temp;

            heapifyMin(largestElementIdx);
        }
    }

    public static void main(String[] args) {
        int A[] = new int[]{ 4, 4, 1, 1, 3, 2, 16, 9, 10, 14, 8, 7, 232, 435, 435, 3565, 3565};
     
        Heap MinHeap = new Heap(A, SortType.HEAP_MIN);
        MinHeap.sort();
        System.out.println("after sort:" + Arrays.toString(A));

        System.out.println("======================================");

        Heap MaxHeap = new Heap(A, SortType.HEAP_MAX);
        MaxHeap.sort();
        System.out.println("after sort:" + Arrays.toString(A));
     
    }

}

Output:

$ java Heap
orig order: [4, 4, 1, 1, 3, 2, 16, 9, 10, 14, 8, 7, 232, 435, 435, 3565, 3565]
total len: 17
heap len: 16, removed item 1
heap len: 15, removed item 1
heap len: 14, removed item 2
heap len: 13, removed item 3
heap len: 12, removed item 4
heap len: 11, removed item 4
heap len: 10, removed item 7
heap len: 9, removed item 8
heap len: 8, removed item 9
heap len: 7, removed item 10
heap len: 6, removed item 14
heap len: 5, removed item 16
heap len: 4, removed item 232
heap len: 3, removed item 435
heap len: 2, removed item 435
heap len: 1, removed item 3565
heap len: 0, removed item 3565
after sort:[3565, 3565, 435, 435, 232, 16, 14, 10, 9, 8, 7, 4, 4, 3, 2, 1, 1]
======================================
orig order: [3565, 3565, 435, 435, 232, 16, 14, 10, 9, 8, 7, 4, 4, 3, 2, 1, 1]
total len: 17
heap len: 16, removed item 3565
heap len: 15, removed item 3565
heap len: 14, removed item 435
heap len: 13, removed item 435
heap len: 12, removed item 232
heap len: 11, removed item 16
heap len: 10, removed item 14
heap len: 9, removed item 10
heap len: 8, removed item 9
heap len: 7, removed item 8
heap len: 6, removed item 7
heap len: 5, removed item 4
heap len: 4, removed item 4
heap len: 3, removed item 3
heap len: 2, removed item 2
heap len: 1, removed item 1
heap len: 0, removed item 1
after sort:[1, 1, 2, 3, 4, 4, 7, 8, 9, 10, 14, 16, 232, 435, 435, 3565, 3565]