blocks|key|1145626|text|还有另一种方式：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1145627|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))));
}|code-block|syntax|javascript|1145628|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Yet another way:

<pre><code>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))));
}
</code></pre>

blocks|key|1360664|text|public+static+int+firstDigit(int+n)+{
++while+(n+<+-9+%7C%7C+9+<+n)+n+/=+10;
++return+Math.abs(n);
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1360665|应该也能很好地处理负数。在这种情况下，将返回负的第一个数字。|unstyled|1360666|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

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

Should handle negative numbers pretty well, too. Will return a negative first digit in that case.

blocks|key|1145689|text|忽略负值会导致：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1145690|(""%2B345).charAt(0);|code-block|syntax|javascript|1145691|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Ignoring negative values leads to:

<pre><code>(""+345).charAt(0);
</code></pre>

blocks|key|1145661|text|缺少的递归解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1145662|int+getFirstInt(int+input)+{
++if+(input+>+0+?+input+<+10+:+input+>+-10)+{
++++return+input+>+0+?+input+:+-input;
++}
++return+getFirstInt(input+/+10);
}|code-block|syntax|javascript|1145663|我不会在现实生活中使用三元运算符，但是-它不是很漂亮吗？;)|1145664|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

The missing recursive solution:

<pre><code>int getFirstInt(int input) {
 if (input &gt; 0 ? input &lt; 10 : input &gt; -10) {
 return input &gt; 0 ? input : -input;
 }
 return getFirstInt(input / 10);
}
</code></pre>

I wouldn't use the ternary operator in real life but - isn't it kind of beautiful? ;)

blocks|key|1145582|text|作业提示:将其转换为字符串，并返回第一个字符。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1145583|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Homework Hint: Convert it to a string and and return the first character.

blocks|key|1145635|text|int+main(void)+{
++int+num+=+3421;

++while+(num*num+%2B+10+-+num*(1+%2B+num)+<=+0)+{
++++num+*=+(num+-+0.9*num)/num;
++}

++std::cout+<<+num+<<+std::endl;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1145636|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>int main(void) {
 int num = 3421;

 while (num*num + 10 - num*(1 + num) &lt;= 0) {
 num *= (num - 0.9*num)/num;
 }

 std::cout &lt;&lt; num &lt;&lt; std::endl;
}
</code></pre>

blocks|key|1360755|text|int+a+=+354;
int+b+=+(int)(a+/+Math.Pow(10,+(int)Math.Log10(a)));+//+3|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1360756|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

blocks|key|1145746|text|看一下提供的代码，似乎有点复杂，这里有一个简单的解决方案……|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1145747|int+number+=+4085;
int+firstDigit+=+number;
while+(firstDigit+>+9)
{
++++++firstDigit+=+firstDigit+/+10;
}
System.out.println("The+First+Digit+is+"+%2B+firstDigit);|code-block|syntax|javascript|1145748|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Looking at the code supplied it seems a tad over complicating the whole thing, here is a simple solution...

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

blocks|key|1361033|text|假设数字为int类型|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1361034|因此，|1361035|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));|code-block|syntax|javascript|1361036|或者，另一种方法是将字符串转换为char，然后从char中获取数值|1361037|例如：|1361038|int+number+=+352;
String+numberString+=+Integer.toString(number);
Character.getNumericValue(String.valueOf(target).charAt(0));+
//+0+means+the+first+digit+of+the+number|1361039|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|V|8|@]|9|@]|A|$G|H]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Assume the number is int type

therefore, 

<pre><code>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));
</code></pre>

or the other way is to change the String into char and get the numerical value from char

e.g.

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

blocks|key|1145790|text|我认为这可能是一种很好的方式：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1145791|public+static+int+length(int+number)+{
++++return+(int)Math.log10(Math.abs(number))+%2B+1;
}

public+static+int+digit(int+number,+int+digit)+{
++++for+(int+i+=+0;+i+<+digit;+i%2B%2B)+{
++++++++number+/=+10;
++++}
++++return+Math.abs(number+%25+10);
}|code-block|syntax|javascript|1145792|适用于负数和正数。digit(345,+length(345)+-+1)将返回3，digit(345,+0)将返回5，以此类推...|offset|length|style|CODE|1145793|entityMap^0|0|0|9|R|13|1|15|D|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]|$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|N|$]]

I think this might be a nice way to do that:

<pre><code>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 &lt; digit; i++) {
 number /= 10;
 }
 return Math.abs(number % 10);
}
</code></pre>

Works for both negative and positive numbers. <code>digit(345, length(345) - 1)</code> will return <code>3</code>, <code>digit(345, 0)</code> will return 5 e.g. and so on...

blocks|key|1361174|text|public+static+void+firstDigit(int+number){++++++
++++while(number+!=+0){
++++++++if+(number+<+10){
++++++++++++System.out.println("The+first+digit+is+"+%2B+number);
++++++++}
++++++++++++number+=+number/10;

++++++++}
++++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1361175|当你调用它的时候，你可以使用Maths.abs来使它对负数起作用：|unstyled|1361176|firstDigit(Math.abs(9584578));+|1361177|这将返回9|1361178|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|F|7|Q|8|@]|9|@]|A|$]]]|L|$]]

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

 }
 }
</code></pre>

When you call it, you can use Maths.abs in order for it to work for negative number:

<pre><code>firstDigit(Math.abs(9584578)); 
</code></pre>

This returns 9

blocks|key|1146378|text|如果你只需要第一个数字/一个特定的数字，那么它比这里给出的任何解决方案都更容易：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1146379|int+temp+=+345%25100+//temp+=+45
int+firstDigit+=+(345+-temp)/100+//fisrtDigit=+300/100+=+3|code-block|syntax|javascript|1146380|如果你也需要检查第二个数字，那么你需要重复第一步|1146381|+int+tempHuns+=+345%25100+//tempHuns+=+45++
+tempTens+=+tempHuns+%2510+//+tempTens=+5
+int+secondDigit+=+(tempHuns+-+tempTens)/10+//fisrtDigit=+40/10+=+4|1146382|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Its easier then any solution given hier if you only need the first digit/one sepcific digit:
<pre><code>int temp = 345%100 //temp = 45
int firstDigit = (345 -temp)/100 //fisrtDigit= 300/100 = 3
</code></pre>
If you need to check the 2nd digit too then you need to repeat step one
<pre><code> int tempHuns = 345%100 //tempHuns = 45 
 tempTens = tempHuns %10 // tempTens= 5
 int secondDigit = (tempHuns - tempTens)/10 //fisrtDigit= 40/10 = 4
</code></pre>

blocks|key|1360937|text|这里有一个非常简单的方法来分别获取整数的第一个和第二个数字，但这只适用于两个数字！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1360938|++++int+firstDigit+=+number+/+10;
++++int+secondDigit+=+number+%25+10;|code-block|syntax|javascript|1360939|对于用户可能输入更多或更少数字，但您可能不知道有多少数字的情况，您可以尝试这种方法，但其他答案对这种情况有更好的解决方案。我刚刚写了这个完整的程序，你可以粘贴到编译器中并运行。一旦你看到了这个模式，你就可以检查任意多个数字，然后只需要一个长度大于你想接受的长度的catch：|1360940|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)+%2B+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(""+%2B+firstDigit);
+++++}
++++if+(length+==+2)
+++++{
++++++++firstDigit+=+number+/+10;+//For+example,+89/10+will+output+8.9+and+show+as+8+in+this+case.
++++++++secondDigit+=+number+%25+10;
++++++++System.out.println(""+%2B+firstDigit+%2B+""+%2B+secondDigit);
+++++}
++++if+(length+==+3)
+++++{
++++++++firstDigit+=+number+/+10+/+10;+//+123/10/10+is+1.23+and+will+show+as+1
++++++++secondDigit+=+number+/+10+%25+10;
++++++++thirdDigit+=+number+%25+10;
++++++++System.out.println(""+%2B+firstDigit+%2B+""+%2B+secondDigit+%2B+""+%2B+thirdDigit);
+++++}
++++if+(length+==+4)
+++++{
++++++++firstDigit+=+number+/+10+/+10+/+10;+
++++++++secondDigit+=+number+/+10+/+10+%25+10;
++++++++thirdDigit+=+number+/+10+%25+10;
++++++++fourthDigit+=+number+%25+10;
++++++++System.out.println(""+%2B+firstDigit+%2B+""+%2B+secondDigit+%2B+""+%2B+thirdDigit+%2B+""+%2B+fourthDigit);
+++++}
+++++if+(length+==+5)
+++++{
++++++++firstDigit+=+number+/+10+/+10+/+10+/+10;+
++++++++secondDigit+=+number+/+10+/+10+/+10+%25+10;
++++++++thirdDigit+=+number+/+10+/+10+%25+10;
++++++++fourthDigit+=+number+/+10+%25+10;
++++++++fifthDigit+=+number+%25+10;
++++++++System.out.println(""+%2B+firstDigit+%2B+""+%2B+secondDigit+%2B+""+%2B+thirdDigit+%2B+""+%2B+fourthDigit+%2B+""+%2B+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+%25+10;
++++++++thirdDigit+=+number+/+10+/+10+/+10+%25+10;
++++++++fourthDigit+=+number+/+10+/+10+%25+10;
++++++++fifthDigit+=+number+/+10+%25+10;+//The+second+to+last+always+looks+like+this
++++++++sixthDigit+=+number+%25+10;++//The+last+digit+always+looks+like+this+no+matter+how+big+you+go
++++++++System.out.println(""+%2B+firstDigit+%2B+""+%2B+secondDigit+%2B+""+%2B+thirdDigit+%2B+""+%2B+fourthDigit+%2B+""+%2B+fifthDigit+%2B+""+%2B+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!");
+++++}

++}

}|1360941|作为一个程序，它只输出你输入的数字，但正如你所看到的，它的方式表明它能够分离用户输入的数字，这样你就可以用它来测试一个简单的程序，但再说一次，它不如这里的其他一些解决方案好，它只是一种对初学者很好的可读性方法。它也可以很好地接受负片。|1360942|另外:在以双精度开头的情况下，您可以使用以下代码将其转换为int并截断小数：|1360943|numberInt+=+(int)number;|1360944|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Here's an extremely simple way of obtaining the first and second digits of an integer separately, but this will only work for exactly two digits!

<pre><code> int firstDigit = number / 10;
 int secondDigit = number % 10;
</code></pre>

For a situation where the user might input more or less digits, but where you may not know how many, you could try this approach, but other answers have better solutions for this case. I just wrote this complete program up that you can paste into a compiler and run. Once you see the pattern you can check for as many digits as you want and then just have a catch for a length greater than you want to accept:

<pre><code>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 &gt; 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!");
 }

 }

}
</code></pre>

As a program it just outputs exactly the number you type in, but as you can see it's doing it in a way that shows that it's able to separate the digits of user input so you can use it as a test for a simple program, but again, it's not as good as some of the other solutions here, it's just a readable approach that works well for beginners. It also accepts negatives just fine.

Also: In a case where you start with a double you could use the following to convert to int and truncate decimals:

<pre><code>numberInt = (int)number;
</code></pre>

blocks|key|1360954|text|//Try+this+one.
Scanner+input+=+new+Scanner(System.in);
System.out.println("enter+first+9+digits:+");
String+x+=+input.nextLine();
String+x1+=+x.substring(0,1);
int+d1+=+Integer.parseInt(x1);
System.out.println(d1);
//+the+substring+gives+the+position+of+extraction.+method+dont+seem+to+work+for+letters+though|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1360955|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>//Try this one.
Scanner input = new Scanner(System.in);
System.out.println("enter first 9 digits: ");
String x = input.nextLine();
String x1 = x.substring(0,1);
int d1 = Integer.parseInt(x1);
System.out.println(d1);
// the substring gives the position of extraction. method dont seem to work for letters though
</code></pre>

blocks|key|1360984|text|int+firstNumber(int+x){
+++++int+firstN+=+x;
+++++while(firstN+>+9){
++++++++++firstN+=+(firstN+-+(firstN%2510))/10;
+++++}
+++++return+firstN;+++
+}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1360985|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>int firstNumber(int x){
 int firstN = x;
 while(firstN &gt; 9){
 firstN = (firstN - (firstN%10))/10;
 }
 return firstN; 
 }
</code></pre>

blocks|key|1361128|text|这是一个较小的版本来获取所有位置的数字，它适用于负值(而不是小数)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1361129|int+number+=+-23456;

int+length+=+(int)+Math.log10(Math.abs(number))+%2B+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+"+%2B+1+%2B+"+is+:-+"+%2B+(int)(Math.abs(number)/Math.pow(10,(length-1))));

for+(int+i+=+2;+i+<=+length;+i%2B%2B){
++++System.out.println("Digit+at+pos+"+%2B+i+%2B+"+is+:-+"+%2B+(int)(Math.abs(number)/Math.pow(10,(length-i))%2510));
}|code-block|syntax|javascript|1361130|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is a smaller version to get digits of all positions, it works with negative value (not decimal).

<pre><code>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 &lt;= length; i++){
 System.out.println("Digit at pos " + i + " is :- " + (int)(Math.abs(number)/Math.pow(10,(length-i))%10));
}
</code></pre>

blocks|key|1361246|text|为了从左到右分离整数的数字，我使用了两种不同的方法，第一种方法是计算整数由多少位组成，然后我从左到右拆分，方法是将整数除以10，再乘以数字数减1的幂。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1361247|//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+%2B+"+//+"+);
++++++++num+%25=+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%2B%2B;+//this+counts+the+number+of+times+the+"while"+loops
++++}
++++return+numOfDigits;
}|code-block|syntax|javascript|1361248|没有使用数组或递归方法，只使用"/“和"%25”进行简单的除法。|1361249|调用该方法：|1361250|public+static+void+main(String+args[])+{

separateDigits(+-123456789+);

}|1361251|收益率:1/2/3/4/5/6/7/8/9+//|1361252|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

To separate digits of an integer from left to right I use 2 different methods, the first one to count how many digits the integer is made up of and then I split them from left to right by dividing the integer by 10 raised to the power of the number of digits minus 1.

<pre><code>//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 &gt;= 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) &gt; 0){ 
 num = num / 10;
 numOfDigits++; //this counts the number of times the "while" loops
 }
 return numOfDigits;
}
</code></pre>

No use of Arrays or recursive methods just simple division with "/" and "%".

Invoking the method: 

<pre><code>public static void main(String args[]) {

separateDigits( -123456789 );

}
</code></pre>

yields:
1 // 2 // 3 // 4 // 5 // 6 // 7 // 8 // 9 //

blocks|key|1146307|text|我认为更简单的做法是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1146308|int+firstDigit+=+i-(i/10)*10+//+i+is+an+integer+or+long+value,+positive+or+negative.|code-block|syntax|javascript|1146309|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I think more simple to do : 

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

blocks|key|1361079|text|这种方法对我来说工作得很好，但它确实涉及到从int到string再到int的转换。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1361080|Integer.parseInt(String.valueOf(x).substring(0,1));|code-block|syntax|javascript|1361081|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This way worked for me just fine, but it does involve converting from int to string and back to int.

<pre><code>Integer.parseInt(String.valueOf(x).substring(0,1));
</code></pre>

How in Java do you return the first digit of an integer.?

i.e. 

345

Returns an int of 3.

Return first digit of an integer

编译器

Java

在Java中，如何返回整数的第一个数字？即345返回一个值为3的整数。

问返回整数的第一位数
EN

回答 19

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问返回整数的第一位数EN

回答 19

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问返回整数的第一位数
EN