На какие группы делятся типы данных в java
Перейти к содержимому

На какие группы делятся типы данных в java

  • автор:

Java/Типы данных

В Java есть 8 примитивных типов, которые делят на 4 группы, вот они:

  1. Целые числа — byte, short, int, long
  2. Числа с плавающей точкой (иначе вещественные) — float, double
  3. Логический — boolean
  4. Символьный — char

Целочисленные типы [ править ]

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

Тип Размер (бит) Диапазон
byte 8 бит от -128 до 127
short 16 бит от -32768 до 32767
char 16 бит беззнаковое целое число, представляющее собой символ UTF-16 (буквы и цифры)
int 32 бит от -2147483648 до 2147483647
long 64 бит от -9223372036854775808L до 9223372036854775807L

Пример использования целочисленных типов:

public class IntegralTypes  public static void main(String[] args)  byte b = 216; // Вот тут будет ошибка, т.к. у нас диапазон от -128 до 127! short s = 1123; int i = 64536; long l = 2147483648L; // Постфикс l или L обозначает литералы типа long System.out.println(i); System.out.println(b); System.out.println(s); System.out.println(l); > > 

Символы тоже относят к целочисленным типам из-за особенностей представления в памяти и традиций.

public class Characters  public static void main(String[] args)  char a = 'a', b, c = 'c'; b = (char) ((a + c) / 2); // Можно складывать, вычитать, делить и умножать // Но из-за особенностей арифметики Java результат приходится приводить к типу char явно System.out.println(b); // Выведет символ 'b' > > 

Типы с плавающей точкой [ править ]

Тип Размер (бит) Диапазон
float 32 от 1.4e-45f до 3.4e+38f
double 64 от 4.9e-324 до 1.7e+308
public class FloatingPointTypes  public static void main(String[] args)  double a, b = 4.12; a = 22.1 + b; float pi = 3.14f; // При использовании типа float требуется указывать суффикс f или F // так как без них типом литерала будет считаться double float anotherPi = (float) 3.14; // Можно привести явно double c = 27; double d = pi * c; System.out.println(d); > > 

Логический тип [ править ]

Тип Размер (бит) Значение
boolean 8 (в массивах), 32 (не в массивах используется int) true (истина) или false (ложь)

В стандартной реализации Sun JVM и Oracle HotSpot JVM тип boolean занимает 4 байта (32 бита), как и тип int. Однако, в определенных версиях JVM имеются реализации, где в массиве boolean каждое значение занимает по 1-му байту.

Ссылочные [ править ]

Ссылочные типы — это все остальные типы: классы, перечисления и интерфейсы, например, объявленные в стандартной библиотеке Java, а также массивы.

Строки [ править ]

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

public class Strings  public static void main(String[] args)  String a = "Hello", b = "World"; System.out.println(a + " " + b); // Здесь + означает объединение (конкатенацию) строк // Пробел не вставляется автоматически // Строки конкатенируются слева направо, надо помнить это когда соединяешь строку и примитив String c = 2 + 2 + ""; // "4" String d = "" + 2 + 2; // "22" d = "" + (2 + 2); // а теперь d тоже "4" String foo = "a string"; String bar = "a string"; // bar будет указывать на тот же объект что и foo String baz = new String("a string"); // Чтобы гарантированно создать новую строку надо вызвать конструктор System.out.println("foo == bar ? " + (foo == bar)); // == сравнивает ссылки на объекты System.out.println("foo равен bar ? " + (foo.equals(bar))); // Метод equals служит для проверки двух объектов на равенство System.out.println("foo == baz ? " + (foo == baz)); System.out.println("foo равен baz ? " + (foo.equals(baz))); > > 

Эта программа выведет:
Hello World
foo == bar ? true
foo равен bar ? true
foo == baz ? false
foo равен baz ? true

Обертки [ править ]

Если требуется создать ссылку на один из примитивных типов данных, необходимо использовать соответствующий класс-обертку. Также в таких классах есть некоторые полезные методы и константы, например минимальное значение типа int можно узнать использовав константу Integer.MIN_VALUE. Оборачивание примитива в объект называется упаковкой (boxing), а обратный процесс распаковкой (unboxing).

Тип Класс-обертка
byte Byte
short Short
int Integer
long Long
char Character
float Float
double Double
boolean Boolean
int i; Integer boxed; // Обычное создание объекта boxed = new Integer(i); // Фабричный метод boxed = Integer.valueOf(i); // Автоматическая упаковка, компилятор просто вставит вызов Integer.valueOf boxed = i; 

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

Получить примитив из объекта-обертки можно методом Value.

Integer boxed; int i; // Явная распаковка i = boxed.intValue(); // Автоматическая распаковка i = boxed; 

Java: Какие бывают типы

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

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

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

  • Примитивные — предопределены в Java
  • Ссылочные или не примитивные — создаются самим программистом, за исключением String и Array

У этих групп есть различия, которые мы разберем позже, когда познакомимся с null и объектно-ориентированным программированием. Пока достаточно знать, что имена примитивных типов начинаются с нижнего регистра ( int ), а ссылочных с верхнего ( String ).

Всего в Java восемь примитивных типов данных:

Рассмотрим первые четыре типа. Это целые числа разного размера:

  • byte — занимает в памяти 1 байт, значит может хранить числа от -128 до 127
  • short — занимает в памяти 2 байта
  • int — занимает в памяти 4 байта
  • long — занимает в памяти 8 байт

Посмотрим на примере такого кода:

byte x = 3; // Отработает без проблем // Error: incompatible types: possible lossy conversion from int to byte byte y = 270; 

Определение переменной y завершилось с ошибкой, потому что мы указали тип byte, но присвоили переменной значение 270, которое выходит за множество допустимых значений.

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

Технически так сделать можно, но мы находимся в мире инженерных решений. У любого решения всегда есть обратная сторона, поэтому невозможно сделать идеально — придется чем-то пожертвовать. В данном случае, объемом занимаемой памяти. Если оставить только long, то программа, активно оперирующая числами, начнет занимать слишком много места в оперативной памяти, что может быть критично.

Такая же логика использовалась для типов float и double. Они оба отвечают за рациональные числа. Разница лишь в том, что double — это двойной float, то есть в памяти он занимает в два раза больше места.

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

Рассмотрим оставшиеся типы данных.

Тип boolean отвечает за логические значения true и false . Им посвящен целый раздел, там мы про него и поговорим.

Особняком стоит тип char — символ. Это не строка, у него другой способ определения — через одиночные кавычки:

char ch = 'a'; // Error: incompatible types: java.lang.String cannot be converted to char char ch2 = "b"; 

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

Извлечение символа из строки извлекает как раз символ, а не строку, состоящую из одного символа:

"hexlet".charAt(1); // 'e' 

Хорошо, а где тип данных String — строка? Дело в том, что она не является примитивным типом. Внутри она представляет собой массив символов. Несмотря на это техническое различие, строки используются наравне с примитивными типами без особых отличий.

Задание

Выведите на экран результат конкатенации слова hexlet, символа и числа 7

Упражнение не проходит проверку — что делать? ��

Если вы зашли в тупик, то самое время задать вопрос в «Обсуждениях». Как правильно задать вопрос:

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

В моей среде код работает, а здесь нет ��

Тесты устроены таким образом, что они проверяют решение разными способами и на разных данных. Часто решение работает с одними входными данными, но не работает с другими. Чтобы разобраться с этим моментом, изучите вкладку «Тесты» и внимательно посмотрите на вывод ошибок, в котором есть подсказки.

Мой код отличается от решения учителя ��

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

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

Прочитал урок — ничего не понятно ��

Создавать обучающие материалы, понятные для всех без исключения, довольно сложно. Мы очень стараемся, но всегда есть что улучшать. Если вы встретили материал, который вам непонятен, опишите проблему в «Обсуждениях». Идеально, если вы сформулируете непонятные моменты в виде вопросов. Обычно нам нужно несколько дней для внесения правок.

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

Полезное

  • Попробуйте поиграть с конкатенированием строк и символов в jshell
  • Статья о дробных числах

Руководство по Java Core. Типы данных.

Переменные – это зарезервированное место в памяти для хранения значения. Другими словами, когда мы объявляем переменную, мы резервируем место в памяти.

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

В языке Java все типы данных делятся на две большие группы:

  • Примитивные типы данных
  • Ссылочное типы данных (Объекты)

Примитивные типы данных

В Java есть 8 примитивных типов данных:

byte

  • 8-битное целое число
  • Максимальное значение: -128 (-2 ^ 7)
  • Минимальное значение: 127 (2 ^ 7 -1)
  • Значение по умолчанию: 0
  • Используется для экономии места в больших массивах. Чаще всего вместо int.
  • Пример: byte c = 65

short

  • 16-битное целое число
  • Максимальное значение: -32,768 (-2 ^ 15)
  • Минимальное значение: 32,767 (2 ^ 15 – 1)
  • Значение по умолчанию: 0
  • Используется для экономии места вместо int.
  • Пример: short a = 20000, short b = -10000

int

  • 32-битное целое число
  • Максимальное значение: -2,147,483,648 (-2 ^ 31)
  • Минимальное значение: 2,147,483,647 (-2 ^ 31 – 1)
  • Значение по умолчанию: 0
  • Используется для целых значений в случае, если нет дефицита памяти.
  • Пример: int i = 2000000000, int h = -1500000000

long

  • 64-битное целое число
  • Максимальное значение: -9,223,372,036,854,775,808 (-2 ^ 63)
  • Минимальное значение: 9,223,372,036,854,775,807 (-2 ^ 63 – 1)
  • Значение по умолчанию: 0L
  • Используется для хранения больших целочисленных значений.
  • Пример: long l = 5000000000L, long k = -4000000000L

float

  • 32-битное число с плавающей точкой IEEE 754
  • Значение по умолчанию: 0.0f
  • Используется для экономии памяти в больших массивах чисел с плавающей точкой.
    Никогда не используется для хранения точных значений (например, денег).
  • Пример: float f = 112.3f

double

  • 64-битное число двойной точности с плавающей точкой IEEE 754
  • Значение по умолчанию: 0.0d
  • Используется для хранения чисел с плавающей точкой (в большинстве случаев).
  • Никогда не используется для хранения точных значений (например, денег).
  • Пример: double d = 121.5

boolean

  • В спецификации размер не указан. Зависит от типа JVM.
  • Возможные значения: true/false
  • Значение по умолчанию: false
  • Используется для определения того, является ли условие истинным.
  • Пример: boolean flag = true

char

  • Символ кодировки Unicode 16-bit
  • Максимальное значение: ‘\u0000’ (или 0)
  • Минимальное значение: ‘uffff’ (или 65.535)
  • Используется для хранения любого символа
  • Пример: char c = ‘C’

Ссылочные типы данных

  • К ссылочным типам данных относятся все типы данных, которые создаются с помощью конструкторов. К ним также относятся все классы, создаваемые разработчиками, например, Developer, Car, Person и т.д.
  • Массивы являются ссылочными типами данных.
  • Ссылочная переменная может использоваться в качестве ссылки на любой объект определённого типа данных.
  • Все ссылочные типы имеют значение по умолчанию: null.
  • Пример:
    Developer developer = new Developer(“Java Developer”);

Литералы

Литералы – это представление фиксированных значений в виде кода. Они не требуют каких-либо вычислений. Например:
[code lang=”java”]
char c = ‘C’
[/code]
Значения int, long, short, byte могут быть выражены с помощью десятичной, шестнадцатеричной и восьмеричной систем.

Пример:
[code lang=”java”]
int decimal = 500;

int octal = 0168;

int hexa = 0x32;
[/code]
Для строк в языке Java используется класс String. String может содержать как простые символы, так и символы Unicode:
[code lang=”java”]
char c = ‘\uffff’;

String str = “\uffff”;
[/code]
В языке Java также существует ряд управляющих последовательностей для отображения некоторых символов:

\n Новая строка (0x0a)
\r Возврат каретки (0x0d)
\f Прогон страницы (0x0c)
\b Возврат на символ назад (0x08)
\s Пробел (0x20)
\t Табуляция
\” Двойная кавычка
\’ Одинарная кавычка
\\ Обратный слэш
\xxx Восьмеричный символ (xxx)
\uxxxx Шестнадцатеричный символ UNICODE (xxxx)

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

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

Полезности

Туториалы
Системный дизайн
Собеседования
Студенты
Задачи

Немного о себе

Приветствую! Меня зовут Евгений. На этом сайте я пишу о разработке программного обеспечения. Связаться со мной вы можете по email: proselytear@yahoo.com Имеет смысл, предварительно ознакомиться вот с этим FAQ разделом.

Недавние публикации
  • Механизмы CAS и FAA глазами Java разработчика
  • ExecutorService в Java и примеры его применения.
  • Особенности работы PreparedStatement в JDBC
  • Основы кэширования в Hibernate
  • Феномены чтения глазами разработчика

Copyright © 2024 PROSELYTE.

Omega WordPress Theme by ThemeHall

На какие группы делятся типы данных в java

Одной из основных особенностей Java является то, что данный язык является строго типизированным. А это значит, что каждая переменная и константа представляет определенный тип и данный тип строго определен. Тип данных определяет диапазон значений, которые может хранить переменная или константа.

Итак, рассмотрим систему встроенных базовых типов данных, которая используется для создания переменных в Java. А она представлена следующими типами.

    boolean : хранит значение true или false

boolean isActive = false; boolean isAlive = true;
byte a = 3; byte b = 8;
short a = 3; short b = 8;
int a = 4; int b = 9;
long a = 5; long b = 10;
double x = 8.5; double y = 2.7;
float x = 8.5F; float y = 2.7F;

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

Целые числа

Все целочисленные литералы, например, числа 10, 4, -5, воспринимаются как значения типа int , однако мы можем присваивать целочисленные литералы другим целочисленным типам: byte , long , short . В этом случае Java автоматически осуществляет соответствующие преобразования:

byte a = 1; short b = 2; long c = 2121;

Однако если мы захотим присвоить переменной типа long очень большое число, которое выходит за пределы допустимых значений для типа int, то мы столкнемся с ошибкой во время компиляции:

long num = 2147483649;

Здесь число 2147483649 является допустимым для типа long, но выходит за предельные значения для типа int. И так как все целочисленные значения по умолчанию расцениваются как значения типа int, то компилятор укажет нам на ошибку. Чтобы решить проблему, надо добавить к числу суффикс l или L , который указывает, что число представляет тип long:

long num = 2147483649L;

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

int num111 = 0x6F; // 16-теричная система, число 111 int num8 = 010; // 8-ричная система, число 8 int num13 = 0b1101; // 2-ичная система, число 13

Для задания шестнадцатеричного значения после символов 0x указывается число в шестнадцатеричном формате. Таким же образом восьмеричное значение указывается после символа 0 , а двоичное значение — после символов 0b .

Также целые числа поддерживают разделение разрядов числа с помощью знака подчеркивания:

int x = 123_456; int y = 234_567__789; System.out.println(x); // 123456 System.out.println(y); // 234567789
Числа с плавающей точкой

При присвоении переменной типа float дробного литерала с плавающей точкой, например, 3.1, 4.5 и т.д., Java автоматически рассматривает этот литерал как значение типа double . И чтобы указать, что данное значение должно рассматриваться как float , нам надо использовать суффикс f:

float fl = 30.6f; double db = 30.6;

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

Символы и строки

В качестве значения переменная символьного типа получает одиночный символ, заключенный в одинарные кавычки: char ch=’e’; . Кроме того, переменной символьного типа также можно присвоить целочисленное значение от 0 до 65535 . В этом случае переменная опять же будет хранить символ, а целочисленное значение будет указывать на номер символа в таблице символов Unicode (UTF-16). Например:

char ch=102; // символ 'f' System.out.println(ch);

Еще одной формой задания символьных переменных является шестнадцатеричная форма: переменная получает значение в шестнадцатеричной форме, которое следует после символов «\u». Например, char ch=’\u0066′; опять же будет хранить символ ‘f’.

Символьные переменные не стоит путать со строковыми, ‘a’ не идентично «a». Строковые переменные представляют объект String , который в отличие от char или int не является примитивным типом в Java:

String hello = "Hello. "; System.out.println(hello);

Кроме собственно символов, которые представляют буквы, цифры, знаки препинания, прочие символы, есть специальные наборы символов, которые называют управляющими последовательностями. Например, самая популярная последовательность — «\n». Она выполняет перенос на следующую строку. Например:

String text = "Hello \nworld"; System.out.println(text);

Результат выполнения данного кода:

Hello world

В данном случае последовательность \n будет сигналом, что необходимо сделать перевод на следующую строку.

Начиная с версии 15 Java поддерживает тестовые блоки (text blocks) — многострочный текст, облеченный в тройные кавычки. Рассмотрим, в чем их практическая польза. Например, выведем большой многострочный текст:

String text = "Вот мысль, которой весь я предан,\n"+ "Итог всего, что ум скопил.\n"+ "Лишь тот, кем бой за жизнь изведан,\n"+ "Жизнь и свободу заслужил."; System.out.println(text);

С помощью операции + мы можем присоединить к одному тексту другой, причем продолжение текста может располагаться на следующей строке. Чтобы при выводе текста происходил перенос на следующую строку, применяется последовательность \n.

Результат выполнения данного кода:

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

Текстовые блоки, которые появились в JDK15, позволяют упростить написание многострочного текста:

String text = """ Вот мысль, которой весь я предан, Итог всего, что ум скопил. Лишь тот, кем бой за жизнь изведан, Жизнь и свободу заслужил. """; System.out.println(text);

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

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *