இரட்டை வகை - உண்மையான எண்கள்

1. doubleவகை

doubleஉண்மையான (பின்ன) எண்களுடன் வேலை செய்வதற்கான வகையை ஜாவா வழங்குகிறது . இது 8 bytesநினைவகத்தில் ஆக்கிரமித்துள்ளது (வகையை விட இரண்டு மடங்கு அதிகம் ) மற்றும் லிருந்து வரையிலான intவரம்பில் மதிப்புகளை சேமிக்க முடியும் . ஒப்பிட்டுப் பார்க்க: வகையிலிருந்து வரம்பில் மதிப்பைச் சேமிக்க முடியும் .-1.7*10308+1.7*10308int-2*109+2*109

உண்மையான எண்களில், பின்ன பகுதி ஒரு தசம புள்ளிக்குப் பிறகு எழுதப்படுகிறது. எடுத்துக்காட்டாக, 123.456, அல்லது 2.5, அல்லது 100.00, அல்லது 0.01. கணினிகள் அத்தகைய எண்களைக் கையாளும் போது, ​​​​அவற்றை மிதக்கும் புள்ளி எண்கள் என்று அழைக்கிறோம்.

மூலம், வகைக்கு கூடுதலாக double, எங்களிடம் வகை உள்ளது float(இது 4 பைட்டுகள் மட்டுமே). அதன் பெயர் மிதக்கும் புள்ளியிலிருந்து வந்தது . மேலும் பெயர் இரட்டை மிதவைdouble என்பதிலிருந்து வந்தது . A என்பது a : எதிராக இரு மடங்கு பெரியது . இது இரட்டை துல்லியமான மிதக்கும் புள்ளி எண் என்றும் அழைக்கப்படுகிறது .doublefloat8 bytes4

2. ஒரு doubleவகையை உருவாக்குதல்

உண்மையான எண்களை சேமிக்க இரட்டை வகை பயன்படுத்தப்படுகிறது. உண்மையான எண்களைச் சேமிக்கக்கூடிய குறியீட்டில் ஒரு மாறியை உருவாக்க, நீங்கள் இது போன்ற ஒரு அறிக்கையைப் பயன்படுத்த வேண்டும்:

double name;

பெயர் என்பது மாறியின் பெயர். எடுத்துக்காட்டுகள்:

double price;

double weight;

double lightSpeed;

வகையைப் போலவே int, ஒரே நேரத்தில் பல மாறிகளை உருவாக்க சுருக்கெழுத்தைப் பயன்படுத்தலாம் double:

double name 1, name 2, name 3;

உடனடியாக அவர்களுக்கு மதிப்புகளை ஒதுக்கவும்:

double name 1 = value 1, name 2 = value 2, name 3 = value 3;

எடுத்துக்காட்டுகள்:

double price = 5.0;

double weight = 2;

double x = 1.0, y = 2.0, z = 3.0;

3. முழு எண்கள் மற்றும் உண்மையான எண்களை ஒதுக்குதல்

முழு எண்கள் மாறிகளுக்கு மட்டுமே ஒதுக்கப்பட்டால் அது மோசமாக இருக்கும் int, மற்றும் உண்மையான எண்கள் - மாறிகளுக்கு மட்டும் double. இரண்டு வகையான எண்களுக்கு இடையில் நாம் மாற்ற விரும்புகிறோம். ஜாவா இந்த திறனை வழங்குகிறது.

முதலில், உண்மையான மற்றும் முழு எண்கள் இரண்டையும் மாறிகளுக்கு ஒதுக்கலாம் double. முழு எண்களை ஒதுக்கும்போது, ​​அவை வெறுமனே உண்மையான எண்களாக மாற்றப்படுகின்றன. நிச்சயமாக, செயல்பாட்டில் சில துல்லியம் இழக்கப்படலாம்.

double price = 5.0;

double weight = 2;

int t = 1000;
double x =  t * t;

இரண்டாவதாக, ஒரு முழு எண் மற்றும் ஒரு உண்மையான எண் சில வெளிப்பாடுகளில் ஈடுபட்டிருந்தால், முழு எண் முதலில் உண்மையான எண்ணாக மாற்றப்படுகிறது, அதன் பிறகுதான் மற்ற உண்மையான எண்ணுடன் செயல்பாடு செய்யப்படுகிறது.

int t = 1000;
double x = t * 5.0;

System.out.println(5 * 2);

System.out.println(5 * 2.0);

இறுதியாக, மாறிகளுக்கு உண்மையான எண்களை ஒதுக்குவதும் சாத்தியமாகும் int. நாம் இதைச் செய்யும்போது, ​​உண்மையான எண்ணின் பகுதியளவு நிராகரிக்கப்படும் - அந்த எண் அருகிலுள்ள முழு எண்ணுக்கு வட்டமிடப்படும்.

கூடுதலாக, கம்பைலருக்கு புரோகிராமர் என்ன நடக்கிறது என்பதை வெளிப்படையாக ஆவணப்படுத்த வேண்டும் (பின்னமான பகுதி கைவிடப்படுவதை மற்ற புரோகிராமர்கள் புரிந்துகொள்வதை உறுதிசெய்ய). பொதுவாக, அத்தகைய மாற்றம் குறியீட்டில் இது போல் தெரிகிறது:

integer_variable = (int)(real_number);

எடுத்துக்காட்டுகள்:

int x = (int)(5.5);

double a = 5.999;
int x = (int)(a);

double a = 5.999;
int b = 2;
int x = (int)(a * b);

4. ஜாவாவில் முழு எண்கள் மற்றும் உண்மையான எண்களை வகுத்தல்

ஒரு முழு எண்ணை ஒரு முழு எண்ணால் வகுக்கும் போது, ​​மீதமுள்ளவை எப்போதும் நிராகரிக்கப்படும். பிறகு எப்படிப் 5பிரித்து 2பெறுவது 2.5?

முதலில், இது சரியான விருப்பம் போல் தெரிகிறது:

double d = 5 / 2;

ஆனால் அது அவ்வளவு எளிதல்ல. இங்குள்ள சிக்கல் என்னவென்றால், ஜாவா இயந்திரம் முதலில் மதிப்பைக் கணக்கிடுகிறது 5 / 2, அதன் பிறகு மட்டுமே அதன் முடிவை மாறிக்கு ஒதுக்குகிறது d. மற்றும் 5 / 2செயல்பாடு முழு எண் பிரிவு ஆகும். அதாவது , d கொண்டிருக்கும் 2அல்லது, இன்னும் துல்லியமாக,2.0

வகுக்கப்பட்ட எண்களில் குறைந்தபட்சம் ஒன்றை உண்மையான எண்ணாக எழுதுவதே சரியான தீர்வு (அதாவது ஒரு தசம புள்ளியுடன்):

double d = 5.0 / 2;

double d = 5 / 2.0;

double d = 5.0 / 2.0;

ஒவ்வொரு வெளிப்பாடுகளிலும், d கொண்டிருக்கும்2.5

ஆனால் நாம் மாறிகளுடன் வேலை செய்தால் என்ன செய்வது? இது போன்ற குறியீடு இருந்தால் என்ன செய்வது?:

int a = 5;
int b = 2;
double d = a / b;

இங்கே ஒரு மிடுக்கான (மற்றும் வெளிப்படையான) தீர்வு உள்ளது - ஜாவா இயந்திரத்தை உண்மையான எண்ணாக ஒன்றால் பெருக்குவதன் மூலம் மாறிகளை உண்மையான எண்களாக மாற்றும்படி கட்டாயப்படுத்தவும் ( 1.0)

int a = 5;
int b = 2;
double d = a * 1.0 / b;

பெருக்கல் மற்றும் வகுத்தல் ஆகியவை சமமான முன்னுரிமையைக் கொண்டுள்ளன, மேலும் அவை இடமிருந்து வலமாகச் செய்யப்படுகின்றன. அதாவது 1.0ஐ எங்கு பெருக்குகிறோம் என்பது முக்கியம்.

எடுத்துக்காட்டுகள்:

int a = 5;
int b = 2;
double d = 1.0 * a / b;

int a = 5;
int b = 2;
double d = a * 1.0 / b;

int a = 5;
int b = 2;
double d = a / b * 1.0;