Integer Sınıfı

MAX_VALUE alanı
Şöyle yaparız.

int max=Integer.MAX_VALUE;

MIN_VALUE alanı
Şöyle yaparız.

int min=Integer.MIN_VALUE;

divideUnsigned metodu

Açıklaması şöyle

The divideUnsigned() method is a method from the Integer class that allows you to divide two numbers and return an unsigned quotient.

Unsigned integers, in comparison to the regular signed integers, can only represent positive numbers. Both unsigned and signed integers have the same number of numbers in their range (the range size is both 65 536 numbers).

However, since unsigned integers cannot be negative, their maximum value in the positive range is much higher than the maximum value for a regular signed integer.

To simplify this, we can instead look at an example of a signed and unsigned byte. Bytes have a range of 256 numbers. A regular byte can be from -128 to 127. However, an unsigned byte can go from 0 all the way to 255.

Other than that, the function works exactly like regular division.

Örnek

Şöyle yaparız

int dividend = 10;
int divisor = 5;
int quotient = Integer.divideUnsigned(dividend, divisor);
System.out.println(quotient);
// Output: 2

getInteger metodu

System.getProperty() ile sadece String okunabilir. Integer bir değer okumak mümkün

Örnek

Şöyle yaparız

int calculatePartBufferSize() {
  int partSize = 0;
  try {
    partSize = Integer.getInteger("jobupload.partsize", 10_000_000);
  } catch (Exception ignored) {
  }
  return partSize;
}

operator == metodu - Object + primitive

Açıklaması şöyle. Yani Object ve primitive == ile karşılaştırılınca reference karşılaştırması değil değer karşılaştırması yapılır.

If r is a reference of type Integer, then unboxing conversion converts r into r.intValue()

Örnek
Elimizde şöyle bir kod olsun.

Integer a = new Integer(10);    
Integer b = 10; 
int c=10;
System.out.println(b==c);       //true
System.out.println(a==c);       //true

Bu kod aslında unboxin ile şu koda çevrilir.

a.intValue() == c

operator >= metodu

Şöyle yaparız. Sarmalanan değer unboxing işlemine uğrar.

Integer a=150;
Integer b=150;
System.out.println(a>=b); // returns true

parseInt metodu - string
Örnek
Şöyle yaparız.

String str = "...";
int  value = Integer.parseInt (str)

Örnek - scientific notation
Elimizde şöyle bir string olsun. Bu metod scientific notation ile gösterilen bir sayıyı parse edemez. Exception fırlatır.

String value = 4.30000000e+01;

parseInt metodu - string + radix
Şu durumlarda exception fırlatır.

if string cannot be parsed as an integer value, or radix < Character.MIN_RADIX || radix > Character.MAX_RADIX.

Radix'in belli bir aralıkta olması gerekir. Ayrıca string ile verilen sayının Integer.MIN_VALU ve Interger.MAX_VALUE aralığında olması gerekir.

Örnek - 2'lik taban
Şöyle yaparız.

int a = Integer.parseInt("11010100", 2);

Örnek - 16'lık taban
Şöyle yaparız.

System.out.println(Integer.parseInt("ff",16));

reverse metodu
Bitlerin yerini sırasını değiştirir. MSB bit LSB bit haline gelir.
Bu işlem sonucunda şöyle olur

ilk hali   : 00000000 00000000 00000000 00000111
reverse : 11100000 00000000 00000000 00000000

reverseBytes metodu
Şöyle yaparız.

int t = ...;
t = Integer.reverseBytes (t);

signum metodu
Açıklaması şöyle. Math.signum() ile aynıdır.

Returns the signum function of the specified int value. (The return value is -1 if the specified value is negative; 0 if the specified value is zero; and 1 if the specified value is positive.)

toBinaryString metodu
Şöyle yaparız.

int n = 100;
String str = Integer.toBinaryString (n);

toHexString metodu
Bu metod baştaki 0 karakterini siliyor. O yüzden her zaman buna dikkat etmek lazım.. Aynı problem BigInteger.toString() metodunda da var.

public static String bytesToHex(byte[] digest) {
  StringBuilder hexString = new StringBuilder(2 * digest.length);
  for (byte b : digest) {
    String hex = Integer.toHexString(0xff & b);
    if (hex.length() == 1) {
      hexString.append('0');
    }
    hexString.append(hex);
  }
  return hexString.toString();
}

Örnek

Şöyle yaparız.

int a = ...;
System.out.println(Integer.toHexString(a));

toString metodu - int + radix
Açıklaması şöyle.

Converting a number into a string is very similar to the division algorithm, but has more overhead because it has to create a string.

Aslında algoritma şuna benziyor. Yani bir bölme işlemi var.

int digits = 0;
while(x > 0) {
  digits ++;
  x /= 10;
}

Metodun içi şöyledir. Girdiyi önce daha buyuk bir set olan eksi sayıya çevirir. Daha sonra bir buffer 'a sağdan - yani sondan -  başlayarak radix ile mod'unu alarak yazar.

public static String toString(long i, int radix) {
  if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
    radix = 10;
  if (radix == 10)
    return toString(i);
  char[] buf = new char[65];
  int charPos = 64;
  boolean negative = (i < 0);

  if (!negative) {
    i = -i;
  }

  while (i <= -radix) {
    buf[charPos--] = Integer.digits[(int)(-(i % radix))];
    i = i / radix;
  }
  buf[charPos] = Integer.digits[(int)(-i)];

  if (negative) {
    buf[--charPos] = '-';
  }

  return new String(buf, charPos, (65 - charPos));
}

valueOf metodu
İmzası şöyle.

public static Integer valueOf(int i);

Integer.valueOf () metodu -128 ile 127 arasındaki değerleri içinde sakladığı önbellekten yaratır. Açıklaması şöyle

Basically, the Integer class keeps a cache of Integer instances in the range of -128 to 127, and all autoboxing, literals and uses of Integer.valueOf() will return instances from that cache for the range it covers.

Diğer sınıfların da bu isimli metodları var. Bunlar şöyle.

Integer.valueOf(int)
Double.valueOf(double)
Float.valueOf(float)