Minimum eines String-Arrays

Status
Nicht offen für weitere Antworten.
S

sebjensen

Mitglied
Hallo,

ich hoffe, dass ihr mir helfen könnt, da ich mit dieser Aufgabe vom Sinn her überhaupt nichts anfangen kann. Ich bin Student und studiere Informatik. Dieses Semester beschäftigen wir uns ein wenig mit Java.

Uns wurde ein Algorithmus vorgestellt, der in einem gegebnen Array vin ganzen Zahlen das Minimum bestimmt. Nun sollen wir dieses Algorithmus derat modifizieren, dass das Minimum in einem String Array (String[]) und allgemeiner in einem Arrayvom Typ Comparable[] bestimmt wird.

Leider ist mir nicht klar, was genau das Minimum eines String-Arrays ist und somit, kann ich die Aufgabe auch nicht bearbeiten. Ich hoffe, dass ihr mir sagen könnt, was das besagte Minimum ist.

Danke schon mal.


Code: 
class MinimumArrayInteger {
	
  public static void main ( String[] args ) {

    int[] array = new int[20];
    array[0] = (int)(Math.random() * 1000);
    array[1] = (int)(Math.random() * 1000);
    array[2] = (int)(Math.random() * 1000);
    array[3] = (int)(Math.random() * 1000);
    array[4] = (int)(Math.random() * 1000);
    array[5] = (int)(Math.random() * 1000);
    array[6] = (int)(Math.random() * 1000);
    array[7] = (int)(Math.random() * 1000);
    array[8] = (int)(Math.random() * 1000);
    array[9] = (int)(Math.random() * 1000);
    array[10] = (int)(Math.random() * 1000);
    array[11] = (int)(Math.random() * 1000);
    array[12] = (int)(Math.random() * 1000);
    array[13] = (int)(Math.random() * 1000);
    array[14] = (int)(Math.random() * 1000);
    array[15] = (int)(Math.random() * 1000);
    array[16] = (int)(Math.random() * 1000);
    array[17] = (int)(Math.random() * 1000);
    array[18] = (int)(Math.random() * 1000);
    array[19] = (int)(Math.random() * 1000);

    int   min;
    min = array[ 0 ];

     for ( int index = 0; index < array.length; index++ ) {
    	 if ( array[ index ] < min )
    		 min = array[ index ] ;
      }
    System.out.println("Das Minimum dieses Arrays ist: " + min );
    }
  }
 
Compareable ist ein Java-Interface ...

die Klassen die dieses Interface implementieren haben eine Methode compareTo(Object obj) welche -1 zurückliefert wenn das Object kleiner als das übergebene ist,0 wenn beide gleich sind und 1 wenn das übergebene größer ist ...

Wie das diese Funnktion realisiert, kann dir egal sein ... du rufst nur auf die Objekte von Typ Compareable diese Funktion auf.

also zum Beispiel ((Compareable) array[1]).compareTo(array[2]);

den Rest solltest du jetzt allein hinbekommen sonst ist Informatik wohl nicht dein Fach *ggg*
 
Code: 
package edu.cau.informatikII.serie01;

class MinimumArrayComparable implements Comparable {
	
  public static void main ( String[] args ) {

    String[] array = new String[10];
    array[0] = "Test";
    array[1] = "Quelle";
    array[2] = "Haus";
    array[3] = "Baum";
    array[4] = "Schornstein";
    array[5] = "Qualle";
    array[6] = "Donaudampfschifffahrtsgesellschaft";
    array[7] = "Ebay";
    array[8] = "Universität";
    array[9] = "Kiel";

    String   min;
    min = array[0];

     for ( int index = 0; index < (array.length - 1); index++ ) {
    	 if (((Comparable)array[index]).compareTo(array[index+1]) == -1) {
    		 min = array[index+1];
    	 }
    	 
    	 
      }
    System.out.println("Das Minimum dieses Arrays ist: " + min );
    }

public int compareTo(Object arg0) {
	// TODO Auto-generated method stub
	return 0;
}
  }

Leider läuft das Programm nicht richtig. Kann mir mal jemand eine kurzen Tipp geben. Ich bin schließlich neu hier auf dem Java-Sektor.
 
ich versteh das so, dass nicht deine Klasse das Interface implementieren muss, sondern dein Algorithmus muss nur damit zurechtkommen

also so etwa:
Code: 
public class ArrayMin {
  public static Comparable getMinimum(Comparable[] array) {
    Comparable minimum = array[0];

    for(int i = 1; i < array.length; i++) {
      if(array[i].compareTo(minimum) < 0) {
         minimum = array[i];
      }
    }

    return minimum;
  }
}
 
Du vergleichst jeweils ein Element mit seinem Nachfolger und merkst dir nicht das Minimum
Code: 
     for ( int index = 0; index < (array.length - 1); index++ ) { 
        if (((Comparable)array[index]).compareTo(array[index+1]) == -1) {
           min = array[index+1];

Also vergleichen mit dem jeweiligen Minimum und Schleife wieder bis < array.length laufen lassen.

Code: 
     for ( int index = 0; index < array.length; index++ ) { 
        if (((Comparable)array[index]).compareTo(min) == -1) {
           min = array[index];

Das Comparable-Interface muß nur von den Klassen implementiert sein, dessen
Instanzen du vergleichen willst.

Dein MinimumArrayComparable brauchst du nicht Comparable implementieren zu lassen
 
Okay. Aber ich versteh nun nicht warum in meinem Beispiel "Schornstein" das Minimum sein sollte.

Code: 
    array[0] = "Test";
    array[1] = "Quelle";
    array[2] = "Haus";
    array[3] = "Baum";
    array[4] = "Schornstein";
    array[5] = "Qualle";
    array[6] = "Donaudampfschifffahrtsgesellschaft";
    array[7] = "Ebay";
    array[8] = "Universität";
    array[9] = "Kiel";
 
Leroy42 hat gesagt.:
Sollte es auch nicht.

Poste doch mal die Schleife, die die Vergleiche durchführt.
Zum Vergrößern anklicken....


Ich habe einfach deine Schleife, die du geschrieben hast genommen und eingefügt, somit entsteht der folgende Quelltext:

Code: 
class MinimumArrayComparable {
	
  public static void main ( String[] args ) {

    String[] array = new String[10];
    array[0] = "Test";
    array[1] = "Quelle";
    array[2] = "Haus";
    array[3] = "Baum";
    array[4] = "Schornstein";
    array[5] = "Qualle";
    array[6] = "Donaudampfschifffahrtsgesellschaft";
    array[7] = "Ebay";
    array[8] = "Universität";
    array[9] = "Kiel";

    String   min;
    min = array[0];


    for ( int index = 0; index < array.length; index++ ) {
       if (((Comparable)array[index]).compareTo(min) == -1) {
          min = array[index]; 
    	 }
    	 
    	 
      }
    System.out.println("Das Minimum dieses Arrays ist: " + min );
    }
  }
 
deathbyaclown hat gesagt.:
ich versteh das so, dass nicht deine Klasse das Interface implementieren muss, sondern dein Algorithmus muss nur damit zurechtkommen

also so etwa:
Code: 
public class ArrayMin {
  public static Comparable getMinimum(Comparable[] array) {
    Comparable minimum = array[0];

    for(int i = 1; i < array.length; i++) {
      if(array[i].compareTo(minimum) < 0) {
         minimum = array[i];
      }
    }

    return minimum;
  }
}
Zum Vergrößern anklicken....

Der Code ist schon absolute Richtig!!!!!

compareTo ist nicht mehr auf -1, 0, 1 festgelegt ... sondern arbeitet jetzt mit <0,0,>0

http://java.sun.com/j2se/1.5.0/docs/api/java/lang/Comparable.html#compareTo(T)
 
Mein Code mit dem was André zu Recht geschrieben hat, funktioniert

Code: 
if (((Comparable)array[index]).compareTo(min) < 0) {
 
Okay. Jetzt gibt er auch "BAUM" zurück. Wunderbar. Ihr habt mir sehr geholfen. Aber nun habe ich noch ein kleines Problem. Ich habe ja nun schon mit Comparable[] gearbeitet. Jetzt ist nur die Frage kann ich das ganze auch nurmit String ohne Comparable mache oder ist dies nicht möglich?
 
Sicher, denn die Methode compareTo ist ja schließlich bereits in der Klasse String
und der Compiler weiß das auch.

Du kannst also einfach schreiben:

Code: 
if (array[i].compareTo(min) < 0)

dbac hat nur deshalb den cast eingebaut, um dir den Allgemeinfall zu verdeutlichen,
wenn dein Array ein Object[] wäre. Dann weiß der Compiler ja nicht, daß die Instanzen
vom Typ einer Klasse sind, die tatsächlich auch Comparable implementiert
(die Methode compareTo) besitzen
 
Ich muss euch doch noch einmal kurz belästige. Sorry! 😳

Code: 
package edu.cau.informatikII.serie01;

class MinimumArrayComparable {
	
  @SuppressWarnings("unchecked")
public static void getminimum(Comparable[] array) {

    Comparable min;
    min = array[0];


    for ( int index = 0; index < array.length; index++ ) {
       int compareTo = ((Comparable)array[index]).compareTo(min);
       if (compareTo < 0) {
    	   min = array[index]; 
    	 }
    	 
    	 
      }
    System.out.println("Das Minimum dieses Arrays ist: " + min );
    }
  }



Warum geht das nicht. Ich habe eine Testdatei:


Code: 
package edu.cau.informatikII.serie01;

public class MinimumArrayComparableTestDrive {
	
 public static void main(String [] args) {
	 
    Comparable[] array = new Comparable[10];
    array[0] = "Test";
    array[1] = 5;
    array[2] = "Haus";
    array[3] = 85;
    array[4] = "Schornstein";
    array[5] = 24;
    array[6] = "Donaudampfschifffahrtsgesellschaft";
    array[7] = 83;
    array[8] = "Universität";
    array[9] = 95;
    
    MinimumArrayComparable.getminimum(array);
 }
}


Das Programm wird nun aber nicht mehr ausgeführt, die Frage ist. Was habe ich dann von Comparable. Wenn ich nicht verschiedene Typen in mein Array einbinden kann?
Danke schon mal!
 
sebjensen hat gesagt.:
Was habe ich dann von Comparable. Wenn ich nicht verschiedene Typen in mein Array einbinden kann?
Danke schon mal!
Zum Vergrößern anklicken....

Was soll denn das bringen? Ist zum Beispiel

85 < "Donaudampfschiffartsgesellschaft" :shock:

new JPanel < new JButton :shock:

new int[] {0} < 42 :shock:

Die Zeile
Code: 
Comparable[] array = new Comparable[10];
kann nicht funktionieren, da man Interfaces nicht instanziieren kann, welcher Typ soll das auch sein?

Ein Interface ist nichts weiter als ein Versprechen, daß Instanzen von Klassen, die dieses
Interface implementieren, die im Interface deklarierten Methoden verstehen
 
java.lang
Interface Comparable<T>


von Interfaces kannst du keine Instancen (also Objecte) erzeugen ... new Comparable[10] geht also nicht .. dort schreibst du dann new String[10] hin. String implementiert Compareable und ist somit vom Typ Comparable...

edit: hui du warst schneller 🙂
 
Äh? Sehrwohl kann man "new Comparable[10]" aufrufen, das generiert einen Comparable-Array der Länge 10. Falsch wäre aber "new Comparable()"...

Nicht alles lässt sich mit allem Vergleichen, in so einem Comparable-Array sollte man nur ein Typ reinschreiben - entweder nur ints, oder nur Strings, ...
 
Andre_ hat gesagt.:
java.lang
Interface Comparable<T>


von Interfaces kannst du keine Instancen (also Objecte) erzeugen ... new Comparable[10] geht also nicht .. dort schreibst du dann new String[10] hin. String implementiert Compareable und ist somit vom Typ Comparable...

edit: hui du warst schneller 🙂
Zum Vergrößern anklicken....
das ist aber falsch... natürlich kann man keine Instanz eines Interfaces anlegen, aber eine Arraydefinition geht natürlich - d.h. Comparable[] array = new Comparable[10]; ist korrekt und geht auch.

ansonsten - wegen den versch. Typen: wie schon gesagt - überleg dir was es bringt ints und Strings zu sortieren... wie soll das gehen ?!

Der nutzen, dass die methode comparable[] definiert ist einfach, dass du ohne probleme String[] oder Integer[] oder Double[] oder was auch immer testen lassen kannst (solange die Klasse Comparable implementiert). D.h. du hast für zig versch. aufrufe nur eine Methode. Aber im array versch. Klassen zuzulassen ist unsinn
 
Status
Nicht offen für weitere Antworten.

Aktuelle Jobs

Neue Themen

Ähnliche Themen

Lokales Minimum- Maximum, Globales Minimum - Maximum ?
Antworten: 4
Minimum eines Int Arrays
Antworten: 6
minimum eines Arrays?
Antworten: 27
Minimum eines Arrays ausgeben
Antworten: 2
Wert eines Arrays einer Variable zuweisen, sobald der Wert eines anderen Arrays eintritt
Antworten: 2

Zurück
Oben