Learn Java

Computer Science

Basic math operations can be applied to int, double, and float data types: - + addition - - subtraction - * multiplication - / division - % modulo (yields the remainder) These operations are not supported for other data types.

Operators

## Arithmetic Operators

Basic math operations can be applied to `int`, `double`, and `float` data types:

- `+` addition
- `-` subtraction
- `*` multiplication
- `/` division
- `%` modulo (yields the remainder)

These operations are not supported for other data types.

```java
int a = 20;
int b = 10;

int result;

result = a + b;  // 30
result = a - b;  // 10
result = a * b;  // 200
result = a / b;  // 2
result = a % b;  // 0
```

## Comparison Operators

Comparison operators can be used to compare two values:

- `>` greater than
- `<` less than
- `>=` greater than or equal to
- `<=` less than or equal to
- `==` equal to
- `!=` not equal to

They are supported for primitive data types and the result of a comparison is a boolean value `true` or `false`:

```java
int a = 5;
int b = 3;

boolean result = a > b;
// result now holds the boolean value true
```

## Bitwise Operators

Bitwise operators are used to manipulate individual bits of a number.

- `&` Bitwise AND
- `|` Bitwise OR
- `^` Bitwise XOR
- `~` Bitwise complement
- `<<` Signed right shift operator
- `>>` Signed left shift operator
- `>>>` Unsigned right shift operator
- `<<<` Unsigned left shift operator

They can only be operated on data of `int`, `char`, `byte`, `long`, and `short`.

```java
int a = 5;
int b = 3;

int bitwiseAnd = a & b;
// 1

int bitwiseOr = a | b;
// 7

int bitwiseXor = a ^ b;
// 6

int bitwiseComplement = ~a;
// -6

int bitwiseRightShift = a >> b;
// 0

int bitwiseLeftShift = a << b;
// 40
```


In Java, an array is used to store a list of elements of the same datatype. Arrays are fixed in size and their elements are ordered. java // Create an array of 5 int elements int[] marks = {10, 20, 30, 40, 50};  In Java, an array can be created in the following ways:

Arrays

In Java, an array is used to store a list of elements of the same datatype.

Arrays are fixed in size and their elements are ordered.

```java
// Create an array of 5 int elements
int[] marks = {10, 20, 30, 40, 50};
```

## Creating an Array

In Java, an array can be created in the following ways:

1. Using the {} notation, by adding each element all at once.

   ```java
   int[] age = {20, 21, 30};
   ```

2. Using the new keyword, and assigning each position of the array individually.

   ```java
   int[] marks = new int[3];

   marks[0] = 50;
   marks[1] = 70;
   marks[2] = 93;
   ```

## Index

An index refers to an element’s position within an array.

The index of an array starts from 0 and goes up to one less than the total length of the array.

```java
int[] marks = {50, 55, 60, 70, 80};

System.out.println(marks[0]);
// Output: 50

System.out.println(marks[4]);
// Output: 80
```

## ArrayList

In Java, an `ArrayList` is used to represent a dynamic list.

While arrays are fixed in size (the length cannot be modified), an `ArrayList` allows flexibility by allowing for the addition and removal of elements.

```java
// Import the ArrayList package
import java.util.ArrayList;

// Create an ArrayList called students
ArrayList<String> students = new ArrayList<String>();
```

## Modifying ArrayLists in Java

An `ArrayList` can easily be modified using built-in methods.

To add elements to an ArrayList, you use the `.add()` method. The element that you want to add goes inside of the `()`.

To remove elements from an ArrayList, you use the `.remove()` method. Inside the `()` you can specify the index of the element that you want to remove. Alternatively, you can directly specify the element that you want to remove.

```java
import java.util.ArrayList;

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

    // Create an ArrayList called studentList, which initially holds []
    ArrayList<String> studentList = new ArrayList<String>();

    // Add students to the ArrayList
    studentList.add("John");
    studentList.add("Lily");
    studentList.add("Samantha");
    studentList.add("Tony");

    // Remove John from the ArrayList, then Lily
    studentList.remove(0);
    studentList.remove("Lily");

    // studentList now holds [Samantha, Tony]

    System.out.println(studentList);
  }
}
```


Java

A class is a blueprint or a template for an object. Blueprints detail the general structure (information and behavior) about an object. java public class Cat { String name; String color; int age; public static void main(String[] args) {

Classes

A class is a blueprint or a template for an object. Blueprints detail the general structure (information and behavior) about an object.

## Syntax

```java
public class Cat {
  String name;
  String color;
  int age;

  public static void main(String[] args) {
    Cat myCat = new Cat();

    System.out.println("Name: " + myCat.name);
    System.out.println("Color: " + myCat.color);
    System.out.println("Age: " + myCat.age);
  }
}
```

## Java Instance

Java instances are objects that are based on classes. For example, `Bob` and `Alice` may each be an instance of the class `Person`.

Every instance has access to its own set of variables which are known as _instance fields_, which are variables declared within the scope of the instance. Values for instance fields are assigned within the constructor method.

```java
public class Person {
  int age;
  String name;

  // Constructor method
  public Person(int age, String name) {
    this.age = age;
    this.name = name;
  }

  public static void main(String[] args) {
    Person Bob = new Person(31, "Bob");
    Person Alice = new Person(27, "Alice");
  }
}
```

## Creating a New Class Instance

In Java, we use the `new` keyword followed by a call to the class constructor in order to create a new instance of a class.

The constructor can be used to provide initial values to instance fields.

```java
public class Person {
  int age;
  // Constructor
  public Person(int a) {
    this.age = a;
  }

  public static void main(String [] args) {
    // Here, we create a new instance of the Person class:
    Person p = new Person(28);
    System.out.println("Age is " + p.age);
    // Output: Age is 28
  }
}
```


A comment is a piece of text within a program that is not executed. It can be used to provide additional information to aid in understanding the code. In Java, single-line comments are created with two consecutive forward slashes //. js // I am a single-line comment! System.out.println(Hello, world!);  A single-line comment can also be used to comment after a line of code:

Comments

A comment is a piece of text within a program that is not executed. It can be used to provide additional information to aid in understanding the code.

## Single-line Comments

In Java, single-line comments are created with two consecutive forward slashes `//`.

```js
// I am a single-line comment!
System.out.println('Hello, world!');
```

A single-line comment can also be used to comment after a line of code:

```js
System.out.println('Hello, world!'); // Me, too!
```

## Multi-line Comments

Multi-line comments are created by surrounding the lines with `/*` at the beginning and `*/` at the end. Comments are good ways for a variety of reasons like explaining a code block or indicating some hints, etc.

```java
/*
And I am a
multi-line comment!
*/
```


Conditionals take an expression, which is code that evaluates to determine a value, and checks if it is true or false. If it’s true, we can tell our program to do one thing — we can even account for false to do another. As we write more complex programs, conditionals allow us to address multiple scenarios and make our programs more robust. An if statement executes a block of code when a specified boolean expression is evaluated as true; otherwise, the block of code will be skipped. java if (berries > 5) { System.out.println("More than a handful of berries."); }

Conditionals

Conditionals take an expression, which is code that evaluates to determine a value, and checks if it is `true` or `false`. If it’s `true`, we can tell our program to do one thing — we can even account for `false` to do another.

As we write more complex programs, conditionals allow us to address multiple scenarios and make our programs more robust.

## If Statement

An `if` statement executes a block of code when a specified boolean expression is evaluated as `true`; otherwise, the block of code will be skipped.

```java
if (berries > 5) {
  System.out.println("More than a handful of berries.");
}
```

## Else

An `else` clause can be added to an `if` statement.

The `else` statement executes a block of code when the condition inside the `if` statement is `false`:

- If the condition evaluates to `true`, code in the `if` part is executed.
- If the condition evaluates to `false`, code in the `else` part is executed.

The else statement is always the last condition.

```java
if (year == 2022) {
  System.out.println("Print if year is 2022");
}
else {
  System.out.println("Print if year is not 2022");
}
```

## Else If

`else if` statements can be chained together to check multiple conditions. Once a condition is `true`, a code block will be executed and the conditional statement will be exited.

There can be multiple `else if` statements in a single conditional statement.

```java
int testScore = 76;
char grade;

if (testScore >= 90) {
  grade = 'A';
} else if (testScore >= 80) {
  grade = 'B';
} else if (testScore >= 70) {
  grade = 'C';
} else if (testScore >= 60) {
  grade = 'D';
} else {
  grade = 'F';
}

System.out.println("Grade is " + grade);
// Ouptut: Grade is C
```

## Nested Conditional Statements

A nested conditional statement is a conditional statement nested inside another conditional statement. The outer conditional statement is evaluated first; if the condition is true, then the nested conditional statement will be evaluated.

```java
boolean studied = true;
boolean wellRested = true;

if (wellRested) {
  System.out.println("Best of luck today!");
  if (studied) {
    System.out.println("You are prepared for your exam!");
  } else {
    System.out.println("Study before your exam!");
  }
}
```

The output would be:

```shell
Output: Best of luck today!
Output: You are prepared for your exam!
```


Constructors are like normal methods within the class, but are used to initialize the object of the class.

Constructors

Constructors are like normal methods within the class but are used to initialize the object of the class.

In Java, every time the `new` keyword is used to create an object, at least one constructor is called.

## Types of Constructors

- Default constructor: These constructors do not accept any parameters.
- Parameterized constructor: These constructors accept a specific number of parameters.

## Creating Constructors

Here are some rules for creating constructors:

- Constructors always have same name as their class name.
- Constructors cannot be declared as `abstract`, `static`, `final`, and `synchronized`.
- Construtors do not have any explicit return types.

### Creating a Default Constructor

Here, the `Tree` class has a default constructor named `Tree()` with no parameters. When the instance of the class is created in `main()`, the constructor is called.

```java
class Tree {
  // Creating a default constructor
  Tree() {
    System.out.println("Tree is created");
  }

  public static void main(String args[]) {
    Tree t = new Tree();  // Calling a default constructor
  }
}

// Output: Tree is created
```

### Creating a Parameterized Constructor

Here, the `Employee` class has a parameterized constructor which takes parameters `int i` and `string n` respectively. These values are passed while creating an instance of class in `main()`.

```java
class Employee {
  int id;
  String name;

  // Creating a parameterized constructor
  Employee(int i, String n) {
    id = i;
    name = n;
    System.out.println(id + " " + name);
  }

  public static void main(String args[]) {
    Employee e = new Employee(110, "Ashish"); // Creating objects and passing values
  }
}

// Output: 110 Ashish
```


Java’s most basic data types are known as primitive data types and are in the system by default. The available types are as follows: - int - char - boolean - byte - long

Data Types

## Primitive Data Types

Java’s most basic data types are known as primitive data types and are in the system by default.

The available types are as follows:

- `int`
- `char`
- `boolean`
- `byte`
- `long`
- `short`
- `double`
- `float`

`null` is another, but it can only ever store the value null.

```java
int age = 28;
char grade = 'A';
boolean late = true;
byte b = 20;
long num1 = 1234567;
short no = 10;
float k = (float)12.5;
double pi = 3.14;
```

## Static Typing

In Java, the type of variable is checked at compile time. This is known as static typing. It has the advantage of catching the errors at compile time rather than at execution time.

Variables must be declared with the appropriate data type or the program will not compile.

```java
int i = 10;           // Type is int
char ch = 'a';        // Type is char

j = 20;               // Won't compile, no type is given
char name = "Sonny";  // Won't compile, wrong data type
```


Enumeration (enum) is a special user defined type where we specify a set of values for a variable and the variable can only take one out of a small set of possible values. The keyword enum is used to define an enumeration. An enum can contain constants, methods, etc. Heres the basic syntax for creating an enum: java public enum name { constant1,

Enums

Enumeration (enum) is a special user defined type where we specify a set of values for a variable and the variable can only take one out of a small set of possible values.

The keyword `enum` is used to define an enumeration.

An `enum` can contain constants, methods, etc.

## Syntax

Here's the basic syntax for creating an `enum`:

```java
public enum name {
  constant1,
  constant2,
  ...
}
```

Here's an `enum` with compass directions:

```java
public enum Direction {
  NORTH, SOUTH, EAST, WEST
}
```

- `Direction.NORTH` will have a value of 0.
- `Direction.SOUTH` will have a value of 1.
- `Direction.EAST` will have a value of 2.
- `Direction.WEST` will have a value of 3.

## Example

```java
public enum Day {
  SUN, MON, TUE, WED,
  THU, FRI, SAT
}
```

- `Day.SUN` will have a value of 0.
- `Day.MON` will have a value of 1.
- `Day.TUE` will have a value of 2.
- `Day.WED` will have a value of 3.
- `Day.THU` will have a value of 4.
- `Day.FRI` will have a value of 5.
- `Day.SAT` will have a value of 6.

To access one of the values:

```java
Day day = Day.MON;
```


The while loop loops through a block of code as long as a specified condition is true: pseudo while (condition) { // Code block to be executed }  In this example, the code in the loop will run again and again, as long as variable i is still less than 10:

Loops

## While Loop

The `while` loop loops through a block of code as long as a specified condition is true:

```pseudo
while (condition) {
  // Code block to be executed
}
```

In this example, the code in the loop will run again and again, as long as variable `i` is still less than 10:

```java
int i = 0;

while (i < 10) {
  System.out.println(i);
  i = i + 2;
}
```

The output would be:

```shell
0
2
4
6
8
```

## For Loop

A `for` loop iterates over a range of values. Its declaration is made up of the following three parts, each separated by a semicolon:

1. The initialization of the loop control variable.
2. A conditional expression.
3. An expression that modifies the loop control variable.

In this example, the loop control variable starts at 3 and decrements. The loop will continue iterating until the conditional expression is no longer true:

```java
for (int i = 3; i > 0; i--) {
  System.out.println(i);
}

System.out.println("Liftoff!");
```

The output would be:

```shell
3
2
1
Liftoff!
```

## For-Each Loop

In Java, the `for`-`each` loop allows you to directly loop through each item in an array or `ArrayList` and perform some action with each item.

When creating a `for`-`each` loop, you must include the `for` keyword and two expressions inside of parentheses, separated by a colon. These include:

- The data type and handle for an element we’re currently iterating over.
- The source array or ArrayList we’re iterating over.

```java
// Array of numbers
int[] numbers = {1, 2, 3, 4, 5};

// For-each loop that prints each number in numbers
// int num is the handle while numbers is the source array
for (int num : numbers) {
    System.out.println(num);
}
```


The Java Math class provides several methods that allows us to work on mathematical calculations with numbers. java Math.method();  Here are the Math methods in alphabetical order:

Math Methods

The Java `Math` class provides several methods that allows us to work on mathematical calculations with numbers.

```java
Math.method();
```

Here are the `Math` methods in alphabetical order:


Instances of the Random class in Java can be used to generate streams of pseudorandom numbers.

Random

The [`Random`](https://docs.oracle.com/javase/8/docs/api/java/util/Random.html) class is present in the `java.util` package. It is used to generate random values or streams of random values of specific data types.

## Usage

The `Random` class can be accessed by importing it as follows:

```java
import java.util.Random;
```

When an instance of the `Random` class is created, either a `seed` value is passed to the constructor or no values are passed at all.

The `seed` is a value that gets manipulated (using a linear congruential formula) to produce a stream of pseudorandom values. The `Random` class uses a 48-bit `seed`.

In this code, objects `rand1` and `rand2` of the `Random` type are created using the `new` keyword. While no parameters are passed during the creation of `rand1`, a `seed` value is used during the creation of `rand2`.

```java
Random rand1 = new Random();

long seed = (long)3.142;
Random rand2 = new Random(seed);
```

The value of the seed can be set or modified at any point during the execution of the program using the `.setSeed()` method.

```java
long newseed = (long)2.7182;
rand2.setSeed(newseed);
```

**Note:** If two objects of type `Random` are created with the same seed, they will generate the same sequence of numbers, provided they are subject to the same sequence of method calls.

## Generating Individual Values

The following methods can be used to generate the next pseudorandom number from the generator's sequence.

- The `.nextDouble()` and `.nextFloat()` methods return values in range [0,1). This means that the range is inclusive of zero (indicated by the square bracket) and exclusive of 1 (indicated by the parenthesis).
- The `.nextInt()` and `.nextLong()` methods have no such limits.

**Note:** In the absence of a `seed`, these methods return different values every time they are called or even for separate instances:

```java
float f = rand1.nextFloat();
double d = rand1.nextDouble();
int i = rand1.nextInt();
long l = rand1.nextLong();
boolean b = rand1.nextBoolean();

System.out.println("Random float: " + f);
System.out.println("Random double: " + d);
System.out.println("Random integer: " + i);
System.out.println("Random long: " + l);
System.out.println("Random boolean: " + b);
```

The output will look like this:

```shell
Random float: 0.13293427
Random double: 0.900476085026994
Random integer: 152429987
Random long: -4775630185711902523
Random boolean: 1
```

The `.nextInt()` method can also be used with an upper bound so that the generated value is between 0 and that upper bound.

```java
i = rand1.nextInt(25);
System.out.println("Random integer in range [0,25): " + i);
```

The output will be:

```shell
Random integer in range [0,25): 16
```

A byte array can also be filled with random elements using the `.nextBytes()` method.

```java
byte[] b = new byte [5];
rand1.nextBytes(b);

System.out.print("Random byte array: ");

for (byte j: b)
  System.out.print(j + " ");
```

The output looks like this:

```shell
Random byte array: -44 -82 44 62 -111
```

## Generating Streams

`IntStream`, `DoubleStream` and `LongStream` objects can be produced using the `.ints()`, `.doubles()` and `.longs()` methods, respectively.

The following example illustrates the generation of a `DoubleStream` object and can be extrapolated for the other two object types as well.

To use an object of this type, the following import statement must be used:

```java
import java.util.stream.DoubleStream;
```

An unlimited stream of pseudorandom `double` values, each in the range [0,1), can be generated using the following code snippet. A `DoubleStream` is a stream over objects of `double` type:

```java
DoubleStream stream;
stream = rand1.doubles();
```

An effectively unlimited stream of pseudorandom `double` values, each in the range specified, can be generated using the following code snippet. The parameters are the lower bound and the upper bound, respectively:

```java
stream = rand1.doubles(0,10);
```

**Note:** In the above method, the lower bound is inclusive but the upper bound is exclusive.

A stream of specified size of values in range [0,1) can be generated using the following code snippet. The parameter represents the size of the stream:

```java
stream = rand1.doubles(5);
```

A stream of specified size with values in a specified range can be generated using the following code snippet. The parameters are the size of stream, the lower bound and the upper bound, respectively:

```java
stream = rand1.doubles(5, 0, 10);
```


A String in Java is an object that holds a sequence of characters contained within a pair of double quotes ("). It is not a primitive datatype. Java strings provide a way to store something like a word, sentence, or whole paragraph. They can be any length and can contain letters, numbers, symbols, and spaces. java // Creating a String variable String name = "Codecademy"; // Creating another String variable String address = "575 Broadway #5, New York, NY 10012"

Strings

A `String` in Java is an object that holds a sequence of characters contained within a pair of double quotes (`"`). It is not a primitive datatype.

Java strings provide a way to store something like a word, sentence, or whole paragraph. They can be any length and can contain letters, numbers, symbols, and spaces.

```java
// Creating a String variable
String name = "Codecademy";

// Creating another String variable
String address = "575 Broadway #5, New York, NY 10012";
```

To compare `String`s, the `.equals()` method must be used instead of the primitive equality comparator `==`. `.equals()` will compare the values of the strings, while `==` compares the references (location in memory) of the strings.

```java
String name = "Bob";

// The following will print "false" because strings are case-sensitive
System.out.println(name.equals("bob"));
```


A switch statement provides a means of checking an expression against various case statements. If there is a match, the code within starts to execute. The break keyword can be used to terminate a case. Theres also an optional default statement marking code that executes if none of the case statements are true. A switch statement looks like: java switch (expression) { case x: // Code block

Switch

A `switch` statement provides a means of checking an expression against various `case` statements. If there is a match, the code within starts to execute. The `break` keyword can be used to terminate a case.

There's also an optional `default` statement marking code that executes if none of the `case` statements are true.

## Syntax

A `switch` statement looks like:

```java
switch (expression) {
  case x:
    // Code block
    break;
  case y:
    // Code block
    break;
  default:
    // Code block
}
```

So here's an example:

```java
switch (grade) {
  case 9:
    System.out.println("Freshman");
    break;
  case 10:
    System.out.println("Sophomore");
    break;
  case 11:
    System.out.println("Junior");
    break;
  case 12:
    System.out.println("Senior");
    break;
  default:
    System.out.println("Invalid");
    break;
}
```

- The `switch` keyword initiates the statement and is followed by `()`, which contains the value that each case will compare. In the example, the value or expression of the switch statement is `grade`.
- Inside the block, `{}`, there are multiple cases.
- The `case` keyword checks if the expression matches the specified value that comes after it. The value following the first case is `9`. If the value of grade is equal to `9`, then the code that follows the `:` would run.
- The `break` keyword tells the computer to exit the block and not execute any more code or check any other cases inside the code block.
- At the end of each switch statement, there is a `default` statement. If none of the cases are `true`, then the code in the `default` statement will run. It’s essentially the `else` part in an `if`/`else if`/`else` statement.

In the code above, suppose grade is equal to `10`, then the output would be “Sophomore”.

**Note:** Without the `break` keyword at the end of each case, the program would execute the code for the first matching case and _all_ subsequent cases, including the `default` code. This behavior is different from `if`/`else` conditional statements which execute only one block of code.

## Example

```java
int rating = 3;

switch (rating) {
  case 5:
    System.out.println("Exceptional");
    break;
  case 4:
    System.out.println("Good");
    break;
  case 3:
    System.out.println("Fair");
    break;
  default:
    System.out.println("Poor");
    break;
}
```


The Scanner class is used to get user input, and it is found in the java.util package. To use the Scanner class: 1. Import the Scanner class at the top of the file. 2. Create a Scanner object. 3. Use a method from the Scanner class. To import the Scanner class, add at the top of the file: java

User Input

The `Scanner` class is used to get user input, and it is found in the `java.util` package.

To use the `Scanner` class:

1. Import the `Scanner` class at the top of the file.
2. Create a `Scanner` object.
3. Use a method from the `Scanner` class.

To import the `Scanner` class, add at the top of the file:

```java
import java.util.Scanner;
```

In our example, we will use the `.nextLine()` method, which is used to read `Strings`:

```java
import java.util.Scanner;                         // 1. Import the Scanner class

class Main {
  public static void main(String[] args) {
    Scanner myObj = new Scanner(System.in);       // 2. Create a Scanner object

    System.out.println("Enter your user name");

    String userName = myObj.nextLine();           // 3. Read the user input with .nextLine()

    System.out.println("The username is: " + userName);
  }
}
```

Here, the user can enter some text in the terminal, press <kbd>enter</kbd>, and that string will get stored in the variable `userName`.

## Input Types

In the example above, we used the `.nextLine()` method, which is used to read `Strings`. To read other types, look at the table below:

| Method           | Description                         |
| ---------------- | ----------------------------------- |
| `.nextBoolean()` | Reads a boolean value from the user |
| `.nextByte()`    | Reads a byte value from the user    |
| `.nextDouble()`  | Reads a double value from the user  |
| `.nextFloat()`   | Reads a float value from the user   |
| `.nextInt()`     | Reads a int value from the user     |
| `.nextLine()`    | Reads a String value from the user  |
| `.nextLong()`    | Reads a long value from the user    |
| `.nextShort()`   | Reads a short value from the user   |


Variables are used whenever there’s a need to store a piece of data. A variable contains data that can be used in the program elsewhere. Using variables also ensures code re-usability since it can be used to replace the same value in multiple places. To declare a variable in Java, any of these three keywords can be used along with a variable name: - The data type. - The variable name. - The value. java int age = 28;

Variables

Variables are used whenever there’s a need to store a piece of data. A variable contains data that can be used in the program elsewhere. Using variables also ensures code re-usability since it can be used to replace the same value in multiple places.

## Declaring a Variable

To declare a variable in Java, any of these three keywords can be used along with a variable name:

- The data type.
- The variable name.
- The value.

```java
int age = 28;
char grade = 'A';
boolean late = true;
byte b = 20;
long num1 = 1234567;
short no = 10;
float k = (float)12.5;
double pi = 3.14;
```

The equal sign `=` is used to assign a value to a variable. After the initial assignment is made, the value of a variable can be updated to new values as needed.


Operators

Arithmetic Operators

Comparison Operators

Bitwise Operators

Contributors

Learn Java on Codecademy

Learn Java

Computer Science

Contributors

Languages

Subjects

Languages