96 views

Uploaded by tkluan

- New Text Document
- Farkle
- 19-Lampiran
- Java Identifiers
- Training Your Commodore 64 Level 2
- Chapter 5(Ca10)
- HCL Test Paper
- Assembly ProGs
- Assignment 7.docx
- Tutorial_01_1081210112
- 9558 Comp
- Ladder Diagram
- CPS109_Mid_2009F
- Programming in Java
- jayapavan.docx
- 1 Intro and Pointers
- SOHO-B53
- EE380 InClass 03 SOL(Week 2)
- Unit 2 Introduction to c Language
- Preprocessor_Vimportant

You are on page 1of 6

The amount of size allocated to variables of each type. Specifically: a long represents a signed 64-bit value, an int represents a signed 32-bit value, a short and a char represent signed 16-bit values, and a byte represents a signed 8-bit value. Java uses the leading (left-most) bit of such numbers to represent the sign. Specifically, a 0 means "positive", and a 1 means "negative." The remaining bits determine the actual number. Because of the differing numbers of bits between these types, this limits the maximum and minimum values that can be stored in each type. Specifically: a long represents an integer in the range [-9,223,372,036,854,775,808 9,223,372,036,854,775,807], an int represents an integer in the range [-2,147,483,648 - 2,147,483,647], both short and char represent integers in the range [-32,768 - 32,767], and a byte represents an integer in the range [-128 - 127]. There is a pattern here--a type that represents an n-bit binary integer can represent any integer in the range [-(2n-1) - 2n-1 1]. One special property of binary numbers relative to their usage in computers is that there are extra numerical operations we can perform on them. We will call them AND, OR, XOR, COMPLEMENT, LSHIFT, RSHIFT, and URSHIFT. Before we describe how the operations work, there is one caveat we must address: Java doesn't allow you to declare numbers directly in binary. The next-best-thing is to declare them in hexadecimal. Since hexadecimal uses 16 distinct numerals to encode a number, one numeral in hexadecimal can be expressed by exactly four bits in binary. Here's the encryption: Hexadecim Binar Decimal al y 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0000 0001 0010 0011 0100 0101 0110 0 1 2 3 4 5 6

0x7 0x8 0x9 0xA 0xB 0xC 0xD 0xE 0xF AND

7 8 9 10 11 12 13 14 15

Let a = 0001101100111101 and let b = 0011110000111111. We use the ampersand character "&" in Java to represent an AND. We define "a & b" as follows: 0 0 0 1 1 0 1 1 0 0 1 1 1 1 0 1 & 0 0 1 1 1 1 0 0 0 0 1 1 1 1 1 1 --------------------------------0 0 0 1 1 0 0 0 0 0 1 1 1 1 0 1 Generally, for each corresponding bit in numbers a and b, the corresponding bit in "a & b" will be 1 if and only if both corresponding bits in a and b are 1. Otherwise, the corresponding bit in "a & b" will be 0. Here's how we do it in Java: short a = 0x1B3D; // hexadecimal representation of a short b = 0x3C3F; // hexadecimal representation of b short c = a & b; // c is 0x183D OR We use the pipe character "|" in Java to represent an OR. Using a and b as before, we define "a | b" as follows: 0 0 0 1 1 0 1 1 0 0 1 1 1 1 0 1 | 0 0 1 1 1 1 0 0 0 0 1 1 1 1 1 1 --------------------------------0 0 1 1 1 1 1 1 0 0 1 1 1 1 1 1 Generally, for each corresponding bit in numbers a and b, the corresponding bit in "a | c" will be 1 if at least one of the bits is 1, or 0 if they are both 0. Here's how to do it in Java: short a = 0x1B3D; short b = 0x3C3F; short c = a | c; // c is 0x3F3F

XOR We use the caret character "^" in Java to represent an XOR. Using a and b as before, we define "a ^ b" as follows: 0 0 0 1 1 0 1 1 0 0 1 1 1 1 0 1 ^ 0 0 1 1 1 1 0 0 0 0 1 1 1 1 1 1 --------------------------------0 0 1 0 0 1 1 1 0 0 0 0 0 0 1 0 Generally, XOR works like OR, with the exception that 1 XOR 1 is 0 (with OR, 1 OR 1 = 1). XOR literally means "eXclusive OR", meaning that only one of the corresponding bits in a and b can be 1 for the corresponding bit in "a ^ b" to be 1. In Java, this is: short a = 0x1B3D; short b = 0x3C3F; short c = a ^ b; // c is 0x3702 COMPLEMENT We use the tilde character "~" in Java to represent a COMPLEMENT. This operation is unary--you use it only one number. Here's an example: ~(0 0 0 1 1 0 1 1 0 0 1 1 1 1 0 1) == 1 1 1 0 0 1 0 0 1 1 0 0 0 0 1 0 The COMPLEMENT operator simply flips the value of each bit in the operand. In Java, this is: short a = 0x1B3D; short c = ~a; // c is 0xE4C2 LSHIFT We use two left angle-brackets "<<" to mean LSHIFT. LSHIFT means "Left SHIFT"--we shift all bits in a binary number to the left a certain number of spaces. The vacant spaces are filled with 0's. Here's an example: (0 0 0 1 1 0 1 1 0 0 1 1 1 1 0 1) << 1 == 0 0 1 1 0 1 1 0 0 1 1 1 1 0 1 0 // shift left by 1 space (0 0 0 1 1 0 1 1 0 0 1 1 1 1 0 1) << 3 == 1 1 0 1 1 0 0 1 1 1 1 0 1 0 0 0 // shift left by 3 spaces (0 0 0 1 1 0 1 1 0 0 1 1 1 1 0 1) << 7 == 1 0 0 1 1 1 1 0 1 0 0 0 0 0 0 0 // shift left by 7 spaces (0 0 0 1 1 0 1 1 0 0 1 1 1 1 0 1) << 15 == 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 // shift left by 15 spaces In Java, this is: short a = 0x1B3D; short c = a << 1; short d = a << 3; short e = a << 7; short f = a << 15;

There are some caveats here. First, you can inadvertently change the sign of a number with LSHIFT. Also, if you want to deal with a type other than int, you may need to explicitly cast to that type (e.g. you can't declare a as 0x9B3D, because 0x9B3D to Java is an int and it will complain that you are trying to declare a as short). Also, be careful when using LSHIFT as part of a larger calculation when dealing with types other than int--Java will attempt to promote the result of a LSHIFT operation to int when dealing with char, byte, and short. RSHIFT We use two right angle-brackets ">>" to mean RSHIFT. RSHIFT means "Right SHIFT"--we shift all bits in a binary number to the right by a certain number of spaces, and fill the vacant spaces on the left of the number with 0's. RSHIFT is tricky--it will preserve the sign of the number when you shift. This means that if you perform an RSHIFT on a negative number, the result will still have the sign bit set to 1. Examples: (0 0 0 1 1 0 1 1 0 0 1 1 1 1 0 1) >> 1 == 0 0 0 0 1 1 0 1 1 0 0 1 1 1 1 0 // shift right by 1 space (0 0 0 1 1 0 1 1 0 0 1 1 1 1 0 1) >> 3 == 0 0 0 0 0 0 1 1 0 1 1 0 0 1 1 1 // shift right by 3 spaces (1 0 0 1 1 0 1 1 0 0 1 1 1 1 0 1) >> 3 == 1 0 0 0 0 0 1 1 0 1 1 0 0 1 1 1 // shift right by 3 spaces, but preserve negative-ness (1 0 0 1 1 0 1 1 0 0 1 1 1 1 0 1) >> 15 == 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 // shift right by 15 spaces, but preserve negative-ness In Java, this is: short a = 0x1B3D; short b = 0x9B3D; short c = a >> 1; short d = a >> 3; short e = b >> 3; short f = b >> 15; URSHIFT We use three right angle-brackets ">>>" to mean URSHIFT. URSHIFT is like RSHIFT, but it will not preserve the sign bit (e.g. it will fill it with 0). URSHIFT stands for "Unsigned Right SHIFT". This is the only bit operation in Java that is NOT found in C. Testing and Setting Bits Setting a Bit to 1 Using the aforementioned bit operations, it becomes trivial to set a bit to 0 or 1. Suppose we wanted to set the nth bit from the right in a number a to 1 (this act is simply referred to "setting" the bit). Here's how to do this in Java: a = a | (1 << n); Or, more concisely,

a |= (1 << n); The aforementioned lines will set the nth bit from the right (henceforth known as simply "the nth bit"). For example, if n is 0, this sets the rightmost bit; if n is 1, this sets the secondrightmost bit; if n is 2, this sets the third-rightmost bit, etc. Note that the aforementioned lines set the bit in the nth place to 1 regardless of whether or not it was already set. This means that we start counting from 0 instead of 1. Here's an example if a = 0x1B3D and n = 6: 0 0 0 1 1 0 1 1 0 0 1 1 1 1 0 1 | 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 // 1 << 6 --------------------------------0 0 0 1 1 0 1 1 0 1 1 1 1 1 0 1 // now the 6th bit is set to 1. There is a caveat here: The "6th" bit really refers to the 7th position. This is because we start counting bits with the "0th" bit, which is the 1st position. Setting a Bit to 0 To set the nth bit to 0 (this act is also called "unsetting the n th bit"), we use this Java code: a = a & ~(1 << n); Or, more concisely, a &= ~(1 << n); Note that this will set the nth bit to 0 regardless of whether or not it is already 0. Here's an example where a = 0x1B3D and n = 5: 0 0 0 1 1 0 1 1 0 0 1 1 1 1 0 1 & 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1 1 // ~(1 << 5) --------------------------------0 0 0 1 1 0 1 1 0 0 0 1 1 1 0 1 // now, the 5th bit is set to 0 Testing a Bit Now, suppose we wanted to determine whether or not the n th bit is 0 or 1. Here's how we would do it in Java: if( (a & (1 << n)) != 0 ) { // the bit is set } else { // the bit is NOT set } Some Fun Finally, we give you this slightly-amusing method that turns an integer into a string of 0's and 1's (for your entertainment): String intToBinary( int theInt ) { String ret = ""; // test each bit (all 32 of them)

for( int i = 31; i >= 0; i-- ) { if( (theInt & (1 << i)) != 0 ) { ret += "1"; // the ith bit is set } else { ret += "0"; // the ith bit is NOT set } } return ret; }

- New Text DocumentUploaded byAnonymous yfhY7Ldpiz
- FarkleUploaded byJamel Neal Rose
- 19-LampiranUploaded byRendongz Tok
- Java IdentifiersUploaded byKian Kajhin
- Training Your Commodore 64 Level 2Uploaded byCubemanPDX
- Chapter 5(Ca10)Uploaded byDeependra Kumar Srivastava
- HCL Test PaperUploaded byamay
- Assembly ProGsUploaded byAnonymous Yc54u9
- Assignment 7.docxUploaded byNahian Kabir
- Tutorial_01_1081210112Uploaded byshadow1dos
- 9558 CompUploaded byJohn Var
- Ladder DiagramUploaded byJacky Deeja
- CPS109_Mid_2009FUploaded byexamkiller
- Programming in JavaUploaded byKen Jung
- jayapavan.docxUploaded byjaya pavan
- 1 Intro and PointersUploaded bysavio77
- SOHO-B53Uploaded bydeliswolf
- EE380 InClass 03 SOL(Week 2)Uploaded byMoe M.Diraa
- Unit 2 Introduction to c LanguageUploaded byLawrence Orewa
- Preprocessor_VimportantUploaded byMahmoud Eladawi
- PointersUploaded bySukhmander Singh
- Array 280910 - AUploaded byJeten C Rika
- lecture3-4 chapt2Uploaded bypooppoop312
- Scala SC 101Uploaded byAbhinash
- bit205-lecture3Uploaded byAditya Santana
- Practice Programs(IP)Uploaded byKashif Hassan
- Proposal JAVA(Tourism)Uploaded byASyiqinAzham
- CodingUploaded byapi-3760134
- java ioUploaded byincognitozaelus
- C - Basic DatatypesUploaded byyusuf

- Review of Thermodynamics - By J G SavenUploaded byEkrem Guldeste
- Basic-Food-analysis-Handbook-KC.pdfUploaded byAbeen
- lec10.pdfUploaded byJoØrsh Ênrique Tu Xikytø NînîØflow
- Narrative ReportUploaded byJohnReyBarnachea
- Fillion, Mathematical Truth, Ontology and Structures Category TheoryUploaded byflores3831_814460512
- SyllabusLedolter216HK2012Uploaded byRyan Lam
- MGEH14-PS4Uploaded byHaley Hopper
- Bridge CourseUploaded byanandkasirajankak
- ISM Finite Ch3-3Uploaded byAli Ezzat
- Analysis of Stock Market Volatility using Neural Network for Apple Stock IndexUploaded byIJSTE
- Motors_and_Drives_Solutions_with_ansoft_softwareUploaded byapi-3805241
- Nonlinear ship waves and computational fluid dynamics.pdfUploaded byFernando Raúl LADINO
- ES-LFSCUploaded byWatts
- theoryMATH0487chap6_7Uploaded byDominiqueDo
- 214_77Uploaded byDidier Angel Lopez Rincon
- MACMESE-17Uploaded bybobot80
- A Brief Report on Geometrical Modeling and Meshing of Textile Structures in TexGenUploaded byAmir Mosavi
- Reliability Improvement and Optimal Placement of Remote Controlling Switches of Distribution Systems Using Tabu Search Algorithm.pdfUploaded bytunghtd
- Edited ProposalUploaded byTesfaye Meberate
- Esper ReferenceUploaded byfristaile
- algoritmo_christofidesUploaded bySunshine Enriquez
- Contact Omega 05-08-09Uploaded bygideon020
- 1710.08362Uploaded byZsolt Bagoly
- 2 - Annotated Testing FilesUploaded byRafael Kniss
- Binary Logistic Regression Schueppert 2009Uploaded byTürk Psikolojik Travma Akademisi
- PSHAUploaded byUmut Akın
- SD pseudocode error questions-mk.docUploaded byJason Tan
- Strctural equation modelingUploaded byshahidameen2
- Chapter 04Uploaded byAbdul Rafi Shaikh
- Bamboo PilesUploaded byKenny Yee