Примитивни типове в Java

1. Списък на примитивните типове

Java има 8 основни примитивни типа. Те се наричат ​​примитивни, защото стойностите на тези типове не са обекти и се съхраняват директно в променливите.

Ето table с кратка информация за тези видове:

Локалните променливи в метода нямат стойност по подразбиране. Ако не присвоите стойност на такива променливи, те се считат за неинициализирани и не могат да бъдат използвани.

Но нека се върнем към примитивните типове и да ги разгледаме по-отблизо.

2. Целочислени типове

Java има 4 типа цели числа: byte, shortи int. longТе се различават по своя размер и диапазона от стойности, които могат да съхраняват.

intТип

Най-често използваният е intтипът. Името идва от думата int eger (цяло число). Всички цели числа (цели числа) в codeа са ints(ако не завършват на L, F, or D).

Променливите от този тип могат да приемат стойности от -2,147,483,648до +2,147,483,647.

Това е много и е достатъчно за почти всеки повод. Почти всяка функция, която връща число, връща int.

Примери:

int n = "String".length();

String[] array = {"Tic", "Tac", "Toe"};
int n = array.length;

shortТип

Типът shortполучава името си от short int. Често се нарича и кратко цяло число . За разлика от intтипа, неговата дължина е само два byteа и обхватът на възможните стойности е от -32,768до +32,767.

Това означава, че не можете да съхранявате числото един мorон в него. Или дори 50 000. Това е най-рядко използваният целочислен тип в Java. Основната мотивация за използването му е запазването на паметта.

Да предположим, че имате ситуация, в която знаете предварително, че ще работите със стойности, които никога не надвишават 30 000, и ще има мorони от тези стойности.

Например, да кажем, че пишете приложение, което обработва картини с ултрависока разделителна способност, които използват 10-бита за цвят. И имате мorон пиксела във вашата снимка. Това е сценарий, при който решението за използване intor shortима meaning.

longТип

Този тип получава името си от long intи се нарича още дълго цяло число . За разлика от intтипа, той има страхотно огромен диапазон от стойности: от до .-9*1018+9*1018

Защо не е основният целочислен тип?

Защото Java се появи в средата на 90-те, когато повечето компютри бяха 32-битови. Това означава, че всички процесори са оптимизирани за работа с числа, състоящи се от 32 бита. Процесорите можеха да работят с 64-битови цели числа, но операциите с тях бяха по-бавни.

В резултат на това програмистите разумно решиха да направят intстандартния целочислен тип и да използват longтипа само когато наистина е необходимо.

byteТип

Това е най-малкият целочислен тип в Java, но далеч не е най-рядко използваният. Името му, byte, е и думата за най-малкия addressируем блок памет в Java.

Няма толкова много валидни стойности за byteтипа: от -128до +127. Но това не е силата му. Типът byteсе използва най-често, когато трябва да съхраните големи данни в паметта. Масив от bytes е идеален за тази цел.

Да предположим, че трябва да копирате файл някъде.

Не е необходимо да обработвате съдържанието на file: просто искате да създадете област от паметта (буфер), да копирате съдържанието на file в нея и след това да запишете тези данни от буфера в друг файл. Масивът byteе това, от което се нуждаете за това.

Имайте предвид, че променливата на масива съхранява само препратка към област от паметта. Когато променливата се предава на няHowъв метод, се предава само addressът на паметта. Самият блок памет не се копира.

byte[] buffer = new byte[1024*1024];
FileInputStream sourceFile = new FileInputStream("c:\\data.txt");
FileOutputStream destFile = new FileOutputStream("c:\\output.txt");
while (true)
{
   int size = sourceFile.read(buffer); // Read data from a file into a buffer
   destFile.write(buffer, 0, size); // Write data from the buffer to a file

   // Stop copying if the buffer is not full
   if (size < buffer.length) break;
}
sourceFile.close();
destFile.close();

3. Реални типове

Примитивните типове включват два типа за реални числа. Въпреки че не е съвсем точно да се използва този термин. Когато компютрите обработват реални числа, ние ги наричаме числа с плаваща запетая . Името идва от стандарт за представяне на числа, при който целите и дробните части на числото са разделени с точка (точка, а не запетая).

Java има два примитивни типа с плаваща запетая: doubleи float.

Както казахме по-рано, тези типове имат много специфична вътрешна подредба: всъщност във всяка променлива от тези типове има не едно число, а две:

Например, числото с плаваща запетая 987654.321може да бъде представено като . Тогава в паметта то ще бъде представено като две числа ( мантиса , т.е. значимата част от числото) и ( експонента , т.е. степен на десет)0.987654321*1069876543216

floatТип

Името на floatтипа идва от число с плаваща запетая . Размерът на този тип е доста малък — само 4 byteа (32 бита) — но може да съхранява стойности от до . 24 бита са разпределени за представяне на мантисата и 8 бита за степента. Този тип може да съхранява само 8 значещи цифри.-3.4*10383.4*1038

Този подход позволява да се съхраняват много по-големи числа от int, като се използват същите 4 byteа. Но за да го направим, ние жертваме точността. Тъй като част от паметта съхранява мантисата, тези променливи съхраняват само 6-7 знака след десетичната запетая, докато останалите се изхвърлят.

Пример:

float a = (float) 123.456789;

float a = (float) 12345.9999;

float a = (float) -123.456789E-2;

Както можете да видите, основният недостатък на този тип е много малкият брой значими цифри и загубата на точност още при осмата цифра. Ето защо floatтипът не е много популярен сред Java програмистите.

doubleТип

Типът doubleе стандартният тип с плаваща запетая. Името идва от число с плаваща запетая с двойна точност . Всички реални литерали са doubles по подразбиране.

Този тип заема 8 byteа памет (64 бита) и може да съхранява стойности от до . Важно е да знаете, че 53 бита са заделени за мантисата, а останалите 11 са за експонентата.-1.7*103081.7*10308

Това позволява да се съхраняват 15-17 значещи цифри.

Пример:

double a = 1234567890.1234567890;

double a = 1234567890.1234512345;

double a = 1234567890.1357913579;

Тази прецизност, особено в сравнение с floatтипа, е решаваща: 99% от всички операции с реални числа се извършват с помощта на doubleтипа.

11битове се разпределят за експонента, което означава, че можете да съхранявате степени на десет от -323до +308(това е степен на две от -1024до +1023). Типът doubleможе лесно да съхранява число със стотици нули след десетичната запетая:

double a = 2E-300 * 3E+302

4. Безкрайност

Числата с плаваща запетая имат друга интересна характеристика: те могат да съхраняват специална стойност, обозначаваща безкрайност . И можете да представите положителна безкрайност и отрицателна безкрайност .

Примери:

System.out.println( 100.0 / 0.0 );

Infinity

System.out.println( -100.0 / 0.0 );

-Infinity

double a = 1d / 0d;
double b = a * 10;
double c = b - 100;

a == Infinity
b == Infinity
c == Infinity

Ако безкрайността се умножи по число, получавате безкрайност. Ако добавите число към безкрайността, ще получите безкрайност. Това е супер удобно.

Не е число ( NaN)

Всички операции, включващи безкрайност, дават безкрайност. Е, повечето, но не всички.

Числата с плаваща запетая могат да съхраняват друга специална стойност: NaN. Това е съкращение от N не N номер (не число).

В математиката, ако разделите безкрайност на безкрайност, резултатът е недефиниран.

Но в Java, ако разделите безкрайност на безкрайност, резултатът е NaN.

Примери:

System.out.println(0.0 / 0.0);

NaN

double infinity = 1d / 0d;
System.out.println(infinity / infinity);

NaN

double a = 0.0 / 0.0;
double b = a * 10;
double c = b - 100;
double d = a + infinity;

a == NaN
b == NaN
c == NaN
d == NaN

Всяка операция с NaNдобиви NaN.

5. charвид

Сред примитивните типове на Java един заслужава специално внимание: типът char. Името му идва от думата char acter , а самият тип се използва за съхраняване на знаци.

Знаците са това, от което са напequalsи низовете, нали? Низовете са масив от знаци.

Но още по-интересен е фактът, че charтипът също е числов тип ! Това е тип с двойно преднаmeaning, така да се каже.

Реалността е, че charтипът всъщност не съдържа знаци. Вместо това, той съхранява codeове на знаци от Unicode codeирането. Всеки знак съответства на число: цифровият code на знака.

Всяка charпроменлива заема два byteа в паметта (същото като shortтипа). Но за разлика от shortтипа, charцелочисленият тип е без знак и може да съхранява стойности от 0до 65,535.

Типът charе хибриден тип. Стойностите му могат да се интерпретират Howто като числа (напр. могат да се събират и умножават), така и като знаци. Това беше напequalsо, защото въпреки че знаците са визуални представяния, за компютър те са преди всичко само числа. И е много по-удобно да работите с тях като числа.

Unicode

Unicode е специална table (codeиране), която съдържа всички знаци в света. И всеки знак има свой номер. Изглежда приблизително така:

Има различни начини за присвояване на стойност на charпроменлива.

char a = 'A';

char a = 65;

char a = 0x41;

char a = 0x0041;

char a = '\u0041';

Най-често хората просто посочват знака в кавички (Howто в първия ред на tableта). Въпреки това, последният метод също е популярен. Предимството му е, че може да се използва в низове.

И Howто казахме, charтипът също е целочислен тип, така че можете да напишете нещо подобно:

char a = 'A';
a++;
System.out.println(a);

Работа с chars

Всеки charе първо число (code на символа), а след това символ. Ако знаете code на знак, винаги можете да получите знака във вашата програма. Пример:

char c = (char) 1128;
System.out.println(c);

Ѩ

Стандартни codeове

Ето най-известните codeове на символи:

6. booleanвид

И последният примитивен тип е boolean.

Както вече знаете, той може да приема само две стойности: trueи false.

И с това вече знаете всичко, което трябва да знаете за този тип.