Core Java

3.3.1 Integer Types

For numbers (positive or negative) witout fractional parts.

Java Integer Types:

The int is the most practical and common. long is for larger numbers, byte and short types are for specialized applications, i.e., low-level file handling or large arrays when storage space is at a premium.

In Java, the ranges of the above integer types are the same on every machine making it easier to move software from one platform to another or between operating systems. In contrast, C and C++ use the most efficient integer type for each processor, meaning that programs that run well on 32-bit may exhibit integer overflow on 16-bit systems.

Long Integer Numbers have a suffix: L or l e.g., 40000000L.

Hexidecimal Numbers (e.g., HEX colors) have the prefix: 0x or 0X e.g., 0xCAFE

Octal Numbers have the prefix: 0 e.g., 010 is 8

Binary Numbers have the prefix: 0b or 0B e.g., 0b1001 is 9.

You can add underscores to integer types to make the numbers easier to read, e.g.; 1_000_000 or 0b1111_0100_0010_0100_0000 both equal 1,000,000.

3.3.2 Floating-Point Types

Floating Point Types are for numbers with fractional parts.

Java Floating Point Types:

The name double means these numbers have twice the precision of the float type. AKA double-precision numbers.

floats have limited precision. Use them only when working with a library that requires them or when you need to store a very large number of them.

Floats have a suffix f or F e.g., 3.14F. Floating-point numbers without the F are considered to be of type double.

Also, Doubles can have the suffix: D or d e.g., 3.14D.

You can specify floating-point literals in hexadecimal: 0.125 = 2 ^-3 can be written as: 0x1.0p-3 (The mantissa is written in hexadecimal and the exponent is written in decimal and has base 2 [not 10]).

There are three special floating-point values to denote overflows and errors:

• Positive Infinity
• Negative Infinity
• NaN (not a number)

The result of dividing a positive number by 0 is positive infinity. 0/0 or the square root of a negative number yields NaN.

Floating point numbers are not suitable for financial calculations in which round-off errors cannot be tolerated. Floating point numbers are represented by the binary number system and, for example, there is no precise binary representation of the fraction 1/10 just as there is no accurate representation of the fraction 1/3 in the decimal system.

The BigDecimal class can be used for precise numerical computations.

3.3.3 The char Type

The char type was originally intended to describe individual characters.

Unicode has been added to over the years and while some Unicode characters can still be described with one char value, others now require two.

Literal values of type char are enclosed in single quotes

Values of type char can be expressed as hexadecimal values from \u0000 to \uFFFF.

Escape sequences can be used inside quoted character literals and strings e.g., '\u2122' or "Hello\n".

The \u escape sequence (but not the others) can be used outside of quoted character constants and strings, for example:

public static void main(String\u005B\u005D args)

Unicode escape sequences are processed before the code is parsed—so be wary of using \u in comments etc.

Escape Sequences for special characters

3.3.4 Unicode and the char Type

Historically, the byte was the number of bits used to encode a single character of text in a computer.

Where a byte had 8 bits, this allowed for 256 (0 to 255) or 2⁸ characters.

Unicode was developed in the late 1980's to address the problem of multiple character encoding schemes

Unicode coded each character with 2 bytes and thus offered 2¹⁶ or 65,536 characters.

In Java, beginning in Java SE 5.0, A code point is a code value that is associated with a character in an encoding scheme.

Unicode has code points that are grouped into 17 code planes.

The basic multilingual plane contains "classic" Unicode characters U+0000 to U+FFFF.

Sixteen additional planes with code points U+10000 to U+10FFFF hold supplementary characters.

The values in the basic multilingual plane are represented as 16-bit values called, code units.

The supplementary characters are encoded as consecutive pairs of code units, and these code units are from what's called the surrogates area—a range of 2048 unused values from the multilingual plane.

3.3.5 The boolean Type

The boolean type has two values: false and true. It is used for evaluating logical conditions and you cannot convert between integers and boolean values.

3.4.1 Initializing Variables

A variable is initialized with an assignment statement — variable name on the left, equals sign ( = ), and a Java expression with an appropriate value on the right.

• int vacationDays
• vacationDays = 12
• double salary = 65000.0

In Java it is considered good practice to declare variables as closely as possible to where they are first used.

3.4.2 Constants

In Java, you use the keyword final to denote a Constant.

final double CM_PER_INCH = 2.54;

The keyword final indicates that you can assign to the variable only once. It is customary to name Constants in all UPPERCASE.

Class Constants are available to multiple methods inside a single class. A Class Constant is set up with the keywords static final (usually directly inside the class scope before any constructors/methods).

public static final double CM_PER_INCH = 2.54;

3.5.1 Mathematical Functions and Constants

The Math class contains numerous mathematical functions

                            
                              double x = 4;
                              double y = Math.sqrt(x);
                              System.out.println(y); // prints 2.0
                            
                          

                            
                              double y = Math.pow(4, 2);
                              System.out.println(y); // prints 16.0
                            
                          

The pow method's parameters are both of type double and it returns a double as well.

The documentation for Java's Math class.

3.5.2 Conversions between Numeric Types

Conversions between numbers in Java can sometimes result in information loss as shown in the image below:

For example, a large integer such as 123456789 has more digits than the float type can represent.

                            
                              int n = 123456789;
                              float f = n; // f is 1.23456792E8
                            
                          

3.5.3 Casts

The syntax for casting is to give the target type in parentheses followed by the variable name.

                            
                              double x = 9.997;
                              int nx = (int) x;
                            
                          

Now, the variable nx has the value of 9 because casting a floating point number to an integer discards the fractional part.

To round a floating point number to the nearest integer, use the Math.round method:

                            
                              double x = 9.997;
                              int nx = (int) Math.round(x);
                            
                          

Now, the variable nx has the value of 10. Note the cast to (int). Math.round normally returns a long.

3.5.4 Combining Assignment with Operators

An alternative to using binary operators in assignment:

                            
                              x += 4;
                            
                          

Is equivalent to:

                            
                              x = x + 4;
                            
                          

3.5.5 Increment and Decrement Operators

                            
                            /** POSTFIX FORM **/
                              int n = 12;
                              n++ // Returns 13

                              int x = 5;
                              x-- //Returns 4

                              4++ // NOT LEGAL - these operators change the value of a variable.

                              /** PREFIX FORM **/
                              // The difference appears when they are used inside expressions.
                              // Prefix form does addition first.
                              // Postfix form evaluates to the old value of the variable.

                              int m = 7;
                              int n = 7;

                              int a = 2 * ++m // now a is 16, m is 8
                              int b = 2 * n++; // now b is 14, n is 8
                            
                          

3.5.6 Relational and boolean Operators

                            

                              3 == 7                  // EQUALITY (is false)
                              3 != 7                  // INEQUALITY (is true)
                              3 < 7                   // LESS THAN (is true)
                              3 > 7                   // GREATER THAN (is false)
                              3 >= 7                  // GREATER THAN OR EQUAL TO (is false)
                              3 <= 7                  // LESS THAN OR EQUAL TO (is true)
                              x > 5 && x < 10         // && is the LOGICAL AND OPERATOR
                              x > 20 || x < 10        // LOGICAL OR OPERATOR
                              x != 0                  // ! is the LOGICAL NEGATION OPERATOR

                              // SYNTAX
                              // expression1 && expression2
                              // if the first expression is false, the second isn't calculated:
                              x != 0 && 1 / x > x + y  // prevents division by 0

                              // TERNARY OPERATOR
                              // SYNTAX:
                              // condition ? expression1 : expression2
                              x < y ? x : y // gives the smaller of x and y
                            
                          

3.5.7 Bitwise Operators

                              
                              /**
                              BITWISE OPERATORS
                              & // ("and")
                              | // ("or")
                              ^ // ("xor")
                              ˜ // ("not" or "compliment") "flips" bits
                              << // ("left shift") The left operands value is moved left by
                                                   the number of bits specified by the
                                                   right operand.
                              >> // ("right shift") The left operands value is moved right by
                                                    the number of bits specified by the right
                                                    operand.
                              >>> // ("zero fill right shift") The left operands value is moved
                                                               right by the number of bits specified
                                                               by the right operand and shifted
                                                               values are filled up with zeros.

                              a = 0011 1100

                              b = 0000 1101

                              -----------------

                              a&b = 0000 1100 which is 12
                              a|b = 0011 1101 which is 61
                              a^b = 0011 0001 which is 49
                              ~a  = 1100 0011 which is -61
                              a << 2 = 1111 0000 which is 240
                              a >> 2 = 1111 which is 15
                              a >>> 2 = 0000 1111 which is 15
                              **/

                              int fourthBitFromRight = (n & 0b1000) / 0b1000;
                              
                            

3.5.8 Parentheses and Operator Hierarchy

If no partentheses are used, operations are performed in the heirarchical order indicated in the table below.

Operators on the same level are processed from left to right except for those that are right-associative.

                            
                            Since && has a higher precedence than ||
                            a && b || c
                            means
                            (a && b) || c

                            Since += associates right to left...
                            a += b += c
                            means
                            a+= (b += c)
                            
                          

3.5.9 Enumerated Types

Sometimes, a variable should only hold a restricted set of values. For example pizza or clothes can be sold in four sizes: small, medium, large, extra large. We could use integers 1, 2, 3, 4 or characters S, M, L, XL, but this is an error-prone setup. It's too easy to use the wrong value (0 or m, for example).

You can define an enumerated type — a type with a finite number of named values:

                            
                              enum Size = {SMALL, MEDIUM, LARGE, EXTRA_LARGE};
                            
                          

Now, you can declare a variable of the Size type:

                            
                              Size s = Size.MEDIUM;
                            
                          

A variable of type Size can only hold one of the values listed in the type declaration or null.

3.6.1 Substrings

Extract a substring with the substring method:

Positions are zero-indexed.

The first parameter is the first letter to be included.

The second parameter is the first letter to be excluded.

The length of s.substring(a, b) always has length b - a

                            
                              String greeting = "Hello";
                              String s = greeting.substring(0, 3);
                              // s = "Hel"
                            
                          

3.6.2 Concatenation

3.6.3 Strings Are Immutable

You cannot change the individual characters in a Java String - they are immutable. You can, however, make a string variable refer to a different string.

                            
                              String greeting = "Hello";
                              greeting = greeting.substring(0, 3) + "p!";
                              // greeting = "Help!"
                            
                          

Isn't it inefficient to build a new string from scratch rather than just altering the code units of the existing string? Yes, but the Java compiler can arrange that strings are shared.

Think of the various strings as sitting in a common pool. String variables point to locations in the pool. If you copy a string variable, both the original and copy point to the same string.

3.6.4 Testing Strings for Equality

Use the equals method to test strings for equality - do not use the == operator. The == operator only determines if two strings are stored in the same location. It is entirely possible to store multiple copies of identical strings in different places.

                            
                              String greeting = "Hello";
                              "Hello".equals(greeting); // true
                              greeting.equalsIgnoreCase("hello") // true

                              greeting == "Hello" // probably true
                              greeting.substring(0, 3) == "Hel" // probably false
                            
                          

Only string literals are shared, not strings that are the result of operations like + or substring.

3.6.5 Empty and Null Strings

An empty string is a String (a Java object) with length 0. A null string indicates that no object is currently associated with the value.

                            
                            String str = "";                          // An empty String
                            String str2 = "non-empty string";
                            String n;                                 // A null String

                            str2 != null && str2.length() > 0         //true
                            str.equals("")                            // true
                            str.length() == 0;                        // true
                            n == null                                 // true

                            n.length()                                //ERROR!
                            //can't call method on null value;
                            
                          

3.6.6 Code Points and Code Units

Java strings are implemented as sequences of char values.

The char data type is a code unit for representing Unicode code points in UTF-16 encoding.

The most commonly used Unicode characters can be represented with a single code unit. The supplementary characters require a pair of code units.

                            
                            // The length() method yields the number of CODE UNITS
                            // required for a given string in UTF-16.
                            String greeting = "Hello";
                            greeting.length(); // is 5.

                            // BUT REMEMBER: some characters require two CODE UNITS
                            // To get the number of CODE POINTS, call:
                            int cpCount = greeting.codePointCount(0, greeting.length());

                            // s.charAt(n) returns the CODE UNIT at position n
                            // where n is between 0 and s.length() -1.
                            char first = greeting.charAt(0); // first "H"
                            char last = greeting .charAt(4); // last "o"

                            // To get at the ith CODE POINT:
                            int index = greeting.offsetByCodePoints(0, i);
                            int cp = greeting.codePointAt(index);

                            // To traverse each CODE POINT in a String:
                            int cp = sentence.codePointAt(i);
                            if (Character.isSupplementaryCodePoint(cp))
                            {
                              i += 2;
                            }
                            else i++

                            // Note the wrapper class, Character, for the primitive
                            // data type, char.

                            // We can traverse a string backwards:

                            i--;
                            if (Character.isSurrogate(sentence.charAt(i))) i--;
                            int cp = sentence.codePointAt(i);

                            // An easier way is with the codePoint() method
                            // which yields a stream of int values - one for each code point.

                            int[] codePoints = str.codePoints().toArray();

                            // Conversely, to turn an array of code points to a string:

                            String str = new String(codePoints, 0, codePoints.length);
                            
                          

3.6.7 The String API

3.6.8 Reading the Online API Documentation

3.6.9 Building Strings

3.7.1 Reading Input

3.7.2 Formatting Output

3.7.3 File Input and Output

3.8.1 Block Scope

3.8.2 Conditional Statements

3.8.3 Loops

3.8.4 Determinate Loops

3.8.5 Multiple Selections—the switch Statement

3.8.6 Statements That Break Control Flow

3.10.1 The "for each" loop

3.10.2 Array Initializers and Anonymous Arrays

3.10.3 Array Copying

3.10.4 Command-Line Parameters

3.10.5 Array Sorting

3.10.6 Multidimensional Arrays

3.10.7 Ragged Arrays