Control Statements in java
We have three types of control statements in java.
Decision making Statements.
Looping statement
Branching statements.
1.Decision making Statements.
Java If-else Statement
The Java if statement is used to test the condition. It
checks Boolean condition: true or false. There are various types
of if statement in java.
if statement
if-else statement
nested if statement
if-else-if ladder
Java IF Statement
The Java if statement tests the condition. It executes the if block if
condition is true.
Syntax:
if(condition){
//code to be executed
}
Example:
public class IfExample {
public static void main(String[] args) {
int sal=400;
if(sal >200){
System.out.print("sal
is grater then 200");
}
}
}
Output:
sal is grater then 200
Java IF-else Statement
The Java if-else statement also tests the condition. It executes
the if block if condition is true otherwise else block is
executed.
Syntax:
if(condition){
//code if condition is true
}else{
//code if condition is false
}
public class IfElseExample {
public static void main(String[] args) {
int number=15;
if(number%2==0){
System.out.println("even number");
}else{
System.out.println("odd number");
}
}
}
Output:
odd number
Java IF-else-if ladder Statement
The if-else-if ladder statement executes one condition from multiple
statements.
Syntax:
if(condition1){
//code to be executed if condition1 is true
}else if(condition2){
//code to be executed if condition2 is true
}
else if(condition3){
//code to be executed if condition3 is true
}
else{
//code to be executed if all the conditions are false
}
public class Test {
public static void main(String args[]) {
int x = 30;
if( x == 10 ) {
System.out.print("Value
of X is 10");
}else if( x == 20 ) {
System.out.print("Value
of X is 20");
}else if( x == 30 ) {
System.out.print("Value
of X is 30");
}else {
System.out.print("This
is else statement");
}
}
}
Switch Statement:
A switch statement is useful when you need to select one of
several alternatives based on the value of an integer, a character, or
a String variable. The basic form of the switchstatement is
this:
switch (expression)
{
case constant:
statements;
break;
[ case constant-2:
statements;
break; ] ...
[ default:
statements;
break; ] ...
}
Example:
package com.opps;
public class SwitchExample {
public static void main(String[] args) {
int lan = 3;
String language;
switch (lan) {
case 1:
language = "C";
break;
case 2:
language = "C++";
break;
case 3:
language = "JAVA";
break;
case 4:
language = "VC++";
break;
case 5:
language = ".NET";
break;
default:
language = "Invalid
language";
break;
}
System.out.println(language);
}
}
output:
JAVA
2. Looping Statements:-
Looping statement are the statements execute one or more statement
repeatedly several number of times. In java programming language there are
three types of loops; while, for and do-while.
Why use loop ?
When you need to execute a block of code several number of times then you
need to use looping concept in Java language.
Advantage with looping statement
Reduce length of Code
Take less memory space.
Burden on the developer is reducing.
Time consuming process to execute the program is reduced.
Difference between conditional and looping statement
Conditional statement executes only once in the program where as looping
statements executes repeatedly several number of time.
While loop
In while loop first check the condition if condition is true
then control goes inside the loop body otherwise goes outside of the body.
while loop will be repeats in clock wise direction.
Syntax
while(condition)
{
Statement(s)
Increment / decrements (++ or --);
}
Example while loop
class whileDemo
{
public static void main(String args[])
{
int i=0;
while(i<5)
{
System.out.println(+i);
i++;
}
Output
1
2
3
4
5
for loop
for loop is a statement which allows code to be repeatedly executed.
For loop contains 3 parts Initialization, Condition and Increment or Decrements
Syntax
for ( initialization; condition; increment )
{
statement(s);
}
Initialization: This step is execute first and this is execute only
once when we are entering into the loop first time. This step is allow to
declare and initialize any loop control variables.
Condition: This is next step after initialization step, if it is
true, the body of the loop is executed, if it is false then the body of the
loop does not execute and flow of control goes outside of the for loop.
Increment or Decrements: After completion of Initialization and
Condition steps loop body code is executed and then Increment or Decrements
steps is execute. This statement allows to update any loop control variables.
First initialize the variable
In second step check condition
In third step control goes inside loop body and execute.
At last increase the value of variable
Same process is repeat until condition not false.
Improve your looping concept For Loop
Display any message exactly 5 times.
Example of for loop
class Hello
{
public static void main(String args[])
{
int i;
for (i=0: i<5; i++)
{
System.out.println("Hello Friends !");
}
}
}
Output
Hello Friends !
Hello Friends !
Hello Friends !
Hello Friends !
Hello Friends !
do-while
A do-while loop is similar to a while loop, except that a
do-while loop is execute at least one time.
A do while loop is a control flow statement that executes a block of code
at least once, and then repeatedly executes the block, or not, depending on a
given condition at the end of the block (in while).
When use do..while loop
when we need to repeat the statement block at least one time then
ues do-while loop. In do-while loop post-checking process will be occur, that
is after execution of the statement block condition part will be executed.
Syntax
do
{
Statement(s)
increment/decrement (++ or --)
}while();
In below example you can see in this program i=20 and we chech condition
i is less than 10, that means conditon is false but do..while loop execute onec
and print Hello world ! at one time.
Example do..while loop
class dowhileDemo
{
public static void main(String args[])
{
int i=20;
do
{
System.out.println("Hello world !");
i++;
}
while(i<10);
}
}
Output
Hello world !
Example do..while loop
class dowhileDemo
{
public static void main(String args[])
{
int i=0;
do
{
System.out.println(+i);
i++;
}
while(i<5);
}
}
Output
1
2
3
4
5
Branching statements.
Return Statement: It is used to terminate execution of the method
and in the definition of a method to initialize return value.
It can be used in two ways:
It can be used in two ways:
Method with returned type void.
Method with returned type non-void.
Example
public class Return
{
static int a=5;
static int b=11;
public static void main(String[] args)//void is used
{
System.out.println (a+b);
return;
}
}
Continue Statement: This statement is used to terminate an iteration
of the loop in for loop, while and do-while loop.
The boolean expression and its increment are evaluated after the continue statement is executed in a for loop. In this case nested statements are executed again if and only if the boolean expression is true.
The boolean expression is evaluated after the continue statement is executed in a while loop and do-while loop. In this case nested statements are executed again if and only if the boolean expression is true.
The boolean expression and its increment are evaluated after the continue statement is executed in a for loop. In this case nested statements are executed again if and only if the boolean expression is true.
The boolean expression is evaluated after the continue statement is executed in a while loop and do-while loop. In this case nested statements are executed again if and only if the boolean expression is true.
Example:
public class Continue
{
public static void main(String args[]) {
//use array to declare integer
int [] num = {1,14,9,16,5,7};
for(int a : num ) {//store num values in int a
//check if a equals to 16 then skip 16 and print next values
if( a == 16 ) {
continue ;
}//skip 16 and continue iteration
System.out.println (a); //print statement
System.out.println ("\n");
}
}
}
Break Statement : It is used to terminate execution of the
statement in loop statements like for loop, while loop, do-while loop and also
in switch statements.
public class Break{
public static void main(String[] args)
{
int j,k;
System.out.println ("Addition between 1 to 8 :");
/*check j is less than 8 then it increment
with 1 and go to next loop and check k is
less than j then go to if loop addition of
j and k equal to 6*/
for (j = 1; j < 8; j++)
{
for (k = 2; k <j; k++)
{
if (j+k==6) {
break ;
}//break if condition is false
}
if (j==k)
{
//check j equal to k if yes then print j
System.out.println (" "+j);
}
}
}
}
DataTypes in java
As explained in the text about java variable , each variable in Java
has a data type. Data types into two groups:
Primitive data types
Object references
A variable takes up a certain amount of space in memory. How much memory
a variable takes depends on its data type.
A variable of a primitive data type contains the value of the variable
directly in the memory allocated to the variable. For instance, a number or a
character.
A variable of an object reference type is different from a variable of a
primitive type. A variable of an object type is also called a reference.
The variable itself does not contain the object, but contains
a reference to the object. The reference points to somewhere else in
memory where the whole object is stored. Via the reference stored in the
variable you can access fields and methods of the referenced object. It is
possible to have many different variables reference the same object. This is
not possible with primitive data types.
The Java language contains the following primitive data types:
|
Data type
|
Description
|
|
boolean
|
A binary value of
either true or false
|
|
byte
|
8 bit signed value, values from -128 to 127
|
|
short
|
16 bit signed value, values from -32.768 to 32.767
|
|
char
|
16 bit Unicode character
|
|
int
|
32 bit signed value, values from -2.147.483.648 to
2.147.483.647
|
|
long
|
64 bit signed value, values from
-9.223.372.036.854.775.808 to 9.223.372.036.854.775.808
|
|
float
|
32 bit floating point value
|
|
double
|
64 bit floating point value
|
That these are primitive data types means that they are not objects, nor
references to objects (classes and objects are explained in later texts in this
Java tutorial).
Here is an example of how you declare a variable of a primitive type:
int myInt;
The primitive types also come in versions that are full-blown objects.
That means that you reference them via an object reference that you can have
multiple references to the same value, and you can call methods on them like on
any other object in Java. The list of core object data types below contains the
object versions of the primitive types. The list also contains a few others of
the core object types in Java.
|
Data type
|
Description
|
|
Boolean
|
A binary value of
either true or false
|
|
Byte
|
8 bit signed value, values from -128 to 127
|
|
Short
|
16 bit signed value, values from -32.768 to 32.767
|
|
Character
|
16 bit Unicode character
|
|
Integer
|
32 bit signed value, values from -2.147.483.648 to
2.147.483.647
|
|
Long
|
64 bit signed value, values from
-9.223.372.036.854.775.808 to 9.223.372.036.854.775.808
|
|
Float
|
32 bit floating point value
|
|
Double
|
64 bit floating point value
|
|
String
|
N byte Unicode string of textual data. Immutable
|
Notice how object types are spelled with a capital letter in the
beginning of their name, where the primitive version (non-object) is spelled in
all lowercase characters. There are also abbreviation differences,
likeint vs. Integer and char vs. Character.
There are of course many other components you can use in the Java API,
but the above mentioned data types are the core Java types. The String type is
explained in more detail in its own text: java Strings
You can also create your own more complex data types by creating
custom classes. I will get back to how in a later text.
Here is how you declare a variable of (reference to) one of the core
object types:
Integer myInteger;
When you declare an object reference variable, the reference does not
point to any object. You need to create (instantiate) an object first. Here is
how that is done:
Integer myInteger;
myInteger = new Integer(45);
This example makes the myInteger variable reference
an Integer object which internally contains the value 45. It is
the new Integer(45) part of the code that creates
the Integer object.
You can also create the object already when the variable is declared, like
this:
Integer myInteger = new Integer(45);
The object versions of the primitive data types are immutable, meaning
the values stored inside them cannot be changed once set. For instance, the
value stored inside an Integer object cannot be changed once the
object has been created.
The variable that references the object can be made to point to another
object though. Here is an example:
Integer myInteger = new Integer(45);
myInteger = new Integer(33);
As you can see, the variable in the example is made to point to
another Integer object.
Before Java 5 you had to call methods on the object versions of the
primitive types, to get their value out as a primitive type. For instance:
Integer myInteger = new Integer(45);
int myInt = myInteger.intValue();
From Java 5 you have a concept called "auto boxing". That means
that Java can automatically "box" a primitive variable in an object
version, if that is required, or "unbox" an object version of the
primitive data type if required. For instance, the example before could be
written like this:
Integer myInteger = new Integer(45);
int myInt = myInteger;
In this case Java would automatically extract the int value
from the myInteger object and assign that value to myInt.
Similarly, creating an object version of a primitive data type variable
was a manual action before Java:
int myInt = 45;
Integer myInteger = new Integer(myInt);
With auto boxing Java can do this for you. Now you can write:
int myInt = 45;
Integer myInteger = myInt;
Java will then automatically "box" the primitive data type
inside an object version of the corresponding type.
Java's auto boxing features enables you to use primitive data types where
the object version of that data type was normally required, and vice versa.
There is one pitfall to keep in mind though. A variable of type object (a
reference to an object) can point to null, meaning it points to nothing -
no object. If you try to convert null to a primitive value you will
get a NullPointerException (an error that causes the program to
fail). This code shows an example of that:
Integer myInteger = null;
int myInt = myInteger;
This code will compile alright, but when executed it will result in
NullPointerException because the variable myInteger points
to null. It is thus not possible to convert (unbox) the value of the
object it points to, because it does not point to any object.
An array is a collection of variables of the same type. For
instance, an array of int is a collection of variables of the
type int. The variables in the array are ordered and each have an index.
You will see how to index into an array later in this text. Here is an
illustration of Java arrays:
Declaring an Array Variable in Java
A Java array variable is declared just like you would declare a variable
of the desired type, except you add[] after the type. Here is a simple
Java array declaration example:
int[] intArray;
You can use a Java array as a field, static field, a local variable, or
parameter, just like any other variable. An array is simply a variation of the
data type. Instead of being a single variable of that type, it is a collection
of variables of that type.
Here are a few more Java array declaration examples:
String[] stringArray;
MyClass[] myClassArray;
The first line declares an array of String references. The
second line declares an array of references to objects of the
class MyClass, which symbolizes a class you have created yourself.
You actually have a choice about where to place the square brackets []
when you declare an array in Java. The first location you have already seen.
That is behind the name of the data type (e.g. String[]). The second
location is after the variable name. The following Java array declarations are
actually all valid:
int[] intArray;
int intArray[];
String[] stringArray;
String stringArray[];
MyClass[] myClassArray;
MyClass myClassArray[];
Personally I prefer to locate the square brackets [] after the data type
(e.g. String[]) and not after the variable name. After all, an array is a
special kind of data type, so I feel it is easier to read the code when the
square brackets are placed right after the data type in the array declaration.
When you declare a Java array variable you only declare the variable
(reference) to the array itself. The declaration does not actually create an
array. You create an array like this:
int[] intArray;
intArray = new int[10];
This example creates an array of type int with space for
10 int variables inside.
Once an array has been created its size cannot be changed. In some
languages arrays can change their size after creation, but in Java an array
cannot change its size once it is created. If you need an array-like data
structure that can change its size, you should use a List.
The previous Java array example created an array of int which
is a primitive data type. You can also create an array of object references.
For instance:
String[] stringArray = new String[10];
Java allows you to create an array of references to any type of object
(to instances of any class).
The Java programming language contains a shortcut for instantiating
arrays of primitive types and strings. If you already know what values to
insert into the array, you can use an array literal. Here is how how an array
literal looks in Java code:
int[] ints2 = new int[]{ 1,2,3,4,5,6,7,8,9,10 };
Notice how the values to be inserted into the array are listed inside
the { ... } block. The length of this list also determines the length
of the created array.
Actually, you don't have to write the new int[] part in the
latest versions of Java. You can just write:
int[] ints2 = { 1,2,3,4,5,6,7,8,9,10 };
It is the part inside the curly brackets that is called an array
literal.
This style works for arrays of all primitive types, as well as arrays of
strings. Here is a string array example:
String[] strings = {"one", "two",
"three"};
Each variable in an Java array is also called an "element".
Thus, the example shown earlier created an array with space for 10 elements,
and each element is a variable of type int.
Each element in the array has an index (a number). You can access each
element in the array via its index. Here is an example:
intArray[0] = 0;
int firstInt = intArray[0];
This example first sets the value of the element (int) with index 0, and
second it reads the value of the element with index 0 into
an int variable.
You can use the elements in a Java array just like if they were ordinary
variables. You can read their value, assign values to them, use the elements in
calculations and pass specific elements as parameters to method calls.
The indexes of elements in a Java array always start with 0 and continue
to the number 1 below the size of the array. Thus, in the example above with an
array with 10 elements the indexes go from 0 to 9.
You can access the length of an array via its length field.
Here is an example:
int[] intArray = new int[10];
int arrayLength = intArray.length;
In this example the variable named arrayLength will contain the
value 10 after the second line of code has been executed.
You can loop through all the elements of an array using the.java for loop
Here is an example of iterating an array with a for loop in Java:
String[] stringArray = new String[10];
for(int i=0; i < stringArray.length; i++) {
stringArray[i] = "String no " + i;
}
for(int i=0; i < stringArray.length; i++) {
System.out.println( stringArray[i] );
}
This example first creates an array of String references. When
you first create an array of object references, each of the cells in the array
points to null - no object.
The first of the two for loops iterate through
the String array, creates a String and makes the cell
reference that String.
The second of the two for loops iterate through
the String array and prints out all of the strings that the cells
reference.
If this had been an array of int (primitive values), it could
have looked like this:
int[] intArray = new int[10];
for(int i=0; i < intArray.length; i++) {
intArray[i] = i;
}
for(int i=0; i < intArray.length; i++) {
System.out.println( intArray[i] );
}
The variable i is initialized to 0 and runs up until the length
of the array minus 1. In this case, i takes the values 0 through 9,
each time repeating the code inside the for loop one time, and for
each iteration i has a different value.
You can also iterate an array using the "for-each" loop in
Java. Here is how that looks:
int[] intArray = new int[10];
for(int theInt : intArray) {
System.out.println(theInt);
}
The for-each loop gives you access to each element in the array, one at a
time, but gives you no information about the index of each element.
Additionally, you only have access to the value. You cannot change the value of
the element at that position. If you need that, use a normal for-loop as shown
earlier.
For for-each loop also works with arrays of objects. Here is an example
showing you how to iterate an array of String objects:
String[] stringArray = {"one", "two",
"three"};
for(String theString : stringArray) {
System.out.println(theString);
}
The examples shown above all created arrays with a single dimension,
meaning elements with indexes going from 0 and up. It is, however, possible to
create arrays where each element has two or more indexes which identify
(locate) it in the array.
You create a multidimensional array in Java by appending one set of
square brackets ([]) per dimension you want to add. Here is an example that
creates a two-dimensional array:
int[][] intArray = new int[10][20];
This example creates a two-dimensional array of int elements.
The array contains 10 elements in the first dimension, and 20 elements in the
second dimension. In other words, this examples creates an array of arrays
of int elements. The array of arrays has space for
10 int arrays, and each int array has space for
20 int elements.
You access the elements in a multidimensional array with one index per
dimension. In the example above you would have to use two indexes. Here is an
example:
int[][] intArray = new int[10][20];
intArray[0][2] = 129;
int oneInt = intArray[0][2];
The variable named oneInt will contain the value 129 after the
last line of Java code has executed.
When you iterate a multidimensional array in Java you need to iterate
each dimension of the array separately. Here is is how iterating a
multidimensional looks in Java:
int[][] intArray = new int[10][20];
for(int i=0; i < intArrays.length; i++){
for(int j=0; j < intArrays[i].length; j++){
System.out.println("i:
" + i + ", j: " + j);
}
}
Sometimes you need to insert elements into a Java array somewhere. Here
is how you insert a new value into an array in Java:
int[] ints = new int[20];
int insertIndex = 10;
int newValue = 123;
//move elements below insertion point.
for(int i=ints.length-1; i > insertIndex; i--){
ints[i] = ints[i-1];
}
//insert new value
ints[insertIndex] = newValue;
System.out.println(Arrays.toString(ints));
The example first creates an array. Then it defines an insert index and a
new value to insert. Then all elements from the insertion index and to the end
of the array are shifted one index down in the array. Note that this will shift
the last value in the array out of the array (it will simply be deleted).
The above array insertion code could be embedded in a Java method. Here
is how that could look:
public void insertIntoArray(
int[] array, int insertIndex,
int newValue){
//move elements below insertion point.
for(int i=array.length-1; i > insertIndex; i--){
array[i] = array[i-1];
}
//insert new value
array[insertIndex] = newValue;
}
This method takes an int[] array as parameter as well as the
index to insert the new value, and the new value. You can insert elements into
an array by calling this method like this:
int[] ints = new int[20];
insertIntoArray(ints, 0, 10);
insertIntoArray(ints, 1, 23);
insertIntoArray(ints, 9, 67);
Of course, if the insertIntoArray() method is located in a
different class than the above code, you would need an object of that class in
order to be able to call the method. Or, if
the insertIntoArray() method was static, you would need to put
the class name and a dot in front of the method name.
Sometimes you have want to remove an element from a Java array. Here is
the code for removing an element from an array in Java:
int[] ints = new int[20];
ints[10] = 123;
int removeIndex = 10;
for(int i = removeIndex; i < ints.length -1; i++){
ints[i] = ints[i + 1];
}
This example first creates an int array. Then it sets the value
of the element with index 10 to 123. Then the example removes the element with
index 10. It removes the element by shifting all elements below index 10 one
position up in the array. After the removal, the last element in the array will
exist twice. Both in the last and second last element.
The above code could be embedded in a Java method. Here is how such an
array removal Java method could look:
public void removeFromArray(
int[] array, int removeIndex){
for(int i = removeIndex; i < array.length -1; i++){
array[i] = array[i + 1];
}
}
This removeFromArray() method takes two parameters: The array
to remove the element from, and the index of the element to remove.
Of course, if the removeFromArray() method is located in a
different class than the above code, you would need an object of that class in
order to be able to call the method. Or, if
the removeFromArray() method was static, you would need to put
the class name and a dot in front of the method name.
Sometimes you may need to find the minimum or maximum value in a Java
array. Java does not have any built-in functions for finding minimum and
maximum value, so I will show you how to code that yourself.
Here is first how you find the minimum value in an array:
int[] ints = {0,2,4,6,8,10};
int minVal = Integer.MAX_VALUE;
for(int i=0; i < ints.length; i++){
if(ints[i] < minVal){
minVal = ints[i];
}
}
System.out.println("minVal = " + minVal);
The example first sets
the minVal to Integer.MAX_VALUE which is the highest
possible value an int can take. This is done to make sure that the
initial value is not by accident smaller than the smallest value in the array.
Second, the example iterates through the array and compares each value
to minValue. If the element in the array is smaller
than minVal then minVal is set to the value of the element.
Finally the minimum value found in the array is printed out. In the
example above the minimum value is 0.
Here is how you find the maximum value in an array. It is pretty similar
to finding the minimum value.
int[] ints = {0,2,4,6,8,10};
int maxVal = Integer.MIN_VALUE;
for(int i=0; i < ints.length; i++){
if(ints[i] > maxVal){
maxVal = ints[i];
}
}
System.out.println("maxVal = " + maxVal);
This example will print out the value 10.
The major differences to finding the minimum value is the initialization
of maxVal and the comparison ofmaxVal to the elements in the
array.
Java contains a special utility class that makes it easier for you to
perform many often used array operations like copying and sorting arrays,
filling in data, searching in arrays etc. The utility class is
calledArrays and is located in the standard Java package java.util.
Thus, the fully qualified name of the class is:
java.util.Arrays
I will cover a few of the methods found in this class in the following
sections. Remember, in order to usejava.util.Arrays in your Java classes
you must import it. Here is how importing java.util.Arrays could look
in a Java class of your own:
package myjavaapp;
import java.util.Arrays;
public class MyClass{
public static void main(String[] args) {
}
}
Notice the import java.util.Arrays; statement in bold. It is
this statement that imports the classjava.util.Arrays into your Java
class.
You can copy an array into another array in Java in several ways.
The first way to copy an array in Java is to iterate through the array
and copy each value of the source array into the destination array. Here is how
copying an array looks using that method:
int[] source = new int[10];
int[] dest = new int[10];
for(int i=0; i < source.length; i++) {
source[i] = i;
}
for(int i=0; i < source.length; i++) {
dest[i] = source[i];
}
First two int arrays are created. Second, the source array is
initialized with values from 0 to 9 (0 to the length of the array minus 1).
Third, each element in the source array is copied into the destination array.
The second method to copy a Java array is to use
the Arrays.copyOf() method. Here is how copying an array
using Arrays.copyOf() looks:
int[] source = new int[10];
for(int i=0; i < source.length; i++) {
source[i] = i;
}
int[] dest = Arrays.copyOf(source, source.length);
The Arrays.copyOf() method takes 2 parameters. The first
parameter is the array to copy. The second parameter is the length of the new
array. This parameter can be used to specify how many elements from the source
array to copy.
The third method to copy a Java array is to use
the Arrays.copyOfRange() method. TheArrays.copyOfRange() method
copies a range of an array, not necessarily the full array. Here is how copying
a full array using Arrays.copyOfRange() in Java looks:
int[] source = new int[10];
for(int i=0; i < source.length; i++) {
source[i] = i;
}
int[] dest = Arrays.copyOfRange(source, 0, source.length);
The Arrays.copyOfRange() method takes 3 parameters. The first
parameter is the array to copy. The second parameter is the first index in the
source array to include in the copy. The third parameter is the last index in
the source array to include in the copy (excluded - so passing 10 will copy
until and including index 9).
You can convert an Java array of primitive types to
a String using the Arrays.toString() method. Here is an
example of how to convert an array of int to
a String using Arrays.toString():
int[] ints = new int[10];
for(int i=0; i < ints.length; i++){
ints[i] = 10 - i;
}
System.out.println(java.util.Arrays.toString(ints));
The first line creates an array of int with 10 elements.
The for loop initializes the array with the values from 10 to 1. The
last line prints out the value returned from Arrays.toString(). The
returned String(which is printed) looks like this:
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
You can sort the elements of an array using
the Arrays.sort() method. Sorting the elements of an array rearranges
the order of the elements according to their sort order. Here is
an Arrays.sort() example:
int[] ints = new int[10];
for(int i=0; i < ints.length; i++){
ints[i] = 10 - i;
}
System.out.println(java.util.Arrays.toString(ints));
java.util.Arrays.sort(ints);
System.out.println(java.util.Arrays.toString(ints));
The first line declares and instantiates an array of int with a
length of 10;
The for loop iterates over the array and inserts values into
each element. The values inserted will go from 10 to 1 in descending order.
After the for loop the array is converted to
a String using Arrays.toString() and printed out to the
console (command line). At this point the output written to the console
(the String version of the array) looks like this:
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
The array is then sorted using Arrays.sort(). The elements will now
be ordered in ascending order.
After sorting the array, it is again converted into
a String and printed to the console. The output printed this time
looks like this:
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
The Arrays.sort() example shown earlier only works for Java
arrays of primitive data types. Java's primitive data types have a natural
ordering, either their numeric order, or the order of the characters in the
ASCII table (the binary number representing the character).
If you want to sort an array of objects you need to use a different
method. Objects may not have any natural sort order, so you need to provide
another object which is capable of determining the order of your objects. Such
an object is called a Comparator.
Hello, my name is Jack Sparrow. I'm a 50 year old self-employed Pirate from the Caribbean. 
No comments:
Post a Comment