Отсутствует значение в Java

Question

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

if (a>=23) 
income = pay_rate; 
else 
income is missing; 

Answer 1

Integer income = null; 
if (a >= 23) { 
    income = payRate; // underscores are generally considered bad convention in Java 
} 

Answer 2

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

Integer income = a>=53?pay_rate:null; 

Answer 3

Вы ищете значение, а не для заявления, и это значение null. Вы не можете назначить null переменного primitive data types, такие как int и double, но вы можете использовать его с их штучной коллегами - Integer, Double, и так далее.

Когда вы это сделаете, вы должны быть осторожны, чтобы проверить свои значения для null перед их доступом. В противном случае невинно выглядящий if (pay_rate > 100) может выбросить исключение с нулевой ссылкой.

Answer 4

Double income = null; 
if (a>=23) {income = pay_rate; } 

доход будет null по умолчанию, так что если неинициализированный

Answer 5

Option типа в теории типа является способом указать тип переменных, которая может или не может иметь значимое значение. Некоторые языки поддерживают Option типа типа Scala's scala.Option. Для языков, которые не поддерживают тип, вы можете использовать классы-оболочки или вставные копии для примитивов.

public class Income { 
    private int value; 
    public Income(int value) { 
    this.value = value; 
    } 
    public int getValue() { 
    return value; 
    } 
    public void setValue(int value) { 
    this.value = value; 
    } 
} 

... 
Income income = null; 
if(a >= 23) 
    income = new Income(pay_rate); 

или просто

Integer income = null; 
if(a >= 23) 
    income = pay_rate; 

Answer 6

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

if(a >= 23){ 
    income = payRate; 
} else{ 
    income = null; 
} 

а не устанавливать его до null по умолчанию вы устанавливаете его на null после того, как он проверяет, что такое a. также убедитесь, что доход равен либо Integer, либо Double

Answer 7

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

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

Для случаев, когда большинство значений + ve и -ve являются допустимыми значениями, используйте Integer.MAX_VALUE или Integer.MIN_VALUE в качестве недостающего значения. Вы просто потеряете одно значение всего доступного диапазона значений.

ПРИМЕЧАНИЕ. Автоматическое боксирование (неявно преобразованное от примитивного к коробочному типу и наоборот) является хорошей функцией, но может привести к некоторым проблемам производительности, которые трудно отлаживать и находить.

Answer 8

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

if (a>=23) 
    income = pay_rate; 
else 
    throw new IllegalArgumentException("income is missing"); 

Answer 9

Вы должны инициализировать varible с null

Double income = null; 
if (a>=23) 
{ 
    income = pay_rate; 
} 

Answer 10

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

1. Использование типов оболочки и нуль

Integer income = null; 
if (a >= 23) { 
    income = payRate; 
} 

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

Во-вторых, «недействительность» дохода не является частью income. В результате программисту нужно быть осторожным при проверке его на null каждый раз, когда он используется. Если он забывает выполнить эту проверку, компилятор не будет жаловаться, но вы получите NullPointerException s во время выполнения.

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

int income = Integer.MAX_VALUE; 
if (a >= 23) { 
    income = payRate; 
} 

Этот подход разделяет второй недостаток null подхода. Хуже того, в этом случае вместо исключения исключения вычисление будет продолжить даже в ошибочных условиях, поскольку Integer.MAX_VALUE является действительным int, что приводит к возможным катастрофическим последствиям.

---

Итак, как вы должны справиться с этим?

Используйте тип данных:

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

Maybe (также известный как Option) подходит для законопроекта. (@Bahribayli уже предложил это. Я расширяю его.) См. Определение данных here.

И это, как вы будете использовать его в вашем случае:

Maybe<Integer> income = Nothing.value(); 
if (a >= 23) { 
    income = Just.of(payRate); 
} 

Существует библиотека имени Functional Java что provides this abstraction. Если у вас возникнут дополнительные вопросы относительно использования этого типа данных, я буду рад ответить на них.

Answer 11

Вы можете сделать это следующим образом:

public abstract class Nullable extends Number { 

    protected final boolean isNA; 


    protected Nullable(boolean isNA) { 
     this.isNA = isNA; 
    } 

    public boolean isNA() { 
     return isNA; 
    } 
} 


public final class NullableInt extends Nullable { 

    public static final NullableInt NA = new NullableInt(0, true); 

    private final int value; 

    public NullableInt(int value, boolean isNA) { 
     super(isNA); 
     this.value = value; 
    } 

    public static NullableInt of(int value) { 
     return new NullableInt(value, false); 
    } 

    public int getValue() { 
     if (!isNA) { 
      return value; 
     } 
     throw new RuntimeException("Value is NA"); 
    } 

    @Override 
    public int intValue() { 
     return getValue(); 
    } 

    @Override 
    public long longValue() { 
     return getValue(); 
    } 

    @Override 
    public float floatValue() { 
     return getValue(); 
    } 

    @Override 
    public double doubleValue() { 
     return getValue(); 
    } 
} 

public class Test { 

    public static void main(String[] args) { 
     NullableInt[] nullableInts = new NullableInt[3]; 
     nullableInts[0] = NullableInt.of(1); 
     nullableInts[1] = NullableInt.of(2); 
     nullableInts[2] = NullableInt.NA; 

     System.out.println(Arrays.toString(nullableInts)); 
    } 
}