Netzwerk in Java - IP-Adressen

public class VerifierAddress {

 static boolean isCorrect(String adr){
 String[] parts = adr.split("\\."); 
 //Der Bereich einer Zahl liegt zwischen 0 und 255
 for(int i = 0 ; i < 4; i++){
 //In Ganzzahl konvertieren und 
 if(new Integer(parts[i])< 0 || new Integer(parts[i])> 255)
 //retroune false
 return false; 
 }
 //gibt standardmäßig true zurück 
 return true; 
 }
 
 public static void main(String[] args) {
 String adr= "192.168.1.3"; 
 System.out.println("adr+" ist "+isCorrect(adr)); 
 }
}

import java.math.BigInteger; 
import java.net.InetAddress; 
import java.net.SocketException; 
import java.net.UnknownHostException; 

/*************************************
 * @author www.codeurjava.com
 * Alle Rechte vorbehalten
 */

public class Adressierung {
 
 public static void main(String[] zero) wirft SocketException {
 
 String address = "192.168.1.199/10"; 
 String[] parts = address.split("/"); 
 Zeichenkette ip = Teile[0]; 
 int-Präfix; 
 if (parts.length < 2) {
 prefix = 0; 
 } else {
 prefix = Integer.parseInt(parts[1]); 
 }
 System.out.println("Adresse =\t" + ip+"\nPräfix =\t" + Präfix); 
 
 //Konvertieren der gesamten Maske in ein 32-Bit-Array
 int mask = 0xffffffff < < (32 - Präfix); 
 int Wert = Maske; 
 byte[] bytes_masque = new byte[]{
 (byte)(Wert > > > 24), (Byte)(Wert > > 16 & 0xff), (Byte)(Wert > > 8 & 0xff), (Byte)(Wert & 0xff) }; 

 try {
 //masque
 InetAddress netAddr = InetAddress.getByAddress(bytes_masque); 
 System.out.println("Mask =\t" + netAddr.getHostAddress()); 
 
 /*************************
 * Netzwerkadresse
 */
 //IP-Adresse in long
 long ipl = ipToLong(ip); 
 
 //IP in ein 32bits
 byte[] Array konvertieren bytes_ip = new byte[]{
 (byte) ((ipl > > 24) & 0xFF),
 (Byte) ((IPL-> > 16) & 0xFF),
 (Byte) ((IPL-> > 8 ) & 0xFF),
 (Byte) (IPL & 0xFF)}; 
 
 //Die logische ET zwischen der IP-Adresse und der Maske
 byte[] bytes_reseau = new byte[]{
 (byte) (bytes_ip[0] & bytes_masque[0]),
 (byte) (bytes_ip[1] & bytes_masque[1]),
 (byte) (bytes_ip[2] & bytes_masque[2]), 
 (Byte) (bytes_ip[3] & bytes_masque[3]),
 }; 
 //erhaltene Netzwerkadresse
 InetAddress adr_reseau = InetAddress.getByAddress(bytes_reseau); 
 System.out.println("Netzwerkadresse =\t"+adr_reseau.getHostAddress()); 
 
 /********************************
 *Broadcast-Adresse 
 */
 //Netzwerkadresse - invertierte Maske ~val & 0xff
 //invert mask
 bytes_masque = new byte[]{
 (byte) (~bytes_masque[0] & 0xff),
 (byte) (~bytes_masque[1] & 0xff),
 (byte) (~bytes_masque[2] & 0xff),
 (byte) (~bytes_masque[3] & 0xff),
 }; 
 System.out.println("Platzhaltermaske) =\t"+InetAddress.getByAddress(bytes_masque).getHostAddress()); 
 
 byte[] bytes_broadcast = new byte[]{
 (byte) (bytes_reseau[0] | bytes_masque[0]),
 (byte) (bytes_reseau[1] | bytes_masque[1]),
 (byte) (bytes_reseau[2] | bytes_masque[2]),
 (byte) (bytes_reseau[3] | bytes_masque[3]),
 }; 
 //Broadcast-Adresse erhalten
 InetAddress adrbroadcast = InetAddress.getByAddress(bytes_broadcast); 
 System.out.println("Broadcast-Adresse =\t"+adrbroadcast.getHostAddress()); 
 
 } catch (UnknownHostException e) {
 e.printStackTrace(); 
 }
 }

 public static long ipToLong(String ipAddress) { 
 long result = 0; 
 String[] ipAddressInArray = ipAddress.split("\\."); 

 for (int i = 3; i >= 0; i--) {
 long ip = Long.parseLong(ipAddressInArray[3 - i]); 
 Ergebnis |= IP < < (i*8); 
 }
 Ergebnis zurückgeben; 
 }
}

import java.net.InetAddress; 
import java.net.SocketException; 
import java.net.UnknownHostException; 

public class ServerAddress {
 
 public static void main(String[] zero) throws SocketException {
 
 String LocaleAddress; 
 InetAddress ServerAddress; 

 try{
 //Local Address
 LocaleAdresse = (Zeichenfolge) InetAddress.getLocalHost().getHostAddress(); 
 System.out.println("Die lokale Adresse = "+LocaleAddress); 
 
 //Serveradresse google
 ServerAddress= InetAddress.getByName("www.google.net"); 
 System.out.println("Google-Serveradresse = "+Serveradresse); 
 } catch (UnknownHostException e) {
 e.printStackTrace(); 
 }
 }
}