C++ to Java

Java was conceived by James Gosling and his team at Sun Microsystems in 1991.

Java is directly related to both C and C++. Java inherits its syntax from C. Its object model is adapted from C++. --Java: A Beginner’s Guide, by Oracle

Oracle became the owner of Java in 2010, when it acquired Sun Microsystems.

Java has remained the most popular language in the world for several years now (as at July 2018), according to the TIOBE index.

Java is both and . Instead of translating programs directly into machine language, the Java compiler generates byte code. Byte code is portable, so it is possible to compile a Java program on one machine, transfer the byte code to another machine, and run the byte code on the other machine. That’s why Java is considered a platform independent technology, aka WORA (Write Once Run Anywhere). The interpreter that runs byte code is called a “Java Virtual Machine” (JVM).

Java technology is both a programming language and a platform. The Java programming language is a high-level object-oriented language that has a particular syntax and style. A Java platform is a particular environment in which Java programming language applications run. --Oracle

According to the Official Java documentation, there are four platforms of the Java programming language:

• Java Platform, Standard Edition (Java SE): Contains the core functionality of the Java programming language.

• Java Platform, Enterprise Edition (Java EE): For developing and running large-scale enterprise applications. Built on top of Java SE.

• Java Platform, Micro Edition (Java ME): For Java programming language applications meant for small devices, like mobile phones. A subset of Java SE.

• JavaFX: For creating applications with graphical user interfaces. Can work with the other three above.

This book chapter uses the Java SE edition unless stated otherwise.

To run Java programs, you only need to have a recent version of the Java Runtime Environment (JRE) installed in your device.

If you want to develop applications for Java, download and install a recent version of the Java Development Kit (JDK), which includes the JRE as well as additional resources needed to develop Java applications.

In Java, the HelloWorld program looks like this:

public class HelloWorld {

    public static void main(String[] args) {
        // generate some simple output
        System.out.println("Hello, World!");
    }
}

    

    


    
    
    

      


    
    

For reference, the equivalent C++ code is given below:

#include <iostream>
using namespace std;

int main() {
    // generate some simple output
    cout << "Hello, World!";
    return 0;
}

    

    


    
    
    

      


    
    

This HelloWorld Java program defines one method named main: public static void main(String[] args)

System.out.println() displays a given text on the screen.

Some similarities:

• Java programs consists of statements, grouped , which are then grouped into classes.
• Java is “case-sensitive”, which means SYSTEM is different from System.
• public is an access modifier that indicates the method is accessible from outside this class. Similarly, private access modifier indicates that a method/attribute is not accessible outside the class.
• static indicates this method is defined as a class-level member. Do not worry if you don’t know what that means. It will be explained later.
• void indicates that the method does not return anything.
• The name and format of the main method is special as it is the method that Java executes when you run a Java program.
• A class is a collection of methods. This program defines a class named HelloWorld.
• Java uses squiggly braces ({ and }) to group things together.
• The line starting with // is a comment. You can use // for single line comments and /* ... */ for multi-line comments in Java code.

Some differences:

• Java use the term method instead of function. In particular, Java doesn’t have stand-alone functions. Every method should belong to a class. The main method will not work unless it is inside the HelloWorld class.
• A Java class definition does not end with a semicolon, but most Java statements do.
• In most cases (i.e., there are exceptions), the name of the class has to match the name of the file it is in, so this class has to be in a file named HelloWorld.java.
• There is no need for the HelloWorld code to have something like #include <iostream>. The library files needed by the HelloWorld code is available by default without having to "include" them explicitly.
• There is no need to return 0 at the end of the main method to indicate the execution was successful. It is considered as a successful execution unless an error is signalled specifically.

To compile the HelloWorld program, open a command console, navigate to the folder containing the file, and run the following command.

>_ javac HelloWorld.java

If the compilation is successful, you should see a file HelloWorld.class. That file contains the byte code for your program. If the compilation is unsuccessful, you will be notified of the compile-time errors.

Notes:

• javac is the java compiler that you get when you install the JDK.
• For the above command to work, your console program should be able to find the javac executable (e.g., In Windows, the location of the javac.exe should be in the PATH system variable).
  This page shows how to set PATH in different OS'es.

To run the HelloWorld program, in a command console, run the following command from the folder containing HelloWorld.class file.

>_ java HelloWorld

Notes:

• java in the command above refers to the Java interpreter installed in your computer.
• Similar to javac, your console should be able to find the java executable.

When you run a Java program, you can encounter a . These errors are also called "exceptions" because they usually indicate that something exceptional (and bad) has happened. When a run-time error occurs, the interpreter displays an error message that explains what happened and where.

System.out.println(5/0);

    

    


    
    
    

      


    
    

Exception in thread "main" java.lang.ArithmeticException: / by zero
    at Hello.main(Hello.java:5)

    

    


    
    
    

      


    
    

Integrated Development Environments (IDEs) can automate the intermediate step of compiling. They usually have a Run button which compiles the code first and then runs it.

Example IDEs:

• IntelliJ IDEA
• Eclipse
• NetBeans

Java has a number of primitive data types, as given below:

• byte: an integer in the range -128 to 127 (inclusive).
• short: an integer in the range -32,768 to 32,767 (inclusive).
• int: an integer in the range -2³¹ to 2³¹-1.
• long: An integer in the range -2⁶³ to 2⁶³-1.
• float: a single-precision 32-bit IEEE 754 floating point. This data type should never be used for precise values, such as currency. For that, you will need to use the java.math.BigDecimal class instead.
• double: a double-precision 64-bit IEEE 754 floating point. For decimal values, this data type is generally the default choice. This data type should never be used for precise values, such as currency.
• boolean: has only two possible values: true and false.
• char: The char data type is a single 16-bit Unicode character. It has a minimum value of '\u0000' (or 0) and a maximum value of '\uffff' (or 65,535 inclusive).

The String type (a peek)

Java has a built-in type called String to represent strings. While String is not a primitive type, strings are used often. String values are demarcated by enclosing in a pair of double quotes (e.g., "Hello"). You can use the + operator to concatenate strings (e.g., "Hello " + "!").

You’ll learn more about strings in a later section.

Java is a statically-typed language in that variables have a fixed type. Here are some examples of declaring variables and assigning values to them.

int x;
x = 5;
int hour = 11;
boolean isCorrect = true;
char capitalC = 'C';
byte b = 100;
short s = 10000;
int i = 100000;

    

    


    
    
    

      


    
    

You can use any name starting with a letter, underscore, or $ as a variable name but you cannot use Java keywords as variables names. You can display the value of a variable using System.out.print or System.out.println (the latter goes to the next line after printing). To output multiple values on the same line, it’s common to use several print statements followed by println at the end.

int hour = 11;
int minute = 59;
System.out.print("The current time is ");
System.out.print(hour);
System.out.print(":");
System.out.print(minute);
System.out.println("."); //use println here to complete the line
System.out.println("done");

    

    


    
    
    

      


    
    

The current time is 11:59.
done

    

    


    
    
    

      


    
    

Use the keyword final to indicate that the variable value, once assigned, should not be allowed to change later i.e., act like a ‘constant’. By convention, names for constants are all uppercase, with the underscore character (_) between words.

final double CM_PER_INCH = 2.54;

    

    


    
    
    

      


    
    

Java supports the usual arithmetic operators, given below.

The following program uses some operators as part of an expression hour * 60 + minute:

int hour = 11;
int minute = 59;
System.out.print("Number of minutes since midnight: ");
System.out.println(hour * 60 + minute);

    

    


    
    
    

      


    
    

Number of minutes since midnight: 719

    

    


    
    
    

      


    
    

When an expression has multiple operators, normal operator precedence rules apply. Furthermore, you can use parentheses to specify a precise precedence.

Java does not allow .

The unary operators require only one operand; they perform various operations such as incrementing/decrementing a value by one, negating an expression, or inverting the value of a boolean.-- Java Tutorial

Relational operators are used to check conditions like whether two values are equal, or whether one is greater than the other. The following expressions show how they are used:

The result of a relational operator is a boolean value.

Java has three conditional operators that are used to operate on boolean values.

Arrays are indicated using square brackets ([]). To create the array itself, you have to use the new operator. Here are some example array declarations:

int[] counts;
counts = new int[4]; // create an int array of size 4

int size = 5;
double[] values;
values = new double[size]; //use a variable for the size

double[] prices = new double[size]; // declare and create at the same time

    

    


    
    
    

      


    
    

Alternatively, you can use the shortcut syntax to create and initialize an array:

int[] values = {1, 2, 3, 4, 5, 6};

int[] anArray = {
    100, 200, 300,
    400, 500, 600,
    700, 800, 900, 1000
};

    

    


    
    
    

      


    
    

-- Java Tutorial

The [] operator selects elements from an array. Array elements .

int[] counts = new int[4];

System.out.println("The first element is " + counts[0]);

counts[0] = 7; // set the element at index 0 to be 7
counts[1] = counts[0] * 2;
counts[2]++; // increment value at index 2

    

    


    
    
    

      


    
    

A Java array is aware of its size. A Java array prevents a programmer from indexing the array out of bounds. If the index is negative or not present in the array, the result is an error named ArrayIndexOutOfBoundsException.

int[] scores = new int[4];
System.out.println(scores.length) // prints 4
scores[5] = 0; // causes an exception

    

    


    
    
    

      


    
    

4
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
	at Main.main(Main.java:6)

    

    


    
    
    

      


    
    

It is also possible to create arrays of more than one dimension:

String[][] names = {
    {"Mr. ", "Mrs. ", "Ms. "},
    {"Smith", "Jones"}
};

System.out.println(names[0][0] + names[1][0]); // Mr. Smith
System.out.println(names[0][2] + names[1][1]); // Ms. Jones

    

    


    
    
    

      


    
    

-- Java Tutorial

Passing arguments to a program

The args parameter of the main method is an array of Strings containing command line arguments supplied (if any) when running the program.

public class Foo{
    public static void main(String[] args) {
        System.out.println(args[0]);
    }
}

    

    


    
    
    

      


    
    

You can run this program (after compiling it first) from the command line by typing:

>_ java Foo abc

abc

if-else statements

if (x > 0) {
    System.out.println("x is positive");
}

    

    


    
    
    

      


    
    

if (x % 2 == 0) {
    System.out.println("x is even");
} else {
    System.out.println("x is odd");
}

    

    


    
    
    

      


    
    

if (x > 0) {
    System.out.println("x is positive");
} else if (x < 0) {
    System.out.println("x is negative");
} else {
    System.out.println("x is zero");
}

    

    


    
    
    

      


    
    

if (x == 0) {
    System.out.println("x is zero");
} else {
    if (x > 0) {
        System.out.println("x is positive");
    } else {
        System.out.println("x is negative");
    }
}

    

    


    
    
    

      


    
    

if (x % 2 == 0)
    System.out.println("x is even");
else
    System.out.println("x is odd");

    

    


    
    
    

      


    
    

switch statements

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

        int month = 8;
        String monthString;
        switch (month) {
        case 1:  monthString = "January";
            break;
        case 2:  monthString = "February";
            break;
        case 3:  monthString = "March";
            break;
        case 4:  monthString = "April";
            break;
        case 5:  monthString = "May";
            break;
        case 6:  monthString = "June";
            break;
        case 7:  monthString = "July";
            break;
        case 8:  monthString = "August";
            break;
        case 9:  monthString = "September";
            break;
        case 10: monthString = "October";
            break;
        case 11: monthString = "November";
            break;
        case 12: monthString = "December";
            break;
        default: monthString = "Invalid month";
            break;
        }
        System.out.println(monthString);
    }
}

    

    


    
    
    

      


    
    

Defining methods

public class PrintTwice {

    public static void printTwice(String s) {
        System.out.println(s);
        System.out.println(s);
    }

    public static void main(String[] args) {
        String sentence = “Polly likes crackers”
        printTwice(sentence);

    }
}


    

    


    
    
    

      


    
    

Polly likes crackers
Polly likes crackers

    

    


    
    
    

      


    
    

return statements

public static void printLogarithm(double x) {
    if (x <= 0.0) {
        System.out.println("Error: x must be positive.");
        return;
    }
    double result = Math.log(x);
    System.out.println("The log of x is " + result);
}

    

    


    
    
    

      


    
    

public class AreaCalculator{

    public static double calculateArea(double radius) {
        double result = 3.14 * radius * radius;
        return result;
    }

    public static void main(String[] args) {
        double area = calculateArea(12.5);
        System.out.println(area);
    }
}

    

    


    
    
    

      


    
    

Overloading

public static double calculateArea(double radius) {
    //...
}

public static double calculateArea(double height, double width) {
    //...
}

    

    


    
    
    

      


    
    

Recursion

public static void nLines(int n) {
    if (n > 0) {
        System.out.println();
        nLines(n - 1);
    }
}

    

    


    
    
    

      


    
    

Java has while and for constructs for looping.

while loops

public static void countdown(int n) {
    while (n > 0) {
        System.out.println(n);
        n = n - 1;
    }
    System.out.println("Blastoff!");
}

    

    


    
    
    

      


    
    

for loops

for (initializer; condition; update) {
    statement(s);
}

    

    


    
    
    

      


    
    

public static void printTable(int rows) {
    for (int i = 1; i <= rows; i = i + 1) {
        printRow(i, rows);
    }
}

    

    


    
    
    

      


    
    

do-while loops

class DoWhileDemo {
    public static void main(String[] args){
        int count = 1;
        do {
            System.out.println("Count is: " + count);
            count++;
        } while (count < 11);
    }
}

    

    


    
    
    

      


    
    

break and continue

class Main {
    public static void main(String[] args) {
        int[] numbers = new int[] { 1, 2, 3, 0, 4, 5, 0 };
        for (int i = 0; i < numbers.length; i++) {
            if (numbers[i] == 0) {
                break;
            }
            System.out.print(numbers[i]);
        }
    }
}

    

    


    
    
    

      


    
    

123

    

    


    
    
    

      


    
    

public static void main(String[] args) {
    int[] numbers = new int[] { 1, 2, 3, 0, 4, 5, 0 };
    for (int i = 0; i < numbers.length; i++) {
        if (numbers[i] == 0) {
            continue;
        }
        System.out.print(numbers[i]);
    }
}

    

    


    
    
    

      


    
    

12345

    

    


    
    
    

      


    
    

Enhanced for loops

for (int i = 0; i < values.length; i++) {
    int value = values[i];
    System.out.println(value);
}

    

    


    
    
    

      


    
    

for (int value : values) {
    System.out.println(value);
}

    

    


    
    
    

      


    
    

Java is an "object-oriented" language, which means that it uses objects to represent data and provide methods related to them. Object types are called classes e.g., you can use String objects in Java and those objects belong to the String class.

importing

import java.awt.Point;

public class Main{
    public static void main(String[] args) {
        Point spot = new Point(3, 4);
        int x = spot.x;
        System.out.println(x);
   }
}

    

    


    
    
    

      


    
    

new operator

Point spot = new Point(3, 4);

    

    


    
    
    

      


    
    

Variables that belong to an object are called attributes (or fields).

To access an attribute of an object, Java uses dot notation.

Point spot = new Point(3, 4);
int sum = spot.x * spot.x + spot.y * spot.y;
System.out.println(spot.x + ", " + spot.y + ", " + sum);

    

    


    
    
    

      


    
    

3, 4, 25

    

    


    
    
    

      


    
    

You can an object by assigning a different value to its attributes.

Point spot = new Point(3, 4);
spot.x = 5;
System.out.println(spot.x + ", " + spot.y);

    

    


    
    
    

      


    
    

5, 4

    

    


    
    
    

      


    
    

Java uses the dot notation to invoke methods on an object too.

Point spot = new Point(3, 4);
System.out.println(spot.x + ", " + spot.y);
spot.translate(5,5);
System.out.println(spot.x + ", " + spot.y);

    

    


    
    
    

      


    
    

3, 4
8, 9

    

    


    
    
    

      


    
    

You can pass objects as parameters to a method in the usual way.

public static void printPoint(Point p) {
    System.out.println("(" + p.x + ", " + p.y + ")");
}

public static void main(String[] args) {
    Point spot = new Point(3, 4);
    printPoint(spot);
}

    

    


    
    
    

      


    
    

(3, 4)

    

    


    
    
    

      


    
    

You can return an object from a method too.

public static Point findCenter(Rectangle box) {
    int x = box.x + box.width / 2;
    int y = box.y + box.height / 2;
    return new Point(x, y);
}

    

    


    
    
    

      


    
    

null and NullPointerException

Point spot = null;
int x = spot.x;          // NullPointerException
spot.translate(50, 50);  // NullPointerException

    

    


    
    
    

      


    
    

public static Point createCopy(Point p) {
    if (p == null) {
        return null; // return null if p is null
    }

    // create a new object with same x,y values
    return new Point(p.x, p.y);
}

    

    


    
    
    

      


    
    

Point result = createCopy(null);
System.out.println(result);

    

    


    
    
    

      


    
    

null

    

    


    
    
    

      


    
    

It is possible to have multiple variables that refer to the same object.

Point p1 = new Point(0,0);
Point p2 = p1;
System.out.println("p1: " + p1.x + ", " + p1.y);
System.out.println("p2: " + p2.x + ", " + p2.y);
p1.x = 1;
p2.y = 2;
System.out.println("p1: " + p1.x + ", " + p1.y);
System.out.println("p2: " + p2.x + ", " + p2.y);

    

    


    
    
    

      


    
    

p1: 0, 0
p2: 0, 0
p1: 1, 2
p2: 1, 2

    

    


    
    
    

      


    
    

Java does not have explicit pointers (and other related things such as pointer de-referencing and pointer arithmetic). When an object is passed into a method as an argument, the method gains access to the original object. If the method changes the object it received, the changes are retained in the object even after the method has completed.

public static void swapCoordinates(Point p){
    int temp = p.x;
    p.x = p.y;
    p.y = temp;
}

public static void main(String[] args) {
    Point p3 = new Point(2,3);
    System.out.println("p3: " + p3.x + ", " + p3.y);
    swapCoordinates(p3);
    System.out.println("p3: " + p3.x + ", " + p3.y);
}

    

    


    
    
    

      


    
    

p3: 2, 3
p3: 3, 2

    

    


    
    
    

      


    
    

What happens when no variables refer to an object?

Point spot = new Point(3, 4);
spot = null;

    

    


    
    
    

      


    
    

The first line creates a new Point object and makes spot refer to it. The second line changes spot so that instead of referring to the object, it refers to nothing. If there are no references to an object, there is no way to access its attributes or invoke a method on it. From the programmer’s view, it ceases to exist. However, it’s still present in the computer’s memory, taking up space.

In Java, you don’t have to delete objects you create when they are no longer needed. As your program runs, the system automatically looks for stranded objects and reclaims them; then the space can be reused for new objects. This process is called garbage collection. You don’t have to do anything to make garbage collection happen, and in general don’t have to be aware of it. But in high-performance applications, you may notice a slight delay every now and then when Java reclaims space from discarded objects.

As you know,

• Defining a class introduces a new object type.
• Every object belongs to some object type; that is, it is an instance of some class.
• A class definition is like a template for objects: it specifies what attributes the objects have and what methods they have.
• The new operator instantiates objects, that is, it creates new instances of a class.
• The methods that operate on an object type are defined in the class for that object.

public class Time {
    private int hour;
    private int minute;
    private int second;
}

    

    


    
    
    

      


    
    

You can give a class any name you like. The Java convention is to use format for class names.

The code is placed in a file whose name matches the class e.g., the Time class should be in a file named Time.java.

When a class is public (e.g., the Time class in the above example) it can be used in other classes. But the that are private (e.g., the hour, minute and second attributes of the Time class) can only be accessed from inside the Time class.

Constructors

public Time() {
    hour = 0;
    minute = 0;
    second = 0;
}

    

    


    
    
    

      


    
    

public Time(int h, int m, int s) {
    hour = h;
    minute = m;
    second = s;
}

    

    


    
    
    

      


    
    

this keyword

public Time(int hour, int minute, int second) {
    this.hour = hour;
    this.minute = minute;
    this.second = second;
}

    

    


    
    
    

      


    
    

public Time() {
    this(0, 0, 0); // call the overloaded constructor
}

public Time(int hour, int minute, int second) {
    // ...
}


    

    


    
    
    

      


    
    

public int secondsSinceMidnight() {
    return hour*60*60 + minute*60 + second;
}

    

    


    
    
    

      


    
    

Time t = new Time(0, 2, 5);
System.out.println(t.secondsSinceMidnight() + " seconds since midnight!");

    

    


    
    
    

      


    
    

As the instance variables of Time are private, you can access them from within the Time class only. To compensate, you can provide methods to access attributes:

public int getHour() {
    return hour;
}

public int getMinute() {
    return minute;
}

public int getSecond() {
    return second;
}

    

    


    
    
    

      


    
    

Methods like these are formally called “accessors”, but more commonly referred to as getters. By convention, the method that gets a variable named something is called getSomething.

Similarly, you can provide setter methods to modify attributes of a Time object:

public void setHour(int hour) {
    this.hour = hour;
}

public void setMinute(int minute) {
    this.minute = minute;
}

public void setSecond(int second) {
    this.second = second;
}

    

    


    
    
    

      


    
    

The content below is an extract from -- Java Tutorial, with slight adaptations.

public class Bicycle {

    private int gear;
    private int speed;

    // an instance variable for the object ID
    private int id;

    // a class variable for the number of Bicycle
    //   objects instantiated
    private static int numberOfBicycles = 0;
        ...
}

    

    


    
    
    

      


    
    

public class Bicycle {

    private int gear;
    private int speed;

    private int id;

    private static int numberOfBicycles = 0;


    public Bicycle(int startSpeed, int startGear) {
        gear = startGear;
        speed = startSpeed;

        numberOfBicycles++;
        id = numberOfBicycles;
    }

    public int getID() {
        return id;
    }

    public static int getNumberOfBicycles() {
        return numberOfBicycles;
    }

    public int getGear(){
        return gear;
    }

    public void setGear(int newValue) {
        gear = newValue;
    }

    public int getSpeed() {
        return speed;
    }

    // ...

}

    

    


    
    
    

      


    
    

Java comes with a rich collection of classes that you can use. They form what is known as the Java API (Application Programming Interface). Each class in the API comes with documentation in a standard format.

• List of all Java classes
• Example: API documentation of the String class

String is a built-in Java class that you can use without importing. Given below are some useful String methods:

Find characters of a string

String fruit = "banana";
char letter = fruit.charAt(0);

    

    


    
    
    

      


    
    

char[] fruitChars = fruit.toCharArray()

    

    


    
    
    

      


    
    

Change a string to upper/lower case

String name = "Alan Turing";
String upperName = name.toUpperCase();
System.out.println(name);
System.out.println(upperName);

    

    


    
    
    

      


    
    

Alan Turing
ALAN TURING

    

    


    
    
    

      


    
    

String s = "Ada";
s.toUpperCase(); // no effect
s = s.toUpperCase(); // the correct way

    

    


    
    
    

      


    
    

Replacing parts of a string

String text = "Computer Science is fun!";
text = text.replace("Computer Science", "CS");
System.out.println(text);

    

    


    
    
    

      


    
    

CS is fun!

    

    


    
    
    

      


    
    

Accessing substrings

Searching within strings

Comparing strings

String name1 = "Alan Turing";
String name2 = "Alan Turing";
System.out.println(name1 == name2);

    

    


    
    
    

      


    
    

if (name1.equals(name2)) {
    System.out.println("The names are the same.");
}

    

    


    
    
    

      


    
    

String name1 = "Alan";
String name2 = "Ada";
int diff = name1.compareTo(name2);
if (diff == 0) {
    System.out.println("The names are the same.");
} else if (diff < 0) {
    System.out.println("name1 comes before name2.");
} else if (diff > 0) {
    System.out.println("name2 comes before name1.");
}

    

    


    
    
    

      


    
    

String s1 = "Apple";
String s2 = "apple";
System.out.println(s1.equals(s2)); //false
System.out.println(s1.equalsIgnoreCase(s2)); //true

    

    


    
    
    

      


    
    

Printing special characters (line breaks, tabs, ...)

System.out.println("First line\nSecond \"line\"");

    

    


    
    
    

      


    
    

First line
Second "line"

    

    


    
    
    

      


    
    

System.out.println("First" + System.lineSeparator() + "Second");

    

    


    
    
    

      


    
    

First
Second

    

    


    
    
    

      


    
    

String formatting

public static String timeString(int hour, int minute) {
    String ampm;
    if (hour < 12) {
        ampm = "AM";
        if (hour == 0) {
            hour = 12;  // midnight
        }
    } else {
        ampm = "PM";
        hour = hour - 12;
    }

    // returns "07:05 PM"
    return String.format("%02d:%02d %s", hour, minute, ampm);
}

    

    


    
    
    

      


    
    

Primitive values (like int, double, and char) do not provide methods.

int i = 5;
System.out.println(i.equals(5));  // compiler error

    

    


    
    
    

      


    
    

But for each primitive type, there is a corresponding class in the Java library, called a wrapper class, as given in the table below. They are in the java.lang package i.e., no need to import.

Double d = new Double(2.5);
int i = d.intValue();
System.out.println(d);
System.out.println(i);

    

    


    
    
    

      


    
    

2.5
2

    

    


    
    
    

      


    
    

Each wrapper class defines constants MIN_VALUE and MAX_VALUE.

System.out.println(Integer.MIN_VALUE + " : " + Integer.MAX_VALUE);

    

    


    
    
    

      


    
    

Wrapper classes provide methods for strings to other types e.g., Integer.parseInt converts a string to (you guessed it) an integer. The other wrapper classes provide similar methods, like Double.parseDouble and Boolean.parseBoolean.

Integer.parseInt("1234") 1234

Wrapper classes also provide toString, which returns a string representation of a value.

Integer.toString(1234) "1234"

java.util.Arrays provides methods for working with arrays. One of them, toString, returns a string representation of an array. It also provides a copyOf that copies an array.

int[] a = new int[]{1,2,3,4};

int[] b = Arrays.copyOf(a, 3); // copy first three elements
System.out.println(Arrays.toString(b));

int[] c = Arrays.copyOf(a, a.length); // copy all elements
System.out.println(Arrays.toString(c));

    

    


    
    
    

      


    
    

[1, 2, 3]
[1, 2, 3, 4]

    

    


    
    
    

      


    
    

Scanner is a class that provides methods for inputting words, numbers, and other data. Scanner provides a method called nextLine that reads a line of input from the keyboard and returns a String. The following example reads two lines and repeats them back to the user:

import java.util.Scanner;

public class Echo {

    public static void main(String[] args) {
        String line;
        Scanner in = new Scanner(System.in);

        System.out.print("Type something: ");
        line = in.nextLine();
        System.out.println("You said: " + line);

        System.out.print("Type something else: ");
        line = in.nextLine();
        System.out.println("You also said: " + line);
    }
}

    

    


    
    
    

      


    
    

Scanner class normally reads inputs as strings but it can read in a specific type of input too.

Scanner in = new Scanner(System.in);

System.out.print("What is your age? ");
int age = in.nextInt();
in.nextLine();  // read the new-line character that follows the integer
System.out.print("What is your name? ");
String name = in.nextLine();
System.out.printf("Hello %s, age %d\n", name, age);