1. Numbers
1. Arithmetic Types
2. Arithmetic Operators
3. Big Number Arithmetic
4. Assignment Operators
5. Arithmetic Quiz
6. Arithmetic Wrapper Classes
2. Example: Temperature Conversion
3. Booleans
1. boolean Type
2. Logical Operators
3. Relational Operators
4. Characters and Strings
1. char Type and Character Class
2. String and StringBuffer Class
3. String Operations

Numbers

Arithmetic Types

Arithmetic Operators

• ^ and ** are not exponentiation operators
; for data of type double you can use the pow operator for computing powers.
• The usual priority rules hold and you can use round brackets to change precedence.
• Automatic type castings apply: byte -> short -> int -> long and float -> double. Explicit casting is sometimes necessary to compute a requested result. This is done by a statement of the form
  (type) expression
  A simple example of type casting:

  long I = 4L;
  int i = (int) I;
  float pi = 3.14F;
  int p = (int) pi;   // answer is 3
  

Big Number Arithmetic

Arbitrary-precision integers are provided by the BigInteger class in the java.Math package. Arithmetic operations are now given by mnemonic names such as add, negate, subtract, multiply, divide, mod, remainder, and pow (for exponentiation).

Arbitrary-precision decimal numbers are provided by the BigDecimal class in the java.Math package.

Assignment Operators

z = (x>y) ? x : y;

Arithmetic Quiz

Java Source Code

public class Arithmetic {
  public static void main(String[] args) {

    int i=2, j=3, k=4;
    float x, y, z;
    double u, v, w;
    System.out.println("Step 0: i="+i+", j="+j+", k="+k);

    // some integer calculations   
 
    i++;     // i = i+1
    --j;     // j = j -1
    k *= i + j; // k = k*(i+j)
    System.out.println("Step 1: i="+i+", j="+j+", k="+k);

    i = k % j; // i  = k modulo j
    j = k / 3; // integer division
    System.out.println("Step 2: i="+i+", j="+j+", k="+k);

    i = 2; 
    j = i++; // j = i; i = i +1;
    k = ++i; // i = i+1; k= i;
    System.out.println("Step 3: i="+i+", j="+j+", k="+k);
 
    // some floating-point calculations

    x = k / 3;             // integer division followed by conversion to float
    y = (float) k / 3;     // floating-point division
    z = (float) k / (float) 3; 
    u = (double) k / 3.0;  // division with double floating points
    v = Math.pow(u,0.5);
    w = -2.0E4;            // scientific notation    
    System.out.println("Step 4: x="+x+", y="+y+", z="+z); 
    System.out.println("        u="+u+", v="+v+", w="+w); 

    u /= 2*v;          // u = u / (2*v)
    v = Math.floor(v); // Entier function application
    w = Math.abs(w);   // absolute value
    System.out.println("Step 5: u="+u+", v="+v+", w="+w); 

    i = Math.round((float) u);  // rounding off
    j = Math.round(-z);
    k = Math.round((float) u - z);
    System.out.println("Step 6: i="+i+", j="+j+", k="+k);

  } 
} 

Computer Results

Step 0: i=2, j=3, k=4
Step 1: i=3, j=2, k=20
Step 2: i=0, j=6, k=20
Step 3: i=4, j=2, k=4
Step 4: x=1, y=1.33333, z=1.33333
        u=1.33333, v=1.1547, w=-20000
Step 5: u=0.57735, v=1, w=20000
Step 6: i=1, j=-1, k=-1

Arithmetic Wrapper Classes

int i;
Integer ii = Integer(i);

Integer ii;
int i = ii.intValue();

Temperature Conversion

Java Code

class FtoC {
  public static void main (String args[]) {
    double TF = Double.valueOf(args[0]).doubleValue();
    double TC = 5.0*(TF - 32.0)/9.0;
    System.out.println(TF + " degrees Fahrenheit = " +
      TC + " degrees Celcius");
  }
}

Conversion of data types

String arg;
double TF = Double.valueOf(arg).doubleValue();

double TF;
String tf_string = String.valueOf(TF);

Output

--> java FtoC 32
32 degrees Fahrenheit = 0 degrees Celcius

--> java FtoC 33
33 degrees Fahrenheit = 0.555556 degrees Celcius

--> java FtoC 34
34 degrees Fahrenheit = 1.11111 degrees Celcius

Interactive Version

Booleans

boolean type

Logical Operators

Boolean is the wrapper class of boolean. It may surprise you, but the wrapper class Boolean contains no methods that correspond to logical operators.

Relational Operators

Characters and Strings

char Type and Character Class

The primitive type char holds a two-byte Unicode character. This may intimidate you, but the more familiar ASCII/ANSI codes can be denoted in Java by character codes such as 'a', '1', ']', and '\n' (newline). More general Unicodes are mostly expressed in terms of a hexadecimal encoding scheme that runs from '\u0000' to '\uFFFF' (ordinary ASCII/ANSI characters range from '\u0000' to '\u00FF').

The character wrapper class is called Character. This class contains several methods to work with characters: you can test the nature of a character (isDigit, isLetter, isLowerCase, ...), change the nature of a character (toLowerCase, toUpperCase), or convert it into a string with the toString method.

String and StringBuffer Class

Strings are sequences of characters, such as "Hello World". In contrast with the C language in which strings are implemented as arrays of characters, Java contains two string classes, viz., String and StringBuffer. The difference between the two classes is the following: String objects are immutable, i.e., there are no methods defined to change the contents of a String. If you want to modify the contents of a string, then you should use the StringBuffer class. This class is used mostly for efficiency reasons in I/O.

Strings are in most cases created

• directly by enclosing a word or sentence with double quotes ("):

  String s = "Hello Attendee";
  StringBuffer e = new StringBuffer(); // empty string
  

• by string concatenation with the + operator:

  String s = "Hello " + "World";
  

• by converting an arithmetic type into a string with the String.valueOf method:

  String three = String.valueOf(3);
  

• by applying the toString method to an object

  Rectangle rect = new Rectangle(20, 30);
  String r = rect.toString();
  

String Operations

Concatenation

With the + operator or the concat method you can join strings. The following concatenations have the same effect:

String s1 = "Nice "+"lesson"+"?";
String s2 = "Nice ".concat("lesson").concat("?");

The += operator has the expected effect:

String name = "Sammy Davis";
name += " Jr.";

is equivalent to

String name = "Sammy Davis";
name = name + " Jr.";

String Editing

To find out the length of a string, use the length method. For example:

String s = "Java";
int l = s.length();  // equals 4

The positions of individual characters in a String s are counted from left to right starting with 0 up to and including s.length() - 1. With the charAt method you get the individual character at the requested position; the substring method allows you to get a substring of a String. But remember, in a String you cannot change a character or a substring. For example, if you want to change the word "Java" into "Jack", then you cannot simply change the last two characters into ck. What you could do is the following: get the substring consisting of the first two characters of s, concatenate "ck", and finally change the current value of the s variable to "Jack":

String s = "Java";
s = s.substring(0,1) + "ck"; 

With a StringBuffer object you could have done the following:

StringBuffer j = new StringBuffer("Java");
j.setCharAt(2,'c');
j.setCharAt(3,'k');

The StringBuffer contains the methods append, insert, reverse, and setLength that do what there names suggest.

String Comparison

The main methods for string comparisons are equals, equalsIgnoreCase, and compareTo. The second method makes no difference between lower- and uppercase characters. The third method compares strings lexicographically and returns a negative value, 0, or a positive value, depending on whether the first string comes before, at the same place, or after the second string, respectively, in the lexicographic ordering. It is the exact analog of the strcmp function in the C language.

"Java".equals("java");            // is false
"Java".equalsIgnoreCase("java");  // is true
"Java".compareTo("java");         // is -32

Keep in mind that a string comparison with the == relational operator may give misleading answers: it is entirely possible that there exist multiple copies of identical strings at the same time in different locations. Compare the following equality tests; the effects have added as comments at the end of the lines.

String j = "Java";
if (j.equals("java")); // is true 
if (j == "Java");      // is probably true, but not guaranteed 
if (j.substring(0,1) == "Ja");  // is most likely false 

Moral:

Never use the relational operator == to compare strings or characters; use the equals method or the compareTo method.