Fibonacci Series is the sequence of numbers in which each number in the sequence is equal to the sum of two numbers before it.
Fibonacci Series:
0, 1, 1, 2, 3, 5, 8, 13, 21………….
public class FibonacciSeries {
public static void main(String[] args) {
int terms = 15;
System.out.println("Fibonacci Series:");
printFibonacciSeries(terms);
}
public static void printFibonacciSeries(int num) {
int a = 0, b = 1;
for (int i = 0; i < num; i++) {
System.out.print(a + " ");
int temp = a + b;
a = b;
b = temp;
}
}
}
Output
Fibonacci Series:
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
A number that can be divided exactly only by itself and 1.
For example 7, 17 and 41.
public class PrimeNumber {
public static void main(String[] args) {
int num = 41;
boolean isPrimeNumber = isPrime(num);
if (isPrimeNumber) {
System.out.println(num + " is a prime number.");
} else {
System.out.println(num + " is not a prime number.");
}
}
public static boolean isPrime(int num) {
if (num <= 1) {
return false;
}
for (int i = 2; i <= Math.sqrt(num); i++) {
if (num % i == 0) {
return false;
}
}
return true;
}
}
Output
41 is a prime number.
We can check if the given number is binary or not by the following ways
1 or 0 digits by the reminder and divide method1 or 0 digit by the reminder and divide methodIn the below program, we are getting each digit of the given input number one by one using the reminder method.
If the digit is any other than the 0 and 1, i.e. number is not Binary and it returns false. Otherwise, it will return true.
Java Program
public class BinaryChecker {
public static void main(String[] args) {
long input = 101110001; // Change this to the number you want to check.
boolean isBinary = isBinaryNumber(input);
if (isBinary) {
System.out.println(input + " is a binary number.");
} else {
System.out.println(input + " is not a binary number.");
}
}
public static boolean isBinaryNumber(long num) {
while (num > 0) {
long digit = num % 10;
if (digit != 0 && digit != 1) {
return false; // The number contains a non-binary digit.
}
num /= 10;
}
return true; // All digits are 0 or 1, so it's a binary number.
}
}
Output
101110001 is a binary number.
In the below program, we have used the regex expression to check if the number has only 0 or 1 digits.
We can do it as follows
We are converting the given input number to a string
inputStr contains only 0 or 1 digits.0 or 1 in the number, the number is binary and it returns true, Otherwise it returns falseJava Program
import java.util.regex.Pattern;
import java.util.regex.Matcher;
public class BinaryChecker2 {
public static void main(String[] args) {
long input = 10110101;
String inputStr = String.valueOf(input);
boolean isBinary = isBinary(inputStr);
if (isBinary) {
System.out.println(inputStr + " is a binary number.");
} else {
System.out.println(inputStr + " is not a binary number.");
}
}
public static boolean isBinary(String num) {
// Define a regular expression pattern to match binary numbers (0 or 1).
String binaryPattern = "^[01]+$";
// Create a Pattern object.
Pattern pattern = Pattern.compile(binaryPattern);
// Use a Matcher to match the input string with the pattern.
Matcher matcher = pattern.matcher(num);
// Return true if the input string is a binary number; otherwise, return false.
return matcher.matches();
}
}
Output
10110101 is a binary number.
/**
* A Java program to check if the given number is a palindrome or not.
* @author coderolls.com
*/
public class PalindromeNumber {
public static void main(String[] args) {
int num = 125521;
checkIfPalindrome(num);
}
private static void checkIfPalindrome(int num) {
int numCopy = num;
int reversedNumber = 0;
int reminder;
while(numCopy != 0){
reminder = numCopy % 10;
reversedNumber = reversedNumber *10 + reminder;
numCopy /=10;
}
if (reversedNumber == num) {
System.out.println("The Number '" + num + "' is a Palindrome Number.");
} else {
System.out.println("The Number '" + num + "' is not a Palindrome Number.");
}
}
}
Output
The Number '125521' is a Palindrome Number.
/**
* A Java program to check if the given string is palindrome or not.
* @author coderolls.com
*/
public class PalindromeString {
public static void main(String[] args) {
String str1 = "racecar";
checkIfPalindrome(str1);
}
private static void checkIfPalindrome(String str) {
String reversedString = "";
int len = str.length();
for (int i = (len - 1); i >= 0; --i) {
reversedString = reversedString + str.charAt(i);
}
if (str.equalsIgnoreCase(reversedString)) {
System.out.println("The String '" + str + "' is a Palindrome String.");
} else {
System.out.println("The String '" + str + "' is not a Palindrome String.");
}
}
}
Output
The String 'racecar' is a Palindrome String.
We can print an array using the following 3 ways
Arrays.toString()Here, we are iterating over an array and printing each element.
Java Program
/**
* Java program to print an array using for loop
* By coderolls.com
*/
public class PrintArray {
public static void main(String[] args) {
int[] arr = {1, 5, 6, 9, 2, 6, 9, 6, 3, 2, 1};
System.out.println("Elements of the array are given below: ");
for (int i: arr) {
System.out.println(i);
}
}
}
Output
Elements of the array are given below:
1
5
6
9
2
6
9
6
3
2
1
Arrays.toString()We have a ready-made method to print an array in Java.
The Arrays.toString() method expects an array to be printed as an input parameter and returns a string of array elements.
Input param - array to be print
Returns - array string
Java Program
/**
* Java program to print an array using Arrays.toString()
* By coderolls.com
*/
public class PrintArray2 {
public static void main(String[] args) {
int[] arr = {1, 5, 6, 9, 2, 6, 9, 6, 3, 2, 1};
System.out.println("Elements of the array are given below: ");
String srrString = Arrays.toString(arr);
System.out.println(srrString);
}
}
Output
Elements of the array are given below:
[1, 5, 6, 9, 2, 6, 9, 6, 3, 2, 1]
Arrays.deepToString()To print a multi-dimensional array we can use the ready-made Arrays.deepToString() method.
Java Program
import java.util.Arrays;
/**
* Java program to print a multi-dimensional array using Arrays.deepToString()
* By coderolls.com
*/
public class PrintArray3 {
public static void main(String[] args) {
int[][] arr = {{1, 5, 8, 7}, {2, 6, 9, 6,}};
System.out.println("Elements of the multi-dimensional array are given below: ");
String srrString = Arrays.deepToString(arr);
System.out.println(srrString);
}
}
Output
Elements of the multi-dimensional array are given below:
[[1, 5, 8, 7], [2, 6, 9, 6]]
In Java 8 Streams, we can use the forEach() method to print each element of an array.
Java Program
import java.util.Arrays;
/**
* Java program to print an array using Java 8 Streams forEach() method
* By coderolls.com
*/
public class PrintArray4 {
public static void main(String[] args) {
int[] arr = {1, 5, 8, 7, 2, 6, 9, 6};
System.out.println("Elements of the array are given below: ");
Arrays.stream(arr).forEach(System.out::println);
}
}
Output
Elements of the array are given below:
1
5
8
7
2
6
9
6
We can check it using the regex expression.
In the below program, we have simply used the regex expression to check whether the given string is numeric or not.
The regex expression to check this is -?\\d+
Here,
-? –> negative sign, could have none or one
\\d+ –> one or more digits
Java Program
import java.util.List;
/**
* A Java program to check if the given String is a number or not.
* @author coderolls.com
*/
public class CheckIfNumber {
public static void main(String[] args) {
List<String> strings = List.of("95965", "Jack485", "-9859", "784Will", "056", "Google");
for(String str : strings) {
boolean isNumber = isNumberOrNot(str);
if (isNumber) {
System.out.println("The String '" + str + "' is a Number.");
} else {
System.out.println("The String '" + str + "' is not a Number.");
}
}
}
/**
* A method checks if the input param string is numeric or not
* It uses a regex Expression
* -? --> negative sign, could have none or one
* \\d+ --> one or more digits
* @param str
* @return
*/
private static boolean isNumberOrNot(String str) {
return str.matches("-?\\d+");
}
}
Output
The String '95965' is a Number.
The String 'Jack485' is not a Number.
The String '-9859' is a Number.
The String '784Will' is not a Number.
The String '056' is a Number.
The String 'Google' is not a Number.
Character.isDigit() methodIn this method, we are iterating over an array of characters of the String and checking if any character is a digit or not.
If we find one or more digits in the string, the given string is not a number string or a number.
import java.util.List;
/**
* A Java program to check if the given String is a number or not.
* using the Character.isDigit() method.
* @author coderolls.com
*/
public class CheckIfNumber2 {
public static void main(String[] args) {
List<String> strings = List.of("95965", "Jack485", "-9859", "784Will", "056", "Google");
for(String str : strings) {
boolean isNumber = isNumberOrNot(str);
if (isNumber) {
System.out.println("The String '" + str + "' is a Number.");
} else {
System.out.println("The String '" + str + "' is not a Number.");
}
}
}
/**
* A method checks if the input param string is numeric or not
* It uses a regex Expression
* -? --> negative sign, could have none or one
* \\d+ --> one or more digits
* @param str
* @return
*/
private static boolean isNumberOrNot(String str) {
char[] chars = str.toCharArray();
for(int i=0; i<str.length(); i++) {
char ch = str.charAt(i);
if(i==0 && ch == '-') {
continue;
}
if (! (Character.isDigit(ch))) {
return false;
}
}
//If not a single ch is a digit, the string is numeric
return true;
}
}
Output
The String '95965' is a Number.
The String 'Jack485' is not a Number.
The String '-9859' is a Number.
The String '784Will' is not a Number.
The String '056' is a Number.
The String 'Google' is not a Number.
NumberFormatExpression way.We can also check if it using the NumberFormatExpression way.
Let’s See how. (Not recommended to use, Just for Info)
We can try to parse the given String using the Integer.parseInt(str) method.
If the given string is not a number the method will throw NumberFormatExpression and we can return false by catching this expression. Otherwise true.
See the sample method below.
public static boolean isInteger(String s) {
try {
Integer.parseInt(s);
} catch(NumberFormatException e) {
return false;
} catch(NullPointerException e) {
return false;
}
// only got here if we didn't return false
return true;
}
But this way is not recommended as it causes expensive exceptions in the code.
]]>sum variable.sum variable.Let’s a Java program to calculate the sum of all digits of a number.
Java Program
/**
* A Java program to calculate the sum of all digits of a given number
* By coderolls.com
*/
public class SumOfAllDigits {
public static void main(String[] args) {
int number = 1256;
int sum = sumOfAllDigits(number);
System.out.println("The sum of all digits of " + number + " is: "+ sum);
}
private static int sumOfAllDigits(int number) {
int sum =0;
while(number!=0){
int reminder = number%10;
sum = sum + reminder;
number = number/10;
}
return sum;
}
}
Output
The sum of all digits of 1256 is: 14
Both are the Object object-oriented programming languages. Still, C++ and Java have a different set of features for different use cases.
Let’s try to understand the basic difference between C++ and Java.
| Property | C++ | Java |
|---|---|---|
| Platform Independence | C++ is a platform-dependent programming language. | C++ is a platform-independent programming language. |
| Garbage Collection | Programmer has to take care of the Garbage Collection. I.e. Removing unrefereed objects from the memory. | Java has a provision to remove unreferred objects from the memory. i.e. Garbage Collection |
| Multiple Inheritance | C++ supports multiple inheritance. | Java does not support multiple inheritance. |
| Internal access to Memory | C++ has the concept of ‘Pointers’ to access the internal memory. | Java does not have Pointers. |
| Object Oriented | C++ is less object-oriented as we can write structural programs without using objects. | Java is more purer Object Oriented Language as compared to C++ (except for primitive variables). |
We will find duplicate elements from an input array as follows:
In this method, we are iterating over an input array to compare each element with the remaining input array.
private static void printDuplicatesByIterating(int[] arr) {
System.out.println("\nFinding duplicate elements using the iterative method.");
Set<Integer> duplicateElements = new HashSet<>();
for (int i=0; i<arr.length; i++) {
for (int j=i+1; j<arr.length; j++) {
if (arr[i] == arr[j]){
duplicateElements.add(arr[i]);
}
}
}
System.out.println("Duplicate elements in array are :" + duplicateElements);
}
In this method, we are sorting the first using the Arrays.sort() method. Then, we iterate over an array to check if the next adjacent element is a duplicate or not.
private static void printDuplicatesBySorting(int[] arr) {
System.out.println("\nFinding duplicate elements using the sorting method.");
Set<Integer> duplicateElements = new HashSet<>();
Arrays.sort(arr);
for (int i=0; i<arr.length-1; i++) {
if (arr[i] == arr[i+1]){
duplicateElements.add(arr[i]);
}
}
System.out.println("Duplicate elements in array are :" + duplicateElements);
}
In this method, we are adding the elements of the input array one by one into HashSet using the set.add() method.
The Set always contains unique elements. The set.add() method returns true if the element is successfully added to the set, and false if the element already exists.
private static void printDuplicatesByHashSet(int[] arr) {
System.out.println("\nFinding duplicate elements using the HashSet method.");
Set<Integer> duplicateElements = new HashSet<>();
Set<Integer> hashSet = new HashSet<>();
for (int i : arr) {
if (!hashSet.add(i)) {
duplicateElements.add(i);
}
}
System.out.println("Duplicate elements in array are :" + duplicateElements);
}
In this method, we are using the Java 8 Streams method to find the duplicate elements from the input array.
We have created a stream of an array. The filter() method accepts an expression and returns a boolean result.
As we know, the Set always contains unique elements. The set.add() method returns true if the element is successfully added to the set, and false if the element already exists.
We are filtering out the duplicate elements using the above logic and collecting them in another set.
private static void printDuplicatesByJava8Streams(int[] arr) {
System.out.println("\nFinding duplicate elements using the Java 8 Streams method.");
Set<Integer> hashSet = new HashSet<>();
Set<Integer> duplicateElements = Arrays.stream(arr).filter(i -> !hashSet.add(i)).boxed().collect(Collectors.toSet());
System.out.println("Duplicate elements in array are :" + duplicateElements);
}
Java Program
import java.util.*;
import java.util.stream.Collectors;
/**
* Java Program to find duplicate elements in an Array
* By coderolls.com
*/
public class DuplicatesInArray {
public static void main(String[] args) {
int[] arr = {1, 5, 6, 9, 2, 6, 9, 6, 3, 2, 1};
System.out.print("The input array is as given: ");
System.out.println(Arrays.toString(arr));
printDuplicatesByIterating(arr);
printDuplicatesBySorting(arr);
printDuplicatesByHashSet(arr);
printDuplicatesByJava8Streams(arr);
}
private static void printDuplicatesByIterating(int[] arr) {
System.out.println("\nFinding duplicate elements using the iterative method.");
Set<Integer> duplicateElements = new HashSet<>();
for (int i=0; i<arr.length; i++) {
for (int j=i+1; j<arr.length; j++) {
if (arr[i] == arr[j]){
duplicateElements.add(arr[i]);
}
}
}
System.out.println("Duplicate elements in array are :" + duplicateElements);
}
private static void printDuplicatesBySorting(int[] arr) {
System.out.println("\nFinding duplicate elements using the sorting method.");
Set<Integer> duplicateElements = new HashSet<>();
Arrays.sort(arr);
for (int i=0; i<arr.length-1; i++) {
if (arr[i] == arr[i+1]){
duplicateElements.add(arr[i]);
}
}
System.out.println("Duplicate elements in array are :" + duplicateElements);
}
private static void printDuplicatesByHashSet(int[] arr) {
System.out.println("\nFinding duplicate elements using the HashSet method.");
Set<Integer> duplicateElements = new HashSet<>();
Set<Integer> hashSet = new HashSet<>();
for (int i : arr) {
if (!hashSet.add(i)) {
duplicateElements.add(i);
}
}
System.out.println("Duplicate elements in array are :" + duplicateElements);
}
private static void printDuplicatesByJava8Streams(int[] arr) {
System.out.println("\nFinding duplicate elements using the Java 8 Streams method.");
Set<Integer> hashSet = new HashSet<>();
Set<Integer> duplicateElements = Arrays.stream(arr).filter(i -> !hashSet.add(i)).boxed().collect(Collectors.toSet());
System.out.println("Duplicate elements in array are :" + duplicateElements);
}
}
Output
The input array is as given: [1, 5, 6, 9, 2, 6, 9, 6, 3, 2, 1]
Finding duplicate elements using the iterative method.
Duplicate elements in array are :[1, 2, 6, 9]
Finding duplicate elements using the sorting method.
Duplicate elements in array are :[1, 2, 6, 9]
Finding duplicate elements using the HashSet method.
Duplicate elements in array are :[1, 2, 6, 9]
Finding duplicate elements using the Java 8 Streams method.
Duplicate elements in array are :[1, 2, 6, 9]