# Anzahl Clients aus Start- und Endadr. berechnen



## MAGIo (14. Mrz 2011)

Hallo, wie kann ich bei gegebener Startadr. und Endadr. durch Benutzereingabe daraus die Anzahl der theoretischen Clients im Netz berechnen? Ich denke die Umrechnung in Bytes könnte mich da weiterbringen, doch muss das ja ein allgemein gültiger Rechenweg sein, da ja unterschiedliche Eingaben je nach Netzklasse gemacht werden. Alternativ ginge es ja auch über die zusätzliche Eingabe der Subnetzmaske. 

Ich denke Ihr hattet sowas schonmal, gefunden habe ich leider nichts.

Bitte helft mir da weiter, VG


----------



## chalkbag (14. Mrz 2011)

An sich brauchst du um die Anzahl der theoretisch möglichen Clients nicht zwangsweise Start u. Endaddresse angeben, auch die Subnetzmaske brauchst du nur beim Subnetting.

Über die führenden Bits, weißt du ja welches Netz du vor dir hast, und wieviel Clients du maximal addressieren kannst.


----------



## Eldar (14. Mrz 2011)

Du ziehst die Startadresse von der Endadresse ab (z.B binär). Dann nur noch -2 für Netz- und Broadcastadresse.

Beispiel:
Anfangsadresse 
192.168.4.0
11000000 10101000 00000100 00000000
Endadresse 
192.168.12.255
11000000 10101000 00001100 11111111


Rechnung
 1100 11111111
-0100 00000000
=1000 11111111
=2303
Sind also 2303 Adressen also 2301 mögliche Clients


----------



## MAGIo (14. Mrz 2011)

> Du ziehst die startadresse von der Endadresse ab (binär)



Komplett? Und die bin. Differenz stellt die anzahl der mögl. Clients dar?


----------



## Eldar (14. Mrz 2011)

Hab mal eine Beispielrechnung eingefügt. Nicht vergessen, dass die erste und die letzte Adresse nicht an einen Client zu vergeben sind.

edit: Mir fällt zumindest auf Anhieb keine Kombination ein bei der das nicht klappen würde.


----------



## MAGIo (15. Mrz 2011)

Bin es rechnerisch durchgegangen und ist ja auch logisch, wenn man sich den prinzipiellen Aufbau anschaut. Jedoch ist dann noch der Unterschied zwischen Theorie und Praxis...


Also.. WIE RECHNE ICH DIE IP ADR. IN DUALZAHLEN ODER BYTES UM?


----------



## Eldar (15. Mrz 2011)

Wie genau bekommst du sie denn? 
Ist vielleicht die Eingabemaske schon entsprechend aufgebaut (4 Felder für Zahlen zwischen 0 und 255)?
Oder bekommst du sie als String (ein Eingabefeld für alle möglichen Zeichen)?
oder wie?

Schau dir mal java.net.InetAdress an.


----------



## MAGIo (15. Mrz 2011)

Ich bekomme den String und nutze InetAddress address = get........

Nur weiss ich nicht wirklich, wie ich daraus die Bitfolge bestimmen kann dann.


----------



## Eldar (15. Mrz 2011)

byte[] getAddress() schon hast du die Oktette. Bissl umwandeln..
Integer.toBinaryString(). 

Oder willst du lieber per Hand rechnen?


----------



## MAGIo (15. Mrz 2011)

ich setze mich morgen frueh da wieder dran und versuch es. Melde mich dann, aber vielen Dank.


----------



## MAGIo (18. Mrz 2011)

```
byte[] rawaddr = address.getAddress();  
     Integer.toBinaryString(i);
```

Da fehlt ja der Zwischenschritt, wie schaffe ich es denn, daraus ein Integer zu machen, sodass ich es zum BinaryString umwandeln kann?


----------



## HoaX (18. Mrz 2011)

Indem du die Bytes aus rawaddr aneinander hängst.

rawaddr[0] << 24 | rawaddr[1] << 16 | ...


----------



## MAGIo (21. Mrz 2011)

Konkret als Code bedeutet das? Ich krieg nur Wirrwarr heraus! 
Zudem krieg ich als Rawaddr. schon negative Zahlen, was ja nicht sein kann...



```
System.out.println( Integer.toBinaryString(rawaddr[0] << 24 | rawaddr[1] << 16 | rawaddr[2] << 8 | rawaddr[3] << 0 ) );
```

genial... wenn ich noch wuesste, wieso?


----------



## HoaX (21. Mrz 2011)

Wieso sollten sie positiv sein? Kommt halt drauf an wie man sie interpretiert.

Ab besten du informierst dich erstmal über die binäre Darstellung von Zahlen und Bit-Operatoren.


----------



## MAGIo (22. Mrz 2011)

Funktioniert Alles, bis auf...

Wie bestimme ich die Netzklasse? Mir ist klar, dass anhand der einleitenden Bits diese bestimmen kann, das wird ja sicherlich schon jemand so gemacht haben. Es ist ja nun praktisch, dass ich die Umrechnung in Bits vorgenommen habe.


----------



## HoaX (22. Mrz 2011)

Schau dir doch mal die binäre Darstellung der Netzklasse an... mit ein bisschen nachdenken (oder googlen) kommst du drauf.


----------



## MAGIo (24. Mrz 2011)

Ich habe das altbekannte Problem, dass die Umrechnung fuer IP Adresse ueber +127 natuerlich was Falsches herauskommt. Hatte es in einem FIrmennetz getestet, daher ist der Fehler nicht aufgefallen. Wie loese ich das denn nun?


----------



## HoaX (24. Mrz 2011)

Rechne halt mit int statt byte?! Bzw sollte die Rechnung idR trotzdem funktionieren, du musst nur am Ende passend auf int umwandeln: 
	
	
	
	





```
byte b = -1; 
int i = b & 0xff; // ergibt i = 255
```


----------



## MAGIo (24. Mrz 2011)

Ich probier schon den halben Tag rum... Es wird mal wieder was ganz simples sein, nur verliert man bei Fehlern dann auch schnell und leicht den Ueberblick und dann wirds kritisch...

Ich probier mal rum, bg


----------



## MAGIo (24. Mrz 2011)

Also irgendwas stimmt hier nicht, bei mir 

zB krieg ich bei einer IP Adresse mit 192. ... den Beginn mit 11111111....  und bei 10.10. 1010...

Ich verstehe auch Deine Ausfuehrung am Ende, nur wie soll ich das einbringen bzgl. Umrechnung im Programm?

Ich konkretisier es mal anhand eines Codeschnipsels:

```
System.out.println( "IP Startbereich eingeben:" ); //Aufforderung zur IP Eingabe
       BufferedReader in = new BufferedReader( //Streamen der Eingabe als Eingabestream
       new InputStreamReader( System.in )); //Erstellen des Eingangsstreams
       start = in.readLine(); //liest komplette Zeile ein und speichert als String start       
  	 System.out.println( "IP Endbereich eingeben:" ); //Aufforderung zur IP Eingabe
     end = in.readLine();     //liest komplette Zeile ein und speichert als String end 
     InetAddress addrstart = InetAddress.getByName(start); //Umwandlung der Start-Eingabe in IP Adresse addresss
     byte[] rawaddrs = addrstart.getAddress();  //Umwandlung der Startadresse in Bitoperatoren RAW 
     binstart = Integer.toBinaryString((rawaddrs[0] << 24 | rawaddrs[1] << 16 | rawaddrs[2] << 8 | rawaddrs[3] << 0 ));
     InetAddress addrend = InetAddress.getByName(end); //Umwandlung der End-Eingabe in IP Adresse addresse
     byte[] rawaddre = addrend.getAddress(); //Umwandlung der Endadresse in Bitoperatoren RAW
     System.out.println(Integer.toBinaryString(rawaddre[0] << 24 | rawaddre[1] << 16 | rawaddre[2] << 8 | rawaddre[3] << 0 ) );
```


----------



## HoaX (24. Mrz 2011)

Zeig doch mal deine Idee und ggf. Code wie dus versuchst ...
Wie du die IPs einliest ist doch völlig irrelevant.


----------



## MAGIo (24. Mrz 2011)

```
binstart = Integer.toBinaryString((rawaddrs[0] << 24 | rawaddrs[1] << 16 | rawaddrs[2] << 8 | rawaddrs[3] << 0 ));
     InetAddress addrend = InetAddress.getByName(end); //Umwandlung der End-Eingabe in IP Adresse addresse
     byte[] rawaddre = addrend.getAddress(); //Umwandlung der Endadresse in Bitoperatoren RAW
     System.out.println(Integer.toBinaryString(rawaddre[0] << 24 | rawaddre[1] << 16 | rawaddre[2] << 8 | rawaddre[3] << 0 ) );
     raw = ((rawaddre[0] << 24 | rawaddre[1] << 16 | rawaddre[2] << 8 | rawaddre[3] << 0))-((rawaddrs[0] << 24 | rawaddrs[1] << 16 | rawaddrs[2] << 8 | rawaddrs[3] << 0)); //Bestimmung der RAW Differenz in Variable raw
     clients = ++raw;//Bestimmung der Testanzahl
     binend = ( Integer.toBinaryString(rawaddre[0] << 24 | rawaddre[1] << 16 | rawaddre[2] << 8 | rawaddre[3] << 0 ) ); //Ausgabe der binary Endadresse
     System.out.println(binstart);
     System.out.println(binend);
```

Klar, aber integrativer Bestandteil der Ausgabe


----------



## HoaX (24. Mrz 2011)

Also den Code zu lesen macht mal null Spaß, nutz doch mal ordentliche Variablennamen und Formatierung und mach nicht immer so viele Schritte in einer Zeile ... und dann mach dir einen Test der z.B. so anfängt:

```
long startAdresse = 192 << 24 | 168 << 16 | 2 << 8 | 0;
long endAdresse = 192 << 24 | 168 << 16 | 2 << 8 | 255;
```
Damit rechnest du dann. Dann kann man das auch einfach mal hier herauskopieren und ausprobieren. So muss man ja erstmal 10 Zeilen anpassen und Variablen deklarieren usw ...

Nachtrag: Deine Idee wie du nun auf die Netzmaske kommst ist bislang auch noch nicht enthalten. Tipp zur einfachen Berechnung: xor


----------



## MAGIo (24. Mrz 2011)

Ja, hab ich gemacht. Das Splitten wollte ich bei erfolgreichem Ablauf machen, weil ich irgendwie tausend Gedanken gleichzeitig habe um das noch besser zu machen. Natuerlich leidet dann die Uberesichtlichkeit und die Funktionalitaet wird nicht unbedingt besser...

Trotzdem, ich denke der Punkt ist bei 


```
InetAddress addrstart = InetAddress.getByName(start); //Umwandlung der Start-Eingabe in IP Adresse addresss
     byte[] rawaddrs = addrstart.getAddress();  //Umwandlung der Startadresse in Bitoperatoren RAW 
     binstart = Integer.toBinaryString((rawaddrs[0] << 24 | rawaddrs[1] << 16 | rawaddrs[2] << 8 | rawaddrs[3]));
```


----------



## MAGIo (24. Mrz 2011)

Naja, die Klassifizierung des Netzes scheint ja zu klappen, habe das mit einer mehrfahren IF Verzweigung geloest, nur ist die Berechnung der binaeren Darstellung zumindest fuer die ersten beiden Trippel falsch, denn fuer zB 192 wird 11111111 ausgegeben, was ja nciht sein kann und aufgrund der unsigned Bytes entsteht.


----------



## HoaX (24. Mrz 2011)

Welcher Punkt? Schreib doch mal komplette Sätze was nicht geht, mit konkretem Code der genau das zeigt was du da versuchst und nicht geht, und dann am Besten wie ich oben schon sagte ohne Firlefanz der uninteressant ist.
Erst kommt der Test mit statischen Daten zum Testen, und wenn dann das System zu berechnung steht dann kommt das nächste Teilproblem dran und ganz am Ende wird das erst kombiniert. Spart dir viel Kopfzerbrechen weil du dich aufs wesentliche Konzentrieren kannst: Das Problem.

Nachtrag: 


MAGIo hat gesagt.:


> ... nur ist die Berechnung der binaeren Darstellung zumindest fuer die ersten beiden Trippel falsch, denn fuer zB 192 wird 11111111 ausgegeben


Wie berechnet du die?



MAGIo hat gesagt.:


> ... , was ja nciht sein kann und aufgrund der unsigned Bytes entsteht.


Wie kommst du darauf?


Nachtrag2: Komm doch mal in den Chat ...


----------



## MAGIo (24. Mrz 2011)

Also ich schaffe es nicht die Umwandlung der eingegebenen IP Adresse als Bitfolge richtig umzusetzen. Die nachfolgenden Berechnungen und Bestimmungen funktionieren, aber eben getestet anhand falsch umgewandelter Daten. Konkretes Beispiel ist Folgendes:


```
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.net.UnknownHostException;


public class Test {

	/**
	 * @param args
	 * @throws UnknownHostException 
	 */
	public static void main(String[] args) throws UnknownHostException {
	     String start = "192.168.178.1";
         
	     InetAddress address = InetAddress.getByName(start);
         byte[] rawaddress = address.getAddress();
	     
         String binaddress = Integer.toBinaryString((rawaddress[0] << 24 | rawaddress[1] << 16 | rawaddress[2] << 8 | rawaddress[3]));
	System.out.println(binaddress);
	}

}
```


----------



## HoaX (24. Mrz 2011)

Ganz einfach:
* rawaddress[0] ist ein Byte, negativ wie du vorhin schon angemerkt hast (da >127), also solltest du das erstmal in eine positive Zahl umwandeln. (Siehe http://www.java-forum.org/742896-post18.html)
* << ergibt eine negative Zahl, da ja nun das erste Bit gesetzt ist -> größeren Datentyp wählen -> long


```
byte b = (byte) 192;
long l = (long)(b & 0xff);
long x = l << 24;
```

Ergibt dann 11000000.00000000.00000000.00000000


----------



## MAGIo (24. Mrz 2011)

Tut mir leid, danke fuer deine Hilfe. Ich moechte ja nichts vorgekaut haben und waere froh das aus eigener Kraft zu schaffen, doch stehe ich total auf dem Schlauch. Dein Beispiel hab ich natuerlich verstaendlich gecoded, doch reflektiert auf meins ist es mir fast unmoeglich einen fehlerfreien Ablauf hinzukriegen. Ich demonstriere es mal:

Das Beispiel als vollstaendiger Code:

```
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.net.UnknownHostException;


public class Test {


	public static void main(String[] args) throws UnknownHostException {
/*	     String start = "192.168.178.1";
         
	     InetAddress address = InetAddress.getByName(start);
         byte[] rawaddress = address.getAddress();
*/         
     	byte b = (byte) 192;
    	long l = (b & 0xff);
    	long x = l << 24;
         String binaddressb = Long.toBinaryString(b);
         String binaddressl = Long.toBinaryString(l);
         String binaddressx = Long.toBinaryString(x);
	System.out.println(b);//-64
	System.out.println(l);//192
	System.out.println(x);//3221225472
	System.out.println(binaddressb);//1111111111111111111111111111111111111111111111111111111111000000
	System.out.println(binaddressl);//11000000
	System.out.println(binaddressx);//11000000000000000000000000000000
	}

}
```

und nun fuer meinen Fall


```
InetAddress addrend = InetAddress.getByName(end); //Umwandlung der End-Eingabe in IP Adresse addresse
     byte[] rawaddre = ((byte[])addrend.getAddress()); //Umwandlung der Endadresse in Bitoperatoren RAW
     long[] rawaddrelong = (rawaddre[0] & 0xff);
```
...?


----------



## HoaX (25. Mrz 2011)

Dein rawaddrlong ist doch ein Array, also muss es dann heißen:

```
long[] rawaddrelong = { rawaddre[0] & 0xff, rawaddre[1] & 0xff, rawaddre[2] & 0xff, rawaddre[3] & 0xff };
```

Danach brauchst du nurnoch die Longs nurnoch zusammenfügen.


----------



## MAGIo (25. Mrz 2011)

JUHU!! Es klappt, das Problem lag auch an den unverstaendlichen Fehlermeldungen und dann irgednwann der verlorenen Uebersicht. Mit ein bisschen Struktur sieht es doch direkt viel einfachcer aus


----------



## HoaX (25. Mrz 2011)

Dann is ja gut.
Rechnung kommt per Post ...


----------



## MAGIo (25. Mrz 2011)

Es geht noch weiter, aber vorher gehe ich erstmal schematisch (wie eben beigebracht) vor und falls ich nicht weiterkomme mit detaillierter Fehlerbeschreibung und dem Code 

Hoffentlich (NICHT) bis gleich...


----------



## MAGIo (25. Mrz 2011)

Und weiter gehts.... 

Ich moechte den Ablauf fuer mehrere IPs innerhalb einer Range machen, habe nun mehrere Ansaetze. Ich koennte den Binarycode jeweils mit der umgewandelten Binarydarstellung des zusaetzlichen Hosts addieren, dann muesste ich aber die Tests auch mit dem Binarycode machen vorher. 

Daher waere es natuerlich ganz praktisch die Veraenderung der getesteten Adresse schon jeweils vorher zu machen, bevor ueberhaupt die ganzen Umwandlungen und Tests stattfinden und das schoen in einer Schleife verpacken. Ich habe mal ein paar kleine Testdurchlaeufe gecodet, komme aber auf kein Ergebnis so richtig, da ja das IP Adressformat beachtet werden muss (Maximale Anzahl der Hosts im Trippel) usw...


```
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.net.UnknownHostException;


public class Test {


	public static void main(String[] args) throws UnknownHostException {
/*	              
	     InetAddress address = InetAddress.getByName(start);
         byte[] rawaddress = address.getAddress();
         long[] rawaddresslong =  { rawaddress[0] & 0xff, rawaddress[1] & 0xff, rawaddress[2] & 0xff, rawaddress[3] & 0xff };
*/      
		
		String start = "192.168.178.1";
	    InetAddress addrstart = InetAddress.getByName(start); //Umwandlung der Start-Eingabe in IP Adresse addresss
	    
		short i=298;	    
	    byte[] rawaddrs = addrstart.getAddress();  //Umwandlung der Startadresse in Bitoperatoren RAW 
	    long[] rawaddrslong = { rawaddrs[0] & 0xff, rawaddrs[1] & 0xff, rawaddrs[2] & 0xff, rawaddrs[3] & 0xff };
	    String binstart = Long.toBinaryString(rawaddrslong[0] << 24 | rawaddrslong[1] << 16 | rawaddrslong[2] << 8 | rawaddrslong[3]); //Ausgabe der binary Startadresse
	    String binoffset = Long.toBinaryString(i); //Ausgabe der binary Startadresse


     	byte b = (byte) 192;
    	long l = (b & 0xff);
    	long x = l << 24;

         for (i=0; i<=5;i++)
         {
         	long c = l+i;
        	 System.out.println(c);
         }
	System.out.println(l);
	System.out.println(addrstart);
//	System.out.println(addrstart2);
	System.out.println(binstart);//ADDITION DER BIN CLIENTS
	System.out.println(binoffset);
	System.out.println(binstart+binoffset);

	}

}
```


----------



## HoaX (25. Mrz 2011)

Ich versteh nur Bahnhof was du eigentlich machen willst ...


----------



## MAGIo (25. Mrz 2011)

mit den bestimmten Clients einfach nen Ablauf schaffen, dass jede Adresse innerhalb der IP Range durchlaufen wird, also immer ++


----------



## HoaX (25. Mrz 2011)

Und was ist da jetzt das Problem? 

Grad schreibst du, dass du die Adressen zwischen zwei bestimmten Adressen durchlaufen willst (wenn ich dich richtig verstanden habe). Einen Post vorher steht da noch was von Tests ... entscheide dich was du willst, und drück dich klar aus.

Start- und Endadresse als "long" berechnen solltest du ja mitterweile wohl hinbekommen. Was fehlt ist einfach nur nen +1 auf die Startadresse solange diese kleiner als die Endadresse ist.
Ich seh jetzt immer noch nicht wo jetzt dein Problem liegt...


----------



## MAGIo (29. Mrz 2011)

Ja, so ist es logisch. Ich hatte eigentlich gedacht die Differenz auszurechnen und diese jeweilis zu erhoehen, doch da waeren Ausnahmen faellig und es waere ja dohc komplizierter. Ich versuche mal Deinen Tipp. 

Die Tests etc. gingen ja um die Binaerdarstellung der IPs, das laeuft unabhaengig des geposteten und funktioniert. Hab ja einen Testfall geschrieben, damit es einfacher nachzuvollziehen ist


----------



## MAGIo (29. Mrz 2011)

```
for (int i = 0; rawaddrslong<=rawaddrelong;i++)
     {
    	 System.out.println(rawaddrslong+i);
     }
```

So in etwa, nur ohne Fehlermeldungen


----------



## MAGIo (29. Mrz 2011)

Wie soll ich eigentlich die Long Arrays inkrementieren, sodass es allgemein immer passt? Ich kann doch auch mehr als 256 (-2)Clients im Netz haben...


----------



## MAGIo (4. Apr 2011)

Ich stehe aktuell bei folgendem Code, aber zum Funktionieren krieg ich gar nix....


```
int clients = 10;
rawaddrs[clients]++;
int carry = rawaddrs[clients] == 0 ? 1 : 0;
while (clients-- > 0) {
	rawaddrs[clients] += carry;
	carry = carry > 0 && rawaddrs [clients] == 0 ?1 : 0;}
```


----------



## chalkbag (5. Apr 2011)

Ich geb zu, ich hab den Thread nicht mehr genauer verfolgt, vielleicht hat dir wer den Code so gegeben.
Aber bei den Code-Konstrukten halte ich eine zu frühe / zu späte inkrementierung /dekrementierung für durchaus wahrscheinlich.


Aber was heißt denn genau, funktioniert nicht?

[Edit]


```
carry = carry > 0 && rawaddrs [clients] == 0 ?1 : 0;}
```

würde er nicht hier versuchen einen boolean der int Variablen zuzuweisen?


----------



## Andi_CH (5. Apr 2011)

chalkbag hat gesagt.:


> Ich geb zu, ich hab den Thread nicht mehr genauer verfolgt, vielleicht hat dir wer den Code so gegeben.
> Aber bei den Code-Konstrukten halte ich eine zu frühe / zu späte inkrementierung /dekrementierung für durchaus wahrscheinlich.
> 
> 
> ...



Vernünftig geschrieben heisst das:

```
if (carry > 0 && rawaddrs [clients] == 0)
  carry = 1;
else
  carry = 0;
```

Ich sage es zum 100 und ersten mal - die ?: Schreibweise ist erbärmlich zu lesen und gehört verboten.


----------



## HoaX (5. Apr 2011)

Du hattest doch weiter vorne im Thread bereits longs erzeugt welche die 4 Bytes enthalten. Jetzt musst du doch nurnoch vom Einen zum Anderen iterieren und den Long zurück umwandeln ...


```
long start = ...;
long end = ...;

while(start < end) {
    int b1 = (start >> 24) & 0xff;
    int b2 = (start >> 16) & 0xff;
    int b3 = (start >> 8) & 0xff;
    int b4 = start & 0xff;

    System.out.println(String.format("%d.%d.%d.%d", b1,b2,b3,b4));
    start++;
}
```


----------



## MAGIo (5. Apr 2011)

Die ? Schreibweise hatte ich selber nicht verstanden, habe mir naemlich die Sache zusammengebastelt. Wenn der Kaffee wirkt, setze ich mich mal dran und poste mein Ergebnis. Bis spaeter


----------



## Andi_CH (6. Apr 2011)

Brauchst nicht mehr viel zu denken - ich habs ja umgeschrieben ;-)

Ich hol mir jetzt meinen dritten Kaffee von heute.


----------



## MAGIo (6. Apr 2011)

```
byte[] rawaddrs = addrstart.getAddress();  //Umwandlung der Startadresse in Bitoperatoren RAW
		long[] rawaddrslong = { rawaddrs[0] & 0xff, rawaddrs[1] & 0xff, rawaddrs[2] & 0xff, rawaddrs[3] & 0xff };
		byte[] rawaddre = addrend.getAddress();  //Umwandlung der Endadresse in Bitoperatoren RAW 
	    long[] rawaddrelong = { rawaddre[0] & 0xff, rawaddre[1] & 0xff, rawaddre[2] & 0xff, rawaddre[3] & 0xff };
		 

	    while(rawaddrslong < rawaddrelong) 
	    {
	        int b1 = (int) (rawaddrslong[0] >> 24);
	        int b2 = (int) (rawaddrslong[1] >> 16);
	        int b3 = (int) (rawaddrslong[2] >> 8);
	        int b4 = (int) (rawaddrslong[3]);
	     
	        System.out.println(String.format("%d.%d.%d.%d",b1,b2,b3,b4));
	        rawaddrslong[0]++;
	    }
```

Fast... aber bisher nichts ausser Fehlermeldungen


----------



## HoaX (6. Apr 2011)

Wenn man falsch abschreibt, dann kann das schon vorkommen...


----------



## MAGIo (6. Apr 2011)

hab das doch per copy and paste und dn auf meinen fall angewendet... was meinst du genau?


----------



## MAGIo (6. Apr 2011)

ich erzeuge doch long arrays [] mit den einzelnen Bytes



```
public static void main(String[] args) {
		long start = 192;
		long end = 200;
		 
		while(start < end) {
		    int b1 = (start >> 24) & 0xff;
		    int b2 = (start >> 16) & 0xff;
		    int b3 = (start >> 8) & 0xff;
		    int b4 = start & 0xff;
		 
		    System.out.println(String.format("%d.%d.%d.%d", b1,b2,b3,b4));
		    start++;
		}

	}
```

Ich habe das parse auf int weggemacht, nur so wie hier beschrieben funktioniert es einfach nicht! 

String.format ist fuer diese Variante nicht ausfuehrbar und bei den jeweiligen variablen kann er nicht von long auf int


----------



## HoaX (6. Apr 2011)

Übernimm doch mal den Teil hier http://www.java-forum.org/742911-post23.html in dein eben gepostetes Beispiel und staune!


----------



## MAGIo (6. Apr 2011)

Exception in thread "main" java.lang.Error: Unresolved compilation problems: 
	Type mismatch: cannot convert from long to int
	Type mismatch: cannot convert from long to int
	Type mismatch: cannot convert from long to int
	Type mismatch: cannot convert from long to int
	The method format(String, Object[]) in the type String is not applicable for the arguments (String, int, int, int, int)

	at TestIncrement.main(TestIncrement.java:12)


----------



## HoaX (6. Apr 2011)

Die ersten vier bekommst du durch etwas nachdenken weg. Hatte ich nur in der Groovyshell getestet ...
Der letzte tritt mit Java6 nicht auf, fass die int-Parameter einfach in ein Array zusammen.


----------



## MAGIo (6. Apr 2011)

```
public class TestIncrement {

	/**
	 * @param args
	 */
    public static void main(String[] args) {
        long startAdresse = 192 << 24 | 168 << 16 | 2 << 8 | 0;
        long endAdresse = 192 << 24 | 168 << 16 | 2 << 8 | 255;
        
        
        
        while(startAdresse < endAdresse) {
            int b1 = (startAdresse >> 24) & 0xff;
            int b2 = (startAdresse >> 16) & 0xff;
            int b3 = (startAdresse >> 8) & 0xff;
            int b4 = startAdresse & 0xff;
         
            System.out.println(String.format("%d.%d.%d.%d", b1,b2,b3,b4));
            startAdresse++;
        }
	}
}
```

Hier der komplette Code mit meinen bisherigen Fehlern.


----------



## HoaX (6. Apr 2011)

Da fehlen mir echt die Worte ... viel Spaß noch.


----------

