# Bestimmen ob String aus Kleinbuchstaben besteht



## jacka (1. Aug 2011)

Ich muss bei einem String bestimmen ob dieser nur aus Kleinbuchstaben besteht. wenn ja true ausgeben, ansonsten false. 
Habe das schon probiert, prüft allerdings nur den letzten Buchstaben, ich will aber das ganze Wort prüfen.
public class StringsAufgabe4 {


	public static void main(String[] args) {
		String wort = "Abkadabra";
		char b = wort.charAt(wort.length()-1);
		System.out.println(Character.isLowerCase(b));
	}

}


----------



## homer65 (1. Aug 2011)

Meine Idee wäre:
[Java]
String wort = "Abkadabra";
String test = wort.toLowerCase();
boolean isLowerCase = false;
if (wort.equals((test))
{
 isLowerCase = true;
}
[/Java]


----------



## Anykey (1. Aug 2011)

mit einer Schleife kannst du jeden Buchstaben einzeln überprüfen. 
So ungefähr:


```
String wort = "allesklein";

for (int i = 0; i < wort.length; i++) {

      char c = wort.charAt(i);
      Character.isLowerCase(c);

}
```


----------



## nillehammer (1. Aug 2011)

[Java]
import java.util.regex.Pattern;

public class RegexBsp {

	/**
	 * Pattern sagt, dass String aus 1-n Kleinbuchstaben bestehen muss. 
	 */
	private static final Pattern KLEIN_BUCHSTABEN = Pattern.compile("\\b[a-z]+\\b");

	public static final void main(final String[] args) {

		System.out.println(KLEIN_BUCHSTABEN.matcher("allesklein").matches());

		System.out.println(KLEIN_BUCHSTABEN.matcher("nichtAllesklein").matches());
	}
}
[/code]


----------



## turtle (1. Aug 2011)

RegEx, wie nillehamer vorschägt, finde ich gut.:applaus:

Wenn Du Eclipse einsetzt und häufig mit regular expressions arbeiten musst, ist folgendes Plugin sehr hilfreich


----------



## njans (1. Aug 2011)

Ich muss sagen, ich hab da so meine Bedenken:
Wenn da nun das Wort "A aSSss d A" kommt, dann muss man auch wieder den RegEx anpassen. Und ich habe keine Ahnung,was für Wörter da alles auftauchen.
homer65s Antwort fand ich da noch am einfachsten, da es unabhängig von der Struktur des Wortes ist.


----------



## turtle (1. Aug 2011)

Die Anforderung war


> Ich muss bei einem String bestimmen ob dieser nur aus Kleinbuchstaben besteht. wenn ja true ausgeben, ansonsten false.



Wieso muss man da wieder den RegEx anpassen?


----------



## Gast2 (1. Aug 2011)

Der Regex geht davon aus dass nur buchstaben vorhanden sind, bei leerzeichen oder satzzeichen klappt das ganze dann nichtmehr.

```
String s = "aasdb";
        System.out.println(s.matches("\\b[a-z]+\\b"));
        System.out.println(s.toLowerCase().equals(s));    	
    	
        String s2 = "a asd b";
        System.out.println(s2.matches("\\b[a-z]+\\b"));
        System.out.println(s2.toLowerCase().equals(s2));
```


----------



## njans (1. Aug 2011)

turtle hat gesagt.:


> Die Anforderung war
> 
> 
> Wieso muss man da wieder den RegEx anpassen?



Exakt. Mal abgesehen davon, dass es ja nicht unhäufig vorkommt, dass ein TO seinen Wunsch eher unpräzise ausdrückt, steht da nichts von "ausschließlich aus Kleinbuchstaben". Demnach könnte man da alles mögliche drin finden 
Aber das muss ja der TO wissen. Also TO, einfach mal Stellung dazu nehmen, wie die Strings denn überhaupt aussehen können.


----------



## Logaff (1. Aug 2011)

homer65 hat gesagt.:


> Meine Idee wäre:
> [Java]
> String wort = "Abkadabra";
> String test = wort.toLowerCase();
> ...



das nenn ich doch mal ne lösung, einfach und schnell^^...warum einfach wenn es auch umständlich geht?


----------



## Marco13 (1. Aug 2011)

Seh' ich genauso. Ich finde, jeder der zur Lösung eines Trivialproblems Regular Expressions vorschlägt, sollte
1. Mal einen Regular Expression Parser / Matcher selbst implementieren
2. Dann 1000 Mal an eine Tafel schreiben: "Java ist nicht langsam"
3. Immer das passende Shirt tragen 

Sie sind schon toll, auch aus theoretischer Sicht, aber für manche Sachen mehr als nur ein Overkill


----------



## eRaaaa (1. Aug 2011)

Wenn toLowerCase, dann aber mit Angabe des Locales :bae:


----------



## Logaff (2. Aug 2011)

Marco13 hat gesagt.:


> Seh' ich genauso. Ich finde, jeder der zur Lösung eines Trivialproblems Regular Expressions vorschlägt, sollte
> 1. Mal einen Regular Expression Parser / Matcher selbst implementieren
> 2. Dann 1000 Mal an eine Tafel schreiben: "Java ist nicht langsam"
> 3. Immer das passende Shirt tragen
> ...



wer findet die komplizierteste methode?^^


----------



## nillehammer (2. Aug 2011)

> wer findet die komplizierteste methode?^^


Wir haben hier drei Lösungen zur Auswahl. Meine ist mit zwei Zeilen die kürzeste (eine Zeile Regex kompilieren eine Zeile Prüfung). Wenn man sich das Kompilieren spart, ist es sogar ein Einzeiler. Ich kann da beim besten Willen nichts Kompliziertes dran finden.

Zur Performance kann ich mich nicht fundiert äußern. Da müsste man mal einen Test schreiben, der 100000 Mal die Prüfung durchführt. Aber dazu hab ich grad keine Lust.

Gruß nillehammer


----------



## Logaff (2. Aug 2011)

```
public boolean isLowerCase(){
   return this.equals(this.toLowerCase()):true:false;
}
```

das müsste eigentlich auch gehen und wär nen einzeiler^^


----------



## Ariol (2. Aug 2011)

Logaff hat gesagt.:


> ```
> public boolean isLowerCase(){
> return this.equals(this.toLowerCase()):true:false;
> }
> ...



Und als nächste machen wir dann sowas :autsch::

```
boolean checkTrue(boolean value)
{
    boolean result = false;
    if(value==true)
          result=true;
    else if(value!=false)
          result=true;
    else
          result=false;

    if(result==true)
          return true;
    if(result==false)
          return false;

    return value==true?true:false;
}
```

Wenn du schon einen einzeiler machen willst, dann doch bitte erstens richtig (Der erste Doppelpunkt muss ein Fragezeichen sein) und zweitens ohne doppelte boolsche Auswertungen...
Weiterhin kann man von String nicht erben und somit keine Methoden zu der Klasse hinzufügen.


```
public boolean isLowerCase(String string){
   return string.equals(string.toLowerCase());
}
```

Fertsch


----------



## Logaff (2. Aug 2011)

aaah ok^^ war mir auch nicht sicher bei dem ganzen


----------

