Как посчитать количество цифр в числе java

Logical AND (&&)

The logical AND ( && ) (logical conjunction) operator for a set of boolean operands will be true if and only if all the operands are true . Otherwise it will be false .

More generally, the operator returns the value of the first falsy operand encountered when evaluating from left to right, or the value of the last operand if they are all truthy.

Try it

Syntax

Description

If a value can be converted to true , the value is so-called truthy. If a value can be converted to false , the value is so-called falsy.

Examples of expressions that can be converted to false are:

• false ;
• null ;
• NaN ;
• 0 ;
• empty string ( «» or » or « );
• undefined .

The AND operator preserves non-Boolean values and returns them as they are:

= "" && "foo"; // result is assigned "" (empty string) result = 2 && 0; // result is assigned 0 result = "foo" && 4; // result is assigned 4 

Even though the && operator can be used with non-Boolean operands, it is still considered a boolean operator since its return value can always be converted to a boolean primitive. To explicitly convert its return value (or any expression in general) to the corresponding boolean value, use a double NOT operator or the Boolean constructor.

Short-circuit evaluation

The logical AND expression is a short-circuit operator. As each operand is converted to a boolean, if the result of one conversion is found to be false , the AND operator stops and returns the original value of that falsy operand; it does not evaluate any of the remaining operands.

Consider the pseudocode below.

(some falsy expression) && expr

The expr part is never evaluated because the first operand (some falsy expression) is evaluated as falsy. If expr is a function, the function is never called. See the example below:

function A()  console.log("called A"); return false; > function B()  console.log("called B"); return true; > console.log(A() && B()); // Logs "called A" to the console due to the call for function A, // && evaluates to false (function A returns false), then false is logged to the console; // the AND operator short-circuits here and ignores function B 

Operator precedence

The AND operator has a higher precedence than the OR operator, meaning the && operator is executed before the || operator (see operator precedence).

true || false && false; // true true && (false || false); // false (2 === 3) || (4  0) && (1 === 1); // false 

Examples

Using AND

The following code shows examples of the && (logical AND) operator.

= true && true; // t && t returns true a2 = true && false; // t && f returns false a3 = false && true; // f && t returns false a4 = false && 3 === 4; // f && f returns false a5 = "Cat" && "Dog"; // t && t returns "Dog" a6 = false && "Cat"; // f && t returns false a7 = "Cat" && false; // t && f returns false a8 = "" && false; // f && f returns "" a9 = false && ""; // f && f returns false 

Conversion rules for booleans

Converting AND to OR

The following operation involving booleans:

&& bCondition2 

is always equal to:

!(!bCondition1 || !bCondition2) 

Converting OR to AND

The following operation involving booleans:

|| bCondition2 

is always equal to:

!(!bCondition1 && !bCondition2) 

Removing nested parentheses

As logical expressions are evaluated left to right, it is always possible to remove parentheses from a complex expression provided that certain rules are followed.

The following composite operation involving booleans:

|| (bCondition2 && bCondition3) 

is always equal to:

|| bCondition2 && bCondition3 

Specifications

Specification
ECMAScript Language Specification # prod-LogicalANDExpression

Browser compatibility

BCD tables only load in the browser

Количество цифр в целом числе в Java

В этом кратком руководстве мы рассмотрим различные способы получения количества цифр в Integer в Java.

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

2. Количество цифр в целом числе ​

Для обсуждаемых здесь методов мы рассматриваем только положительные целые числа. Если мы ожидаем какой-либо отрицательный ввод, то мы можем сначала использовать Math.abs(number) перед использованием любого из этих методов.

2.1. Строковое решение​

Возможно, самый простой способ получить количество цифр в Integer — преобразовать его в String и вызвать метод length() . Это вернет длину строкового представления нашего числа:

 int length = String.valueOf(number).length(); 

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

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

2.2. Логарифмический подход​

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

 int length = (int) (Math.log10(number) + 1); 

Обратите внимание, что log 10 0 любого числа не определен, поэтому, если мы ожидаем каких-либо входных данных со значением 0 , мы также можем поставить проверку для этого.

Логарифмический подход значительно быстрее, чем подход, основанный на String , поскольку ему не нужно проходить процесс преобразования данных. Это просто включает в себя простой, прямой расчет без какой-либо дополнительной инициализации объекта или циклов.

2.3. Повторное умножение​

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

 int length = 0;   long temp = 1;   while (temp  number)    length++;   temp *= 10;   >   return length; 

2.4. Деление со степенью двойки​

Если мы знаем диапазон нашего числа, то мы можем использовать вариант, который еще больше уменьшит наши сравнения. Этот метод делит число на степени двойки (например, 1, 2, 4, 8 и т. д.):

 int length = 1;   if (number >= 100000000)    length += 8;   number /= 100000000;   >   if (number >= 10000)    length += 4;   number /= 10000;   >   if (number >= 100)    length += 2;   number /= 100;   >   if (number >= 10)    length += 1;   >   return length; 

Он использует тот факт, что любое число может быть представлено сложением степеней двойки. Например, 15 можно представить как 8+4+2+1, которые являются степенями двойки.

Для 15-значного числа мы бы сделали 15 сравнений в нашем предыдущем подходе, по сравнению с четырьмя в этом методе.

2.5. Разделяй и властвуй​

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

Мы можем получить ответ всего за три-четыре простых оператора if :

 if (number  100000)    if (number  100)    if (number  10)    return 1;   > else    return 2;   >   > else    if (number  1000)    return 3;   > else    if (number  10000)    return 4;   > else    return 5;   >   >   >   > else    if (number  10000000)    if (number  1000000)    return 6;   > else    return 7;   >   > else    if (number  100000000)    return 8;   > else    if (number  1000000000)    return 9;   > else    return 10;   >   >   >   > 

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

3. Сравнительный анализ​

Теперь, когда у нас есть хорошее представление о возможных решениях, давайте проведем простой бенчмаркинг наших методов с помощью Java Microbenchmark Harness (JMH) .

В следующей таблице показано среднее время обработки каждой операции (в наносекундах):

Benchmark Mode Cnt Score Error Units Benchmarking.stringBasedSolution avgt 200 32.736 ± 0.589 ns/op Benchmarking.logarithmicApproach avgt 200 26.123 ± 0.064 ns/op Benchmarking.repeatedMultiplication avgt 200 7.494 ± 0.207 ns/op Benchmarking.dividingWithPowersOf2 avgt 200 1.264 ± 0.030 ns/op Benchmarking.divideAndConquer avgt 200 0.956 ± 0.011 ns/op 

Решение на основе String , которое является самым простым, также является наиболее дорогостоящей операцией, поскольку только оно требует преобразования данных и инициализации новых объектов.

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

Повторное умножение включает простое умножение пропорционально длине числа; например, если число состоит из 15 цифр, то этот метод будет включать 15 умножений.

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

Наконец, как мы можем сделать вывод, наиболее эффективным алгоритмом является многословная реализация «Разделяй и властвуй», которая выдает ответ всего за три-четыре простых оператора if . Мы можем использовать его, если у нас есть большой набор данных, который нам нужно проанализировать.

4. Вывод​

В этой краткой статье мы описали некоторые способы определения количества цифр в целом числе и сравнили эффективность каждого подхода.

Как всегда, полный код доступен на GitHub .

Определить количество цифр в числе типа BigInteger в Java

@МаркТюков система исчисленния. На самом деле десятичная и так будет использоваться, но explicit is better than implicit.

3 сен 2017 в 14:49

В toString не обязательно передавать 10, т.к. это значение по умолчанию. И да, второй способ ни разу не лучше.

3 сен 2017 в 14:59
@defaultlocale о чем я и написал
3 сен 2017 в 15:12

Вот еще вариант для чисел от 1 до 1 до 99 999 999 999 999 (верхняя граница грубая, т.к. для большинства 15-значных тоже работает, но не всех) с использованием 10го логарифма:

private static int logLength(BigInteger i)

Мои грубые замеры показали, что такой вариант работает в несколько раз быстрее, чем способ через длину строки:

public static void main(String[] args) < long start = System.currentTimeMillis(); BigInteger integer = BigInteger.ONE; //увеличиваем значения на 11 (для чистоты эксперимента - чтобы log10 не был целым) каждые 1_000_000 итераций BigInteger multiplier = BigInteger.valueOf(11); for (int i = 0; i < 14; i++) < for (int j=0; jinteger = integer.multiply(multiplier); > long end = System.currentTimeMillis(); System.out.println("log10: " + ((double)(end - start))/1000); integer = BigInteger.ONE; start = System.currentTimeMillis(); for (int i = 0; i < 14; i++) < for (int j=0; jinteger = integer.multiply(multiplier); > end = System.currentTimeMillis(); System.out.println("strlen: " + ((double)(end - start))/1000); > private static int strLength(BigInteger i)

log10: 0.387 strlen: 1.768 

PS:
Спасибо @default locale за конструктивные комментарии насчет точности метода

Difference Between & and && in Java

In this section, we will discuss the two most important operators & and && in Java and also see the key differences between logical and bitwise operators along with its uses.

& Operator

The single AND operator (&) is known as the Bitwise AND operator. It operates on a single bit. It takes two operands. A bit in the result is 1 if and only if both of the corresponding bits in the operands are 1. The result of the operator may be any number. For example:

&& Operator

The double AND operators (&&) are known as logical AND operators. It is usually used in loops and conditional statements. It is usually used in Boolean expressions. The result of && is always 0 or 1.

Difference Between & and &&

The key difference between && and & operators is that && supports short-circuit evaluations while & operator does not.

Another difference is that && will evaluate the expression exp1, and immediately return a false value if exp1 is false. While & operator always evaluates both expressions (exp1 and exp2) before retiring an answer.

S.N.	Basis	& Operator	&& Operator
1	Operator	It is a bitwise AND operator.	It is a logical AND operator.
2	Evaluation	It evaluates both the left and right side of the given expression.	It only evaluates the left sides of the given expression.
3	Operates on	It operates on Boolean data types as well as on bits.	It operates only on Boolean datatype.
4	Uses	Used to check logical condition and also used to mask off certain bits such as parity bits.	Used only to check the logical conditions.
5	Example	z = x & y	if (y > 1 && y > x)

Let’s understand bitwise and logical and operator through a Java program.

LogicalAndExample.java

Output:

true false

BitwiseAndExample.java