# Dateien Auslesen



## X-Treme (15. Nov 2006)

He Leute,

Ich hab ein weiteres Problem! Ich soll ein Prog schreiben, dass eine TextDatei ausliest und den Inhalt durchforstet! Nun soll das Prog erkenne ob der Inhalt Englisch oder Deutsch ist!^^Mal wieder so ne Sache (siehe:Wieß nicht weiter!)

Wär cool wenn irgendjemand einen Ansatz hätte wie das denn wohl zu lösen sei! (Anfänger freundlich  :lol: )

MfG

X-Tremefile:///usr/share/ubuntu-artwork/home/index.html


----------



## MASTERmind (15. Nov 2006)

Ne Datei auslesen ist ziemlich einfach...so ungefähr:
Für Englisch oder deutsch muss in der datei irgendwo ein flag gesetzt werden dass du auslesen kannst an einer bestimmten Position. Alles andere ist glaube ich nicht praktikabel! 

```
#import java.io.*;
import java.util.*;


public class DateiBearbeitung
  // Anfang Variablen
  // Ende Variablen
{
  // Anfang Ereignisprozeduren
 public void DateiLesen()
 {
  try
  {
   String dateiName;
   dateiName = "C:/Dokumente und Einstellungen/xxx/Desktop/text.txt";
   File pfad = new File(dateiName);
   
   BufferedReader stdin = new BufferedReader(new FileReader(pfad));
   
   Vector vec = new Vector();
   String[] inhalt = {};

       while(stdin != null)
       {

        String line = stdin.readLine();
        if(line != null)
        {
         System.out.println(line);
        }
       }
  }
  catch(IOException ex)
  {
    System.out.println(ex);
  }
 }
```


----------



## Acha (15. Nov 2006)

Hmmm,

vielleicht kannst Du das anhand der Häufigkeit der verwendeten Buchstaben erkennen? In Deutsch ist "e" ein sehr häufiger Buchstabe und in Englisch das "y". Aber darüber gibt es auch Tabellen, mußt eben mal googeln;-)

MFG

Acha


----------



## dieta (15. Nov 2006)

Mach' dir ne Liste von häufigen rein deutschen Wörtern (30 oder so) und eine ebenso lange mit häufigen rein englischen Wörtern. Dann durchsuchst du die Datei, wie oft Wörter aus der deutschen Liste und wie oft Wörter aus der englischen Liste vorkommen. Wenn hauptsächlich deutsche Wörter vorkommen, ist der Text warsch. deutsch, a sonsten ist er warsch. englisch.

[edit]Mist zweiter, aber wow, noch 1 sek. vor dem 3.[/edit]


----------



## MASTERmind (15. Nov 2006)

@acha:
und was macht er wenn in einer kurzen englischen datei zufällig viele wörter mit "e" vorkommen?

das ist alles so nicht eindeutig....


----------



## dercheffe (15. Nov 2006)

ich würde noch zusätzlich auf ö, ä, ü, ß überprüfen. gibt es ja im englischen nicht. auch das vorkommen "sch" ist im englischen eher selten bis gar nicht vorhanden, mir fällt nur "school" ein, wobei doppel umlaute glaube ich auch nicht oft im deutschen vorkommen.


----------



## X-Treme (15. Nov 2006)

Erstmal Danke, aber könntest mal erklären was hier jetzt Falsch ist (5 Fehler)!^^


```
#import java.io.*;
import java.util.*;


public class Sprachen
{
public void DateiLesen()
{
  try
  {
   String sprache.txt;
   sprache = "/home/lars/sprache.txt";
   File pfad = new File(sprache);
   
   BufferedReader stdin = new BufferedReader(new FileReader(/home/lars/sprache.txt));
   
   Vector vec = new Vector();
   String[] inhalt = {};

       while(stdin != null)
       {

        String line = stdin.readLine();
        if(line != null)
        {
         System.out.println(line);
        }
       }
  }
  catch(IOException ex)
  {
    System.out.println(ex);
  }
}
```


----------



## X-Treme (15. Nov 2006)

Ich glaube auch, dass es im eglischen kein ß gibt! Das sind so Sachen wo man sich wieder überlegen muss, wie genau man arbeiten will!


----------



## Murray (15. Nov 2006)

Was an deinem Programm syntaktisch falsch ist, sagt dir doch schon der Compiler, oder?


----------



## dercheffe (15. Nov 2006)

Fehler:

1) 

```
#import java.io.*;
```
2)

```
String sprache.txt;
```
3)

```
BufferedReader stdin = new BufferedReader(new FileReader(/home/lars/sprache.txt));
```

...

Also wenn du den ersten Fehler "reparierst", dann verschwinden auch ein paar der anderen.


----------



## X-Treme (15. Nov 2006)

Sprachen.java:1: illegal character: \35
#import java.io.*;
^
Sprachen.java:11: ';' expected
   String sprache.txt;
                 ^
Sprachen.java:15: illegal start of expression
   BufferedReader stdin = new BufferedReader(new FileReader(/home/lars/sprache.txt));
                                                            ^
Sprachen.java:15: ')' expected
   BufferedReader stdin = new BufferedReader(new FileReader(/home/lars/sprache.txt));
                                                                                    ^
Sprachen.java:34: '}' expected
}
 ^
5 errors

Also ich für meinen Teil hab keinen Plan was er von mir will^^

(bin halt kein Pro)

MfG


----------



## dercheffe (15. Nov 2006)

wirklich nicht?

mach mal als erstes die # beim import weg. 

und dann machst du doch bitte 

```
String sprache.txt;
```
zu

```
String sprache;
```

bin auch kein pro, aber ich hab schon in einem java buch gelesen und weiß wie man variablen deklariert


----------



## X-Treme (15. Nov 2006)

Hab schon alles berichtigt bis auf den Dateipfad! Die Sache ist die, dass ich hier Linux benutzte und auch von Linux nicht alzu viel Ahnung hab! Also wie geb ich den Dateipfad denn hier an? es gibt kein C: oder sowas!


----------



## dieta (15. Nov 2006)

> Sprachen.java:1: illegal character: \35
> #import java.io.*;
> ^


Damit meint er, dass das # zu viel ist.


> Sprachen.java:11: ';' expected
> String sprache.txt;
> ^


Das ist schon komplizierter, aber du darfst in den Namen von Strings keine Punkte ( . ) verwenden.


> Sprachen.java:15: illegal start of expression
> BufferedReader stdin = new BufferedReader(new FileReader(/home/lars/sprache.txt));
> ^


Der Fehler ist, dass der String nicht in Anführungsstrichen ( " ) steht.


> Sprachen.java:15: ')' expected
> BufferedReader stdin = new BufferedReader(new FileReader(/home/lars/sprache.txt));
> ^


Das ist ein Folgefehler des vorherigen


> Sprachen.java:34: '}' expected
> }
> ^


Und das schätze ich mal auch.

[edit]Das ist hier ja 'ne Antwort-Schlacht  :lol:  Innerhalb von 30 Sekunden 3 Antworten...[/edit]


----------



## dercheffe (15. Nov 2006)

Schau mal hier was man einem FileReader übergeben muss, damit er arbeiten kann  :###


----------



## X-Treme (15. Nov 2006)

Ok, also Compilieren geht. Wenn ich das Prog jetzt ausführe, sagt er mir  "Exception in thread "main" java.lang.NoSuchMethodError: main".


----------



## dercheffe (15. Nov 2006)

was sagt einem das als englischsprechender angehender programmierer ???

vieleicht, dass es keine main methode gibt?


----------



## X-Treme (15. Nov 2006)

ja das weiß ich schon, aber ich frag mich was da rein soll?


(Außerdem werd ich kein Programmierer - mach nur Praktikum^^)

MfG


----------



## Murray (15. Nov 2006)

Die VM meldet ziemlich genau, was nicht stimmt: 
"java.lang.NoSuchMethodError: main" sagt uns, dass versucht wurde, eine Methode namens main aufzurufen, die es in der Klasse aber nicht gibt.

Die VM kann ja nicht wissen, welche Methode einer Klasse der Einstiegspunkt einer Anwendung sein soll, daher gibt es die Konvention, dass die Methode main heisst, als static dekaliert ist und ein String-Array als Parameter bekommt.

Das hast du in deinen anderen Klassen auch schon verwendet (vermutlich ohne genau zu wissen warum).


----------



## X-Treme (15. Nov 2006)

Doch ich weiß schon warum (bei C++ (wird bei Java wohl nicht anders sein^^) ) Aber wie gesagt ich weiß nur gerad net was da rein soll^^


----------



## Murray (15. Nov 2006)

X-Treme hat gesagt.:
			
		

> (Außerdem werd ich kein Programmierer - mach nur Praktikum^^)



Das ist genau die richtige Einstellung, wenn man hier Hilfe erwartet - wir alle opfern doch gern unsere Zeit für jemanden, der nichts lernen will, sondern nur ein paar Wochen (Schul-?)Praktikum abreissen muss.  :noe:


----------



## dercheffe (15. Nov 2006)

naja mach doch in die main mehtode den aufruf der methode die du starten willst, das ist doch in c++ auch nicht anderst, so habe ich es zumindest in dem einen semester c++ gelernt.


----------



## X-Treme (15. Nov 2006)

Das war nur so gemeint, dass ich das nicht alles kennen kann! Ich will das ja lernen sonst hät ich nicht für das Praktikum entschieden!


----------



## X-Treme (15. Nov 2006)

Ich habs jetzt einfach so gemacht:


```
import java.io.*;
import java.util.*;


public class Sprachen
{
public static void main (String[] args)
{
  try
  {
   String sprache;
   sprache = "/home/lars/sprache.txt";
   File pfad = new File(sprache);
   
   BufferedReader stdin = new BufferedReader(new FileReader("/home/lars/sprache.txt"));
   
   Vector vec = new Vector();
   String[] inhalt = {};

       while(stdin != null)
       {

        String line = stdin.readLine();
        if(line != null)
        {
         System.out.println(line);
        }
       }
  }
  catch(IOException ex)
  {
    System.out.println(ex);
  }
}
}
```

Jetzt gib er mir aus was in der Datei steht, aber wie soll ich das mit dem Englischen und Deutschen realisieren? Ich hab bis jetzt nur die Anhaltspunkte von den anderen wie (keine Umlaute | Kein ß)


----------



## dercheffe (15. Nov 2006)

im prinzip genauso wie dein männlich und weiblich problem, nur dass du diesmal andere kriterien ansetzt


----------



## X-Treme (15. Nov 2006)

Jo, aber wie müsste ich das abändern, wenn es 1. keine Eingabe mehr gibt und 2. nicht den letzten Buchstaben nehmen soll sonder sich nach Umlauten und ß umschauen soll?


----------



## Murray (15. Nov 2006)

Mach erstmal die Schleife anders; bisher terminiert die nie, da stdin niemals null wird:


```
BufferedReader stdin = new BufferedReader(new FileReader("/home/lars/sprache.txt"));
   
String line;
while( line = stdin.readLine() != null) {
   System.out.println(line);
}
```


----------



## dercheffe (15. Nov 2006)

naja im prinzip könnte man ja den String line als die "Eingabe" ansehen. 

Ich würde eine Methode schreiben, die die line mit split in einzelne wörter aufteilt, und dann mit einer for schleife die einzelnen wörter durchlaufen, und überprüfen, ob diese ein ü, ö, ä enthält. Wenn dies so ist zum beispiel einen zähler hochzählen, das wort dann auch auf merkmale vom englischen überprüfen und dann dort einen anderen zähler hochzählen. 

dann zum schluß überprüfen welcher zähler höher ist und dann sagen ob es eher ein englischer oder ein deutscher text sein könnte

aber meine lösungen sind nicht immer die optimalsten


----------



## X-Treme (15. Nov 2006)

Irgendwie klappt das nicht so richtig! Ich hab jetzt erstmal den alten Quellcode wiederhergestellt! Kannst du mir anhand des kompletten Codes zeigen was ich da ändern muss?



```
import java.io.*;
import java.util.*;


public class Sprachen
{
	public static void main (String[] args)
	{
		try
	{
		String sprache;
		sprache = "/home/lars/sprache.txt";
		File pfad = new File(sprache);  
		BufferedReader stdin = new BufferedReader(new FileReader("/home/lars/sprache.txt"));  
		Vector vec = new Vector();
		String[] inhalt = {};
		while(stdin != null)
		{
			String line = stdin.readLine();
			if(line != null)
			{
				System.out.println(line);
			}
			}
		}
			catch(IOException ex)
		{
			System.out.println(ex);
		}
	}
	
}
```

MfG


----------



## X-Treme (15. Nov 2006)

So langsam komm ich nicht mehr mit! Bitte alles schön ruhig und langsam.... :autsch:


----------



## dercheffe (15. Nov 2006)

aber schreiben soll ich dir des programm nicht oder?


```
import java.io.*;
import java.util.*;


public class Sprachen
{
   public static void main (String[] args){
      try{
          String sprache;
          sprache = "/home/lars/sprache.txt";                        //was willst du eingentlich damit wenn du unten eh nix damit machst
          File pfad = new File(sprache);                                 //wird auch nie verwendet
          BufferedReader stdin = new BufferedReader(new FileReader("/home/lars/sprache.txt")); 
          String line;
          while( line = stdin.readLine() != null) {
               System.out.println(line);
          } 
      }
         catch(IOException ex){
             System.out.println(ex);
      }
   }
   
}
```


----------



## X-Treme (15. Nov 2006)

> aber schreiben soll ich dir des programm nicht oder?



Ne, ich versuch doch nur irgendwie mal dahinter zu Steigen wie das alles funzt^^

Wenn ich deine Lösung nehme, sagt er mir, dass er boolean braucht bei der Schleife!?!?!?!


----------



## Murray (15. Nov 2006)

Sorry, mein Fehler; da fehlen Klammern:

```
while( (line = stdin.readLine()) != null) {
```


----------



## dercheffe (15. Nov 2006)

nicht mein code, hab ihn nur kopiert


```
while( (line = stdin.readLine()) != null) {
               System.out.println(line);
          }
```


----------



## X-Treme (15. Nov 2006)

Ok jetzt beendet er das Prog! Gut! wenn ich jetzt das so ähnlich mache wie bei "männlicher oder weiblicher vorname", wie sehe das dann aus! Hab mal Probiert, funzt aber net!


```
protected boolean istUmlaut( char c) 
	{
		char[] UmlautArray = { 'ä', 'ü', 'ö', 'ß' };                   //hab das ß jetzt einfache damit reingepackt
		for ( int i=0; i < UmlautArray.length; i++)
		{
			if ( c == UmlautArray[i]) return true;
		}
			return false;
		}
```

Das erstmal
Und dann muss ich ja noch diese ändern:


```
public boolean endedMitVokal( String str) 
	{  
		if ( (str == null)  || (str.length() == 0)) return false;
		return istVokal( str.charAt( str.length()-1));
	}
```


----------



## X-Treme (15. Nov 2006)

Jetzt hat das ja nichts mehr mit der länge zu tun!


----------



## dieta (15. Nov 2006)

Du kannst das ganze auch mit vorgefertigten Methoden von String machen:

```
if(derString.matches(".*[äÄöÖüÜß].*"))
{
    //Der String enthält ä, Ä, ö, Ö, ü, Ü oder ß
}
else
{
    //Der String enthält kein ä, Ä, ö, Ö, ü, Ü oder ß
}
```


----------



## X-Treme (15. Nov 2006)

In dem Falle müsste es doch dann so aussehen:


```
import java.io.*;
import java.util.*;


public class Sprachen
{
   public static void main (String[] args){
      try{
          String sprache;
          sprache = "/home/lars/sprache.txt";                        
          File pfad = new File(sprache);                                 
          BufferedReader stdin = new BufferedReader(new FileReader("/home/lars/sprache.txt"));
          String line;
         while( (line = stdin.readLine()) != null)
		 {
               System.out.println(line);
          }
      }
         catch(IOException ex)
	{
             System.out.println(ex);
	}
	if(line.matches(".*[äÄöÖüÜß].*"))
	{
		System.out.println("Der Text ist wahrscheinlich deutsch!");
	}
else
{
	System.out.println("Der Text ist wahrscheinlich englisch!");
} 
   }
   
}
```

Was ist hier Falsch?


----------



## dercheffe (15. Nov 2006)

so wie du es hier hast, überprüfst du immer nur die letzte zeile der datei und auch immmer die ganze zeile auf einmal. Du müsstest es schon irgendwie in die while schleife machen. ich empfehle dir eine methode zu schreiben.


----------



## X-Treme (15. Nov 2006)

Wie meinst du das mit der Methode? Ich habs jetzt so! Compiler mekkert net, aber ein Fehler zur Laufzeit tritt auf!


```
import java.io.*;
import java.util.*;


public class Sprachen
{
   public static void main (String[] args)
	{
      try
	{
          String sprache;
          sprache = "/home/lars/sprache.txt";                        
          File pfad = new File(sprache);                                 
          BufferedReader stdin = new BufferedReader(new FileReader("/home/lars/sprache.txt"));
          String line;
         while( (line = stdin.readLine()) != null)
		 {
               System.out.println(line);
          }
			if(line.matches(".*[äÄöÖüÜß].*"))
			{
				System.out.println("Der Text ist wahrscheinlich deutsch!");
			}
			else
			{
				System.out.println("Der Text ist wahrscheinlich englisch!");
			} 
      		}
         	catch(IOException ex)
			{
             	System.out.println(ex);
			}
   		}
}
```

THX to All


----------



## X-Treme (15. Nov 2006)

andere Frage: was wären die Parameter für die Methode (ist doch das was in der Klammer dahinter steht, oder?)


----------



## Leroy42 (15. Nov 2006)

```
BufferedReader stdin = new BufferedReader(new FileReader(/home/lars/sprache.txt));
```

Das ist schon eine richtige Pfadangabe unter Linux. Du mußt den
Pfad eben nur noch in Gänsefüßchen schreiben:


```
BufferedReader stdin = new BufferedReader(new FileReader("/home/lars/sprache.txt"));
```

Edit: Uppss! Wieder mal übersehen, daß der Thread schon 3 Seiten lang ist.


----------



## MASTERmind (15. Nov 2006)

X-Treme mein gutster...verstehe ja dass du villeicht schon ein bissch4en verzweifelst. aber so läuft das nicht mit dem java lernen.du musst schon geduld haben und bisschen knobeln, sowie nachlesen.

empfehle immer wieder das tutorial von www.gailer-net.de


----------



## X-Treme (15. Nov 2006)

jo ich glaubs auch so langsam. Hast aber recht, bin am verzwifeln!^^ 
Ich kriegs schon irgendwie hin!

MfG & thx

X-Treme


----------



## MASTERmind (15. Nov 2006)

probiers erst ma mit ausknobeln, lesen und verstehen.
solltest du probleme haben helfe ich gern wenn ich kann.
btw: es ist nicht selten, dass man für ein problem mal zwei stunden oder mehr benötigt es zu lösen!!!


----------



## MASTERmind (15. Nov 2006)

und?hinbekommen?


----------



## X-Treme (16. Nov 2006)

Ne noch nich so ganz, aber ich hoffe ich bin nah dran! Also ich knobel jetzt gerade....^^ 
Also so hab ichs:

```
import java.io.*;
import java.util.*;


public class Sprachen
{
	protected boolean istUmlaut( char a )
	{
		char[] umlautArray = { 'ä', 'Ä', 'ö', 'Ö', 'ü', 'Ü', 'ß' };
		for (int i=0;i < umlautArray.length; i++)
		{
			if ( a == umlautArray[i]) return true;
		}
			return false;
		}
	public boolean schlüssel( String str) 
	{  
		if ( (str == null)  || (str.length() == 0)) return false;
		return istUmlaut( str.charAt( str.length()-1));
	}
	public static void main (String[] args)
	{
		try
	{	                            
		BufferedReader stdin = new BufferedReader(new FileReader("/home/lars/sprache.txt"));
		String line;
		while( (line = stdin.readLine()) != null)
		{
			System.out.println(line);
		}
		}
		catch(IOException ex)
		{
			System.out.println(ex);
		}
		Sprachen sp = new Sprachen();
		boolean englisch = sp.schlüssel( line );
		System.out.print( "Der Satz" + line + " ist wahrscheinlich ");
		if ( englisch ) 
		{
			System.out.println( "Englisch");
		} 
		else
		{
			System.out.println( "Deutsch");    			
		}
	}
}
```

Ich frag mich nur, wie ich bei der "Schlüssel" Methode das hinkrieg, dass er nicht nur den lezten Buchstaben checken soll. Naja bin ich auf dem richtigen weg?

MfG

X-Treme


----------



## Guest (16. Nov 2006)

probier mal die methode nicht mit einem char.


```
private boolean isGerman(String satz){
    
    
        if(satz.matches(".*[äÄöÖüÜß].*")){
              return true;
        }
        else{
              return false;
        }
    }

}
```


----------



## dercheffe (16. Nov 2006)

einfach zu früh für mich :?  :?  
Sry für den Doppelpost


probier mal die methode nicht mit einem char.


```
private boolean isGerman(String satz){

    if(satz.matches(".*[äÄöÖüÜß].*")){
        return true;
    }
    else{
        return false;
    }
}
```


----------



## X-Treme (16. Nov 2006)

is schon schwer so früh am Morgen^^

Das scheint zu klappen allerdings will er unten noch was haben


```
boolean englisch = sp.schlüssel();
```

Weißt du zufällig was da rein soll? Ich hab schon tausend sachen Probiert aber immer Fehler


----------



## dercheffe (16. Nov 2006)

hast es oben doch schon richtig gemacht und ihm die aktuelle zeile übergebe


```
boolean englisch = sp.schlüssel( line );
```

warum diesmal nicht?


----------



## X-Treme (16. Nov 2006)

deswegen:

Sprachen.java:34: cannot find symbol
symbol  : variable line
location: class Sprachen
                boolean deutsch = sp.istDeutsch( line );
                                                 ^
1 error


----------



## X-Treme (16. Nov 2006)

sry ich glaub ich habs...

hab was vergessen!


----------



## X-Treme (16. Nov 2006)

so hab ichs jetzt


```
import java.io.*;
import java.util.*;


public class Sprachen
{
private boolean istDeutsch(String satz)
{
	if(satz.matches(".*[äÄöÖüÜß].*"))
	{
	return true;
	}
	else
	{
	return false;
	}
	}
	 public boolean schlüssel( String str)
   { 
      if ( (str == null)  || (str.length() == 0)) return false;
      return istDeutsch( str.charAt( str.length()-1));
   } 
	public static void main (String[] args)
	{
		try
	{	                            
		BufferedReader stdin = new BufferedReader(new FileReader("/home/lars/sprache.txt"));
		String line;
		while( (line = stdin.readLine()) != null)
		{
			System.out.println(line);
		}
		}
		catch(IOException ex)
		{
			System.out.println(ex);
		}
		Sprachen sp = new Sprachen();
		boolean englisch = sp.schlüssel( line );
		System.out.print( "Der Satz ist wahrscheinlich ");
		if ( englisch ) 
		{
			System.out.println( "Englisch");
		} 
		else
		{
			System.out.println( "Deutsch");    			
		}
	}
}
```

Jetzt spuckt er aber aus:

Sprachen.java:21: istDeutsch(java.lang.String) in Sprachen cannot be applied to (char)
      return istDeutsch( str.charAt( str.length()-1));
             ^
Sprachen.java:39: cannot find symbol
symbol  : variable line
location: class Sprachen
                boolean englisch = sp.schlüssel( line );
                                                 ^
2 errors

(p.s. ich werd noch verrückt!  :bahnhof: )


----------



## dercheffe (16. Nov 2006)

```
import java.io.*;
import java.util.*;


public class Sprachen
{
private boolean istDeutsch(String satz)
{
   if(satz.matches(".*[äÄöÖüÜß].*"))
   {
   return true;
   }
   else
   {
   return false;
   }
}
    
   public static void main (String[] args)
   {
      try
   {                              
      BufferedReader stdin = new BufferedReader(new FileReader("/home/lars/sprache.txt"));
      String line;
      while( (line = stdin.readLine()) != null)
      {
          if(istDeutsch(line){
              System.out.print( "Der Satz ist wahrscheinlich Deutsch");
          }
          else{
             System.out.print( "Der Satz ist wahrscheinlich Englisch");
       }
    } //end try
    catch(IOException ex)
      {
         System.out.println(ex);
      }//end catch
    } //end main

} //end Class
```


----------



## X-Treme (16. Nov 2006)

erstmal Danke, aber der mekkert immer noch (5Fehler^^). Also manchmal.....
hier die Fehler:^^

Sprachen.java:26: ')' expected
                        if(istDeutsch(line){
                                           ^
Sprachen.java:33: illegal start of expression
        }
        ^
Sprachen.java:34: 'catch' without 'try'
                catch(IOException ex)
                ^
Sprachen.java:20: 'try' without 'catch' or 'finally'
                try
                ^
Sprachen.java:39: '}' expected
}
     ^
5 errors

Aber trotzdem echt nett! thx


----------



## dercheffe (16. Nov 2006)

bist du gar nicht krativ, des i ein klammer problem:


```
if(istDeutsch(line)){
```

damit dürfte das wohl behoben sein


----------



## X-Treme (16. Nov 2006)

sry net gesehen  :bahnhof: 

aber noch ne Frage, kann das sein, dass das Try an ner falschen Stelle steht oder so? Weil er mekkert noch über 3 Fehler^^

So wie ich das verstanden hab, will das Try ein catch haben! Kann es aber net finden!


----------



## Gast (16. Nov 2006)

hast die else klammer nicht zugemacht


----------



## X-Treme (16. Nov 2006)

hab ich schon gesehen, aber immer noch 2^^

thx


----------



## dercheffe (16. Nov 2006)

beim else in der while schleife fehlt auch noch die schließende } Klammer


----------



## X-Treme (16. Nov 2006)

hier

Sprachen.java:34: 'catch' without 'try'
                        catch(IOException ex)
                        ^
Sprachen.java:20: 'try' without 'catch' or 'finally'
                try
                ^
2 errors


----------



## X-Treme (16. Nov 2006)

ich kann ja Blind, aber meines erachtens nach sind die Klammern alle richig!


```
import java.io.*;
import java.util.*;


public class Sprachen
{
	private boolean istDeutsch(String satz)
	{
		if(satz.matches(".*[äÄöÖüÜß].*"))
		{
			return true;
		}
		else
		{
			return false;
		}
	}   
	public static void main (String[] args)
	{
		try
	{                             
		BufferedReader stdin = new BufferedReader(new FileReader("/home/lars/sprache.txt"));
		String line;
		while( (line = stdin.readLine()) != null)
		{
			if(istDeutsch(line)){
			System.out.print( "Der Satz ist wahrscheinlich Deutsch");
		}
		else
		{
			System.out.print( "Der Satz ist wahrscheinlich Englisch");
		}
		}
			catch(IOException ex)
			{
				System.out.println(ex);
			}
		}
	}
}
```


----------



## dercheffe (16. Nov 2006)

des catch steht in der while schleife



```
import java.io.*;
import java.util.*;


public class Sprachen{

   private boolean istDeutsch(String satz) {
      if(satz.matches(".*[äÄöÖüÜß].*")){
         return true;
      }
      else{
         return false;
      }
   }   
   
    public static void main (String[] args){
      
      try{                             
          BufferedReader stdin = new BufferedReader(new FileReader("/home/lars/sprache.txt"));
          String line;
         
          while( (line = stdin.readLine()) != null){
             if(istDeutsch(line)){
                System.out.print( "Der Satz ist wahrscheinlich Deutsch");
             }
             else{
                System.out.print( "Der Satz ist wahrscheinlich Englisch");
             }
          }
      }
      catch(IOException ex) {
            System.out.println(ex);
      }
   }
}
```


----------



## X-Treme (16. Nov 2006)

Jo Danke ,jetzt funzt es!  :lol: 

Aber man hätte aus der methode istDeutsch noch static machen müssen^^

So das war der erste Teil! Meine Zweite Idee war (um die genauigkeit des Progs zu erhöhen), noch ein Methode zu benutzen die bestimmte Schlüssel Wörter wie "is, are, am usw" sucht und dann wieder dahin zurück geht um das auszugeben, dass das Enlgisch ist! Kann man das machen oder?! Ich habs mit nem Array Probiert aber ging net^^


ABER ERSTMAL DANKE   

Greetz

X-Treme


----------



## dercheffe (16. Nov 2006)

Klar geht (fast) alles:
als erstes schau mal hier, was zum lesen 

schau die die mehtoden split und equals an, damit solltest du weiter kommen.


----------



## X-Treme (16. Nov 2006)

muss ich beides anwenden oder kann ich mir eins aussuchen?


----------



## dercheffe (16. Nov 2006)

X-Treme hat gesagt.:
			
		

> muss ich beides anwenden oder kann ich mir eins aussuchen?



ich würd beides nehmen


----------



## X-Treme (16. Nov 2006)

```
public String[] split(String regex, int limit)
```

kann ich für regex irgendwas einsetzen oder was hat das zu bedeuten?


----------



## X-Treme (16. Nov 2006)

Also equals steht für entspricht! Also wenn im Satz das Wort is auftauchen würde müsste das so aussehen?



```
if(schlüsselwort.equals("is")
{
    System.out.println("Das Wort" + schlüsselwort "kommt in dem Text vor und ist deßhalb wahrscheinlich englisch!");
```

so in der art (für equals)?


----------



## dercheffe (16. Nov 2006)

jup, des könnte man so machen


----------



## X-Treme (16. Nov 2006)

sollte das dann so aussehen, oder ist da was falsch?


```
public boolean contentEquals(StringBuffer sb)
	{
	if(sb.equals("is", "are", "I");
	{
		System.out.println("Der Satz enthält ein englisches Wort! Und zwar:" +sb);
	}
	else
	{
		return false;
	}
```

Thx to dercheffe^^


----------



## X-Treme (16. Nov 2006)

das Semikolon hinter der If-Anweisung hab ich schon weggemacht^^


----------



## dercheffe (16. Nov 2006)

hm, ich würd sagen des geht schief probier mal:

```
private void contentEquals(String wort){
    if(wort.equals("is") || wort.equals("are") || wort.equals("I")){
       //mach Irgendwas sinnvolles
    }
    else{
        //mach Irgendwas sinvolles
    }
}
```

Du musst ja die Überprüfung für jedes Wort aus dem Satz machen, also überleg dir was du machst, wenn du eins der Schlüsselwörter in einem Satz findest. Und überlege die wie du diese Mehtode auf jedes Wort des Satzes anwendes (vieleicht mit split() .


----------



## X-Treme (16. Nov 2006)

hab zwei Fragen dazu:
1. Was überprüft das Prgramm den jetzt wenn es nicht mit der Methode jedes Wort überprüft?
2. Was meinst du mit "mach was sinnvolles" -> Irgend ne Anweisung oder eine Bildschirm ausgabe?


----------



## X-Treme (16. Nov 2006)

jetzt siehst so aus:


```
import java.io.*;
import java.util.*;


public class Sprachen
{	
	private void contentEquals(String wort)
	{
		if(wort.equals("is") || wort.equals("are") || wort.equals("I"))
		{
			System.out.println("enthält");
		}
		else
		{
			System.out.println("enthält nicht");
		}
	} 
	private static boolean istDeutsch(String satz)
	{
		if(satz.matches(".*[äÄöÖüÜß].*"))
		{
			return true;
		}
		else
		{
			return false;
		}
	}   
	public static void main (String[] args)
	{
		try
	{                             
		BufferedReader stdin = new BufferedReader(new FileReader("/home/lars/sprache.txt"));
		String line;
		while( (line = stdin.readLine()) != null)
		{
			if(istDeutsch(line)){
			System.out.print( "Der Satz ist wahrscheinlich Deutsch");
		}
		else
		{
			System.out.print( "Der Satz ist wahrscheinlich Englisch         ");
		}
		}
		}
			catch(IOException ex)
			{
				System.out.println(ex);
			}
				System.out.println("  ");
		}
	}
```

Sieht aber bei der Ausgabe so aus, als würd die Methode garnichts tun?!?!


----------



## dercheffe (16. Nov 2006)

Also des Programm des wir oben haben mit dem istDeutsch, überprüft ja Zeile, ob da ein umlaut drinn ist, und wenn in einer Zeile ein Umlaut drinn ist, dann gibt er was auf dem Bildschirm aus.

Eine Zeile besteht aber aus mehreren Wörtern. Also musst du es schaffen, diese Wörter aus der Zeile rauszubekommen. Das kann man mit der String Methode split machen.

Die Methode die ich grade geschrieben haben überprüft einen String ob er gleich "is", "are", "I" ist. Sollte also ein Wort sein, was hier überprüft wird.

Ich würde nicht bei jeder Zeile des Textes ausgeben ob diese Zeile deutsch oder englisch ist. Ich würde mir zwei counter machen, einen für deutsche vorkommen und einen für englische. Wenn jetzt was deutsches vorkommt, dann würde ich den counter für deutsch hochzählen, wenn was englisches vorkommt, dann eben den counter für englisch.

zum schluß die beiden counter vergleichen und dann daraus das ergebnis bilden. 

Erweitere am besten das Programm mit istDeutsch so, dass wenn eine Zeile keinen Umlaut hat, jedes Wort dieser Zeile überprüft wird, ob es sich um eines deiner schlüsselwörter handelt.


----------



## X-Treme (16. Nov 2006)

wäre das so richtig deklariert?


```
public String[wort] split(String wörter)
```


----------



## X-Treme (16. Nov 2006)

wo finde ich die Methoden für die Counter?


----------



## dercheffe (16. Nov 2006)

Du hast doch schon mal in c++ programmiert, oder?

also split wie man in der api nachlesen kann, erhält als parameter einen String und gibt ein Array zurück. Also

Hier ein Beispiel:


```
String satz = "Hallo dies ist ein Satz"
String[] temp = satz.split(" ");

System.out.println(temp[0]);
System.out.println(temp[1]);
System.out.println(temp[2]);
```

Ausgabe wäre dann:

Hallo
dies 
ist

allet klar wie split funktioniert?

und als counter kannst du doch einfach ne int variable nehmen die du hochzählst


----------



## X-Treme (16. Nov 2006)

jo is Klar nur, du hast den Satz ja sozusagen intialisiert! Ich will aber ja den Satz aus der Datei haben! Und der is ja auch veränderbar!


----------



## dercheffe (16. Nov 2006)

```
import java.io.*;
import java.util.*;


public class Sprachen{

   int englisch = 0;
   int deutsch = 0;
   
   private boolean istDeutsch(String satz) {
      if(satz.matches(".*[äÄöÖüÜß].*")){
         return true;
      }
      else{
         return false;
      }
   }   
   
   private boolean checkWords(String satz){
   	String[] temp = satz.split(" ")
   	for(int i =0; i<=temp.length; i++){
   		if(wort.equals("is") || wort.equals("are") || wort.equals("I")){
      			 this.englisch++;
    		}
    		else{
        		this.deutsch++;
    		}
    	}
    } 
   
    public static void main (String[] args){
     
      try{                             
          BufferedReader stdin = new BufferedReader(new FileReader("/home/lars/sprache.txt"));
          String line;
         
          while( (line = stdin.readLine()) != null){
             if(istDeutsch(line)){
                this.deutsch++;
             }
             else{
                checkWords(line);
             }
          }
      }
      catch(IOException ex) {
            System.out.println(ex);
      }
      
      if(englisch > deutsch){
      	System.out.println("Dieser Text ist wahrscheinlich Englisch");
      }
      else if(deutsch > englisch){
      	System.out.println("Dieser Text ist wahrscheinlich Deutsch");
      }
      else{
      	System.out.println("Keine Ahnung welche Sprache dieser Text hat, lesen könnte helfen.");
      }
   }
}
```

Keinen Nerv mehr, ich geh essen.


----------



## X-Treme (16. Nov 2006)

Jo Danke für deine Geduld! Ich weiß ich brauch immer ein bischen.....  

Aber trotzdem Danke für alles!

MfG

X-Treme

p.s. Guten Apetit^^


----------



## X-Treme (16. Nov 2006)

Diese Frage geht NICHT an dercheffe (wiil net nerven^^)
aber ich hab in dem Code von Ihm noch Fehler!

Sprachen.java:24: ';' expected
                for(int i =0; i<=temp.length; i++)
                ^
1 error

 ???:L [/code]


----------



## dercheffe (16. Nov 2006)

String[] temp = satz.split(" ") ;


----------



## X-Treme (16. Nov 2006)

ja so hab ich das auch gemacht, aber dann spuckt er auf einamal 10 Fehler aus! die irgendwas mit englisch < deutsch zu tun haben, aber ich kuck erstmal (bischen Knoblen^^)

thx


----------



## X-Treme (16. Nov 2006)

Falls du ne Idee hast:

Sprachen.java:26: cannot find symbol
symbol  : variable wort
location: class Sprachen
                        if(wort.equals("is") || wort.equals("are") || wort.equals("I"))
                           ^
Sprachen.java:26: cannot find symbol
symbol  : variable wort
location: class Sprachen
                        if(wort.equals("is") || wort.equals("are") || wort.equals("I"))
                                                ^
Sprachen.java:26: cannot find symbol
symbol  : variable wort
location: class Sprachen
                        if(wort.equals("is") || wort.equals("are") || wort.equals("I"))
                                                                      ^
Sprachen.java:44: non-static method istDeutsch(java.lang.String) cannot be referenced from a static context
                        if(istDeutsch(line))
                           ^
Sprachen.java:46: non-static variable this cannot be referenced from a static context
                        this.deutsch++;
                        ^
Sprachen.java:50: non-static method checkWords(java.lang.String) cannot be referenced from a static context
                        checkWords(line);
                        ^
Sprachen.java:58: non-static variable englisch cannot be referenced from a static context
        if(englisch > deutsch)
           ^
Sprachen.java:58: non-static variable deutsch cannot be referenced from a static context
        if(englisch > deutsch)
                      ^
Sprachen.java:62: non-static variable deutsch cannot be referenced from a static context
        else if(deutsch > englisch)
                ^
Sprachen.java:62: non-static variable englisch cannot be referenced from a static context
        else if(deutsch > englisch)
                          ^
10 errors


----------



## X-Treme (16. Nov 2006)

wo muss ich die den static machen?


----------



## Murray (16. Nov 2006)

So, wie hier alle Variablen und Methoden direkt aus der main-Methode verwendet werden, kann es nur klappen, wenn diese Variablen und Methoden static deklariert sind - besser (im Sinne der OOP) wäre es natürlich, hier sauber mit Instanzen zu arbeiten.


----------



## X-Treme (16. Nov 2006)

jetzt nur noch drei! Hab die main non-static gemacht!


----------



## X-Treme (16. Nov 2006)

Sprachen.java:26: cannot find symbol
symbol  : variable wort
location: class Sprachen
                        if(wort.equals("is") || wort.equals("are") || wort.equals("I"))
                           ^
Sprachen.java:26: cannot find symbol
symbol  : variable wort
location: class Sprachen
                        if(wort.equals("is") || wort.equals("are") || wort.equals("I"))
                                                ^
Sprachen.java:26: cannot find symbol
symbol  : variable wort
location: class Sprachen
                        if(wort.equals("is") || wort.equals("are") || wort.equals("I"))
                                                                      ^
3 errors

kann das sein, dass man wort noch irgendwo deklarieren muss?


----------



## Murray (16. Nov 2006)

```
private static int englisch = 0;
   private static int deutsch = 0;
   
   private static boolean istDeutsch(String satz) {
     ...
   }   
   
   private static boolean checkWords(String satz)
      ...
    }
```

Die Main-Methode muss static sein, sonst kann man sie nicht aufrufen!


----------



## X-Treme (16. Nov 2006)

oO OK^^
thx


----------



## Murray (16. Nov 2006)

X-Treme hat gesagt.:
			
		

> kann das sein, dass man wort noch irgendwo deklarieren muss?



Ja, da ist bei der Umstellung wohl etwas  schiefgegangen:

```
private boolean checkWords(String satz){
      String[] temp = satz.split(" ")
      for(int i =0; i<=temp.length; i++){
         String wort = temp[i];
         if(wort.equals("is") || wort.equals("are") || wort.equals("I")){
                this.englisch++;
          }
          else{
              this.deutsch++;
          }
       }
    }
```


----------



## Leroy42a (16. Nov 2006)

X-Treme hat gesagt.:
			
		

> kann das sein, dass man wort noch irgendwo deklarieren muss?



Wenn das in dieser Methode steht:

```
private void contentEquals(String wort) 
   { 
      if(wort.equals("is") || wort.equals("are") || wort.equals("I")) 
      { 
         System.out.println("enthält"); 
      } 
      else 
      { 
         System.out.println("enthält nicht"); 
      } 
   }
```
dann nicht. Es ist dort als formaler Parameter definiert und
_kann _keine derartige Fehlermeldung bewirken-


----------



## X-Treme (16. Nov 2006)

Kann mir mal bitte jemand sagen, was hier jetzt falsch ist?


```
import java.io.*;
import java.util.*;


public class Sprachen
{
	private static int englisch = 0;
	private static int deutsch = 0;
  
	private static boolean istDeutsch(String satz) 
	{
	if(satz.matches(".*[äÄöÖüÜß].*"))
	{
		return true;
	}
	else
	{
		return false;
	}
}      
	private static boolean checkWords(String satz)
	{
		String[] temp = satz.split(" ");
		for(int i =0; i<=temp.length; i++)
		{
			if(wort.equals("is") || wort.equals("are") || wort.equals("I"))
			{
				this.englisch++;
			}
			else
			{
				this.deutsch++;
			}
		}
	}
	public static void main (String[] args)
	{
		try
	{                             
		BufferedReader stdin = new BufferedReader(new FileReader("/home/lars/sprache.txt"));
		String line;
		while( (line = stdin.readLine()) != null)
		{
			if(istDeutsch(line))
		{
			this.deutsch++;
		}
		else
		{
			checkWords(line);
		}
	}
}
	catch(IOException ex) 
	{
		System.out.println(ex);
	}
	if(englisch > deutsch)
	{
		System.out.println("Dieser Text ist wahrscheinlich Englisch");
	}
	else if(deutsch > englisch)
	{
		System.out.println("Dieser Text ist wahrscheinlich Deutsch");
	}
		else
		{
			System.out.println("Dieser Text ist wahrscheinlich weder deutsch oder englisch!");
		}
	}
}
```


----------



## X-Treme (16. Nov 2006)

wenn ichs so mach (nach Murrays Beispiel) gehts auch net!


```
import java.io.*;
import java.util.*;


public class Sprachen
{
	private static int englisch = 0;
	private static int deutsch = 0;
  
	private static boolean istDeutsch(String satz) 
	{
	if(satz.matches(".*[äÄöÖüÜß].*"))
	{
		return true;
	}
	else
	{
		return false;
	}
}      
	private static boolean checkWords(String satz)
	{
		String[] temp = satz.split(" ");
		for(int i =0; i<=temp.length; i++)
		{
			String wort = temp[i];
			if(wort.equals("is") || wort.equals("are") || wort.equals("I"))
			{
				this.englisch++;
			}
			else
			{
				this.deutsch++;
			}
		}
	}
	public static void main (String[] args)
	{
		try
	{                             
		BufferedReader stdin = new BufferedReader(new FileReader("/home/lars/sprache.txt"));
		String line;
		while( (line = stdin.readLine()) != null)
		{
			if(istDeutsch(line))
		{
			this.deutsch++;
		}
		else
		{
			checkWords(line);
		}
	}
}
	catch(IOException ex) 
	{
		System.out.println(ex);
	}
	if(englisch > deutsch)
	{
		System.out.println("Dieser Text ist wahrscheinlich Englisch");
	}
	else if(deutsch > englisch)
	{
		System.out.println("Dieser Text ist wahrscheinlich Deutsch");
	}
		else
		{
			System.out.println("Dieser Text ist wahrscheinlich weder deutsch oder englisch!");
		}
	}
}
```


----------



## AlArenal (16. Nov 2006)

Du kannst keine Variablen verwenden, die nicht initialisiert und nichtmal deklariert sind.


----------



## X-Treme (16. Nov 2006)

AlArenal hat gesagt.:
			
		

> Du kannst keine Variablen verwenden, die nicht initialisiert und nichtmal deklariert sind.



Es sind doch alle deklariert und initialisiert, oder?


----------



## AlArenal (16. Nov 2006)

Was sagen die Fehlermeldungen?


----------



## X-Treme (16. Nov 2006)

Jo Leute ich mach jetzt Feierabend! Für heute hab ich auch die Schnauze voll^^

aber morgen gehts weiter^^

Greetz 

X-Treme


----------



## Leroy42a (16. Nov 2006)

Und wo bitte ist hier drin

```
private static boolean checkWords(String satz) 
   { 
      String[] temp = satz.split(" "); 
      for(int i =0; i<=temp.length; i++) 
      { 
         String wort = temp[i]; 
         if(wort.equals("is") || wort.equals("are") || wort.equals("I")) 
         { 
            this.englisch++; 
         } 
         else 
         { 
            this.deutsch++; 
         } 
      } 
   }
```

die Variable _wort_ deklariert?  :shock: 

Preisfrage: Durch welche (deklarierte) Variable muß _wort_ ersetzt werden,
sodaß die Methode syntaktisch und semantisch korrekt ist?  ???:L


----------



## Leroy42a (16. Nov 2006)

Uuupps! 

wort ist ja doch mittlerweile deklariert!   

Irgendwie macht mich die andauernde Eingabe meines
Benutzernamens kirre im Kopf.   :autsch:


----------



## AlArenal (16. Nov 2006)

Meld dich doch einfach an


----------



## Murray (16. Nov 2006)

Mittlerweile dürfte das Problem eher darin bestehen, dass durch die Umstellung auf statics das this in der Methode nicht mehr lediglich überflüssig, sondern wirklich falsch ist.

Also:

```
private static boolean checkWords(String satz)
   {
      String[] temp = satz.split(" ");
      for(int i =0; i<=temp.length; i++)
      {
         String wort = temp[i];
         if(wort.equals("is") || wort.equals("are") || wort.equals("I"))
         {
            englisch++;
         }
         else
         {
            deutsch++;
         }
      }
   }
```


----------



## Leroy42a (16. Nov 2006)

AlArenal hat gesagt.:
			
		

> Meld dich doch einfach an



Wenn ich mein Passwort noch kennen würde oder zumindest,
welche email-Adresse ich hier angegeben habe *und* dazu dann noch
wüßte wie das Passwort bei dieser email-Adresse ist *und* mach dann
noch mit Kontoeinrichtungen in diesem bescheuerten Outlook, der
auf diesem Ersatzrechner installiert ist, auskennen würde *und* mich
dieses Augenkrebserregende  XP-Look&Feel, was ja _auf gar keinen Fall
geändert werden darf_, nicht ohnehin schon brastig machen würde; vielleicht.

Eins ist schon mal klar: Wenn _mein Rechner_ nach einer Woche von der
Reparatur zurückkommt, muß ich erstmal in Reparatur...  :autsch:


----------



## Guest (16. Nov 2006)

Leroy42a hat gesagt.:
			
		

> Uuupps!
> 
> wort ist ja doch mittlerweile deklariert!
> 
> ...



oO mmM

Naja, ich kanns erst morgen ausprobieren Murray...(aber ich vertrau dir mal!^^) Hab das Prog nähmlich auf meinem Arbeitsplatz Rechner liegen^^

Also bis morgen^^


----------



## X-Treme (17. Nov 2006)

Guten Morgen allerseits, ich hät noch eine Frage zu meinem Prog und zwar wollte ich wohl Fragen wo ich hier noch eine Klammer oder ein return statement hinsetzen muss!


```
import java.io.*;
import java.util.*;


public class Sprachen
{
	private static int englisch = 0;
	private static int deutsch = 0;
  
	private static boolean istDeutsch(String satz) 
	{
	if(satz.matches(".*[äÄöÖüÜß].*"))
	{
		return true;
	}
	else
	{
		return false;
	}
}      
	private static boolean checkWords(String satz)
	{
		String[] temp = satz.split(" ");
		for(int i =0; i<=temp.length; i++)
		{
			String wort = temp[i];
			if(wort.equals("is") || wort.equals("are") || wort.equals("I"))
			{
				englisch++;
			}
			else
			{
				deutsch++;
			}
		}
	}
	public static void main (String[] args)
	{
		try
	{                             
		BufferedReader stdin = new BufferedReader(new FileReader("/home/lars/sprache.txt"));
		String line;
		while( (line = stdin.readLine()) != null)
		{
			if(istDeutsch(line))
		{
			deutsch++;
		}
		else
		{
			checkWords(line);
		}
	}
}
	catch(IOException ex) 
	{
		System.out.println(ex);
	}
	if(englisch > deutsch)
	{
		System.out.println("Dieser Text ist wahrscheinlich Englisch");
	}
	else if(deutsch > englisch)
	{
		System.out.println("Dieser Text ist wahrscheinlich Deutsch");
	}
		else
		{
			System.out.println("Dieser Text ist wahrscheinlich weder deutsch oder englisch!");
		}
	}
}
```

Greetz X-Treme


----------



## dercheffe (17. Nov 2006)

```
private static boolean checkWords(String satz)
```
wie du es deklariert hast musst du noch einen boolean zurückgeben

als ich gestern abend mir dieses programm durch den kopf hab gehen lassen ist mir noch ein fehler aufgefallen. bei check words wird überprüft ob ein satz die "schlüsselwörter" enthält. wenn dies der fall ist, dann wird englisch hochgezählt, wenn nicht dann deutsch. Dies geschieht für jedes wort. ein englischer satz besteht aber vielmehr aus wörtern die eben nicht die "schlüsselwörter" sind. also zählt er häufiger den deutschen int hoch. ich würde das else entfernen, dann ist die ausgabe korrekter, oder eben die schlüsselwörter vervielfachen um es genauer hinzubekommen.


----------



## X-Treme (17. Nov 2006)

also eine true & false anweisung oder wie?


----------



## dercheffe (17. Nov 2006)

ja, boolean ist  ein true oder ein false


----------



## X-Treme (17. Nov 2006)

> als ich gestern abend mir dieses programm durch den kopf hab gehen lassen ist mir noch ein fehler aufgefallen. bei check words wird überprüft ob ein satz die "schlüsselwörter" enthält. wenn dies der fall ist, dann wird englisch hochgezählt, wenn nicht dann deutsch. Dies geschieht für jedes wort. ein englischer satz besteht aber vielmehr aus wörtern die eben nicht die "schlüsselwörter" sind. also zählt er häufiger den deutschen int hoch. ich würde das else entfernen, dann ist die ausgabe korrekter, oder eben die schlüsselwörter vervielfachen um es genauer hinzubekommen.



Jo ich hab ne Liste mit den 10 häufigsten deutschen und englischen Wörtern. Ist das dann immer noch zu ungenau oder nicht?

der
die
und
in
den
von
zu
das
mit
sich

of
to
and
a
in
for
is
the
that
on


----------



## X-Treme (17. Nov 2006)

Wie müsste ich das denn machen, wenn ich für beides Überprüfen will?

wo soll das true oder false denn stehen? direkt hinter der Klammer oder bei der If-Anweisung?


----------



## X-Treme (17. Nov 2006)

Ich habs jetzt so gemacht:



```
import java.io.*;
import java.util.*;


public class Sprachen
{
	private static int englisch = 0;
	private static int deutsch = 0;
  
	private static boolean istDeutsch(String satz) 
	{
	String[] temp2 = satz.split(" ");
	for(int i =0; i<=temp2.length; i++)
	{
		String wort2 = temp2[i];
		if(wort2.equals("der") || wort2.equals("die") || wort2.equals("und") || wort2.equals("in") || wort2.equals("den"( || wort2.equals("von") || wort2.equals("das") || wort2.equals("mit") || wort2.equals("zu") || wort2.equals("sich"))
		{
			deutsch++;
		}
	}
}      
	private static boolean checkWords(String satz)
	{
		String[] temp = satz.split(" ");
		for(int i =0; i<=temp.length; i++)
		{
			String wort = temp[i];
			if(wort.equals("is") || wort.equals("a") || wort.equals("I") || wort.equals("of") || wort.equals("to") || wort.equals("and") || wort.equals("for") || wort.equals("the") || wort.equals("that") || wort.equals("on") || wort.equals("are"))
			{
				englisch++;
			}
		}
	}
	public static void main (String[] args)
	{
		try
	{                             
		BufferedReader stdin = new BufferedReader(new FileReader("/home/lars/sprache.txt"));
		String line;
		while( (line = stdin.readLine()) != null)
		{
			if(istDeutsch(line))
		{
			deutsch++;
		}
		else
		{
			checkWords(line);
		}
	}
}
	catch(IOException ex) 
	{
		System.out.println(ex);
	}
	if(englisch > deutsch)
	{
		System.out.println("Dieser Text ist wahrscheinlich Englisch");
	}
	else if(deutsch > englisch)
	{
		System.out.println("Dieser Text ist wahrscheinlich Deutsch");
	}
		else
		{
			System.out.println("Dieser Text ist wahrscheinlich weder deutsch oder englisch!");
		}
	}
}
```

hab nur noch immer das mit dem mising return statement und einen Klammerfehler


----------



## X-Treme (17. Nov 2006)

Klammerfehler gefudnen, jetzt brauch ich halt 2mal ein retunr statement (logisch)^^


----------



## dercheffe (17. Nov 2006)

warum machst du sie nicht einfach void ?


----------



## X-Treme (17. Nov 2006)

Das scheint irgendwie nicht so zu funktionieren oO

Der will unbedingt boolean haben! Sagt er auch found:viod required: boolean!


----------



## dercheffe (17. Nov 2006)

:shock:  :shock:  :shock:  :shock: 
siehe hier

wenn du mit  :###  feritg bist, kannst du nochmal eine  :?:  stellen, aber ich hoffe dir geht vorher ein  :idea:  auf. 

Da dies bestimmt nicht die letze Aufgabe ist, die du in deinem Praktikum bekommst, solltest du dann des Buch Java ist auch eine Insel lesen.


----------



## X-Treme (17. Nov 2006)

Jup hast recht^^

also werd ich mal  :###  und vllt geht mir dann ja ein  :idea: auf^^

MfG

X-Treme


----------



## X-Treme (17. Nov 2006)

Ich glaub ich habs! Das Programm liefert das richtige ergebnis, aber könnte vllt jemand nochmal prüfen ob das Prog den richtigen weg nimmt?


```
import java.io.*;
import java.util.*;


public class Sprachen
{
	private static int englisch = 0;
	private static int deutsch = 0;
  
	private static void istDeutsch(String satz) 
	{
	String[] temp2 = satz.split(" ");
	for(int i =0; i<=temp2.length; i++)
	{
		String wort2 = temp2[i];
		if(wort2.equals("der") || wort2.equals("die") || wort2.equals("und") || wort2.equals("in")
                 || wort2.equals("den") || wort2.equals("von") || wort2.equals("das") || wort2.equals("mit") || wort2.equals("zu")
                 || wort2.equals("sich"))
		{
			deutsch++;
		}
	}
}      
	private static void istEnglisch(String satz)
	{
		String[] temp = satz.split(" ");
		for(int i =0; i<=temp.length; i++)
		{
			String wort = temp[i];
			if(wort.equals("is") || wort.equals("a") || wort.equals("I") || wort.equals("of") || wort.equals("to") 
                       || wort.equals("and") || wort.equals("for") || wort.equals("the") || wort.equals("that") || wort.equals("on") 
                       || wort.equals("are"))
			{
				englisch++;
			}
		}
	}
	public static void main (String[] args)
	{
		try
	{                             
		BufferedReader stdin = new BufferedReader(new FileReader("/home/lars/sprache.txt"));
		String line;
		while( (line = stdin.readLine()) != null)
		{
			if(line.matches(".*[äÄöÖüÜß].*"))
		{
			deutsch++;
		}
		else
		{
			englisch++;
		}
	}
}
	catch(IOException ex) 
	{
		System.out.println(ex);
	}
	if(englisch > deutsch)
	{
		System.out.println("Dieser Text ist wahrscheinlich Englisch");
	}
	else if(deutsch > englisch)
	{
		System.out.println("Dieser Text ist wahrscheinlich Deutsch");
	}
		else
		{
			System.out.println("Dieser Text ist wahrscheinlich weder deutsch oder englisch!");
		}
	}
}
```

thx


----------



## X-Treme (17. Nov 2006)

schon gut! Ist ein Fehler noch drin sry (hab vergessen zu Prüfen wenn der Inhalt deutsch ist^^


----------



## Murray (17. Nov 2006)

Du hast hier offenbar zwei Ansätze vermischt; die Methoden istDeutsch und isEnglisch werden überhaupt nicht aufgerufen; vielmehr wird anstelle der in diesen Methoden implementierten Wortanalyse direkt in der main einfach jede Zeile dahingehend untersucht, ob sie einen Umalut enthält. Du müsstest dich also entscheiden, welchen Ansatz du verfolgen willst.


----------



## X-Treme (17. Nov 2006)

Ja das mit den Umaluten unten hinzuschreiben war nur so ne Idee eigentlich siehts so aus:


```
import java.io.*;
import java.util.*;


public class Sprachen
{
	private static int englisch = 0;
	private static int deutsch = 0;
  
	private static void istDeutsch(String satz) 
	{
	String[] temp2 = satz.split(" ");
	for(int i =0; i<=temp2.length; i++)
	{
		String wort2 = temp2[i];
		if(wort2.equals("der") || wort2.equals("die") || wort2.equals("und") || wort2.equals("in") || wort2.equals("den")
                 || wort2.equals("von") || wort2.equals("das") || wort2.equals("mit") || wort2.equals("zu") || wort2.equals("sich"))
		{
			deutsch++;
		}
	}
}      
	private static void istEnglisch(String satz)
	{
		String[] temp = satz.split(" ");
		for(int i =0; i<=temp.length; i++)
		{
			String wort = temp[i];
			if(wort.equals("is") || wort.equals("a") || wort.equals("I") || wort.equals("of") || wort.equals("to") 
                     || wort.equals("and") || wort.equals("for") || wort.equals("the") || wort.equals("that") || wort.equals("on")
                    || wort.equals("are"))
			{
				englisch++;
			}
		}
	}
	public static void main (String[] args)
	{
		try
	{                        
		BufferedReader stdin = new BufferedReader(new FileReader("/home/lars/sprache.txt"));
		String line;
		while( (line = stdin.readLine()) != null)
		{
			if(istDeutsch(line))
		{
			deutsch++;
		}
		else
		{
			 istEnglisch(line);
		}
	}
}
	catch(IOException ex) 
	{
		System.out.println(ex);
	}
	if(englisch > deutsch)
	{
		System.out.println("Dieser Text ist wahrscheinlich Englisch");
	}
	else if(deutsch > englisch)
	{
		System.out.println("Dieser Text ist wahrscheinlich Deutsch");
	}
		else
		{
			System.out.println("Dieser Text ist wahrscheinlich weder deutsch oder englisch!");
		}
	}
}
```

Ich bin noch am Knobeln, weil "dercheffe" gesagt, dass ich das einfach void mach soll! Aber wenn ich das tue will er auf einaml wieder boolean haben! Sehr verwirrend^^


----------



## X-Treme (17. Nov 2006)

so siehts nähmlich aus!

incompatible types
found   : void
required: boolean
                        if(istDeutsch(line))
                                     ^
1 error

Ich find dazu nix! Ich entnehme daraus, dass er boolean haben will! Aber wie???


----------



## Murray (17. Nov 2006)

Entweder machst du die Methoden void und erhöhst die Zählen in den Methoden du oder lieferst Werte zurück und erhöhst die Zähler dort ,wo die Methoden augerufen werden. Im Moment mischt du das.

Wenn Du istDeutsch und istEnglisch so lassen willst, könnte die main so aussehen:

```
public static void main (String[] args) {
      try {                       
        BufferedReader stdin = new BufferedReader(new FileReader("/home/lars/sprache.txt"));
        String line;
        while( (line = stdin.readLine()) != null)  {
           istDeutsch(line);
           istEnglisch(line);
       }
     } catch(IOException ex) {
      System.out.println(ex);
     }
     if(englisch > deutsch) {
      System.out.println("Dieser Text ist wahrscheinlich englisch");
     } else if(deutsch > englisch) {
      System.out.println("Dieser Text ist wahrscheinlich deutsch");
     } else {
         System.out.println("Dieser Text ist wahrscheinlich weder deutsch oder englisch!");
     }
   }
```


----------



## X-Treme (17. Nov 2006)

erstmal Danke Murray, kann man irgendwo Fehlermeldungen nachlesen?

Ich hab nähmlich (zur laufzeit allerdings) folgenden bekommen:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4
        at Sprachen.istDeutsch(Sprachen.java:15)
        at Sprachen.main(Sprachen.java:42)

kann man sowas irgendwo nachschlagen, oder net?


----------



## dercheffe (17. Nov 2006)

```
for(int i =0; i<temp.length; i++)
```

da muss ein "=" raus


----------



## X-Treme (17. Nov 2006)

jo THX. kann das sein, dass das Programm biede Methoden jedesmal ausführt und dann auch jedes mal zählt? Ich jetzt nen Deutschen Text in die Datei geschrieben und: Diese ist ein Test! Jetzt gibt mir aber aus, dass der Text weder Deutsch nohc Englisch sei!


----------



## X-Treme (17. Nov 2006)

hab dem Fehler schon^^


----------



## X-Treme (17. Nov 2006)

Also der Fehler war, dass in "Dies ist ein Test!" keines der Schlüsselwörter vorkam^^

Also ist das alles ne Frage der genauigtkeit!

Danke an alle

Greetz

X-Treme


----------

