const map = new Map()

console.log(map.size) // 0

map.set('name', 'Atta')
map.set('age', 34)

console.log(map.size) // 2

The size property provides an integer value representing the number of entries in the Map object.

Unlike the length property of an array, which can be found here, the size property of a map is read-only and cannot be modified:

const map = new Map([
  ['name', 'Atta'],
  ['age', 34]
])

console.log(map.size) // 2

map.size = 6

console.log(map.size) // 2 --> Remains the same

In contrast, the length property of an array is writable and can be assigned a new value to increase or decrease the size of the array:

const numbers = [1, 2, 3, 4]

// Truncate to a 3-element array
numbers.length = 3

console.log(numbers)
// [1, 2, 3]

// Increase the size to 5
numbers.length = 5

console.log(numbers);
// [1, 2, 3, <2 empty items>]

To learn more about the Map object and how to create collections of key-value pairs in JavaScript, you can refer to this article.

const map = new Map([
  ['name', 'Alex Hales'],
  ['age', 27],
  ['country', 'United States']
])

console.log(map)
// Map(3) {
//   'name' => 'Alex Hales',
//   'age' => 27,
//   'country' => 'United States'
// }

console.log(map.delete('name')) // true
console.log(map.delete('name')) // false (already removed)
console.log(map.delete('job')) // false (not found)

To delete all elements in a Map object, the clear() method can be used:

const map = new Map([
  ['name', 'Alex Hales'],
  ['age', 27],
  ['country', 'United States']
])

map.clear()

console.log(map.size) // 0
console.log(map) // Map(0) {}

To gain a deeper understanding of the Map object and how to create collections of key-value pairs in JavaScript, refer to this article.

1. Using the entries() method and next():

const map = new Map([
  ['name', 'Alex Hales'],
  ['age', 27],
  ['country', 'United States']
])

const first = map.entries().next().value

console.log(first)
// ['name', 'Alex Hales']

The entries() method returns an iterator object with key-value pairs. By calling next() once, you can retrieve the first element from the iterator.

2. Converting to an array and accessing the first element:

const map = new Map([
  ['name', 'Alex Hales'],
  ['age', 27],
  ['country', 'United States']
])

const first = Array.from(map)[0] // or [...map][0]

console.log(first)
// ['name', 'Alex Hales']

By using Array.from(map) or the spread operator (...map), you can convert the Map object into an array. Then, accessing the element at index 0 will give you the first key-value pair.

3. Using array destructuring with keys() or values():

const map = new Map([
  ['name', 'Alex Hales'],
  ['age', 27],
  ['country', 'United States']
])

const [firstKey] = map.keys()
console.log(firstKey); // 'name'

const [firstVal] = map.values()
console.log(firstVal); // 'Alex Hales'

You can utilize array destructuring to extract the first key or value by calling keys() or values() on the Map object.

To learn more about the Map object and working with key-value pairs in JavaScript, you can refer to this article.

const map = new Map()

map.set('name', 'John Doe')
map.set('age', 29)
map.set('job', 'UX Designer')

console.log(map.get('name')) // John Doe
console.log(map.get('age')) // 29
console.log(map.get('job')) // UX Designer

console.log(map.get('address')) // undefined

If the value associated with the specified key is an object, the get() method returns a reference to that object. Any modifications made to the object will be reflected inside the Map object as well:

const product = { name: 'Milk', qty: 2 }
const prices = [2.99]

const items = new Map()
items.set('product', product)
items.set('prices', prices)

items.get('product').qty = 100
items.get('prices').push(4.55)

console.log(product)
// { name: 'Milk', qty: 100 }

console.log(prices)
// [ 2.99, 4.55 ]

To delve deeper into the Map object and discover more about creating collections of key-value pairs in JavaScript, you can refer to this article.

const map = new Map([
  ['name', 'Alex'],
  ['scores', [75, 87]],
  ['bio', { age: 27, country: 'Pakistan' }]
])

console.log(map)
// Map(3) {
//   'name' => 'Alex',
//   'scores' => [75, 87],
//   'bio' => { age: 27, country: 'Pakistan' }
// }

// Update name (STRING)
map.set('name', 'Alex Hales')
console.log(map.get('name')) // Alex Hales

// Update scores (ARRAY)
map.set('scores', [...map.get('scores'), 99])
console.log(map.get('scores')) // [75, 87, 99]

// Update bio (OBJECT)
map.set('bio', { ...map.get('bio'), job: 'Engineer' })

console.log(map.get('bio'))
// { age: 27, country: 'Pakistan', job: 'Engineer' }

In the above example, the name, scores, and bio elements are updated with new values using the set() method. The name is updated with a string value, scores with an array value by spreading the existing scores and adding a new score of 99, and bio with an object value by spreading the existing bio object and adding a job property.

You can also use the set() method to add new elements to a Map object:

const map = new Map([
  ['name', 'Alex'],
  ['scores', [75, 87]],
  ['bio', { age: 27, country: 'Pakistan' }]
])

map.set('email', 'alex@example.com')

console.log(map)
// Map(4) {
//   'name' => 'Alex',
//   'scores' => [75, 87],
//   'bio' => { age: 27, country: 'Pakistan' },
//   'email' => 'alex@example.com'
// }

In this case, the email element is added to the Map object with its corresponding value.

To learn more about the Map object and how to utilize it to create collections of key-value pairs in JavaScript, you can refer to this article.

const map = new Map()

map.set('name', 'John Doe')
map.set('age', 27)
map.set('country', 'Pakistan')

console.log(map)

// Map(3) {
//   'name' => 'John Doe',
//   'age' => 27,
//   'country' => 'Pakistan'
// }

Since the set() method returns the same Map object, you can chain multiple set() calls together to add multiple elements:

const map = new Map()

map.set('name', 'John Doe').set('age', 27).set('country', 'Pakistan')

console.log(map)

// Map(3) {
//   'name' => 'John Doe',
//   'age' => 27,
//   'country' => 'Pakistan'
// }

It's important to note that Map keys are unique. If you call the set() method multiple times with the same key, it will update the value associated with that key:

const map = new Map()

map.set('name', 'John')
map.set('name', 'John Doe')

console.log(map)

// Map(1) {
//   'name' => 'John Doe'
// }

In the above example, the value for the key 'name' is initially set to 'John', but it is then updated to 'John Doe' in the second set() call.

The Map object allows you to store various types of objects as keys or values, including object literals, arrays, and functions:

const menu = {
  sandwich: '🥪',
  cookie: '🍪',
  popcorn: '🍿'
}

const pizza = () => '🍕'

const foods = new Map()

foods.set(menu, 5.9)
foods.set(pizza, 'What is Pizza?')

console.log(foods.get(menu)) // 5.9
console.log(foods.get(pizza)) // What is Pizza?

In the above example, an object literal (menu) and a function (pizza) are used as keys in the Map object, and their corresponding values are retrieved using the get() method.

To learn more about the Map object and how to use it to create collections of key-value pairs in JavaScript, you can refer to this article.

Here's an example of how you can convert a Map to an object using Object.fromEntries():

const map = new Map([
  ['name', 'John Doe'],
  ['age', 20],
  ['job', 'Doctor']
])

const user = Object.fromEntries(map)
console.log(user)
// { name: 'John Doe', age: 20, job: 'Doctor' }

In this example, the Object.fromEntries() method is called with the map object as the argument, which contains key-value pairs. The method converts the map object to an object literal with the same key-value pairs.

The Object.fromEntries() takes an iterable, such as a Map, and returns an object containing the key-value pairs of the iterable:

const kvPairs = [
  ['name', 'John Doe'],
  ['age', 20],
  ['job', 'Doctor']
]

const user = Object.fromEntries(kvPairs)

console.log(user)
// { name: 'John Doe', age: 20, job: 'Doctor' }

In this case, the kvPairs array directly represents the key-value pairs, and Object.fromEntries() converts them into an object.

An alternate approach is to use the Map.forEach() method to iterate over the entries of the Map object and create a new key on the object for each of them:

const map = new Map([
  ['name', 'John Doe'],
  ['age', 20],
  ['job', 'Doctor']
])

const user = {}

map.forEach((value, key) => {
  user[key] = value
})

console.log(user)
// { name: 'John Doe', age: 20, job: 'Doctor' }

If you want to convert the object back to a Map object, you can use the Object.entries() method to get an array of key-value pairs from the object, and then create a new Map using the Map constructor:

const user = {
  name: 'John Doe',
  age: 20,
  job: 'Doctor'
}

const map = new Map(Object.entries(user))
console.log(map)

// Map(3) { 'name' => 'John Doe', 'age' => 20, 'job' => 'Doctor' }

In this example, Object.entries(user) returns an array of key-value pairs, which is then used to create a new Map object.

To learn more about the Map object and how to create collections of key-value pairs in JavaScript, you can refer to this article.

Here's an example of how you can convert an object to a Map using Object.entries():

const user = {
  name: 'John Doe',
  age: 20,
  job: 'Engineer'
}

const kvPairs = Object.entries(user)

const map = new Map(kvPairs)
console.log(map)

// Map(3) { 'name' => 'John Doe', 'age' => 20, 'job' => 'Engineer' }

In this example, Object.entries(user) returns an array of key-value pairs from the user object, which is then used to create a new Map object using the Map constructor.

Alternatively, you can use the Array.forEach() method to iterate over the object keys and add each key-value pair to the Map using the Map.set() method:

const user = {
  name: 'John Doe',
  age: 20,
  job: 'Engineer'
}

const map = new Map()

Object.keys(user).forEach(key => {
  map.set(key, user[key])
})

console.log(map)
// Map(3) { 'name' => 'John Doe', 'age' => 20, 'job' => 'Engineer' }

In this example, Object.keys(user) returns an array of keys from the user object. We then iterate over these keys using forEach() and use the Map.set() method to add each key-value pair to the map object.

If you want to convert the Map object back to an object, you can use the Object.fromEntries() method:

const map = new Map([
  ['name', 'John Doe'],
  ['age', 20],
  ['job', 'Engineer']
])

const user = Object.fromEntries(map)

console.log(user)
// { name: 'John Doe', age: 20, job: 'Engineer' }

The Object.fromEntries() method takes an iterable of key-value pairs, such as an array, and returns a new object with the key-value pairs.

To learn more about the Map object and how to create collections of key-value pairs in JavaScript, you can refer to this article.

const users = [
  { name: 'John Doe', role: 'Admin' },
  { name: 'Alex Hales', role: 'Manager' },
  { name: 'Ali Feroz', role: 'User' }
]

const kvPairs = users.map(u => [u.name, u.role])

const map = new Map(kvPairs)
console.log(map)

// Map(3) {
//     'John Doe' => 'Admin',
//     'Alex Hales' => 'Manager',
//     'Ali Feroz' => 'User'
// }

In the above code, a callback function is provided to the Array.map() method, which is executed for each object in the array. During each iteration, an array is returned containing the key and value for each object, resulting in an array of key-value pairs:

const users = [
  { name: 'John Doe', role: 'Admin' },
  { name: 'Alex Hales', role: 'Manager' },
  { name: 'Ali Feroz', role: 'User' }
]

const kvPairs = users.map(u => [u.name, u.role])
console.log(kvPairs)

// [
//     [ 'John Doe', 'Admin' ],
//     [ 'Alex Hales', 'Manager' ],
//     [ 'Ali Feroz', 'User' ]
// ]

Finally, the resulting array is passed to the Map() constructor to create a new instance of the Map object.

Alternatively, you can use the Array.forEach() method to convert the array of objects to a map. This approach involves three steps:

1. Create an empty map object using the Map() constructor.
2. Use the forEach() method on the array to iterate through all the objects.
3. During each iteration, utilize the Map.set() method to add the key-value pair to the map.

const users = [
  { name: 'John Doe', role: 'Admin' },
  { name: 'Alex Hales', role: 'Manager' },
  { name: 'Ali Feroz', role: 'User' }
]

const map = new Map()

users.forEach(u => {
  map.set(u.name, u.role)
})

console.log(map)
// Map(3) {
//     'John Doe' => 'Admin',
//     'Alex Hales' => 'Manager',
//     'Ali Feroz' => 'User'
// }

For further information on the Map object and its usage for creating collections of key-value pairs in JavaScript, you can refer to this article.

const map = new Map()

map.set('John Doe', 'Admin')
map.set('Alex Hales', 'Manager')
map.set('Ali Feroz', 'User')

console.log(map)

// Map(3) {
//     'John Doe' => 'Admin',
//     'Alex Hales' => 'Manager',
//     'Ali Feroz' => 'User'
// }

The Map constructor can also accept an iterable object, such as an array, to initialize a map object with values:

const users = [
  ['John Doe', 'Admin'],
  ['Alex Hales', 'Manager'],
  ['Ali Feroz', 'User']
]

const map = new Map(users)
console.log(map)

// Map(3) {
//     'John Doe' => 'Admin',
//     'Alex Hales' => 'Manager',
//     'Ali Feroz' => 'User'
// }

Additionally, you can convert a JavaScript object into a map object with values using the Object.entries() method:

const user = { name: 'John Doe', age: 20, job: 'Engineer' }

const map = new Map(Object.entries(user))
console.log(map)

// Map(3) { 'name' => 'John Doe', 'age' => 20, 'job' => 'Engineer' }

For further information on the Map object and how to create collections of key-value pairs in JavaScript, you can refer to this article.

const num = 3.50000
const res1 = parseFloat(num)
console.log(res1) // 3.5

// parse the string back to a number
const str = '6.870000'
const res2 = parseFloat(str)
console.log(res2) // 6.87

The parseFloat() method parses the given string and returns a floating point number without trailing zeros.

If you need to set a specific number of decimal places, use the toFixed() method. The toFixed() method returns a string representation of the number with the specified decimals.

const num = 2.347000
const res = parseFloat(num.toFixed(2))
console.log(res) // 2.35

As you can see above, the toFixed() method rounds the number if required and pads the fractional part with zeros if the specified decimal places are more than the number has.

1. Use the parseFloat() method to parse the string to a float point number.
2. Use the toFixed() method to format the floating point number to 2 decimal places.
3. The toFixed() method takes a number as input and returns a string representation of the number formatted to 2 decimal places.

const str1 = '2.567'
const res1 = parseFloat(str1).toFixed(2)
console.log(res1) // 2.57

const str2 = '5'
const res2 = parseFloat(str2).toFixed(2)
console.log(res2) // 5.00

const str3 = '4.5'
const res3 = parseFloat(str3).toFixed(2)
console.log(res3) // 4.50

We use the parseFloat() method to convert the string into a floating point number.

Next, we called the toFixed() method on the pointing point number, passing it 2 as the number of digits to appear after the decimal point. It rounds the number and pads the decimal places with zero if necessary.

Note that the toFixed() method returns a string representing the pointing point number. If you need a number, as a result, call the parseFloat() method again:

const str = '3.500'
const res = parseFloat(str).toFixed(2)
console.log(res) // 3.50
console.log(typeof res) // string

// Parse the string back to a number
const num = parseFloat(res)
console.log(num) // 3.5
console.log(typeof num) // number

const num1 = 12.865
const res1 = num1.toFixed(2)
console.log(res1) // 12.87

const num2 = 19
const res2 = num2.toFixed(2)
console.log(res2) // 19.00

In the above examples, we called the toFixed() method on the number, passing it 2 as a parameter to format the number to 2 decimal places.

The only parameter toFixed() takes is the number of digits to appear after the decimal point. The value must be between 0 and 100 inclusive. If this argument is skipped, it is treated as 0. If you pass a value greater than 100, a RangeError is thrown:

const num1 = 17.8654553
const res1 = num1.toFixed()
console.log(res1) // 18

const num2 = 55.3469
const res2 = num2.toFixed(120)
console.log(res2)
// RangeError: toFixed() digits argument must be between 0 and 100

Using toFixed() with negative numbers may produce unexpected results. You need to group the negative number expression to get a formatted string:

const res1 = -7.892.toFixed(2)
console.log(res1) // -7.89
console.log(typeof res1) // number --> ❌

const res2 = (-7.892).toFixed(2)
console.log(res2) // -7.89
console.log(typeof res2) // string -->  ✅

If the number is wrapped in a string, you need to convert the string to a number first before calling the toFixed() method:

const str = '22.567'
const res = parseFloat(str).toFixed(2)
console.log(res) // 22.57

1. Math.round() — Rounds a number to the nearest integer. If the fraction value is 0.5 or higher, round up.
2. Math.ceil() — Rounds up to the nearest integer.
3. Math.floor() — Rounds down to the nearest integer.

Math.round(5.287) // 5
Math.round(5.87)  // 6

// Rounds up
Math.ceil(5.33)   // 6

// Rounds down
Math.floor(5.87)  // 5

To round a number to 2 decimal places, you need to do a bit of calculation, as shown below:

const num = Math.round(5.87456 * 100) / 100

console.log(num) // 5.87

Alternatively, you can use the toFixed() method to round a number to 2 decimal places in JavaScript. The toFixed() method rounds and formats the number to 2 decimal places:

const num = 5.87456

const str = num.toFixed(2)
console.log(str) // 5.87

The toFixed() method takes the number of digits after the decimal point as input and returns a string representation of the number.

To convert the string back to a floating point number, you can use the parseFloat() method or the Number() constructor:

const num = 5.87456

const str = num.toFixed(2)
console.log(str) // 5.87
console.log(typeof str) // string

const final = parseFloat(str)
console.log(final) // 5.87
console.log(typeof final) // number

const final2 = Number(str)
console.log(final2) // 5.87
console.log(typeof final2) // number

// Create date instances
OffsetDateTime startOffsetDT = OffsetDateTime.parse("2022-02-23T10:40:30+03:30");
OffsetDateTime endOffsetDT = OffsetDateTime.parse("2022-11-12T10:40:33-05:00");

// Calculate the difference
long days = ChronoUnit.DAYS.between(startOffsetDT, endOffsetDT);

// Print days
System.out.println("Days between " + startOffsetDT + " and " + endOffsetDT + ": " + days);
// Days between 2022-02-23T10:40:30+03:30 and 2022-11-12T10:40:33-05:00: 262

The ChronoUnit enum class was introduced in Java 8 to represent individual date and time units such as day, month, year, week, hour, minutes, etc.

The between() method returns a negative difference in days if the start is after the end date, as shown below:

System.out.println(ChronoUnit.DAYS.between(endOffsetDT, startOffsetDT)); // -262

You can also use the ChronoUnit enum to calculate the difference between two OffsetDateTime objects in weeks, months, and years:

System.out.println(ChronoUnit.WEEKS.between(startOffsetDT, endOffsetDT)); // 37
System.out.println(ChronoUnit.MONTHS.between(startOffsetDT, endOffsetDT)); // 8
System.out.println(ChronoUnit.YEARS.between(startOffsetDT, endOffsetDT)); // 0

Read this article to learn more about calculating the difference between two dates in Java.

// Create date instances
ZonedDateTime startZonedDateTime = ZonedDateTime.parse("2022-03-23T10:40:30+01:00[Europe/Paris]");
ZonedDateTime endZonedDateTime = ZonedDateTime.parse("2022-11-12T10:40:33+05:00[Asia/Karachi]");

// Calculate the difference
long days = ChronoUnit.DAYS.between(startZonedDateTime, endZonedDateTime);

// Print days
System.out.println("Days between " + startZonedDateTime + " and " + endZonedDateTime + ": " + days);
// Days between 2022-03-23T10:40:30+01:00[Europe/Paris] 
// and 2022-11-12T10:40:33+05:00[Asia/Karachi]: 233

The ChronoUnit enum class was introduced in Java 8 to represent individual date and time units such as day, month, year, week, hour, minutes, etc.

The between() method returns a negative difference in days if the start is after the end date, as shown below:

System.out.println(ChronoUnit.DAYS.between(endZonedDateTime, startZonedDateTime)); // -233

You can also use the ChronoUnit enum to calculate the difference between two ZonedDateTime objects in weeks, months, and years:

System.out.println(ChronoUnit.WEEKS.between(startZonedDateTime, endZonedDateTime)); // 33
System.out.println(ChronoUnit.MONTHS.between(startZonedDateTime, endZonedDateTime)); // 7
System.out.println(ChronoUnit.YEARS.between(startZonedDateTime, endZonedDateTime)); // 0

Read this article to learn more about calculating the difference between two dates in Java.

// Create date instances
LocalDateTime startDateTime = LocalDateTime.parse("2022-02-12T10:40");
LocalDateTime endDateTime = LocalDateTime.parse("2022-11-12T10:40");

// Calculate the difference
long days = ChronoUnit.DAYS.between(startDateTime, endDateTime);

// Print days
System.out.println("Days between " + startDateTime + " and " + endDateTime + ": " + days);
// Days between 2022-02-12T10:40 and 2022-11-12T10:40: 273

The ChronoUnit enum class was introduced in Java 8 to represent individual date and time units such as day, month, year, week, hour, minutes, etc.

The between() method returns a negative number as a difference in days if the start is after the end date, as shown below:

System.out.println(ChronoUnit.DAYS.between(endDateTime, startDateTime)); // -273

You can also use the ChronoUnit enum to calculate the difference between two LocalDateTime objects in weeks, months, and years:

System.out.println(ChronoUnit.WEEKS.between(startDateTime, endDateTime)); // 39
System.out.println(ChronoUnit.MONTHS.between(startDateTime, endDateTime)); // 9
System.out.println(ChronoUnit.YEARS.between(startDateTime, endDateTime)); // 0

Read this article to learn more about calculating the difference between two dates in Java.

// Create date instances
LocalDate startDate = LocalDate.parse("2022-08-30");
LocalDate endDate = LocalDate.parse("2022-11-16");

// Calculate the difference
long days = ChronoUnit.DAYS.between(startDate, endDate);

// Print days
System.out.println("Days between " + startDate + " and " + endDate + ": " + days);
// Days between 2022-08-30 and 2022-11-16: 78

The ChronoUnit enum class was introduced in Java 8 to represent individual date and time units such as day, month, year, week, hour, minutes, etc.

The between() method returns the difference in days as a negative number if the start is after the end date, as shown below:

System.out.println(ChronoUnit.DAYS.between(endDate, startDate)); // -78

You can also use the ChronoUnit enum to calculate the difference between two LocalDate objects in weeks, months, and years:

System.out.println(ChronoUnit.WEEKS.between(startDate, endDate)); // 11
System.out.println(ChronoUnit.MONTHS.between(startDate, endDate)); // 2
System.out.println(ChronoUnit.YEARS.between(startDate, endDate)); // 0

Read this article to learn more about calculating the difference between two dates in Java.

Let us say we have the following enum representing the days of the week:

public enum Weekday {
    MONDAY(1, "Monday"),
    TUESDAY(2, "Tuesday"),
    WEDNESDAY(3, "Wednesday"),
    THURSDAY(4, "Thursday"),
    FRIDAY(5, "Friday"),
    SATURDAY(6, "Saturday"),
    SUNDAY(7, "Sunday");

    private final int number;
    private final String value;

    Weekday(int number, String value) {
        this.number = number;
        this.value = value;
    }
    
    public int getNumber() {
        return number;
    }

    public String getValue() {
        return value;
    }
}

Search an enum value by name

Since the enum type is a special data type in Java, the name of each enum is constant. For example, the name of Weekday.FRIDAY is FRIDAY.

To search the enum by its name, you can use the valueOf() method, as shown below:

String str = "FRIDAY";

Weekday day = Weekday.valueOf(str.toUpperCase());
System.out.println(day); // FRIDAY

The valueOf() method works as long as you pass a string that matches an enum name. If the given string does not match an enum name, an IllegalArgumentException is thrown:

// Fail due to case mismatch
Weekday monday = Weekday.valueOf("Monday");

// Fail due to invalid value
Weekday invalidStr = Weekday.valueOf("Weekend");

To handle exceptions gracefully, let us add a static function called findByName() to Weekday that searches the enum by name and returns null if not found:

public enum Weekday {
    // ...

    public static Weekday findByName(String name) {
        for (Weekday day : values()) {
            if (day.name().equalsIgnoreCase(name)) {
                return day;
            }
        }
        return null;
    }
}

The findByName() method uses the values() method to iterate over all enum values and returns an enum object if the given string matches an enum name. Otherwise, it returns null as shown below:

System.out.println(Weekday.findByName("Monday")); // MONDAY
System.out.println(Weekday.findByName("friday")); // FRIDAY
System.out.println(Weekday.findByName("Weekday")); // null

Search an enum by value

To search an enum by value, you can use the same valueOf() method you used above. This time, instead of using the name() method, use the getValue() method, as shown below:

public enum Weekday {
    // ...
    
    public static Weekday findByValue(String value) {
        for (Weekday day : values()) {
            if (day.getValue().equalsIgnoreCase(value)) {
                return day;
            }
        }
        return null;
    }
}

The findByValue() method works to findByName() and returns an enum object that matches the enum value. So for Tuesday, you will get Weekday.TUESDAY. If the given value is invalid, the findByValue() method returns null as shown below:

System.out.println(Weekday.findByValue("Tuesday")); // TUESDAY
System.out.println(Weekday.findByValue("friday")); // FRIDAY
System.out.println(Weekday.findByValue("Fri")); // null

Search an enum by an integer value

You can also write a function to search an enum by an integer value. For example, to search a Weekday by the number field, you can use the following code:

public enum Weekday {
    // ...
    
    public static Weekday findByNumber(int number) {
        for (Weekday day : values()) {
            if (day.getNumber() == number) {
                return day;
            }
        }
        return null;
    }
}

The findByNumber() method compares the given number with the day's number. If the number matches, it returns the matched object. Otherwise, it returns null as shown below:

System.out.println(Weekday.findByNumber(3)); // WEDNESDAY
System.out.println(Weekday.findByNumber(5)); // FRIDAY
System.out.println(Weekday.findByNumber(9)); // null

Search an enum using Java 8 Streams

You can also use Java 8 Streams to simplify the enum search. Let us rewrite the above findByNumber() method using streams:

public static Optional<Weekday> findByNumber(int number) {
    return Arrays.stream(values()).filter(weekday -> weekday.getNumber() == number)
            .findFirst();
}

The above example code looks different from the previous codes because we have used Java 8 streams to implement the search.

Also, instead of returning the enum itself, an Optional value of the Weekday is returned. For the null value, the findByNumber() method returns an empty Optional.

Here is an example that uses the above method to check if the enum exists:

Optional<Weekday> weekday = Weekday.findByNumber(6);
if (weekday.isPresent()) {
    System.out.println("The number matches " + weekday.get().name());
} else {
    System.out.println("Number does not match.");
}

// The number matches SATURDAY

Throwing an exception if the enum is not found

You can also throw an exception instead of returning null or empty Optional. Let us again rewrite the findByNumber() to throw an IllegalArgumentException if the enum is not found:

public static Weekday findByNumber(int number) {
    return Arrays.stream(values()).filter(weekday -> weekday.getNumber() == number)
            .findFirst().orElseThrow(IllegalArgumentException::new);
}

The following example uses the above findByNumber() method to search an enum by an integer value:

System.out.println(Weekday.findByNumber(5)); // FRIDAY
System.out.println(Weekday.findByNumber(8));
// Exception in thread "main" java.lang.IllegalArgumentException

In this article, you will learn about different ways to iterate over enum values in Java. Let us say we have the following enum class:

public enum Days {
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
}

Iterate over enum values using the for loop

You can use the values() method to retrieve an array containing all the enum values. Once you obtain the array, you can iterate over it using the for loop, as shown below:

for (Days day : Days.values()) {
    System.out.println(day);
}

// MONDAY
// TUESDAY
// WEDNESDAY
// THURSDAY
// FRIDAY
// SATURDAY
// SUNDAY

The values() method returns an array containing the constants of the enum type, in the order, they're declared.

Iterate over enum values using forEach()

The forEach() method was introduced in Java 8 as part of the Iterable interface. So all the Java collection classes (List, Set, etc.) provides an implementation of the forEach() method.

To use the forEach() method to iterate over enum values, you first need to convert the enum into a list or a set.

Here is how you can use the Arrays.asList() method to convert an enum into a list and then use the forEach() method to iterate over all values:

Arrays.asList(Days.values()).forEach(System.out::println);

// MONDAY
// TUESDAY
// WEDNESDAY
// THURSDAY
// FRIDAY
// SATURDAY
// SUNDAY

Alternatively, you can use the EnumSet.allOf() method to convert the enum into a set and iterate over its values:

EnumSet.allOf(Days.class).forEach(System.out::println);

Iterate over enum values using Streams

The Stream class can also be used to iterate over enum values, as shown below:

Stream.of(Days.values()).forEach(System.out::println);

// MONDAY
// TUESDAY
// WEDNESDAY
// THURSDAY
// FRIDAY
// SATURDAY
// SUNDAY

Let us say we have the following enum class that represents the days of the week:

public enum Day {
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY;
}

The following example demonstrates how you can convert a string to a Day object using the valueOf() method:

String str = "FRIDAY";

Day enumDay = Day.valueOf(str);
System.out.println(enumDay); // FRIDAY

Note that the valueOf() method is case-sensitive. The string value must be an exact match of an enum constant, including the case. Otherwise, an IllegalArgumentException exception is thrown.

The following two examples will fail due to an invalid string or case mismatch:

// ❌ Fail due to case mismatch
Day mismatchStr = Day.valueOf("Monday");

// ❌ Fail due to invalid value
Day invalidStr = Day.valueOf("Weekend");

// ✅ Correct value
Day correctStr = Day.valueOf("MONDAY");

To handle case mismatch, you can transform the given string to uppercase, as shown below:

String str = "Monday";

// Transform the string to uppercase
Day enumDay = Day.valueOf(str.toUpperCase());
System.out.println(enumDay); // MONDAY

Alternatively, you can also use the Streams API to convert a string to an enum value:

String str = "Monday";

Optional<Day> enumDay = Arrays.stream(Day.values())
        .filter(d -> d.name().equalsIgnoreCase(str))
        .findFirst();

if (enumDay.isPresent()) {
    System.out.println("✅ Enum exists: " + enumDay.get());
} else {
    System.out.println("❌ Enum does not exist!");
}

// ✅ Enum exists: MONDAY

Convert a string to a char[] using String.toCharArray()

The String.toCharArray() method returns an array of characters from the given string. The returned character array has the same length as the length of the string.

Here is an example:

// Declare a string
String str = "Java Protips";

// Convert string to a char array
char[] chars = str.toCharArray();

System.out.println(Arrays.toString(chars));
// [J, a, v, a,  , P, r, o, t, i, p, s]

Convert a string to a char[] using String.chars()

The String.chars() is yet another simple method to transform a string into an array of characters in Java 8 and higher, as shown below:

// Declare a string
String str = "Java Protips";

// Convert string to a char array
Character[] chars = str.chars()
        .mapToObj(c -> (char) c)
        .toArray(Character[]::new);

System.out.println(Arrays.toString(chars));
// [J, a, v, a,  , P, r, o, t, i, p, s]

Read this article if you want to convert a character array to a string in Java.

Convert char[] to a string using the String constructor

The easiest way to convert a character array to a string is using the string constructor e.g. new String(char[]).

The String class in Java provides an overloaded constructor that accepts a char array as an argument. Here is an example:

// Declare char array
char[] chars = {'M', 'a', 'n', 'g', 'o'};

// Convert the char array to a string
String str = new String(chars);

System.out.println(str);
// Mango

Convert char[] to a string using String.valueOf()

The String.valueOf() method is yet another simple way to convert a char[] to a string in Java. It returns the string representation of the passed argument, as shown below:

// Declare char array
char[] chars = {'M', 'a', 'n', 'g', 'o'};

// Convert the char array to a string
String str = String.valueOf(chars);

System.out.println(str);
// Mango

Convert char[] to a string using Arrays.stream()

Java 8 provides the Arrays.stream() method to create a stream using an array of characters. Then, you can use the Collectors.joining() method to convert the stream into a string object:

// Declare char array
Character[] chars = {'M', 'a', 'n', 'g', 'o'};

// Convert the char array to a string
String str = Arrays.stream(chars)
        .map(String::valueOf)
        .collect(Collectors.joining());

System.out.println(str);
// Mango

Read this article if you want to convert a string into a character array in Java.

public class Product {
    private int id;
    private String name;
    private double price;

    public Product(int id, String name, double price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }

    // getters and setters, equals(), toString() .... (omitted for brevity)
}

The following example demonstrates how you can create a list of Product objects and use Collectors.toMap() to convert it into a map:

// Create a list of products
List<Product> products = List.of(
        new Product(1, "Milk", 2.3),
        new Product(2, "Honey", 9.99),
        new Product(3, "Cookies", 3.5),
        new Product(4, "Noodles", 0.99)
);

// Convert list of products to map
Map<Integer, String> map = products.stream()
        .collect(Collectors.toMap(Product::getId, Product::getName));

// Print map elements
System.out.println(map);

// {1=Milk, 2=Honey, 3=Cookies, 4=Noodles}

In the above example, we used the unique id field as the Map key. You can also use the product name field as a key, as shown below:

Map<String, Double> map = products.stream()
        .collect(Collectors.toMap(Product::getName, Product::getPrice));

System.out.println(map);

// {Honey=9.99, Cookies=3.5, Milk=2.3, Noodles=0.99}

If the product list contains duplicate names, an error will be thrown by the Collectors.toMap() method:

List<Product> products = List.of(
        new Product(1, "Milk", 2.3),
        new Product(2, "Honey", 9.99),
        new Product(3, "Cookies", 3.5),
        new Product(4, "Noodles", 0.99),

        // Duplicate Product Name
        new Product(5, "Honey", 7.99)
);

Map<String, Double> map = products.stream()
        .collect(Collectors.toMap(Product::getName, Product::getPrice));

System.out.println(map);

// Exception in thread "main" java.lang.IllegalStateException: 
// Duplicate key Honey (attempted merging values 9.99 and 7.99)

To solve the duplicate key issue above, you need to pass the third argument, a merger function, to Collectors.toMap():

Map<String, Double> map = products.stream()
        .collect(Collectors.toMap(Product::getName, Product::getPrice,
                (oldValue, newValue) -> oldValue
        ));

System.out.println(map);

// {Honey=9.99, Cookies=3.5, Noodles=0.99, Milk=2.3}

Notice the line,

(oldValue, newValue) -> oldValue

Here, we specified that in case of a duplicate key, choose the old key over the new one.

If you prefer to use the new key value, use the following code:

Map<String, Double> map = products.stream()
        .collect(Collectors.toMap(Product::getName, Product::getPrice,
                (oldValue, newValue) -> newValue
        ));

System.out.println(map);

// {Honey=7.99, Cookies=3.5, Noodles=0.99, Milk=2.3}

public class User {
    private String name;
    private String profession;
    private int age;

    public User(String name, String profession, int age) {
        this.name = name;
        this.profession = profession;
        this.age = age;
    }

    // getters and setters, equals(), toString() .... (omitted for brevity)
}

The following example demonstrates how you can convert a list of User objects into a list of strings using Java 8 streams:

// Create a list of users
List<User> users = List.of(
        new User("John Doe", "Engineer", 23),
        new User("Alex Mike", "Doctor", 43),
        new User("Jovan Lee", "Lawyer", 34)
);

// Convert list of users to list of strings
List<String> list = users.stream()
        .map(User::toString)
        .collect(Collectors.toList());

// Print list of strings
list.forEach(System.out::println);

// User{name='John Doe', profession='Engineer', age=23}
// User{name='Alex Mike', profession='Doctor', age=43}
// User{name='Jovan Lee', profession='Lawyer', age=34}

To convert a list of User objects to a list of name values, you can do the following:

List<String> list = users.stream()
        .map(User::getName)
        .collect(Collectors.toList());

list.forEach(System.out::println);

// John Doe
// Alex Mike
// Jovan Lee