Как представить нулевой примитивный тип int в Java?

Вам придется либо отказаться от примитивного типа, либо использовать какое-то произвольное значение int в качестве вашего «недопустимого года».

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

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

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

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

Рассмотрите возможность использования безопасного типа null, такого как Option, иногда известного как Maybe. Популярный в таких языках, как Scala и Haskell, он похож на контейнер с одним или нулевым элементом. Ваше поле будет иметь тип Option<Integer>, который объявляет необязательный характер вашего поля года системе типов и заставляет другой код иметь дело с возможными отсутствующими годами.

Вот библиотека, включающая тип Option.

Вот как бы вы назвали свой код, если бы использовали его:

partyLikeIts.setDocumentYear(Option.some(1999));

Option<Integer> y = doc.getDocumentYear();
if (y.isSome())
   // This doc has a year
else
   // This doc has no year

for (Integer year: y) {
  // This code only executed if the document has a year.
}

Другой вариант — иметь связанный флаг boolean, который указывает, действительно ли ваше значение года. Этот флаг false будет означать, что год «неизвестен». Это означает, что вам нужно проверить один примитив (логическое значение), чтобы узнать, есть ли у вас значение, и если да, то проверить другой примитив (целое число).

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

Вы можете использовать обычное целое число, но используйте значение, такое как Integer.MAX_VALUE или Integer.MIN_VALUE, которые являются определенными константами в качестве вашей недопустимой даты. Также более очевидно, что -1 или низкое отрицательное значение, что оно недействительно, оно точно не будет выглядеть как 4-значная дата, которую мы привыкли видеть.

Если у вас есть целое число и вы обеспокоены тем, что произвольное значение null может быть перепутано с реальным значением, вместо этого вы можете использовать long. Это более эффективно, чем использование Integer, а Long.MIN_VALUE не имеет ничего общего с допустимым значением int.

Для полноты другой вариант (определенно не самый эффективный) — использовать класс-оболочку Year.

class Year {
    public int year;
    public Year(int year) { this.year = year; }
}

Year documentYear = null;
documentYear = new Year(2013);

Или, если это более семантично, или вам нужны несколько типов целых чисел, допускающих значение NULL (кроме Years), вы можете имитировать примитивы C# Nullable следующим образом:

class Int {
    public int value;
    public Int(int value) { this.value = value; }
    @Override 
    public String toString() { return value; }
}

Использование примитива int вместо типа Integer — прекрасный пример преждевременной оптимизации.

Если вы сделаете математику:

• интервал = N (4)
• Целое число = N(16)

Таким образом, для 10 000 целых чисел это будет стоить 40 000 байт или 40 КБ. Для 10 000 целых это будет стоить 160 000 байт или 160 КБ. Если учесть объем памяти, необходимый для обработки изображений/фото/видеоданных, это практически ничтожно мало.

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

Что не так с java.lang.Integer? Это разумное решение, если вы, возможно, не храните очень большие суммы этого значения.

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

PS: черт вас побери, я пытался уйти с небольшой белой ложью об объектах и ​​структурах. Моя точка зрения заключалась в том, что он использует больше памяти, подобно методу логического флага, хотя синтаксически тип с нулевым значением, конечно, лучше. Кроме того, я не был уверен, что кто-то со знанием Java поймет, что я имел в виду под struct.

java.lang.Integer подходит для этого случая. И он уже реализовал Serializable, поэтому вы можете сохранить только поле года на жесткий диск и загрузить его обратно.

Другой вариант может состоять в том, чтобы использовать специальное значение внутри (-1 или Integer.MIN_VALUE или подобное), но предоставлять целое число как два метода:

hasValue() {
    return (internalValue != -1);
}

getValue() {
    if (internalValue == -1) {
        throw new IllegalStateException(
            "Check hasValue() before calling getValue().");
    }
    return internalValue;
}

Если вы собираетесь экономить память, я бы посоветовал упаковать несколько лет в один int. Таким образом, 0 есть nil. Затем вы можете сделать предположения для оптимизации. Если вы работаете только с текущими датами, например, с 1970 по 2014 годы, вы можете вычесть из них 1969 год и получить диапазон 1—55. Такие значения могут быть закодированы только 6 битами. Таким образом, вы можете разделить свой int, который всегда 32-битный, на 4 зоны с указанием года в них. Таким образом, вы можете упаковать 4 года в диапазоне 1970–2226 годов в один int. Чем уже ваш диапазон, например только 2000—2014 (4 бита), тем больше лет вы сможете уместить в одном int.

Вы можете использовать аннотацию @Nullable при использовании java 7