Въведение в Java Primitive

1. Общ преглед

Езикът за програмиране Java включва осем примитивни типа данни.

В тази статия ще си припомним какво са примитивите и ще преминем към тях.

2. Примитивни типове данни

Осемте примитиви, дефинирани в Java, са int , byte , short , long , float , double , boolean и char - те не се считат за обекти и представляват сурови стойности.

Те се съхраняват директно в стека (вижте тази статия за повече информация относно управлението на паметта в Java).

Нека да разгледаме размера на хранилището, стойностите по подразбиране и примери за това как да използваме всеки тип.

Нека започнем с бърза справка:

Тип	Размер (бита)	Минимум	Максимум	Пример
байт	8	-27	27– 1	байт b = 100;
къс	16.	-215	215– 1	кратко s = 30_000;
инт	32	-231	231– 1	int i = 100_000_000;
дълго	64	-263	263– 1	дълъг l = 100_000_000_000_000;
плувка	32	-2-149	(2-2-23) · 2127	плувка f = 1.456f;
двойно	64	-2-1074	(2-2-52) · 21023	двойно f = 1,456789012345678;
char	16.	0	216– 1	char c = 'c';
булев	1	-	-	булево b = вярно;

2.1. инт

Първият примитивен тип данни, който ще покрием, е int . Известен също като цяло число, типът int съдържа широк диапазон от дробни числови стойности.

По-конкретно, Java го съхранява, използвайки 32 бита памет . С други думи, той може да представлява стойности от -2,147,483,648 (-231) до 2,147,483,647 (231-1).

В Java 8 е възможно да се съхранява неподписана цяла стойност до 4 294 967 295 (232-1), като се използват нови специални помощни функции.

Можем просто да декларираме int просто:

int x = 424_242; int y;

Стойността по подразбиране на int, деклариран без присвояване, е 0.

Ако променливата е дефинирана в метод, трябва да присвоим стойност, преди да можем да я използваме.

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

2.2. байт

byte е примитивен тип данни, подобен на int , освен че заема само 8 бита памет . По този начин, защо го наричаме байт. Тъй като размерът на паметта е толкова малък, байтът може да съдържа само стойностите от -128 (-27) до 127 (27 - 1).

Можем да създадем байт :

byte b = 100; byte empty;

Стойността по подразбиране на байта също е 0.

2.3. къс

Следващата спирка в нашия списък с примитивни типове данни в Java е кратка .

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

При 16 бита памет това е половината от размера на int и два пъти по-голям от байта . Диапазонът му от възможни стойности е от -32,768 (-215) до 32,767 (215-1).

short се декларира по следния начин:

short s = 202_020; short s;

Също подобно на останалите типове, стойността по подразбиране е 0. Можем да използваме и всички стандартни аритметики върху нея.

2.4. дълго

Последният ни примитивен тип данни, свързан с цели числа, е дълъг .

дълго е големият брат на int . Той се съхранява в 64 бита памет, така че може да побере значително по-голям набор от възможни стойности.

Възможните стойности на лонг са между -9,223,372,036,854,775,808 (-263) до 9,223,372,036,854,775,807 (263 - 1).

Можем просто да декларираме един:

long l = 1_234_567_890; long l;

Както при другите цели числа, по подразбиране също е 0. Можем да използваме цялата аритметика на long, която работи на int .

2.5. плувка

Представяме основни дробни числа в Java, използвайки типа float . Това е десетично число с една точност. Което означава, че ако преминем шест десетични знака, това число става по-малко точно и по-скоро приблизително.

В повечето случаи не ни интересува загубата на прецизност. Но ако нашето изчисление изисква абсолютна точност (т.е. финансови операции, кацане на Луната и т.н.), трябва да използваме специфични видове, предназначени за тази работа. За повече информация разгледайте Java класа Big Decimal.

This type is stored in 32 bits of memory just like int. However, because of the floating decimal point its range is much different. It can represent both positive and negative numbers. The smallest decimal is 1.40239846 x 10-45, and the largest value is 3.40282347 x 1038.

We declare floats the same as any other type:

float f = 3.145f; float f;

And the default value is 0.0 instead of 0. Also, notice we add the f designation to the end of the literal number to define a float. Otherwise, Java will throw an error because the default type of a decimal value is double.

We can also perform all standard arithmetic operations on floats. However, it's important to note that we perform floating point arithmetic very differently than integer arithmetic.

2.6. double

Next, we look at double – its name comes from the fact that it's a double-precision decimal number.

It's stored in 64 bits of memory. Which means it represents a much larger range of possible numbers than float.

Although, it does suffer from the same precision limitation as float does. The range is 4.9406564584124654 x 10-324 to 1.7976931348623157 x 10308. That range can also be positive or negative.

Declaring double is the same as other numeric types:

double d = 3.13457599923384753929348D; double d;

The default value is also 0.0 as it is with float.Similar to float, we attach the letter D to designate the literal as a double.

2.7. boolean

The simplest primitive data type is boolean. It can contain only two values: true or false. It stores its value in a single bit.

However, for convenience, Java pads the value and stores it in a single byte.

Declare boolean like this:

boolean b = true; boolean b;

Declaring it without a value defaults to false. boolean is the cornerstone of controlling our programs flow. We can use boolean operators on them (i.e., and, or, etc.).

2.8. char

The final primitive data type to look at is char.

Also called a character, char is a 16-bit integer representing a Unicode-encoded character. Its range is from 0 to 65,535. Which in Unicode represents ‘\u0000' to ‘\uffff'.

For a list of all possible Unicode values check out sites like Unicode Table.

Let's now declare a char:

char c = 'a'; char c = 65; char c;

When defining our variables, we can use any character literal, and they will get automatically transformed into their Unicode encoding for us. A characters default value is ‘/u0000'.

2.9. Overflow

The primitive data types have size limits. But what happens if we try to store a value that's larger than the maximum value?

We run into a situation called overflow.

When an integer overflows, it rolls over to the minimum value and begins counting up from there.

Floating point number overflow by returning Infinity. When they underflow, they return 0.0.

Here's an example:

int i = Integer.MAX_VALUE; int j = i + 1; // j will roll over to -2_147_483_648 double d = Double.MAX_VALUE; double o = d + 1; // o will be Infinity

Underflow is the same issue except if we store a value smaller than the minimum value.

2.10. Autoboxing

Each primitive data type also has a full Java class implementation that can wrap it. For instance, the Integer class can wrap an int. There is sometimes a need to convert from the primitive type to its object wrapper (e.g., using them with generics).

За щастие Java може да извърши това преобразуване за нас автоматично. Ние наричаме този процес Autoboxing . Ето пример:

Character c = 'c'; Integer i = 1;

3. Заключение

В този урок разгледахме осемте примитивни типа данни, поддържани в Java.

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