# Zeichen vertauschen



## coldstone (20. Feb 2012)

Hallo liebe freunde,

hoffe ihr könnt mir Tiipps geben.

Habe folgendes vor.

Undzwar möchte ich von der Zeichenkette "Fahrrad", wenn die schleife einen Zeichen "r" findet, es mit dem Zeichen "n" ersetzen.

Habe mal so angefangen:


```
public class array {
	
		
	public static void main (String[] args) {
	
	String team = new String ("Fahrrad");  
	
	
	for(int i = 0; i < team.length(); i++) {
		
	if (??????  ) {
		

		
	}
     }			
   }
}
```


Wie muss die if-Bedingung aussehen?
Meine Theorie: Wenn i = "r", dann tuhe........
Aber wie muss es Syntax technisch eingebunden werden. Eclipse gibt immer fehlermeldung.
Kann ich Strin benutzen oder muss ich Stringbuilder benutzen. Verstehe nicht genau den Unterschied?


----------



## Gast2 (20. Feb 2012)

Nen String ist immutable, verändern kannst du da also nichts. Nen StringBuilder wäre da schon besser geeignet. StringBuffer bietet dir da auch Methoden die dir Buchstaben ersetzen können.


----------



## Kiri (20. Feb 2012)

Warum eine Schleife? String hat doch die replaceAll-Methode?

Also mit

```
team = team.replaceAll("r", "n");
```

machst du aus "Fahrrad" ein "Fahnnad".


----------



## coldstone (20. Feb 2012)

OK, das mit den methoden für String ist mir bekannt. Aber kann man es denn nicht auch mit der gezeigten Schleife machen? 
Mir geht es darum die Benutzung der for-schleife anzueignen.
Wie kann ich den compiler bei der for-schleife dazu bringen, dass wenn "r" erscheint, er es in "n" umändert?
Wie muss der Ausdruck in der if-Bedingung aussehen um es zu verwirklichen?


----------



## Gast2 (20. Feb 2012)

Schau dir bitte die Javadoc vom schon erwähnten StringBuilder an:
StringBuilder (Java 2 Platform SE 5.0)
StringBuilder (Java 2 Platform SE 5.0)


----------



## HimBromBeere (20. Feb 2012)

Wenn du unbedingt eine for-Schleife willst, solltest du mal bei String#charAt(int index) vorbeischauen, wo du einfach noch den Index deines aktuellen Zeichens übergeben musst. Alternativ kannst du auch erst deine Zeichenkette in ein char-Array umwandeln mittels String#toCharArray() und dann durch dieses Array laufen, kommt auf´s gleiche heraus.


----------



## coldstone (20. Feb 2012)

Kann ich in der if-Bedingung nicht gleich eine zeichen vergleichen?

Wie zb.:


```
public class array {
	
	public static void main (String[] args) {
	
	StringBuilder team = new StringBuilder ("Fahrrad");  
	
	for(int i = 0; i < team.length(); i++) {
		
	if (team[i] = "r" ) {
		
	}
				
	}			
  }
}
```


----------



## coldstone (20. Feb 2012)

HimBromBeere hat gesagt.:


> Wenn du unbedingt eine for-Schleife willst, solltest du mal bei String#charAt(int index) vorbeischauen, wo du einfach noch den Index deines aktuellen Zeichens übergeben musst. Alternativ kannst du auch erst deine Zeichenkette in ein char-Array umwandeln mittels String#toCharArray() und dann durch dieses Array laufen, kommt auf´s gleiche heraus.



Mit charAt würde ich ihm ja aber sagen wo das zeichen "r" sich befindet. Der compiler soll ja aber selber darauf kommen.
Sozusagen:  Wenn r erscheint, dann mach dies und das!


----------



## HimBromBeere (20. Feb 2012)

Erstens: eine Gleichheitsbedingung hat zwei Gleichheitszeichen (if a == "b"). 
Zweitens: Das kannst du prinzipiell schon machen, aber wie du in meinem voigen Beitrag gelesen haben könntest, musst du dafür deine Zeichenkette erstmal in ein char-Array umwandeln (.toCharArray).
Drittens: Für char nimmst du dann aber nicht doppelte Anführungszeichen, sondern einfache Hochkommas.

Also:

```
String str = "Fahrrad";
char[] characters = str.toCharArray();
for (int i = 0; i < characters.length; i++) {
    if (characters[i] == 'r') ...
}
```
Oder eben, was bei ´nem StringBuilder dann auch geht:

```
StringBuilder sb = new StringBuilder("Fahrrad");
for (int i = 0; i < sb.length(); i++) {
    if (sb.charAt(i) == 'r') ...
}
```

EDIT:


> Mit charAt würde ich ihm ja aber sagen wo das zeichen "r" sich befindet.


Darum läufst du ja auch durch die gesamte Zeichenkette und testest jedes einzelne Zeichen...


----------



## coldstone (20. Feb 2012)

Heist das ich kann direkt in der if-Bedingung meinen String in char umwandeln "sb.charAt(i)"???
Kann ich in der if-bedingung immer eine String Mehode anwenden???


----------



## Kiri (20. Feb 2012)

coldstone hat gesagt.:


> Heist das ich kann direkt in der if-Bedingung meinen String in char umwandeln "sb.charAt(i)"???
> Kann ich in der if-bedingung immer eine String Mehode anwenden???



Du kannst in der If-Bedingung alles verwenden, was true oder false ergibt!


----------



## coldstone (20. Feb 2012)

Was mache ich bitte hier falsch?


```
public class array {
	
		
	public static void main (String[] args) {
	
	StringBuilder team = new StringBuilder ("Fahrrad");  
	StringBuilder n = new StringBuilder ("n");
	
	for(int i=0; i < team.length(); i++)  {
		if(team.charAt(i) == 'r') {
			team[i] = n;
			
		}
	}
	
	System.out.println(team);
		
	}			
}
```

Darf ich dies

```
team[i] = n;
```
 so verwenden??? Eclipse sagt nein ???:L


----------



## HimBromBeere (20. Feb 2012)

Ich möchte dich nur nochmal drauf hinweisen, dass 
	
	
	
	





```
.charAt()
```
 - wie der Name bereits sagt - einen einzelnen char zurüchgibt. Daher musst du diesen in einfache Hochkommas einschließen in der Bedingung, nicht - wie bei Strings sonst üblich - in doppelte. 
Zu deiner Frage: in einer If-Bedingung kann alles stehen, was in irgend einer Form wahr sein könnte, entweder formuliert durch einen Vergleich (z.B. 
	
	
	
	





```
if(zahl == 3)
```
) oder durch die Verwendung eines Wahrheitswetes oder einer Methode, die einen solchen zurückgibt (z.B. 
	
	
	
	





```
if(zahl.istGerade())
```
).


----------



## truesoul (20. Feb 2012)

coldstone hat gesagt.:


> Was mache ich bitte hier falsch?
> 
> 
> ```
> ...



team_ ist ja auch kein Array sondern ein Stringbuilder.
StringBuilder hat eine replace Methode womit du Stellen austauschen kannst.



		Java:In die Zwischenablage kopieren


StringBuilder team = new StringBuilder ("Fahrrad");  
String text = "n";
		    
for(int i=0; i < team.length(); i++)  {
     if(team.charAt(i) == 'r') {
	     team.replace(i, i+1, text);   
     }
}
		    
System.out.println(team);


Mfg_


----------



## coldstone (20. Feb 2012)

Heist das also, dass ich das Zeichen eines String´s nur mit einer dementsprechenden Methode vertausche oder ersetzen kann?
Ich kann also nicht direkt sagen "Ersetze 4. komponente des String´s mit dem Zeichen "n"?"


----------



## HimBromBeere (20. Feb 2012)

Auf dem String selbst sowieso nicht, sondern wie bereits mehrfach erwähnt nur mittels StringBuilder, da ein String nicht veränderlich ist. Um auf deine Frage zu antworten: eine direktere Methode als die bisher genannten gibt es nicht, aber ich denke, das reicht auch...


----------



## irgendjemand (20. Feb 2012)

Kiri hat gesagt.:


> Warum eine Schleife? String hat doch die replaceAll-Methode?
> 
> Also mit
> 
> ...



VORSICHT ... kann bei anfängern leicht zu fehlern führen da replaceAll eine RegEx erwartet ... und die meisten dann sowas wie ".+?" mit einbauen was aber RegEx steuerzeichen sind ...

@TO

für sowas einfaches solltest du String.replace(String, String) verwenden ...


----------



## pro2 (20. Feb 2012)

Vielleicht möchte man als Anfänger so etwas aber auch einmal selber programmieren und nicht nur alles nehmen, was es schon gibt, um es besser zu verstehen.


----------



## coldstone (20. Feb 2012)

```
StringBuilder team = new StringBuilder ("Fahrrad");  
String text = "n";
            
for(int i=0; i < team.length(); i++)  {
     if(team.charAt(i) == 'r') {
         team.replace(i, i+1, text);   
     }
}
            
System.out.println(team);
```

mit dieser methode bekomme ich aber "Fahnnad". Er würde ja alle "r" Zeichen mit "n" Zeichen ersetzen. Aber gibt es eine möglichkeit es so hinzubekommen, so das ich die 4. Komponente vom String mit dem Zeichen "n" ersetze?

Und kann mir jemand bitte sagen was hier genau passiert:


```
if(team.charAt(i) == 'r') {
         team.replace(i, i+1, text);   
     }
```


----------



## coldstone (21. Feb 2012)

Wenn ich jetzt so eine Aufgabe habe:

"Schreiben Sie eine Java-Methode mit der Signatur public static String swap (String text), die aus einer als Parameter übergebenen Zeichenfolge durch Vertauschen des ersten und letzten ZEichens eine neue Zeichenfolge bildet. 
Die neue Zeichenfolge soll als Ergebnis von swap zurückgeliefert werden."

Es muss ein String mit der Kennzeichnung "text" erstellt werden.
Also 


```
String text = "vier";
```
Richtig?

Mich bringt aber String swap irgendwie durcheinander. Was ist das? Ein String mit der Bezeichnug "swap"? Wozu?


----------



## Crian (21. Feb 2012)

Nein, eine Methode Namens swap, die einen String zurückgibt. In deinem Fall "riev".


----------



## Gast2 (21. Feb 2012)

Nein, das ist die Methodensignatur.

```
public static String swap (String text)
```
Das bedeutet dass diese statische Methode einen String entgegen nimmt und auch einen String zurückgibt.



> Es muss ein String mit der Kennzeichnung "text" erstellt werden.


Wie der String heißt egal, innerhalb der Methode heißt der String dann text. Folgendes geht auch:

```
String foo = "vier";
String swappedFoo = swap(foo);
```

Aber wenn dir Rückgabewerte nichts sagen dann solltest du dir vielleicht nochmal die Grundlagen anschauen.


----------



## darkeye2 (21. Feb 2012)

ich würde den TO mal dringend raten, sich die grundlagen anzuschauen.

Also, grundsätzlich ist java objectorientiert aufgebaut, was auch verhindert, dass du einen String direkt ohne methodenaufrufe verändern kannst, was aber besser für den programmierer ist, da so viele fehler ausgeschlossen werden (z.b. siehe typische c fehler). 
Ein String ist intern auch nur ein array von chars, um das ganze aber besser zu verwalten existiert die Klasse String, die das char array kapselt und methoden bietet, um dieses zu verwalten.
Eine methode in java ist immer folgendermaßen aufgebaut:
zugriffskontrolle rückgabetyp methodenName(Typ parametername, ...){
   //was passiert
}

eine methode kann  public (von überral zugägnlich), private (nur aus aktueller klasse zugänglich) oder auch protected sein, für den anfang sind nur public und privat interessant. Der rückgabetyp kann entweder ein primitiever datentyp (int, float, double, short, char, byte, long)  oder jedes beliebige Object (z.b. String) sein, oder auch gar nix, dann seht void da, was zeigt, dass die methode nix zurückgibt. eine methode kann keinen, einen, oder x viele parameter kriegen.
in der praxis sieht sowas dann z.b. so aus:
public int getInteger(){}, oder private long getLong(){}, oder auch (für dich noch nicht ganz so interessant) protected void doSomething(){} 

In deinem fall ist eine methode gefordert, die public (öffentlich) sein soll, zudem soll sie statisch sein, was das schlüsselwort static ausdrückt, und sie soll einen String zurückgeben, und erhält als paramter auch einen String und heißt swap:

```
//zugriff          Rückgabetyp    Methodenname      parameter
public  static         String              swap              (String  text){

}
```

Das wäre schonmal das grundgerüst, nun soll deine Methode den ersten buchstaben von text mit dem letzten buchstaben von text vertauschen und das ergebniss dann ausgeben. Für das vertauschen gibt es jetzt viele möglichkeiten, um jetzt bei deiner for schleife zu bleiben nutzen wir mal ein array um das ganze zu realisieren:

```
//folgendes ist nicht die beste und auch nicht die schnellste möglichkeit
public static String swap(String text){
   //array deklarieren, dass dann alle zeichen des strings enthält
   char[] charArrayAusText = text.toCharArray();  //ruft die mehtode von String auf, die die einzelnen zeichen als array zurückgibt
   //array festlegen, wo der neue String rein kommt
   char[] neuerString = new char[charArrayAusText.length] //die gleiche länge wir das alte array
   //nun schreiben wir schonmal den ersten buchstaben an die letzte stelle und den letzten an die erste:
   neuerString[0] =  charArrayAusText[charArrayAusText.length-1]; //letzer buchstabe an erste stelle
   neuerString[neuerString.length-1] = charArrayAusText[0]; //erster buchstabe an letzte stelle
   //in schleife alle anderene buchstaben reinschreiben:
   for(int i = 1; i<neuerString.length-1; i++){
      neuerString[i] = charArrayAusText[i];
   }

   //nun muss ja noch der neue String mit return zurückgegeben werden, dazu nutzen wir den String construktor, der
   //ein char array etgegennimmt:
   return new String(neuerString);

}
```


EDIT:
Statische Methoden sind von überral her erreichbar, um sie aufzurufen wird folgendes verwendet:
KlassenName.methodenname();
weiterführend würde ich empfehlen folgndes durchzulesen:
[TIPP]The ?static? Keyword in Java
Tutorial / Java Grundlagen / Variablen[/TIPP]


----------



## coldstone (21. Feb 2012)

Erstmal vielen vielen dank für die Ausfürliche Antwort.
Verstehe ich das Richtig, das die methode tocharArray() meinen String text in eine Array char[] charArrayAusText zuweist. Und das dies notwendig ist damit ich irgendwelche Komponenten meines Parameters vertauschen kann? Würde heissen das die Zeichenkette, die ich vom Typ String zugewiesen habe, ich umwandle in den Typen char[], somit ich beliebige manipulationen vornehmen kann?


----------



## HimBromBeere (21. Feb 2012)

JAU... genau so ist es:toll:

EDIT: String-->toCharArray-->Manipuliere einzelne Zeichen-->Erstelle neuen String aus dem manipulierten char-Array


----------



## coldstone (21. Feb 2012)

Es gehen gerade 30 Lampen auf einmal in meinem Kopf an :idea:


----------



## coldstone (22. Feb 2012)

OK nur zur Kontrolle.

Dies wäre doch auch ein Lösungsweg um das erste Zeichen mit dem letzten Zeichen zu Vertauschen!
Zumindest funktioniert es.


```
public class Vertauschen {
	
	public static void main (String[] args) {
		
	
	String team = new String("Barcelona");
	char[] teamNeu = team.toCharArray();
	char erste = teamNeu[0];
	char letzte = teamNeu[8];
	teamNeu[0] = letzte;
	teamNeu[8] = erste;
	
	
	System.out.println(teamNeu);
	}
}
```

Korrekt?


----------



## njans (22. Feb 2012)

Jop, das sollte gehen


----------



## HimBromBeere (22. Feb 2012)

Wenn´s geht, ist doch erstmal super. Möchstest du aber wirklich ein String-Objekt erhalten, ist an der Stelle noch nicht Schluss, du müsstest noch ein neues erstellen, z.B. so:

```
String str = new String(teamNeu);
```


----------



## njans (22. Feb 2012)

Oder auch 
	
	
	
	





```
Arrays.toString(teamNeu)
```
 oder aber 
	
	
	
	





```
String.valueOf(teamNeu);
```


----------



## bygones (22. Feb 2012)

oder ueber StringBuilder#setCharAt(int index, char theChar) ginge auch


----------



## coldstone (22. Feb 2012)

Gut einen String hätte ich noch erstellen sollen. Die vorfreude war zu gross, dass es funktioniert hat 

Noch eine Frage zum Quellcode von darkeye2:


```
char[] neuerString = new char[charArrayAusText.length]
```

"charArrayAusText.length"   die length methode bewirkt das ich meine VOLLE länger der zeichenkette dem char neuerString zuweise? Also wenn es z.B. "Barcelona" ist wird auch die Zeichenkette "Barcelona" char neuer String zugewiesen?


Wenn es so wäre:


```
char[] neuerString = new char[charArrayAusText.length-1]
```

würde es ausser der letzten komponente, die zeichenkette an neuerString zuweisen. Wie z.B. "Barcelona" zugewiesen an neuerString wird "Barcelon", also ohne a. Ist das so korrekt?


----------



## HimBromBeere (22. Feb 2012)

Sollte so gehen


----------



## darkeye2 (22. Feb 2012)

coldstone hat gesagt.:


> Wenn es so wäre:
> 
> 
> ```
> ...



also grunsätzlich gibt dir array.length immer die länge des arrays zurück, also wie viele zeichen drin sind:
sprich:
char[] test = "test".toCharArray();
so würde jetzt test.length dir 4 zurückgeben, weil der string test aus viel buchstaben besteht und somit das array auch vier ellemente hat.

die zeile:

```
char[] neuerString = new char[charArrayAusText.length]
```
erstellt ein neues array vom typ char, das aber leer ist (keine buchstaben drin), aber in dieses array kann man eine bestimmte anzahl an buchstaben rein tun, diese anzahl ist durch das ergebniss von charArrayAusText.length festgelegt.

Ein array ist im grunde sowas wie eine schrank mit regalen, jedes regal kann nur ein element aufnehmen, in dem fall muss das element vom typ char sein, somit haben wir hier einen schrank erstellt, der eine bestimme anzahl an regalen hat, von dennen des jeweils einen  char aufnehmen kann.
Bei arrays muss bereits beim erstellen die größe festegelegt werden, es müssen zwar danach nicht alle "regale" besetzt werden, aber du kannst nicht mehr "sachen" in den "schrank" tun, als regale vorhanden sind.
wenn du also mit deiner zeile:

```
char[] neuerString = new char[charArrayAusText.length-1]
```
ein array erstellst, und dein ausgangstext, der sich im charArrayAusText befindet, "Barcelona" war, hast du jetzt  ein leeres  array, in das du nur noch maximal "Barcelon" reinschreiben könntest, weil das array (der schrank) zu kleine für das ganze wort ist.

weiterführend:
Tutorial / Java Grundlagen / Arrays


----------



## coldstone (24. Feb 2012)

Vielen dank für die ausführliche Antwort.

DIese Zeile würde dann aber den letzen Buchstaben meines arrays an temp2 zuweisen oder?


```
char temp2 = teamNeu [teamNeu.length-1];
```


----------



## darkeye2 (24. Feb 2012)

ja, das stimmt
im übrigen:
chars kannst du wie shorts verwenden, also auch auf diese weise manipulieren
Bsp.:

```
char c = 'a';
char  c2 = c+1;
System.out.println(c2);  //die ausgabe wäre dann ein b
```
Das ist praktisch, wenn  zum beispiel überprüfen willst, ob der char in einem bestimmten bereich liegt, also wenn ich jetzt will, dass der user einen string eingibt, der nur aus den buchstaben c,d,e,f,g besteht, kann man das überpfrüfen, in dem man den string in ein char array umwandelt und dann jeden buchtaben folgendermaßen überprüfst:

```
//öffentliche methode mit dem namen validChar,  die einen boolischen wert zurücklievert, ob  der buchstabe im gewünschten bereich liegt
public boolean validChar(char c){  //öffentliche mehtode namens validChar, die als parameter einen char bekommt und einen 
                                              //boolean zurückgibt, der aussagt, ob der char eine c,d,e,f oder g ist.
  if(c>='c' && c<= 'g'){  //wenn der werte von c>= der von buchstaben c ist, und gleichzeitig
                              // der wert von c<= dem wert vom buchstaben g ist
      return true;        //gib true (wahr) zurück
  }
  return false;           //diese stelle wird nur  erreicht, wenn return vorher noch nicht aufgerufen wurde
                             //demnach kann die aussage an dieser stelle ja nur noch falsch sein, also geben wir false zurück  
}
```


----------

