JAVA - 1000 Zahlen der Größe nach ordnen

[hamsterfreund]

Guten Abend allerseits,

gleich vorneweg sollte ich erwähnen, dass ich kein guter Programmierer bin. Punkt.

Ich habe mir dennoch das folgende Programm, aus einem anderen Programm, das ich im Netz gefunden habe, zusammengeschustert.

Das Programm sortiert Zahlen von klein nach groß. Das ist deshalb nötig, weil diese später in einer Grafik verarbeitet werden sollen.


Was das Programm macht (bzw. machen sollte):

Zu Beginn gibt man also die Anzahl der Zahlen ein, die sortiert werden sollen und danach die entsprechenden Zahlen.
Von Hand klappt das alles ganz wunderbar.

Soweit so gut, aber ich habe dieses Programm „zusammengekloppt“ um damit exakt 1000, teilweise sehr lange, ganzzahlige Zahlen von einer Textdatei einzulesen, zu sortieren und wieder auszugeben, was von Hand viel zu aufwendig wäre.

Gebe ich jetzt also über die Eingabeaufforderung den Befehl

„java sort2 < sort2input.txt > sort2output.txt“

ein, so erhalte ich nur folgende Meldung:


„Exception in Thread „main“ java.lang.NullPointerException
at sort2.initArray(sort2.java:22)
at sort2.main(sort2.java:113)“


Die Input-Textdatei befindet sich übrigens im gleichen Ordner. Sie beginnt in der ersten Zeile mit 1000 (Die Anzahl) und dann folgen die 1000 Werte. Jeder Wert in einer Zeile. Daran sollte es also nicht liegen.

Ich hoffe ihr könnt mir helfen, bin gerade ziemlich am verzweifeln. Von Hand gebe ich das bestimmt nicht ein

 

[platin91]

Java dazu zu bringen mit der cmd zu kommunizieren ist vermutlich nicht die beste Idee.
Wie wärs wenn du einfach 2 Argumente (Input und Output File) mitgibst und dann einen BufferedWriter für args[1] zum schreiben und einen BufferedReader für args[0] als Input nimmst?
Dann schön eine .jar packen und eine Verknüpfung für die Parameter.

Sonst hat dir die VM doch gesagt wo das Problem ist:
Zeile 22: wert = Integer.parseInt( zeile.trim()); wird nach dem letzten Element null lesen.

Ich würde das grob so machen (sollte schon funktionieren):

public static void main(String[] args) {
	if (args.length < 2) throw new IllegalArgumentException();
	String line;
	try {
		BufferedReader r = new BufferedReader(new FileReader(args[0]));
		line = r.readLine();
		if (line == null) throw new IllegalArgumentException();
		int[] in = new int[Integer.parseInt(line)];
		for (int i = 0; i < in.length; i++) {
			line = r.readLine();
			if (line == null) throw new IllegalArgumentException();
			in[i] = Integer.parseInt(line);
		}
		r.close();
		mergeSort(in);
		BufferedWriter w = new BufferedWriter(new FileWriter(args[1]));
		//Wenn die Länge oben dazu soll: w.write(""+in.length); w.newLine();
                for (int i : in) {
			w.write(""+i);
			w.newLine();
		}
		w.close();
	} catch (IOException e) { throw new RuntimeException(); }
}

 

[hamsterfreund]

Hi platin,

erst mal viel Dank für deine Antwort. Leider weiß ich jetzt nicht so ganz, was ich jetzt damit anfangen soll. Wie gesagt, ich bin kein guter Programmierer

Ich habe jetzt jedenfalls meine main-Methode durch deine ersetzt, aber wie bekomme ich jetzt meine 1000 Zahlen in das Programm?

Ich habs noch mal mit der cmd versucht, aber die knallt mir nur das hier an den Kopf:

„Exception in thread "main" java.lang.IllegalArgumentException
at cb.main(cb.java:103)“

Die selbe Exception kommt auch im Editor, sobald ich das Programm compiliert und auf ausführen geklickt habe.

Die einzulesende Textdatei sieht ungefähr so aus, falls das etwas hilft:

„1000 (falls man die Anzahl am Anfang benötigt)
18576123
4876535
-45322
...
...
...
1487626 (1000. Wert)“





neuer Programm-Code:

 import java.io.*;

public class sort2 {
    
    
    static int[] initArray (int anzahl)  throws IOException  {
        
        String zeile;
        
        int wert;
        
        BufferedReader stdin = new BufferedReader (new InputStreamReader (System.in));
        
        int[] feld;
        
        feld = new int [anzahl];
        
        for (int i = 0; i < anzahl; i++)
        {
            zeile = stdin.readLine();
            
            wert = Integer.parseInt( zeile.trim());
            
            feld [i] = wert;
        }
        
        return feld;
        
    }
    
    /*
     * Hilfsmethode: Ausgabe der Elemente eines Feldes
     */
    static void printArray (int[] array) {
        for (int i = 0; i < array.length; i++)
            System.out.print (array[i] + "\n");
    }
    
    /*
     * Hilfsmethode: Austauch zweier Feldelemente
     */
    static void swap (int[] array, int idx1, int idx2) {
        int tmp = array[idx1];
        array[idx1] = array[idx2];
        array[idx2] = tmp;
    }
    
    static void insertionSort (int[] array) {
        for (int i = 1; i < array.length; i++) {
            int marker = i;
            int temp = array[i];
            // f?r alle Elemente links vom Marker-Feld
            while (marker > 0 && array[marker - 1] > temp) {
                // verschiebe alle gr??eren Element nach hinten
                array[marker] = array[marker - 1];
                marker--;
            }
            // setze temp auf das freie Feld 
            array[marker] = temp;
        }
    }
    
    /*
     * Implementierung des MergeSort
     */
    
    // Hilfsmethode f?r rekursives Sortieren durch Mischen
    static void msort (int[] array, int le, int ri) {
        int i, j, k;
        int[] b = new int[array.length];
        
        if (ri > le) {
            // zu sortierendes Feld teilen
            int mid = (ri + le) / 2;
            // Teilfelder sortieren
            msort (array, le, mid);
            msort (array, mid + 1, ri);
            
            // Hilfsfeld aufbauen
            for (k = le; k <= mid; k++)
                b[k] = array[k];
            for (k = mid; k < ri; k++)
                b[ri + mid - k] = array[k + 1];
            
            // Ergebnisse mischen ?ber Hilfsfeld b
            i = le; j = ri;    
            for (k = le; k <= ri; k++)
                if (b[i] < b[j])
                    array[k] = b[i++];
                else
                    array[k] = b[j--];
            
        }
    }
    
    static void mergeSort (int[] array) {
        msort (array, 0, array.length - 1);
    }
    
    
    
    public static void main(String[] args) {
        if (args.length < 2) throw new IllegalArgumentException();
        String line;
        try {
            BufferedReader r = new BufferedReader(new FileReader(args[0]));
            line = r.readLine();
            if (line == null) throw new IllegalArgumentException();
            int[] in = new int[Integer.parseInt(line)];
            for (int i = 0; i < in.length; i++) {
                line = r.readLine();
                if (line == null) throw new IllegalArgumentException();
                in[i] = Integer.parseInt(line);
            }
            r.close();
            mergeSort(in);
            BufferedWriter w = new BufferedWriter(new FileWriter(args[1]));
            //Wenn die Länge oben dazu soll: w.write(""+in.length); w.newLine();
            for (int i : in) {
                w.write(""+i);
                w.newLine();
            }
            w.close();
        }
        catch (IOException e) {
            throw new RuntimeException(); 
        }
    }
    
}

 

[platin91]

Willst du dieses Programm in einem anderen Programm aufrufen?
Wenn nicht: .jar aus der Klasse erstellen und dann keine Verknüpfung auf die .jar mit 2 Argumenten:
C:\sort2.jar C:/EingabeDateiMitZahlen C:/AusgabeDatei

Oder: java sort2 sort2input.txt sort2output.txt
müsste auch gehen

 

[hamsterfreund]

Hi platin,

vielen, vielen Dank. Es funktioniert wunderbar



Dafür bestell ich bei dir jetzt auch 2 l Klabusterbeerentee für meine liebsten Feinde. Selbstverständlich lauwarm serviert

 

[platin91]

Kein Problem, immer gerne.
Übrigens sorry für die Faulheit bei den Exceptions

Mit dem Klabusterbeerentee musst du dich beeilen, den wollen viele haben
die von Kollegen auf der Arbeit genervt werden

 

[IceMatrix]

Wenn das Projekt unter Linux laufen soll kannst du es dir auch seeeeeeehr viel einfacher machen:

sort -n sort2input.txt > sort2output.txt

 

[asdfman]

Denke auch, eine so aufgeblasene Sache wie Java wird ja wohl ein Sortierverfahren anbieten.
Selbst C hat ja qsort() (Eine Funktion höherer Ordnung! Selten in C. Wollt ichnur mal anmerken)

 

[Tumbleweed]

Guter Einwand. Sowohl Arrays.sort() als auch Collections.sort() ersparen in solchen Fällen viel Schreibarbeit.

 

[platin91]

Natürlich geht das viel einfacher, aber wenn er das schon zusammengesucht
hat kann man ihm doch auch einfach eine neue main-Methode spendieren oder nicht?

 

[asdfman]

Durch Zusammensuchen lernt man genau so viel über Sortieren, wie wenn man vorgefertigte Funktionalität nimmt,
nämlich gar nichts. Und warum die Arbeit machen, wenn man keinen Nutzen davon hat?

Wenn man lernen will, wie Sortieralgorithmen funtionieren und wie man sie implementiert, ist das natürlich eine
ganz andere Sache. Da sind vorgefertigte Features dann sinnlos. Nur den Eindruck macht OP halt nicht.