Immer nur drei Werte lesen

flashdog

Bekanntes Mitglied
Hallo,
folgender Code liest die unteren Zeilen ein und speichert diese in ein ArrayList ab. Anschließend berechnet er aus allen Werten den Medien Wert aus und gibt in aus.
Code:
4 
5 
1 
3 
1 
7 
2 
6 
2 
7 
1

Java:
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;

public class Numbers {
  private ArrayList<Double> ret = new ArrayList<Double>();

  public Numbers(String filename) throws IOException {
    readNumbers(filename);
  }

  public void readNumbers(String fn) throws IOException {
    BufferedReader br = new BufferedReader(new FileReader(fn));

    String line;
    while ((line = br.readLine()) != null) {
      ret.add(Double.parseDouble(line.trim()));
    }
  }

  public double median() {
    Collections.sort(ret);

    if (ret.size() % 2 == 1) {
      return ret.get((ret.size() + 1) / 2 - 1);
    } else {
      double lower = ret.get(ret.size() / 2 - 1);
      double upper = ret.get(ret.size() / 2);

      return (lower + upper) / 2.0;
    }
  }

  public static void main(String[] args) {
    String fileName = "F:\\testFile.txt";

    try {
      Numbers n = new Numbers(fileName);
      System.out.println("Read file " + fileName);
      double median = n.median();
      System.out.println("Median value is " + median);
    } catch (IOException ie) {
      System.err.println("I/O Error: " + ie);
    }
  }
}

Wie könnte man den Code am besten modifizieren damit dieser jeweils aus drei Werten den Medien berechnet und wenn es keine drei Werte existieren dann eben aus dem Rest?

Viele Grüße
 
Ich verstehe nicht so ganz um welche 3 Werte es sich handelt?

Möglichkeit 1:

median of (wert1,wert2 ,wert3)
median of (wert4,wert5 ,wert6)
median of (wert7,wert8 ,wert9)
...

Möglichkeit 2:
median of (wert1,wert2 ,wert3)
median of (wert2,wert3 ,wert4)
median of (wert3,wert4 ,wert5)
...

oder willst du noch was anderes ?
wie viele ergebnise soll es geben ?
 
Drei Werte war nur ein Beispiel um schnell das Programm zu testen. In Wirklichkeit kann die Eingabedatei mehr als 10000 Einträge oder weniger beinhalten und ich möchte jeweils aus 1000 Einträgen den Median bestimmen d.h. ich würde 10 Median (10 X 1000) Werte bekommen.

Die Datei kann also nicht Grade sein z.B. 9999 und dann muss ich noch immer 10 Werte als Ergebnis bekommen (9 X 1000 und 1 X 999).
 
Ich versuche mal hier was in Pseudocode zu skizzieren:
Annahme ALL = 9999 Werte und MEDIAN = 10 (sprich 10 Medians)


zum Klären - Dein Problem besteht darin die ganze Liste in geeignete partitions zu teilen
d.h. 9999 / 10 = 999 und nicht 1000 wie du es haben willst

nun die schnell lösung wie man die partitionsgröße errechnen kann:
Java:
Integer allValues = 9999; // Integer wichtig für die toString() Operation
int Median = 5;
Double tmp = Double.valueOf(allValues );

for(int pos = 0 ; pos < allValues .toString().length()-1;pos++)
    tmp = tmp /10;
		
int fullsize = (int)(Math.ceil(tmp) * Math.pow(10,alleWerte.toString().length()-1) );
// nun hast du 10000 als Ergebnis
int partitionsize = fullsize / Median; // nun hast du deine 1000 schrittweite

1. Datei einlesen und jede Zahl in eine List speichern
2. in einer for schleife:
Java:
for ( int pos = 0; pos < list.size(); pos += partitionsize ) 
// somit hast du die nach jedem schleifen durchlauf 
// jeweils eine partition übersprungen.
{
    // hier den Median der Partition berechnen
    for( int partpos = 0 ; partpos < partitionsize && pos + partpos <  list.size() ; partpos++) 
    {
        // hier die werte der partition aufsammeln vllt. in eine neue List
    }
    //hier hast du eine List mit entweder mit 1000 oder den rest Elementen
   // die kannst du dann deiner funktion übergeben , muss sie aber modifizieren -
// sprich nicht auf member variable zugreifen sondern auf das was du übergeben hast
// (die Liste aus der inneren for schleife) und entsprechend dein ergebnis in eine ergebnis list speichern.

So falls du weiter nciht weisst, dann schreib mal was du nicht verstehst.
Ich hoffe ich könnte zumindest auf die Sprunge helfen.
 
Zuletzt bearbeitet:
Leider habe ich deine Lösung nicht ganz verstanden und habe es nochmal versucht und es scheint zu funktionieren siehe (readNumbers()).

Gibt es eine Möglichkeit den Code zu optimieren z.B.
1.)
BufferedReader br = new BufferedReader(new FileReader(fn));
BufferedReader br = new BufferedReader(new FileInputStream(fn);
Oder gibt es eine andere schnellere Kombination und gibt es irgendwo Benchmarks?

2.)
Ist die Berechnung von Median optimal?

Java:
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;

public class Numbers {

  private ArrayList<Double> medians = new ArrayList<Double>();

  public Numbers(String filename, int lines) throws IOException {
    readNumbers(filename, lines);
  }

  private void readNumbers(String fn, int lines) throws IOException {
    BufferedReader br = new BufferedReader(new FileReader(fn));
    ArrayList<Double> numbersFromFile = new ArrayList<Double>();
    int i = 0;
    String line;
    
    while (true) {
      i++;
      if ((line = br.readLine()) != null) {
        numbersFromFile.add(Double.parseDouble(line.trim()));
        if (i == lines) {
          i = 0;
          median(numbersFromFile);
          numbersFromFile.clear();
        }
      } else {
        median(numbersFromFile);
        numbersFromFile.clear();
        break;
      }
    }
  }

  public void median(ArrayList<Double> values) {
    Collections.sort(values);

    if (values.size() % 2 == 1) {
      medians.add(values.get((values.size() + 1) / 2 - 1));
    } else {
      double lower = values.get(values.size() / 2 - 1);
      double upper = values.get(values.size() / 2);
      medians.add((lower + upper) / 2.0);
    }
  }

  public void output() {
    for (double v : medians) {
      System.out.println(v);
    }
  }

  public static void main(String[] args) {
    String fileName = "F:\\testFile.txt";

    try {
      Numbers n = new Numbers(fileName, 3);
      System.out.println("Read file " + fileName);
      n.output();
    } catch (IOException ie) {
      System.err.println("I/O Error: " + ie);
    }
  }
}
 
Gibt es eine Möglichkeit den Code zu optimieren z.B.

ja, du könntest z.b. den konstruktor dafür hernehmen, wofür er da ist und zwar zum initialisieren der attribute. das was du machst ist imho aus oo-sicht ein grauss. ist jetzt allerdings kein funktionelles problem - eher ein stilistisches.

ansonsten vllt in readNumbers die numberformatexception catchen.

...

ok.. nachdem mir grad beim schreiben immer mehr sachen auffallen, die in meinen augen nicht so optimal sind, hab ich das jetzt mal kurz in eine anständige form gebracht.

ich sag aber gleich, dass ich weder mich tiefer mit dem algo beschäftigt habe, noch zu der uhrzeit für korrektheit garantiere 😀

Java:
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;

public class Numbers {

	private ArrayList<Double> medians;
	private ArrayList<Double> numbersFromFile;
	private String filename;
	private int lines;

	public Numbers(String filename, int lines) {
		medians = new ArrayList<Double>();
		numbersFromFile = new ArrayList<Double>();
		this.filename = filename;
		this.lines = lines;
	}
	public void setFilename(String filename) {
		this.filename = filename;
	}
	public String getFilename() {
		return filename;
	}
	public void setLines(int lines) {
		this.lines = lines;
	}
	public int getLines() {
		return lines;
	}
	private void readNumbers() throws IOException {
		BufferedReader br = new BufferedReader(new FileReader(filename));
		int i = 0;
		String line;
		try {
			while ((line = br.readLine()) != null) {
				numbersFromFile.add(Double.parseDouble(line.trim()));
				if (++i == lines) {
					i = 0;
					median();
				}
			} 
			median();
		} catch (NumberFormatException nfe) {
			System.out.println("Fehlerhafte Entität in der Eingabedatei! Java Fehler: " + nfe.getMessage());
		} finally {
			br.close();
		}
	}
	private void median() {
		Collections.sort(numbersFromFile);
		if (numbersFromFile.size() % 2 == 1) {
			medians.add(numbersFromFile.get((numbersFromFile.size() + 1) / 2 - 1));
		} else {
			double lower = numbersFromFile.get(numbersFromFile.size() / 2 - 1);
			double upper = numbersFromFile.get(numbersFromFile.size() / 2);
			medians.add((lower + upper) / 2.0);
		}
		numbersFromFile.clear();
	}
	public void output() {
		for (double v : medians)
			System.out.println(v);
	}
	public static void main(String[] args) {
		try {
			Numbers n = new Numbers("F:\\testFile.txt", 3);
			n.readNumbers();
			System.out.println("Read file " + n.getFilename());
			n.output();
		} catch (IOException ie) {
			System.err.println("I/O Error: " + ie);
		}
	}
}

edit die 5te... ich geh jetzt einfach schlafen, dann fallen mir auch keine sachen mehr ein, die ich editieren kann ^^
 
Zuletzt bearbeitet:
Hi, ich sehe dass, bei deinem Ansatz, du selbst bestimmst wie viele Zahlen den Median bilden.
Dh. wenn insgesamt 10 Medians haben willst musst du nun im Kopf rechenen wie viele Zeilen es sind,
und ggf selbst aufrunden.

Bei meinem Anstatz, bestimmst du wie viele Medians du haben willst.

BEISPIEL:
es gibt 467 Zahlen (Lines in der Datei) und du insgesamt 5 Medians willst.
467 / 5 = 93,4 -> das sollten die Lines pro Medians sein - nicht optimal

so runde ich in der Schleife nacheinander 467 nach 47,0 dann 47,0 nach 5,0 und dann
multipliziere ich dies mit der potenz von 10 hoch die Länge der ersten (Zahl -1)
5,0 *(10 ^ (3 -1))
so bekomme ich 500. Nun teile ich dies durch die Anzahl der Medians 5 und weiss dass ich 100 zeilen pro median abarbeiten muss.

Ich weiss natürlich nicht ob du solches vorgehen vorhattest.
 
Danke für die Korrektur.

Ich brauchte nur eingeben wie viele Zahlen ein Median bilden.

Welche von diesen Kombinationen ist die schnellste?
BufferedReader br = new BufferedReader(new FileReader(fn));
BufferedReader br = new BufferedReader(new FileInputStream(fn);

Gibt es irgendwo eine Seite wo man für jedes Problem die schnellste Buffered/Stream Kombination finden kann?
 
mal ganz allgemein, wenn du dir öfters die Frage stellen solltest, ob a oder b schneller ist:

Java:
		long start = System.nanoTime();
		//a
		System.out.printf("a braucht %g ms\n", (double)(System.nanoTime() - start) / 1000000);
		start = System.nanoTime();
		//b
		System.out.printf("b braucht %g ms\n", (double)(System.nanoTime() - start) / 1000000);

einfach ausprobieren 🙂
 

Neue Themen


Zurück
Oben