సమాచార సాంకేతికతలు
20వ శతాబ్దం చివరిలో ప్రారంభమైన కంప్యూటర్ విప్లవం 90వ దశకంలో ఇంటర్నెట్ (వెబ్) సృష్టికి దారితీసింది. మరియు అది మరింత గొప్ప విప్లవానికి నాంది. ఇంటర్నెట్ సృష్టి ప్రభావం పారిశ్రామికీకరణ వంటిది. అయితే ఈ ప్రక్రియ ఇప్పుడే ప్రారంభం కావడం విశేషం.
కొత్త ప్రపంచం
సైట్ పరిమాణం 200 మిలియన్లకు పైగా ఉంది. 3 బిలియన్ల మంది ఇంటర్నెట్ వినియోగదారులు ఉన్నారు. ఇంటర్నెట్ వేలం, వెబ్‌సైట్‌లు, ఆన్‌లైన్ షాపులు, ఇంటర్నెట్ సేవలు. ఇన్ఫర్మేషన్ టెక్నాలజీ పరిశ్రమ ఏటా 20%-30% వృద్ధి చెందుతోంది. ఇది భయంకరమైన రేట్లు. మరియు అది పెరుగుతూనే ఉంటుంది. సిలికాన్ వ్యాలీలో గత 10 సంవత్సరాలుగా (ప్రపంచంలోని హైటెక్ పరిశ్రమ యొక్క ప్రధాన కేంద్రం), ప్రతి 2 నెలలకు ఒక కంపెనీ సృష్టించబడుతుంది, దీని తర్వాత బిలియన్ల డాలర్లు ఖర్చవుతాయి. ఫేస్‌బుక్ ($220 బిలియన్), అమెజాన్ ($140 బిలియన్) మరియు గూగుల్ ($350 బిలియన్) వంటి ఇంటర్నెట్ స్టార్‌ల గురించి ప్రత్యేకంగా చెప్పనక్కర్లేదు. ఇంటర్నెట్ లేకపోతే ఈ కంపెనీలన్నీ కనిపించవు. ఇవన్నీ ఐటి-నిపుణులకు అధిక డిమాండ్‌ను కలిగిస్తాయి. ప్రపంచ హైటెక్ పరిశ్రమకు అవసరం: సాఫ్ట్‌వేర్ డెవలపర్లు, డిజైనర్లు, QA టెస్టర్‌లు, ఆర్కిటెక్ట్‌లు, మేనేజర్‌లు, సిస్టమ్ అడ్మినిస్ట్రేటర్‌లు మరియు ఇతర నిపుణులు.ఐటీ స్పెషలిస్ట్‌గా ఉండటం మంచిది
మీరు ఐటీ-స్పెషలిస్ట్ అయితే, ఇది మీకు గోల్డెన్ టైమ్. మీరు పెద్ద కంపెనీలో పని చేయవచ్చు మరియు చిన్న పట్టణంలో నివసించవచ్చు లేదా విదేశీ కంపెనీలో పని చేయవచ్చు. మీరు EU కంటే రెండు రెట్లు తక్కువ సంపాదించవచ్చు, ఉదాహరణకు, మీరు స్థానిక లేబర్ మార్కెట్‌లో 3-10 రెట్లు ఎక్కువ పొందుతారు. ఊరు ఎంత చిన్నదో అంత తేడా. మీరు విలువైన అనుభవం, మంచి డబ్బు మరియు ఉజ్వల భవిష్యత్తును అందుకుంటారు. కొన్నిసార్లు మీరు మీ యజమాని కార్యాలయానికి వ్యాపార పర్యటనలకు వెళతారు. మరియు మీరు చాలా ఇష్టపడితే, మీరు అక్కడికి మకాం మార్చవచ్చు. పెరుగుతున్న ఆటుపోట్లు అన్ని పడవలను ఎత్తివేస్తుంది. సరైన సమయంలో మరియు సరైన స్థలంలో ఉన్న అలాంటి పడవ ఎందుకు ఉండదు? ఇది కూడా ఒక కళ.
మీరు కొత్త స్థాయికి చేరుకున్నారు
స్థాయి 7
1 ఎల్లీ, అర్రేస్
- హే, అమిగో! - ఏమైంది, ఎల్లీ? - ఈ రోజు నేను మీకు కొత్త ఆసక్తికరమైన ఎంటిటీ - శ్రేణుల గురించి చెబుతాను. శ్రేణి అనేది ఒకటి కంటే ఎక్కువ విలువలను నిల్వ చేయగల ప్రత్యేక డేటా రకం.
- నేను సారూప్యతతో ప్రారంభిస్తాను. సాధారణ ఇల్లు మరియు ఎత్తైన గృహాన్ని పోల్చి చూద్దాం. ఒక ఇల్లు ఒకే కుటుంబంచే ఆక్రమించబడింది, అయితే ఎత్తైన భవనం అపార్ట్మెంట్లుగా విభజించబడింది. ఇంట్లో నివసించే కుటుంబానికి లేఖ రాయడానికి మీరు ప్రత్యేకమైన చిరునామాను పేర్కొనాలి. అపార్ట్మెంట్లో నివసించే కుటుంబం కోసం, మీరు తప్పనిసరిగా అపార్ట్మెంట్ నంబర్ను అదనంగా పేర్కొనాలి. - అవును, అది స్పష్టంగా ఉంది. - కాబట్టి, అర్రే వేరియబుల్ అనేది ఎత్తైన భవనం లాంటిది. మీరు దానిలో అనేక విలువలను నిల్వ చేయవచ్చు. ఇటువంటి వేరియబుల్ కొన్ని అపార్టుమెంట్లు (కణాలు) కలిగి ఉంటుంది. ప్రతి అపార్ట్‌మెంట్‌ను దాని సంఖ్య (ఇండెక్స్) ద్వారా యాక్సెస్ చేయవచ్చు.దీన్ని చేయడానికి, చతురస్రాకార బ్రాకెట్లలో వేరియబుల్ పేరు తర్వాత మీరు యాక్సెస్ చేయబడిన సెల్ యొక్క సూచికను తప్పనిసరిగా పేర్కొనాలి. ఇది చాలా సులభం. - నేను ఆశిస్తున్నాను. - శ్రేణి వేరియబుల్ (ఎత్తైన భవనం) ఏదైనా రకం కావచ్చు, కాబట్టి మీరు TypeName[] variable_nameబదులుగా వ్రాయవలసి ఉంటుంది TypeName variable_name. - మీరు శ్రేణులతో ఏమి చేయగలరో ఇక్కడ ఉదాహరణలు ఉన్నాయి: 
- ఎంత ఉత్తేజకరమైనది! - శ్రేణి వేరియబుల్‌కు అదనపు ప్రారంభీకరణ అవసరం. - ఎందుకని? - ఒక సాధారణ వేరియబుల్ దాని ప్రకటన తర్వాత ఉపయోగం కోసం సిద్ధంగా ఉంది. శ్రేణుల విషయానికొస్తే, ఇది కొంచెం క్లిష్టంగా ఉంటుంది: - మొదట, మీరు N మూలకాల యొక్క కంటైనర్‌ను సృష్టించాలి, ఆపై మీరు దానిలో విలువలను ఉంచవచ్చు. 
- అవును. ఇది ఇప్పుడు మరింత స్పష్టమవుతుంది. - శ్రేణుల గురించి ప్రాథమిక అంశాలు :
- శ్రేణి బహుళ కణాలను కలిగి ఉంటుంది.
- ప్రతి సెల్ దాని సంఖ్యను సూచించడం ద్వారా యాక్సెస్ చేయబడుతుంది.
- అన్ని కణాలు ఒకే రకమైనవి.
- n మూలకాల శ్రేణిలో, కణాలు 0,1,2,...,n-1 సూచికలను కలిగి ఉంటాయి. శ్రేణిలో సూచిక nతో సెల్ లేదు.
- అన్ని సెల్‌లకు ప్రారంభ విలువ శూన్యం, ఆదిమ రకాలకు – 0, పాక్షిక వాటికి 0.0, తప్పు - బూలియన్ రకానికి, సాధారణ అన్‌ఇనిషియలైజ్డ్ వేరియబుల్స్‌లో సరిగ్గా అదే.
- స్ట్రింగ్[] జాబితా అనేది వేరియబుల్ యొక్క డిక్లరేషన్ మాత్రమే. మొదట మీరు శ్రేణిని (కంటైనర్) సృష్టించాలి మరియు దానిని వేరియబుల్‌లో ఉంచాలి, ఆపై దాన్ని ఉపయోగించండి. దిగువ ఉదాహరణ చూడండి.
- మీరు ఆబ్జెక్ట్ శ్రేణిని (కంటైనర్) సృష్టించినప్పుడు, దాని పొడవును పేర్కొనడం అవసరం (అది ఎన్ని సెల్‌లను కలిగి ఉంటుంది). దీన్ని చేయడానికి మీరు ఆదేశాన్ని వ్రాయాలి: TypeName అనేది శ్రేణిలోని సెల్‌లలో నిల్వ చేయబడే విలువల రకం.
new TypeName[n];
- ఉదాహరణలు: 
2 రిషా, మెమరీలో శ్రేణుల అమరిక
- హే, అమిగో! మెమరీలో ఇవన్నీ ఎలా పనిచేస్తాయో నేను మీకు చూపిస్తాను:
- మరియు ఈ 345 అంటే ఏమిటి? - వాస్తవానికి, నేను దానిని గాలి నుండి తీసివేసాను, కానీ సాధారణంగా, ఇది "ఆపు" అనే పదాన్ని కలిగి ఉన్న స్ట్రింగ్ యొక్క చిరునామా. - శ్రేణుల విషయానికొస్తే, ఇది కొంచెం క్లిష్టంగా ఉంటుంది:
3 రిషా, శ్రేణుల ఉదాహరణలు అర్రే
- మీరు శ్రేణులతో చేయగలిగే ఆసక్తికరమైన విషయాల యొక్క కొన్ని ఉదాహరణలను నేను మీకు అందించాలనుకుంటున్నాను: ఉదాహరణ 1.
ఉదాహరణ 2. 
ఉదాహరణ 3. 
ఉదాహరణ 4. 
ఉదాహరణ 5. 
4 డియెగో, శ్రేణుల సృష్టి మరియు ఉపయోగం కోసం విధులు
- హే, అమిగో! మిత్రమా, మీ కోసం ఇక్కడ కొన్ని టాస్క్‌లు ఉన్నాయి:| పనులు | |
|---|---|
| 1 | 1. గరిష్టంగా 20 సంఖ్యల శ్రేణి 1. పద్దతిలో initializeArray() : 1.1. 20 సంఖ్యల శ్రేణిని సృష్టించండి 1.2. కీబోర్డ్ నుండి 20 సంఖ్యలను చదవండి మరియు వాటితో శ్రేణిని పూరించండి 2. పద్ధతి max(int[] array) శ్రేణి యొక్క మూలకాల యొక్క గరిష్ట సంఖ్యను కనుగొనాలి |
| 2 |
2. రివర్స్ ఆర్డర్‌లో స్ట్రింగ్‌ల శ్రేణి |
| 3 | 3. 2 శ్రేణులు 1. 10 స్ట్రింగ్‌ల యొక్క ఒక శ్రేణిని సృష్టించండి. 2. మరో 10 సంఖ్యల శ్రేణిని సృష్టించండి. 3. కీబోర్డ్ నుండి 10 స్ట్రింగ్‌లను చదవండి మరియు వాటితో స్ట్రింగ్ అర్రేని పూరించండి. 4. స్ట్రింగ్ శ్రేణిలోని ప్రతి సెల్ నుండి స్ట్రింగ్ యొక్క పొడవును ఒకే సూచికతో సంఖ్యల శ్రేణిలోని సెల్‌లో వ్రాయండి. సంఖ్యల శ్రేణిలోని విషయాలను స్క్రీన్‌పై ప్రదర్శించండి. ప్రతి విలువ కొత్త లైన్‌లో ఉండాలి. |
| 4 | 4. రివర్స్ ఆర్డర్‌లో సంఖ్యల శ్రేణి 1. 10 సంఖ్యల శ్రేణిని సృష్టించండి. 2. కీబోర్డ్ నుండి 10 సంఖ్యలను చదవండి మరియు వాటిని శ్రేణిలో నిల్వ చేయండి. 3. శ్రేణి మూలకాలను రివర్స్ క్రమంలో అమర్చండి. 4. ఫలితాన్ని తెరపై ప్రదర్శించండి. ప్రతి విలువ కొత్త లైన్‌లో ఉండాలి. |
| 5 | 5. ఒక పెద్ద మరియు రెండు చిన్న శ్రేణులు 1. 20 సంఖ్యల శ్రేణిని సృష్టించండి. 2. కీబోర్డ్ 20 సంఖ్యల నుండి చదవండి మరియు వాటితో శ్రేణిని పూరించండి. 3. ఒక్కొక్కటి 10 సంఖ్యల రెండు శ్రేణులను సృష్టించండి. 4. పెద్ద శ్రేణి యొక్క సంఖ్యలను రెండు చిన్న శ్రేణులకు కాపీ చేయండి: సంఖ్యలలో సగం మొదటి శ్రేణికి, మిగిలిన సగం రెండవదానికి. 5. రెండవ చిన్న శ్రేణిని స్క్రీన్‌కు ప్రదర్శించండి. ప్రతి విలువ కొత్త లైన్‌లో ఉండాలి. |
5 ఎల్లీ, అర్రేలిస్ట్ vs. అర్రే
- అది నేనే. - హాయ్, ఎల్లీ! - ఈ రోజు మనకు కొత్త ఉత్తేజకరమైన అంశం ఉంది! ఇప్పుడు నేను మీకు ఆసక్తికరమైన కొత్త తరగతి గురించి చెబుతాను, అర్రేలిస్ట్ . - ఓ, కొత్త తరగతి? వావ్! ఇది ఏమి చేస్తుంది? - నేను కొద్దిగా వెనుక కథతో ప్రారంభిస్తాను. ప్రోగ్రామర్లు శ్రేణి యొక్క ఒక ఆస్తిని ఇష్టపడలేదు: దాని పరిమాణాన్ని మార్చడం అసాధ్యం. మీరు శ్రేణిలో మూడు ఎంట్రీలను నిల్వ చేయాలనుకుంటే ఏమి చేయాలి, కానీ ఒకే ఖాళీ స్థలం మాత్రమే ఉంది? - స్థలం లేకపోవడం సమస్యకు ఏకైక పరిష్కారం అన్ని అంశాలను కలిగి ఉన్న చాలా పెద్ద శ్రేణిని సృష్టించడం. కానీ ఇది తరచుగా మెమరీ యొక్క అసమర్థ వినియోగానికి దారితీసింది. ఉదాహరణకు, 99% శ్రేణి జీవితకాలంలో మీరు శ్రేణిలో 3 మూలకాలను మాత్రమే నిల్వ చేయాల్సి ఉంటే మరియు కేవలం 1% - 100 మూలకాలలో, మీరు 100 మూలకాల శ్రేణిని సృష్టించాలి. - కాబట్టి ప్రోగ్రామర్లు ఏమి వచ్చారు? - వారు అర్రే వలె అదే పనిని చేసిన తరగతి అర్రేలిస్ట్‌ని వ్రాసారు, కానీ దాని పరిమాణం మారవచ్చు. - ఒక ఆసక్తికరమైన తరలింపు. మరియు వారు దానిని ఎలా చేసారు? - ప్రతి అర్రేలిస్ట్ ఆబ్జెక్ట్ లోపల మూలకాల యొక్క సాధారణ శ్రేణిని నిల్వ చేస్తుంది. మీరు అర్రేలిస్ట్ నుండి ఎలిమెంట్‌లను చదివినప్పుడు , అది తన అంతర్గత శ్రేణి నుండి వాటిని చదువుతుంది. మీరు మూలకాలను వ్రాసినప్పుడు, అది వాటిని అంతర్గత శ్రేణికి వ్రాస్తుంది. సరిపోల్చండి:
- కాబట్టి అర్రేలిస్ట్ యొక్క ప్రయోజనం ఏమిటి? నా విషయానికొస్తే, కోడ్ పొడవుగా మారింది. - ముందుగా, ప్రోగ్రామర్లు చాలా తరచుగా ఉపయోగించే శ్రేణిలో అందుబాటులో లేని కొన్ని అదనపు ఫీచర్‌లకు ArrayList మద్దతు ఇస్తుంది. ఉదాహరణకి,మూలకాలను చొప్పించండి మరియు రంధ్రాలను వదలకుండా శ్రేణి మధ్యలో నుండి వాటిని తొలగించండి. - రెండవది, అర్రేలిస్ట్ దాని పరిమాణాన్ని మార్చగలదు . ArrayList దాని అంతర్గత శ్రేణిలో మరొక మూలకాన్ని నిల్వ చేయవలసి వచ్చినప్పుడు మరియు ఖాళీ స్థలం లేనప్పుడు, ArrayList లోపల క్రింది విధంగా జరుగుతుంది :
- మరొక శ్రేణి సృష్టించబడింది, రెండు రెట్లు పెద్దది.
- పాత శ్రేణిలోని అన్ని అంశాలు కొత్త శ్రేణికి కాపీ చేయబడతాయి.
- ArrayList వస్తువు యొక్క అంతర్గత వేరియబుల్‌లో కొత్త శ్రేణి నిల్వ చేయబడుతుంది, పాత శ్రేణి చెత్తగా ప్రకటించబడుతుంది (మేము దాని సూచనను ఇకపై నిల్వ చేయము).
మరియు అర్రేలిస్ట్‌తో ఎలా పని చేయాలి? - వాస్తవానికి, శ్రేణితో అదే పద్ధతిలో. ఇక్కడ చూడండి. అర్రేలిస్ట్‌తో పనిని సరిపోల్చండి మరియు అర్రేతో పని చేద్దాం. ఉదాహరణగా, కింది పనిని పరిష్కరిద్దాం: « ప్రోగ్రామ్ కీబోర్డ్ 10 స్ట్రింగ్ నుండి చదవాలి మరియు వాటిని రివర్స్ ఆర్డర్‌లో స్క్రీన్‌కు ప్రదర్శించాలి ». - దీన్ని తనిఖీ చేయండి: 
- నేను రెండు నిలువు వరుసలలో సమానమైన చర్యలను ఒకే రంగుతో చిత్రించాను. - ఇది భిన్నంగా అనిపిస్తుంది, కానీ మీరు దగ్గరగా చూస్తే ప్రతిదీ ఒకేలా ఉంటుంది. - అవును. అర్రేలిస్ట్‌ని ఉపయోగిస్తున్నప్పుడు ఇప్పుడు మనకు స్క్వేర్ బ్రాకెట్‌లు లేవు . బదులుగా, మేము పొందడం , సెట్ చేయడం మరియు జోడించడం వంటి పద్ధతులను ఉపయోగిస్తాము . - నేను గమనించాను. కానీ ఇది ఇప్పటికీ చాలా పోలి ఉంటుంది.
6 డియెగో, అర్రేలిస్ట్ టాస్క్‌లు
- మీరు మళ్ళీ ఏమీ చేయలేదా? మీరు ఒక రోబోట్, మీరు కాదు? రోబోలు ఎప్పుడూ ఏదో ఒక పనిలో బిజీగా ఉంటాయి. మిమ్మల్ని నిలబెట్టడానికి ఇక్కడ కొన్ని టాస్క్‌లు ఉన్నాయి. అయితే కొన్ని చిట్కాలతో ప్రారంభిద్దాం. - చిట్కా 1: జాబితా అంటే సాధారణంగా అర్రేలిస్ట్ అని అర్థం . - చిట్కా 2: స్ట్రింగ్ అంటే స్ట్రింగ్ రకం . - చిట్కా 3: స్ట్రింగ్‌ల జాబితాను సృష్టించడం అంటే సాధారణంగా అర్రేలిస్ట్ <స్ట్రింగ్> జాబితా = కొత్త అర్రేలిస్ట్<స్ట్రింగ్>();| పనులు | |
|---|---|
| 1 | టాస్క్ 1. జాబితాలో 5 విభిన్న స్ట్రింగ్‌లు 1. స్ట్రింగ్‌ల జాబితాను సృష్టించండి. 2. జాబితాకు 5 విభిన్న స్ట్రింగ్‌లను జోడించండి. 3. స్క్రీన్ దాని పరిమాణాన్ని ప్రదర్శించండి. 4. జాబితా యొక్క స్క్రీన్ కంటెంట్‌లకు ప్రదర్శించండి. ప్రతి విలువ కొత్త లైన్‌లో ఉండాలి. లూప్ ఉపయోగించండి. |
| 2 | టాస్క్ 2. 5 లైన్లు: «101», «102», «103», «104», «105» 1. స్ట్రింగ్స్ జాబితాను సృష్టించండి. 2. జాబితాకు 5 స్ట్రింగ్‌లను జోడించండి. "101", "102", "103", "104", "105". 3. మొదటిది, మధ్యది మరియు చివరిది తొలగించండి. 4. జాబితా యొక్క స్క్రీన్ కంటెంట్‌లకు ప్రదర్శించండి. ప్రతి విలువ కొత్త లైన్‌లో ఉండాలి. లూప్ ఉపయోగించండి. 5. స్క్రీన్ దాని పరిమాణాన్ని ప్రదర్శించండి. (ఒక ఎంట్రీని తొలగించిన తర్వాత, ఇతర ఎంట్రీల సూచికలు మారుతాయి. ఉదాహరణకు, మనం మొదటి మూలకాన్ని తొలగిస్తే, రెండవది మొదటిది అవుతుంది). |
| 3 | టాస్క్ 3. రివర్స్ ఆర్డర్‌లో 5 పంక్తులు 1. స్ట్రింగ్‌ల జాబితాను సృష్టించండి. 2. కీబోర్డ్ నుండి 5 స్ట్రింగ్‌లను చదివి, ఆపై వాటిని జాబితాకు జోడించండి. 3. వాటిని రివర్స్ క్రమంలో అమర్చండి. 4. జాబితా యొక్క స్క్రీన్ కంటెంట్‌లకు ప్రదర్శించండి. ప్రతి విలువ కొత్త లైన్‌లో ఉండాలి. లూప్ ఉపయోగించండి. |
| 4 |
టాస్క్ 4. జాబితా ప్రారంభంలో 5 స్ట్రింగ్‌లను జోడించండి |
| 5 | టాస్క్ 5. చివరి స్ట్రింగ్‌ను తొలగించి, జాబితా ప్రారంభంలో దానిని జోడించండి 1. స్ట్రింగ్‌ల జాబితాను సృష్టించండి. 2. కీబోర్డ్ 5 స్ట్రింగ్స్ నుండి చదవండి. ఈ స్ట్రింగ్‌లను జాబితాకు జోడించండి. 3. చివరి స్ట్రింగ్‌ను తొలగించి, జాబితా ప్రారంభంలో దానిని జోడించండి. ఈ చర్యను 13 సార్లు పునరావృతం చేయండి. 4. జాబితా యొక్క స్క్రీన్ కంటెంట్‌లకు ప్రదర్శించండి. ప్రతి విలువ కొత్త లైన్‌లో ఉండాలి. లూప్ ఉపయోగించండి. |
7 రిషా, జెనరిక్స్
- ఇప్పుడు, మరొక అద్భుతమైన అంశం. - ఈ రోజు ఆశ్చర్యాలతో నిండి ఉంది. ఇది నిజమైన పుట్టినరోజు లాంటిది. - ఈ రోజు నేను మీకు జెనరిక్స్ అంటే ఏమిటో చెబుతాను. జెనరిక్స్ అనేది పారామితులను కలిగి ఉన్న రకాలు. జావాలో, కంటైనర్ తరగతులు వాటి అంతర్గత వస్తువుల రకాలను పేర్కొనడానికి మిమ్మల్ని అనుమతిస్తుంది . - మేము జెనరిక్ వేరియబుల్‌ని ప్రకటించినప్పుడు, మేము ఒకదానికి బదులుగా రెండు రకాలను పేర్కొంటాము: వేరియబుల్ రకం మరియు వేరియబుల్‌లో నిల్వ చేయబడిన డేటా రకం. దీనికి మంచి ఉదాహరణ అర్రేలిస్ట్. మేము అర్రేలిస్ట్ రకం యొక్క కొత్త ఆబ్జెక్ట్/వేరియబుల్‌ని సృష్టించినప్పుడు, జాబితా లోపల నిల్వ చేయవలసిన విలువల రకాన్ని పేర్కొనడం కూడా మంచిది.
- ఇది ఉత్సాహంగా ఉంది. ముఖ్యంగా మీరు ఏ రకం గురించి చెప్పిన దాన్ని నేను ఇష్టపడ్డాను. - ఇది బాగానే ఉంది. వాస్తవానికి, ఒక పద్ధతిలో స్ట్రింగ్‌లను అర్రేలిస్ట్‌లో ఉంచి, మరొక పద్ధతిలో మీరు దాని కంటెంట్‌లతో పని చేస్తే మరియు సంఖ్యలు మాత్రమే ఉంటాయని ఆశించినట్లయితే, ప్రోగ్రామ్ క్రాష్ అవుతుంది. - అలాగా. - ఇప్పటివరకు, మేము టైప్-పారామితులతో మా స్వంత తరగతులను సృష్టించడం లేదు , మేము జావా సృష్టికర్తలు వ్రాసిన తరగతులను ఉపయోగించడం నేర్చుకుంటాము. - నేను వ్రాసిన తరగతిని కూడా టైప్-పారామీటర్‌గా ఉపయోగించవచ్చా? - అవును, ఏదైనా రకం, ఆదిమమైనవి తప్ప. క్లాస్ ఆబ్జెక్ట్ నుండి అన్ని క్లాస్ పారామితులు వారసత్వంగా పొందాలి. - కాబట్టి నేను ArrayList<int> వ్రాయలేను , నేను చేయగలనా? - మీరు చేయలేరు. కానీ జావా డెవలపర్లు ఆదిమ రకాలకు వారి నాన్-ప్రిమిటివ్ అనలాగ్‌లను వ్రాశారు - తరగతులు వారసత్వంగావస్తువు . ఇది ఎలా ఉంటుందో ఇక్కడ ఉంది: 
- ఆదిమ రకాలు మరియు అనలాగ్ తరగతులు (ర్యాపర్ తరగతులు) ఒకదానికొకటి సులభంగా కేటాయించబడతాయి: 
- జరిమానా. అప్పుడు నేను అర్రేలిస్ట్‌ని మరింత తరచుగా ఉపయోగిస్తానని అనుకుంటున్నాను.
8 రిషా, అర్రేలిస్ట్ ఉదాహరణలు, జెనరిక్స్
- ఇప్పుడు నేను మీకు నిజంగా ఉపయోగకరమైన విషయాలు ఇస్తాను. అర్రేలిస్ట్ మరియు జెనరిక్స్‌తో పని చేయడానికి ఇక్కడ కొన్ని సులభ ఉదాహరణలు ఉన్నాయి: - ఉదాహరణ 1. 
- ఉదాహరణ 2. 
- ఉదాహరణ 3. 
- ఉదాహరణ 4. 
- ఉదాహరణ 5. 
- అద్భుతం! కాబట్టి, డియెగో ఇప్పుడు నాకు ఇలాంటి టాస్క్‌ల సమూహాన్ని ఇవ్వబోతున్నాడు, కాదా? - అవును!
9 డియెగో, జాబితా<T> టాస్క్‌లు
- చివరకు మీరు స్వేచ్ఛగా ఉన్నారు. మీ కోసం ఈ పనులను గుర్తుంచుకోవడంలో నేను విసిగిపోయాను. మిమ్మల్ని కొనసాగించడానికి ఇక్కడ మరికొన్ని ఉన్నాయి:| Intellij Ideaలో చేయవలసిన అదనపు పనులు | |
|---|---|
| 1 | 1. మూడు శ్రేణులు 1. కీబోర్డ్ 20 సంఖ్యలను చదవండి, వాటిని జాబితాలో సేవ్ చేయండి, ఆపై వాటిని మూడు ఇతర జాబితాలుగా క్రమబద్ధీకరించండి: జాబితా 1 స్టోర్ సంఖ్యలను 3 ద్వారా విభజించండి ( x%3==0 ) 2 ద్వారా భాగించబడే 2 స్టోర్‌ల సంఖ్యలను జాబితా చేయండి ( x%2==0 ) జాబితా 3 మిగిలిన సంఖ్యలను నిల్వ చేస్తుంది. ఒకే సమయంలో 3 మరియు 2 ద్వారా భాగించబడే సంఖ్యలు (ఉదాహరణకు 6) రెండు జాబితాలకు చెందినవి - జాబితా 1 మరియు జాబితా 2. 2. పద్ధతి printList() జాబితాలోని ప్రతి మూలకాన్ని కొత్త లైన్‌లో ప్రదర్శించాలి. 3. ఈ మూడు జాబితాలను స్క్రీన్‌పై ప్రదర్శించడానికి ప్రింట్‌లిస్ట్() పద్ధతిని ఉపయోగించండి . మొదట జాబితా 1 ప్రదర్శించబడాలి, ఆపై జాబితా 2, ఆ జాబితా 3 తర్వాత. |
| 2 | 2. రివర్స్ ఆర్డర్‌లో 5 పదాలు కీబోర్డ్ నుండి 5 పదాలు చదవండి. వాటిని స్ట్రింగ్ జాబితాలో చేర్చండి మరియు వాటిని రివర్స్ ఆర్డర్‌లో స్క్రీన్‌పై ప్రదర్శించండి. |
| 3 | 3. పదం «ఇక్కడ» 1. «ఆపు», «చూడండి», «వినండి» పదాల జాబితాను సృష్టించండి. 2. ప్రతి పదం తర్వాత «ఇక్కడ» ఉన్న స్ట్రింగ్‌ను జోడించండి. 3. ఫలితాన్ని ప్రదర్శించండి. జాబితాలోని ప్రతి మూలకం కొత్త లైన్‌లో ఉండాలి. "ఫర్" లూప్ ఉపయోగించండి. |
| 4 | 4. అక్షరాలు «r» మరియు «l» 1. పదాలు/తీగల జాబితాను సృష్టించండి, మీకు కావలసిన వాటితో నింపండి. 2. పద్ధతి పరిష్కారము() తప్పక: 2.1. స్ట్రింగ్స్ జాబితా నుండి «r» అక్షరాన్ని కలిగి ఉన్న అన్ని పదాలను తొలగించండి 2.2. "l" అక్షరాన్ని కలిగి ఉన్న అన్ని పదాలను రెట్టింపు చేయండి. 2.3 పదం «r» మరియు «l» రెండు అక్షరాలను కలిగి ఉంటే దానిని మార్చకుండా ఉంచండి. 2.4 ఇతర పదాలతో ఏమీ చేయవద్దు. ఉదాహరణ: రోజ్ విల్లో లైర్ ఓక్ అవుట్‌పుట్ డేటా: విల్లో విల్లో లైర్ ఓక్ |
| 5 | 5. పదాలను నకిలీ చేయండి 1. కీబోర్డ్ నుండి 10 పదాలు/తీగలను చదవండి, వాటిని స్ట్రింగ్ జాబితాలోకి జోడించండి. 2. డబుల్ వాల్యూస్ అనే పద్ధతి నమూనా ప్రకారం పదాలను నకిలీ చేయాలి: a,b,c → a,a,b,b,c,c. 3. ఫలితాన్ని ప్రదర్శించండి. జాబితాలోని ప్రతి మూలకం కొత్త లైన్‌లో ఉండాలి. "ఫర్" లూప్ ఉపయోగించండి. |
10 ప్రొఫెసర్
- నేను నా అద్భుతమైన ఉపన్యాసాలను కనుగొన్నాను! కాబట్టి ఈ రోజు మీరు శ్రేణులు మరియు జాబితాలలో అత్యంత విలువైన జ్ఞానాన్ని పొందుతారు. అవి ఇక్కడ ఉన్నాయి: జావాలో అర్రేలిస్ట్ గురించి చిట్కాలు
11 జూలియో
- హే, అమిగో! మీరు వీటన్నింటిని ఎదుర్కొన్నందుకు నేను సంతోషిస్తున్నాను - మీరు బహుమతికి అర్హులు:12 కెప్టెన్ ఉడుతలు
- హలో, సైనికుడు! - శుభోదయం అయ్యా! - మీ కోసం నా దగ్గర కొన్ని అద్భుతమైన వార్తలు ఉన్నాయి. మీ నైపుణ్యాలను బలోపేతం చేయడానికి ఇక్కడ శీఘ్ర తనిఖీ ఉంది. ప్రతిరోజూ దీన్ని చేయండి మరియు మీరు మీ నైపుణ్యాలను త్వరగా పెంచుకుంటారు. Intellij IDEAలో టాస్క్‌లు ప్రత్యేకంగా రూపొందించబడ్డాయి.| Intellij Ideaలో చేయవలసిన అదనపు పనులు | |
|---|---|
| 1 | 1. రివర్స్ క్రమంలో సంఖ్యలను ప్రదర్శించు కీబోర్డ్ నుండి 10 సంఖ్యలను చదవండి మరియు వాటితో జాబితాను పూరించండి. రివర్స్ క్రమంలో సంఖ్యలను స్క్రీన్‌పై ప్రదర్శించండి. లూప్ ఉపయోగించండి. |
| 2 | 2. మొదటి M పంక్తులను జాబితా చివరకి తరలించండి 2 సంఖ్యలు కీబోర్డ్ నుండి చదవండి: N మరియు M . కీబోర్డ్ N స్ట్రింగ్స్ నుండి చదవండి మరియు వాటితో జాబితాను పూరించండి. మొదటి M పంక్తులను జాబితా చివరకి తరలించండి జాబితాను స్క్రీన్‌పై ప్రదర్శించండి. ప్రతి విలువ కొత్త లైన్‌లో ఉండాలి. |
| 3 | 3. శ్రేణిలో అతిపెద్ద మరియు చిన్న సంఖ్య 20 సంఖ్యల శ్రేణిని సృష్టించండి. కీబోర్డ్ నుండి చదివిన సంఖ్యలతో దాన్ని పూరించండి. శ్రేణిలో అతిపెద్ద మరియు చిన్న సంఖ్యను కనుగొనండి. స్పేస్‌తో వేరు చేయబడిన అతిపెద్ద మరియు అతి చిన్న సంఖ్యలను స్క్రీన్‌కు ప్రదర్శించండి. |
| 4 | 4. వినియోగదారు "ముగింపు" స్ట్రింగ్‌లోకి ప్రవేశించే వరకు కీబోర్డ్ నుండి స్ట్రింగ్‌లను చదవండి. స్ట్రింగ్‌ల జాబితాను సృష్టించండి. కీబోర్డ్ స్ట్రింగ్‌ల నుండి చదవండి (మీకు కావలసినది), వాటిని జాబితాకు జోడించండి. వినియోగదారు "ముగింపు" స్ట్రింగ్‌లోకి ప్రవేశించే వరకు కీబోర్డ్ నుండి స్ట్రింగ్‌లను చదవండి. "ముగింపు" విస్మరించబడాలి. స్ట్రింగ్‌లను స్క్రీన్‌కు ప్రదర్శించండి. ప్రతి స్ట్రింగ్ కొత్త లైన్‌లో ఉండాలి. |
| 5 | 5. బ్యాంగ్! 30 నుండి 0 వరకు లెక్కించబడే ప్రోగ్రామ్‌ను వ్రాయండి మరియు "బ్యాంగ్!" చివరలో. కార్యక్రమం సెకనుకు 10 సార్లు సంఖ్యను తగ్గించాలి. ఆలస్యాన్ని చొప్పించడానికి క్రింది ఫంక్షన్‌ని ఉపయోగించండి: Thread.sleep(100); //సెకనులో పదోవంతు ఆలస్యం. ఉదాహరణ: 30 29 … 1 0 బ్యాంగ్! |
| 6 | 6. కుటుంబం ఫీల్డ్‌లతో మానవ తరగతిని సృష్టించండి : స్ట్రింగ్ పేరు , బూలియన్ సెక్స్ , పూర్ణ వయస్సు , మానవ తండ్రి , మానవ తల్లి . మానవ తరగతికి చెందిన 9 వస్తువులను సృష్టించండి మరియు ఇద్దరు తాతలు, ఇద్దరు అమ్మమ్మలు, తండ్రి, తల్లి మరియు ముగ్గురు పిల్లలను పొందే విధంగా వాటిని పూరించండి. స్క్రీన్‌పై ఉన్న వస్తువులను స్క్రీన్‌కు ప్రదర్శించండి. చిట్కా: మీరు మీ పద్ధతిని String toString()ని హ్యూమన్ క్లాస్‌లో వ్రాస్తే , అది ఒక వస్తువును ప్రదర్శించడానికి ఉపయోగించబడుతుంది. ఉదాహరణ అవుట్‌పుట్: పేరు: అన్నా, సెక్స్: స్త్రీ, వయస్సు: 21, తండ్రి: పాల్, తల్లి: కేట్ పేరు: కేట్, సెక్స్: స్త్రీ, వయస్సు: 55 పేరు: ఇయాన్, లింగం: పురుషుడు, వయస్సు: 2, తండ్రి: మైఖేల్, తల్లి: అన్నా ... |
| 7 | 7. ఒక మాడిఫైయర్ స్టాటిక్‌ని తరలించండి, ఒక స్టాటిక్ మాడిఫైయర్‌ని తరలించండి, తద్వారా ప్రోగ్రామ్ కంపైల్ అవుతుంది. |
| బోనస్ పనులు | |
|---|---|
| 1 | 1. ప్రోగ్రామ్ కంపైల్ మరియు రన్ చేయదు. సరి చేయి. టాస్క్: కీబోర్డ్ నుండి పిల్లి డేటాను చదివి స్క్రీన్‌పై ప్రదర్శించండి. ఉదాహరణ: పిల్లి పేరు జిన్క్స్, వయస్సు 6, బరువు 5, తోక = 22 పిల్లి పేరు మైసీ, వయస్సు 8, బరువు 7, తోక = 20 |
| 2 | 2. ప్రోగ్రామ్‌కు కొత్త కార్యాచరణను జోడించండి. పాత పని: ఎంటర్ నొక్కడం ద్వారా వినియోగదారు ఖాళీ లైన్‌లోకి ప్రవేశించే వరకు ప్రోగ్రామ్ స్ట్రింగ్‌లను రీడ్ చేస్తుంది. అప్పుడు అది చిన్న అక్షరాన్ని పెద్ద అక్షరంలోకి మారుస్తుంది (అమ్మ MOMగా మారుతుంది) మరియు వాటిని స్క్రీన్‌పై ప్రదర్శిస్తుంది. కొత్త పని: ఎంటర్ నొక్కడం ద్వారా వినియోగదారు ఖాళీ లైన్‌లోకి ప్రవేశించే వరకు ప్రోగ్రామ్ స్ట్రింగ్‌లను చదవాలి. ప్రోగ్రామ్ కొత్త జాబితాను రూపొందిస్తుంది. స్ట్రింగ్ సరి సంఖ్యలో అక్షరాలను కలిగి ఉంటే, స్ట్రింగ్ నకిలీ చేయబడుతుంది, బేసి సంఖ్య అయితే, స్ట్రింగ్ మూడు రెట్లు పెరుగుతుంది. ఉదాహరణ ఇన్‌పుట్: క్యాట్ క్యాట్స్ మి ఉదాహరణ అవుట్‌పుట్: క్యాట్ క్యాట్ క్యాట్ క్యాట్స్ క్యాట్స్ మి మి |
| 3 | 3. అల్గోరిథం నేర్చుకోవడం మరియు సాధన చేయడం. కీబోర్డ్ నుండి 20 సంఖ్యలను చదవండి మరియు వాటిని అవరోహణ క్రమంలో ప్రదర్శించండి. |