Java'daki mod sözdizimi nedir

Sözde kodda örnek olarak:

if ((a mod 2) == 0)
{
    isEven = true;
}
else
{
    isEven = false;
}

Negatif olmayan tamsayılar için biraz farklı semantiğe sahip modulo operatörü yerine, kalan operatörü kullanabilirsiniz %. Tam örneğiniz için:

if ((a % 2) == 0)
{
    isEven = true;
}
else
{
    isEven = false;
}

Bu, bir astarla basitleştirilebilir:

isEven = (a % 2) == 0;

İşte sahte kodunuzun en az Java kodunda gösterimi;

boolean isEven = a % 2 == 0;

Şimdi bileşenlerine ayıracağım. Java'daki modül operatörü yüzde karakteridir (%). Bu nedenle int% int almak başka bir int döndürür. Çift eşittir (==) operatörü, bir çift ints gibi değerleri karşılaştırmak için kullanılır ve bir boole döndürür. Bu daha sonra 'isEven' boole değişkenine atanır. Operatör önceliğine bağlı olarak, modül karşılaştırma öncesinde değerlendirilecektir.

Herkes zaten cevabı verdiğinden, biraz ek bağlam ekleyeceğim. "modül" operatörü aslında geri kalan işlemi gerçekleştirmektedir. Mod ve rem arasındaki fark, ince ama önemlidir.

(-1 mod 2) normalde 1 verir. Daha spesifik olarak X ve Y olmak üzere iki tamsayı verildiğinde, işlem (X mod Y), [0, Y) aralığında bir değer döndürme eğilimindedir. Farklı bir şekilde söylendiğinde, X ve Y modülü her zaman sıfırdan büyük veya ona eşittir ve Y'den küçüktür.

"%" Veya rem operatörü ile aynı işlemi yapmak X değerinin işaretini korur. X negatifse, (-Y, 0] aralığında bir sonuç alırsınız. X pozitifse, [0, Y) aralığında bir sonuç alırsınız.

Genellikle bu ince ayrım önemli değildir. Yine de kod sorunuza geri dönersek, "eşitlik" için çözmenin birden fazla yolu vardır.

İlk yaklaşım yeni başlayanlar için iyidir, çünkü özellikle ayrıntılıdır.

// Option 1: Clearest way for beginners
boolean isEven;
if ((a % 2) == 0)
{
  isEven = true
}
else
{
  isEven = false
}

İkinci yaklaşım dilden daha iyi yararlanır ve daha özlü koda yol açar. (== operatörünün bir boole döndürdüğünü unutmayın.)

// Option 2: Clear, succinct, code
boolean isEven = ((a % 2) == 0);

Üçüncü yaklaşım tamlık için burada ve üçlü operatör kullanıyor . Üçlü operatör genellikle çok yararlı olmasına rağmen, bu durumda ikinci yaklaşımı daha üstün buluyorum.

// Option 3: Ternary operator
boolean isEven = ((a % 2) == 0) ? true : false;

Dördüncü ve son yaklaşım, tamsayıların ikili gösterim bilgisini kullanmaktır . En küçük anlamlı bit 0 ise sayı çifttir. Bu bitsel ve (&) operatörü kullanılarak kontrol edilebilir . Bu yaklaşım en hızlı olsa da (bölme yerine basit bit maskelemesi yapıyorsunuz), belki de yeni başlayanlar için biraz gelişmiş / karmaşıktır.

// Option 4: Bitwise-and
boolean isEven = ((a & 1) == 0);

Burada bitsel-ve operatörünü kullandım ve seçenek 2'de gösterilen kısa ve özlü formda temsil ettim. Seçenek 1'in formunda (ve alternatif olarak Seçenek 3'lerde) yeniden yazmak okuyucuya bir alıştırma olarak bırakılır. ;)

Umarım yardımcı olur.

Java'nın% (REM) işleminin negatif X ve pozitif Y değerleri için MOD gibi çalışmasını sağlamak için şu yöntemi kullanabilirsiniz:

private int mod(int x, int y)
{
    int result = x % y;
    if (result < 0)
    {
        result += y;
    }
    return result;
}

veya üçlü operatörle (bazı durumlarda daha kısa, ancak mümkün değil veya daha az verimli):

private int mod(int x, int y)
{
    int result = x % y;
    return result < 0? result + y : result;
}

Java aslında C'nin yaptığı gibi hiçbir modulo operatörüne sahip değildir. Java'da%, kalan bir operatördür. Pozitif tamsayılarda, tam olarak modulo gibi çalışır, ancak negatif tamsayılarda farklı çalışır ve modulo'dan farklı olarak kayan nokta sayılarıyla da çalışabilir. Yine de,% değerini pozitif tamsayılardan başka bir şeyde kullanmak nadirdir, bu yüzden bir modulo olarak adlandırmak istiyorsanız, çekinmeyin!

Değerin negatif olup olmadığını kontrol ederek uygun bir modulo yapmak ve eğer varsa (birçoklarının önerdiği gibi) düzeltmek mümkün olsa da, daha kompakt bir çözüm var.

(a % b + b) % b

Bu önce modulo'yu yapacak, değeri -b -> + b aralığına sınırlayacak ve daha sonra değerin pozitif olmasını sağlamak için b ekleyecek ve bir sonraki modüloyu 0 -> b aralığına sınırlayacaktır.

Not: b negatifse, sonuç da negatif olur

Kod modulo kullanmadan çok daha hızlı çalışır:

public boolean isEven(int a){
    return ( (a & 1) == 0 );
}

public boolean isOdd(int a){
    return ( (a & 1) == 1 );
}

if (a % 2 == 0) {
} else {
}

'remainder' operatörünü kullanmadan önce teknik özellikleri incelemelisiniz%:

http://java.sun.com/docs/books/jls/third_edition/html/expressions.html#15.17.3

// bad enough implementation of isEven method, for fun. so any worse?
boolean isEven(int num)
{
    num %= 10;
    if(num == 1)
       return false;
    else if(num == 0)
       return true;
    else
       return isEven(num + 2);
}
isEven = isEven(a);

Java'da %operatör: 15.17.3. Kalan Operatör%

Ayrıca olduğunu unutmayın floorModiçinde java.lang.Mathfarklı bir sonuç verecek sınıfta %farklı işaretlerle bağımsız değişkenler için:

public static int floorMod​(int x, int y)

Ayrıca, mod şu şekilde kullanılabilir:

int a = 7;
b = a % 2;

beşittir. Çünkü 7 % 2 = 1.

Java'da geri kalan operatör %ve modulo operatörü şu şekilde ifade edilebilir:

public int mod(int i, int j)
{
  int rem = i % j;
  if (j < 0 && rem > 0)
  {
    return rem + j;
  }
  if (j > 0 && rem < 0)
  {
    return rem + j;
  }
  return rem;
}

Diğerlerinin de belirttiği gibi, %(kalan) operatör matematiksel modmodülün çalışması / işlevi ile aynı değildir .

mod vs %

x mod nFonksiyon eşler xiçin naralığındadır [0,n).
Oysa x % noperatöre eşler xiçin naralığındadır (-n,n).

Matematiksel modül işlemini kullanmak için bir yönteme sahip olmak ve xbirinin önündeki işareti önemsememek için şunları kullanabilirsiniz:

((x % n) + n) % n

Belki bu resim daha iyi anlamaya yardımcı olur (başımı buralara sarmakta zorlandım)

Başka bir yol:

boolean isEven = false;
if((a % 2) == 0)
{
    isEven = true;
}

Ancak en kolay yol hala:

boolean isEven = (a % 2) == 0;

@Steve Kuo'nun dediği gibi.

Olarak Java, mod işlemi gibi gerçekleştirilebilir:

Math.floorMod(a, b)

Not: mod işlemi farklıdır kalan işlem. Olarak Java, geri kalan işlem gibi gerçekleştirilebilir:

a % b

Modulo operatörü% (yüzde işareti) şeklindedir. Düzgünlüğü test etmek veya genellikle 2 güç için modulo yapmak için, isEven =! (A & 1) gibi & (ve ve işleci) de kullanabilirsiniz.

@Cody koduna bir alternatif:

Modül operatörünü kullanma:

bool isEven = (a % 2) == 0;

Ben daha az çoğaltma ve kullanılmayan esneklik çünkü bu yazma / marjinal olarak daha iyi bir kod olduğunu düşünüyorum. İncelemek için biraz daha fazla beyin gücü gerektirir, ancak isEventelafi eder.