Verwendung des Modulo- oder Restoperators in Java

Modulo ist einer der am häufigsten verwendeten arithmetischen Operatoren, mit denen der Rest zweier Werte ermittelt wird. Es wird auch als „Rest“ oder der „Modul”-Operator und wird mit dem Symbol „%”-Symbol in Java. Der Rückgabetyp des Modulo-Operators hängt vom Eingabetyp der angegebenen Operanden ab. Wenn beispielsweise beide Operanden Ganzzahlen sind, ist auch der Rest eine Ganzzahl. Wenn einer oder beide Operanden doppelt sind, ist auch der Rest doppelt.

Kurzer Überblick

Was ist ein Modulo-Operator und wie funktioniert er in Java?

Der Modulo-Operator führt eine Division der angegebenen Werte durch und ruft den Rest als Ausgabe ab. In Java wird es mit einem Prozentzeichen angegeben „%“, wie in der folgenden Syntax gezeigt:

dividend % divisor;

Grafische Darstellung des Modulo-Operators:

Es gibt zahlreiche Anwendungsfälle des Modulo-Operators. Einige davon werden im Folgenden zusammen mit praktischen Beispielen besprochen:

Fall 1: Verwenden Sie den Modulo-Operator, um den Rest zweier Ganzzahlen zu ermitteln

Deklarieren und initialisieren Sie einige Variablen vom Typ Integer in der main()-Methode:

int dividend = 73; 
int divisor = 6;

Verwenden Sie den Modulo-Operator „%” auf die angegebenen Werte und speichern Sie das Ergebnis in einer neuen Variablen namens „modulo“:

int modulo = dividend%divisor;

Drucken Sie das berechnete Ergebnis auf der Konsole aus:

System.out.println(dividend + "%" + divisor + " is equal to: "+ modulo);

Vollständiger Code und Ausgabe

Fall 2: Verwenden Sie den Modulo-Operator, um den Rest zweier Double-Werte zu ermitteln

Deklarieren und initialisieren Sie zwei Variablen vom Typ Double: „Dividend“ und „Divisor“:

double dividend = 73.52; 
double divisor = 6.73;

Verwenden Sie den Modulo-Operator „%” auf die bereitgestellten Werte, speichern Sie das Ergebnis in einer neuen Variablen namens „modulo“ und geben Sie es auf der Konsole aus:

double modulo = dividend%divisor;
System.out.println(dividend + "%" + divisor + " = "+ modulo);

Vollständiger Code und Ausgabe

Fall 3: Verwenden Sie den Modulo-Operator, um zu prüfen, ob eine Zahl durch 3 teilbar ist

Das folgende Beispiel übernimmt eine Zahl vom Benutzer und prüft, ob diese durch 3 teilbar ist. Importieren Sie dazu zunächst die Klasse Scanner:

import java.util.Scanner;

Erstellen Sie ein Scanner-Objekt und verwenden Sie es mit nextInt(), um einen ganzzahligen Wert vom Benutzer zu erhalten:

Scanner scannerObj = new Scanner(System.in);
      System.out.println("Please Enter a Number");
      int input = scannerObj.nextInt();

Verwenden Sie den Moduloperator, um den Rest der vom Benutzer eingegebenen Zahl für 3 zu ermitteln:

int modulo = input%3;

Verwenden Sie nun die if-else-Anweisung, um zu prüfen, ob die vom Benutzer eingegebene Zahl durch 3 teilbar ist:

if (modulo == 0)
  {
  System.out.println("Input Number is Divisible by 3");
  }
else
  {
  System.out.println("Input Number is Not Divisible by 3");
  }

Vollständiger Code und Ausgabe

Fall 4: Verwenden Sie den Modulo-Operator, um zu prüfen, ob der vom Benutzer eingegebene Wert eine Primzahl ist

Die ersten beiden Schritte sind die gleichen wie im vorherigen Beispiel, dh importieren Sie die Scanner-Klasse und nehmen Sie Benutzereingaben entgegen. Erstellen Sie anschließend eine Variable vom Typ Integer und weisen Sie ihr den Wert 0 zu:

int flag = 0;

Verwenden Sie nun eine for-Schleife und iterieren Sie diese bis zu „input /2“. Verwenden Sie innerhalb der for-Schleife die if-Anweisung, um zu prüfen, ob der vom Benutzer eingegebene Wert durch eine beliebige Zahl teilbar ist. Wenn es durch eine beliebige Zahl teilbar ist, unterbrechen Sie die Schleife:

for (int i = 2; i <= input/2; i++)
    {
      if (input % i == 0)
    {
          flag++;
    break;
  }   
      }

Eine Zahl (>1), die durch „sich selbst“ und „1“ teilbar ist, wird als Primzahl bezeichnet. Geben Sie diese Bedingung in der if-else-Anweisung an, um zu prüfen, ob der angegebene Wert eine „Primzahl“ ist:

if (flag == 0 && input != 1)
    {          System.out.println(input + " is a Prime number");
    }
else
    {
System.out.println(input + " is Not a Prime number");
    }

Vollständiger Code und Ausgabe:

Fall 5: Verwenden Sie den Modulo-Operator, um die Gesamtvorkommen gerader und ungerader Zahlen in einem Array zu ermitteln

Erstellen Sie zunächst ein Array verschiedener Ganzzahlen und verwenden Sie das „Länge”-Eigenschaft darauf, um seine Größe zu ermitteln:

int[] input = {2, 1, 3, 5, 6, 98, 91, 121, 0, 3};  
int arrSize = input.length;

Deklarieren und initialisieren Sie einige Variablen vom Typ Integer mit dem Wert 0:

int evenCount =0, oddCount = 0;

Verwenden Sie die for-Schleife, um das angegebene Array zu durchlaufen und die Anzahl der geraden und ungeraden Zahlen zu ermitteln. Verwenden Sie innerhalb der for-Schleife eine if-else-Anweisung mit dem Modulo-Operator, um die geraden und ungeraden Zahlen im Array zu finden:

for (int i=0; i< arrSize; i++)
    {
if (input[i]%2 == 0)
          evenCount++;
else
    oddCount++;       }

Verwenden Sie abschließend die Methode „System.out.println()“, um die Anzahl der geraden und ungeraden Werte anzuzeigen:

System.out.println("Total Even Numbers in the Given Array: " + evenCount);
System.out.println("Total Odd Numbers in the Given Array: " + oddCount);

Vollständiger Code und Ausgabe:

Fall 6: Verwenden Sie den Modulo-Operator für ein kreisförmiges Array

Der häufigste Anwendungsfall des Modulo-Operators sind kreisförmige Arrays. Ein kreisförmiges Array ist ein Array, dessen Elemente kreisförmig miteinander verbunden sind. Es ist so, dass das erste Element mit einem zweiten Element verbunden ist, ein zweites Element mit einem dritten Element verbunden ist und so weiter, bis das letzte Element mit dem ersten Element verbunden ist.

Deklarieren und initialisieren Sie beispielsweise ein einfaches String-Array:

String [] circularArray = { "j", "a", "v", "a", "b", "e", "a", "t"};

Nun iterieren Sie mit einer for-Schleife über das Array, um seine Elemente auszugeben:

for (int i = 4; i <= 11; i++) {
System.out.println(circularArray[i]);
}

Die Schleife beginnt ihre Iteration ab Index 4 und wird voraussichtlich bis Index 11 fortgesetzt:

Der letzte Index des angegebenen Arrays ist „7“. Daher wirft Java ein „Index außerhalb der GrenzenAusnahme, wenn wir versuchen, auf ein Element mit Index 8 oder höher zuzugreifen. Um diese Ausnahme zu beheben, verwenden Sie den Modulo-Operator wie folgt:

circularArray[arrayIndex % arraySize];

Verwenden Sie die Längeneigenschaft, um die Größe des angegebenen Arrays zu ermitteln. Dann iterieren Sie die Schleife bis zu einer bestimmten Zahl und verwenden Sie innerhalb des Schleifenkörpers den Modulo-Operator mit der Array-Größe, um über jedes Element des kreisförmigen Arrays zu iterieren:

int arraySize = circularArray.length;
for (int i = 4; i <= 11; i++) {
System.out.println(circularArray[i%arraySize]);
}

Vollständiger Code und Ausgabe:

Fall 7: Verwenden Sie den Modulo-Operator, um das Schaltjahr zu überprüfen

Verwenden Sie den Modulo-Operator, um zu überprüfen, ob der Benutzer ein Schaltjahr eingibt. Importieren Sie dazu zunächst die Scanner-Klasse und übernehmen Sie als Eingabe ein „Jahr“ vom Benutzer:

Scanner scannerObj = new Scanner(System.in);
System.out.println("Enter a Year");
int inputYear = scannerObj.nextInt();

Verwenden Sie nun den Modulo-Operator mit der if-else-Anweisung, um zu überprüfen, ob der Benutzer ein Schaltjahr eingegeben hat:

if ((inputYear % 4 == 0 && inputYear % 100 != 0) || inputYear % 400 == 0) {
    System.out.println("It's a Leap year.");
    }
else {
    System.out.println("Not a leap year.");
}

Wenn ein Jahr vollständig durch „4“ teilbar ist, spricht man von einem Schaltjahr. Allerdings gilt ein Jahrhundertjahr als Schaltjahr, wenn es durch 400 teilbar ist.

Vollständiger Code und Ausgabe:

Fall 8: Verwenden Sie den Modulo-Operator, um zyklische Schleifen zu erstellen

Um eine zyklische Schleife zu erstellen, geben Sie eine Zahl an, bis zu der Sie eine Schleife durchlaufen möchten. Anschließend verwenden Sie den Modulo-Operator mit einem Divisor, auf dessen Grundlage Sie einen Zyklus erstellen möchten:

for (int num = 0; num < 12; num++) {
    int cycleVal = num % 4;
    System.out.println(cycleVal);
}

Vollständiger Code und Ausgabe:

Fall 9: Verwenden Sie den Modulo-Operator, um Minuten in Stunden umzuwandeln

Verwenden Sie zunächst die Scanner-Klasse, um die Konvertierung vom Benutzer in Minuten vorzunehmen:

Scanner scannerObj = new Scanner(System.in);
System.out.println("Please Enter Total Minutes");
int inputMinutes = scannerObj.nextInt();

Verwenden Sie den Divisionsoperator, um die Gesamtstunden zu berechnen, und den Modulooperator, um die verbleibenden Minuten zu ermitteln:

int hours = minutes / 60;
int remainingMinutes = minutes % 60;
System.out.print(minutes + " minutes = "
          + hours + " hours "
          + remainingminutes + " minutes");

Vollständiger Code und Ausgabe:

Fall 10: Verwenden Sie den Modulo-Operator für negative Werte

Der Modulo-Operator ruft die Ausgabe entsprechend dem mit dem Dividenden verknüpften Vorzeichen ab. Verwenden Sie zur Demonstration zunächst den Modulo-Operator mit dem negativen Dividenden:

int modulo = -72 % 11;
System.out.println("Modulo When Dividend is Negative: " + modulo);

Verwenden Sie nun den Modulo-Operator mit einem positiven Dividenden und einem negativen Divisor:

int modulo1 = 72 % -11;
System.out.println("Modulo When Divisor is Negative: " + modulo1);

Verwenden Sie abschließend den Modulo-Operator mit einem negativen Dividenden und einem negativen Divisor:

int modulo2 = -72 % -11;
System.out.println("Modulo When Both Dividend and Divisor are Negative: " + modulo2);

Vollständiger Code und Ausgabe:

Division vs. Modulo: Was ist der Unterschied?

A Aufteilung Operator „/” gibt einen Quotienten zurück, während a Modulo Operator „%„ruft einen Rest in Java ab:

Betrachten Sie den folgenden Code, um diesen Unterschied bei der Java-Programmierung zu verstehen.

Beispiel: Modulo vs. Division in Java

Verwenden Sie zunächst die „%”-Operator auf die angegebenen Werte und speichern Sie das Ergebnis in einer Variablen namens „modulo“:

int modulo = 73 % 6;

Benutzen Sie nun die „/”-Operator auf die gleichen Werte und speichern Sie das Ergebnis in einer Variablen namens „division“:

int division = 73 / 6;

Drucken Sie die Ausgabe beider Operatoren auf der Konsole aus:

System.out.println("Modulo: " + modulo
    +"\nDivision: " + division);

Vollständiger Code und Ausgabe:

Mögliche Ausnahmen beim Arbeiten mit dem Modulo-Operator

Ein „ArithmeticException„tritt auf, wenn ein Benutzer „0“ als Teiler angibt:

Notiz: Der Modulo-Operator funktioniert bei Ganzzahlen einwandfrei, kann jedoch bei Nicht-Ganzzahlen zu unerwarteten Ergebnissen führen.

Modulo-Operator-Alternativen

Die unten aufgeführten alternativen Ansätze können uns helfen, die gleiche Funktionalität wie der Modulo-Operator in Java zu erreichen:

  • Rest() verwenden
  • Verwenden von Math.floorMod()
  • Benutzerdefinierte Logik verwenden

Alternative 1: rest() verwenden

Der Rest() Die Methode gehört zur BigDecimal-Klasse von Java. Es berechnet den Rest von zwei BigDecimal-Werten. Um diese Methode zu verwenden, importieren Sie zunächst die BigDecimal Klasse in Ihrem Programm:

import java.math.BigDecimal;

Erstellen Sie nun ein paar BigDecimal-Variablen, um den Dividenden und den Divisor zu initialisieren:

BigDecimal dividend = new BigDecimal("112.50");
BigDecimal divisor = new BigDecimal("12.2");

Verwenden Sie die Methode „remainder()“ für die angegebenen Werte, um den Rest zu ermitteln. Verwenden Sie anschließend die Methode println(), um den Rest auf der Konsole anzuzeigen:

BigDecimal modulo = dividend.remainder(divisor);
System.out.println("Remainder: "+ modulo);

Vollständiger Code und Ausgabe:

Alternative 2: Verwendung von Math.floorMod()

Der floorMod() ist eine integrierte Methode der Java Math-Klasse. Es akzeptiert zwei ganzzahlige Werte, führt eine Division durch und ruft den Rest der angegebenen Zahlen ab. Um diese Methode zu verwenden, deklarieren und initialisieren Sie zunächst einige Ganzzahlvariablen:

int dividend = 125, divisor = 2;

Verwenden Sie nun die Methode Math.floorMod(), um die restlichen Eingabewerte abzurufen:

System.out.println("The Remainder: " + Math.floorMod(dividend, divisor));

Vollständiger Code und Ausgabe:

Alternative 3: Benutzerdefinierte Logik verwenden

Benutzer können den Rest gegebener Zahlen ermitteln, ohne den Modulo-Operator oder integrierte Methoden zu verwenden. Erstellen Sie dazu zunächst eine benutzerdefinierte Funktion, sagen wir „modulo()“. Die Funktion akzeptiert zwei ganzzahlige Parameter: „Dividend“ und „Divisor“. Führen Sie die Division durch Dividend und Divisor durch und multiplizieren Sie das Ergebnis mit dem Divisor. Subtrahieren Sie anschließend den resultierenden Wert von der Dividende und geben Sie das Endergebnis zurück:

public static int modulo(int dividend, int divisor) 
{ 
return (dividend - divisor * (dividend/divisor)); 
}

Rufen Sie nun in der Methode main() die Funktion modulo() mit den gewünschten Argumenten auf und drucken Sie das Ergebnis mit println() auf der Konsole aus:

System.out.println("The Remainder: " + modulo(172, 12));

Vollständiger Code und Ausgabe:

Dies fasst die Funktionsweise des Modulo-Operators von Java zusammen.

Abschließende Gedanken

Modulo, Moduloder „%„ ist ein arithmetischer Operator in Java, der eine Division der bereitgestellten Zahlen durchführt und die abruft Rest als Ausgabe. Es gibt zahlreiche Anwendungsfälle, wie zum Beispiel die Prüfung, ob die gegebene Zahl gerade oder ungerade ist, das Finden des nächsten oder vorherigen Index von kreisförmigen Arrays, das Umrechnen von Minuten in Stunden und vieles mehr. In diesem Beitrag wurden zehn verschiedene Anwendungsfälle des Modulo-Operators, der Unterschied zwischen Division und Modulo und einige geeignete Alternativen des Modulo-Operators besprochen.

Kommentar verfassen

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Nach oben scrollen