Spring Framework Generate Random Integer in specific range in Java

Ranging random integers not found in java.util.Random

An example on generating random integers between a specified range.

Example

import java.util.*;
class RandomRangeInt
{
public static void main(String args[])
{

// Create Random object
Random r=new Random();

// Specify start, end
int start=10;
int end=100;

// Create a 1 time loop
for(int i=0;i<1;i++)
{

// Generate random int below 100
int k=r.nextInt(end);

// If random integer below 100 is greater than start (10)
                        if(k>start)

// Then print
System.out.println(k);

                        // Else loop again, till if is true!, you may also write while loop
else i--;

}
}
}

Output

77

If you want to include start i.e. you want to allow even value of start (here 10) to come, then you must change if(k>start) to if(k>=start)

If you don't wish to write the logic, you can see my example on my class gowtham.gutha.util.RandomRangeInteger, download the java-utils framework (for using the class).

If you don't have already seen generating random integers in Java, you can see my post of Generating random values in Java (for all datatypes int,float,long,double..) and for generating random strings from first and last names, there is also a post.

Spring Framework How to reverse elements in ArrayList

Here i will discuss about reversing elements in a List. The method used here works for all implementations of the java.util.List which include ArrayList, LinkedList and Vector classes. There is no logic that we need to write to reverse the elements. The method reverse(List) has done everything for us and we are just a method call away from it. Simple is that. This method is present in the java.util.Collections class and is available as static which means that it can be accessed without the need of creating an object. The order of the elements in the list is reversed. Here is a tiny example that illustrates this.

import java.util.*;
class ReverseList
{
    public static void main(String args[])
    {

    // Create an ArrayList containing String type elements

    ArrayList<String> aList=new ArrayList<String>();


    // Add elements to the ArrayList aList    

    aList.add("Gowtham");
    aList.add("Gutha's");
    aList.add("java");
    aList.add("-");
    aList.add("demos");
    aList.add(".");
    aList.add("blogspot");
    aList.add(".");
    aList.add("com");

    // Store the size of aList
    // This avoids repeated calling of method in loops

    int size=aList.size();

    // Print elements before reversing


    System.out.println("\nElements before reversing");
    
    System.out.println("--------------------");


        for(int i=0;i<size;i++)
        {
        System.out.println(aList.get(i));
        }    


    
    // Reverse the elements in ArrayList

    Collections.reverse(aList);


    // Print the reversed elements

    System.out.println("\nElements in reversed order");

    System.out.println("--------------------");


        for(int i=0;i<size;i++)
        {
        System.out.println(aList.get(i));
        }    


    }
}

Output of the program

Elements before reversing
--------------------
Gowtham
Gutha's
java
-
demos
.
blogspot
.
com

Elements in reversed order
--------------------
com
.
blogspot
.
demos
-
java
Gutha's
Gowtham

Explaining the program

There is nothing in fact to explain in the program except the method which does it all. The java.util.Collections.sort(List l) method takes in a java.util.List object (i.e. object of any of it's implementing classes) and sorts it. In a similar way you can do it for LinkedList and Vector also. Just Replace All ArrayList with LinkedList (for LinkedList) and with Vector (for Vector), Stack. That's it.

Also see my post on sorting elements in a ArrayList, LinkedList and Vector

Spring Framework Sort Elements in ArrayList, LinkedList, Vector

Let us sort elements in ArrayList in the increasing order. Not only ArrayList, but also LinkedList. The code for both of them is same and dead easy as well. All you need to do is to remember this sweet method prototype. The following method will sort the elements according to their compareTo() method. For elements in a list to be sorted, those elements must be implementing the java.lang.Comparable interface.

import java.util.*;
class SortList
{
    public static void main(String args[])
    {

    // Create an ArrayList containing String type elements

    ArrayList<String> aList=new ArrayList<String>();


    // Add elements to the ArrayList aList   

    aList.add("Gowtham");
    aList.add("Gutha's");
    aList.add("java");
    aList.add("-");
    aList.add("demos");
    aList.add(".");
    aList.add("blogspot");
    aList.add(".");
    aList.add("com");


    // Print elements before sorting

    System.out.println("\nElements before sorting");
    System.out.println("--------------------");

        for(int i=0;i<aList.size();i++)
        {
        System.out.println(aList.get(i));
        }   


    
    // Sort the elements in ArrayList

    Collections.sort(aList);


    // Print the sorted elements

    System.out.println("\nElements in sorted order");
    System.out.println("--------------------");


        for(int i=0;i<aList.size();i++)
        {
        System.out.println(aList.get(i));
        }   


    }
}

Output of the program

Elements before sorting
--------------------
Gowtham
Gutha's
java
-
demos
.
blogspot
.
com

Elements in sorted order
--------------------
-
.
.
Gowtham
Gutha's
blogspot
com
demos
java

Explaining the program

The java.util.Collections class contains a static method called sort() which takes a java.util.List object and sorts this according to the compareTo() method written in the element class. Here, the elements are of type java.lang.String and hence for sorting the compareTo() method in the String class is used. As said earlier, for this to happen the element class must be implementing the java.lang.Comparable interface. The algorithm used for developing this method is a modified version of the mergesort.

The List that is sent as parameter should be modifiable because re arranging the elements has to take place.

To sort a LinkedList the way is the same. To try the above program with LinkedList Replace All the ArrayList with LinkedList and for Vector replace with Vector. Save the program, compile and then execute. That's it. Remember that the Collections.sort() takes List object which can be LinkedList or ArrayList or Vector and any class implementing the List interface.

Also see sorting an array in increasing order

Spring Hibernate Generate Random String in Java

Random String Generation in Java

Yet another example on generating a random string in Java taking characters randomly from first and last names and attaching a random number <1000 at the end.

Example

// For Scanner and Random classes
import java.util.*;
class GenerateRandomName
{
public static void main(String args[])
{

// Create a java.util.Scanner object for taking input from cmd
Scanner s=new Scanner(System.in);

// Take first name
String fname=s.nextLine();

// Take last name
String lname=s.nextLine();

// Create java.util.Random object
Random r=new Random();

// Generate random name
String rname=fname.substring(0,r.nextInt(fname.length()-1))+lname.substring(0,r.nextInt(lname.length()-1))+r.nextInt(10000);

// Print random name
System.out.println("Random name: "+rname);

}
}

Output

Gowtham
Gutha
Random name: GowGut2446

The theme of generation is explained above. For further doubts, feel free to drop a comment.

Also see Generating Random numbers in Java

Spring Framework Difference between capacity() and size() in Vector

The difference between capacity() and size() in java.util.Vector is that capacity() returns how many elements it can store whereas the size() gives the no.of elements in the Vector at the time of method call.

Capacity of a vector is usually declared within the constructor itself. An example will give better understand.

import java.util.*;

class CapacitySize

{

        public static void main(String args[])

        {

        Vector<String> v=new Vector<String>(10);

        v.setSize(3);

        v.add("java-demos.blogspot.com");

        v.add("Gowtham Gutha");

        

        System.out.println("The capacity of the vector is "+v.capacity());

        System.out.println("The size of the vector is "+v.size());

        }

}

In the above example, the size of the vector is set to 10 (if you use the default constructor, the default vector size then will be 10 only). Next, the size is set to 3 and then added 2 elements to it. When, the size is printed, 5(3+2) is printed. Because 2 elements are added after the size is set to 3. A vector is like a dynamic array which can be extended. The capacity is the no.of elements that the vector can store is 10 because 10 is passed in the creation, 10 will be printed.

Sample Output

The capacity of the vector is 10

The size of the vector is 5

92YF2PBFC8XG

Spring Framework Remove Duplicate Elements in a Vector

Vector in java.util package is used as a dynamic array. Any no.of elements can be added to the vector. It might be essential sometimes to remove duplicate elements in the vector to save space. While this is not needed all the time, it is better to have an idea about the logic of how to remove duplicate elements in a Vector. Let us see how we can do this.

import java.util.*;

class RemoveDuplicates

{



    public static void main(String args[])

    {

    Vector<String> v=new Vector<String>();

    v.add("Gowtham");

    v.add(" Gutha's");

    v.add(" Java");

    v.add("-");

    v.add("demos");

    v.add(".");

    v.add("blogspot");



    // '.' again!

    v.add(".");

    v.add("com ");



    // Gowtham again!

    v.add("gowtham");

        

    System.out.println("Original");



        for(int i=0;i<v.size();i++)

        {

            System.out.print(v.elementAt(i));



        }



    System.out.println("\nAfter removing duplicates");

    removeDuplicates(v);



        for(int i=0;i<v.size();i++)

        {

            System.out.print(v.elementAt(i));

        }

    

    }





    // Applicable for all types of vectors



    public static void removeDuplicates(Vector v)

    {

        for(int i=0;i<v.size();i++)

        {

            for(int j=0;j<v.size();j++)

            {

                    if(i!=j)

                    {

                        if(v.elementAt(i).equals(v.elementAt(j)))

                        {

                        v.removeElementAt(j);

                        }

                    }

            }

        }

    }





    /*

        * Specifically applicable for String is written for equalIgnoreCase

        * The code..

    



        public static void removeDuplicates(Vector<String> v)

        {

            for(int i=0;i<v.size();i++)

            {

                for(int j=0;j<v.size();j++)

                {

                    if(i!=j)

                    {

                        if(v.elementAt(i).equalsIgnoreCase(v.elementAt(j)))

                        {

                        v.removeElementAt(j);

                        }

                    }

            }

        }

    */



}

Output

Original

Gowtham Gutha's Java-demos.blogspot.com gowtham

After removing duplicates

Gowtham Gutha's Java-demos.blogspotcom gowtham

Logic Analysis

A. Logic Applicable for all types of vectors

This is the logic that can be used for any type of Vector. java.util.Vector is a generic class and therefore any type of object can be stored. The equals() method compares two objects. It returns true if the object values are equal, false otherwise.
A double loop is used here which checks each element in the array at one index with other index. For a better understand, lets consider a case.
At the statement,
for(int i=0;i<v.size();i++)
The initial value of i is 0 and it is looped till it reaches v.size()-1 (This is because the elements are stored in the vector from 0th element and not from 1st element). v.size() returns the size of the vector i.e. number of elements in the vector. The i value increments every time the loop is executed. This is done till the condition of the loop fails i.e. i value equals to the size of the vector.

The next loop is the inner loop which consists of the same code but with i replaced by j.

A.1 Now what do the loops do?

The loops are used to check an element at particular index with other elements at other indexes and also the same element at the same index. Didn't get it? No problem. I'll explain analytically using the program.

First when i=0 and when control enters the inner for loop, then, j=0. The condition, if(i!=j) means that if the value of i is not equal to j. So control enters the inner if condition only if the value of i does not match with j. Next time, when the inner for loop (j loop) executes, the value of j becomes 1 due to j++ and the condition is i!=j is passed since i=0 and j=1 and now the control enters the inner most if condition and checks whether the element at i (here 0) is equal to the element at j (here j=1) which means that if first element (i.e. element at 0th index) is equal to the second element (i.e. element at the 1st index). This process continues till the inner for loop condition fails i.e. the value of j becomes the size of the vector. In all the cases (here) except 0 the outer if condition (i!=j condition) is satisfied and control enters the inner condition. If this condition is satisfied, then the element at j is removed. Here we are removing the elements that are repeated and at the positions after which they had already occurred. For example, if gowtham is an element that is repeated which occurs at 0th position in the vector and also at the fourth position in the vector, then the gowtham at the fourth position is removed not the one at the first position (i.e. not the one that has occurred first).
So whenever the i and j values never coincide (i.e. whenever they are not equal) and whenever the element at i position is equal to the element at j position, then the element at j position is removed.

i=0 and j=0; i!=j (false)
i=0 and j=1; i!=j (true) -> Check the inner if condition -> Remove duplicate if satisfied
i=0 and j=2; i!=j (true) -> Check the inner if condition -> Remove duplicate if satisfied
....

So, if we consider the 0th element is checked with 1st element, 2nd element, 3rd element, 4th element and so on till the end of all the elements in the vector. It is removed when it is found to be a duplicate.

Similarly,  1st element is checked with 0th element, 2nd element,3rd element, 4th element.... with all the elements in the vector to ensure that whether it is repeated or not.

Similarly, 2nd element is checked with 0th element, 1st element, 2nd element, 3rd element....

You'll have to note that the element 0th element is not checked with 0th element because they are however equal and in a similar way, 1st element is not checked with 1st element because they are however similar. This checking is prevented by i!=j condition. So, therefore the duplicate elements are removed.

B. Logic applicable for String type vectors only

With the help of this logic String type vectors can be ignored. You might already have an idea about equalIgnoreCase() method. It compares two strings ignoring the case. For example, java and Java are both equal according to equalIgnoreCase().

Spring Framework Binary search for integer in array

The following example illustrates binary search of int in array.

import java.util.*;

class SearchInt

{

        public static void main(String args[])

        {

        Scanner s=new Scanner(System.in);

        System.out.println("Enter no.of elements");

        int n=s.nextInt();

        

        System.out.println("Enter elements into array");

        int[] a=new int[n];

        

  for(int i=0;i<n;i++)

  {

  a[i]=s.nextInt();

  }



 System.out.println("Enter search element");

        int sr=s.nextInt();



        Arrays.sort(a);

        

        System.out.println("Sorted array\n--------------");

    for(int k:a)

    System.out.println(k);



        int idx=Arrays.binarySearch(a,sr);

        

        System.out.println("Element found at (after sorting) "+idx);

        }

}

Sample Output

Enter no.of elements

8

Enter elements into array

6

9

8

7

5

6

45

45

Enter search element

8

Sorted array

--------------

5

6

6

7

8

9

45

45

Element found at (after sorting)  4

binarySearch(a,sr): Takes array and search element respectively. Static method of the class.

sort(a): a must be sorted before searching for proper results. Static method.

idx: The index (may be any index if repeated more than 1 time). index value is with respect to the sorted array and not to the original one.

Arrays: Located in the java.util package.

Spring Framework How to Convert ArrayList into Array

Here is a question about converting ArrayList to an array. We can do this using two simple methods in the java.util.ArrayList. These methods return the Object[] which can be typecasted. Here are two programs that illustrate two methods separately for a better understand. These are provided with explanation and analysis for help. Not only this you'll learn a lot of things in this post (bonus!)

import java.util.*;
class ArrayListToArray
{
    public static void main(String args[])
    {
    ArrayList<String> a=new ArrayList<String>();

    a.add("Gowtham");
    a.add("Gutha's");
    a.add("Java");
    a.add("-");
    a.add("demos");
    a.add(".");
    a.add("blogspot");
    a.add(".");
    a.add("com");

    String st[]=a.toArray(new String[a.size()]);
    
    System.out.println("The elements are");

        for(String k:st)
        System.out.println(k);
    }
}

Output of the Program

The elements are
Gowtham
Gutha's
Java
-
demos
.
blogspot
.
com

Explaining toArray(T[]) method

This method returns an array of type of the object of ArrayList elements which is also the type of this method's parameter. For example, as you can see in the above program, i have sent new String[a.size()] as parameter and the elements in the ArrayList are of type String. So as there are multiple elements of type String we'll get a String[] in return. This returned String[] contains all the elements in the ArrayList in the order. This method is created for generic types. The parameter T[] clearly expresses this.

If you try changing the type of the parameter and the return type such as specifying the type of the parameter as an Integer array and the return type as String[] you'll probably get an error even if you do vice versa.

The prototype of this method is

<T> T[] toArray(T[] array)

Note that if the type of the ArrayList is a String and you are passing and taking Integer[] to and from the method respectively, you'll not get a compile time error rather you'll get an exception stating

Exception in thread "main" java.lang.ArrayStoreException
        at java.lang.System.arraycopy(Native Method)
        at java.util.ArrayList.toArray(Unknown Source) 

Here is an example illustrating toArray() method. The prototype is

Object[] toArray()

import java.util.*;
class ArrayListToArray
{
    public static void main(String args[])
    {
    ArrayList<String> a=new ArrayList<String>();

    a.add("Gowtham");
    a.add("Gutha's");
    a.add("Java");
    a.add("-");
    a.add("demos");
    a.add(".");
    a.add("blogspot");
    a.add(".");
    a.add("com");

    Object[] ob=a.toArray();
    
    System.out.println("The elements are");

        for(Object k:st)
        System.out.println(k);
    }
}

You'll get the same output for this. But when it comes to explanation, the toArray() method is a non-generic version. The return type of this method is Object[]. However, you can work out with the generic version of the ArrayList class. In this case, it is not even necessary to have ArrayList<String>, it is enough if you write ArrayList. But when you convert to array, you'll not get the generic type however. One more thing is that you cannot typecast it. This is because arrays cannot be typecasted directly like

String[] st=(String[])a.toArray();

which will lead to an error. As you will get an Object[] you cannot access String (here) methods such as substring() etc. Note that by the above statement, you'll not get a compile time error rather you'll receive a ClassCastException.

In this way, conversion of ArrayList into an array made simple. Also see Sort an Array in increasing order

Spring Framework Subtract Elements in Array in Java

An example code on subtracting elements in array in Java in decreasing order in 3 main steps. This simple logic can also be used on any programming language.

Subtract Elements

import java.util.*;

class SubArray

{

 public static void main(String args[])

 {

 

 

 // Create Scanner object for taking input from cmd

 Scanner s=new Scanner(System.in);

 

 

 // Read no.of elements for array and store it in n

 int n=s.nextInt();

 

 

 // Create array of n elements

 int[] a=new int[n];

 

 

  // Loop n times

  for(int i=0;i<a.length;i++)

  {

  

  // Take input from user and store in each element

  a[i]=s.nextInt();

  

  }

  

 

 // Modify the array, arrange it in increasing order

 Arrays.sort(a);

 

 

 // Initialize sub value to 0

 int sub=0;

 

 

  // Loop from end to start (decreasing order)

  for(int i=a.length-1;i>=0;i--)

  {



  

  // Subtract old value from new value

  sub=sub-a[i];

  

   // For the first time, the value is -ve so make it +ve

   if(i==(a.length-1))

   // To do that, multiply with -1

   sub=-1*sub;

   

  // Print every element in array in decreasing order

  System.out.println("array "+a[i]);

  

  

  }



  

  // Print the result

  System.out.println("Difference of all elements in array in decreasing order "+sub);

 

 

 }

 

 

}

Sample Output

5

5

4

3

8

1

array 8

array 5

array 4

array 3

array 1

Difference of all elements in array in decreasing order -5

Analysis

Loop from end to start: So that i could arrange those elements in decreasing order as the Arrays.sort() was called previously, all the elements in the array are arranged in increasing order.

n=5, sub=0, a[0]=5, a[1]=4, a[2]=3, a[3]=8, a[4]=1 (before sorting). In increasing order, a[0]=1, a[1]=3, a[2]=4, a[3]=5, a[4]=8 (after Arrays.sort(a))

sub=sub-a[i]:

In decreasing order, i is initially equal to 4, so

0=0-8 = -8 => sub=-8

i==a.length-1 => i==4? true -> sub= -1*sub => -8=-1*-8 = 8 => sub=8

8=8-5=3 => sub=3

3=3-4=-1 => sub=-1

-1=-1-3=-4 => sub=-4

-4=-4-1=-5 => sub=-5

-5 will be printed. The if condition is satisfied for the first time only. Still more efficient logic is appreciated in the comments.
Also see my other posts on Adding elements in array in Java and sorting array elements in increasing order in Java

Spring Framework Sort Array in Increasing Order in Java

An example code on sorting an array of (any numeric datatype) in increasing order in a single statement.

Sorting Array in Increasing Order

import java.util.*;

class SortIntArray

{





 public static void main(String args[])

 {

 

 

 // Create Scanner object

 Scanner s=new Scanner(System.in);

 

 

 // Take no.of elements in array

 int n=s.nextInt();

 

 

 // Create an array of n elements

 int[] a=new int[n];

 

 

  // Loop till end of array

  for(int i=0;i<n;i++)

  {

  

  

  // Read int from user and store

  a[i]=s.nextInt();

  

  

  }

 

 

 Arrays.sort(a);

 

 // Say user that is sorted array

 System.out.println("Sorted array");

 

 

  // 'i' represents every element in array 'a'

  for(int i:a)

  {

  System.out.println(i);

  }

  

  

 }

 

 

}

Output

5

3

5

6

8

7

Sorted array

3

5

6

7

8

There in fact no analysis that can be done, the logic is written by the developers of the class java.util.Array therefore removing the burden for the app developers to do this. That's why Java developers love to code in Java! Happy java coding :)

Spring Framework StringTokenizer in Java Example

An example on using java.util.StringTokenizer for counting no.of tokens split by a delimeter, using the methods hasMoreTokens(), nextToken() etc..

StringTokenizer Example

import java.util.*;

class StringTokenizerDemo

{





 public static void main(String args[])

 {



 

 String st1="this is a test";

 String st2="this,is,a,test";

 String st3="this.is.a.test";

 

 

 // Create a StringTokenizer with default delimeter i.e. space

 StringTokenizer s1=new StringTokenizer(st1);

 

 

 // Create a StringTokenizer with ',' as delimeter

 StringTokenizer s2=new StringTokenizer(st2,",");

 

 

 // Create a StringTokenizer with default delimeter i.e. space

 StringTokenizer s3=new StringTokenizer(st3);

 

 

 // Print the no.of tokens split by delimeter above

 System.out.println("No.of tokens for s1 are "+s1.countTokens());

 System.out.println("No.of tokens for s2 are "+s2.countTokens());

 System.out.println("No.of tokens for s3 are "+s3.countTokens());



 

  // Loop till hasMoreElements return false

  while(s1.hasMoreElements())

  {

  System.out.println(s1.nextToken());

  }

  

  

  System.out.println();

  

  

  // Loop till hasMoreTokens return false

  while(s2.hasMoreTokens())

  {

  System.out.println(s2.nextElement());

  }

  

  

  System.out.println();

  

  

  // Loop till hasMoreElements return false

  while(s3.hasMoreTokens())

  {

  System.out.println(s3.nextToken("."));

  }



 }

 



}

Explanation

s1=new StringTokenizer(st1): Create StringTokenizer for the first string st1. The default delimeter is a blank space. A delimeter is nothing but a string that is used for separating another string.

s2=new StringTokenizer(s2,","): Here, we have specified ',' as the delimeter. So this is used to split the string s2 into parts called tokens separated by a comma. This acts as s2.split(",").

s3=new StringTokenizer(st3): Create StringTokenizer with default delimeter pointing st3.

s1.nextToken(): Get's the next token in the string nothing but the word that is after the delimeter (here word after the space). You'll have to note that this also includes the first token though it doesn't have the specified delimeter (space) before it i.e. the first word this

s2.nextElement(): Same as the above, but not the set of characters between a space, but the set of characters between a comma also including the first one.

s3.nextToken("."): This returns the token enclosed between two dots (.) also including the first word (this) but not space. Though the delimeter was not specified in the constructor, it was specified here (i.e. in the nextToken(".") method) to get the tokens enclosed between dots.

Note: The s3.countTokens() method returns only one i.e. only the first token is returned as the default delimeter was space and there was no space found in the string st3 so the first one (from starting till ending) was returned.

Output

No.of tokens for s1 are 4

No.of tokens for s2 are 4

No.of tokens for s3 are 1

this

is

a

test



this

is

a

test



this

is

a

test

Spring Hibernate Java Random Number Generator

Java Random Number Generator

Here is a sample tutorial for generating random numbers in Java using java.util.Random class.

Random int number Java - Range Unspecified

import java.util.Random;
class JavaRandomNumber
{
public static void main(String args[])
{
// Create Random object
Random r=new Random();

// Generate 10 random integers

for(int i=0;i<10;i++)
{
int randomint=r.nextInt();
System.out.println("Random Integer : "+randomint);
}
}
}

r.nextInt(): Returns random number.

Random Java int number Generator - Range Specified

import java.util.Random;
class JavaRandomNumberRange
{
public static void main(String args[])
{
// Create Random object
Random r=new Random();
// Generate 10 random integers between 0 - 100

for(int i=0;i<10;i++)
{
int randomint=r.nextInt(100);
System.out.println("Random Integer : "+randomint);
}
}
}

r.nextInt(100): Returns random number from 0 - 100.

Random Java Long Number Generator

import java.util.Random;
class JavaRandomNumberLong
{
public static void main(String args[])
{
// Create Random object
Random r=new Random();
// Generate 10 random long values

for(int i=0;i<10;i++)
{
long randomlong=r.nextLong();
System.out.println("Random Integer : "+randomlong);
}
}
}

r.nextLong(): Generate random long number.

Java Random Boolean Value Generator

import java.util.Random;
class JavaRandomBoolean
{
public static void main(String args[])
{
// Create Random object
Random r=new Random();
// Generate random boolean - 10 times

for(int i=0;i<10;i++)
{
boolean randomboolean=r.nextBoolean();
System.out.println("Random Boolean : "+randomboolean);
}
}
}

r.nextBoolean(): Generates random boolean value (true/false).

Java Random Float Number Generator

import java.util.Random;
class JavaRandomFloat
{
public static void main(String args[])
{
// Create Random object
Random r=new Random();
// Generate random float - 10 times

for(int i=0;i<10;i++)
{
float randomfloat=r.nextFloat();
System.out.println("Random Float : "+randomfloat);
}
}
}

r.nextFloat(): Generates random float value.

Java Random Double Number Generator

import java.util.Random;
class JavaRandomDouble
{
public static void main(String args[])
{
// Create Random object
Random r=new Random();
// Generate random double - 10 times

for(int i=0;i<10;i++)
{
double randomdouble=r.nextDouble();
System.out.println("Random Double : "+randomdouble);
}
}
}

r.nextDouble(): Generates random double value.

Java Random Byte Numbers

import java.util.Random;
class JavaRandomBytes
{
public static void main(String args[])
{
// Create Random object
Random r=new Random();
// Generate 10 random byte values, store in byte array
byte[] b=new byte[10];

r.nextBytes(b);

for(byte t:b)
{
System.out.println(t);
}

}
}

r.nextBytes(b): Generates 'b' array length sized byte values & store them in b.

Note: Outputs vary.

Spring Framework Printing a Right Triangle in Java

Let us print a right angled triangle on the console in Java. Doing this is very simple if you put a very little effort. The following code sample illustrates how this can be achieved.

import java.util.*;

class RightTriangle

{

    public static void main(String args[])

    {



    Scanner s=new Scanner(System.in);



    System.out.println("Enter the base length (chars)");

    int n=s.nextInt();



    System.out.println("Enter the char");

    char st=s.next().charAt(0);

    

        for(int i=0;i<=n;i++)

        {

            for(int j=0;j<i+1;j++)

            {

            System.out.print(st);

            }

        System.out.println();

        }    

    }

}

Sample Output

Enter the base length (chars)

10

Enter the char

`

`

``

```

````

`````

``````

```````

````````

`````````

Explanation

n is an integer which represents the base length i.e. the no.of chars in the last line.

st represents the char that is to be used to draw the right angled triangle.

The two loops together draw the right angled triangle. Let us first consider the inner loop.

The inner loop is dedicated to print the required no.of given chars. It is obvious that the loop condition fails, whenever j becomes i+1.

The outer loop, rotates from 0 till the value of n (base length).
The inner loop rotate from 0 to i+1. Let us analyze the program for better understand.

For the first time

i=0;

j=0; j<0+1? (true) -> Print a `

j++; (j=1)

1<1? (false) -> Exit inner loop -> System.out.println();

i++; (i=1);

For the second time

i=1;

j=0; j<1+1? (true) -> Print a `

j++; (j=1); 1<1+1? (true) -> Print a `

j++; (j=2);

2<2? (false); -> Exit inner loop -> System.out.println();

This continues so on, it depends upon the value of n. Whatever, a right angled triangle is printed and this how we can achieve this in Java.