Типы данных Java: примитивные, ссылочные. Ссылочные типы данных java.

Содержание

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

Переменные в Джаве: типы и их особенности

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

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

Термины в программировании – что может пригодиться

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

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

  • алгоритм – набор принципов, правил и инструкций, используемых для решения поставленных задач/проблем;
  • аргумент – значение, передаваемое в команду или функцию;
  • символ – способ отображения данных, который приравнивается к одному буквенному или символьному значению;
  • объект – сочетание связанные констант, переменных, иных структурных сведений, выбираемых и обрабатываемых совместно;
  • класс – набор связанных объектов, обладающих одними и теми же свойствами;
  • константа – значение, которое не подлежит корректировке в процессе выполнения исходного кода программы;
  • массив – список или группа схожих типов значений данных, подлежащих так называемой группировке;
  • переменная – «простейшее» место хранения информации в программном коде.

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

Переменная – это…

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

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

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

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

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

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

В зависимости от выбранного программистом варианта, соответствующий объект занимает определенное место в памяти.

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

Тип Значение
булево Двоичные истина или ложь
Байт 8-битный знаковый, значения о т-128 до 127
короткий 16-разрядный знаковый, значения о т-32,768 до 32,767
char 16-битный символ Юникода
int 32-битный со знаком, значения о т-2,147,483,648 до 2,147,483,647
lang 64-битный со знаком, значения о т-9,223,372,036,854,775,808 до 9,223,372,036,854,775,808
Поплавок 32-битная плавающая точка
двойной 64-битный float

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

Ниже приведен пример объяснения:

Типы объектов

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

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

Список примитивов.

Формат Описание
Булево Двоичное значение, которое является либо истинным, либо ложным
Байт 8-битное знаковое значение, значения о т-128 до 127
Коротко 16-битное знаковое значение, значения о т-32,768 до 32,767
Персонаж Символ Юникода 16 бит
Целое число 32-битное значение со знаком, значения о т-2,147,483,648 до 2,147,483,647
Длинный 64-битное значение со знаком, значения о т-9,223,372,036,854,775,808 до 9,223,372,036,854,775,808
Поплавок 32-битное значение с плавающей запятой
Двойной Значение с плавающим подразделением 64 бита
Строка Unicode N-байтовая строка с текстовыми данными. Без изменений

Обратите внимание, что типы объектов пишутся с заглавной буквы в начале имени объекта. Оригинальная версия (другой вариант) пишется в нижнем регистре. Существуют также различия в сокращениях, например, int против integer и char против character.

Вы также можете создавать свои собственные более сложные типы данных, классы.

Integer myInteger,

Когда вы объявляете ссылочную переменную, она не ссылается ни на одну из них, потому что сначала вы должны создать ее (экземпляр). Вот как это сделать:

Integer myInteger; myInteger = new Integer(45),

В этом примере переменная myInteger ссылается на объект integer, который внутренне содержит 45. Раздел кода new Integer(45) создает целое число.

Создание при объявлении переменной:

Integer myInteger = new Integer(45),

Автобокс

До появления Java 5 для получения значения примитивных типов объектов нужно было вызывать методы:

Integer myInteger = new Integer(45); int myInt = myInteger.intValue(),

В Java 5 появилась концепция, называемая «автобоксинг». Это означает, что оболочка может автоматически «упаковывать» примитивную переменную в объектную версию или «распаковывать» примитивную объектную переменную. В зависимости от того, что требуется. Предыдущий пример можно записать следующим образом:

Integer myInteger = new Integer(45); int myInt = myInteger,

В этом случае Java автоматически извлечет int из myInteger и присвоит это значение myInt.

Создание примитивной объектной переменной также было ручным процессом:

int myInt = 45; Integer myInteger = new Integer(myInt),

С помощью Autobox оболочка может сделать это за вас. Теперь запись выглядит следующим образом:

int myInt = 45; Integer myInteger = myInt,

Затем Java автоматически «упаковывает» примитив в объектную версию соответствующего типа.

Автобоксные функции позволяют использовать примитивы, для которых обычно требуется их объектная версия, и наоборот. Есть одна загвоздка. Объектная переменная (ссылка) может указывать на null, т.е. на ничто. Если вы попытаетесь преобразовать null в примитивное значение, вы получите NullPointerException (ошибка, приводящая к краху программы). В этом коде показан пример:

Integer myInteger = null; int myInt = myInteger,

Этот код компилируется нормально, но во время выполнения он выбрасывает NullPointerException, потому что myInteger указывает на null. Поэтому невозможно преобразовать (распаковать) значение объекта, на который он указывает, так как он не указывает ни на какой объект.

Spring Boot стартеры

Изображение

Стартеры — это набор удобных дескрипторов зависимостей, которые вы можете включить в свое приложение. Вы получаете универсальный набор для всех необходимых вам Spring и связанных технологий без необходимости искать примеры кода и копировать и вставлять различные дескрипторы зависимостей. Например, если вы хотите использовать Spring и JPA для доступа к базам данных, включите в свой проект зависимость spring-boot-starter-data-jpa. Стартеры содержат множество зависимостей, необходимых для быстрого запуска проекта с последовательным, поддерживаемым набором управляемых переходных зависимостей. Что указывается в имени бутстрапа Все официальные бутстрапы следуют схожей схеме именования: spring-boot-starter-*, где * обозначает конкретный тип приложения. Эта структура именования должна помочь вам найти стартера. Интеграция Maven со многими IDE позволяет искать зависимости по имени. Например, если установлен соответствующий плагин ecl

Как получить текущий timestamp в Java

Изображение

Чтобы получить текущую метку времени в Java: package main; import java.sql.Timestamp; public class Main.>Резюме: 2019-10-03 10:09:21.61 Вот два более подробных примера получения текущей метки времени в Java: 1. java.sql.Timestamp Есть два метода получения текущей метки java.sql.Timestamp package main; import java.sql.Timestamp; import java.text.SimpleDateFormat; import java.util.Date; public class Main

Типы ссылок

Если вы внимательно посмотрите на рисунок структуры памяти, вы, вероятно, заметите, что стрелки, представляющие ссылки на объекты из кучи, на самом деле имеют разные типы. Это связано с тем, что в языке программирования Java используются различные типы связей: сильные, слабые, мягкие и воображаемые связи. Разница между ссылочными типами заключается в том, что объекты на куче, на которые они ссылаются, подлежат сборке мусора в соответствии с различными критериями. Давайте рассмотрим каждый из них подробнее.

1. Сильная ссылка

Это наиболее распространенные типы отчетов, к которым мы все привыкли. В приведенном выше примере StringBuilder мы фактически храним сильную ссылку на объект из кучи. Объект на куче не будет удален сборщиком мусора, если он идентифицирован сильной ссылкой или если он явно доступен через цепочку сильных ссылок.

2. Слабая ссылка

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

WeakReference Reference = new WeakReference<>(new StringBuilder()),

Хорошим примером использования слабых ссылок является кэширование сценариев. Представьте, что вы извлекаете некоторые данные и хотите сохранить их в памяти — те же данные можно извлечь снова. С другой стороны, вы не уверены, будут ли эти данные запрашиваться снова и когда. Поэтому вы можете хранить слабую ссылку на него, и если вы запустите сборщик мусора, он, вероятно, уничтожит ваш элемент на куче. Поэтому через некоторое время, если вы захотите получить элемент, на который вы ссылаетесь, вы можете неожиданно получить нулевое значение. Хорошей реализацией кэширования скриптов является коллекция WeakHashMap. Если мы откроем класс WeakHashMap в Java API, то увидим, что его записи фактически расширяют класс WeakReference и используют его поле ref в качестве ключа присваивания ( Map ):

/** * Записи в этой хэш-таблице расширяют WeakReference, используя основное поле ref * в качестве ключа. */ private static class Entry extends WeakReference implements Map.Entry.

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

3. Мягкая ссылка

Эти ссылочные типы используются в сценариях с большим объемом памяти, поскольку они собираются сборщиком мусора только тогда, когда в вашем приложении заканчивается память. Следовательно, сборщик мусора не будет трогать легкодоступные объекты, если нет острой необходимости освободить память. Java гарантирует, что все объекты с мягкими связями будут удалены до возникновения исключения OutOfMemoryError. В документации Javadocs говорится, что "все мягкие ссылки на легкодоступные объекты гарантированно будут очищены до того, как виртуальная машина выдаст ошибку OutOfMemoryError".

Как и мягкие ссылки, мягкая ссылка создается следующим образом:

SoftReference Reference = новый SoftReference<>(new StringBuilder()),

4. Фантомная ссылка

Он используется для планирования действий по уборке после смерти, после того как мы точно знаем, что объектов больше нет. Он используется только с очередью ссылок, поскольку метод .get() всегда возвращает null для таких ссылок. Эти типы ссылок предпочтительны для финализаторов.

Ссылки на String

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

String localPrefix = "297"; //1 String prefix = "297"; //2 if (prefix == localPrefix)иначеString localPrefix = "297" ; // 1

При запуске этот код выводит следующее:

Струны равны

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

String localPrefix = new Integer(297).toString(); //1

Струны разные

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

String localPrefix = new Integer(297).toString().internal(); //1

Если вы внесете указанное выше изменение, результат будет следующим.

Процесс сборки мусора

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

Объекты, подходящие для сборки мусора

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

Чтобы остановиться на этом подробнее, следует отметить несколько моментов:

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

Хотя Java сама решает, когда запустить сборщик мусора, вы можете явно вызвать System.gc() и ожидать, что сборщик мусора запустится, когда будет выполнена эта строка кода, верно?

Это ложное предположение.

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

Поскольку это довольно сложная процедура, которая может повлиять на вашу производительность, она была реализована продуманно. Для этого используется процедура, называемая "метка и зачистка". Java анализирует переменные стека и "помечает" все объекты, которые должны быть сохранены. Затем все неиспользуемые объекты удаляются.

Таким образом, Java на самом деле не собирает мусор. Чем больше мусора и чем меньше объектов, помеченных как живые, тем быстрее идет процесс. Чтобы оптимизировать ее еще больше, память кучи фактически состоит из нескольких частей. Мы можем визуализировать использование памяти и другие полезные вещи с помощью JVisualVM, инструмента, который поставляется с Java JDK. Все, что вам нужно сделать, это установить плагин под названием Visual GC, который позволяет увидеть, как на самом деле структурирована память. Давайте немного увеличим масштаб и проанализируем общую картину:

Поколения памяти кучи

Когда объект создан, он помещается в пространство Eden (1). Поскольку пространство Eden не очень большое, оно очень быстро заполняется. Сборщик мусора работает в Eden Space и помечает объекты как живые.

Если объект выживает в процессе сбора мусора, он перемещается в так называемое пространство выживания S0(2). Когда сборщик мусора запускается во второй раз в Eden Space, он перемещает все уцелевшие объекты в S1(3). Кроме того, все, что сейчас находится в пространстве S0(2), будет перемещено в пространство S1(3).

-Основные типы данных

Тип данных Размер (бит) Диапазон По умолчанию Упаковка
Байт 8 -128 - 127 0 Байт
Выстрел (небольшое целое число) 16 -32768 - 32767 0 Булево
int (целое число) 32 -2147483648-2147483647 0 Коротко
long (большое целое число) 64 -9233372036854477808-9233372036854477807 0 Персонаж
float (плавающая точка) 32 -3.40292347E+38-3.40292347E+38 0.0f Целое число
double (двойная точность) 64 -1.79769313486231570E+308-1.79769313486231570E+308 0.0d Длинный
char (тип символа) 16 ' \u0000 - u\ffffffffffffff ' '\u0000 ' Поплавок
логический 1 истина/ложь ложный Двойной

1. для базовых типов данных длины других типов данных, за исключением длины логического типа, не зависят от платформы. Например, int всегда требует 4 байта (1 байт = 8 бит).

2. void не является базовым типом данных.

Всего в Java существует восемь основных типов, подробнее см. раздел 4.2 спецификации Java. См. раздел 4.2 Спецификации языка Java: http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.

Кроме того, в разделе 14.8 спецификации языка Java также говорится, что void не является типом: http://java.sun.com/docs/books/jls/third_edition/html/statements.html#5989.

Почему в некоторых книгах, например, Thinking in Java, говорится, что void - это базовый тип?

Посмотрите на исходный код класса-обертки void java.lang.Void:

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

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

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

Общие типы ссылок. Поэтому String также является ссылочным типом данных:

Строкаa ="фарфор";Строкаb = a; // тогда и a, и b ссылаются на набор констант"фарфор"Строкаa =новыйСтрока("фарфор");Строкаb = a; // тогда и a, и b указывают на кучу"фарфор"Строкаa =новыйСтрока("фарфор");Строкаb =a; a = a.substring(0,1); //тогда b указывает на стек"фарфор"a указывает на новый объект"c"

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

Методы == и equals() - это методы сравнения равенства. В чем разница и связь между ними? Во-первых, символ == сравнивает значение при сравнении базовых типов данных и значение адреса при сравнении двух объектов с помощью символа ==:

intx =10;inty =10Строка str1 =новыйстрока("abc"); String str2 =новыйстрока("abc"); Система.отключен.println(x == y),// print trueСистема.отключен.println(str1 == str2),// print false

А как насчет метода equals()? Просмотр исходного кода показывает, что метод equals() существует в классе Object, поскольку класс Object является прямым или косвенным родительским классом для всех классов, что означает, что методы equals() во всех классах наследуются от класса Object и передаются классу Object Из исходного кода видно, что основной метод equals() в классе Object основан на символе ==. Во всех классах, которые не переопределяют метод equals(), вызов метода equals() с символом == по сути одинаков. Значение сравниваемого адреса. Однако большинство классов, предоставляемых Java, переписали метод equals(). Переписанный метод equals() обычно сравнивает значения двух объектов: здесь я определяю сам класс Student без перезаписи метода equals(), конечный результат: false.

После переформулировки метода equals() результат будет истинным.

Теперь, когда мы рассмотрели некоторые основы, давайте вернемся к первому примеру:

Строкаstr1 =новыйСтрока("abc");Строкаstr2 =новыйСтрока("abc"); Система.отключен.println(s1.equals(s2)); System.отключен.println(s1 == s2),

Согласно вышесказанному, первое верно, а второе неверно. Это верно, тогда посмотрите на следующий пример:

-Сравнение двух типов

Наконец, некоторые сравнения между базовыми типами данных и ссылочными типами данных:

Основной тип данных Ссылочный тип данных
Распределение стеков Распределение стека, скорость чтения/записи стека намного медленнее, чем у стека
Имена переменных относятся к конкретным значениям Имя переменной определяет адрес памяти объекта данных, т.е. имя переменной определяет хэш-значение
После объявления переменной Java немедленно выделяет под нее место в памяти Он указывает на сущность объекта (конкретное значение) особым образом (подобно указателю языка C). Этот тип объявления переменной не выделяет память, а сохраняет адрес памяти.
Назначение между основными типами - создание нового экземпляра Присвоение между объектами осуществляется просто с помощью ссылки
"==" и "! =' сравнить значения "==" и "! =" сравнить две ссылки на одно и то же, вы должны сами реализовать метод equals()
Переменные базового типа быстро создаются и уничтожаются. Объекты класса нуждаются в JVM для их уничтожения.

Интеллектуальная рекомендация

Удовольствие от темы SpringCloud (7) - Центр регистрации SpringCloud Eureka изящно закрывается

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

Администрация Национального заповедника озера Хулун закладывает корм для защиты диких желтых овец на зиму

На фотографии сотрудники заповедника наблюдают за течением жизни Хуан Яна и записывают данные. Фото Ван Янцина На снимке сотрудники заповедника наблюдают за течением жизни Хуа.

PAT (продвинутый уровень) Практика A1043 Is It a Binary Search Tree (25 баллов) (C ++) (Level A) (BST, двоичное дерево сортировки)

Ссылка на оригинальное название: A1043 Is It a Binary Search Tree.

Разработка интерфейса № 5: Подключите базу данных доступа с помощью ADO

Восемь ADO Link Использование базы данных Разделенная на четыре уровня карта, этот проект использует базу данных Access 2003 (.mde), Другое использование базы данных не указано: import msado1.

инструменты Код аудита Fortify 17,10 и Mac Лицензия версии платформы

Введение В версии 17.10 мастер установки использует значение облака fortify для представления Fortify SCA, инструмента статической проверки безопасности исходного кода. Это приводит к.

Коротко

Он представляет собой прототип 16-битного знакового целочисленного типа данных. Его диапазон составляет о т-32768 до 32767 (или о т-2 15 до 2 15 - 1).

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

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

Char

Char - это 16-битный беззнаковый исходный тип данных, который представляет символ Unicode. Без знака означает, что переменная не может иметь отрицательное значение. Диапазон составляет от 0 до 65535, что соответствует набору символов Unicode. Литерал представляет собой символьное значение и может быть выражен в следующих форматах:

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

Символ можно выразить, заключив его в одинарные кавычки: char C1 = 'A'. Двойные кавычки обозначают буквенно-цифровое число, которое не может быть присвоено переменной char, даже если буквенно-цифровое число состоит из одного символа. Это неприемлемо, поскольку ссылка не присваивается примитивной переменной. Все буквенно-цифровые символы являются объектами класса string и, следовательно, ссылками, а буквенно-цифровые символы относятся к типу primitive.

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

Управляющая последовательность Unicode имеет вид '\uxxxx', где \u (обратная косая черта, за которой следует строчная u) представляет начало, а xxxx - ровно четыре шестнадцатеричные цифры кода символов Unicode. Например, "A" - это десятичный 65 и шестнадцатеричный 41, поэтому этот символ можно представить как "\u0041".

Восьмеричная управляющая последовательность записывается в виде '\nnn', где n – восьмеричная цифра (0-7). Диапазон значений – от '\000' до ']]>77', где 3778nn', где n - восьмеричная цифра (0-7). Диапазон значений от '\000' до '\377', где 37710соответствует 255

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

Логический тип

. Поэтому он используется для представления символов с кодом от 0 до 255, что необходимо для совместимости с другими языками программирования. В отличие от последовательностей Unicode, которые требуют все четыре шестнадцатеричные цифры, здесь вы можете использовать 1, 2 или 3 восьмеричные цифры: '

', '

n' или '

n'.

  • float f1 = 3.25F;
  • float f2 = 32.5E-1F;
  • float f3= 0.325E + 1F.

Булево значение имеет только два допустимых значения: true и false. Они называются булевыми литералами. Логическая переменная не может быть преобразована в другой тип и наоборот. Java не определяет размер булевого значения - это зависит от конкретной реализации виртуальной машины Java.

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

Оцените статью
Uhistory.ru
Добавить комментарий