Оболочки*

Теоретический блок

Вам нужно просто прочитать его. Команды выполнять не требуется.

В java только восемь примитивных типов не реализованы с помощью классов. Они оставлены в Java потому что арифметические действия удобнее и быстрее производить с обычными числами, а не с объектами классов.

Но и для этих типов в языке Java есть соответствующие классы-оболочки (wrappers). Конечно, они предназначены не для быстрых вычислений, а для действий, типичных при работе с классами - создания объектов, преобразования объектов, получения численных значений в разных формах и передачи объектов в методы по ссылке.

Для каждого примитивного типа есть соответствующий класс. Числовые классы имеют общего предка - абстрактный класс Number, в котором описаны шесть методов, возвращающих числовое значение, содержащееся в классе, приведенное к соответствующему примитивному типу: bytevalue(), doubievalue(), floatValue(), intValue(), longValue(), shortValue(). Эти методы переопределены в каждом из шести числовых классов-оболочек.

Помимо метода сравнения объектов equals(), объявленного в классе Object, все описанные в этой главе классы, кроме Boolean и Class, имеют метод compareTo(), сравнивающий числовое значение, содержащееся в данном объекте, с числовым значением объекта - аргумента метода compareTo(). В результате работы метода получается целое значение:

• 0, если значения равны;
• отрицательное число (-1), если числовое значение в данном объекте меньше, чем в объекте-аргументе;
• положительное число (+1), если числовое значение в данном объекте больше числового значения, содержащегося в аргументе.

Числовые классы-оболочки

В каждом из шести числовых классов-оболочек есть статические методы преобразования строки, содержащей число, в соответствующий примитивный тип: Byte.parseByte(), Double.parseDouble(), Float.parseFloat(), Integer.parselnt(), Long.parseLong(), Short.parseShort(). Эти методы полезны при вводе данных в поля ввода, обработке параметров командной строки, т. е. всюду, где числа представляются строками цифр со знаками плюс или минус и десятичной точкой. В каждом из этих классов есть статические константы MAX_VALUE и MIN_VALUE, показывающие диапазон числовых значений соответствующих примитивных типов. В классах Double и Float есть еще константы POSITIVE_INFINITY, NEGATIVE_INFINITY, NaN, которые соответствуют плюс бесконечности, минус бесконечности и NaN(Not a number), а также и логические методы проверки isNan(), isInfinite().

Статическими методами toBinaryString(), toHexString() и toOctalString() классов Integer и `Long можно преобразовать целые значения типов int и long, заданные как аргумент метода, в строку символов, показывающую двоичное, шестнадцатеричное или восьмеричное представление числа.

Пример использования:

public class Main {
    public static void main(String[] args) {
        int i = 0;
        short sh = 0;
        double d = 0;

        Integer kl = 55;
        Integer k2 = 100;
        Double dl = 3.14;

        try {
            i = Integer.parseInt(args[0]);
            sh = Short.parseShort(args[0]);
            d = Double.parseDouble(args[1]);
            dl = new Double(args[1]);
            kl = new Integer(args[0]);
        } catch (Exception e) {

        }

        double x = 1.0 / 0.0;
        System.out.println("i = " + i);
        System.out.println("sh - " + sh);
        System.out.println("d. = " + d);
        System.out.println("kl.intValue() = " + kl.intValue());
        System.out.println("dl.intValue() = " + dl.intValue());
        System.out.println("kl > k2? " + kl.compareTo(k2));
        System.out.println("x = " + x);
        System.out.println("x isNaN? " + Double.isNaN(x));
        System.out.println("x islnfinite? " + Double.isInfinite(x));
        System.out.println("x == Infinity? " +
                (x == Double.POSITIVE_INFINITY));
        System.out.println("d = " + Double.doubleToLongBits(d));
        System.out.println("i = " + Integer.toBinaryString(i));
        System.out.println("i = " + Integer.toHexString(i));
        System.out.println("i = " + Integer.toOctalString(i));
    }
}

На консоль будет выведено:

i = 0
sh - 0
d. = 0.0
kl.intValue() = 55
dl.intValue() = 3
kl > k2? -1
x = Infinity
x isNaN? false
x islnfinite? true
x == Infinity? true
d = 0
i = 0
i = 0
i = 0

Методы parseInt(), parseDouble() и т.д., а также конструкторы классов от строкового аргумента требуют обработки исключений, поэтому в листинг вставлен блок try{} catch(){}. Пока что о них говорить не будем, просто нужно запомнить, какие строки нужно добавить до вызова метода и после.

Класс Boolean

Это очень небольшой класс, предназначенный главным образом для того, чтобы передавать логические значения в методы по ссылке. Конструктор Boolean (String s)`` создает объект, содержащий значение true`, если строка s равна "true" в любом сочетании регистров букв, и значение false - для любой другой строки. Логический метод booleanValue() возвращает логическое значение, хранящееся в объекте.

Класс Character

В этом классе собраны статические константы и методы для работы с отдельными символами. Статический метод digit(char ch, in radix)`` переводит цифру chсистемы счисления с основаниемradix в ее числовое значение типаint. Статический метод forDigit(int digit, int radix)производит обратное преобразование целого числаdigitв соответствующую цифру (тип char) в системе счисления с основаниемradix. Основание системы счисления должно находиться в диапазоне от Character.MIN_RADIXдо Character.MAX_RADIX`.

Статические методы toLowerCase(), `toUppercase()`` – переводят символ в нижний и верхний регистр соответственно.

Множество статических логических методов проверяют различные характеристики символа, переданного в качестве аргумента метода:

isDigit() - проверяет, является ли символ цифрой; isLetter() - проверяет, является ли символ буквой; isLetterOrDigit() - Проверяет, является ли символ буквой или цифрой; isLowerCase() - определяет, записан ли символ в нижнем регистре; isUpperCase() - проверяет, записан ли символ в верхнем регистре;

public class Main {
    public static void main(String[] args) {

        Character c1 = '9';

        System.out.println("cl.charValue() = " + c1.charValue());
        System.out.println("number of 'A' = " + Character.digit('A', 16));
        System.out.println("digit for 12 = " + Character.forDigit(12, 16));

        System.out.println("cl = " + c1.toString());
        System.out.println("ch isDigit? " + Character.isDigit(c1));

    }
}

На консоль будет выведено:

cl.charValue() = 9
number of 'A' = 10
digit for 12 = c
cl = 9
ch isDigit? True

Классы BigInteger, BigDecimal

Все примитивные целые типы имеют ограниченный диапазон значений. Для того чтобы было можно производить целочисленные вычисления любого размера, в java есть два класса: BigInteger и BigDecimal. Эти классы расширяют класс Number, следовательно, в нем переопределены методы doubleValue(), floatValue(), intValue(), longValue(). Методы byteValue() и shortValue() не переопределены, а прямо наследуются от класса Number.

Действия с объектами классов BigInteger и BigDecimal не приводят ни к переполнению. Если результат операции велик, то число разрядов просто увеличивается. Числа хранятся в двоичной форме с дополнительным кодом. Перед выполнением операции числа выравниваются по длине распространением знакового разряда. Две константы - ZERO и ONE - содержат ноль и единицу.

Метод toByteArray() преобразует объект в массив байтов. Эти классы соответствуют неизменяемым(immutable) объектам, как строки. Поэтому все операции создают новые объекты, не изменяя тот, от которого они были вызваны.

• abs() - возвращает объект, содержащий абсолютное значение числа, хранящегося в данном объекте this;
• add(x) - операция this + х;
• and(x) - операция this & х;
• andNot(x) - операция this & (~х) ;
• divide (x) - операция this / х;
• divideAndRemainder(х) - возвращает массив из двух объектов класса Biglnteger, содержащих частное и остаток от деления this на х;
• gcd(x) - наибольший общий делитель, абсолютных, значений объекта this и аргумента х;
• mах(х) - наибольшее из значений объекта this и аргумента х; min(x) - наименьшее из значений объекта this и аргумента х; mod(x) - остаток от деления объекта this на аргумент метода х;
• modinverse(x) - остаток от деления числа, обратного объекту this, на аргумент х;
• multiply(х) - операция this * х;
• negate() - перемена знака числа, хранящегося в объекте;
• not() - операция ~this;
• оr(х) - операция this | х;
• pow(n) - операция возведения числа, хранящегося в объекте, в степень n;
• remainder(х) - операция this % х;
• shiftLeft(n) - операция this « n ;
• shiftRight(n) - операция this » n;
• signum() - функция sign (x);
• subtract(x) - операция this - x;
• xor(x) - операция this ^ x.

Пример использования:

public class Main {
    public static void main(String[] args) {
        BigInteger a = new BigInteger("99999999999999999");
        BigInteger b = new BigInteger("88888888888888888888");
        System.out.println("bits in a = " + a.bitLength());
        System.out.println("bits in b = " + b.bitLength());
        System.out.println("a + b = " + a.add(b));
        System.out.println("a & b = " + a.and(b));
        System.out.println("a & ~b = " + a.andNot(b));
        System.out.println("a / b = " + a.divide(b));
        BigInteger[] r = a.divideAndRemainder(b);
        System.out.println("a / b: q = " + r[0] + ", r = " + r[1]);
        System.out.println("gcd(a, b) = " + a.gcd(b));
        System.out.println("max(a, b) = " + a.max(b));
        System.out.println("min(a, b) = " + a.min(b));
        System.out.println("a mod b = " + a.mod(b));
        System.out.println("a * b = " + a.multiply(b));
        System.out.println("-a = " + a.negate());
        System.out.println("~a = " + a.not());
        System.out.println("a | b = " + a.or(b));
        System.out.println("а ^ 3 = " + a.pow(3));
        System.out.println("a % b = " + a.remainder(b));
        System.out.println("a « 3 = " + a.shiftLeft(3));
        System.out.println("a » 3 = " + a.shiftRight(3));
        System.out.println("sign(a) = " + a.signum());
        System.out.println("a - b = " + a.subtract(b));
        System.out.println("а xor b = " + a.xor(b));
    }
}

На консоль будет выведено:

bits in a = 57
bits in b = 67
a + b = 88988888888888888887
a & b = 72133975954525752
a & ~b = 27866024045474247
a / b = 0
a / b: q = 0, r = 99999999999999999
gcd(a, b) = 1
max(a, b) = 88888888888888888888
min(a, b) = 99999999999999999
a mod b = 99999999999999999
va * b = 8888888888888888799911111111111111112
-a = -99999999999999999
~a = -100000000000000000
a | b = 88916754912934363135
а ^ 3 = 999999999999999970000000000000000299999999999999999
a % b = 99999999999999999
a « 3 = 799999999999999992
a » 3 = 12499999999999999
sign(a) = 1
a - b = -88788888888888888889
а xor b = 88844620936979837383