Примитивы и объекты

Теперь в качестве обобщения.

В Java есть два общих типа данных: примитивы и объекты.

Примитив – это тип данных Java, которые считаются простейшей формой данных.

Данные этого типа хранятся непосредственно в памяти.

Это данные типа int, char, double и boolean.

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

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

Поэтому вы создаете совершенно новую версию этой переменной каждый раз, когда вы манипулируете ей.

Так как примитивы такие простые, мы можем выполнять с ними прямые математические операции, такие как сложение, вычитание, деление, и так далее.

Теперь, что такое объект?

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

Такие вещи, как String, Array, Scanner и ArrayList считаются объектами.

И все они начинаются с большой буквы в Java, чтобы обозначить их как объекты.

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

Затем, когда вы передаете это значение в качестве параметра, вы передаете ссылку, а не фактические данные.

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

Поэтому вам всегда нужно понимать, когда вы копируете ссылку на объект или сами данные объекта.

Поскольку объекты сложнее примитивов, вы не можете выполнять такие вещи, как сложение и вычитание, как с простыми числами.

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

Например, если вы хотите узнать, сколько символов в строке, вы вызываете метод length.

Каждый объект имеет свой собственный набор моделей поведения.

И есть одна вещь, о которой нужно знать.

Это специальное ключевое слово null.

Null – это просто слово, которое означает отсутствие объекта.

По сути, это значение 0 для объекта.

Точно так же, как 0 – это значение 0 для int или 0.0 – это значение 0 для double.

Null – это значение 0 для всех типов объектов.

Предположим, мы создаем новый массив строк.

Если мы создадим новый массив символов, мы знаем, что он хранит значения нулей по умолчанию.

Но что он хранит в случае, когда мы создаем массив строк?

Это Null.

Это то, что автоматически заполняется в массив, что означает, объект может быть здесь, но его нет здесь и сейчас.

Это важно знать, потому что вы можете столкнуться с очень распространенным типом исключения Null Pointer.

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

Например, мы хотим получить длину строки, которая хранится в этом массиве.

Там нет строки, поэтому мы получаем так называемое исключение Null Pointer.

Вы не можете назвать длину того, чего не существует.

Имейте в виду, что null означает объект, а не пустой объект.

Например, вы можете вызвать метод length для пустой String.

Это длина равна нулю.

Но нет такой длины, как длина того, чего не существует.

Просто важно знать, что null означает, что здесь нет объекта.

И нам нужно туда его поместить.

Теперь, когда мы понимаем, что такое примитив и что такое объект, важно понять, как компьютер рассматривает эти два типа переменных в своей собственной памяти.

Потому что это оказывает огромное влияние на то, как вы их программируете.

Представим себе, что это память компьютера.

На самом деле это похоже на то, как выглядит память компьютера.

Это общая сетка с адресами для каждого отдельного местоположения, очень похожая на массив.

Когда вы создаете новую переменную примитивного типа, компьютер занимает одно место в памяти и просто помещает эту информацию прямо там, имя и значение переменной.

Когда вы создаете новый объект, он является динамическим.

Он может расти и сокращаться, он может быть большим.

Поэтому компьютер должен придумать особый способ поддерживать этот объект в собственной памяти.

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

И затем он занимает целую секцию памяти для какого-либо большого объекта.

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

Это и есть ссылка.

Таким образом существует большое различие между примитивами и объектами.

Примитивы хранятся непосредственно в памяти, как только вы создаете примитив.

Они настолько малы, что это имеет смысл.

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

Между ними нет реальной связи.

Это будут две совершенно разные переменные.

Как вы можете себе представить, объекты функционируют по-другому.

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

Поэтому, если я создаю новый массив, а затем создаю другой массив, и устанавливаю его равным первому массиву, что копируется?

Компьютер копирует ссылку.

Теперь у меня есть две переменные, которые указывают на одну и ту же информацию.

Поэтому, если я что-то изменяю в массиве z, изменится и массив y, и наоборот.

Вы просто скопировали адрес, где находится информация.

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

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

Мне даже не нужно возвращать его в методе.

Как было сказано ранее, массивы – это объекты. Однако, у них нет полезных методов внутри объекта Array.

Для этого в Java есть класс Arrays,

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

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

Метод toString возвращает строковое представление массива.

Метод equals определяет, одинаковы ли два массива.

Метод fill присваивает новое значение всем элементам массива.

Метод sort сортирует элементы.

Метод binarySearch выполняет поиск элемента по значению и возвращает индекс элемента в случае успеха, или отрицательное целое в случае, если такого элемента нет.

Для работы метода binarySearch необходимо, чтобы массив был уже отсортирован.

Класс Arrays находится в пакете java. util, и если вы хотите его использовать, вы должны добавить строку import java. util.* в начало Java файла.

Давайте рассмотрим пример использования пары методов из класса Arrays.

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

Для решения задачи, сначала мы создадим копию массива, т.о. мы не изменим оригинальный массив.

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

Вот наш метод median, который принимает массив целых чисел в качестве аргумента, и возвращает значение типа double.

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

Метод начинается с создания копии массива-аргумента вызовом метода copyOf класса Arrays.

Этот метод создаст копию массива с количеством элементов, которое указанно вторым аргументом.

В данном случае, мы создаем полную копию массива numbers.

После того, как копия сделана, мы сортируем ее, вызывая метод Arrays.sort.

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

Если длина четная, мы возвращаем среднее значение двух центральных элементов.

В этом случае, мы делим на 2.0, чтобы получить число с плавающей запятой.

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

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

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

Для массивов объектных типов, значение при инициализации – это специальное значение null.

Значение null просто означает, что там не пока объекта.

Например, если мы создадим массив coordinate, это массив трех элементов типа Point.

Все три элемента будут проинициализированы значением null.

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

Т.о. массивы объектного типа требуют инициализации в два этапа.

На первом тапе, вы создаете объект массива, а на втором этапе, вы создаете объект базового типа для каждого элемента массива.

В образце кода, первым шагом является создание массива coordinate.

Затем, мы выполняем второй шаг с помощью цикла, в котором создается реальный объект класса Point для элемента 0, 1 и 2.

Массивы – полезный инструмент.

Однако они имеют некоторые ограничения.

Когда вы сначала создаете массив, вам нужно выбрать его размер.

И как только вы выберете размер массива, его нельзя изменить.

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

Что, если вы не знаете, сколько всего будет элементов в конце концов?

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

Это означает, что вы должны сдвинуть все остальные элементы дальше по массиву.

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

Такая структура данных в Java есть и это список.

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

При этом, он добавляет функциональность, позволяющую ему расти и уменьшаться и вставлять элемент в середину без необходимости делать какие-либо изменения.

Также вы можете удалить элемент внутри списка.

Первый тип списка, так как в Java существует много типов списков, это ArrayList.

ArrayList хранит информацию в массиве, но при этом предоставляет дополнительную функциональность списка.

Вот несколько сравнений использования ArrayList и простого массива.

С массивом вы начнете с типа и затем набор скобок, а затем его размер.

С ArrayList, вам просто нужно знать, какой тип информации вы собираетесь хранить в нем, а затем вы создаете новый ArrayList.

И он будет расти и сокращаться по мере необходимости.

Не нужно передавать его длину.

Чтобы добавить значение в массив вы должны найти в нем место и добавить в это место значение.

В ArrayList вы можете просто сказать add и затем добавить все, что захотите, в ArrayList.

Он сам знает, где находится свободное пространство.

Вы также можете получить элемент, как и массив, используя индекс.

ArrayList поддерживает индексы для каждого из элементов, как и массив.

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

И это отлично подходит для объектов.

Но как насчет примитивов?

К сожалению, вы не можете просто создать ArrayList из, например, int.

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

Это класс Integer.

То же самое существует для double и char.

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

Вы не только можете добавить элемент в самом конце, но вы также можете добавить элемент по определенному индексу.

Вы можете очистить массив, вы можете выполнить поиск по массиву.

Например, вы ищете конкретное слово, но вы не знаете, в каком индексе оно находится.

Это метод indexOf.

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

По сути, ArrayList это массив внутри класса, который имеет большой размер 2^32—1, так что вы не сможете использовать всю длину массива.

ArrayList имеет переменную размера, которую он всегда поддерживает.

Вы добавляете элемент в массив и удаляете, при этом изменяется переменная размера.