How to find hamming weight in java

May 08, 2024

How to find Hamming Weight in Java

Hamming weight of a number is the count of bits that are set to 1. For instance:
  • 1001 → Hamming weight = 2
  • 100001111 → Hamming weight = 5
In this article we will see how to calculate Hamming weight efficiently.

Using Simple Division and Remainder

Here we divide the number by 2 repeatedly until it becomes 0. At each step, we check if the remainder is 1 (i.e., the least significant bit is set). 
public static int hammingWeight(int n) {
    int count = 0;
    while (n != 0) {
        if (n % 2 == 1) {
            count++;
        }
        n = n / 2;
    }
    return count;
}

Using Bit Masking

In this example, we use bit masking. Since an int in Java has 32 bits, we shift a mask bit and check each position with a bitwise AND. 
public static int hammingWeightII(int n) {
    int count = 0;
    int mask = 1;

    for (int i = 0; i < 32; i++) {
        if ((n & mask) != 0) {
            count++;
        }
        mask = mask << 1; // shift the mask
    }
    return count;
}

Full Example

package ic.binary;

public class NumberOf1s {

  public static void main(String[] args) {
    int n = 5;
    System.out.println("Number of 1 bits for " + n + " -> " + hammingWeight(n));
    System.out.println("Number of 1 bits for " + n + " -> " + hammingWeightII(n));

    n = 8;
    System.out.println("Number of 1 bits for " + n + " -> " + hammingWeight(n));
    System.out.println("Number of 1 bits for " + n + " -> " + hammingWeightII(n));
  }

  public static int hammingWeight(int n) {
    int count = 0;
    while (n != 0) {
      if (n % 2 == 1) {
        count++;
      }
      n = n / 2;
    }
    return count;
  }

  public static int hammingWeightII(int n) {
    int count = 0;
    int mask = 1;
    for (int i = 0; i < 32; i++) {
      if ((n & mask) != 0) {
        count++;
      }
      mask <<= 1;
    }
    return count;
  }
}
Output of above program
Number of 1 bits for 5 -> 2
Number of 1 bits for 5 -> 2
Number of 1 bits for 8 -> 1
Number of 1 bits for 8 -> 1
Read More

Java OptionalInt Example

May 07, 2024
Java OptionalInt Example | Avoid NullPointerException

Java OptionalInt example

OptionalInt allows us to create an object which may or may not contain an int value. If a value is present, isPresent() will return true and getAsInt() will return the value.

Additional methods that depend on the presence or absence of a contained value are provided, such as orElse().

Other classes similar to OptionalInt are OptionalDouble, OptionalLong, and Optional. These help us eliminate exceptions that occur due to the absence of a value at runtime. The key is to first check if the Optional contains a value before trying to retrieve it.

OptionalIntExample

In this example, we return an OptionalInt from a Stream created from an integer array and finally return a value using the reduce() method. If the value is present, then only we print it using getAsInt(). 

package javaexp.blogspot.stream;

import java.util.Arrays;
import java.util.OptionalInt;

public class OptionalIntExample {

  public static void main(String[] args) {
    int iarray[] = {9, 10, 11, 12, 15, 15, 25};
    
    OptionalInt result = Arrays.stream(iarray)
                               .reduce((left, right) -> left);
    
    if (result.isPresent()) {
      System.out.println("First element of Array: " + result.getAsInt());
    }
  }

}

Summary

OptionalInt and other respective Optional classes help protect against NullPointerException when trying to retrieve values from potentially null objects. They provide a safer way to work with values that may or may not be present.

Read More

Bucket sort implementation in Java

May 05, 2024

Bucket Sort in Java

In this article we will go through a simple implementation of Bucket Sort in Java.

What is Bucket Sort

Bucket Sort is a sorting algorithm that divides the input into several buckets. Once the buckets are populated with input data, they are sorted individually using another sorting mechanism. After sorting, the buckets are concatenated together to produce the final result.
Following is the pseudocode for Bucket Sort: 
function bucketSort(array, k) is 
  buckets ← new array of k empty lists
  Max ← the maximum key value in the array
  Min ← the minimum key value in the array 
  Divisor ← (Max - Min) / (k - 1)

  for i = 0 to length(array) do
    insert array[i] into buckets[floor((array[i] - Min) / Divisor)]

  for i = 0 to k do
    Sort(buckets[i]) 

  return concatenation of buckets[0] ... buckets[k]
Bucket Sort implementation in Java: 
import java.util.*;

public class BucketSortExample {

  public static void main(String[] args) {
    int[] arr = {8, 4, 2, 10, 3, 1, 9, 6, 5, 7};
    int numBuckets = 5;
    bucketSort(arr, numBuckets);

    System.out.println("Sorted array:");
    for (int value : arr) {
      System.out.print(value + " ");
    }
  }

  public static void bucketSort(int[] arr, int numBuckets) {
    if (numBuckets <= 0) return;

    // create empty buckets
    ArrayList> buckets = new ArrayList<>(numBuckets);
    for (int i = 0; i < numBuckets; i++) {
      buckets.add(new ArrayList<>());
    }

    distributeToBuckets(arr, numBuckets, buckets);

    // sort each bucket
    for (ArrayList bucket : buckets) {
      Collections.sort(bucket);
    }

    // concatenate
    int index = 0;
    for (ArrayList bucket : buckets) {
      for (int item : bucket) {
        arr[index++] = item;
      }
    }
  }

  private static void distributeToBuckets(int[] arr, int numBuckets,
      ArrayList> buckets) {

    int min = Arrays.stream(arr).min().getAsInt();
    int max = Arrays.stream(arr).max().getAsInt();
    float diff = max - min;
    float divisor = diff / (numBuckets - 1);

    for (int value : arr) {
      int index = (int) ((value - min) / divisor);
      if (index >= numBuckets) index = numBuckets - 1; // safeguard
      buckets.get(index).add(value);
    }
  }
}

Complexity

The best case for Bucket Sort happens when the data is distributed evenly across buckets. This uniform distribution minimizes the sorting inside buckets, leading to overall time complexity:

Best Case: O(n + k)
Average Case: O(n + k)
Worst Case: O(n²)
Space Complexity: O(n + k)

Summary

Bucket Sort is a distribution-based sorting method where input elements are distributed into buckets, and each bucket is sorted using another algorithm. The sorted buckets are then concatenated to form the final sorted output.
Read More

IntSummaryStatistics Example in Java

April 27, 2024

IntSummaryStatistics

IntSummaryStatistics provides different statistical data like max, min, average. This class is desinged to work with Java streams but can work with with out streams also.

Example

Following class shows an example of IntSummaryStatistics used with stream. It is used to print interesting information like max, min, average, sum and count. And then the accept method is used to add a new integer to the previous data passed as the numStream.
public class IntSummaryStatisticsExample {

  public static void main(String[] args) {
   
    Stream<Integer> numStream = Stream.of(1, 2, 3, 4, 5);
    IntSummaryStatistics summary = numStream.mapToInt(p-> p).summaryStatistics();
    
    System.out.println("Max From the Data is " + summary.getMax());
    System.out.println("Min From the Data is " + summary.getMin());
    System.out.println("Average From the Data is " + summary.getAverage());
    System.out.println("Sum From the Data is " + summary.getSum());
    System.out.println("Count From the Data is " + summary.getCount());
    
    //Add a new number to the stream
    System.out.println("\n");
    summary.accept(10);
    
    System.out.println("Max From the Data is " + summary.getMax());
    System.out.println("Min From the Data is " + summary.getMin());
    System.out.println("Average From the Data is " + summary.getAverage());
    System.out.println("Sum From the Data is " + summary.getSum());
    System.out.println("Count From the Data is " + summary.getCount());
   
  }
}
IntSummaryStatistics Example Max From the Data is 5 Min From the Data is 1 Average From the Data is 3.0 Sum From the Data is 15 Count From the Data is 5 Adding number 10 to the data Max From the Data is 10 Min From the Data is 1 Average From the Data is 4.166666666666667 Sum From the Data is 25 Count From the Data is 6 
IntSummaryStatistics Example
Max From the Data is 5
Min From the Data is 1
Average From the Data is 3.0
Sum From the Data is 15
Count From the Data is 5

Adding number 10 to the data
Max From the Data is 10
Min From the Data is 1
Average From the Data is 4.166666666666667
Sum From the Data is 25
Count From the Data is 6

Conclusion

IntSummaryStatistics defined in java.util package and available since java 8 provides a way to calculate statistical information. It works with and with out stream.
Read More

How to convert Java Stream to List

April 27, 2024

How to convert Java Stream to List

Convert Java Stream to List
Following code show how to convert the stream intStream to list using collect.
 // Converting Streams to Collection
 Stream<Integer> intStream = Stream.of(1, 2, 3, 4, 5);
 List<Integer> list = intStream.collect(Collectors.toList());
 System.out.println(list); // prints [1, 2, 3, 4, 5]
Read More

Arduino Humadity

January 31, 2024 

#include 

#include 

dht DHT;

#define DHT11_PIN 7

void setup(){
  Serial.begin(9600);
}

void loop(){
  int chk = DHT.read11(DHT11_PIN);
  Serial.print("Temperature = ");
  Serial.println(DHT.temperature);
  Serial.print("Humidity = ");
  Serial.println(DHT.humidity);
  delay(1000);
}
Read More

Ardino Gas Sensors

January 31, 2024

 


//#include 

#define MQ2pin (0)
//https://robu.in/mq2-sensor-interfacing-with-arduino-gas-and-smoke-detection/
float sensorValue;  //variable to store sensor value

void setup()
{
  Serial.begin(9600); // sets the serial port to 9600
  Serial.println("Gas sensor warming up!");
  Serial.println("I can detect 300 - 10000ppm");

  delay(20000); // allow the MQ-2 to warm up
}

void loop()
{
  sensorValue = analogRead(MQ2pin); // read analog input pin 0
  
  Serial.print("Sensor Value: ");
  Serial.print(sensorValue);
  
  Serial.println("");
  delay(2000); // wait 2s for next reading
}
Read More

How to see the content of .war file

November 30, 2023

Extract content of .war file

A WAR file (Web Application Resource or Web application Archive) is a file used to distribute a collection of files and folders associated with web application. Sometimes we want to look inside the war file to know what files or folders are inside the war file. Jar -xvf jar with option -xvf will extract the content of the war file. Following command will extract the content of blogapp.war file into the current directory

jar -xvf blogapp.war

To extract the content of war file type the above command. For instance for a war file blogapp.war we can use the command jar -xvf.
A generic square placeholder image with rounded corners in a figure.
Content of the blogapp.war file

Conclusion

jar -xvf can be used to extract the content of jar file. This command will work in any platform with installed java.
Read More

ComputeIfPresent Example in Java

March 09, 2023

HashMap computeIfPresent() method in Java with Examples

The computeIfPresent(Key, BiFunction) method of HashMap class is used to update value in a key-value pair in the map. If key does not exist then it does not do any thing.

Syntax

undefined
V computeIfPresent(K key,
            BiFunction<? super K, ? super V, ? extends V> remappingFunction)

Example

Following is an example of computeIfAbsent invocation and its results.
ComputeIfAbsentExample
package corejava.map;

import java.util.HashMap;
import java.util.Map;

public class ComputeIfPresentExample {

	public static void main (String argv[]) {
		
		Map<String, Integer> map = new HashMap<String, Integer>();

		map.put("Sunglass", 105);
		map.put("Watch", 1501);
		
		
		newline("Original Map");
		map.forEach((a, b) -> {
			System.out.println(a + " -> " + b);
		});
		
		
		map.computeIfPresent("Watch", (k,v) -> {return v + v;});
		
		newline("After calling computeIfAbsent Map");
		map.forEach((a, b) -> {
			System.out.println(a + " -> " + b);
		});
	}
	
	static void newline(String s) {
		System.out.println("\n" + s);
	};
}
Output of above program.
Original Map
Watch -> 1501
Sunglass -> 105

After calling computeIfAbsent Map
Watch -> 3002
Sunglass -> 105

Summary

computeIfPresent helps in writing more compact code and also make code more readable.
Read More

computeifabsent Example in Java map

March 09, 2023

HashMap computeIfAbsent() method in Java with Examples

The computeIfAbsent(Key, Function) method of HashMap class is used to enter a new key-value pair to map if the key does not exist. If key exists then it does not do any thing.

Syntax

undefined
public V computeIfAbsent(K key, Function<? super K, ? extends V> remappingFunction)

Example

Following is an example of computeIfAbsent invocation and its results.
ComputeIfAbsentExample
package corejava.map;

import java.util.HashMap;
import java.util.Map;

public class ComputeIfAbsentExample {

	public static void main (String argv[]) {
		
		Map<Integer, String> map = new HashMap<Integer, String>();

		map.put(1, "one");
		map.put(2, "two");
		map.put(3, "three");
		map.put(4, "four");
		map.put(5, "five");
		
		newline("Original Map");
		map.forEach((a, b) -> {
			System.out.println(a + " -> " + b);
		});
		
		map.computeIfAbsent(6, k-> { return "six";});
		map.computeIfAbsent(7, k -> "seven");
		
		newline("After calling computeIfAbsent Map");
		map.forEach((a, b) -> {
			System.out.println(a + " -> " + b);
		});
	}
	
	static void newline(String s) {
		System.out.println("\n" + s);
	};
}
Output of above program.
Original Map
1 -> one
2 -> two
3 -> three
4 -> four
5 -> five

After calling computeIfAbsent Map
1 -> one
2 -> two
3 -> three
4 -> four
5 -> five
6 -> six
7 -> seven

Summary

computeIfAbsent helps in writing more compact code and also make code more readable.
Read More

How to remove entries from java map based on values

March 05, 2023

Remove all entries in map by value

Java Map is a data structure that holds key->value pairs. In this article we will see how to delete all entries in the map by map values.

Using removeAll

removeAll() takes one argument a collection. And entries matching the passed collection will be removed from the original map
Using removeAll
Map<Integer, String> map = new HashMap<Integer, String>();
map.put(1, "one");
map.put(2, "two");
map.put(3, "three");
map.put(4, "four");
map.put(5, "five");
map.put(6, "five");

newline("Original Map");
map.values().removeAll(Collections.singleton("five"));

newline("After removing values = five");
map.forEach( (a,b) -> {
	System.out.println(a + " -> " + b);
});
Output of above program.
Original Map
1 -> one
2 -> two
3 -> three
4 -> four
5 -> five
6 -> five
7 -> five

After removing values = five
1 -> one
2 -> two
3 -> three
4 -> four

Using removeIf

removeIf
Map<Integer, String> map = new HashMap<Integer, String>();
map.put(1, "one");
map.put(2, "two");
map.put(3, "three");
map.put(4, "four");
map.put(5, "five");
map.put(6, "five");

newline("Original Map");

//remove entries where value = five
map.values().removeIf("five"::equals);

newline("After removing values = five");
map.forEach( (a,b) -> {
	System.out.println(a + " -> " + b);
});
Output of above program.
Original Map
1 -> one
2 -> two
3 -> three
4 -> four
5 -> five
6 -> five
7 -> five

After removing values = five
1 -> one
2 -> two
3 -> three
4 -> four
Read More

How to delete all entries in java map.

March 05, 2023

Remove all entries from java map

Java Map is a data structure that holds key->value pairs. In this article we will see how to delete all entries in the map in java easily and efficetively.

Method clear()

clear() method is method that does not return any thing (void return type) and is part of the Map interface. Each implementation subclasses provides an implementation. clear () methods deleted all entries and turn them map into empty map.
Clear method
static void clearALLItemsInMap() {
		Map<Integer, String> map = new HashMap<Integer, String>();
		map.put(1, "one");
		map.put(2, "two");
		map.put(3, "three");
		map.put(4, "four");
		map.put(5, "five");
		map.put(6, "five");
		
		newline("Original Map");
		map.forEach( (a,b) -> {
			System.out.println( a + " -> " + b);
		});
		
                 //clear the map
		map.clear();
		
		newline("After classing clear() Map");
		map.forEach( (a,b) -> {
			System.out.println(a + " -> " + b);
		});
	}
Output of above program.
Original Map
1 -> one
2 -> two
3 -> three
4 -> four
5 -> five
6 -> five

After classing clear() Map
empty

Summary

For removing all the entries from java map, clear() method is the best option. Also please note that the clear() method is implemented in each of its implementation classes like, HashMap, TreeMap, LinkedHashMap etc.
Read More

When to User BigInteger in Java

February 19, 2023

When to use Java BigInteger

Java BigInteger class is used to perform arithmetic operation or holding Numbers large enough that Integer cannot hold. In fact BigInteger does not have any limit on the numerical value that it can represent.

java.math.BigInteger

Integer Max and Min value

In Java Integer can hold between 2147483647 and -2147483648. This is denoted by Integer.MAX_VALUE and Integer.MIN_VALUE

Print Value of Integer Max and Min

Print max and min value
System.out.println(Integer.MAX_VALUE); //2147483647
System.out.println(Integer.MIN_VALUE);  //-2147483648
When we have numbers that cannot fit in the Integer range we can use BigInteger class. Also this Class provides a lot of methods to carry out different mathematical operations such as add, subtract, divide, multiply and many more
BigInteger Example
BigInteger a = BigInteger.valueOf(15);
BigInteger b = BigInteger.ONE;

BigInteger result = a.add(b);
System.out.println("Addition of a,b = " + result);

result = a.subtract(b);
System.out.println("Subtration of a,b = " + result);

result = a.divide(b);
System.out.println("Division of a,b = " + result);

result = a.multiply(b);
System.out.println("Multipllication of a,b = " + result);
Read More

How to delete .DS_STORE files in current folder and all subfolders

February 13, 2023

Delete .DS_STORE files in all subfolders

.DS_STORE file is automatically created in Apple Mac. If we have a git repository it is generally recommended that we remove all .DS_STORE files in the repository folder.
We can delete recursively using find command like bellow.
Delete .DS_Store
find . -name ".DS_Store" -delete
Read More

How to generate Radom Integer in Java between two numbers.

February 12, 2023

Generate random number

Following java code will generate a random number between a given range. For instance if we want to generate a random number between 80, 100 we can use the following codes. In java to generate random number we have two options, using class Math or Random. We will see both examples

Using Class java.lang.Math

Math.random() generates a fraction(double) number between 0.0 and 1.0. We then add the lower bound to the product of (upperbound-lowerbound)*random_between0_1.
GenerateRandom1
private static int generateRandomInteger(int rangeStart, int rangeEnd) {
		// generate double between 0.0 and 1.0
		double r = Math.random();
		Integer result = (int) (rangeStart + r * (rangeEnd - rangeStart));
		return result;
	}

Using Class java.util.Random

GenerateRandom2
private static int generateRandomIntegerII(int rangeStart, int rangeEnd) {
		// generate double between 0.0 and 1.0
		Random random = new Random();
		double r = random.nextDouble();
		Integer result = (int) (rangeStart + r * (rangeEnd - rangeStart));
		return result;
}

Full Example

GenerateRandomNumber
import java.util.Random;
public class GenerateRandomNumber {

	public static void main(String[] args) {

		System.out.println(GenerateRandomNumber.generateRandomInteger(35, 40));
		System.out.println(GenerateRandomNumber.generateRandomIntegerII(35, 40));

	}

	private static int generateRandomInteger(int rangeStart, int rangeEnd) {
		// generate double between 0.0 and 1.0
		double r = Math.random();
		Integer result = (int) (rangeStart + r * (rangeEnd - rangeStart));
		return result;
	}

	private static int generateRandomIntegerII(int rangeStart, int rangeEnd) {
		// generate double between 0.0 and 1.0
		Random random = new Random();
		double r = random.nextDouble();
		Integer result = (int) (rangeStart + r * (rangeEnd - rangeStart));
		return result;
	}

}
Read More