Regardons d'abord l'exemple de code :
Copiez le code comme suit :
classe
{
privatestaticlongiptolong(stringstrip)
//Convertit l'adresse IP sous la forme 127.0.0.1 en un entier décimal Aucune gestion des erreurs n'est effectuée ici.
{
intj=0;
inti=0;
long[]ip=newlong[4];
intposition1=strip.indexof(".");
intposition2=strip.indexof(".",position1+1);
intposition3=strip.indexof(".",position2+1);
ip[0]=long.parselong(strip.substring(0,position1));
ip[1]=long.parselong(strip.substring(position1+1,position2));
ip[2]=long.parselong(strip.substring(position2+1,position3));
ip[3]=long.parselong(strip.substring(position3+1));
retour(ip[0]<<24)+(ip[1]<<16)+(ip[2]<<8)+ip[3];//ip1*256*256*256+ip2*256* 256+ip3*256+ip4
}
chaîne statique privéelongtoip(longlongip)
//Convertissez la forme entière décimale en une adresse IP sous la forme 127.0.0.1, saisissez ping3396362403l à l'invite de commande
{
stringbuffersb=newstringbuffer("");
sb.append(string.valueof(longip>>>24));//Décalage direct de 24 bits vers la droite
sb.append(".");
sb.append(string.valueof((longip&0x00ffffff)>>>>16));//Définissez les 8 bits supérieurs sur 0, puis décalez vers la droite de 16 bits
sb.append(".");
sb.append(string.valueof((longip&0x0000ffff)>>>>8));
sb.append(".");
sb.append(string.valueof(longip&0x000000ff));
sb.append(".");
renvoieb.tostring();
}
publicstaticvoidmain(string[]args)
{
system.out.println("Diverses expressions de l'adresse IP : rn");
system.out.print("Forme binaire 32 bits : ");
system.out.println(long.tobinarystring(3396362403l));
system.out.print("Forme décimale :");
system.out.println(iptolong("202.112.96.163"));
system.out.print("Formulaire commun :");
system.out.println(longtoip(3396362403l));
}
}
Résultats en cours d'exécution :
Diverses manifestations des adresses IP :
Forme binaire 32 bits : 11001010011100000110000010100011
Forme décimale : 3396362403
Formulaire commun : 202.112.96.163.
Sortie terminée (prend 1 seconde) - terminaison normale. Analysons les points de connaissance étape par étape : un nombre binaire, décalé vers la gauche de n bits, consiste à multiplier la valeur du nombre par 2 élevée à la puissance n et à diviser par deux, c'est-à-dire décaler d'une position vers la droite
1. Convertir l'adresse IP en entier <BR>Principe : Chaque segment d'adresse IP peut être considéré comme un entier non signé de 8 bits, c'est-à-dire 0-255. Divisez chaque segment en une forme binaire et combinez-le, puis convertissez-le. le nombre binaire dans un Unsigned 32 est un entier.
Exemple : Une adresse IP est 10.0.3.193
Le nombre binaire correspondant à chaque segment de nombres
1000001010
000000000
300000011
19311000001
La combinaison est la suivante : 00001010000000000000001111000001. Une fois converti en décimal, il s'agit de : 167773121, c'est-à-dire le numéro converti de l'adresse IP.
Le code est le suivant
Copiez le code comme suit :
publicclassIp{
publicstaticvoidmain(String[]args){
System.out.print(ip2int("10.0.3.193"));
}
publicstaticlongip2int(Stringip){
String[]items=ip.split(".");
returnLong.valueOf(items[0])<<24
|Long.valueOf(éléments[1])<<16
|Long.valueOf(éléments[2])<<8
|Long.valueOf(éléments[3]);
}
}
2. Convertir un entier en adresse IP <BR>Principe : Convertir cet entier en un nombre binaire de 32 bits. De gauche à droite, divisez tous les 8 bits pour obtenir 4 segments de nombres binaires de 8 bits. Convertissez ces nombres binaires en entiers et ajoutez "." Exemple : 167773121.
La représentation binaire est : 00001010000000000000001111000001
Divisez-le en quatre segments : 00001010, 00001010, 00000011, 11000001. Après les avoir convertis en entiers et ajouté ".", vous obtenez 10.0.3.193.
Le code est le suivant
Copiez le code comme suit :
publicclassIp{
publicstaticvoidmain(String[]args){
System.out.print(int2ip(167773121));
}
publicstaticStringint2ip(longipInt){
StringBuildersb=newStringBuilder();
sb.append(ipInt&0xFF).append(".");
sb.append((ipInt>>8)&0xFF).append(".");
sb.append((ipInt>>16)&0xFF).append(".");
sb.append((ipInt>>24)&0xFF);
renvoieb.toString();
}
}
