Когда, обычно, Вы используете == равенство на ссылочной переменной определенного типа в Java / C#?

Для простых чисел, таких как «12234» или «231231.23123», ответ может быть простым.

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

В Задаче C это будет выглядеть следующим образом:

NSString *numStr=@"1234",*num2Str=nil;
num2Str=[NSString stringWithFormat:@"%lld",numStr.longlongValue];

if([numStr isEqualToString: num2Str]) NSLog(@"numStr is an integer number!");

Используя этот закон преобразования, мы можем создать решение
для обнаружения double или long чисел:

NSString *numStr=@"12134.343"
NSArray *numList=[numStr componentsSeparatedByString:@"."];

if([[NSString stringWithFormat:@"%lld", numStr.longLongValue] isEqualToString:numStr]) NSLog(@"numStr is an integer number"); 
else 
if( numList.count==2 &&
               [[NSString stringWithFormat:@"%lld",((NSString*)numList[0]).longLongValue] isEqualToString:(NSString*)numList[0]] &&
               [[NSString stringWithFormat:@"%lld",((NSString*)numList[1]).longLongValue] isEqualToString:(NSString*)numList[1]] )
            NSLog(@"numStr is a double number");
else 
NSLog(@"numStr is not a number");

Я не копировал приведенный выше код из своего рабочего кода, поэтому могут быть некоторые ошибки, но я думаю, что главное ясно. Конечно, это решение не работает с числами типа «1E100», а также не учитывает размер целой и дробной части. Используя закон, описанный выше, вы можете выполнять любое обнаружение числа.

7
задан 9 June 2009 в 20:44
поделиться

8 ответов

Для Java чаще всего проверять, является ли ссылка нулевой:

 if (someReference == null) {
 //do something
 }

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

5
ответ дан 6 December 2019 в 12:53
поделиться

Объединение ответов ...

Когда вы обычно используете == равенство по ссылочной типизированной переменной в Java / C #?

1. Чтобы проверить наличие нуля:

if (a == null) ...

2. Для эффективности при построении реализации равенства:

boolean equals(Object o) {
    if (o == null)      return false;
    if (this == o)      return true;

    // Some people would prefer "if (!(o instanceof ClassName)) ..."
    if (getClass() != o.getClass())   return false;

    // Otherwise, cast o, leverage super.equals() when possible, and
    // compare each instance variable ...

3. Для эффективности при сравнении перечислений или сравнении объектов класса, разработанного таким образом, что сравнение идентичности объекта эквивалентно проверке эквивалентности объекта (например, объектов класса):

enum Suit { DIAMONDS, HEARTS, CLUBS, SPADES }

class SomeCardGame {
    ...
    boolean static isATrumpCard(Card c) {
        return (c.getSuit() == TRUMP_SUIT);
    }
}

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

boolean iChoseNotToUseJUnitForSomeReasonTestCase() {
    final List<String> externalList = testObject.getCopyOfList();
    final List<String> instanceVariableValue =
        getInstanceVariableValueViaCleverReflectionTrickTo(testObject, "list");
    if (instanceVariableValue == externalList) {
      System.out.println("fail");
    } else {
      System.out.println("pass");
    }
}

Интересно, что для пункта № 3 одна статья предлагает использовать equals безопаснее , чем использование .equals (), потому что компилятор будет жаловаться, если вы попытаетесь сравнить ссылки на объекты, которые не относятся к тому же классу ( http://schneide.wordpress.com /2008/09/22/or-equals/[1143163 impression).

6
ответ дан 6 December 2019 в 12:53
поделиться

Поскольку это так быстро и просто, == обычно является частью функции Equals () . Если два объекта - == , то они равны , и вам не нужна дополнительная обработка. Для примитивов в Java == - ваш единственный вариант (я не думаю, что это верно для C #, но я не уверен). Я буду использовать == для проверки на ноль (хотя чаще это ! = ). Кроме этого ... Используйте Equals () . Требование == больше равно , но это редко и, вероятно, является признаком проблемы.

2
ответ дан 6 December 2019 в 12:53
поделиться

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

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

Compare(LargeObj a, LargeObj b) {
if (a == b)
  return true;

// do other comparisons here

}
1
ответ дан 6 December 2019 в 12:53
поделиться

В C # оператор == может быть перегружен, что может означать, что вы можете сравнивать ссылочные типы для ЛОГИЧЕСКОГО равенства.

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

При этом будьте осторожны при проверке if (a == b) в C #. Это МОЖЕТ быть эталонное равенство или МОЖЕТ быть логическим сравнением.

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

object.ReferenceEquals(a, b)
a.Equals(b)

Первый одно - эталонное сравнение, а второе - обычно логическое.

вот типичная == перегрузка, только для справки:

public static bool operator ==(RRWinRecord lhs, RRWinRecord rhs)
{
    if (object.ReferenceEquals(lhs, rhs))
    {
        return true;
    }
    else if ((object)lhs == null || (object)rhs == null)
    {
        return false;
    }
    else
    {
        return lhs.Wins == rhs.Wins &&
            lhs.Losses == rhs.Losses &&
            lhs.Draws == rhs.Draws &&
            lhs.OverallScore == rhs.OverallScore;
    }
}
1
ответ дан 6 December 2019 в 12:53
поделиться

В принципе, вы можете использовать ==, когда «знаете», что «==» эквивалентно «.equals» (в Java).

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

Простой пример, в котором вы увидите, это в методе .equals.

public boolean equals(Object o) {
    // early short circuit test
    if (this == o) {
        return true;
    }
    // rest of equals method...
}

Но в некоторых алгоритмах вы хорошо знаете объекты, с которыми работаете, поэтому вы можете полагаться на == для тестов . Например, в контейнерах, работе с графиками и т. Д.

0
ответ дан 6 December 2019 в 12:53
поделиться

Мое личное предпочтение (C #) - всегда оставлять == для обозначения ссылочного равенства (относящегося к одному и тому же объекту). Если мне нужна логическая эквивалентность, я буду использовать Equals . Если я буду следовать этому правилу единообразно, то никогда не будет путаницы.

0
ответ дан 6 December 2019 в 12:53
поделиться

Старайтесь избегать == с объектами, которые обычно определяются с помощью final static, а затем передаются как члены в сериализованных классах.

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

Например (ввод кода без компиляции, извините, если есть какие-то проблемы с code)

public class CarType implements Serializable {
  public final static CarType DODGE = new CarType("Dodge");
  public final static CarType JEEP = new CarType("JEEP");

  private final String mBrand;

  private CarType( String pBrand ) {
     mBrand = pBrand;
  }

  public boolean equals( Object pOther ) {
     ...
  }
}

Экземпляры CarType были сериализованы при использовании в других объектах ... но после материализации (в другом экземпляре JVM) операция == завершилась неудачно.

1
ответ дан 6 December 2019 в 12:53
поделиться