Methodenaufbau

Status
Nicht offen für weitere Antworten.
J

java-anfaenger

Aktives Mitglied
Ich habe folgenden Code vorgegeben:

Code: 
int [] feld = {4 ,2 ,7 ,5 ,2 ,1 ,5 ,3};
Sucher s = new Sucher ();
int index = s. bestimmeIndex (feld , 5);
public class Sucher {
/**
* bestimmt den Index des ersten Auftretens von x
*
* @param feld das zu durchsuchende ( unsortierte ) Feld
* @param x der zu suchende Wert
* @return der Index des ersten Auftretens
*/
public int bestimmeIndex ( int [] feld , int x) {
// Hier bitte den entsprechenden Quelltext ergaenzen .
}
}


den vervollständige ich so:

Code: 
public class Sucher {
/**
* bestimmt den Index des ersten Auftretens von x
*
* @param feld das zu durchsuchende ( unsortierte ) Feld
* @param x der zu suchende Wert
* @return der Index des ersten Auftretens
*/

int [] feld = {4 ,2 ,7 ,5 ,2 ,1 ,5 ,3};
Sucher s = new Sucher ();
int index = s. bestimmeIndex (feld , 5);

public int bestimmeIndex ( int [] feld , int x) {
for (int i=0;i<feld.length;i++)
if (feld[i]==x){
index=i+1;
break;
}
return index;
}
}


für was brauche ich:
Sucher s = new Sucher ();
 
S

SlaterB

Gast
einfach so Code aneinanderreihen geht nicht,
bei ordentlicher Strutkur sollte es klar sein, dass ein Sucher-Objekt benötigt wird:

Java: 
public class Test
{
    public static void main(String[] args)
    {
        int[] feld = {4, 2, 7, 5, 2, 1, 5, 3};
        Sucher s = new Sucher();
        int index = s.bestimmeIndex(feld, 5);
        System.out.println("index: " + index);
    }
}

class Sucher
{
    /**
     * bestimmt den Index des ersten Auftretens von x
     * 
     * @param feld das zu durchsuchende ( unsortierte ) Feld
     * @param x der zu suchende Wert
     * @return der Index des ersten Auftretens
     */
    public int bestimmeIndex(int[] feld, int x)
    {
        int index = -1;
        for (int i = 0; i < feld.length; i++)
            if (feld[i] == x)
            {
                index = i + 1;
                break;
            }
        return index;
    }
}

die lokale Variable index in bestimmeIndex() ist übrigens eine andere als in der main-Methode,
könnte auch einen anderen Namen haben
 
M

Marco13

Top Contributor
Java: 
    /**
     ...
     * @return der Index des ersten Auftretens PLUS EINS - warum auch immer....
     ...
     */
:rolleyes:
 
J

java-anfaenger

Aktives Mitglied
Ich hab jetzt im Bluej 2 Klassen:
Code: 
public class Sucher
{
/**
* bestimmt den Index des ersten Auftretens von x
*
* @param feld das zu durchsuchende ( unsortierte ) Feld
* @param x der zu suchende Wert
* @return der Index des ersten Auftretens
*/
public int bestimmeIndex ( int [] feld , int x) {
int index =-1;
for (int i=0;i<feld.length;i++)
if (feld[i]==x){
index=i+1;
break;
}

return index;
}}


und

Code: 
public class Sucher_Test {

 public static void suchen()
    {
        int[] feld = {4, 2, 7, 5, 2, 1, 5, 3};
        Sucher s = new Sucher();
        int index = s.bestimmeIndex(feld, 5);
        System.out.println("index: " + index);
    }
}

das funktioniert alles, aber ich möchte das Feld auch umgekehrt ausgeben können- eine SortierMethode bietet sich ja nicht an, weil ich das Feld nicht sortieren, sondern einfach umgekeht ausgeben möchte -wie mache ich das
 
Zuletzt bearbeitet:
J

java-anfaenger

Aktives Mitglied
so:

Code: 
public class Sucher_Test {

 public static void suchen()
    {
        int[] feld = {4, 2, 7, 5, 2, 1, 5, 3};
        Sucher s = new Sucher();
        int index = s.bestimmeIndex(feld, 5);
        for (int i=0;i<feld.length;i++){
        System.out.println (feld[i]);}
        
        System.out.println("index: " + index);
    }
}


ich möchte einfache eine Methode, wo ich ein Feld umgekehrt ausgeben kann
 
S

SlaterB

Gast
und
> System.out.println (feld);}
kannst du nun modifizeren, z.B.
System.out.println (feld[i-3]);}
System.out.println (feld[i*2]);}

du musst dir nur eine Formel überlegen, die i = 0, 1, 2, .. in die gewünschte Index-Folge umwandelt,

alternativ könntest du auch die For-Schleife modifizieren, kommt aufs gleiche hinaus
 
J

java-anfaenger

Aktives Mitglied
Code: 
public class Sucher_Test {

 public static void suchen()
    {
        int[] feld = {4, 2, 7, 5, 2, 1, 5, 3};
        Sucher s = new Sucher();
        int index = s.bestimmeIndex(feld, 5);
        System.out.println("Feld in umgekehrter Reihenfolge: ");
        for (int i=feld.length;i==0;i--){
        System.out.println (feld[i]);}
        
        System.out.println("index: " + index);
    }
}

so tut er nichts
 
S

SlaterB

Gast
die Bedingung heißt nicht 'wann ist Ende', sondern 'wie lange noch', der erste Index wäre auch ungünstig

for (int i=feld.length;i==0;i--){
->
for (int i=feld.length-1;i>=0;i--){
 
J

java-anfaenger

Aktives Mitglied
neue Spielerei
Code: 
public class UmgekehrtesF {
/**
* liefert ein neues Feld mit umgekehrter Reihenfolge
*
* @param feld das umzukehrende Feld
* @return das neue Feld mit umgekehrter Reihenfolge
*/
int [] feld= {1,2,3,4,5,6};
public int [] kehreFeldUm ( int [] feld ) {
for (int i=feld.length-1;i>=0;i--){

//System.out.println(feld[i]);
}
return feld;
}
}
wenn ich System.out aktiv setze dann gibt ers richtig aus - aber ich möchte das mit "return" ausgeben, weil return von der Methode verlangt wird - public int [] kehreFeldUm ( int [] feld ) möchte ich aber nicht auf void umändern - Wie gebe ich das mit return aus :)
 
M

Marco13

Top Contributor
Du hast es höchstens 8 Minuten lang versucht, bzw. höchstens 8 Minuten lang drüber nachgedacht :noe:
 
J

java-anfaenger

Aktives Mitglied
ungefähr so?

Java: 
public class UmgekehrtesF {
/**
* liefert ein neues Feld mit umgekehrter Reihenfolge
*
* @param feld das umzukehrende Feld
* @return das neue Feld mit umgekehrter Reihenfolge
*/
int [] feld= {1,2,3,4,5,6};
int [] a=new int [6];
public int [] kehreFeldUm ( int [] feld ) {
for (int i=feld.length-1;i>=0;i--){
    for (int l=0;l<feld.length;l++){
            a[l]=feld[i];


}}
return a;
}
}
 
Zuletzt bearbeitet:
T

tuxedo

Gast
btw: java anfänger hin oder her, die rote Schrift über den Nachrichteneditierfeld, die darauf hinweist, dass man Java Quelltext bitte in Java Tags packen soll (und nicht einfach code-tags) ist doch nicht zu übersehen, oder?

- Alex
 
S

SlaterB

Gast
keine doppelte Schleife, wenn das Array 5 Elemente hat, willst du genau 5x etwas kopieren, nicht 25x

eine Schleife, und nun musst du doch noch mit dem Index basteln
a=feld;
kopiert i nach i
a=feld[i-2];
kopiert um zwei nach links bzw. rechts,

aber irgendeine Formel wird es schon geben, die genau die gesuchten Indexe einander zuordnet ;)
 
J

java-anfaenger

Aktives Mitglied
tuxedo hat gesagt.:
Danke. Liest sich doch gleich viel besser.

- Alex
Zum Vergrößern anklicken....
mache ich doch gerne

so müsste es passen, oder?

Java: 
public class UmgekehrtesF {
/**
* liefert ein neues Feld mit umgekehrter Reihenfolge
*
* @param feld das umzukehrende Feld
* @return das neue Feld mit umgekehrter Reihenfolge
*/
int [] feld= {1,2,3,4,5,6};
int [] a=new int [6];
public int [] kehreFeldUm ( int [] feld ) {
for (int i=feld.length-1;i>=0;i--){
    
    
            a[i]=feld[feld.length-1-i];

        
}
return a;
}
}
 
M

Michael...

Top Contributor
Das neue int-Feld würde ich in der Methode erstellen. Da Du ja die Methode eventuell mehrfach mit unterschiedlichen Feldern aufrufen willst.
 
J

java-anfaenger

Aktives Mitglied
meinst so:

Java: 
public class UmgekehrtesF {
/**
* liefert ein neues Feld mit umgekehrter Reihenfolge
*
* @param feld das umzukehrende Feld
* @return das neue Feld mit umgekehrter Reihenfolge
*/
int [] feld= {1,2,3,4,5,6};

public int [] kehreFeldUm ( int [] feld ) {
int [] a=new int [feld.length];
for (int i=feld.length-1;i>=0;i--){
    
    
            a[i]=feld[feld.length-1-i];

        
}
return a;
}
}
 
S

SlaterB

Gast
geht doch oder?
wenn du nun eh mit Index rechnen musst, kannst du auch wieder

for (int i=0; i<feld.length; i++){
schreiben,
ob du nun das Array von vorne aus oder hinten kopierst, ist am Ende egal
 
Status
Nicht offen für weitere Antworten.

Aktuelle Jobs

Neue Themen


Oben