Упростить цикл

for(int i=0;i<n;i++){
            for(int j=i;j<n;j++){
                flag=false;
                if(mass[j]>mass[i]){mass[i]=mass[j];flag=true; break;}
                
            }
            if (flag==false){mass[i]=0;}
        }

import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.Scanner;
 
public class zadacha1 {
    public static void main(String[] args)
    {
        int n = 0;
        int[] mass=new int[1000];
        try{
            Scanner sc = new Scanner(new File("Input.txt"));
            while(sc.hasNext()){
                n=sc.nextInt();
            for(int i=0; i<n; i++){
                mass[i]=sc.nextInt();
                
               }
            }           
            sc.close();
        }
        catch(FileNotFoundException e){}
        boolean flag=false;
        for(int i=0;i<n;i++){
            for(int j=i;j<n;j++){
                flag=false;
                if(mass[j]>mass[i]){mass[i]=mass[j];flag=true; break;}
                
            }
            if (flag==false){mass[i]=0;}
        }
        
        try{
            PrintWriter pw = new PrintWriter(new File("output.txt"));
            for(int i=0;i<n;i++){
                pw.print(mass[i]+" ");
            }
            pw.println();
            pw.close();}catch(Exception e){}
        
        
        
 
    }
}

import java.util.Arrays;
import java.util.Stack;
 
public class Zadacha {
    static long start, stop;
    static int[] original = { 1, 2, 3, 4, 6, 7, 9, 1, 2, 4, 3, 6, 5, 6 };
    static int[] a;
    static int[] must =     { 2, 3, 4, 6, 7, 9, 0, 2, 4, 6, 6, 0, 6, 0 };
    static int[] b;
 
    public static void main(String[] args) {
 
        init();
        psilon(a);
 
        System.out.println("original " + Arrays.toString(original));
        System.out.println("psilon   " + Arrays.toString(a));
        System.out.println("must be  " + Arrays.toString(must));
 
        // the mutagens way
        System.out.println();
        
        init();
        mutagen(a);
 
        System.out.println("original " + Arrays.toString(original));
        System.out.println("mutagen  " + Arrays.toString(b));
        System.out.println("must be  " + Arrays.toString(must));
    }
 
    static void init() {
        a = original.clone();
    }
 
    static void shrinkStack(int pretender, Stack<Integer> stack) {
        if (stack.size() != 0 && stack.firstElement() <= pretender) {
            stack.clear();
            stack.push(pretender);
        } else {
            stack.push(pretender);
        }
    }
 
    static int compareStack(int pretender, Stack<Integer> stack) {
        for (int j = stack.size() - 1; j >= 0; j--) {
            if (pretender < stack.get(j)) {
                return stack.get(j);
            }
        }
        return 0;
    }
 
    static void mutagen(int[] a) {
        b = new int[a.length];
        Stack<Integer> stack = new Stack<Integer>();
        stack.push(a[a.length - 1]);
        b[b.length - 1] = 0;
        for (int i = a.length - 1; i > 0; i--) {
            if (a[i - 1] < a[i]) {
                shrinkStack(a[i], stack);
//               stack.push(a[i]);
                b[i - 1] = a[i];
            } else {
                b[i - 1] = compareStack(a[i - 1], stack);
            }
        }
    }
 
    static void psilon(int[] a) {
        for (int i = a.length - 1, j; i > 0;) {
            j = i;
            for (; j > 0 && a[j - 1] < a[j]; j--) {
                a[j - 1] = a[j];
            }
            a[i] = 0;
            i = j - 1;
        }
    }
 
}

original [1, -2, 8, 3, 5]
psilon   [8, 8, 0, 5, 0]
 
original [1, -2, 8, 3, 5]
mutagen  [8, 8, 0, 5, 0]

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Random;
import static java.lang.System.out;
 
public class Zadacha {
    static long start;
    static int[] original = { 1, 2, 3, 4, 6, 7, 9, 1, 2, 4, 3, 6, 5, 6 }; 
    static int[] a;
    static int[] mustBe = { 2, 3, 4, 6, 7, 9, 0, 2, 4, 6, 6, 0, 6, 0 };
 
    public static void main(String[] args) throws NoSuchMethodException, SecurityException {
 
        out.println("logic test\n");
        
        init();
        psilon();
        print("psilon");
 
        out.println();
 
        mutagen();
        print("mutagen");
 
        out.println();
 
        out.println("Timing test");
        out.println();
 
        // time test
        Random r = new Random();
        int size = 1000000;
        original = new int[size];
        for (int i = 0; i < original.length; i++) {
            original[i] = r.nextInt();
        }
 
        init();
        out.println("mutagen takes " + timeTest(Zadacha.class.getDeclaredMethod("mutagen", null)) + " ms for "
                + size + " elements");
 
        init();
        out.println("psilon takes " + timeTest(Zadacha.class.getDeclaredMethod("psilon", null)) + " ms for "
                + size + " elements");
    }
 
    static void init() {
        a = original.clone();
    }
 
    static void shrinkStack(int pretender, LinkedList<Integer> stack) {
        if (stack.getFirst() <= pretender) {
            stack.clear();
            stack.push(pretender);
        } else {
            stack.push(pretender);
        }
    }
 
    static int compareStack(int pretender, LinkedList<Integer> stack) {
        for (Integer j : stack) {
            if (pretender < j)
                return j;
        }
        return 0;
    }
 
    static void mutagen() {
        LinkedList<Integer> stack = new LinkedList<Integer>();
        stack.push(original[original.length - 1]);
        a[a.length - 1] = 0;
        for (int i = a.length - 1; i > 0; i--) {
            if (original[i - 1] < original[i]) {
                shrinkStack(a[i], stack);
                a[i - 1] = original[i];
            } else {
                a[i - 1] = compareStack(a[i - 1], stack);
            }
        }
    }
 
    static void psilon() {
        for (int i = a.length - 1, j; i > 0;) {
            j = i;
            for (; j > 0 && a[j - 1] < a[j]; j--) {
                a[j - 1] = a[j];
            }
            a[i] = 0;
            i = j - 1;
        }
    }
 
    static void print(String who) {
        out.println("original " + Arrays.toString(original));
        out.println(String.format("%-7s  %s", who, Arrays.toString(a)));
        out.println("must be  " + Arrays.toString(mustBe));
    }
 
    static long timeTest(Method m) {
        start = System.currentTimeMillis();
        try {
            m.invoke(null, null);
        } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
            e.printStackTrace();
        }
        return System.currentTimeMillis() - start;
    }
 
}