Начинающий Java-вопрос о Integer.parseInt() и кастинге

Integer.parseInt не делает то же самое, что и приведение типов.

Давайте посмотрим на ваш первый пример:

int randomNumber=(int) (Math.random()*5)

Math.random возвращает двойное число, и когда вы умножаете двойное число на целое число, Java считает результат двойным. Таким образом, выражение Math.random()*5 имеет тип double. То, что вы пытаетесь сделать, это присвоить это значение переменной типа int. По умолчанию Java не позволит вам присвоить двойное значение переменной типа int, если вы явно не сообщите компилятору, что это нормально. По сути, вы можете думать о приведении типа double к типу int как о сообщении компилятору: «Я знаю, что эта переменная типа int не может содержать десятичную часть этого значения типа double, но это нормально, просто усеките ее».

Теперь взгляните на преобразование String в int:

int value = Integer.parseInt("5");

Строка «5» не может быть немедленно преобразована в целое число. В отличие от double, которые по определению могут быть преобразованы в целое число путем отбрасывания десятичной части, String нельзя легко или последовательно преобразовать в int. «5», «042» и «1000» имеют целочисленное представление, но что-то вроде «Hello, World!» не. Из-за этого нет функции языка первого порядка для преобразования String в int. Вместо этого вы используете метод для анализа строки и возврата значения.

Итак, чтобы ответить на все ваши вопросы:

Почему два разных способа сделать значение int ?

Вы должны принять во внимание тип значения, которое вы конвертируете. Если вы конвертируете примитив в int, вы можете использовать приведение, если вы конвертируете объект, вам нужно будет использовать какой-то метод преобразования, специфичный для этого типа.

Также я сделал поиск, и он говорит, что parseInt() принимает строку в качестве аргумента. Значит ли это, что parseInt() ТОЛЬКО для преобразования строки в целое число?

Правильный. Вы не можете передать какой-либо другой тип в метод parseInt, иначе вы получите ошибку компилятора.

А как насчет этого кастинга тогда (инт) ?? Можем ли мы также использовать это для преобразования строки в int?

Нет, приведение к типу int будет работать только для примитивных значений, а в Java String не является примитивом.

В вашем примере вы переводите число с плавающей запятой в int. Однако Integer.parseInt() считывает целочисленное значение из строки.

Вы можете использовать только совместимые типы (я бы дал ссылку на JLS, но это может быть слишком много для вопроса новичка).

Приведение в основном просто берет значение и говорит: «Эй, эта штука, которая была двойной? Теперь это целое число. Итак».

Вы не можете сделать это со строкой, потому что она не похожа на int. Вместо этого вам нужно разобрать из него целое число, что на самом деле намного сложнее, чем кажется. К счастью, он уже реализован для вас, поэтому вам не нужно беспокоиться о том, как он работает.

Приведение может только преобразовать из одного числового типа в другой. Интерпретация строки (также известная как синтаксический анализ) должна выполняться с помощью вызова метода.

Начнем сверху.

int randomNumber=(int) (Math.random()*5);

Да, это действительно дает случайное целое число от 0 до 4, но это не совсем правильный способ сделать это. Видите ли, если вы забудете скобку, т.е. наберете

int notSoRandomNumber=(int) Math.random()*5;

вы всегда получите 0, потому что кастинг имеет более высокий приоритет, чем умножение. То есть результат Math.random() сначала преобразуется в целое число, которое всегда будет равно 0, а затем умножается на 5, что по-прежнему равно 0.

Я бы предпочел использовать java.util.Random для генерации случайных целых чисел. q.v. http://java.sun.com/javase/6/docs/api/java/util/Random.html#nextInt(int).

Кастинг может выполняться только между «совместимыми типами». Для примитивных типов и их оболочек (например, int, Integer, long, Long и т. д.) вы можете всегда выполнять приведение между ними с оговоркой, что при некоторых преобразованиях теряется информация. например при преобразовании длинного значения в целое число может содержать число больше, чем Integer.MAX_VALUE]. Этот тип приведения Java в основном получил от C++, который, в свою очередь, получил от C.

Что касается кастинга объектов, то тут все проще. Просто спросите: «Этот объект, о, X?» Если это так, то (X) o имеет смысл и имеет статический тип X. Если o не является X, и вы все равно попытаетесь выполнить приведение, вы получите исключение ClassCastException, означающее, что динамический тип o (во время выполнения) несовместим с X. возможно, это будет иметь больше смысла позже, когда вы поймете разницу между статическим и динамическим (во время выполнения) типом объектов.

Следующий код преобразует String в int без каких-либо методов

public class MyStringToNumber {

    public static int convert_String_To_Number(String numStr){

        char ch[] = numStr.toCharArray();
        int sum = 0;
        //get ascii value for zero
        int zeroAscii = (int)'0'; // '0'=48 zeroAscii=48
        for(int i=0;i<ch.length;i++){
            int tmpAscii = (int)ch[i]; // for 0  ch[i]=3,3=51, tempAscii=51
                                       //         (0*10)+(51-48)
                                       //         0     +3
                                       //         3
                                       //      sum=3
                                       // for 1  ch[i]=2,2=50, tempAscii=50            
            sum = (sum*10)+(tmpAscii-zeroAscii);  // 0 +(51-48)=3 sum=3
                                                  // (3*10)=30+(50-48)
                                                  //           30  +  2
                                                  //   sum=32
                                       // for 2  ch[i]=5, 5=53 tempAscii=53
                                       //         (32*10)+(53-48)
                                       //          320   + 5
                                       //          325     
                                       //  sum=325
                                      // for 3   ch[i]=6,6=54, tempAscii=54
                                      //         (325*10)+(54-48)
                                      //         3250 +6
                                     //         3256
                                     //    sum=3256
        }
        return sum;
    }

    public static void main(String a[]){

        System.out.println("\"3256\" == "+convert_String_To_Number("3256"));
    }
}

Вывод "3256" --> 3256

1. Метод Parse() доступен во многих форматах, класс Integer имеет метод ParseInt(), который является статическим методом, мы вызываем этот метод с помощью Integer.ParseInt()

2. Точно так же класс Double имеет ParseDouble(), и мы называем его Double.ParseDouble().

3. Более общий способ — XXXX.ParseXXXX().

4. Основное использование этого метода заключается в преобразовании любого объекта в примитив.

5. И тут можно поставить вопрос, зачем нам конвертировать в Примитивы? Ответ заключается в том, что мы знаем, что примитивы хранятся в области стека, а объекты хранятся в области кучи, и вы не хотите тратить память кучи, и вы можете преобразовать объект в примитив.

6. И еще, при доступе к любому объекту могут быть накладные расходы. Лучше использовать как примитив.