Introduzione agli operatori Java: logici, aritmetici, bit a bit

Parliamo delle operazioni in Java: numeriche, logiche, bit per bit. Questa è una base teorica sicuramente necessaria per imparare a programmare.

• Quali sono i tipi di operatori in Java?
• Corso Operatori Java nel JavaRush
• Operazioni sui numeri in Java
• Operazioni logiche in Java
• Operazioni bit a bit in Java
• Precedenza delle operazioni in Java
• Esempi utili di utilizzo

Quali sono i tipi di operatori in Java?

Per qualsiasi operazione abbiamo bisogno di almeno due cose:

• operatore;
• operando.

Un esempio di operatore potrebbe essere un semplice vantaggio nell'operazione di somma di due numeri. E i numeri sommati tra loro saranno operandi in questo caso. Quindi, con l'aiuto degli operatori, eseguiamo operazioni su uno o più operandi. Gli operatori che eseguono operazioni su due operandi sono detti binari. Ad esempio, sommando due numeri. Gli operatori che eseguono operazioni su un singolo operando sono detti unari. Ad esempio, un meno unario.

Corso Operatori Java nel JavaRush

Diverse lezioni sono dedicate agli operatori Java al quarto livello della prima ricerca: Sintassi Java. In particolare, gli operatori condizionali come boolean . Il corso contiene 22 attività che ti aiuteranno a comprendere il lavoro degli operatori di confronto, degli operatori condizionali e degli operatori logici.

Operazioni sui numeri in Java

L'operazione più comune che i programmatori eseguono sui numeri è assegnare un valore numerico a una variabile. Lei, come l'operatore, =ti è familiare:

int a = 1;
int b = 2;
int c = 3;

Ci sono anche operazioni aritmetiche. Vengono eseguiti utilizzando operatori aritmetici binari: Tabella 1. Operatori aritmetici binari I primi quattro operatori non dovrebbero sollevare alcuna domanda: tutto è uguale alla matematica. Anche l'ultimo operatore, il resto della divisione, non fa nulla di troppo complicato. Ad esempio, se dividiamo 24 per 7, otteniamo 3 numeri interi e 3 resti. È il resto che questo operatore restituirà:

System.out.println(24 % 7); // prints 3

Ecco alcuni esempi dal sito ufficiale della documentazione Oracle: Questo programma restituirà quanto segue: 1 + 2 = 3 3 - 1 = 2 2 * 2 = 4 4 / 2 = 2 2 + 8 = 10 10 % 7 = 3 Java ti consente da combinare: ad esempio, assegnazioni di operatori e operatori aritmetici. Diamo un'occhiata ad un esempio:

int x = 0;
x = x + 1; // x = 0 + 1 => x = 1
x = x + 1; // x = 1 + 1 => x = 2
x = x + 1; // x = 2 + 1 => x = 3

Qui abbiamo definito una variabile xe le abbiamo assegnato il valore zero. Successivamente, in ogni riga assegniamo un valore xalla somma del valore corrente della variabile xe uno. Ci sono spiegazioni nei commenti per ogni riga. Questa procedura è chiamata crescita o incremento di una variabile. L'operazione di incremento dell'esempio precedente può essere sostituita con un'altra simile utilizzando una combinazione di operatori:

int x = 0;
x += 1; // x = 0 + 1 => x = 1
x += 1; // x = 1 + 1 => x = 2
x += 1; // x = 2 + 1 => x = 3

Puoi combinare l'operatore di assegnazione con qualsiasi operatore aritmetico:

int x = 0;
x += 10; // x = 0 + 10 => x = 10
x -= 5; // x = 10 - 5 => x = 5
x *= 5; // x = 5 * 5 => x = 25
x /= 5; // x = 25 / 5 => x = 5
x %= 3; // x = 5 % 3 => x = 2;

Dimostriamo come funziona l'ultimo esempio: Oltre agli operatori binari, Java ha operatori aritmetici unari. Tabella 2. Operatori aritmetici unari: Esempio di più e meno unari:

int x = 0;
x = (+5) + (+15); // Parentheses for clarity, it is possible without them
System.out.println("x = " + x);

int y = -x;
System.out.println("y = " + y);

Le operazioni di incremento e decremento sono essenzialmente semplici. Nel primo caso la variabile viene incrementata di 1, nel secondo la variabile viene decrementata di 1. Di seguito l'esempio:

int x = 9;
x++;
System.out.println(x); // 10

int y = 21;
y--;
System.out.println(y); // 20

Esistono due tipi di queste operazioni: suffisso e prefisso. Nel primo caso l'operatore viene scritto dopo la variabile, nel secondo caso prima della variabile. L'unica differenza è quando viene eseguita l'operazione di incremento o decremento. Esempio e descrizione nella tabella seguente. Diciamo che abbiamo una variabile:

int a = 2;

Poi: Tabella 3. Operatori di incremento-decremento: Dimostrazione: Oltre all'aritmetica, ci sono operazioni di confronto (di due numeri). Il risultato sarà sempre vero o falso ( vero / falso ). Tabella 4. Operatori di confronto Esempi:

int a = 1;
int b = 2;

boolean comparisonResult = a == b;
System.out.println("a == b :" + comparisonResult);

comparisonResult = a != b;
System.out.println("a != b :" + comparisonResult);

comparisonResult = a > b;
System.out.println("a >  b :" + comparisonResult);

comparisonResult = a >= b;
System.out.println("a >= b :" + comparisonResult);

comparisonResult = a < b;
System.out.println("a <  b :" + comparisonResult);

comparisonResult = a <= b;
System.out.println("a <= b :" + comparisonResult);

Dimostrazione:

Operazioni logiche in Java

Diamo un'occhiata alle operazioni logiche e alle tabelle di verità di ciascuno di essi:

• operazione di negazione ( NOT);
• operazione di congiunzione, AND logico ( AND);
• operazione di disgiunzione, OR logico ( OR);
• Operazione di addizione modulo, OR esclusivo ( XOR).

L'operatore di negazione è unario e si applica a un singolo operando. Tutte le altre operazioni sono binarie. Consideriamo le tavole di verità di queste operazioni. Qui 0 è l'equivalente di false in Java e 1 è l'equivalente di true . Tabella 5. Tabella della verità degli operatori di negazione (NOT) Tabella 6. Tabella di verità dell'operatore di congiunzione (AND) Tabella 7. Tavola di verità dell'operatore di disgiunzione (OR) Tabella 8. Tabella della verità dell'operatore di addizione del modulo (XOR) Java ha le stesse operazioni logiche:

• !— operatore di negazione;
• &&— operatore logico AND (breve);
• ||— operatore logico OR (breve);
• &— operatore AND bit per bit;
• |— operatore OR bit per bit;
• ^— operatore OR esclusivo bit per bit.

Di seguito diamo un'occhiata alla differenza tra gli operatori bit a bit e quelli abbreviati, mentre convertiamo tutte le tabelle di verità in codice Java:

public class LogicDemo {

   public static void main(String[] args) {
    notExample();
    andExample();
    orExample();
    xorExample();
   }

   public static void notExample() {
    System.out.println("NOT EXAMPLE:");
    System.out.println("NOT false = " + !false);
       System.out.println("NOT true  = " + !true);
    System.out.println();
   }

   public static void andExample() {
    System.out.println("AND EXAMPLE:");
    System.out.println("false AND false = " + (false & false));
    System.out.println("false AND true  = " + (false & true));
    System.out.println("true  AND false = " + (true & false));
    System.out.println("true  AND true  = " + (true & true));
    System.out.println();
   }

   public static void orExample() {
    System.out.println("OR EXAMPLE:");
    System.out.println("false OR false = " + (false | false));
    System.out.println("false OR true  = " + (false | true));
    System.out.println("true  OR false = " + (true | false));
     System.out.println("true  OR true  = " + (true | true));
    System.out.println();
   }

   public static void xorExample() {
    System.out.println("XOR EXAMPLE:");
    System.out.println("false XOR false = " + (false ^ false));
    System.out.println("false XOR true  = " + (false ^ true));
    System.out.println("true  XOR false = " + (true ^ false));
    System.out.println("true  XOR true  = " + (true ^ true));
    System.out.println();
   }
}

Questo programma visualizzerà: NON ESEMPIO: NON falso = vero NON vero = falso ED ESEMPIO: falso AND falso = falso falso AND vero = falso vero AND falso = falso vero AND vero = vero O ESEMPIO: falso OR falso = falso falso OR vero = vero vero OR falso = vero vero OR vero = vero XOR ESEMPIO: falso XOR falso = falso falso XOR vero = vero vero XOR falso = vero vero XOR vero = falso Gli operatori logici si applicano solo alle booleanvariabili. Nel nostro caso, li abbiamo applicati direttamente ai valori, ma puoi anche usarli con booleanle variabili: E alle booleanespressioni: Ora abbiamo gli operatori abbreviati ( &&, ||) e operatori bit a bit simili ( &, |). Qual'è la differenza tra loro? Innanzitutto, bit a bit può essere applicato agli interi. Ne parleremo un po' più tardi. E in secondo luogo, alcuni sono abbreviati, mentre altri no. Per capire come appare l'abbreviazione, diamo un'occhiata all'espressione:

false AND x = ?
true OR x = ?

Può xassumere qualsiasi valore booleano. E in generale, secondo le leggi della logica e delle tabelle di verità, indipendentemente dal fatto che sia x vero o falso , il risultato della prima espressione sarà falso e il risultato della seconda sarà vero . Aspetto. A volte il risultato di un'espressione può essere calcolato dal primo operando. Questo è ciò che distingue gli operatori abbreviati &&e ||. Nelle espressioni simili a quelle sopra descritte non valutano il valore del secondo operando. Ecco un piccolo esempio: Nel caso degli operatori abbreviati la seconda parte dell'espressione non viene valutata. Ma questo accade solo quando il risultato dell'espressione è già evidente dal primo operando.

Operazioni bit a bit in Java

Bene, qui arriviamo alla parte più interessante: le operazioni bit a bit. Come suggerisce il nome, si tratta di operazioni che vengono eseguite sui bit. Ma prima di approfondire questo argomento, vale la pena parlare delle aree correlate.

Rappresentazione dei numeri nel sistema numerico binario

I numeri, come qualsiasi altra informazione in un programma, vengono archiviati nella memoria del computer in codice binario. Il codice binario è un insieme di zeri e uno. Ogni zero o uno rappresenta un'unità di informazione chiamata bit.

Secondo Wikipedia:

Un bit (dall'inglese Binary Digit - numero binario; anche un gioco di parole: inglese Bit - pezzo, particella) è un'unità di misura della quantità di informazioni. 1 bit di informazione è un simbolo o segnale che può assumere due significati: acceso o spento, sì o no, alto o basso, carico o scarico; nel sistema binario è 1 (uno) o 0 (zero).

Con che tipo di dati lavorano gli operatori bit a bit?

Le operazioni bit a bit in Java vengono eseguite solo su numeri interi. I numeri interi vengono archiviati nella memoria del computer come un insieme di bit. Possiamo dire che un computer converte qualsiasi informazione in un sistema di numeri binari (un insieme di bit) e solo successivamente interagisce con esso. Ma come funziona il sistema dei numeri binari? Nel sistema numerico decimale abbiamo solo 10 simboli: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. Usiamo questi simboli per contare. Dopo 9 arriva 10, dopo 19 - 20, dopo 99 - 100, dopo 749 - 750. Cioè, usiamo una combinazione dei 10 simboli disponibili e possiamo usarli per contare "da zero a pranzo". Nel sistema numerico binario, invece di dieci simboli, ce ne sono solo due: 0, 1. Ma combinando questi simboli secondo lo stesso principio del sistema decimale, possiamo contare all'infinito. Dimostriamo il conteggio da 0 a 15 in decimale e binario: Come puoi vedere, tutto non è così complicato. Oltre ai bit, esistono altre unità di informazione familiari: byte , kilobyte , megabyte , gigabyte , ecc. Probabilmente sai che ci sono 8 bit in 1 byte . Cosa significa? Ciò significa che 8 bit consecutivi occupano 1 byte. Ecco alcuni esempi di cosa possono essere i byte:

00000000 - 1 byte
10110010 - 1 byte
01011011 - 1 byte

Il numero di possibili combinazioni non ripetitive di bit in un byte è 256 (2 ⁸ = 256). Ma torniamo più vicino a Java. Esiste un tipo di dati intero - byte. Questo tipo può assumere valori da -128 a 127 e un numero nella memoria del computer occupa esattamente 8 bit, ovvero 1 byte. Un numero di questo tipo occupa esattamente 1 bytememoria del computer. E qui i nomi coincidono non a caso. Come ricordiamo, 1 byte può memorizzare 256 valori diversi. E un numero tipo bytepuò assumere 256 valori diversi (128 negativi, 127 positivi e 1 zero). Ogni valore numerico byteha un set univoco di otto bit. Questo è il caso non solo di type byte, ma di tutti i tipi integrali. Il tipo byteviene fornito come esempio come il più piccolo. La tabella seguente mostra tutti i tipi interi Java e lo spazio di memoria che occupano: Considera il tipo int. Può memorizzare 2147483648 valori negativi, 2147483647 valori positivi e uno zero. Totale:

2147483648 + 2147483647 + 1 = 4294967296.

Questo tipo occupa 32 bit nella memoria del computer. Il numero di combinazioni possibili da un insieme di 32 zeri e uno è:

232 = 4294967296.

Lo stesso numero del numero di valori che il tipo può contenere int. Questa è solo una dimostrazione della relazione tra l'intervallo di valori di un tipo di dati e la sua dimensione (numero di bit in memoria). Qualsiasi numero di qualsiasi tipo in Java può essere convertito in binario. Vediamo con quanta facilità è possibile farlo utilizzando il linguaggio Java. Impareremo dall'esempio di type int. Questo tipo ha una propria classe wrapper - Integer. E ne ha uno toBinaryString, che farà tutto il lavoro per noi: Voilà: non è così complicato. Ma c’è ancora qualcosa da chiarire. intil numero richiede 32 bit. Ma quando stampiamo il numero 10 nell'esempio sopra, nella console vediamo 1010. Questo perché gli zeri iniziali non vengono stampati. Se fossero visualizzati, nella console vedremmo 000000000000000000000000000001010, ma per facilità di percezione tutti gli zeri iniziali vengono omessi. Non è così difficile finché non ti chiedi: che dire dei numeri negativi? Percepisce le informazioni solo nel sistema binario. Si scopre che anche il segno meno deve essere scritto in codice binario. Questo può essere fatto utilizzando codice diretto o complementare.

Codice diretto

Un metodo per rappresentare i numeri nel sistema numerico binario, in cui il bit più significativo (il bit più a sinistra) è assegnato al segno del numero. Se il numero è positivo, il bit più a sinistra viene scritto 0, se negativo - 1. Diamo un'occhiata a questo utilizzando un numero a 8 bit come esempio: L’approccio è semplice e, in linea di principio, comprensibile. Tuttavia, presenta degli svantaggi: difficoltà nell'esecuzione di operazioni matematiche. Ad esempio, con l'aggiunta di numeri negativi e positivi. Non possono essere piegati a meno che non vengano eseguite ulteriori manipolazioni.

Codice aggiuntivo

Utilizzando codice aggiuntivo è possibile evitare gli svantaggi del codice diretto. Esiste un semplice algoritmo per ottenere il codice aggiuntivo di un numero. Proviamo a ottenere il codice aggiuntivo per il numero -5. Rappresentiamo questo numero utilizzando il codice in complemento a due nel sistema numerico binario. Passaggio 1. Otteniamo una rappresentazione di un numero negativo utilizzando il codice diretto. Per -5 sarà 10000101. Passaggio 2. Invertire tutte le cifre tranne la cifra del segno. Sostituiamo tutti gli zeri con uno e quelli con zeri ovunque tranne il bit più a sinistra.

10000101 => 11111010

Passaggio 3. Aggiungi uno al valore risultante:

11111010 + 1 = 11111011

Pronto. Abbiamo ottenuto il valore di -5 nel sistema numerico binario utilizzando il codice in complemento a due. Ciò è importante per comprendere il materiale seguente, poiché Java utilizza il codice in complemento a due per memorizzare i numeri negativi in ​​bit.

Tipi di operazioni bit a bit

Ora che abbiamo affrontato tutte le introduzioni, parliamo delle operazioni bit a bit in Java. Un'operazione bit a bit viene eseguita su numeri interi e il suo risultato è un numero intero. Nel processo, il numero viene convertito in binario, viene eseguita un'operazione su ciascun bit e il risultato viene riconvertito in decimale. L'elenco delle operazioni è nella tabella seguente: Come abbiamo già scoperto, i numeri possono essere rappresentati come un insieme di bit. Le operazioni bit a bit eseguono operazioni esattamente su ciascun bit di tale rappresentazione. Prendiamo NOT, AND, OR, XOR. Ricordiamo che recentemente abbiamo esaminato le tabelle di verità solo per gli operandi logici. In questo caso le stesse operazioni vengono applicate a ciascun bit dell'intero.

Operatore unario bit a bit NOT ~

Questo operatore sostituisce tutti gli zeri con uno e tutti gli uno con zero. Diciamo che abbiamo il numero 10 in notazione decimale. In binario, questo numero è 1010. Se applichiamo l'operatore unario di negazione bit a bit a questo numero, otteniamo qualcosa del genere: Diamo un'occhiata a come appare nel codice Java:

public static void main(String[] args) {
   int a = 10;

   System.out.println(" a = " + a + "; binary string: " + Integer.toBinaryString(a));
   System.out.println("~a = " + ~a + "; binary string: " + Integer.toBinaryString(~a));
}

Vediamo ora cosa viene visualizzato nella console: Nella prima riga abbiamo il valore nel sistema numerico binario senza zeri iniziali. Anche se non li vediamo, sono lì. Ciò è evidenziato dalla seconda riga, in cui tutti i bit sono stati trasformati in inversi. Questo è il motivo per cui vediamo così tante unità leader. Questi sono i precedenti zeri iniziali che sono stati ignorati dal compilatore quando sono stati stampati sulla prima riga. Ecco un piccolo programma che visualizza anche gli zeri iniziali per chiarezza.

Operatore AND bit a bit

Questo operatore si applica a due numeri. Esegue un'operazione ANDtra i bit di ciascun numero. Facciamo un esempio: Questa operazione viene eseguita su due numeri. Esempio nel codice Java:

Operatore OR bit a bit

OR si applica a due numeri. Esegue un'operazione OR tra i bit di ciascun numero: Ora diamo un'occhiata a come apparirebbe in IDEA:

Operazione bit a bit, OR esclusivo (XOR)

Diamo un'occhiata allo stesso esempio, ma con una nuova operazione: Codice di esempio:

Spostamento bit per bit a sinistra

Questo operatore è applicabile a due operandi, ovvero nell'operazione x << yi bit del numero xsi sposteranno ydi posizione verso sinistra. Cosa significa? Consideriamo l'esempio dell'operazione: 10 << 1 il risultato dell'operazione sarà il numero 20 nel sistema decimale. Come puoi vedere dal diagramma sopra, tutti i bit vengono spostati a sinistra di 1. Durante questa operazione, il valore del bit più significativo (il bit più a sinistra) viene perso. E il bit meno significativo (il bit più a destra) è riempito con zero. Cosa puoi dire di questa operazione?

1. Spostando i bit di un numero Xdi Nbit verso sinistra, moltiplichiamo il numero Xper 2 ^N .

   Ecco un esempio:

2. Ma! Il segno del numero può cambiare se il bit con il valore 1 occupa la posizione più a sinistra.

3. Se ti sposti a sinistra indefinitamente, il numero diventerà semplicemente 0. Dimostriamo i punti 2 e 3:

Spostamento bit a destra a destra

Questo operatore si applica a due operandi. Quelli. nell'operazione x >> yi bit del numero xsi sposteranno ydi posizione verso destra. Diamo un'occhiata a un altro esempio. Analizziamo schematicamente il funzionamento 10 >> 1. Spostiamo tutti i bit del numero 10 di una posizione a destra: durante l'operazione di spostamento perdiamo i bit giusti. Semplicemente scompaiono. Il bit più a sinistra è il segno del numero (0 è positivo, 1 è negativo). Pertanto, nel valore finale viene inserito come nel numero originale. Esempio con un numero negativo: il bit più a destra viene perso e il bit più a sinistra viene copiato dal numero originale, come segno onorario del numero. Come fare tutto questo in IDEA? In linea di principio, niente di complicato, basta prenderlo e spostarlo: Ora. Cosa puoi dire dei numeri che vengono spostati a destra? Sono divisibili per 2. Ogni volta che ci spostiamo di un bit a destra, dividiamo il numero originale per 2. Se il numero non è divisibile per 2, il risultato verrà arrotondato verso meno infinito (verso il basso). Ma funziona solo se spostiamo i bit esattamente di 1. E se per 2 bit, dividiamo per 4. Per 3 bit, dividiamo per 8. Per 4 bit, dividiamo per 16. Vedi? Potenze di 2... Quando spostiamo un numero Xa Ndestra di bit, dividiamo il numero Xper 2 alla potenza di 2 N. Dimostrazione:

public class BitOperationsDemo {

   public static void main(String[] args) {

    for (int i = 1; i <= 10; i++) {

        int shiftOperationResult = 2048 >> i;
        int devideOperationResult = 2048 / (int) Math.pow(2, i);


           System.out.println(shiftOperationResult + " - " + devideOperationResult);
    }

   }

}

Cosa sta succedendo qui?

1. Un ciclo in cui la variabile i viene incrementata da 1 a 10.

2. Ad ogni iterazione calcoliamo 2 valori:

• Scriviamo nella variabile shiftOperationResultil risultato dello spostamento verso destra di i bit del numero 2048;

• devideOperationResultScriviamo il risultato della divisione del numero 2048 per 2 elevato alla i in una variabile .

3. Mostriamo i due valori ottenuti in coppia.

Il risultato dell'esecuzione del programma è il seguente: 1024 - 1024 512 - 512 256 - 256 128 - 128 64 - 64 32 - 32 16 - 16 8 - 8 4 - 4 2 - 2

Shift a destra bit per bit con riempimento zero

Mentre uno spostamento a destra normale preserva il segno del numero (il bit più significativo mantiene il suo valore), uno spostamento a destra con riempimento zero no. E il bit più significativo è riempito con zero. Vediamo come appare:

Precedenza delle operazioni in Java

Come la matematica, Java ha la precedenza sulle operazioni. La tabella seguente mostra la priorità (dalla più alta alla più bassa) delle operazioni da noi considerate.

Esempi utili di utilizzo

Determinazione della parità di un numero

Trovare l'elemento massimo in un array

Per trovare l'elemento minimo è sufficiente cambiare il segno di confronto nel posto giusto.