ఈ వ్యాసంలో, జావాలో రెండు సంఖ్యలను కలిపే సరళమైన ఇంకా ముఖ్యమైన భావనను నేను మీకు పరిచయం చేయబోతున్నాను. కానీ ముందుకు వెళ్ళే ముందు, “జావా అంటే ఏమిటి”, జావా యొక్క లక్షణాలు మరియు మీ సిస్టమ్‌లో మీరు జావాను ఎలా ఇన్‌స్టాల్ చేయవచ్చు అనేదాని గురించి తెలుసుకోవాలని నేను మీకు సూచిస్తాను. . ఇది రాబోయే భావనలను త్వరగా మరియు సులభంగా పట్టుకోవడంలో మీకు సహాయపడుతుంది. మా రాసిన ఈ జావా ట్యుటోరియల్ సిరీస్‌లోని ఇతర బ్లాగులు నిపుణులు జావా & జె 2 ఇఇ యొక్క అన్ని ముఖ్యమైన విషయాలను లోతుగా కవర్ చేస్తారు,
ఈ వ్యాసంలో క్రింది గమనికలు కవర్ చేయబడతాయి,
- విధానం 1
- విధానం 2
- పునరావృత యునరీ ఆపరేటర్
- ప్రారంభ లూప్ పట్టిక
- జావాలో బిట్‌వైస్ మరియు బిట్‌షిఫ్ట్ ఆపరేటర్
- పునరావృతం
కాబట్టి అప్పుడు ప్రారంభిద్దాం,
జావాలో రెండు సంఖ్యలను చేర్చడం
విధానం 1
తెరపై “రెండు సంఖ్యల సంకలనం” ముద్రించడానికి జావాలో ఒక ప్రోగ్రామ్‌ను అభివృద్ధి చేయడం ద్వారా నేరుగా అర్థం చేసుకుందాం.
క్లాస్ AddTwoNumbers {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {System.out.println (“10 + 20 అనే రెండు సంఖ్యలను చేర్చడం” + (10 + 20%)}}అవుట్పుట్
దీన్ని మనం అర్థం చేసుకోవాలి, ఇక్కడ సంఖ్యలు నేరుగా జోడించబడతాయి 10 + 20 అంటే 30 అని చెప్పండి. కాని మనకు కన్సోల్ నుండి సంఖ్యలు లభిస్తాయి. అలాంటప్పుడు విలువలు వేరియబుల్‌లో నిల్వ చేయబడతాయి. జావా పరంగా, స్ట్రింగ్ అర్రే వేరియబుల్ ఆ సంఖ్యలను వాటి సూచిక ఆధారంగా నిల్వ చేస్తుంది.
పబ్లిక్ క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {System.out.println ('రెండు సంఖ్యల కలయిక' + అర్గ్స్ [0] + '+' + అర్గ్స్ [1] + 'అనేది' + (అర్గ్స్ [0 ] + అర్గ్స్ [1]))}}మేము 10 మరియు 20 అదే సంఖ్యను దాటినప్పుడు దీని యొక్క అవుట్పుట్ కన్సోల్లో చూపిన విధంగా ఉంటుంది.
ఇహ్, మేము ఇక్కడ పొందిన ఫలితం కోరుకోలేదు 30. స్ట్రింగ్ [] అర్గ్స్ గుర్తుంచుకోండి, మీరు కన్సోల్ నుండి తీసుకునే ప్రతి ఇన్పుట్ స్ట్రింగ్లో సూచించబడుతుంది. కాబట్టి ఇక్కడ మనం అదనంగా లెక్కించడానికి ఆ తీగలను పూర్ణాంకంగా మార్చాలి.
పబ్లిక్ క్లాస్ మెయిన్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {//System.out.println( 'రెండు సంఖ్యల సంకలనం' + అర్గ్స్ [0] + '+' + అర్గ్స్ [1] + 'అనేది' + (అర్గ్స్ [0] + args [1])) System.out.println ('రెండు సంఖ్యల కలయిక' + args [0] + '+' + args [1] + 'is' + (Integer.parseInt (args [0] ) + Integer.parseInt (అర్గ్స్ [1])))}}అవుట్పుట్
ఇప్పుడు కావలసిన అవుట్పుట్ మనకు కావాలి. మేము 10 ను స్ట్రింగ్ నుండి ఇంటీజర్ వరకు అన్వయించిన తర్వాత 30 మరియు 20 అదనంగా ఉంటుంది.
జావాలో రెండు సంఖ్యల సంకలనంపై ఈ వ్యాసంలో తదుపరిది
విధానం 2
వ్యవకలనం ఆపరేటర్‌ను ఉపయోగించడం: ప్రతికూల సంఖ్యను తిరస్కరించే రెండు సంఖ్యలను జోడించడానికి మేము వ్యవకలనాన్ని ఉపయోగించవచ్చు మరియు తద్వారా అదనంగా వస్తుంది.
పబ్లిక్ క్లాస్ AddTwoNumbers {పబ్లిక్ స్టాటిక్ Int యాడ్ (int a, int b) {రిటర్న్ a - (-b)} పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {System.out.println (జోడించు (10, 20)) సిస్టమ్. out.println (జోడించు (-10, 20%)}}.పుట్
30
10
జావాలో రెండు సంఖ్యల సంకలనంపై ఈ వ్యాసంలో తదుపరిది
పునరావృత యునరీ ఆపరేటర్
ఇది లూప్ అయితే ఉంటుంది, దీని వెనుక ఉన్న ప్రాథమిక ఆలోచన మొదటి ఒపెరాండ్ విలువను సున్నాకి తీసుకురావడం. మరియు దాని సంబంధిత రెండవ ఆపరేషన్‌ను అదే మొత్తంలో పునరావృతం చేయడం ద్వారా కొనసాగించడం. ఈ క్రింది ఉదాహరణను మీరే పరిశీలించండి.
పబ్లిక్ క్లాస్ హలోవర్ల్డ్ {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {System.out.println ('add' + add (10, 20%) System.out.println ('add' + add (-10, 20%) } పబ్లిక్ స్టాటిక్ Int యాడ్ (int a, int b) {//System.out.println ('--->' + a + ':' + b) అయితే (a> 0) {//System.out.println ('అయితే a> 0 --->' + a + ':' + b) b ++ a--} ఉండగా (a<0) { //System.out.println('while a ' + a + ' : ' + b) b-- a++ } //System.out.println('return b--->'+ a +': '+ b) తిరిగి b}}.పుట్
$ javac HelloWorld.java $ java -Xmx128M -Xms16M HelloWorld add 30 add 10
జావాలో రెండు సంఖ్యల సంకలనంపై ఈ వ్యాసంలో తదుపరిది
జావాలో బిట్‌వైస్ మరియు బిట్‌షిఫ్ట్ ఆపరేటర్
XOR బిట్‌వైస్ ఆపరేటర్‌ను ఉపయోగించడం ద్వారా మేము రెండు పూర్ణాంకాల చేరికను కూడా చేయవచ్చు మరియు AND ఆపరేటర్ ద్వారా పొందవచ్చు. మొత్తాన్ని తీసుకువెళ్ళడానికి మేము సంతకం చేసిన ఎడమ షిఫ్ట్ ఆపరేటర్‌ని ఉపయోగించాలి. ఇది ఎలా జరుగుతుంది? మొదట ఒక ఉదాహరణ చూద్దాం.
పబ్లిక్ క్లాస్ హలోవర్ల్డ్ {పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {System.out.println ('+ ve ఉపయోగించి + అదనంగా' + addUsingBits (10, 20%) System.out.println ('-ve ఉపయోగించి అదనంగా' + addUsingBits ( -10, 20))} పబ్లిక్ స్టాటిక్ Int addUsingBits (int a, int b) {అయితే (b! = 0) {int carry = (a & b) a = a ^ bb = carry<< 1 } return a } }అవుట్పుట్
$ జావాక్ హలోవర్ల్డ్.జావా
$ java -Xmx128M -Xms16M HelloWorld
+ Ve 30 ఉపయోగించి అదనంగా
-V 10 ఉపయోగించి అదనంగా
system.exit (0)
ఎల్లప్పుడూ గుర్తుంచుకోండి, రెండు బిట్ల కలయికను అంచనా వేయడానికి XOR ఆపరేషన్ ఉపయోగించబడుతుంది. మరియు ఆపరేషన్ రెండు బిట్స్ యొక్క క్యారీని అంచనా వేయడానికి ఉపయోగించబడుతుంది. దీనిని మనం విడదీయాలా? ఇన్పుట్ విలువల ద్వారా వెళితే మొదటి షరతు కోసం = 10 మరియు బి = 20 తీసుకుందాం.
ఆపరేషన్ | వ్యక్తీకరణ మూల్యాంకనం | బైనరీ సమానం | దశాంశ విలువ |
కు | 10 | 00001010 | 10 |
బి | ఇరవై | 00010100 | ఇరవై |
అయితే (బి! = 0) | నిజం | ||
int క్యారీ = (a & b) | 10 & 20 | 0 | 0 |
a = a ^ b | 10 ^ 20 | 00011110 | 30 |
b = క్యారీ<< 1 | 0<< 1 | 0 | 0 |
తిరిగి a | 30 | 00011110 | 30 |
ఇప్పుడు, a కోసం నెగటివ్ ఇన్పుట్ చెప్పండి -10. దిగువ పట్టికలో ఏమి జరుగుతుందో పరిశీలిద్దాం.క్యారీ యొక్క దశాంశ విలువ ప్రతికూలంగా వచ్చే వరకు ఇది లూప్‌లోకి అనుమతిస్తుంది.
జావాలో రెండు సంఖ్యల సంకలనంపై ఈ వ్యాసంలో తదుపరిది
ప్రారంభ లూప్ పట్టిక
ఆపరేషన్ | వ్యక్తీకరణ మూల్యాంకనం | బైనరీ సమానం | దశాంశ విలువ |
కు | -10 | 11110110 | -10 |
బి | ఇరవై | 00010100 | ఇరవై |
అయితే (బి! = 0) | నిజం | ||
int క్యారీ = (a & b) | -10 & 20 | 00010100 | ఇరవై |
a = a ^ b | -10 ^ 20 | 11100010 | -30 |
b = క్యారీ<< 1 | ఇరవై<< 1 | 00101000 | 40 |
లూప్ 1.
ఆపరేషన్ | వ్యక్తీకరణ మూల్యాంకనం | బైనరీ సమానం | దశాంశ విలువ |
కు | -30 | 11100010 | -30 |
బి | 40 | 00101000 | 40 పట్టికలో కాంటెక్స్ట్ ఫిల్టర్ అంటే ఏమిటి |
అయితే (బి! = 0) | నిజం | ||
int క్యారీ = (a & b) | -30 & 40 | 00100000 | 32 |
a = a ^ b | -30 ^ 40 | 11001010 | -54 |
b = క్యారీ<< 1 | 32<< 1 | 00101000 | 64 |
సంక్షిప్తత కోసం లూప్ బి = 0 గా మారే వరకు & హెల్ప్ అన్ని ఫలితాలు ఇక్కడ చూపబడవు. కాబట్టి దిగువ పట్టిక ఈ ఆపరేషన్‌లో చివరి లూప్‌ను సూచిస్తుంది.
ఆపరేషన్ | వ్యక్తీకరణ మూల్యాంకనం | బైనరీ సమానం | దశాంశ విలువ |
కు | -2147483638 | 11111111111111111111111111100000000000000000000001010 | -2147483638 |
బి | -2147483648 | 111111111111111111111111111000000000000000000000000000 | -2147483648 |
అయితే (బి! = 0) | నిజం | ||
int క్యారీ = (a & b) | -2147483638 & -2147483648 | 111111111111111111111111111000000000000000000000000000 | -2147483648 |
a = a ^ b | -2147483638 ^ -2147483648 | 00001010 | 10 |
b = క్యారీ<< 1 | -2147483648<< 1 | 0 | 0 |
తిరిగి a | 10 | 00001010 | 10 |
అందువల్ల అదనంగా లెక్కించబడుతుంది. ఓహ్! ఆలోచన కోసం చాలా. ఈ గణన మానవీయంగా మానవీయంగా జరిగిందా అని ఆలోచించండి, ప్రధానంగా బైనరీ లెక్కలు.
జావాలో రెండు సంఖ్యల సంకలనంపై ఈ వ్యాసంలో తదుపరిది
పునరావృతం
పునరావృతాన్ని ఉపయోగించి పై ప్రోగ్రామ్‌ను కూడా వ్రాయవచ్చు. గణన భాగం కొద్దిగా భిన్నంగా ఉంటుంది, మీ కోసం హోంవర్క్ కోసం దీనిని పరిగణించాలా? పునరావృతం కోసం నేను ఇక్కడ సారాన్ని ఇస్తాను మరియు మీరు మీ స్వంత పట్టికను నిర్మించడానికి ప్రయత్నిస్తారు, తద్వారా ఇది అంతర్గతంగా ఎలా పనిచేస్తుందో మీకు తెలుస్తుంది. అలాగే, మీరు ఇక్కడ అంతర్గత పనుల గురించి ఉత్సాహంగా ఉంటే తప్ప ప్రాతినిధ్య ప్రయోజనం కోసం మాత్రమే ఇవన్నీ కప్పుకోవలసిన అవసరం లేదు.
పబ్లిక్ స్టాటిక్ Int addUsingRecursion (int a, int b) {if (b == 0) ఒక int sum = a ^ b int carry = (a & b)<< 1 return add(sum, carry) }జావాలో + ఆపరేటర్‌ను ఉపయోగించకుండా మరియు + ఆపరేటర్‌ను ఉపయోగించకుండా రెండు సంఖ్యలను చేర్చడానికి ఇదంతా జరిగింది. ఈ రెండింటికి వెళ్ళడానికి కారణం పూర్తిగా ప్రాజెక్ట్ అవసరం మరియు అవసరం మీద ఆధారపడి ఉంటుంది.
పనితీరుతో ముందుకు రావడానికి నేను రెండు దృష్టాంతాల పనిని అంచనా వేయలేదు మరియు పరీక్షించలేదు. మీరు రాకెట్‌ను నిర్మించి అంతరిక్షంలోకి పంపిస్తేనే అది అమలులోకి వస్తుందని నేను ess హిస్తున్నాను.
నేను దాని స్వంత మెమరీ పరిమితిని కలిగి ఉన్న సంక్షిప్తత కోసం పూర్ణాంకాలకు సంబంధించిన సంఖ్యలను మాత్రమే వివరించాను. ఫ్లోట్, డబుల్ మొదలైనవాటిని ఉపయోగించి మరింత అన్వేషించడానికి నేను మీకు వదిలివేస్తున్నాను. మీరు ఆదిమ రకాల పరిమితి విలువను మించిపోతే ఫలితం భిన్నమైన సమాధానం చూపుతుందని గుర్తుంచుకోండి.
చూడండి ప్రపంచవ్యాప్తంగా విస్తరించి ఉన్న 250,000 మందికి పైగా సంతృప్తికరమైన అభ్యాసకుల నెట్‌వర్క్‌తో విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. మీ ప్రయాణంలో అడుగడుగునా మీకు సహాయం చేయడానికి మేము ఇక్కడ ఉన్నాము, మీ ఉత్తమంగా మారడానికి, మేము జావా డెవలపర్‌గా ఉండాలనుకునే విద్యార్థులు మరియు నిపుణుల కోసం రూపొందించిన ఒక పాఠ్యాంశంతో ముందుకు వచ్చాము.