Mga primitive na uri sa Java: Hindi sila ganoon ka-primitive

Panimula

Maaaring ituring ang pagbuo ng application bilang pagtatrabaho sa ilang data, o sa halip, pag-iimbak at pagproseso nito. Ngayon gusto kong hawakan ang unang pangunahing aspeto. Paano nakaimbak ang data sa Java? Narito mayroon kaming dalawang posibleng mga format: reference at primitive na mga uri ng data. Pag-usapan natin ang tungkol sa mga uri ng primitive na uri at ang mga posibilidad ng pagtatrabaho sa kanila (anuman ang maaaring sabihin, ito ang pundasyon ng ating kaalaman sa isang programming language). Ang mga primitive na uri ng data ng Java ay ang pundasyon kung saan nakasalalay ang lahat. Hindi, hindi naman ako nag-e-exaggerate. Ang Oracle ay may hiwalay na Tutorial na nakatuon sa mga primitive: Mga Primitive na Uri ng Data Isang maliit na kasaysayan. Sa simula ay mayroong zero. Pero nakakatamad ang zero. At pagkatapos ay lumitaw ang kaunti . Bakit siya tinawag ng ganoon? Pinangalanan ito mula sa abbreviation na “ bi nary digi t ” (binary number). Ibig sabihin, dalawa lang ang kahulugan nito. At dahil ito ay zero, ito ay lohikal na ngayon ito ay alinman sa 0 o 1. At ang buhay ay naging mas masaya. Ang mga piraso ay nagsimulang magtipon sa mga kawan. At ang mga kawan na ito ay nagsimulang tawaging byte (byte). Sa modernong mundo, byte = 2 sa ikatlong kapangyarihan, i.e. 8. Ngunit lumalabas na hindi ito palaging nangyayari. Maraming hula, alamat at tsismis kung saan nanggaling ang pangalang byte. Iniisip ng ilang tao na ito ay tungkol sa mga pag-encode noong panahong iyon, habang iniisip ng iba na mas kumikita ang pagbabasa ng impormasyon sa ganitong paraan. Ang isang byte ay ang pinakamaliit na naa-address na piraso ng memorya. Ito ang mga byte na may natatanging mga address sa memorya. May isang alamat na ang ByTe ay isang abbreviation para sa Binary Term - isang machine word. Machine word - sa madaling salita, ito ang dami ng data na maaaring iproseso ng processor sa isang operasyon. Dati, ang laki ng machine word ay kapareho ng pinakamaliit na addressable memory. Sa Java, ang mga variable ay maaari lamang mag-imbak ng mga halaga ng byte. Tulad ng sinabi ko sa itaas, mayroong dalawang uri ng mga variable sa Java:

• Ang mga primitive na uri ng java ay direktang nag-iimbak ng halaga ng mga byte ng data (titingnan natin ang mga uri ng mga primitive na ito nang mas detalyado sa ibaba);
• isang uri ng sanggunian, nag-iimbak ng mga byte ng address ng object sa Heap, ibig sabihin, sa pamamagitan ng mga variable na ito ay direktang nakakakuha tayo ng access sa mismong object (uri ng remote control para sa object)

Java byte

Kaya, ang kasaysayan ay nagbigay sa amin ng isang byte - ang pinakamababang halaga ng memorya na magagamit namin. At ito ay binubuo ng 8 bits. Ang pinakamaliit na uri ng data ng integer sa java ay byte. Ito ay isang nilagdaang 8-bit na uri. Ano ang ibig sabihin nito? Magbilang tayo. Ang 2^8 ay 256. Ngunit paano kung gusto natin ng negatibong numero? At ang mga developer ng Java ay nagpasya na ang binary code na "10000000" ay kumakatawan sa -128, iyon ay, ang pinaka makabuluhang bit (ang pinakakaliwang bit) ay magsasaad kung ang numero ay negatibo. Ang binary na "0111 1111" ay katumbas ng 127. Ibig sabihin, ang 128 ay hindi maaaring italaga sa anumang paraan, dahil ito ay magiging -128. Ang buong pagkalkula ay ibinigay sa sagot na ito: Bakit ang saklaw ng mga byte -128 hanggang 127 sa Java? Upang maunawaan kung paano nakuha ang mga numero, dapat mong tingnan ang larawan: Alinsunod dito, upang kalkulahin ang laki 2^(8-1) = 128. Nangangahulugan ito na ang pinakamababang limitasyon (at mayroon itong minus) ay magiging -128. At ang maximum ay 128 – 1 (ibawas ang zero). Iyon ay, ang maximum ay magiging 127. Sa katunayan, hindi kami gumagana sa uri ng byte nang madalas sa isang "mataas na antas". Karaniwang ito ay ang pagproseso ng "raw" na data. Halimbawa, kapag nagtatrabaho sa paghahatid ng data sa isang network, kapag ang data ay isang set ng 0s at 1s na ipinadala sa pamamagitan ng ilang channel ng komunikasyon. O kapag nagbabasa ng data mula sa mga file. Magagamit din ang mga ito kapag nagtatrabaho sa mga string at encoding. Halimbawang code:

public static void main(String []args){
        byte value = 2;
        byte shortByteValue = 0b10; // 2
        System.out.println(shortByteValue);
        // Начиная с JDK7 мы можем разделять литералы подчёркиваниями
        byte minByteValue = (byte) 0B1000_0000; // -128
        byte maxByteValue = (byte) 0b0111_1111; // 127
        byte minusByteValue = (byte) 0b1111_1111; // -128 + 127
        System.out.println(minusByteValue);
        System.out.println(minByteValue + " to " + maxByteValue);
}

Sa pamamagitan ng paraan, huwag isipin na ang paggamit ng uri ng byte ay makakabawas sa pagkonsumo ng memorya. Ang byte ay pangunahing ginagamit upang bawasan ang pagkonsumo ng memorya kapag nag-iimbak ng data sa mga array (halimbawa, ang pag-iimbak ng data na natanggap sa network sa ilang buffer, na ipapatupad bilang isang byte array). Ngunit kapag nagsasagawa ng mga operasyon sa data, ang paggamit ng byte ay hindi matutugunan ang iyong mga inaasahan. Ito ay dahil sa pagpapatupad ng Java Virtual Machine (JVM). Dahil ang karamihan sa mga system ay 32 o 64 bit, ang byte at short sa panahon ng mga kalkulasyon ay mako-convert sa isang 32-bit int, na pag-uusapan natin sa ibang pagkakataon. Ginagawa nitong mas madali ang mga kalkulasyon. Para sa higit pang mga detalye, tingnan Ang pagdaragdag ba ng byte ay na-convert sa int dahil sa mga panuntunan sa java language o dahil sa jvm? . Ang sagot ay naglalaman din ng mga link sa JLS (Java Language Specification). Bukod pa rito, ang paggamit ng byte sa maling lugar ay maaaring humantong sa mga awkward na sandali:

public static void main(String []args){
        for (byte i = 1; i <= 200; i++) {
            System.out.println(i);
        }
}

Magkakaroon ng loop dito. Dahil ang counter value ay umabot sa maximum (127), isang overflow ang magaganap at ang value ay magiging -128. At hinding hindi tayo aalis sa cycle.

maikli

Ang limitasyon para sa mga halaga ng byte ay medyo maliit. Samakatuwid, para sa susunod na uri ng data nagpasya kaming i-double ang bilang ng mga bit. Iyon ay, ngayon ito ay hindi 8 bits, ngunit 16. Iyon ay, 2 bytes. Ang mga halaga ay maaaring kalkulahin sa parehong paraan. 2^(16-1) = 2^15 = 32768. Nangangahulugan ito na ang hanay ay mula -32768 hanggang 32767. Ito ay bihirang ginagamit para sa anumang mga espesyal na kaso. Tulad ng sinasabi sa amin ng dokumentasyon ng wikang Java: " maaari kang gumamit ng maikli upang makatipid ng memory sa malalaking array ."

int

Kaya nakarating kami sa pinaka madalas na ginagamit na uri. Tumatagal ito ng 32 bits, o 4 bytes. Sa pangkalahatan, patuloy kaming nagdodoble. Ang saklaw ng mga halaga ay mula -2^31 hanggang 2^31 – 1.

Pinakamataas na halaga ng int

Ang maximum na halaga ng int 2147483648 ay 1, na hindi gaanong maliit. Tulad ng nakasaad sa itaas, upang i-optimize ang mga kalkulasyon, dahil Ito ay mas maginhawa para sa mga modernong computer, na isinasaalang-alang ang kanilang bit na kapasidad, upang mabilang; ang data ay maaaring implicit na ma-convert sa int. Narito ang isang simpleng halimbawa:

byte a = 1;
byte b = 2;
byte result = a + b;

Ang ganoong hindi nakakapinsalang code, ngunit nakuha namin ang error: "error: mga hindi tugmang uri: posibleng lossy conversion mula int hanggang byte." Kailangan mong itama ito sa byte na resulta = (byte)(a + b); At isa pang hindi nakakapinsalang halimbawa. Ano ang mangyayari kung patakbuhin natin ang sumusunod na code?

int value = 4;
System.out.println(8/value);
System.out.println(9/value);
System.out.println(10/value);
System.out.println(11/value);

At makukuha natin ang konklusyon

2
2
2
2

*tunog ng panic* Ang katotohanan ay kapag nagtatrabaho sa mga halaga ng int, ang natitira ay itinapon, na iniiwan lamang ang buong bahagi (sa mga ganitong kaso mas mahusay na gumamit ng doble).

mahaba

Patuloy kaming nagdodoble. I-multiply namin ang 32 sa 2 at makakuha ng 64 bits. Sa pamamagitan ng tradisyon, ito ay 4 * 2, iyon ay, 8 bytes. Ang hanay ng mga halaga ay mula -2^63 hanggang 2^63 – 1. Higit pa sa sapat. Ang ganitong uri ay nagpapahintulot sa iyo na magbilang ng malaki, malalaking numero. Madalas na ginagamit kapag nagtatrabaho sa oras. O sa malalayong distansya, halimbawa. Upang ipahiwatig na ang isang numero ay mahaba, ilagay ang literal na L - Mahaba pagkatapos ng numero. Halimbawa:

long longValue = 4;
longValue = 1l; // Не ошибка, но плохо читается
longValue = 2L; // Идеально

Gusto kong mauna sa sarili ko. Susunod, isasaalang-alang namin ang katotohanan na mayroong kaukulang mga wrapper para sa mga primitive, na ginagawang posible na magtrabaho kasama ang mga primitive bilang mga bagay. Ngunit mayroong isang kawili-wiling tampok. Narito ang isang halimbawa: Gamit ang parehong Tutorialspoint online compiler, maaari mong suriin ang sumusunod na code:

public class HelloWorld {

     public static void main(String []args) {
        printLong(4);
     }

    public static void printLong(long longValue) {
        System.out.println(longValue);
    }
}

Gumagana ang code na ito nang walang mga error, maayos ang lahat. Ngunit sa sandaling ang uri sa paraan ng printLong ay pinalitan mula mahaba hanggang Mahaba (ibig sabihin, ang uri ay hindi naging primitive, ngunit bagay), nagiging malabo sa Java kung anong parameter ang ipinapasa natin. Nagsisimula itong ipagpalagay na ang isang int ay ipinapadala at magkakaroon ng isang error. Samakatuwid, sa kaso ng isang pamamaraan, kakailanganing tahasang ipahiwatig ang 4L. Kadalasan ang haba ay ginagamit bilang isang ID kapag nagtatrabaho sa mga database.

Java float at Java double

Ang mga uri na ito ay tinatawag na mga uri ng floating point. Ibig sabihin, hindi ito mga uri ng integer. Ang float type ay 32 bits (tulad ng int), at double ay tinatawag na double precision type, kaya ito ay 64 bits (multiply by 2, tulad ng gusto natin). Halimbawa:

public static void main(String []args){
        // float floatValue = 2.3; lossy conversion from double to float
        float floatValue = 2.3F;
        floatValue = 2.3f;
        double doubleValue = 2.3;
        System.out.println(floatValue);
        double cinema = 7D;
}

At narito ang isang halimbawa ng pagkakaiba sa mga halaga (dahil sa katumpakan ng uri):

public static void main(String []args){
        float piValue = (float)Math.PI;
        double piValueExt = Math.PI;
        System.out.println("Float value: " + piValue );
        System.out.println("Double value: " + piValueExt );
 }

Ang mga primitive na uri na ito ay ginagamit sa matematika, halimbawa. Narito ang patunay, isang pare-pareho para sa pagkalkula ng numero PI . Well, sa pangkalahatan, maaari mong tingnan ang API ng klase ng Math. Narito kung ano pa ang dapat na mahalaga at kawili-wili: kahit na ang dokumentasyon ay nagsasabing: “ Ang uri ng data na ito ay hindi dapat gamitin para sa mga tiyak na halaga, gaya ng pera. Para diyan, kakailanganin mong gamitin ang java.math.BigDecimal na klase sa halip. Ang Mga Numero at String ay sumasaklaw sa BigDecimal at iba pang kapaki-pakinabang na mga klase na ibinigay ng Java platform. " Ibig sabihin, hindi kailangang kalkulahin ang pera sa float at double. Isang halimbawa tungkol sa katumpakan gamit ang halimbawa ng trabaho sa NASA: Java BigDecimal, Pagharap sa mga kalkulasyon ng mataas na katumpakan Buweno, para maramdaman mo ito para sa iyong sarili:

public static void main(String []args){
        float amount = 1.0000005F;
        float avalue = 0.0000004F;
        float result = amount - avalue;
        System.out.println(result);
}

Sundin ang halimbawang ito, at pagkatapos ay magdagdag ng 0 bago ang mga numero 5 at 4. At makikita mo ang lahat ng kakila-kilabot) Mayroong isang kawili-wiling ulat sa Russian tungkol sa float at double sa paksa: https://youtu.be/1RCn5ruN1fk Mga halimbawa ng pagtatrabaho na may BigDecimal ay makikita dito: Gumawa ng mga sentimo gamit ang BigDecimal Oo nga pala, ang float at double ay maaaring magbalik ng higit pa sa isang numero. Halimbawa, ang halimbawa sa ibaba ay magbabalik ng Infinity:

public static void main(String []args){
        double positive_infinity = 12.0 / 0;
        System.out.println(positive_infinity);
}

At ang isang ito ay magbabalik ng NAN:

public static void main(String []args){
        double positive_infinity = 12.0 / 0;
        double negative_infinity = -15.0 / 0;
        System.out.println(positive_infinity + negative_infinity);
}

Ito ay malinaw tungkol sa infinity. Ano ang NaN? Ito ay Hindi isang numero , ibig sabihin ang resulta ay hindi maaaring kalkulahin at hindi isang numero. Narito ang isang halimbawa: Gusto naming kalkulahin ang square root ng -4. Ang square root ng 4 ay 2. Iyon ay, 2 ay dapat na squared at pagkatapos ay makakakuha tayo ng 4. Ano ang dapat na squared upang makakuha ng -4? Hindi ito gagana, dahil... kung mayroong positibong numero, mananatili ito. At kung ito ay negatibo, kung gayon ang minus sa pamamagitan ng minus ay magbibigay ng plus. Ibig sabihin, hindi ito computable.

public static void main(String []args){
        double sqrt = Math.sqrt(-4);
        System.out.println(sqrt + 1);
        if (Double.isNaN(sqrt)) {
           System.out.println("So sad");
        }
        System.out.println(Double.NaN == sqrt);
}

Narito ang isa pang mahusay na pangkalahatang-ideya sa paksa ng mga numero ng floating point: Nasaan ang iyong punto?

Java boolean

Ang susunod na uri ay Boolean (lohikal na uri). Maaari lamang nitong tanggapin ang mga halagang totoo o mali, na mga keyword. Ginagamit sa mga lohikal na operasyon tulad ng while loops, at sa branching gamit ang if, switch. Anong mga kawili-wiling bagay ang maaari mong malaman dito? Well, halimbawa, theoretically, kailangan lang namin ng 1 bit ng impormasyon, 0 o 1, iyon ay, totoo o mali. Ngunit sa katotohanan, ang Boolean ay kukuha ng mas maraming memorya at ito ay depende sa partikular na pagpapatupad ng JVM. Kadalasan ito ay nagkakahalaga ng kapareho ng int. Ang isa pang pagpipilian ay ang paggamit ng BitSet. Narito ang isang maikling paglalarawan mula sa aklat ng Java Fundamentals: BitSet

Java char

Ngayon naabot na namin ang huling primitive na uri. Kaya, ang data sa char ay tumatagal ng 16 bits at inilalarawan ang character. Gumagamit ang Java ng Unicode encoding para sa char. Maaaring itakda ang simbolo alinsunod sa dalawang talahanayan (makikita mo ito dito ):

• Unicode character table
• ASCII character table

Halimbawa sa studio:

public static void main(String[] args) {
    char symbol = '\u0066'; // Unicode
    symbol = 102; // ASCII
    System.out.println(symbol);
}

Sa pamamagitan ng paraan, ang char, bilang mahalagang isang numero, ay sumusuporta sa mga pagpapatakbo ng matematika tulad ng kabuuan. At kung minsan ito ay maaaring humantong sa mga nakakatawang kahihinatnan:

public class HelloWorld{

    public static void main(String []args){
        String costForPrint = "5$";
        System.out.println("Цена только для вас " +
        + costForPrint.charAt(0) + getCurrencyName(costForPrint.charAt(1)));
    }

    public static String getCurrencyName(char symbol) {
        if (symbol == '$') {
            return " долларов";
        } else {
            throw new UnsupportedOperationException("Not implemented yet");
        }
    }

}

Lubos kong inirerekumenda na tingnan ang online na IDE mula sa tutorialspoint . Nang makita ko ang palaisipang ito sa isa sa mga kumperensya, nabuhayan ako ng loob. Sana ay magustuhan mo rin ang halimbawa) UPDATED: This was at Joker 2017, report: " Java Puzzlers NG S03 - Saan kayo nanggaling?! "

Mga literal

Ang literal ay isang tahasang tinukoy na halaga. Gamit ang mga literal, maaari mong tukuyin ang mga halaga sa iba't ibang mga sistema ng numero:

• Decimal system: 10
• Hexadecimal: 0x1F4, nagsisimula sa 0x
• Octal system: 010, nagsisimula sa zero.
• Binary system (mula noong Java7): 0b101, magsisimula sa 0b

Gusto ko pumunta sa isang maliit na karagdagang detalye sa octal system, dahil ito ay nakakatawa:

int costInDollars = 08;

Ang linya ng code na ito ay hindi mag-compile:

error: integer number too large: 08

Parang walang kwenta. Ngayon tandaan natin ang tungkol sa binary at octal system. Walang dalawa sa binary system, dahil mayroong dalawang halaga (simula sa 0). At ang octal system ay may 8 halaga, simula sa zero. Iyon ay, ang halaga 8 mismo ay hindi umiiral. Samakatuwid, ito ay isang error na sa unang tingin ay tila walang katotohanan. At tandaan, narito ang "follow-up" na panuntunan para sa pagsasalin ng mga halaga:

Mga klase ng wrapper

Ang mga primitive sa Java ay may sariling mga klase ng wrapper upang maaari kang magtrabaho sa kanila bilang mga bagay. Iyon ay, para sa bawat primitive na uri ay may kaukulang uri ng sanggunian. Ang mga klase ng wrapper ay hindi nababago: nangangahulugan ito na kapag nalikha na ang isang bagay, ang estado nito—ang halaga ng field ng value—ay hindi na mababago. Ang mga klase ng wrapper ay idineklara bilang pinal: mga bagay, kumbaga, read-only. Gusto ko ring banggitin na hindi posibleng magmana sa mga klaseng ito. Awtomatikong gumagawa ang Java ng mga conversion sa pagitan ng mga primitive na uri at mga wrapper nito:

Integer x = 9;          // autoboxing
int n = new Integer(3); // unboxing

Ang proseso ng pag-convert ng mga primitive na uri sa mga uri ng sanggunian (int->Integer) ay tinatawag na autoboxing , at ang reverse ay tinatawag na unboxing . Ginagawang posible ng mga klase na ito na i-save ang isang primitive sa loob ng isang bagay, at ang object mismo ay kikilos tulad ng isang Bagay (well, tulad ng anumang iba pang bagay). Sa lahat ng ito, nakakakuha tayo ng isang malaking bilang ng iba't-ibang, kapaki-pakinabang na mga static na pamamaraan, tulad ng paghahambing ng mga numero, pag-convert ng isang simbolo sa case, pagtukoy kung ang isang simbolo ay isang titik o isang numero, paghahanap para sa pinakamababang numero, atbp. Ang ibinigay na hanay ng functionality ay nakasalalay lamang sa wrapper mismo. Isang halimbawa ng sarili mong pagpapatupad ng isang wrapper para sa int:

public class CustomerInt {

   private final int value;

   public CustomerInt(int value) {
       this.value = value;
   }

   public int getValue() {
       return value;
   }
}

Ang pangunahing pakete, java.lang, ay mayroon nang mga pagpapatupad ng mga klase na Boolean, Byte, Short, Character, Integer, Float, Long, Double, at hindi na namin kailangang gumawa ng sarili naming bagay, ngunit gamitin lang muli ang handa na. mga. Halimbawa, ang mga ganitong klase ay nagbibigay sa amin ng kakayahang lumikha, sabihin, isang Listahan , dahil ang isang Listahan ay dapat lamang maglaman ng mga bagay, na ang mga primitive ay hindi. Upang mag-convert ng isang halaga ng isang primitive na uri, mayroong mga static na valueOf na pamamaraan, halimbawa, ang Integer.valueOf(4) ay magbabalik ng isang object na may uri na Integer. Para sa reverse conversion mayroong mga pamamaraan intValue(), longValue(), atbp. Ang compiler ay naglalagay ng mga tawag sa valueOf at *Value sa sarili nitong, ito ang esensya ng autoboxing at autounboxing. Ano ang hitsura ng halimbawa ng autopacking at autounpacking na ipinakita sa itaas:

Integer x = Integer.valueOf(9);
int n = new Integer(3).intValue();

Maaari kang magbasa nang higit pa tungkol sa autopacking at autounpacking sa artikulong ito .

Cast

При работе с примитивами существует такое понятие How приведение типов, одно из не очень приятных свойств C++, тем не менее приведение типов сохранено и в языке Java. Иногда мы сталкиваемся с такими ситуациями, когда нам нужно совершать взаимодействия с данными разных типов. И очень хорошо, что в некоторых ситуациях это возможно. В случае с ссылочными переменными, там свои особенности, связанные с полиморфизмом и наследованием, но сегодня мы рассматриваем простые типы и соответственно приведение простых типов. Существует преобразование с расширением и преобразование сужающее. Всё на самом деле просто. Если тип данных становится больше (допустим, был int, а стал long), то тип становится шире (из 32 бит становится 64). И в этом случае мы не рискуем потерять данные, т.к. если влезло в int, то в long влезет тем более, поэтому данное приведение мы не замечаем, так How оно осуществляется автоматически. А вот в обратную сторону преобразование требует явного указания от нас, данное приведение типа называется — сужение. Так сказать, чтобы мы сами сказали: «Да, я даю себе отчёт в этом. В случае чего — виноват сам».

public static void main(String []args){
   int intValue = 128;
   byte value = (byte)intValue;
   System.out.println(value);
}

Whatбы потом в таком случае не говорor что «Ваша Джава плохая», когда получат внезапно -128 instead of 128 ) Мы ведь помним, что в byteе 127 верхнее meaning и всё что находилось выше него соответственно можно потерять. Когда мы явно превратor наш int в byte, то произошло переполнение и meaning стало -128.

Область видимости

Это то место в codeе, где данная переменная будет выполнять свои функции и хранить в себе Howое-то meaning. Когда же эта область закончится, переменная перестанет существовать и будет стерта из памяти и. How уже можно догадаться, посмотреть or получить ее meaning будет невозможно! Так что же это такое — область видимости? Область определяется "блоком" — вообще всякой областью, замкнутой в фигурные скобки, выход за которые сулит удаление данных объявленных в ней. Или How минимум — сокрытие их от других блоков, открытых вне текущего. В Java область видимости определяется двумя основными способами:

• Классом.
• Методом.

Как я и сказал, переменная не видна codeу, если она определена за пределами блока, в котором она была инициализирована. Смотрим пример:

int x;
x = 6;
if (x >= 4) {
   int y = 3;
}
x = y;// переменная y здесь не видна!

И How итог мы получим ошибку:

Error:(10, 21) java: cannot find symbol
  symbol:   variable y
  location: class com.javaRush.test.type.Main

Области видимости могут быть вложенными (если мы объявor переменную в первом, внешнем блоке, то во внутреннем она будет видна).

Заключение

Сегодня мы познакомorсь с восемью примитивными типами в Java. Эти типы можно разделить на четыре группы:

• Целые числа: byte, short, int, long — представляют собой целые числа со знаком.
• Числа с плавающей точкой — эта группа включает себе float и double — типы, которые хранят числа с точностью до определённого знака после запятой.
• Булевы значения — boolean — хранят значения типа "истина/ложь".
• Mga Tauhan - kabilang sa pangkat na ito ang uri ng char.

Tulad ng ipinakita ng teksto sa itaas, ang mga primitive sa Java ay hindi masyadong primitive at nagbibigay-daan sa iyo upang malutas ang maraming mga problema nang epektibo. Ngunit nagpapakilala rin ito ng ilang feature na dapat nating tandaan kung ayaw nating makatagpo ng hindi mahuhulaan na gawi sa ating programa. Tulad ng sinasabi nila, kailangan mong magbayad para sa lahat. Kung gusto natin ng primitive na may "matarik" (malawak) na hanay - tulad ng mahaba - isinasakripisyo natin ang paglalaan ng mas malaking piraso ng memorya at sa kabilang direksyon. Sa pamamagitan ng pag-save ng memorya at paggamit ng mga byte, nakakakuha kami ng limitadong saklaw mula -128 hanggang 127.