Как перевести число в строку java: Java: преобразование строки в число и наоборот

java — Как определить, является ли строка числом?

В связи с повышенным интересом по данному вопросу, сделал маленькое исследование 🙂

Полный код доступен тут.

В исследовании принимали участия классы:

CharacterDelegator() // код @Sergey
ComplexMatcher() // код @VladD
NumberUtilsDelegator() // мой код
SimpleMatcher()  // код @ivkremer (для простых чисел)
GuavaDelegator()  // код @Nofate♦
SimpleMatcherWithDot() // код @ivkremer (для чисел с точкой)
SimpleParser()  // оригинальный код от @pol
GuavaComplexDelegator() // модифицированный вариант кода @Nofate♦ для Float
InnerSetImpl()  // мой специфический вариант

(@VladD, извиняюсь, понимаю, что делает ваш регэксп, но завести его у меня не получилось)

Тестовые данные:

{"1", "1.1", "1.11", "1.0", "-1",
 "-1.0", "-1.1", "4563575687468353456", 
 "1l", "1L", "1f", "1F", "0xCAFEBABE", "1F",
 "10000000000000000000000000000000000000000000000000", 
 "1.26767E108"}

Вывода много, поэтому вкратце:

• абсолютно все строки из примера распарсил только NumberUtils (commons-lang)
• вариант с использованием Guava (расширенный) справился со всем кроме long-нотаций («l») и «0xCAFEBABE» 🙂 (честно, не понимаю, почему он варианты с «f»-нотацией прожевал)
• остальные варианты в большей степени рассчитаны на парсинг именно интов, хотя в изначальном вопросе об этом ни слова 🙂

А вот самое интересное — это время работы данного кода.

Start performance test for core.impl.CharacterDelegator Ints: 125ms Numbers: 67ms Numbers with 25% errors: 50ms Small Ints: 43ms

Start performance test for core.impl.ComplexMatcher Ints: 10825ms Numbers: 11134ms Numbers with 25% errors: 10606ms Small Ints: 10380ms

Start performance test for core.impl.InnerSetImpl Ints: 50ms Numbers: 52ms Numbers with 25% errors: 54ms Small Ints: 42ms

Start performance test for core.impl.NumberUtilsDelegator Ints: 111ms Numbers: 91ms Numbers with 25% errors: 99ms Small Ints: 51ms

Start performance test for core.impl.SimpleMatcher Ints: 1072ms Numbers: 853ms Numbers with 25% errors: 847ms Small Ints: 766ms

Start performance test for core.impl.GuavaDelegator Ints: 131ms Numbers: 108ms Numbers with 25% errors: 124ms Small Ints: 119ms

Start performance test for core.impl.SimpleMatcherWithDot Ints: 3069ms Numbers: 5855ms Numbers with 25% errors: 5484ms Small Ints: 2548ms

Start performance test for core.impl.SimpleParser Ints: 157ms Numbers: 2189ms Numbers with 25% errors: 2117ms Small Ints: 81ms

Start performance test for core.impl.GuavaComplexDelegator Ints: 980ms Numbers: 943ms Numbers with 25% errors: 1016ms Small Ints: 837ms

Тест построен следующим образом

1. Генерируем 2 рандомных списка со стрингами (числа). Тут есть 4 варианта:

     1. Просто Инты.
     2. Числа (с 50% вероятностью в стринге есть точка).
     3. Числа с возможной ошибкой (25% что в строке есть подстрока "error").
     4. Набор Интов в небольшом диапазоне.
   

2. Делаем тестовый прогон на 10_000 элементах.

3. Делаем прогон на 1_000_000 элементах.

Из приведенных выкладок видно, что NumberUtils работает быстрее всего. Схожее время работы у простого варианты Guava`ы и простых regexp. Даже добавление простой точки значительно замедляет код. Также замечу, что код @Sergey работает очень быстро, но он рассчитан на проверку строго интов.

А еще есть мой специфический пример InnerSetImpl. Он основан на допущении, что у нас есть ограниченное число возможных вариантов (то есть, мы можем и готовы держать их в памяти). Тогда мы просто помещаем их в HashSet и проверяем наличие строк в нем. Собственно, такой вариант самый быстрый, но допущение многое портит 🙂

ИТОГО: если нужно простое и элегантное решение — то лучше всего воспользоваться

А если вдруг у вас стоит специфическая задача на парсинг не просто чисел, но чисел в Java-нотациях, то это единственный полностью рабочий вариант.

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

Kotlin | Преобразование типов

Преобразование типов

Последнее обновление: 30.05.2021

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

Встроенные методы преобразования типов

Для преобразования данных одного типа в другой можно использовать встроенные следующие функции, которые есть у базовых типов (Int, Long, Double и т.д.) (Конкретный набор функций для разных базовых типов может отличаться. ):

• toByte

• toShort

• toInt

• toLong

• toFloat

• toDouble

• toChar

Все эти функции преобразуют данные в тот тип, которые идет после префикса to: toByte.

val s: String = "12"
val d: Int = s.toInt()
println(d)

В данном случае строка s преобразуется в число d. Просто так передать строку переменной типа Int, мы не можем, несмотря на то, что вроде бы строка и содержит число 12:

val d: Int = "12"	// ! Ошибка

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

val s: String = "tom"
try {
	val d: Int = s.toInt()
	println(d)
}
catch(e: Exception){
	println(e.message)
}

Smart cast и оператор is

Оператор is позволяет проверить выражение на принадлежность определенному типу данных:

значение is тип_данных

Этот оператор возвращает true, если значение слева от оператора принадлежит типу, указанному справа от оператора. Если локальная переменная или свойство успешно пройдет проверку на принадлежность определенному типу, то далее нет нужды дополнительно приводить значение к этому типу. Данные преобразования еще называются smart casts или «умные преобразования».

Данный оператор можно применять как к базовым типам, но к собственным классам и интерфейсам, которые находятся в одной и той же иерархии наследования.

fun main() {

    val tom = Person("Tom")
    val bob = Employee("Bob", "JetBrains")

    checkEmployment(tom)    // Tom does not have a job
    checkEmployment(bob)    // Bob works in JetBrains
}

fun checkEmployment(person: Person){
	// println("${person.name} works in ${person.company}")    // Ошибка - у Person нет свойства company
    if(person is Employee){
        println("${person.name} works in ${person.company}")
    }
    else{
        println("${person.name} does not have a job")
    }
}
open class Person(val name: String)
class Employee(name: String, val company: String): Person(name)

Здесь класс Employee наследуется от класса Person. В функции checkEmployment() получаем объект Person. С помощью оператора is проверяем, представляет ли он тип Employee (так как не каждый объект Person может представлять тип Employee). Если он представляет тип Employee, то выводим название его компании, если он не представляет тип Employee, то выводим, сообщение, что он безработный.

Причем даже если значение представляет тип Employee, то до применения оператора is оно тем не менее принадлежит типу Person. И только применение оператора is преобразует значение из типа Person в тип Employee.

Также можно применять другую форму оператора — !is/span>. Она возвращает true, если значение НЕ представляет указанный тип данных:

fun main() {

    val tom = Person("Tom")
    val bob = Employee("Bob", "JetBrains")

    checkEmployment(tom)    // Tom does not have a job
    checkEmployment(bob)    // Bob works in JetBrains
}

fun checkEmployment(person: Person){
	// println("${person.name} works in ${person.company}")    // Ошибка - у Person нет свойства company
    if(person !is Employee){
        println("${person.name} does not have a job")
    }
    else{
		println("${person.name} works in ${person.company}")
    }
}
open class Person(val name: String)
class Employee(name: String, val company: String): Person(name)

Однако, что, если свойство company имеет пустую строку, например, val bob = Employee("Bob", "")

fun checkEmployment(person: Person){
    if(person is Employee && person.company.length > 0){
        println("${person.name} works in ${person.company}")
    }
    else{
        println("${person.name} does not have a job")
    }
}

в выражении

person.company.length > 0){

компилятор уже видит, что person — это объект типа Employee, поэтому позволяет обращаться к его свойствам и функциям.

Если необходимо определить различные действия в зависимости от типа объекта, то удобно использовать конструкцию when:

fun identifyPerson(person: Person){
    when(person){
        is Manager -> println("${person.name} is a manager")
        is Employee -&t; println("${person.name} is an employee")
        is Person -> println("${person.name} is just a person")
    }
}

open class Person(val name: String)
open class Employee(name: String, val company: String): Person(name)
class Manager(name: String, company: String): Employee(name, company)

Ограничения умных преобразований

Подобные smart-преобразования тем не менее имеют ограничения. Они могут применяться, только если компилятор может гарантировать, что переменная не изменила своего значения в промежутке между проверкой и использованием. Для smart-преобразований действуют следующие правила:

1. smart-преобразования применяются к локальным val-переменным (за исключением делегированных свойств)

2. smart-преобразования применяются к val-свойствам, за исключением свойств с модификатором open (то есть открытых к переопределению в производных классах) или свойств, для которых явным образом определен геттер

3. smart-преобразования применяются к локальным var-переменным, если переменная не изменяет своего значения в промежутке между проверкой и использованием и не используется в лямбда-выражении, которое изменяет ее, а также не является локальным делегированным свойством

4. к var-свойствам smart-преобразования не применяются

Рассмотрим некоторые случаи. Возьмем последнее правило про var-свойства:

fun main() {

    val tom = Person("Tom")

    if(tom.phone is SmartPhone){

        println("SmartPhone: ${tom.phone.name}, OS: ${tom.phone.os}")	// ! Ошибка
    }
    else{
        println("Phone: ${tom.phone.name}")
    }
}
open class Phone(val name: String)
class SmartPhone(name: String, val os: String) : Phone(name)

open class Person(val name: String){
    var phone: Phone = SmartPhone("Pixel 5", "Android")
}

Здесь класс Person хранит var-свойство класса Phone, которому присваивается объект класса SmartPhone. Соответственно в выражении:

if(tom.phone is SmartPhone){

очевидно, что свойство tom.phone представляет класс SmartPhone, однако поскольку это свойство определено с помощью var, то к нему не применяются smart-преобразования. То есть если в данном случае мы заменим var на val, то у нас проблем не возникнет.

Или второе правило — изменим класс Person, определив для свойства геттер:

open class Person(val name: String){
    val phone: Phone
        get()  = SmartPhone("Pixel 5", "Android")
}

В соответствии с вторым правилом опять же к такому свойству не применяются smart-преобразования, так как оно имеет геттер.

Явные преобразования и оператор as

С помощью оператора as мы можем приводить значения одного типа к другому типу:

значение as тип_данных

Слева от оператора указывается значение, а справа — тип данных, в которых надо преобразовать значение. Например, преобразуем значение типа String? в тип String:

fun main() {

    val hello: String? = "Hello Kotlin"
    val message: String = hello as String
    println(message)
}

Здесь переменная hello хранит строку и может быть удачно преобразована в значение типа String. Однако если переменная hello равна null:

val hello: String? = null
val message: String = hello as String
println(message)

В этом случае преобразование завершится неудачно — ведь значение null нельзя преобразовать в значение типа String. Поэтому будет сгенерировано исключение ClassCastException.

Чтобы избежать генерации исключения мы можем применять более безопасную версию оператора as?, которая в случае неудачи преобразования возвращает null.

val hello: String? = null
    val message: String? = hello as? String
    println(message)

В данном случае оператор as? возвратит null, так как строку нельзя преобразовать в число.

Также можно применять данный оператор к преобразованиям своих типов:

fun main() {

    val tom = Person("Tom")
    val bob = Employee("Bob", "JetBrains")
    checkCompany(tom)
    checkCompany(bob)
}
fun checkCompany(person: Person){
    val employee = person as? Employee
    if (employee!=null){
        println("${employee.name} works in ${employee.company}")
    }
    else{
        println("${person.name} is not an employee")
    }
}
open class Person(val name: String)
open class Employee(name: String, var company: String): Person(name)

Здесь функция checkCompany() принимает объект класса Person и пытается преобразовать его в объект типа Employee, который унаследован от Employee. Но если каждый объект Employee представляет также объект Person (каждый работник является человеком), то не каждый объект Person представляет объект Employee (не каждый человек является работником). И в этом случае чтобы получить значение типа Employee, применяется оператор as?. Если объект person представляет тип Employee, то возвращается объект этого типа, иначе возвращается null. И далее мы можем проверить на значение null и выполнить те или иные действия.

Консольный вывод программы:

Tom is not an employee
Bob works in JetBrains

parseInt() — JavaScript | MDN

Функция parseInt() принимает строку в качестве аргумента и возвращает целое число в соответствии с указанным основанием системы счисления.

The source for this interactive example is stored in a GitHub repository. If you’d like to contribute to the interactive examples project, please clone https://github.com/mdn/interactive-examples and send us a pull request.

Параметры

string

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

radix

Целое число в диапазоне между 2 и 36, представляющее собой основание системы счисления числовой строки string, описанной выше. В основном пользователи используют десятичную систему счисления и указывают 10. Всегда указывайте этот параметр, чтобы исключить ошибки считывания и гарантировать корректность исполнения и предсказуемость результата. Когда основание системы счисления не указано, разные реализации могут возвращать разные результаты.

Возвращаемое значение

Целое число, полученное парсингом (разбором и интерпретацией) переданной строки. Если первый символ не получилось сконвертировать в число, то возвращается NaN. 

Функция parseInt преобразует первый переданный ей аргумент в строковый тип, интерпретирует его и возвращает целое число или значение NaN. Результат (если не NaN) является целым числом и представляет собой первый аргумент (string), рассматривающийся как число в указанной системе счисления (radix). Например, основание 10 указывает на преобразование из десятичного числа, 8 — восьмеричного, 16 — шестнадцатеричного и так далее. Если основание больше 10, то для обозначения цифр больше 9 используются буквы. Например, для шестнадцатеричных чисел (основание 16) используются буквы от A до F.

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

Так как некоторые числа включают символ e в своём строковом представлении (например, 6.022e23), то использование parseInt для усечения числовых значений может дать неожиданные результаты, когда используются очень малые или очень большие величины. parseInt не должна использоваться как замена для Math.floor().

Если основание системы счисления имеет значение undefined (не определено) или равно 0 (или не указано), то JavaScript по умолчанию предполагает следующее:

• Если значение входного параметра string начинается с «0x» или «0X«, за основание системы счисления принимается 16, и интерпретации подвергается оставшаяся часть строки.
• Если значение входного параметра string начинается с «0», за основание системы счисления принимается либо 8, либо 10, в зависимости от конкретной реализации. В спецификации ECMAScript 5 прописано использование 10 (десятичная система), но это поддерживается ещё не всеми браузерами, поэтому необходимо всегда указывать основание системы счисления при использовании функции parseInt.
• Если значение входного параметра string начинается с любого другого символа, система счисления считается десятичной (основание 10).

Если первый символ строки не может быть преобразован в число, parseInt возвращает значение NaN.

С точки зрения математики, значение NaN не является числом в какой-либо системе счисления. Чтобы определить, вернёт ли parseInt значение NaN в качестве результата, можно вызвать функцию isNaN. Если NaN участвует в арифметических операциях, результатом также будет NaN.

Для преобразования числа в строку в указанной системе счисления, используйте intValue.toString(radix).

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

Все следующие примеры возвращают 15:

parseInt(" 0xF", 16);
parseInt(" F", 16);
parseInt("17", 8);
parseInt(021, 8);
parseInt("015", 10);  
parseInt(15.99, 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15*3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

Все следующие примеры возвращают NaN:

parseInt("Hello", 8); 
parseInt("546", 2);   

Все следующие примеры возвращают -15:

parseInt("-F", 16);
parseInt("-0F", 16);
parseInt("-0XF", 16);
parseInt(-15.1, 10)
parseInt(" -17", 8);
parseInt(" -15", 10);
parseInt("-1111", 2);
parseInt("-15e1", 10);
parseInt("-12", 13);

Все следующие примеры возвращают 4:

parseInt(4.7, 10);
parseInt(4.7 * 1e22, 10); 
parseInt(0.00000000000434, 10); 

Следующий пример возвращает 224:

Хотя это не поощряется в спецификацией ECMAScript 3 и запрещено в ECMAScript 5, многие реализации интерпретируют числовую строку, начинающуюся с 0, как восьмеричную. Следующий пример может иметь как восьмеричный, так и десятичный результат. Чтобы избежать непредвиденного результата, всегда указывайте основание системы счисления.

parseInt("0e0"); 
parseInt("08"); 

ECMAScript 5 устраняет восьмеричную интерпретацию

Спецификация ECMAScript 5 функции parseInt больше не разрешает трактовать в восьмеричной системе счисления строки, начинающиеся с 0. ECMAScript 5 провозглашает:

Функция parseInt производит целочисленное значение в результате интерпретации содержимого строкового аргумента в соответствии с указанным основанием системы счисления. Пробел в начале строки не учитывается.(\-|\+)?([0-9]+|Infinity)$/.test(value)) return Number(value); return NaN; } console.log(filterInt(‘421’)); console.log(filterInt(‘-421’)); console.log(filterInt(‘+421’)); console.log(filterInt(‘Infinity’)); console.log(filterInt(‘421e+0’)); console.log(filterInt(‘421hop’)); console.log(filterInt(‘hop1.61803398875’)); console.log(filterInt(‘1.61803398875’));

BCD tables only load in the browser

C# конвертация числа в строку (int, double, short, … → string) с необходимой точностью

Новое приложение для изучения C#

Отладка кода

Типы данных C#

Хранение объектов в памяти. Удаление объектов из памяти

C# конвертация типов

Текст в C# (тип string и класс String)

Перечисления в C# (enum)

null

try-catch

Классы в C# (class)

Конструкторы для класса

Деструкторы для класса

Наследование

Наследование с использованием new

Наследование с использованием sealed

Абстрактный класс

Константы и readonly поля в классе

Свойства get и set в классе C# (аксессоры)

Операторы, индексаторы в C#

Вложенные типы в C#

Параметры в методе класса C#

Универсальные методы, универсальные классы в C# (шаблоны)

Преобразование объекта класса из одного типа в другой

Объект класса в C#

Статический конструктор и статические свойства и методы

Дополнительные возможности класса в C#

Правила именования классов в C#

Статический класс

Анонимный класс

Интерфейсы

Структура struct

Преобразование объекта структуры из одного типа в другой

Отложенная загрузка class Lazy в C#

Кортежи (tuple)

Динамические объекты с любыми свойствами

Массивы

Коллекции

Классы необобщенных коллекций (в одной коллекции хранятся элементы разного типа)

Класс ArrayList (коллекция в C#)

Класс SortedList (коллекция в C#)

Класс Stack (коллекция в C#)

Класс Queue (коллекция в C#)

Класс Hashtable (коллекция в C#)

Класс BitArray (коллекция в C#)

Классы обобщенных, типизированных коллекций в C# (в одной коллекции хранятся элементы одного типа)

Класс List<T> (типизированная коллекция в C#)

Класс LinkedList<T> (типизированная коллекция в C#)

Класс SortedList<TKey, TValue> (типизированная коллекция в C#)

Класс Stack<T> (типизированная коллекция в C#)

Класс Queue<T> (типизированная коллекция в C#)

Класс HashSet<T> (типизированная коллекция в C#)

Класс SortedSet<T> (типизированная коллекция в C#)

Класс ObservableCollection<T> (типизированная коллекция в C#)

Класс Dictionary<TKey, TValue> (типизированная коллекция в C#)

Класс SortedDictionary<TKey, TValue> (типизированная коллекция в C#)

Класс ConcurrentDictionary<TKey, TValue> (типизированная коллекция в C#)

Асимптотическая сложность для добавления, удаления, взятия элемента в коллекциях

Сортировка элементов в массиве [] и коллекции List

Моя реализация IEnumerator, IEnumerable и итераторы

Методы расширения для IEnumerable (поиск, замена, выборка значений) в C#

Сортировка, фильтрация в LINQ (Language-Integrated Query)

Указатели

Работа с файлами

Сериализация

Пространства имен

Delegate

Универсальные делегаты

События

Лямда

Регулярные выражения

Процесс, модули процесса

Потоки, многопоточность

Parallel Library Task (TPL) Параллельное программирование задач

Асинхронные методы (async и await)

Домены приложений

Атрибуты

Рефлексия (отражение) reflection в C#

Директивы препроцессора (if при компиляции)

Что такое сборка и исполняющая среда CLR ?

Создание и подключение нашей сборки

▷

База данных (Entity Framework) в консольном приложении C#

Внедрение зависимостей (Dependency Injection) DI в C#

Удобные утилиты Visual Studio

В приложении C# вызываем C++ функции

Дополнительные темы, вопросы

Математические операторы checked и unchecked

Дополнительный C# классы

Время

WWW сайты для изучения C#

Python. Средства преобразования строк и одиночных символов.

Средства преобразования строк и одиночных символов. Функции int(), str(), repr(), float(), ord(), chr()

Содержание

Поиск на других ресурсах:

1. Функция int(). Преобразование в целое число

Функция int() есть конструктором класса int. Эта функция возвращает целочисленный объект, который может быть образован из:

• целого числа или объекта;
• числа или объекта с плавающей запятой;
• строки символов или строчного объекта, содержащего последовательность цифр.

Функция может вызваться одним из двух способов:

• int() – в этом случае функция возвращает значение 0;
• int(x, base) – в этом случае обрабатывается объект x. Значение base определяет систему исчисления, в которую нужно конвертировать объект x. По умолчанию base = 10. Если явным образом задана система исчисления, то тип объекта x должен быть строчным, другие типы в этом случае запрещаются.

Пример.

# Функция int()
# 1. Вызов без параметров
a = int() # a = 0

# 2. Вызов с целочисленным значением
a = int(15) # a = 15

# 3. Вызов с числом с плавающей запятой
a = int(2.85) # a = 2

# 4. Вызов со строкой
s = '28'
a = int(s) # a = 28

# 5. Вызов с конвертированием в другую систему исчисления - только для строк

# конвертировать 155 из 16-й системы в десятичную
s = '155'
a = int(s, 16) # a = 341, значение 155 в 16-й системе

# конвертировать 111 из двоичной системы в десятичную
s = '111'
a = int(s, 2) # a = 7

# 6. Так нельзя
# a = int(111,2) - ошибка, нельзя конвертировать число, должна быть строка

  ⇑

2. Функция str(). Преобразование в строку

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

Функция имеет две реализации:

• str() – без параметров. В этом случае функция возвращает пустую строку;
• str(x) – с параметром x. Параметр x есть объектом некоторого типа. Данный вызов может также содержать еще два дополнительных параметра, которые определяют систему кодирования (по умолчанию система кодирования устанавливается utf-8) и схему обработки ошибок (по умолчанию установлена схема вызова исключения типа UnicodeError).

Результат функции str() может использоваться для вывода в функции print().

Пример.

# Функция str()
# 1. Вызов с целым числом
x = 25
s = str(x) # s = '25' - строка символов

# 2. Вызов с числом с плавающей запятой
y = 2.338
s = str(y) # s = '2.338'

# 3. Вызов со строкой
s = str("3.778") # s = '3.778'

# 4. Вызов со строкой, которая не отображает число
s = str("abcdef") # s = 'abcdef'

# 5. Вызов без параметров
s = str() # s = ''

  ⇑

3. Функция repr(). Преобразование в строку как литерал

Функция repr() реализует преобразование в строку таким образом, если бы эта строка была литералом в программном коде.
Функция repr() может быть применена к:

• целым числам;
• числам с плавающей запятой;
• строкам символов.

Пример 1. Конвертировать целое число в строку, которая представлена литералом.

# Функция repr()

# конвертировать целое число в строку
number = 25
snumber = repr(number) # snumber = '25' - как строка символов

number = -100029
snumber = repr(number) # snumber = '-100029' - как строка символов

Пример 2. Конвертировать в строку число с плавающей запятой.

# Функция repr()
# конвертировать число с плавающей запятой в строку
number = 25.233
snumber = repr(number) # snumber = '25.233'

snumber = repr(-1e-2) # snumber = '-0.01'

Пример 3. Конвертировать строку символов в другую строку так если бы она была литералом.

# Функция repr()
# конвертировать строку в строку
s1 = 'Text string'
s2 = repr(s1) # s2 = "'Text string'"

s1 = "Text string"
s2 = repr(s1) # s2 = "'Text string'"

Пример 4. Конвертирование кортежа.

# Функция repr() - обработка кортежа
x = ( 2.85, 15, 'Hello')
str_x = repr(x) # str_x = "(2.85, 15, 'Hello')"

  ⇑

4. Какое отличие между функциями repr() и str()?

В языке Python функции repr() и str() преобразуют произвольные объекты в их строчное представление.

Разница между функциями проявляется в том, как они конвертируют строку.
Функция repr() возвращает представление строчного объекта в виде строки программного кода, которую можно выполнить чтобы воссоздать этот объект. Иными словами, функция repr() возвращает строку в виде строки. При использовании такого объекта в функции print() будут выведены ограничивающие строку кавычки (строка во вложенных кавычках).
В свою очередь, функция str() используется для конвертирования строки в строку без ее преобразования в предшествующую форму. При использовании результата функции str() в функции print() будет выведена обычная строка в одинарных кавычках.

Например.

# Функции repr() и str()
# конвертировать строку в строку
s1 = 'Text string'

# функция repr()
s2 = repr(s1) # s2 = "'Text string'"

# функция str()
s3 = str(s1) # s3 = 'Text string'

Как видно из вышеприведенного кода, функция repr() возвращает строку как литерал

"'Text string'"

а функция str() возвращает обычную строку

'Text string'

  ⇑

5. Функция float(). Преобразование в число с плавающей запятой

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

• float() – без параметра. В этом случае возвращается значение 0.0;
• float(x) – где параметр x задает число или строку, которую нужно конвертировать.

В качестве входного параметра или исходного результата функция может использовать грамматические символы:

• «Infinity» или «inf» – обозначают бесконечность. Бесконечность может быть отрицательной: «-Infinity» или «-inf»;
• «nan» – обозначает неопределенность.

Пример.

# Функция float() - возвращает число с плавающей запятой
# 1. Результат получается из числа
a = 25 # целое число
x = float(a) # x = 25.0

b = 21.555e-2 # число с плавающей запятой
x = float(b) # x = 0.21555

# 2. Результат получается из строки
# s = 'abcdef' - ошибка, строка не имеет вида числа
# x = float(s)

# строка в экспоненциальном формате
s = '-1.23e-2'
x = float(s) # x = -0.0123

# строка в обычном формате
s = "288.75"
x = float(s) # x = 288.75 - как число

# использование в выражении
x = float(5.2)+float(3.8)*float(-2.1) # x = -2.7799999999999994

# использование со знаком +
x = float('+2.34') # x = 2.34

# использование со словом "Infinity" или "inf"
x = float("Infinity") # x = inf
x = float('-inf') # x = -inf - с отрицательным знаком

# использование со словом "nan"
x = float("nan") # x = nan

x = float() # x = 0.0

  ⇑

6. Функции ord() и chr(). Преобразование кодов символов

Функции ord() и chr() используются для одиночных символов. Эти функции являются инверсными друг к другу.
Функция chr() позволяет получать символ на основе его кода. Функция ord() позволяет получить код на основе представления символа.

Общая форма вызова функции chr() следующая

c = chr(i)

где c – символьное представление символа с Unicode-кодом i.

Общая форма вызова функции ord()

i = ord(c)

где i – код символа c.

Пример.

# Функции chr() и ord()
# 1. Функция chr()
code = 49 # код в десятичной системе исчисления
symbol = chr(code) # symbol = '1' - цифра '1'

code = 100
symbol = chr(code) # symbol = 'd'

code = 7785
symbol = chr(code) # symbol = 'ṩ' - кодирование Unicode

# 2. Функция ord
symbol = '5'
code = ord(symbol) # code = 53

symbol = 'ṩ'
code = ord(symbol) # code = 7785

symbol = ' ' # символ пробел
code = ord(symbol) # code = 32

  ⇑

7. Можно ли в Python сложить строку с числом?

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

Пример.

# Сложить строку с числом не получится
s = '25' # это строка
a = 30 # это число

# Случай 1. Сложить (суммировать) два числа
# Предварительно нужно конвертировать строку в число
b = int(s)
res = a + b
print('As numbers: a + s = ', res)

# Случай 2. Сложить две строки
# Предварительно нужно конвертировать число в строку
res_str = str(a) + s
print('As strings: a + s = ', res_str)

Результат выполнения программы

As numbers: a + s = 55
As strings: a + s = 3025

  ⇑

Связанные темы

  ⇑

Как из double перевести в int java

Подскажите, как конвертировать double в int ?

4 ответа 4

Сама конвертация не сложна:

Т.е. инструкция в общем виде выглядит так:

Но тут, есть подводные камни, а именно – тип int содержит значения в диапазоне от -2147483648 до 2147483647 , притом что они являются целочисленные, т.е. без дробной части. А double содержит числа в диапазоне от 4.9E-324 до 4.9E-324 . Т.е. при конвертации может произойти переполнение и/или не учитывание дробной части.

Для более гибкого преобразования стоит использовать классы BigDecimal и BigInteger .

Если нужно округлять вверх или вниз, используйте Math.round()

Округляем в нужную сторону.

UP — округление в сторону большего числа для положительных чисел и меньшего для отрицательных.
DOWN — округление в сторону меньшего числа для положительных чисел и большего для отрицательных.
CEILING — округление в сторону большего и для положительных, и для отрицательных чисел.
FLOOR — округление в сторону меньшего и для положительных, и для отрицательных чисел.
HALF_UP — округление в большую сторону в случае числа вида 0.5
HALF_DOWN — округление в меньшую сторону в случае числа вида 0.5
HALF_EVEN — классическое округление

Ссылка на документацию >>>

Всё ещё ищете ответ? Посмотрите другие вопросы с метками java double или задайте свой вопрос.

Похожие

Для подписки на ленту скопируйте и вставьте эту ссылку в вашу программу для чтения RSS.

дизайн сайта / логотип © 2019 Stack Exchange Inc; пользовательское содержимое попадает под действие лицензии cc by-sa 4.0 с указанием ссылки на источник. rev 2019.11.15.35459

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

В следующих примерах будет использована конструкция try-catch. Это необходимо для обработки ошибки, в случае, если строка содержит иные символы кроме чисел или число, выходящее за рамки диапазона допустимых значений определенного типа.

Например, строка «somenumber» не может быть переведена в тип int или в любой другой числовой тип. В это случае, при компеляции возникнет ошибка. Чтобы этого избежать, следует обезопаситься с помощью конструкции try-catch.

C использованием конструктора

С использованием метода valueOf класса Byte

С использованием метода parseByte класса Byte

Перевод строки в массив байтов и обратно из массива байтов в строку

C использованием конструктора

C использованием метода valueOf класса Short

C использованием метода parseShort класса Short

C использованием конструктора

C использованием метода valueOf класса Integer

C использованием метода parseInt класса Integer

C использованием конструктора

C использованием метода valueOf класса Long

C использованием метода parseLong класса Long

С использованием конструктора

C использованием метода valueOf класса Float

C использованием метода parseFloat класса Float

С использованием конструктора

C использованием метода valueOf класса Double

C использованием метода parseDouble класса Double

Преобразование строки в логический тип 2мя способами. Обратите внимание, что строка не соответствующая true, будет преобразована в логическое значение false.

By Chaitanya Singh | Filed Under: Java Conversion

In this java tutorial, we will see how to convert int to double in Java. Since double has longer range than int data type, java automatically converts int value to double when the int value is assigned to double.

1. Java implicit conversion from int to double without typecasting.
2. Java – Convert int to double using Double wrapper class.

1. Java implicit conversion from int to double without typecasting

Since double data type has wider range and greater memory size than int, the conversion from int to double is implicit. As you can see we have not done the typecasting like we did in double to int conversion in Java.

Output:

2. Java – Convert int to double using Double wrapper class

In this example we are doing the int to double conversion using the valueOf() method of Double wrapper class. This method accepts the other type value as parameter and returns the same value converted in double type.

Output:

Преобразование примитивных типов в Java

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

В Java возможны преобразования между целыми значениями и значениями с плавающей точкой. Кроме того, можно преобразовывать значения целых типов и типов с плавающей точкой в значения типа char и наоборот, поскольку каждый символ соответствует цифре в кодировке Unicode. Фактически тип boolean является единственным примитивным типом в Java, который нельзя преобразовать в другой примитивный тип. Кроме того, любой другой примитивный тип нельзя преобразовать в boolean.

Преобразование типов в Java бывает двух видов: неявное и явное.

Неявное преобразование типов выполняется в случае если выполняются условия:

1. Оба типа совместимы
2. Длина целевого типа больше или равна длине исходного типа

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

Так же существуют два типа преобразований:

1. Расширяющее преобразование (widening conversion)
2. Сужающее преобразование (narrowing conversion)

Расширяющее преобразование (widening conversion) происходит, если значение одного типа преобразовывается в более широкий тип, с большим диапазоном допустимых значений. Java выполняет расширяющие преобразования автоматически, например, если вы присвоили литерал типа int переменной типа double или значение пепременной типа char переменной типа int. Неявное преобразование всегда имеет расширяющий тип.

Но у тут могут быть свои небольшие грабельки. Например если преобразуется значение int в значение типа float. И у значения int в двоичном представлении больше чем 23 значащих бита, то возможна потеря точности, так как у типа float под целую часть отведено 23 бита. Все младшие биты значения int, которые не поместятся в 23 бита мантиссы float, будут отброшены, поэтому хотя порядок числа сохраниться, но точность будет утеряна. То же самое справедливо для преобразования типа long в тип double.

Расширяющее преобразование типов Java можно изобразить еще так:

Сплошные линии обозначают преобразования, выполняемые без потери данных. Штриховые линии говорят о том, что при преобразовании может произойти потеря точности.

Стоит немного пояснить почему, к примеру тип byte не преобразуется автоматически (не явно) в тип char, хотя тип byte имеет ширину 8 бит, а char 16, тоже самое касается и преобразования типа short в char. Это происходит потому, что byte и short знаковые типы данных, а char без знаковый. Поэтому в данном случае требуется использовать явное приведение типов, поскольку компилятору надо явно указать что вы знаете чего хотите и как будет обрабатываться знаковый бит типов byte и short при преобразовании к типу char.

Поведение величины типа char в большинстве случаев совпадает с поведением величины целого типа, следовательно, значение типа char можно использовать везде, где требуются значения int или long. Однако напомним, что тип char не имеет знака, поэтому он ведет себя отлично от типа short, несмотря на то что диапазон обоих типов равен 16 бит.

short s = ( short) 0xffff; // Данные биты представляют число –1
char c = ‘\uffff’; // Те же биты представляют символ юникода
int i1 = s; // Преобразование типа short в int дает –1
int i2 = c; // Преобразование char в int дает 65535

Сужающее преобразование (narrowing conversion) происходит, если значение преобразуется в значение типа, диапазон которого не шире изначального. Сужающие преобразования не всегда безопасны: например, преобразование целого значения 13 в byte имеет смысл, а преобразование 13000 в byte неразумно, поскольку byte может хранить только числа от −128 до 127. Поскольку во время сужающего преобразования могут быть потеряны данные, Java компилятор возражает против любого такого преобразования, даже если преобразуемое значение укладывается в более узкий диапазон указанного типа:

int i = 13;
byte b = i; // Компилятор не разрешит это выражение

Единственное исключение из правила – присвоение целого литерала (значения типа int) переменной byte или short, если литерал соответствует диапазону переменной.

Сужающее преобразование это всегда явное преобразование типов.

Явное преобразование примитивных типов

Оператором явного преобразования типов или точнее говоря приведения типов являются круглые скобки, внутри которых указан тип, к которому происходит преобразование – (type). Например:

int i = 13;
byte b = (byte) i; // Принудительное преобразование int в byte
i = (int) 13.456; // Принудительное преобразование литерала типа double в int 13

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

При приведении более емкого целого типа к менее емкому старшие биты просто отбрасываются. По существу это равнозначно операции деления по модулю приводимого значения на диапазон целевого типа (например для типа byte это 256).

Слишком большое дробное число при приведении к целому превращается в MAX_VALUE или MIN_VALUE.

Слишком большой double при приведении к float превращается в Float.POSITIVE_INFINITY или Float.NEGATIVE_INFINITY.

Таблица представленная ниже представляет собой сетку, где для каждого примитивного типа указаны типы, в которые их можно преобразовать, и способ преобразования. Буква N в таблице означает невозможность преобразования. Буква Y означает расширяющее преобразование, которое выполняется автоматически. Буква С означает сужающее преобразование, требующее явного приведения. Наконец, Y* означает автоматическое расширяющее преобразование, в процессе которого значение может потерять некоторые из наименее значимых разрядов. Это может произойти при преобразовании int или long во float или double. Типы с плавающей точкой имеют больший диапазон, чем целые типы, поэтому int или long можно представить посредством float или double. Однако типы с плавающей точкой являются приближенными числами и не всегда могут содержать так много значащих разрядов в мантиссе, как целые типы.

Автоматическое расширение типов в выражениях

Так же стоит еще раз упомянуть об автоматическом повышении (расширении) типов в выражениях. Мы с этим уже сталкивались когда рассматривали целочисленные типы данных и операции над ними, но все же стоит и тут напомнить, чтобы усвоилось еще лучше и к тому же это имеет непосредственное отношение к данной теме. В примере ниже знак @ означает любой допустимый оператор, например +, –, *, / и т.п.

То есть, все целочисленные литералы в выражениях, а так же типы byte, short и char расширяются до int. Если, как описано выше, в выражении не присутствуют другие, более большие типы данных (long, float или double). Поэтому приведенный выше пример вызовет ошибку компиляции, так как переменная c имеет тип byte, а выражение b+1, в результате автоматического повышения имеет тип int.

Неявное приведение типов в выражениях совмещенного присваивания

Хоть данный раздел и относится к неявному преобразованию (приведению) типов, его объяснение мы привели тут, поскольку в данном случае так же работает и автоматическое расширение типов в выражениях, а затем уже неявное приведение типов. Вот такой кордебалет. Пример ниже я думаю все разъяснит. Так же как и в предыдущем объяснении знак @ означает любой допустимый оператор, например +, –, *, / и т.п.

Это стоит пояснить на простом примере:

byte b2 = 50;
b2 = b2 * 2; // не скомпилируется
b2 *= 2; //скомпилируется, хотя и равнозначна b2 = b2 * 2

Вторя строка, приведенная в примере не скомпилируется из-за автоматического расширения типов в выражениях, так как выражение b2*2 имеет тип int, так как происходит автоматическое расширение типа (целочисленные литералы в выражении всегда int). Третья же строка спокойно скомпилируется, так как в ней сработает неявное приведение типов в совмещенном выражении присваивания.

Boxing/unboxing – преобразование примитивных типов в объекты обертки

Boxing и unboxin – это тоже достаточно большая тема, но она достаточно простая.

По существу boxing и unboxing это преобразование примитивных типов в объекты обертки и обратно.

Для объектов оберток примитивных типов применимо все что было сказано выше.

Об классах обертках упоминалось в таблицах, при разборе каждого из примитивных типов. Но тогда это было лишь упоминание в таблице.

Так вот, для каждого примитивного типа есть его старший брат, и он совсем не примитивный, а является настоящим классом, с полями и методами. И для каждой такой парочки возможно автоматическое преобразование.

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

Приведу простой пример:

int i3;
byte b2=3;
Byte myB;
myB=b2;
myB++;
b2=myB;
i3=myB;

Если пока не понятно зачем это нужно, то это не страшно, просто завяжите узелок на память.

6 способов преобразования Java int (float, double) в String с 9 примерами

В Java вы можете использовать несколько способов преобразования чисел (int, float, double и т. Д.) В строку. Для конвертации можно использовать следующие методы:

Предпочтительные и общие способы преобразования в Java:

• toString ()
• стоимость
• Оператор конкатенации строк (+)

Другие способы преобразования чисел в строку:

• формат ()
• StringBuffer
• StringBuilder

Преобразование с помощью toString (), пример valueOf, StringBuilder, пример

Каждый из этих способов поясняется ниже с примерами преобразования чисел (int или float и double) в строку.

Метод toString () класса Integer может использоваться для преобразования примитивного объекта типа int или Integer в строку. Вот как вы можете использовать этот метод:

Для int в строку:

toString (интервал i)

Для преобразования целочисленного объекта в строку:

Integer.toString (Integer_Object)

См. Следующий код для использования toString обоими способами:

Вы видели, объявлены переменные типа int и другие целые числа.Они присваиваются строковым переменным после преобразования в строки с помощью метода valueOf.

Аналогичным образом вы можете использовать метод toString класса Float для преобразования примитивного числа с плавающей запятой или объекта с плавающей запятой в строку.

См. Следующий пример, где float (примитив) и объект Float заменяются на строку с помощью метода valueOf:

Поплавок для перемешивания = 50.55

Поплавок для перемешивания = 66,45

Класс Double также имеет метод toString (), который можно использовать для преобразования объектов double (примитивный тип) и Double в строку. См. Демонстрацию ниже:

Atter double to перемешивание = 50.55

Atter Double для перемешивания = 15,5

Другой предпочтительный метод преобразования чисел в строку — это метод String class valueOf () . Используя метод String valueOf (), вы можете преобразовать любое из них:

• Примитивный тип int для строки
• Целочисленный объект в строку
• Примитив длинного типа в строку
• Длинный объект для строкового типа
• Примитивный поплавок к строке
• Плавающий объект в строку
• двойная к струне
• Двойной объект для строки и т. Д.

См. Следующий пример, где все эти типы данных используются для преобразования в строки:

Знак плюс (+) — это оператор конкатенации строк, который также используется для преобразования объектов в строки.Java предоставляет специальную поддержку для этого оператора.

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

См. Следующий пример, в котором строка создается на основе значений переменных типа int, float и double с помощью оператора +:

Строка: 77 24.7 475474,52

В приведенном выше примере мы использовали примитивные типы для преобразования. Точно так же вы можете использовать объекты для преобразования в строку, используя оператор +. Это показано в демонстрации ниже. Там я создал три объектных переменных:

Строка с числовыми объектами: 35 45.5 4547457,25

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

См. Демонстрацию ниже, в которой преобразовывается не только int, но и другие типы данных с помощью метода format () String.

int -> Строка по формату () = 1005

float -> Строка по формату () = 105.500000

double -> Строка по формату () = 1241214.524000

Отображать только 2 цифры после десятичной точки = 124 1214,52

Вы можете видеть, плавать и удваивать с разной точностью, также преобразованные в строки.

Что ж, использование этих классов для преобразования int или других типов в строки может быть полезно, если вы работаете с изменяемыми строками. Классы StringBuffer и StringBuilder позволяют создавать строку, которую можно изменять, поскольку; строки класса String неизменяемы в Java.

Я не буду вдаваться в подробности того, что такое классы StringBuffer или StringBuilder, так как это отдельная тема, но взглянем на приведенные ниже примеры. Во-первых, с помощью класса StringBuffer для преобразования int в строку (вместе с преобразованием с плавающей точкой и двойным преобразованием). Далее следует пример класса StringBuilder.

С классом StringBuffer:

Последняя строка:

Добавим int = 10 и число с плавающей запятой: 525.2 и, наконец, двойной: 1415414.14

Давайте добавим int = 10 и float: 525.2 и, наконец, double: 1415414.14

Разница между классами StringBuilder и StringBuffer заключается в том, что StringBuffers безопасны для использования несколькими потоками, в то время как StringBuilder не гарантирует синхронизации.

Что касается нашей темы о преобразовании в строки, если вы просто измените объект в приведенном выше примере с StringBuffer на StringBuilder, он даст тот же результат.См. Код и вывод ниже:

Я изменил только имена и значения переменных.

Преобразование числа в строку JavaScript

 a = a + '' // Это преобразует a в строку
b + = '' // Это преобразует b в строку

5.41 + '' // Результат: строка 5.41
Math.PI + '' // Результат: строка '3.1415
589793'
 

a = a.toString () // Преобразует a в строку
b = b.toString () // Преобразует b в строку

(5.41) .toString () // Результат: строка 5.41
(Math.PI) .toString () // Результат: строка '3.1415
589793'
 

Авторские права © 1999-2012, JavaScripter.сеть.

5 различных программ Java для преобразования двойного значения в строку без экспоненты

Введение:

В Java мы можем преобразовать двойное значение в строку с помощью встроенной функции String.valueOf () . Это даст тот же желаемый результат, т.е. мы получим то же строковое значение, что и вход. Но иногда он может возвращать строку с экспоненциальной составляющей или в экспоненциальной нотации. Позвольте мне показать вам пример ниже:

  public class Main {
    public static void main (String [] args) {
        двойное число1 = 12;
        двойное число2 = 0.054;
        двойное число3 = 0,000047823458;

        System.out.println (String.valueOf (число1));
        System.out.println (String.valueOf (число2));
        System.out.println (String.valueOf (число3));
    }
}  

Выход:

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

Есть несколько способов выполнить преобразование двухстрочного кода в . Позвольте мне показать вам один за другим:

Using String.format ():

Мы можем отформатировать двойное число с помощью метода String.format () . Он принимает два аргумента: первый — это строка формата, а второй — это один или несколько объектов, которые необходимо отформатировать.

  public class Main {
    public static void main (String [] args) {
        двойное число = 12.000047823458;

        System.out.println (String.format ("% f", число));
        System.out.println (String.format ("%. 0f", число));
        System.out.println (String.format ("%.12f ", номер));
    }
}  

В этом примере мы использовали три разных способа форматирования одного и того же значения типа double. Он напечатает следующий результат:

  12.000048
12
12.000047823458  

Как видите, двойное число полностью форматируется в строку только для % .12f . Потому что мы упомянули метод форматирования, что нам нужно 12 значений после десятичной дроби. Этот метод полезен, если вы знаете, сколько десятичных знаков находится справа от десятичной точки.

Использование Double.toString ():

Класс Double имеет встроенный метод toString () метод для преобразования двойного значения в строку. Это не добавит экспоненциальной составляющей к преобразованию.

  public class Main {
    public static void main (String [] args) {
        двойное число = 12.000047823458;

        System.out.println (Double.toString (число));
    }
}  

Вывод:

Добавление пустой строки:

Это самый простой способ преобразовать двойное число в строку.Просто добавьте одну пустую строку, и она преобразуется в строку. Как показано ниже:

  public class Main {
    public static void main (String [] args) {
        двойное число = 12.000047823458;
        Строка numberInString = number + "";

        System.out.println (numberInString);
    }
}  

Результат будет таким же.

Использование DecimalFormat:

DecimalFormat принимает один шаблон и на основе этого шаблона форматирует входное число и возвращает строковое представление отформатированного числа.Например:

  import java.text.DecimalFormat;

public class Main {
    public static void main (String [] args) {
        двойное число = 12.000047823458;

        Шаблон строки = "##. ############";
        DecimalFormat decimalFormat = новый DecimalFormat (шаблон);

        System.out.println (decimalFormat.format (число));
    }
}  

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

  импорт java.text.DecimalFormat;

public class Main {
    public static void main (String [] args) {
        двойное число = 12.164547823458;

        Шаблон строки = "##. ##";
        DecimalFormat decimalFormat = новый DecimalFormat (шаблон);

        System.out.println (decimalFormat.format (число));
    }
}  

Будет напечатано 12.16 в качестве вывода.

Заключение:

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

сообщить об этом объявлении Похожие руководства:

Python String to Int () и Int to String Учебное пособие

Как преобразовать строку Python в Int:
Чтобы преобразовать строку в целое число в Python, используйте функцию int () .Эта функция принимает два параметра: начальную строку и необязательную базу для представления данных. Используйте синтаксис print (int ("STR")) , чтобы вернуть str как int или целое число.

Как преобразовать Python Int в строку:
Чтобы преобразовать целое число в строку в Python, используйте функцию str () . Эта функция принимает любой тип данных и преобразует его в строку, включая целые числа. Используйте синтаксис print (str (INT)) , чтобы вернуть int как str или строку.

Python включает ряд типов данных, которые используются для различения определенного типа данных. Например, строки Python используются для представления текстовых данных, а целые числа могут представлять целые числа. При программировании вам может потребоваться преобразовать значения между разными типами данных, чтобы вы могли работать с ними по-разному.

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

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

Типы данных Python

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

Это важно, потому что каждым типом данных можно управлять по-разному. Таким образом, Python необходимо хранить разные типы данных, используя разные типы данных. В Python есть несколько типов данных, которые используются для хранения данных, включая числа, логические значения и списки.

В этой статье мы сосредоточимся на двух из этих типов данных: строках и числах.

В Python строки заключаются в одинарные или двойные кавычки и используются для представления текстовой информации.Вот пример строки:

 text_data = "Эта строка содержит текстовые данные." 

Числовой тип данных используется для хранения как десятичных, так и целых чисел. Десятичные числа будут автоматически преобразованы в число с плавающей запятой, а целые числа будут считаться целыми. Вот пример целого числа и числа с плавающей запятой в Python:

 example_integer = 22
example_float = 2,22 

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

Строка Python в Int

Метод int () можно использовать для преобразования строки в целочисленное значение в Python.

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

Метод возвращает значение, которое вы передали через int () , представленное как целое число.Вот синтаксис метода Python int () :

Вот пример использования метода int () для преобразования строки в целое число:

Наш код возвращает:

Пример строки для Int в действии

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

Давайте создадим программу, которая выполняет эту функцию. Начнем с использования метода input () , чтобы получить возраст пользователя:

 raw_user_age = input («Сколько тебе лет?»)
печать (raw_user_age) 

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

Пользователь ввел значение 12 .Это может выглядеть как число. Однако, когда мы используем метод type () для проверки типа данных на возраст нашего пользователя, мы видим, что это не число. Мы можем использовать следующий код, чтобы проверить тип данных возраста нашего пользователя:

 печать (тип (raw_user_age)) 

Наш код возвращает:

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

 raw_user_age = input («Сколько тебе лет?»)
user_age = int (raw_user_age)

print (user_age) 

Вот что происходит, когда мы выполняем наш код и вставляем значение 12 :

Наш код возвращает тот же результат, что и выше, но 12 теперь хранится как целое число.Мы можем использовать метод type () для проверки:

Наш код возвращает:

Теперь наше значение хранится как целое число, как мы изначально хотели.

Метод str () позволяет преобразовать целое число в строку в Python. Синтаксис этого метода:

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

 raw_user_age = input («Сколько тебе лет?»)
user_age = int (raw_user_age)
 

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

 print ("Ваш возраст:" + user_age)
 

Наш код возвращает ошибку:

 Traceback (последний звонок последний):
  Файл "main.py", строка 3, в 
print ("Ваш возраст:" + user_age)
TypeError: можно только объединить str (не "int") с str
 

Это потому, что вы не можете объединить строку с целым числом, как мы пытались сделать выше. Чтобы наш код заработал, нам нужно будет преобразовать возраст нашего пользователя в строку.Мы можем сделать это с помощью метода str () :

 raw_user_age = input («Сколько тебе лет?»)
user_age = int (raw_user_age)
as_string = str (возраст_пользователя)

print ("Ваш возраст:" + as_string)
 

Наш код возвращает:

Сколько тебе лет?

12

Ваш возраст: 12

Мы успешно преобразовали наше целое число в строку с помощью str (). Оба значения теперь являются строками, что означает, что теперь мы можем объединить сообщение Ваш возраст: с возрастом пользователя.

Python преобразовать список строк в список целых чисел

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

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

Рассмотрим этот код:

 оценок = ["82", "84", "71", "64", "66"]

new_grades = [int (g) для g в оценках]

печать (new_grades) 

Сначала мы определяем список под названием «оценки». Этот список содержит строки. Затем мы пишем анализ списка, который преобразует каждое значение в нашем списке «оценок» в целое число. Наше понимание списков делает это, перебирая каждое значение в «оценках» и изменяя их тип данных с помощью функции int ().

В конце нашей программы мы печатаем наш новый список целых чисел:

Наш код успешно преобразовал наш список строк в список целых чисел.

Заключение

Метод int () используется для преобразования строки в целое число в Python. Это может быть полезно, если вам нужно сохранить значение как целое число или выполнить математические операции над значением, хранящимся в виде строки. Метод str () используется для преобразования целого числа в строку.

Теперь вы готовы преобразовывать строки в целые числа на Python, как эксперт!

Number.prototype.toString () — JavaScript | MDN

Метод toString () возвращает строку, представляющую Указан Номер объекта .

  toString ()
toString (основание системы счисления)
  

Параметры

основание системы счисления Дополнительно

Целое число в диапазоне от 2 до 36 , определяющее основание использовать для представления числовых значений.

Возвращаемое значение

Строка, представляющая указанный объект Number .

Исключения

Объект Number переопределяет метод toString () Объект объект.(Это , а не наследует Object.prototype.toString () ). Для объектов Number toString () метод возвращает строковое представление объекта в указанный основание системы счисления.

Метод toString () анализирует свой первый аргумент и пытается вернуть строковое представление в указанной системе счисления (основание). Для корня выше 10 буквы алфавита обозначают цифры больше 9.Для Например, для шестнадцатеричных чисел (основание 16) от до до f использовал.

Если основание системы счисления не указано, предполагается предпочтительное основание системы счисления. быть 10 .

Если numObj отрицательное, знак сохраняется. Это регистр, даже если основание системы счисления 2 ; возвращенная строка является положительным двоичным кодом представление числа numObj , которому предшествует знак - , , а не , два дополнения к numObj .

Если numObj не является целым числом, знак точки используется для разделите десятичные знаки.

Использование toString

  let count = 10

console.log (count.toString ())
console.log ((17) .toString ())
console.log ((17.2) .toString ())

пусть x = 6

console.log (x.toString (2))
console.log ((254) .toString (16))

console.log ((- 10) .toString (2))
console.log ((- 0xff) .toString (2))
  

Таблицы BCD загружаются только в браузере

Преобразовать целое число в римское — Java

Цель : Для заданного целого числа напишите программу для преобразования его в римское число.

Эту проблему можно сформулировать как «Преобразовать десятичную строку в римскую» ИЛИ «Преобразовать числовое значение в римскую».

Римское число — буквы, используемые в римских цифрах, и соответствующие числовые значения приведены в таблице ниже.

Правила:

Римские цифры обычно пишутся по убыванию слева направо, за исключением некоторых особых случаев, когда левый символ меньше правого символа. например, «IV» эквивалентно 4, а не «IIII».В таких случаях вычтите значение левого символа из значения правого символа. ‘IV’ будет 5-1 = 4, то же самое для ‘IX’ = 10-1 = 9. Ниже приведены случаи —

• I можно разместить перед V или X, представляет вычесть один , поэтому IV (5-1) = 4, а 9 — IX (10-1) = 9.
• X можно разместить перед L или C представляет , вычесть десять , поэтому XL (50-10) = 40 и XC (100-10) = 90.
• C , помещенное перед D или M представляет вычесть сотню , поэтому CD (500-100) = 400 и CM (1000-100) = 900.

Пример:

 Целое число: 25
Роман: XXV
-------------------------------------------------- -
Целое число: 36
Роман: XXXVI
-------------------------------------------------- -
Целое число: 1023
Роман: MXXIII
-------------------------------------------------- -
Целое число: 542
Роман: DXLII 

Подход:

Сохранить Буквы, используемые в римских цифрах и соответствующие числовые значения в массиве.Инициализируйте построитель строк.Теперь начните проверять, является ли входной номер> = старшим римским числом, затем добавьте его в построитель строк и уменьшите его соответствующее значение из входного числа, и если входной номер <старшего римского числа, тогда проверьте со следующей по величине римской цифрой и повторяйте описанный выше процесс до тех пор, пока входное число не станет 0. Построитель строк будет нашим римским представлением входного числа.

Проходной:

 N = 36
значения = [1000,900,500,400,100,90,50,40,10,9,5,4,1]
String [] romanLiterals = ["M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", «IV», «I»];
результат = ""

1000> 36, проверьте следующую римскую цифру, результат = ""
900> 36, проверьте следующую римскую цифру, результат = ""
500> 36, проверьте следующую римскую цифру, результат = ""
400> 36, проверьте следующую римскую цифру, результат = ""
90> 36, проверьте следующую римскую цифру, результат = ""
50> 36, проверьте следующую римскую цифру, результат = ""
40> 36, проверьте следующую римскую цифру, результат = ""
10 <36, добавьте соответствующий литерал 'X' к результату, результат = X, N = 36-10 = 26
10 <26, добавьте соответствующий литерал 'X' к результату, результат = XX, N = 26-10 = 16
10 <16, добавьте соответствующий литерал 'X' к результату, результат = XXX, N = 16-10 = 6
10> 6, проверьте следующую римскую цифру, результат = XXX
9> 6, проверьте следующую римскую цифру, результат = XXX
5 <6, добавить соответствующий литерал 'V' к результату, результат = XXXV, N = 6-5 = 1
5> 1, проверьте следующую римскую цифру, результат = XXXV.
4> 1, проверьте следующую римскую цифру, результат = XXXV.
1 == 1, добавить соответствующий литерал 'I' к результату, результат = XXXVI, N = 1-1 = 0

Результат = XXXVI
 

Запустить этот код

Код:

Выход:

 Целое число: 25
Роман: XXV
-------------------------------------------------- -
Целое число: 36
Роман: XXXVI
-------------------------------------------------- -
Целое число: 1023
Роман: MXXIII
-------------------------------------------------- -
Целое число: 542
Роман: DXLII
-------------------------------------------------- -
 

Встроенные модули для чисел — Руководство по Apache FreeMarker

Вопросы и ответы по теме: у вас есть такие вещи, как 1000000 или 1000000 вместо 1000000 или что-то вроде 3.14 вместо 3,14 или наоборот наоборот? См. Эту и эту запись в часто задаваемых вопросах, также обратите внимание c встроенный выше.

Эта встроенная функция существует, начиная с FreeMarker 2.3.20.

Дает абсолютное значение числа. Например x? Abs , если x равно -5, будет оцените до 5.

Эта встроенная функция существует с FreeMarker 2.3.3.

Эта встроенная функция преобразует число в строку для «компьютерный язык» в отличие от человеческого языка. То есть он форматируется по правилам, которые используются в языках программирования. использовать, который не зависит от языка и формата чисел настройки FreeMarker. Он всегда использует точку в качестве десятичного разделителя и он никогда не использует разделители групп (например, 3,000,000), ни экспоненциальные форма (например, 5E20), ни лишних ведущих или завершающих нулей (например, 03 или 1.0) или знак + (например, +1). Он будет печатать не более 16 цифр после десятичная точка, и, следовательно, числа, абсолютное значение которых меньше, чем 1E-16 будет отображаться как 0. Эта встроенная функция имеет решающее значение, поскольку числа по умолчанию (например, $ {x} ) преобразуются в строки с номером локали (языка, страны) форматирование, предназначенное для читателей (например, 3000000, возможно, напечатано как 3 000 000). Когда номер напечатан не для человека аудитория (e.g. для идентификатора записи базы данных, используемого как часть URL-адреса, или как значение невидимого поля в форме HTML, или для печати Числовые литералы CSS / JavaScript), этот встроенный модуль должен использоваться для напечатайте число (т.е. используйте $ {x? c} вместо $ {x} ), иначе выход может быть нарушен в зависимости от текущих настроек форматирования чисел и локали (например, десятичная точка — это не точка, а запятая во многих странах) и значение числа (например, большие числа, возможно, «повреждены» группировочными разделителями).

Если Incpatible_improvements FreeMarker параметр конфигурации установлен на 2.3.24 или выше (также если он установлен до 2.3.20 или выше, и вы находитесь за пределами строкового литерала), это встроенный вернет "INF" , "-INF" и "NaN" для положительная / отрицательная бесконечность и не-число с плавающей запятой IEEE, соответственно. Это совместимые с XML-схемой представления эти особые ценности.(Ранее он возвращал то, что java.text.DecimalFormat сделал с локалью США, нет из которых понимается любым (общим) компьютерным языком.)

Обратите внимание, что эта встроенная функция также работает на логические.

Эта встроенная функция существует, начиная с FreeMarker 2.3.20.

Сообщает, является ли число бесконечным с плавающей запятой (согласно IEEE 754).Например, someNumber? Is_infinite оценивается как истинно или ложно в зависимости от того, является ли значение someNumber бесконечный или нет. Конечно, если базовое число не тип с плавающей запятой, это всегда будет возвращать ложь .

Эта встроенная функция существует, начиная с FreeMarker 2.3.20.

Сообщает, является ли число NaN с плавающей запятой (согласно IEEE 754). Например, someNumber? Is_nan оценивается как истина или ложь в зависимости от того, если значение someNumber — NaN или нет. Конечно, если базовое число не относится к типу с плавающей запятой, это будет всегда возвращать false .

Эта встроенная функция существует с FreeMarker 2.3.22.

Преобразует 1 , 2 , 3 и т. Д. На строку "a" , "b" , "c" и т. Д. При достижении "z" , продолжается как "aa" , "ab" и т. Д. Это та же самая логика, что и вы можете видеть в заголовках столбцов в приложениях для работы с электронными таблицами (например, Excel или Calc). Наименьшее допустимое число — 1 . Нет никаких верхний предел.Если номер 0 или меньше или не является целым числом, тогда обработка шаблона будет прервана с ошибкой.

Пример:

Шаблон

 <#list 1..30 as n> $ {n? Lower_abc}  

Отпечатков:

Выход

 a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad 

См. Также: upper_abc

Встроенные функции округления существуют со времен FreeMarker 2.3.13.

Преобразует число в целое число, используя указанный правило округления:

• round : округление до ближайшего целого номер. Если число заканчивается на 0,5, оно округляется в большую сторону. (т.е. к положительной бесконечности)

• этаж : округляет число в меньшую сторону (т.е. в сторону отрицательной бесконечности)

• потолок : округляет число в большую сторону (я.е., в сторону положительной бесконечности)

Пример:

Шаблон

 <#assign testlist = [
  0, 1, -1, 0,5, 1,5, -0,5,
  -1,5, 0,25, -0,25, 1,75, -1,75]>
<# list testlist как результат>
    $ {результат}? floor = $ {результат? этаж}? потолок = $ {результат? потолок}? round = $ {результат? round}
 

Отпечатков:

Выход

 0? Этаж = 0? Потолок = 0? Круглый = 0
    1? Этаж = 1? Потолок = 1? Круг = 1
    -1? Этаж = -1? Потолок = -1? Раунд = -1
    0.5? Этаж = 0? Потолок = 1? Круг = 1
    1,5? Пол = 1? Потолок = 2? Круглый = 2
    -0,5? Этаж = -1? Потолок = 0? Круглый = 0
    -1,5? Пол = -2? Потолок = -1? Круглый = -1
    0,25? Пол = 0? Потолок = 1? Круг = 0
    -0,25? Пол = -1? Потолок = 0? Круглый = 0
    1,75 ° пол = 1 ° потолок = 2 ° круг = 2
    -1,75? Пол = -2? Потолок = -1? Круг = -2 

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

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

Существует четыре стандартных числовых формата: компьютер , валюта , число и процентов .Точный их значение зависит от региона (национальности) и контролируется установкой платформы Java, а не FreeMarker, за исключением компьютер , использующий то же форматирование, что и встроенный c (при условии несовместимости улучшения установлены на 2.3.31 или выше, либо бесконечность и NaN не отформатирован таким образом). Также может быть определен программистом форматы, название которых начинается с @ (программисты подробнее здесь…). Вы можете использовать эти предопределенные форматы, например:

Шаблон

 <#assign x = 4200000>
$ {x}
$ {x? string} <# - то же, что $ {x} ->
$ {x? string.number}
$ {x? string.currency}
$ {x? string.percent}
$ {x? string.computer} 

Если вы используете английский (США), будет напечатано:

Выход

 4,200,000
4 200 000
4 200 000
4 200 000 долларов США
420 000 000%
4200000 

Вывод первых трех выражений идентичен, потому что первые два выражения используют формат по умолчанию, то есть здесь «число».Вы можете изменить это значение по умолчанию, используя установка:

Шаблон

 <#setting number_format = "currency">
<#assign x = 4200000>
$ {x}
$ {x? string} <# - то же, что $ {x} ->
$ {x? string.number}
$ {x? string.currency}
$ {x? string.percent} 

Будет выводить:

Выход

 4 200 000 долларов США
4 200 000 долларов США
4 200 000
4 200 000 долларов США
420 000 000% 

, поскольку числовой формат по умолчанию был установлен на «валюта».

Вы также можете ссылаться на именованные пользовательские форматы, которые были определены при настройке FreeMarker (подробнее здесь программисты), нравится:

Шаблон

 $ {x? String. @ Price}
$ {x? string. @ weight} 

, где названиями пользовательского формата были «цена» и «масса». Таким образом, шаблоны могут просто ссылаться на значение домена приложения, и может быть указан точный формат вне шаблонов, на одном центральном месте.(Программисты могут читайте об определении таких названные форматы здесь …)

Помимо именованных форматов, вы можете указать шаблоны числовых форматов. напрямую, используя Java синтаксис формата десятичных чисел (с некоторыми специфичными для FreeMarker расширения; видеть позже):

Шаблон

 <#assign x = 1.234>
$ {x? строка ["0"]}
$ {x? строка ["0. #"]}
$ {x? строка ["0. ##"]}
$ {x? строка ["0. ###"]}
$ {x? строка ["0. ####"]}

$ {1? String ["000.00 "]}
$ {12.1? Строка ["000.00"]}
$ {123.456? Строка ["000.00"]}

$ {1.2? Строка ["0"]}
$ {1.8? Строка ["0"]}
$ {1.5? String ["0"]} <- 1.5, округлено в сторону четного соседа
$ {2,5? String ["0"]} <- 2,5, округлено в сторону четного соседа

$ {12345? String ["0. ## E0"]} 

Выход

 1
1.2
1,23
1,234
1,234

001.00
012,10
123,46

1
2
2 <- 1,5, округляется в сторону четного соседа
2 <- 2,5, округляется в сторону четного соседа

1.23E4 

Обратите внимание, что, как и в FreeMarker foo.бар есть эквивалент foo ["bar"] , вы также можете написать x? String.currency как x? Строка ["валюта"] , но, конечно, это не так будьте практичны. Но в приведенных выше примерах мы должны использовать квадрат синтаксис скобок, поскольку задействованные символы (числа, точка, # ) не разрешены синтаксически после точки оператор.

По историческим причинам вы также можете писать такие вещи, как x? Строка ("0.# ") , который выполняет те же функции, что и x? Строка ["0. #"] .

По умолчанию в соответствии с финансовой и статистической практикой. округление происходит по так называемому правилу половинной четности, которое означает округление в сторону ближайшего «соседа», если только оба соседа равноудалены, и в этом случае он округляется в сторону даже сосед. Это было видно в приведенном выше примере, если вы посмотрите на округление до 1,5 и 2.5, поскольку оба округлены до 2, поскольку 2 чётно, но 1 и 3 - шансы. Другое популярное правило округления, где мы всегда округляем вверх, когда соседи равноудалены (и поэтому 2,5 округляется до 3) называется правилом половинного увеличения, и его можно активирован как описано позже.

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

Шаблон

 <#setting number_format = "0.## ">
$ {1.234} 

Формат чисел по умолчанию также может быть указан вне шаблоны с FreeMarker API (например, с Configuration.setNumberFormat (строка) ).

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

Шаблон

 <#setting number_format = ", ## 0.00">
<#setting locale = "en_US">
Жители США пишут: $ {12345678}
<#setting locale = "de_DE">
Немцы пишут: $ {12345678} 

Вывод

 Жители США пишут: 12 345 678.00
Немцы пишут: 12.345.678,00 

Для работы необходим FreeMarker 2.3.24. До этого части расширенного десятичного формата Java просто молча игнорируется java.text.DecimalFormat .

FreeMarker расширяет шаблоны десятичного формата Java с помощью Дополнительные опции. Эти параметры представляют собой пары имя-значение, указанные после две точки с запятой ( ;; ) в конце формата строка, или если у вас есть отрицательный шаблон (который отделен от обычная скороговорка с точкой с запятой, как в "0.0; минус 0,0 "), после одной точки с запятой. Например:

Шаблон

 Стандартный десятичный формат: $ {10002.5? String [", 000"]}
Расширенный десятичный формат: $ {10002.5? String [", 000  ;; roundingMode = halfUp groupingSeparator = _ "]} 

Выход

 Стандартный десятичный формат: 10,002
Расширенный десятичный формат: 10  _  00  3  

Очень легко сделать ошибку - просто использовать один точка с запятой вместо двух.Это даже не приведет к ошибке, так как java.text.DecimalFormat думает, что у вас есть только указал какой-то странный формат для отрицательных чисел. Так что не забудьте используйте две точки с запятой.

Выше в расширенном десятичном формате мы указали режим округления до половины и разделитель групп "_" . Ниже приводится таблица всех опций (обратите внимание, что они определены java.text.DecimalFormat и java.text.DecimalFormatSymbols , а не FreeMarker):

Что касается синтаксиса опций:

• Имя параметра и значение разделены знаком равенства. символ ( = ).«. Если значение сам должен содержать символ, используемый для цитаты, тогда его нужно ввести дважды (например, бесконечность = 'Это' infinite ', но вы также можете написать infinity = "Это бесконечно" ). Обратная косая черта не имеет особое значение.

• Нестроковые значения не должны заключаться в кавычки. У струн есть только должны быть процитированы, если они содержат знаки препинания или пробелы, или любые другие небуквенные нецифровые не- "_" не "$" знаков.Так, например, оба roundingMode = вниз и roundingMode = "down" допустимы.

Эта встроенная функция существует, начиная с FreeMarker 2.3.22.

То же, что и lower_abc , но преобразуется в заглавные буквы, например "A" , "B" , "C" ,…, «AA» , «AB» и др.