java

Synopsis

Java is a general-purpose programming language that is class-based, object-oriented, and designed to have as few implementation dependencies as possible. It is intended to let application developers “write once, run anywhere” (WORA), meaning that compiled Java code can run on all platforms that support Java without the need for recompilation.

Data Types

I/O Methods

Output Methods

	system.out.print("Hello World!"); //Will not move to the next line.
	system.out.println("Hello World!"); //Will move to the next line.

	// There is another type of output method, which is similar to C language.
	int a = 23;
	system.out.printf("value of a is : %d", a);

Input Methods

	import java.util.Scanner
	Scanner s = new Scanner(System.in);

	// input for an integer.
	int a = s.nextInt();

	// input for a string.
	String str = s.nextLine();
	String ss  = s.next();   // Takes input till 1st whitespace.

	// input for a double.
	double d = s.nextDouble();

Data Conversion

String to Number

        int i = Intege­r.p­ars­eInt(_str_);
 	double d = Double.pa­rse­Double(_str_);

Any Type to String

 	String s = String.va­lueOf(_value_);

Numeric Conver­sions

 	int i = (int) _numeric expression_;
        double i = (double) _numeric expression_;
        long i = (long) _numeric expression_;

Operators

Statements

If Statement

if ( _expression_ ) {
­ _statements_
} else if ( _expression_ ) {
­ _statements_
} else {
­ _statements_
}

While Loop

while ( _expression_ ) {
­ _statements_
}

Do-While Loop

do {
­ _statements_
} while ( _expression_ );

For Loop

for ( int i = 0; i < _max_; ++i) {
­ _statements_
}

For Each Loop

for ( _var_ : _collection_ ) {
­ _statements_
}

Switch Statement

switch ( _expression_ ) {
­ case _value_:
­ ­ ­ _statements_
­ ­ ­ ­break;
­ case _value2_:
­ ­ ­ _statements_
­ ­ ­ ­break;
­ ­def­ault:
­ ­ ­ _statements_
}

Exception Handling

try {
­ ­sta­tem­ents;
} catch (_Except­ionType_  _e1_) {
­ ­sta­tem­ents;
} catch (Exception _e2_) {
­ ­cat­ch-all statem­ents;
} finally {
­ ­sta­tem­ents;
}

Comments

A comment is the code that is not executed by the compiler, and the programmer uses it to keep track of the code.

Single Line Comment

// This is a single line command

Multi-Line Comment

/*
This is a multi line comment
we can add multiple lines here
x=5
y=c
*/

Constants

Constants are like variables, except that their value never changes during program execution. Constants are declared using static and final keywords

static final float pi = 3.1415;

Escape Sequences

Tab

It gives a tab space

\t

Backslash

It adds a backslash

\\

Single quote

It adds a single quotation mark

\'

Question mark

It adds a question mark

\?

Type Casting

Type Casting is a process of converting one data type into another

Widening Type Casting (Automatically)

It means converting a lower data type into a higher

int x = 49;
double new_x = x;   // Outputs 49.0

Narrowing Type Casting (Manually)

It means converting a higher data type into a lower

double x = 99.2
int new_x = (int) x;  // Outputs 99

Arrays

Initialisation

For 1-D array

// datatype array_name[] = new datatype[Size];
int number[] = new int[10];           // An Integer Array
String characters[] = new String[10]; // A String array
int[] number = new int[]{ 1,2,3,4,5,6,7,8,9,10 };

For 2-D array

// datatype array_name[][] = new datatype[row][column];
int number[][] = new int[10][10];            // An Integer Array of dimensions 10 x 10
String characters[][] = new String[10][10];  // A String Array of dimensions 10 x 10

Traversal

// Traditional for loop
for(int i=0;i<number.length;i++) //length gives the size of the array
{
System.out.println(number[i]);
}
// Advanced for loop
for(int i:number)
{
System.out.println(i);
}

Strings

“In Java, a string is basically an object that represents sequence of char values. An array of characters works same as Java string.” : Javatpoint

Ways to Initialise a string

Using String Literal

String s = "INPUT";
//Using the new keyword
String s = new String("INPUT");
//From a given character array
char ch[]={'I','N','P','U','T'};
String s=new String(ch);

The above mentioned methods creates a string that are immutable, to make strings mutable, we can use StringBuilder or StringBuffer

Using StringBuffer

“The string represents fixed-length, immutable character sequences while StringBuffer represents growable and writable character sequences.” : GFG

//Create a StringBuffer Object, i.e., empty string buffer
//By default it can take upto a sequence of 16 characters
StringBuffer sb = new StringBuffer();
// Can be initialised with a string
StringBuffer sb2 = new StringBuffer("Input");

1) append(string_data) method : Used to concatenate the entered string and the strings in the buffer

sb.append("Input");  //Now the empty string has been modified to "Input"

2) insert(beginIndex, endIndex, string_data) method : Inserts a given string literal to the specified positions

sb.insert(2," A String");
//Now the string is "In A Stringput"

3) replace(beginIndex, endIndex, string_data) method : Use to replace a sequence of characters from the specified beginIndex and endIndex-1, with another sequence

sb.replace(11,14," Literal");
//Now the string is "In A string Literal"

4) delete(beginIndex, endIndex) method : Use to delete a sequence of characters from the specified beginIndex and endIndex-1

sb.delete(11,19);
//Now the string is "In A String"

5) reverse() method : Reverses the current string

sb.reverse();
// Now the string is "gnirtS A nI"

Using StringBuilder

Very similiar to the StringBuffer class but is not Synchronous and neither Thread-Safe. But high in performance, i.e., speedy

//Create a StringBuilder Object, i.e., StringBuilder with no characters
//By default it can take upto a sequence of 16 characters
StringBuilder sb = new StringBuilder();
StringBuilder sb2 = new StringBuffer("Input");

append(), insert(), replace(), delete(), reverse() are used in the same way as used in the StringBuffer

To convert the objects of either StringBuilder or StringBuffer to string, use : toString()

String str = sb.toString();
System.out.println(str);

Array Methods

The Arrays class of the java.util package contains several static methods that can be used to fill, sort, search, etc in arrays.

String Methods

StringTokenizer

A class in java that is used to break a string into tokens based on given delimeter(s), by default breaks at whitespaces

Initialising

// To break the string at whitespaces, use the following code
StringTokenizer st = new StringTokenizer(string_value_or_variable);
// To break the string at multiple delimeters, use the following code
StringTokenizer st = new StringTokenizer(string_value_or_variable, delimiter_string);

Functions available in the StringTokeniser Class

Example to break the string at whitespaces

StringTokenizer st = new StringTokenizer("Hy there, how are you? Hoping you are doing great!");
while (st.hasMoreTokens())
{
	System.out.print(st.nextToken() + " ; ");
}

Output : Hy ; there, ; how ; are ; you? ; Hoping ; you ; are ; doing ; great! ;

The semi colon is used to seperate the tokens

Example to break the string at multiple delimeters

// The following scheme can be used to break a punctuated string, into words
StringTokenizer st = new StringTokenizer("Hy there, how are you? Hoping you are doing great!", ":,!? ");
while (st.hasMoreTokens())
{
	System.out.print(st.nextToken() + " ; ");
}

Output : Hy ; there ; how ; are ; you ; Hoping ; you ; are ; doing ; great ;

The semi colon is used to seperate the tokens

Collection

List

Set

Operations on List and Set

Map

Queue