Возвращает первую цифру целого числа

Самый простой способ — использовать String.valueOf(Math.abs((long)x)).charAt(0) — это даст вам char¹. Чтобы получить это как целочисленное значение, вы можете просто вычесть «0» (как в Unicode, от «0» до «9» являются смежными).

Это несколько расточительно, конечно. Альтернативой было бы просто взять абсолютное значение, а затем циклически делить на 10, пока число не окажется в диапазоне 0-9. Если это домашнее задание, я бы дал такой ответ. Однако я не буду приводить для него код, потому что думаю, что это может быть домашним заданием. Однако, если вы предоставите комментарии и отредактируете свой ответ, чтобы объяснить, как у вас дела и с какими проблемами вы сталкиваетесь, мы можем помочь.

¹Обратите внимание, что абсолютное значение Integer.MIN_VALUE не может быть представлено как int, поэтому вы можете сначала преобразовать его в long, затем использовать Math.abs, затем заниматься арифметикой. Вот почему там есть актерский состав.

Еще один способ:

public int firstDigit(int x) {
  if (x == 0) return 0;
  x = Math.abs(x);
  return (int) Math.floor(x / Math.pow(10, Math.floor(Math.log10(x))));
}

public static int firstDigit(int n) {
  while (n < -9 || 9 < n) n /= 10;
  return Math.abs(n);
}

Должен также хорошо обрабатывать отрицательные числа. В этом случае вернет отрицательную первую цифру.

Игнорирование отрицательных значений приводит к:

(""+345).charAt(0);

Отсутствующее рекурсивное решение:

int getFirstInt(int input) {
  if (input > 0 ? input < 10 : input > -10) {
    return input > 0 ? input : -input;
  }
  return getFirstInt(input / 10);
}

Я бы не стал использовать тернарный оператор в реальной жизни, но — разве это не красиво? ;)

Я нахожу это более простым:

int firstDigit(int num)
{
    if(num/10 == 0)
        return num;
    return firstDigit(num/10);

}

• Ввод: 123 => Вывод: 1
• Ввод: -123 => Вывод: -1

Обновлено: решение log10:

Вариант решения log10 без деления:

public int getFirstDigit(int x) {
    double e = Math.log10(Math.abs((long) x));
    return Double.valueOf(Math.pow(10.0, e - Math.floor(e))).intValue());
}

Что он делает?

1. приведите целое к длинному (чтобы справиться с проблемой MIN_VALUE)
2. получить абсолютное значение
3. рассчитать лог10
4. рассчитать пол из бревна10
5. вычесть пол из бревна10 (разница будет дробью)
6. поднимите десять до разницы, давая вам значение первой цифры.

Решение цикла while:

Чтобы обработать Integer.MIN_VALUE и сохранить Math.abs() и приведение к длинному циклу:

public static int getFirstDigit(int i) {
    i = Math.abs(i / (Math.abs((long)i) >= 10 ) ? 10 : 1);
    while (i >= 10 ) 
        i /= 10;
    return i;
}

Самый быстрый способ:

• Вычислите журнал abs(x), затем получите пол. Назовем это н.
• Разделите число на 10^n

Подсказка к домашнему заданию: преобразовать его в строку и вернуть первый символ.

Глядя на предоставленный код, кажется, что все это немного усложняет, вот простое решение...

int number = 4085;
int firstDigit = number;
while (firstDigit > 9)
{
      firstDigit = firstDigit / 10;
}
System.out.println("The First Digit is " + firstDigit);

Предположим, что число имеет тип int

поэтому,

int number = 352
// Change the int into String format
String numberString = Integer.toString(number);
// We can know the first digit of that String with substring method directly
Integer.parseInt(numberString.substring(0,1));

или другой способ - изменить строку на char и получить числовое значение из char

e.g.

int number = 352;
String numberString = Integer.toString(number);
Character.getNumericValue(String.valueOf(target).charAt(0)); 
// 0 means the first digit of the number

Я думаю, что это может быть хорошим способом сделать это:

public static int length(int number) {
    return (int)Math.log10(Math.abs(number)) + 1;
}

public static int digit(int number, int digit) {
    for (int i = 0; i < digit; i++) {
        number /= 10;
    }
    return Math.abs(number % 10);
}

Работает как для отрицательных, так и для положительных чисел. digit(345, length(345) - 1) вернет 3, digit(345, 0) вернет 5, например. и так далее...

public static void firstDigit(int number){      
    while(number != 0){
        if (number < 10){
            System.out.println("The first digit is " + number);
        }
            number = number/10;

        }
    }

Когда вы вызываете его, вы можете использовать Maths.abs, чтобы он работал с отрицательным числом:

firstDigit(Math.abs(9584578)); 

Это возвращает 9

Это Groovy, но его легко преобразовать в Java:

int firstNum(int x) {
    a = Math.abs(x)
    sig = Math.floor(Math.log10(a))
    return a / Math.pow(10, sig)
}

Полученные результаты:

заводной> println(firstNum(345))
3

заводной> println(firstNum(3452))
3

заводной> println(firstNum(-112))
1

заводной> println(firstNum(9999))
9

groovy> println(firstNum(Integer.MAX_VALUE))
2

groovy> println(firstNum(Integer.MIN_VALUE + 1))
2

Вот чрезвычайно простой способ получения первой и второй цифр целого числа по отдельности, но он будет работать только для ровно двух цифр!

    int firstDigit = number / 10;
    int secondDigit = number % 10;

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

package testingdigits;

import java.util.Scanner;

public class TestingDigits {


Scanner keyboard = new Scanner(System.in);    

public static void main(String[] args) 
{

Scanner keyboard = new Scanner(System.in);

System.out.printf("\nEnter a number to test:");
int number = keyboard.nextInt();

int length = (int) Math.log10(number) + 1; //This gets the length of the number of digits used 

//Initializing variables first to prevent error
int firstDigit = 0, secondDigit = 0, thirdDigit = 0, fourthDigit = 0, fifthDigit = 0, sixthDigit = 0;

    if (length == 1)
     {
        firstDigit = number;
        System.out.println("" + firstDigit);
     }
    if (length == 2)
     {
        firstDigit = number / 10; //For example, 89/10 will output 8.9 and show as 8 in this case.
        secondDigit = number % 10;
        System.out.println("" + firstDigit + "" + secondDigit);
     }
    if (length == 3)
     {
        firstDigit = number / 10 / 10; // 123/10/10 is 1.23 and will show as 1
        secondDigit = number / 10 % 10;
        thirdDigit = number % 10;
        System.out.println("" + firstDigit + "" + secondDigit + "" + thirdDigit);
     }
    if (length == 4)
     {
        firstDigit = number / 10 / 10 / 10; 
        secondDigit = number / 10 / 10 % 10;
        thirdDigit = number / 10 % 10;
        fourthDigit = number % 10;
        System.out.println("" + firstDigit + "" + secondDigit + "" + thirdDigit + "" + fourthDigit);
     }
     if (length == 5)
     {
        firstDigit = number / 10 / 10 / 10 / 10; 
        secondDigit = number / 10 / 10 / 10 % 10;
        thirdDigit = number / 10 / 10 % 10;
        fourthDigit = number / 10 % 10;
        fifthDigit = number % 10;
        System.out.println("" + firstDigit + "" + secondDigit + "" + thirdDigit + "" + fourthDigit + "" + fifthDigit);
     }
    //You can probably see the pattern by now. It's not an elegant solution, but is very readable by even beginners:     
    if ((length == 6))
     {
        firstDigit = number / 10 / 10 / 10 / 10 / 10; //The first digit is divided by 10 for however many digits are after it
        secondDigit = number / 10 / 10 / 10 % 10;
        thirdDigit = number / 10 / 10 / 10 % 10;
        fourthDigit = number / 10 / 10 % 10;
        fifthDigit = number / 10 % 10; //The second to last always looks like this
        sixthDigit = number % 10;  //The last digit always looks like this no matter how big you go
        System.out.println("" + firstDigit + "" + secondDigit + "" + thirdDigit + "" + fourthDigit + "" + fifthDigit + "" + sixthDigit);
     }
    if ((length > 6))
     {
        //The main problem with this approach is that you have to define in advance how many digits you are working with
        //So it's simple, but not very elegant, and requires something to catch unexpected input from the user.
        System.out.println("Invalid Input!");
     }

  }

}

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

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

numberInt = (int)number;

Вот уменьшенная версия для получения цифр всех позиций, она работает с отрицательным значением (не десятичным).

int number = -23456;

int length = (int) Math.log10(Math.abs(number)) + 1; //This gets the length of the number of digits used
//Math.abs to change negative int to positive

System.out.println("Digit at pos " + 1 + " is :- " + (int)(Math.abs(number)/Math.pow(10,(length-1))));

for (int i = 2; i <= length; i++){
    System.out.println("Digit at pos " + i + " is :- " + (int)(Math.abs(number)/Math.pow(10,(length-i))%10));
}

Чтобы разделить цифры целого числа слева направо, я использую 2 разных метода: первый для подсчета количества цифр, из которых состоит целое число, а затем я разделяю их слева направо, разделив целое число на 10, возведенное в степень количество цифр минус 1.

//method to separate digits of an integer from left to right
private static void separateDigits(int num){
    int numOfDigits = countNumberOfDigits(num);
    for (int numOfZeros = numOfDigits-1; numOfZeros >= 0 ; --numOfZeros){
        int divisor = (int) Math.pow(10, numOfZeros);
        System.out.print( Math.abs(num) / divisor + " // " );
        num %= divisor;
    }
}

//method to count number of digits
private static int countNumberOfDigits(int num){
    int numOfDigits=0;
    //using absolute value of num allows method to work even with negative integers
    while(Math.abs(num) > 0){ 
        num = num / 10;
        numOfDigits++; //this counts the number of times the "while" loops
    }
    return numOfDigits;
}

Никакого использования массивов или рекурсивных методов, просто деление с помощью «/» и «%».

Вызов метода:

public static void main(String args[]) {

separateDigits( -123456789 );

}

выходы: 1 // 2 // 3 // 4 // 5 // 6 // 7 // 8 // 9 //

Я думаю проще сделать:

int firstDigit = i-(i/10)*10 // i is an integer or long value, positive or negative.

Этот способ отлично сработал для меня, но он включает преобразование из int в строку и обратно в int.

Integer.parseInt(String.valueOf(x).substring(0,1));