Dans cet article, je vais vous présenter un concept simple mais important qui consiste à ajouter deux nombres en Java. Mais avant d'aller de l'avant, je vous suggère de vous familiariser avec «Qu'est-ce que Java», les fonctionnalités de Java et comment installer Java sur votre système, que vous pouvez trouver dans les précédents . Cela vous aidera à saisir les concepts à venir rapidement et facilement. Les autres blogs de cette série de tutoriels Java écrits par notre des experts couvriront en profondeur tous les sujets importants de Java & J2EE,
Les pointeurs suivants seront traités dans cet article,
- Méthode 1
- Méthode 2
- Opérateur unaire répété
- Table de boucle initiale
- Opérateur Bitwise et Bitshift en Java
- Récursion
Alors commençons alors,
Ajout de deux nombres en Java
Méthode 1
Comprenons directement en développant un programme en Java pour imprimer «Ajout de deux nombres» à l’écran.
Classe AddTwoNumbers {public static void main (String [] args) {System.out.println ('Addition de deux nombres 10 + 20 est' + (10 + 20))}}
Production
Nous devons comprendre cela, ici les nombres sont ajoutés directement, disons 10 + 20 soit 30. Mais ce que nous obtenons des nombres de la console. Dans ce cas, les valeurs seront stockées dans une variable. En termes de Java, la variable de tableau String stockera ces nombres en fonction de leur index.
public class Main {public static void main (String [] args) {System.out.println ('Addition de deux nombres' + args [0] + '+' + args [1] + 'is' + (args [0 ] + args [1]))}}
La sortie pour cela sera comme indiqué dans la console lorsque nous transmettons le même nombre que 10 et 20.
Eh, le résultat que nous avons obtenu ici n'est pas souhaité 30. Rappelez-vous String [] args, chaque entrée que vous prenez de la console est représentée dans String. Nous devons donc convertir ces chaînes en nombre entier pour calculer l'addition.
public class Main {public static void main (String [] args) {//System.out.println('Addition of two numbers '+ args [0] +' + '+ args [1] +' is '+ (args [0] + args [1])) System.out.println ('Addition de deux nombres' + args [0] + '+' + args [1] + 'is' + (Integer.parseInt (args [0] ) + Integer.parseInt (args [1])))}}
Production
Maintenant, la sortie souhaitée est ce que nous voulons. C'est l'addition de 10 et 20 est 30 après que nous l'avons analysé de String à Integer.
Suivant dans cet article sur l'ajout de deux nombres en Java
Méthode 2
Utilisation de l'opérateur de soustraction: Nous pouvons utiliser la soustraction pour ajouter deux nombres tels que cela annulera la valeur négative et aboutira ainsi à l'addition.
public class AddTwoNumbers {public static int add (int a, int b) {return a - (-b)} public static void main (String [] args) {System.out.println (add (10, 20)) System. out.println (ajouter (-10, 20))}}
Ouput
30
dix
Suivant dans cet article sur l'ajout de deux nombres en Java
Opérateur unaire répété
Cela implique une boucle while, l'idée de base derrière cela est de ramener la valeur du premier opérande à zéro. Et de continuer à incrémenter son deuxième opérande correspondant du même nombre d'itérations. Considérez vous-même l'exemple ci-dessous.
public class HelloWorld {public static void main (String [] args) {System.out.println ('add' + add (10, 20)) System.out.println ('add' + add (-10, 20)) } public static int add (int a, int b) {//System.out.println ('--->' + a + ':' + b) while (a> 0) {//System.out.println ('while a> 0 --->' + a + ':' + b) b ++ a--} while (a<0) { //System.out.println('while a ' + a + ' : ' + b) b-- a++ } //System.out.println('return b--->'+ a +': '+ b) retourne b}}
Ouput
$ javac HelloWorld.java $ java -Xmx128M -Xms16M HelloWorld ajouter 30 ajouter 10
Suivant dans cet article sur l'ajout de deux nombres en Java
Opérateur Bitwise et Bitshift en Java
Nous pouvons également faire l'addition de deux entiers en utilisant l'opérateur bit à bit XOR et le report peut être obtenu par l'opérateur AND. Pour ajouter le report à la somme, nous devons utiliser l'opérateur de décalage gauche signé. Comment cela se passe-t-il? Voyons d'abord un exemple.
public class HelloWorld {public static void main (String [] args) {System.out.println ('Addition using + ve' + addUsingBits (10, 20)) System.out.println ('Addition using -ve' + addUsingBits ( -10, 20))} public static int addUsingBits (int a, int b) {while (b! = 0) {int carry = (a & b) a = a ^ bb = carry<< 1 } return a } }
Production
$ javac HelloWorld.java
$ java -Xmx128M -Xms16M HelloWorld
Ajout avec + ve 30
Addition avec -ve 10
Rappelez-vous toujours que l'opération XOR est utilisée pour évaluer l'addition de deux bits. L'opération ET est utilisée pour évaluer le report de deux bits. Disséquons ça, d'accord? En suivant les valeurs d’entrée, prenons a = 10 et b = 20 pour la première condition.
Opération | Évaluation d'expression | Equivalent binaire | Valeur décimale |
à | dix | 00001010 | dix |
b | vingt | 00010100 | vingt |
tandis que (b! = 0) | vrai | ||
int porter = (a & b) | 10 et 20 | 0 | 0 |
a = a ^ b | 10 ^ 20 | 00011110 | 30 |
b = porter<< 1 | 0<< 1 | 0 | 0 |
retourner un | 30 | 00011110 | 30 |
Maintenant, prenons une entrée négative, disons -10 pour un. Examinons ce qui se passe dans le tableau ci-dessous.Cela nous permet de faire une boucle jusqu'à ce que la valeur décimale du report devienne négative.
Suivant dans cet article sur l'ajout de deux nombres en Java
Table de boucle initiale
Opération | Évaluation d'expression | Equivalent binaire | Valeur décimale |
à | -dix | 11110110 | -dix |
b | vingt | 00010100 | vingt |
tandis que (b! = 0) | vrai | ||
int porter = (a & b) comment éviter les blocages en java | -10 et 20 | 00010100 | vingt |
a = a ^ b | -10 ^ 20 | 11100010 | -30 |
b = porter<< 1 | vingt<< 1 | 00101000 | 40 |
Boucle 1.
générer une chaîne aléatoire en java
Opération | Évaluation d'expression | Equivalent binaire | Valeur décimale |
à | -30 | 11100010 | -30 |
b | 40 | 00101000 | 40 |
tandis que (b! = 0) | vrai | ||
int porter = (a & b) | -30 et 40 | 00100000 | 32 |
a = a ^ b | -30 ^ 40 | 11001010 | -54 |
b = porter<< 1 | 32<< 1 | 00101000 | 64 |
Et ainsi de suite & hellip jusqu'à ce que la boucle se révèle être b = 0 par souci de brièveté, tous les résultats ne sont pas affichés ici. Le tableau ci-dessous représente donc la dernière boucle de cette opération.
Opération | Évaluation d'expression | Equivalent binaire | Valeur décimale |
à | -2147483638 | 11111111111111111111111111111110000000000000000000000000001010 | -2147483638 |
b | -2147483648 | 11111111111111111111111111111110000000000000000000000000000000 | -2147483648 |
tandis que (b! = 0) | vrai | ||
int porter = (a & b) | -2147483638 et -2147483648 | 11111111111111111111111111111110000000000000000000000000000000 | -2147483648 |
a = a ^ b | -2147483638 ^ -2147483648 | 00001010 | dix |
b = porter<< 1 | -2147483648<< 1 | 0 | 0 |
retourner un | dix | 00001010 | dix |
C’est ainsi que l’addition a été calculée. Phew! tant pour la pensée. Pensez simplement si ce calcul a été fait manuellement par des humains, principalement des calculs binaires.
Suivant dans cet article sur l'ajout de deux nombres en Java
Récursion
Nous pouvons également écrire le programme ci-dessus en utilisant la récursivité. La partie calcul diffère légèrement permet de considérer cela pour les devoirs pour vous, d'accord? Je vais donner l'extrait ici pour la récursivité et vous essayez de construire votre propre table afin que vous sachiez comment cela fonctionne en interne. En outre, pas besoin de muger tout cela qui est uniquement à des fins de représentation à moins que vous ne soyez enthousiasmé par le fonctionnement interne ici.
public static int addUsingRecursion (int a, int b) {if (b == 0) return a int sum = a ^ b int carry = (a & b)<< 1 return add(sum, carry) }
Tout cela pour l'ajout de deux nombres en Java avec l'opérateur + et sans l'opérateur +. La raison pour laquelle l'une ou l'autre de ces options dépendra entièrement des besoins et des exigences du projet.
Je n'ai pas évalué et testé le fonctionnement des deux scénarios pour arriver à des performances. Je suppose que cela n'entrera en vigueur que si vous construisez la fusée et la livrez dans l'espace.
Je n'ai expliqué que les nombres liés aux entiers par souci de brièveté qui a sa propre limite de mémoire. Je vous laisse le soin d'explorer davantage en utilisant float, double, etc. Rappelez-vous toujours que si vous dépassez la valeur limite des types primitifs, le résultat affichera une réponse différente.
Vérifiez par Edureka, une entreprise d'apprentissage en ligne de confiance avec un réseau de plus de 250 000 apprenants satisfaits répartis dans le monde entier. Nous sommes là pour vous aider à chaque étape de votre voyage, pour devenir votre meilleur, nous proposons un programme conçu pour les étudiants et les professionnels qui souhaitent devenir un développeur Java.