New Feature: Playlist Center! Pick a topic and let our playlists guide the way.

Easy-to-follow video tutorials help you learn software, creative, and business skills.Become a member

Working with numbers

From: Java Essential Training

Video: Working with numbers

In Java, you can represent numbers as either primitive values or as complex objects. I am going to start by showing you how you represent them as primitives and then show, how to convert them into complex objects when needed. A primitive data type is a simple value. It represents only a single value and not many. That's one of the big differences between primitive values and complex objects. A primitive always points to a single value. Primitive data types are stored in the fastest available memory, whereas complex objects are stored in heap memory.

Working with numbers

In Java, you can represent numbers as either primitive values or as complex objects. I am going to start by showing you how you represent them as primitives and then show, how to convert them into complex objects when needed. A primitive data type is a simple value. It represents only a single value and not many. That's one of the big differences between primitive values and complex objects. A primitive always points to a single value. Primitive data types are stored in the fastest available memory, whereas complex objects are stored in heap memory.

When you are running an application, you won't see significant differences, but they do exist. Primitives can be used to represent numeric, logical, or single character values. They can't be used to represent strings, dates or other things that have to be represented as complete objects. Most of your numeric values will be declared as primitives. You will only need to use complex objects where you need to do conversions or you need to guarantee precision when doing certain kinds of calculations. When you declare a primitive data type, you spell the data type in all lowercase.

So for example int, i-n-t or byte would be spelled all lowercase. There are also classes with these names, but they will have an uppercase initial character. Here are the numeric primitive data types. The byte data type takes 8-bits and can represent numbers starting at -128 and going to a maximum of 127. The short integer takes 16-bits and has much greater range and the most commonly used integer data type int takes 32-bit to memory and has a minimum and maximum of over 2 million in each direction.

There is also a long integer. It takes twice the memory that an int does and should only be used when you are representing very large numbers. Then there are two primitives that can represent floating values. The float takes 32-bits and the double takes 64-bits. You'll see developers represent currency values frequently with doubles, but as I'll explain later typically, you will want to use a special class called BigDecimal for that sort of purpose. When you use primitives, you can set their values directly using literal representation of numbers.

For the first three primitive data types, byte, short, and int, the syntax of the number is pretty conventional. It's just a numeric value without any quotes. You can't include string values such as currency symbols or commas. When you get into the larger numbers, the long, the float, and the double, the syntax is a little different. For long values, a literal numeric should be followed with the letter l, for long. You can use either an upper or lowercase l, but because the lowercase usually looks a lot like a 1, typically developers will use the uppercase L. The float value takes a lowercase f and the double value, a lowercase d. Again, you could use uppercase, but most developers use lowercase for these.

If you don't put in those additional alphabetical characters, usually things will still work out okay, but what's happening internally, may surprise you. If you don't put in that additional alphabetical character into your code, the value will be cast, based on a set of rules, that Java follows, for example the 100 would be initially be cast a byte and then it would be up cast to the long. So you are actually taking more memory than necessary creating two values where only one is needed. So it's recommended that if you are explicitly using a literal to represent a long, a float or a double then use these characters.

In addition to the primitive data types for numbers, there are also a set of helper classes that are part of the Java Class Library. Each of these helper classes includes tools for converting and outputting numeric values. Here is a listing of the data types on the left and their matching helper classes on the right. For the most part the names match, byte is byte, short is short and so on and the only difference is the initial character. The primitive data type is all lowercase. The class name has an initial uppercase character.

The only difference is in the integer where the primitive Data Type is int and the name of the Helper Class is Integer with an uppercase I. The helper classes have all sorts of great tools in them and they are always available to your Java code. Here is an example. The Double class provides methods and other tools for converting and managing double values. Let's say you started off with a literal doubleValue of 156.5d and you assigned that to a primitive variable of doubleValue.

Well, in order to convert it, the first step would be to create an instance of the Double class. This would be the syntax. The data type has Double with an uppercase D, which means the helper class and not the primitive. I am constructing an instance of the Double class and passing in the primitive value. Now I can convert that value using a set of methods called byteValue, intValue, floatValue and toString. These are instance methods or class methods of the Double class.

We'll learn more about what that means in later videos, but for now just take it to mean that you can call these methods whenever you create an instance of the class. Because a doubleValue you can have more precision than say a byte or an int, calling this syntax will result in truncating the value. So the result of myIntValue would be simply 156. The result of myByteValue though because 156 exceeds the available range of a byte, would wrap around and you would actually end up with a negative number.

I'll show you examples of these in some of the codes samples. When you declare a number, using a primitive data type, if you don't set the value initially, it defaults to zero. So for example, here I am declaring a variable called myInt and I am setting it using the int data type. I am not including the equals assignment operator or an initial value and so the result is that myInt is initially assigned as 0. You'll see that this is true of all the primitive numerics.

Now when you get into complex objects instances of classes, the rules are different, but we'll talk about that later. There is one other major issue to know about when you are working with numbers. If your application requires numeric precision, when you are doing calculations or rounding, you shouldn't use primitives for this purpose. The problem is that primitive values are stored in memory in a way that can't guarantee that precision. Instead, you should use a class called BigDecimal especially when you are working with currency values and you need to do certain kinds of math, the BigDecimal class can help you guarantee that precision.

Here is an example of what can go wrong. Let's say that you are starting off with a primitive value, in this case a literal of 1115.37. I am going to create an instance of the BigDecimal class called payment and I am constructing it directly from that literal value and then I am going to output that value as a string. You might think you would see the value 1115.37 as a string, but in fact you are going to see something like this. The exact value is going to vary depending on your system, your processor and other variables, but internally the number is stored in a very surprising way.

So when you are working with currency values, it's strongly recommend that you construct your big decimals based on strings. This guarantees that you are talking about exactly the value you think you are talking about. Let's say for example that you start off with a double value once again of 1115.37. Before you create your instance of BigDecimal, you should first get a string representation of the number. This guarantees that any additional decimal values are truncated and you are only working with the value you want.

So the second line of code uses the Double class's toString method and converts to a value called ds, data-typed as a string. Now I construct the instances of BigDecimal based on the string and then output the value and now I get what I expect. We'll talk more about the BigDecimal class in a later video in the series. So that's a look at representing numeric values in Java. For most purposes, the primitive data types do a great job, but in many cases, you want to use the numeric helper classes that are part of the class library and specifically when you are working with currency values and doing calculations and rounding, you should look at the big decimal class.

Show transcript

This video is part of

Image for Java Essential Training
Java Essential Training

71 video lessons · 66744 viewers

David Gassner
Author

 
Expand all | Collapse all
  1. 10m 8s
    1. Welcome
      1m 3s
    2. Is this course for you?
      5m 35s
    3. Using the exercise files
      3m 30s
  2. 31m 24s
    1. The history of Java
      5m 19s
    2. Java compilation and syntax
      8m 54s
    3. Understanding the principles of Java
      8m 28s
    4. Choosing a development environment
      8m 43s
  3. 19m 5s
    1. Installing Java on Windows
      6m 42s
    2. Installing Eclipse on Windows
      3m 19s
    3. Exploring Java on Mac OS X Leopard and Snow Leopard
      2m 27s
    4. Installing Java on Mac OS X Lion
      3m 27s
    5. Installing Eclipse on Mac OS X
      3m 10s
  4. 46m 10s
    1. Creating a Hello World application
      11m 7s
    2. Exploring the Eclipse IDE
      8m 55s
    3. Compiling and running from the command line
      8m 2s
    4. Passing arguments to the application
      8m 17s
    5. Using the Java API documentation
      4m 5s
    6. Memory management and garbage collection
      5m 44s
  5. 58m 57s
    1. Everything is an object
      5m 59s
    2. Declaring and initializing variables
      9m 15s
    3. Working with numbers
      8m 32s
    4. Converting numeric values
      6m 40s
    5. Understanding operators
      7m 58s
    6. Working with character values
      5m 14s
    7. Working with boolean values
      5m 13s
    8. Outputting primitive values as strings
      5m 33s
    9. Creating a simple calculator application
      4m 33s
  6. 53m 40s
    1. Writing conditional code
      5m 35s
    2. Using the switch statement
      8m 50s
    3. Repeating code blocks with loops
      7m 35s
    4. Creating reusable code with methods
      6m 31s
    5. Declaring methods with arguments
      5m 41s
    6. Overloading method names with different signatures
      5m 53s
    7. Passing arguments by reference or by value
      5m 35s
    8. Creating a more complex calculator application
      8m 0s
  7. 20m 30s
    1. Using the String class
      5m 44s
    2. Building strings with StringBuilder
      3m 34s
    3. Parsing string values
      3m 19s
    4. Working with date values
      7m 53s
  8. 20m 44s
    1. Understanding compile-time vs. runtime errors
      4m 5s
    2. Handling exceptions with try/catch
      4m 55s
    3. Throwing exceptions in methods
      2m 50s
    4. Using the debugger
      8m 54s
  9. 32m 22s
    1. Using simple arrays
      4m 47s
    2. Using two-dimensional arrays
      6m 17s
    3. Managing resizable arrays with ArrayList
      7m 14s
    4. Managing unordered data with HashMap
      6m 5s
    5. Looping through collections with iterators
      7m 59s
  10. 52m 2s
    1. Understanding encapsulation
      5m 59s
    2. Creating and instantiating custom classes
      8m 8s
    3. Organizing classes with packages
      6m 47s
    4. Creating and using instance methods
      6m 52s
    5. Storing data in instance variables
      6m 56s
    6. Using constructor methods
      5m 40s
    7. Managing instance data with getter and setter methods
      8m 26s
    8. Using class variables and Enum classes
      3m 14s
  11. 41m 15s
    1. Understanding inheritance and polymorphism
      9m 12s
    2. Extending custom classes
      9m 1s
    3. Overriding superclass methods
      3m 8s
    4. Casting subclass objects
      5m 3s
    5. Understanding interfaces and implementing classes
      4m 2s
    6. Creating your own interfaces
      4m 14s
    7. Using abstract classes and methods
      6m 35s
  12. 32m 17s
    1. Managing files with the core class library
      7m 46s
    2. Managing files with Apache Commons FileUtils
      7m 32s
    3. Reading a text file from a networked resource
      7m 52s
    4. Parsing an XML file with DOM
      9m 7s
  13. 17m 39s
    1. Creating your own JAR files
      4m 54s
    2. Understanding the classpath
      5m 2s
    3. Documenting code with Javadoc
      7m 43s
  14. 47s
    1. Goodbye
      47s

Start learning today

Get unlimited access to all courses for just $25/month.

Become a member
Sometimes @lynda teaches me how to use a program and sometimes Lynda.com changes my life forever. @JosefShutter
@lynda lynda.com is an absolute life saver when it comes to learning todays software. Definitely recommend it! #higherlearning @Michael_Caraway
@lynda The best thing online! Your database of courses is great! To the mark and very helpful. Thanks! @ru22more
Got to create something yesterday I never thought I could do. #thanks @lynda @Ngventurella
I really do love @lynda as a learning platform. Never stop learning and developing, it’s probably our greatest gift as a species! @soundslikedavid
@lynda just subscribed to lynda.com all I can say its brilliant join now trust me @ButchSamurai
@lynda is an awesome resource. The membership is priceless if you take advantage of it. @diabetic_techie
One of the best decision I made this year. Buy a 1yr subscription to @lynda @cybercaptive
guys lynda.com (@lynda) is the best. So far I’ve learned Java, principles of OO programming, and now learning about MS project @lucasmitchell
Signed back up to @lynda dot com. I’ve missed it!! Proper geeking out right now! #timetolearn #geek @JayGodbold

Are you sure you want to delete this note?

No

Thanks for signing up.

We’ll send you a confirmation email shortly.


Sign up and receive emails about lynda.com and our online training library:

Here’s our privacy policy with more details about how we handle your information.

Keep up with news, tips, and latest courses with emails from lynda.com.

Sign up and receive emails about lynda.com and our online training library:

Here’s our privacy policy with more details about how we handle your information.

   
submit Lightbox submit clicked
Terms and conditions of use

We've updated our terms and conditions (now called terms of service).Go
Review and accept our updated terms of service.