Réseau en Java - Les adresses IP

public class VerifierAdresse {

 static boolean estCorrecte(String adr){
 String[] parties = adr.split("\\.");
 //La plage d'un nombre est entre 0 et 255
 for(int i = 0 ; i < 4; i++){
 //Convertir en entier et tester 
 if(new Integer(parties[i])<0 || new Integer(parties[i])>255)
 //retroune false
 return false;
 }
 //retourne true par défaut 
 return true;
 }
 
 public static void main(String[] args) {
 String adr= "192.168.1.3";
 System.out.println("adr+" est "+estCorrecte(adr));
 }
}

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

/*************************************
 * @author www.codeurjava.com
 * Tous droits réservés
 */

public class Adressage {
 
 public static void main(String[] zero) throws SocketException {
 
 String adresse = "192.168.1.199/10";
 String[] parties = adresse.split("/");
 String ip = parties[0];
 int prefixe;
 if (parties.length < 2) {
 prefixe = 0;
 } else {
 prefixe = Integer.parseInt(parties[1]);
 }
 System.out.println("Addresse =\t" + ip+"\nPrefixe =\t" + prefixe);
 
 //convertir le masque entier en un tableau de 32bits
 int masque = 0xffffffff << (32 - prefixe);
 int valeur = masque;
 byte[] bytes_masque = new byte[]{
 (byte)(valeur >>> 24), (byte)(valeur >> 16 & 0xff), (byte)(valeur >> 8 & 0xff), (byte)(valeur & 0xff) };

 try {
 //masque
 InetAddress netAddr = InetAddress.getByAddress(bytes_masque);
 System.out.println("Masque =\t" + netAddr.getHostAddress());
 
 /*************************
 * Adresse réseau
 */
 //Convertir l'adresse IP en long
 long ipl = ipToLong(ip);
 
 //Convertir l'IP en un tableau de 32bits
 byte[] bytes_ip = new byte[]{
 (byte) ((ipl >> 24) & 0xFF),
 (byte) ((ipl >> 16) & 0xFF),
 (byte) ((ipl >> 8 ) & 0xFF),
 (byte) (ipl & 0xFF)};
 
 //Le ET logique entre l'adresse IP et le masque
 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]),
 };
 //adresse réseau obtenue
 InetAddress adr_reseau = InetAddress.getByAddress(bytes_reseau);
 System.out.println("Adresse réseau =\t"+adr_reseau.getHostAddress());
 
 /********************************
 *Adresse de diffusion broadcast 
 */
 //adresse réseau - masque inversé ~val & 0xff
 //inverser le masque
 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("Masque inverse (Wildcard) =\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]),
 };
 //adresse Broadcast obtenue
 InetAddress adrbroadcast = InetAddress.getByAddress(bytes_broadcast);
 System.out.println("Adresse de diffusion (Broadcast) =\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]);
 result |= ip << (i * 8);
 }
 return result;
 }
}

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

public class AdresseServeur {
 
 public static void main(String[] zero) throws SocketException {
 
 String LocaleAdresse ;
 InetAddress ServeurAdresse;

 try{
 //Adresse locale
 LocaleAdresse = (String) InetAddress.getLocalHost().getHostAddress();
 System.out.println("L'adresse locale = "+LocaleAdresse );
 
 //Adresse du serveur google
 ServeurAdresse= InetAddress.getByName("www.google.net");
 System.out.println("L'adresse du serveur Google = "+ServeurAdresse);
 } catch (UnknownHostException e) {
 e.printStackTrace();
 }
 }
}