Java: mga bit at byte

Panimula

Kung ang mga tao ay nagbibilang sa decimal na sistema ng numero, ang mga computer ay mabibilang sa binary system. At ang isang programmer ay dapat na maunawaan kung paano makipag-usap sa parehong mga tao at mga computer. Ang pagsusuri na ito ay dapat makatulong sa bagay na ito. Minsan may isang buong mundo na nakatago sa likod ng halata. Ipinapanukala kong pag-usapan ang mundong ito. Halimbawa, mayroong 7 araw sa isang linggo. Ngayon, sagutin natin ang tanong: Ano ang numerong "7"? ) Una, ito ay isang integer (positibong) natural na numero. Isa rin itong decimal na numero. Ang decimal na numero ay isang numero sa Decimal System. Kapag sinabi nating "decimal number system", nangangahulugan ito na ang number system ay may base na 10 . Ipinapakita ng radix kung gaano karaming mga digit ang maaaring gamitin sa isang ibinigay na sistema ng numero upang kumatawan sa isang numero. Ang countdown ay mula sa zero. Alinsunod dito, upang kumatawan sa mga numero sa sistema ng decimal na numero, gumagamit kami ng mga numero mula 0 hanggang 9. Ito ay mabuti, ngunit kailangan nating magbilang hindi lamang hanggang 9, ngunit higit pa. Paano maging? Halimbawa, ang numerong 10. Upang isulat ang numerong ito, gumagamit kami ng kasing dami ng 2 digit. Ang posisyon ng bawat digit sa decimal system ay tinatawag na decimal place. Ang mga digit ay binibilang mula kanan hanggang kaliwa: Bilang karagdagan, ang decimal na numero ay maaaring palawakin tulad ng sumusunod: 103 = 1*10^2 + 0*10^1 + 3*10^0 Ang bilang ay talagang lumalaki mula kanan hanggang kaliwa. Iyon ay, sa una ito ay 7, at pagkatapos ay naging 10. Samakatuwid, ang mga digit ay binibilang mula sa kanan, simula sa zero. Para saan ang lahat ng ito? Ito ay dahil hindi tayo mga kompyuter. At habang nagbibilang tayo sa decimal (iyon ay, base 10), ang mga computer ay binibilang sa binary (iyon ay, base 2). Ngunit ang mga patakaran na nalalapat sa mga sistema ng numero ay pareho.

Binary system

Ang binary system ay halos kapareho sa decimal system, na ang pagkakaiba lamang ay ang limitasyon dito ay hindi 10, ngunit 2. Ihambing natin sa isang halimbawa. Paano natin kinakatawan ang 11 sa binary? Ito ay napaka-simple: kailangan mo lamang na hatiin ang decimal na numero sa base 2, iyon ay, bilangin ang 11/2 sa isang column. Halimbawa: O narito ang isang halimbawa mula sa WikiHow: Kapansin-pansin, maaari nating katawanin ang isang numero sa binary sa parehong paraan tulad ng sa decimal: 111 sa binary = 1*2^2 + 1*2^1 + 1*2^0 = 4 + 2 + 1 Ang isang halimbawa ng conversion mula sa binary hanggang decimal ay makikita sa online na calculator . Sa pagsasalita tungkol sa katotohanan na ang mga patakaran ng pagpapatakbo sa mga sistema ng numero ay pareho, tingnan natin ang karagdagan sa binary system: Tulad ng nakikita mo, naglilipat kami ng mga digit sa panahon ng pagdaragdag sa parehong paraan tulad ng sa decimal system. Ang pagsusuri ng karagdagan ay makikita, halimbawa, dito:

• " Foxford: Pagdaragdag, Pagbabawas at Pagpaparami ng Binary Numbers "
• " Pagdaragdag, pagbabawas, pagpaparami at paghahati sa sistema ng binary number "

Sa pamamagitan ng paraan, ang ilang salitang "discharge" ay pana-panahong binabanggit. At ano ito? Ang lugar ay isang "estruktural elemento" lamang ng kumakatawan sa isang numero. Iyon ay, ang numero 10 ay binubuo ng dalawang numero: kailangan namin ng 2 digit, 2 lugar, 2 elemento upang isulat ang numerong ito. Mahalagang maunawaan natin ito dahil sa binary number system, ang isang digit ay medyo . Ang salitang Bit ay nagmula sa Ingles na "binary digit" , iyon ay, isang binary number. Maaari itong maging alinman sa 0 o 1. Ngunit tulad ng pagbabasa natin ng mga numero at salita sa kabuuan, at hindi bawat titik, ang mga computer ay hindi nagbabasa nang paisa-isa. Para sa pinakamababang "piraso" ng naprosesong impormasyon sa RAM (ang tinatawag na pinakamaliit na addressable unit ng impormasyon), isang sequence ng 8 bits ang binabasa . Dahil mayroong 8 sa kanila, ang isang ito ay tinatawag na "octet". At gayundin - ang mas kilalang salitang Byte . Upang matandaan ang octet, maaari mong tandaan na ang salitang octopus (walong paa) ay isinalin sa Ingles bilang octopus. Iyon ay, narito ang eksaktong parehong "octo" sa pamagat: Isipin natin kung ano ang maximum na bilang na maaari nating katawanin bilang 8 bits? At dito lumitaw ang tanong: paano ang mga negatibong numero? Upang maunawaan ito, pag-usapan natin kung paano kinakatawan ang mga byte sa Java

Java at Byte

Paano natin magagamit ang mga negatibong numero sa Java? Ginagawa ito nang simple. Sa Java, ang mga byte ay nilagdaan. Ang pinakakaliwang digit/bit (tinatawag ding “most significant bit”) ay ginawang uri ng “marker” na sumasagot sa tanong na: “Negative ba ang numerong ito?” Kung ang sagot ay oo, kung gayon ang marker ay may halagang 1. Kung hindi, ito ay 0. Tingnan natin ang isang halimbawa kung paano gawing negatibong numero 5 ang numero 5: Batay sa larawang ito, mauunawaan mo ang mga limitasyon kung saan namamalagi ang halaga ng Byte: Malinaw din na:

• kung magdadagdag tayo ng isa sa 127, makakakuha tayo ng -128.
• kung ibawas natin ang isa sa -128, makakakuha tayo ng 127.

Kaya, ang Byte sa Java ay maaaring tumagal ng isang halaga mula -128 hanggang 127. Tulad ng naaalala natin, ang isang byte ay isang octet. At ang maximum na digit/pinaka makabuluhang bit ay may serial number na 7, dahil nagbibilang tayo mula sa zero. Sa kasong ito, madaling tandaan na ang isang byte ay katumbas ng -2 sa kapangyarihan ng 7 (mas mababang limitasyon) hanggang 2 sa kapangyarihan ng 7 minus 1 (itaas na limitasyon). Ang pagtatrabaho sa uri ng data mismo ay simple. Ginagamit namin ang online na Java compiler na "repl.it" bilang isang "sandbox" para sa artikulong ito. https://repl.it/languages/java. Halimbawa, patakbuhin natin ang code na kakatawan sa isang byte variable sa binary form bilang isang string:

class Main {
  public static void main(String[] args) {
    byte octet = 5;
    String bin = String.format("%8s", Integer.toBinaryString(octet)).replace(' ', '0');
    System.out.println(bin);
  }
}

Ang pagtatrabaho sa mga byte ay aktibong ginagamit kapag nagtatrabaho sa I/O Streams. Maaari kang magbasa nang higit pa sa tutorial mula sa Oracle: " I/O Streams ". Bilang karagdagan, sa Java maaari kang gumamit ng isang espesyal na literal upang tukuyin ang halaga bilang mga bit:

class Main {
  public static void main(String[] args) {
    byte data = 0b101;
    System.out.println(data);
  }
}

Bit Manipulation

Ang pagpindot sa mga byte at bits, hindi mabibigo ang isa na banggitin ang iba't ibang mga manipulasyon ng bit. Marahil ang pinakakaraniwang operasyon ay shifts (bitwise shift o bit-shift). At lahat dahil ang kanilang resulta ay may malinaw na praktikal na mga benepisyo. Ano ang gamit? Ang paglilipat pakaliwa ng N na posisyon ay katumbas ng pagpaparami ng numero sa 2N. At ang paglipat sa kanan ay katulad ng parehong dibisyon. Kaya, 5<<2 == 5*Math.pow(2,2) At para maunawaan kung bakit ganito, tingnan natin ang halimbawang ito nang mas detalyado: Ang bitwise negation NOT (Unary bitwise), na kinakatawan ng isang tilde, ay binabaligtad ang mga bit. Ito ay nakasulat bilang isang tilde, halimbawa ~5.

public static void main(String[] args) {
	System.out.println(~5); //-6
 	System.out.println(~-5);//4
}

Muli itong nagpapakita na kapag binago ng Java ang tanda ng isang numero, bilang karagdagan sa pagbabaligtad ng mga halaga ng bit sa pinakadulo, nagsasagawa kami ng +1. At kung wala ito, tulad ng nakikita natin, ang aming numero 5 ay nagbabago. At upang ito ay manatiling parehong numero tulad ng bago baguhin ang sign, kailangan mong gawin ang +1. Binibigyang-daan ka ng Bitwise AND na mag-iwan ng dalawang magkaibang numero na may halagang 1 nang kaunti lamang kung ang lahat ng bit ay may halaga ng isa. Ano ang kawili-wili tungkol dito ay maaaring mayroon itong ilang mga benepisyo sa aplikasyon:

int x=4;
System.out.println((x&1) != 1);

Sinusuri ng code na ito ang numero x para sa parity. Tingnan natin ang isang halimbawa: Sa pamamagitan ng paggamit ng Bitwise AND at Bitwise OR nang magkasama, maaari kang gumamit ng mga maskara:

public static void main(String[] args) {
    byte optionA=0b0100;
    byte optionB=0b0010;
    byte optionC=0b0001;
    byte value = (byte)(optionB | optionC);
    // Check for optionB
    if ((optionC & value) != 0b0000) {
      System.out.println("Yes");
    } else {
      System.out.println("No");
    }
  }

Tingnan ang " Mga opsyon sa masking gamit ang mga bitwise operator sa Java " para sa higit pang mga detalye . Ang pagmamanipula ng bit ay isang kawili-wiling paksa kung saan naisulat ang mga hiwalay na review, artikulo at libro. At dito magsisimula ang mahabang landas patungo sa cryptography. Bilang bahagi ng pagsusuri na ito, ito ay nagkakahalaga ng pag-unawa kung bakit ito gumagana at kung paano. Para sa higit pang impormasyon tungkol sa mga pagpapatakbo ng bit, inirerekumenda kong basahin ang pagsusuri mula sa tproger: " Tungkol sa mga pagpapatakbo ng bit ."

Mga primitive na uri

Kaya, ang isang byte ay isang octet, iyon ay, 8 bits. Madaling tandaan na sa Java mayroon ding 8 primitive na uri, kung nagkataon. Ang primitive na uri ay isang uri ng data na binuo sa isang programming language, ibig sabihin, available bilang default. Ang byte ay ang pinakamaliit na primitive na uri ng data sa mga tuntunin ng memory footprint na maaaring gamitin ng Java. Tulad ng sinabi namin kanina, ang isang byte ay tumatagal ng 8 bits. Samakatuwid, ang pinakamahalagang digit ay numero 7. Samakatuwid, ang byte ay naglalaman ng mga halaga mula -2 hanggang ika-7 na kapangyarihan hanggang 2 hanggang ika-7 na kapangyarihan minus 1 ng resulta. Ano ang iba pang mga primitive na uri naroroon: Tulad ng nakikita natin mula sa talahanayan, ang mga uri ng data sa mga tuntunin ng dami ng data na inookupahan ay doble. Iyon ay, maikli = 2 * byte, at int = 2 * maikli. Ito ay talagang madaling tandaan. Tandaan na ang byte = 8 bits. Ang katotohanan na hindi ito maaaring mas mababa ay naaalala din. Sa Ingles, ang integer ay tinatawag na integer. Ang primitive na uri mula dito ay tinawag na abbreviation int. Mayroong regular na integer - int. Mayroong maikling bersyon, maikli, at mahabang bersyon, mahaba. Alinsunod dito, ang int ay sumasakop ng 32 bits (4 bytes). Ang maikling bersyon ay 2 beses na mas maliit - 16 bits (2 bytes), at ang mahabang bersyon ay dalawang beses na mas malaki, i.e. 64 bits (8 bytes). Kaya ang isang int ay maaaring mag-imbak ng halos 2 bilyon at isang daang milyon. At mahaba ay maaaring mag-imbak ng isang maximum ng tungkol sa 9 quadrillion (isang magandang salita). Ang pag-alala sa lumang biro tungkol sa kung paano iniisip ng isang baguhang programmer na mayroong 1000 byte sa isang kilobyte, at naniniwala ang isang kumpletong programmer na mayroong 1024 gramo sa isang kilo, mauunawaan natin:

1 mb = 1024 Kbyte = 1024 * 1024 = 1048576 bytes
1 int = 4 bytes
1 mb = 262144 int

Sa pamamagitan ng paraan, maaaring napansin ng isang matulungin na mambabasa na mayroon lamang 7 mga uri sa larawan. 8 primitive na uri ay boolean. Ang boolean ay isang Boolean data type na may dalawang value lang: true at false. Ngunit ang tanong ay lumitaw - anong sukat nito? Sasagot sa amin ang Java Virtual Machine Specifiaction at seksyong " 2.3.4. The boolean Type ": Ibig sabihin, ang isang boolean lang ay kukuha ng parehong halaga bilang isang int. Kung idedeklara namin ang isang array ng boolean, ang bawat elemento ng array ay sasakupin ng 1 byte. Ito ay mga himala :)

Konklusyon

Iminumungkahi kong maging pamilyar ka sa ilang higit pang mga materyales upang pagsamahin:

• " Hackerrank: Bit Manipulation "
• " Hackerrank: Lutasin ang 'Lonley Integer' Gamit ang Bit Manipulation "
• " Bit Manipulation 01: Panimula "
• " Hamon sa Pag-code #120: Pagbabago ng Bit "

#Viacheslav