CodeVsColor

Learn to create a custom progress button in React Native and TypeScript

Sun, 24 Mar 2024 17:23:25 GMT

How to create a custom progress button in React Native with TypeScript:

In this post, I will show you how to create a custom progress button in React Native using TypeScript. We will create a button component that will take different props to customize its style.

`props` of the button:

The following interface will be used as the button props:

interface LoadingButtonProps {
  backgroundColorDefault: string;
  backgroundColorLoading: string;
  isLoading: boolean;
  indicatorColor: string;
  indicatorSize: number | "small" | "large" | undefined;
  textColorDefault: string;
  textColorLoading: string;
  text: string;
  textLoading: string;
  fontSize: number;
  width: number;
  height: number;
  borderRadius: number;
  onPress: () => void;
}

Here,

backgroundColorDefault is the default color for the button.
backgroundColorLoading is the color of the button on the loading state.
isLoading defines the current state.
indicatorColor is the color of the activity indicator.
indicatorSize is the size of the activity indicator.
textColorDefault is the default font color.
textColorLoading is the font color when the button is loading.
text is the default text.
textLoading is the text to show on loading.
fontSize is the font size.
width is the width of the button.
height is the height of the button.
borderRadius is the border radius of the button.
onPress is a callback method to invoke when user taps on the button.

Button component:

Let’s create one new component LoadingButton.tsx with the following code:

import React from "react";
import { Pressable, View, Text, ActivityIndicator } from "react-native";

interface LoadingButtonProps {
  backgroundColorDefault: string;
  backgroundColorLoading: string;
  isLoading: boolean;
  indicatorColor: string;
  indicatorSize: number | "small" | "large" | undefined;
  textColorDefault: string;
  textColorLoading: string;
  text: string;
  textLoading: string;
  fontSize: number;
  width: number;
  height: number;
  borderRadius: number;
  onPress: () => void;
}

const LoadingButton = (props: LoadingButtonProps) => {
  return (
    <Pressable onPress={props.onPress}>
      <View
        style={{
          backgroundColor: props.isLoading
            ? props.backgroundColorLoading
            : props.backgroundColorDefault,
          width: props.width,
          height: props.height,
          borderRadius: props.borderRadius,
          alignItems: "center",
          justifyContent: "center",
          flexDirection: "row",
        }}
      >
        {props.isLoading && (
          <ActivityIndicator
            size={props.indicatorSize}
            style={{ paddingEnd: 10 }}
            color={props.indicatorColor}
          />
        )}
        <Text
          style={{
            color: props.isLoading
              ? props.textColorLoading
              : props.textColorDefault,
            fontSize: props.fontSize,
          }}
        >
          {props.isLoading ? props.textLoading : props.text}
        </Text>
      </View>
    </Pressable>
  );
};

export default LoadingButton;

This is the loading button.

It uses a Pressable as its parent component.
The visibility of the ActivityIndicator is controlled by the isLoading value of the props. Other styles are added as defined by the props to the components.

`App.tsx` file changes:

We can use the above component in any other component. For example, the following code uses the LoadingButton component:

import React, { useState } from "react";
import { SafeAreaView, StyleSheet } from "react-native";
import LoadingButton from "./LoadingButton";

const App = () => {
  const [loading, setLoading] = useState(false);

  const onPressButton = () => {
    setLoading(!loading);
  };

  return (
    <SafeAreaView style={styles.container}>
      <LoadingButton
        backgroundColorDefault="#6750A4"
        backgroundColorLoading="#79747E"
        isLoading={loading}
        indicatorColor="white"
        indicatorSize={26}
        textColorDefault="white"
        textColorLoading="white"
        text="Download"
        textLoading="Downloading.."
        fontSize={20}
        width={300}
        height={60}
        borderRadius={10}
        onPress={onPressButton}
      />
    </SafeAreaView>
  );
};

const styles = StyleSheet.create({
  container: {
    flex: 1,
    alignItems: "center",
    justifyContent: "center",
  },
});

export default App;

Output:

The state of the button is changed on clicking on it. If you run it on Android device, it will look as below:

How to hide the keyboard on scrolling through a FlatList in React Native

Wed, 13 Mar 2024 17:23:25 GMT

How to hide the keyboard on scrolling through a list in React Native:

This post will show you how to hide the keyboard once user starts to scroll through a FlatList. We will create one simple program with a FlatList. It will include a list of TextInput components. If the user clicks on the TextInput component, it will open the keyboard. We need to close the the keyboard if user scrolls through the list or clicks on anywhere on the screen that is not a TextInput component.

Basic program with a `FlatList`:

In this example, we will use the following program. It has one FlatList with a list of TextInput components. The FlatList loads the data defined in the constant LIST_DATA. It uses the value of key id as the id of each child. Each element of the FlatList shows the text defined by the text key and one more TextInput component:

import React from 'react';
import {
  SafeAreaView,
  View,
  FlatList,
  StyleSheet,
  Text,
  StatusBar,
  TextInput,
} from 'react-native';

const LIST_DATA = [
  {
    id: '1',
    text: 'Name',
  },
  {
    id: '2',
    text: 'Address',
  },
  {
    id: '3',
    text: 'Address-2',
  },
  {
    id: '4',
    text: 'Job Profile',
  },
  {
    id: '5',
    text: 'Comment',
  },
];

type ListItemProp = {text: string};

const ListItem = ({text}: ListItemProp) => (
  <View style={styles.item}>
    <Text style={styles.text}>{text}</Text>
    <TextInput style={styles.textInput} />
  </View>
);

const App = () => {
  return (
    <SafeAreaView style={styles.container}>
      <FlatList
        data={LIST_DATA}
        renderItem={({item}) => <ListItem text={item.text} />}
        keyExtractor={item => item.id}
      />
    </SafeAreaView>
  );
};

const styles = StyleSheet.create({
  container: {
    flex: 1,
    marginTop: StatusBar.currentHeight,
  },
  item: {
    padding: 20,
    marginVertical: 8,
    marginHorizontal: 16,
  },
  textInput: {
    borderWidth: 1,
    borderRadius: 5,
  },
  text: {
    fontSize: 20,
    marginBottom: 4,
  },
});

export default App;

If you run the above program, it will load one screen as below:

If you click on the TextInput components, it will open the keyboard. But, if you scroll the list, the keyboard will not dismiss.

How to dismiss the keyboard automatically once user scroll through the `FlatList`:

We need to dismiss the keyboard if the list scrolling starts. We can use the following two callback props of FlatList:

onScrollBeginDrag: This is fired when the scrolling starts.
onScrollEndDrag: This is fired when the scrolling ends.

We can import the Keyboard module and call its dismiss() method to dismiss the active keyboard.

a. Import `Keyboard` from `react-native`:

import {
  Keyboard,
} from 'react-native';

b. Dismiss it on scroll:

<FlatList
    data={LIST_DATA}
    renderItem={({item}) => <ListItem text={item.text} />}
    keyExtractor={item => item.id}
    onScrollBeginDrag={() => Keyboard.dismiss()}
    onScrollEndDrag={() => Keyboard.dismiss()}
    />

Complete program:

Below is the complete program:

import React from 'react';
import {
  SafeAreaView,
  View,
  FlatList,
  StyleSheet,
  Text,
  StatusBar,
  TextInput,
  Keyboard,
} from 'react-native';

const LIST_DATA = [
  {
    id: '1',
    text: 'Name',
  },
  {
    id: '2',
    text: 'Address',
  },
  {
    id: '3',
    text: 'Address-2',
  },
  {
    id: '4',
    text: 'Job Profile',
  },
  {
    id: '5',
    text: 'Comment',
  },
];

type ListItemProp = {text: string};

const ListItem = ({text}: ListItemProp) => (
  <View style={styles.item}>
    <Text style={styles.text}>{text}</Text>
    <TextInput style={styles.textInput} />
  </View>
);

const App = () => {
  return (
    <SafeAreaView style={styles.container}>
      <FlatList
        data={LIST_DATA}
        renderItem={({item}) => <ListItem text={item.text} />}
        keyExtractor={item => item.id}
        onScrollBeginDrag={() => Keyboard.dismiss()}
        onScrollEndDrag={() => Keyboard.dismiss()}
      />
    </SafeAreaView>
  );
};

const styles = StyleSheet.create({
  container: {
    flex: 1,
    marginTop: StatusBar.currentHeight,
  },
  item: {
    padding: 20,
    marginVertical: 8,
    marginHorizontal: 16,
  },
  textInput: {
    borderWidth: 1,
    borderRadius: 5,
  },
  text: {
    fontSize: 20,
    marginBottom: 4,
  },
});

export default App;

If you click on any other TextInput, it will not hide the keyboard. It will dismiss only if the click is on any other component.

3 ways to detect if Keyboard is opened or closed in React Native

Sun, 11 Feb 2024 17:23:25 GMT

How to detect if Keyboard is opened or closed in React Native:

This post will show you how to find if the keyboard is open or closed in React Native in different ways. We will use the Keyboard module.

Method 1: By using the `addListener()` method:

The Keyboard module in React Native provides different methods to control and listen to different keyboard events in both Android and iOS. The addListener method can be used to add listeners to different keyboard events. It takes two parameters:

static addListener: (
  eventType: KeyboardEventName,
  listener: KeyboardEventListener,
) => EmitterSubscription;

eventType is the type of event we want to listen. It is a string parameter.
The second parameter is a callback function.

If we want to listen keyboard events for both Android and iOS, we need to use keyboardDidShow and keyboardDidHide strings as the first parameter to this method.

Note that if android:windowSoftInputMode is set to adjustNothing for the MainActivity in AndroidManifest.xml file for Android 10 and lower devices, it will not trigger these events.

Let’s try it with an example program:

import React, {useEffect, useState} from 'react';
import {SafeAreaView, TextInput, Keyboard, Text} from 'react-native';

function App(): React.JSX.Element {
  const [isVisible, setIsVisible] = useState(false);

  useEffect(() => {
    const keyboardShowListener = Keyboard.addListener('keyboardDidShow', () => {
      setIsVisible(true);
    });
    const keyboardHideListener = Keyboard.addListener('keyboardDidHide', () => {
      setIsVisible(false);
    });

    return () => {
      keyboardShowListener.remove();
      keyboardHideListener.remove();
    };
  }, []);

  return (
    <SafeAreaView style={{alignItems: 'center', marginTop: 60}}>
      <Text>'Keyboard is'{isVisible ? 'visible' : 'hidden'}</Text>
      <TextInput style={{width: 300, margin: 10, borderWidth: 1}} />
    </SafeAreaView>
  );
}

export default App;

isVisible is a state variable to define if the keyboard is currently open or closed. Based on its value, we are showing one message with a Text component if the keyboard is visible or hidden.
The addListener method is used to add a listener to the keyboardDidShow and keyboardDidHide events. Based on these events callbacks, it updates the isVisible variable.

If you run the app, it will update the text as showing below:

Keyboard hidden:

Keyboard showing:

Method 2: Using a custom hook:

We can use a custom hook to move the above listener to a separate file. It is a better approach as we can re-use the custom hook in other files.

useKeyboardListener.tsx:

Let’s create one file useKeyboardListener.tsx with the following content:

import {useEffect, useState} from 'react';
import {Keyboard} from 'react-native';

export const useKeyboardListener = () => {
  const [isVisible, setIsVisible] = useState(false);

  useEffect(() => {
    const keyboardShowListener = Keyboard.addListener('keyboardDidShow', () => {
      setIsVisible(true);
    });
    const keyboardHideListener = Keyboard.addListener('keyboardDidHide', () => {
      setIsVisible(false);
    });

    return () => {
      keyboardShowListener.remove();
      keyboardHideListener.remove();
    };
  }, []);

  return isVisible;
};

The useKeyboardListener method returns the current keyboard listener. We can use this hook in any other file to listen to the status.

App.tsx:

The following code snippet shows how to use useKeyboardListener:

import React from 'react';
import {SafeAreaView, TextInput, Text} from 'react-native';
import {useKeyboardListener} from './useKeyboardListener';

function App(): React.JSX.Element {
  const isVisible = useKeyboardListener();

  return (
    <SafeAreaView style={{alignItems: 'center', marginTop: 60}}>
      <Text>Keyboard is{isVisible ? ' visible' : ' hidden'}</Text>
      <TextInput style={{width: 300, margin: 10, borderWidth: 1}} />
    </SafeAreaView>
  );
}

export default App;

It will give similar results.

Method 3: With `Keyboard.isVisible()`:

This is the simplest of all other methods we have seen above. The Keyboard module provides a method isVisible() to check if the current keyboard is visible or not. We can use it as below:

import React from 'react';
import {Keyboard, SafeAreaView, TextInput, Text} from 'react-native';

function App(): React.JSX.Element {

  return (
    <SafeAreaView style={{alignItems: 'center', marginTop: 60}}>
      <Text>Keyboard is{Keyboard.isVisible() ? ' visible' : ' hidden'}</Text>
      <TextInput style={{width: 300, margin: 10, borderWidth: 1}} />
    </SafeAreaView>
  );
}

export default App;

This method returns one boolean value to define if the keyboard is currently visible or not.

How to hide the keyboard in React Native on tapping outside of TextInput

Sat, 20 Jan 2024 17:23:25 GMT

How to hide the keyboard in React Native on tapping outside of `TextInput`:

This is a common problem and expected behavior in a mobile application. Suppose we have multiple TextInput components in a row and we need to hide the keyboard if the user clicks on anywhere outside.

This can be implemented in different ways in React Native. In this post, I will show you two different ways to solve this problem with a mini React Native project.

Method 1: By using a `ScrollView`:

We can simply add the items in a ScrollView and it will handle the keyboard automatically, i.e. if the user taps anywhere on ScrollView that is not a TextInput, the keyboard will be hidden.

Let’s try it with a simple project. Create one basic React Native project and replace the App.tsx file with the following:

import React from "react";
import {
  SafeAreaView,
  ScrollView,
  StyleSheet,
  TextInput,
  View,
  Button,
} from "react-native";

function App(): React.JSX.Element {
  return (
    <SafeAreaView>
      <ScrollView
        style={styles.scrollStyle}
        contentContainerStyle={styles.containerStyle}
      >
        <View style={styles.headerView} />
        <TextInput style={styles.input} />
        <TextInput style={styles.input} />
        <View style={styles.buttonView}>
          <Button title="click me" />
        </View>
      </ScrollView>
    </SafeAreaView>
  );
}

const styles = StyleSheet.create({
  containerStyle: {
    alignItems: "center",
    flexGrow: 1,
  },
  scrollStyle: {
    height: "100%",
  },
  headerView: { height: 100, width: "80%", margin: 10, backgroundColor: "red" },
  input: {
    width: 300,
    margin: 10,
    borderWidth: 1,
    padding: 10,
    fontSize: 20,
  },
  buttonView: { width: 200 },
});

export default App;

This screen has one ScrollView with one View, two TextInput components and one more Button in a column. If you run this app, it will load the following screen:

If you click outside the TextInput, it will hide the keyboard.

Method 2: By using the `Keyboard` module:

The problem with the above method is that it will hide the keyboard even if we click on the Button. If you click on the button, it will hide the keyboard and on the second click it will click on the button. One way to fix this is by passing keyboardShouldPersistTaps='handled' props to the ScrollView. It will not hide the keyboard if we click on any component of the ScrollView.

React Native provides a module to handle and listen to keyboard events. It has one method called dismiss to dismiss the keyboard manually.

We can use a TouchableWithoutFeedback as the parent component and call this method on onPress prop.

import React from "react";
import {
  SafeAreaView,
  TouchableWithoutFeedback,
  StyleSheet,
  TextInput,
  View,
  Button,
  Keyboard,
} from "react-native";

function App(): React.JSX.Element {
  return (
    <SafeAreaView>
      <TouchableWithoutFeedback onPress={Keyboard.dismiss}>
        <View style={styles.parent}>
          <View style={styles.headerView} />
          <TextInput style={styles.input} />
          <TextInput style={styles.input} />
          <View style={styles.buttonView}>
            <Button title="click me" />
          </View>
        </View>
      </TouchableWithoutFeedback>
    </SafeAreaView>
  );
}

const styles = StyleSheet.create({
  parent: {
    height: "100%",
    alignItems: "center",
  },
  headerView: { height: 100, width: "80%", margin: 10, backgroundColor: "red" },
  input: {
    width: 300,
    margin: 10,
    borderWidth: 1,
    padding: 10,
    fontSize: 20,
  },
  buttonView: { width: 200 },
});

export default App;

It will hide the keyboard if the user taps anywhere outside the TextInput components. The button click will not hide the keyboard. It will click on the button.

By using a HOC:

We can use a higher order component or HOC to take the component as its child. We can write it as below in TypeScript:

type KeyboardDismissTouchableProps = {
  children: React.ReactNode,
};

const KeyboardDismissTouchable = ({
  children,
}: KeyboardDismissTouchableProps) => (
  <TouchableWithoutFeedback onPress={() => Keyboard.dismiss()}>
    {children}
  </TouchableWithoutFeedback>
);

Use it in any other file:

function App(): React.JSX.Element {
  return (
    <SafeAreaView>
      <KeyboardDismissTouchable>
        <View style={styles.parent}>
          <View style={styles.headerView} />
          <TextInput style={styles.input} />
          <TextInput style={styles.input} />
          <View style={styles.buttonView}>
            <Button title="click me" />
          </View>
        </View>
      </KeyboardDismissTouchable>
    </SafeAreaView>
  );
}

It will work similarly to the previous example.

How to change the text size of TextInput in React Native

Sun, 14 Jan 2024 17:23:25 GMT

How to change the text size of `TextInput` in React Native:

The TextInput component of React Native is used to take text inputs. It provides different props to handle its different properties. This post will show you how to change the size of the text input font manually.

Create a basic React Native project:

Before starting the tutorial, let’s create a basic React Native project using React Native cli. You can skip this step if you are already working on a React Native project.

Open a terminal window, go to a folder to create the project and run the following command:

npx react-native@latest init TextInputDemo

It will initialize one project in the TextInputDemo folder. Open your project in your favorite code editor and run npm run android on that folder to run the project on an Android emulator or run npm run ios to run it on an iOS emulator.

Edit your App.tsx file:

Open your App.tsx file with the below content:

import React from 'react';
import {SafeAreaView, StyleSheet, TextInput, View} from 'react-native';

function App(): React.JSX.Element {
  return (
    <SafeAreaView>
      <View style={styles.sectionContainer}>
        <TextInput style={styles.input} />
      </View>
    </SafeAreaView>
  );
}

const styles = StyleSheet.create({
  sectionContainer: {
    marginTop: 32,
    paddingHorizontal: 24,
  },
  input: {
    height: 40,
    margin: 12,
    borderWidth: 1,
    padding: 10,
  },
});

export default App;

It has one TextInput component. It added the style defined in input style block.

If you run the above program, it will create one page with an empty TextInput component. You can click on this component and type anything to write.

How to change the font size of `TextInput` component:

We can simply pass the fontSize to the style prop of TextInput to change the size of its text.

const styles = StyleSheet.create({
  sectionContainer: {
    marginTop: 32,
    paddingHorizontal: 24,
  },
  input: {
    height: 40,
    margin: 12,
    borderWidth: 1,
    padding: 10,
    fontSize: 20,
  },
});

That’s all!! It will change the font size to 20.

Make sure to adjust the height of the `TextInput`:

If you make the font size bigger, it will get cropped. For example, the height of the TextInput is 40 in the above example, and if we change the font size to 30, it will look as like below:

The following style is used for this example:

const styles = StyleSheet.create({
  sectionContainer: {
    marginTop: 32,
    paddingHorizontal: 24,
  },
  input: {
    height: 40,
    margin: 12,
    borderWidth: 1,
    padding: 10,
    fontSize: 30,
  },
});

You can avoid it by removing the height property from the style. For example, if I change the fontSize to 100 and remove the height from its style, it will look as below:

const styles = StyleSheet.create({
  sectionContainer: {
    marginTop: 32,
    paddingHorizontal: 24,
  },
  input: {
    margin: 12,
    borderWidth: 1,
    padding: 10,
    fontSize: 100,
  },
});

How to remove the first occurrence of an item in a list in Python

Fri, 03 Nov 2023 09:39:27 GMT

How to remove the first occurrence of an item in a list in `Python`:

This post will show you how to remove the first occurrence of an item from a list in Python. The program will use one predefined list and one number to remove from the list. There are different ways to solve this problem in Python. I will show you four different ways.

Method 1: By using the `remove()` method:

The remove() method of Python list removes the first occurrence of an element from a list. This method takes the element as its parameter and removes its first instance. The syntax of the remove() method is:

list.remove(e)

e is the element to remove. If the element doesn’t exists in the list, it throws a ValueError.
The return value of this method is None or it returns nothing.

Let’s take a look at the following example:

days = ['sun', 'mon', 'tues', 'thurs', 'fri', 'sat']

print(f'Given list: {days}')

days.remove('tues')

print(f'Final list: {days}')

It has a predefined list of strings days.
It uses the remove() method to remove the string from the list.
It prints the content of the list before and after the string is removed.

If you run this program, it will print:

Given list: ['sun', 'mon', 'tues', 'thurs', 'fri', 'sat']
Final list: ['sun', 'mon', 'thurs', 'fri', 'sat']

The string 'tues' is removed from the list.

If the list has multiple instances of the element we are trying to remove, it will remove the first occurrence of the element. Let’s consider the following example:

days = ['sun', 'mon', 'tues', 'thurs', 'fri', 'tues', 'sat']

print(f'Given list: {days}')

days.remove('tues')

print(f'Final list: {days}')

Download it on GitHub

The list days includes two instances of the string 'tues'. The remove() method will remove the first one from the list. If you run this program, it will print:

Given list: ['sun', 'mon', 'tues', 'thurs', 'fri', 'tues', 'sat']
Final list: ['sun', 'mon', 'thurs', 'fri', 'tues', 'sat']

Method 2: By using the `pop()` method:

The pop method is another method to remove Python list elements. This method takes the index of the element to remove as its parameter. The syntax of the pop method is:

list.pop(i)

The i is the only parameter requires. It is the index of the element to remove from the list.
The parameter i is optional. If we don’t provide its value, it will remove the last element of the list, i.e. -1 is passed as the parameter.
The pop method supports negative indexing. e.g. if we pass -1, it will remove the last element, -2 will remove the second last element etc.
The pop method returns the deleted item.
For invalid index value, it throws IndexError: pop index out of range exception.

We can use the index() method to get the index of the first occurrence of an element. Note that this method throws ValueError if the element is not found in the list.

days = ['sun', 'mon', 'tues', 'thurs', 'fri', 'tues', 'sat']

print(f'Given list: {days}')

days.pop(days.index('tues'))

print(f'Final list: {days}')

Download it on GitHub

It will print:

Given list: ['sun', 'mon', 'tues', 'thurs', 'fri', 'tues', 'sat']
Final list: ['sun', 'mon', 'thurs', 'fri', 'tues', 'sat']

Method 3: By using the `del` operator:

The del operator is similar to the pop() method. The only difference is that it doesn’t return the deleted item. The following program shows how we can use the del operator to remove an item from a list:

days = ['sun', 'mon', 'tues', 'thurs', 'fri', 'tues', 'sat']

print(f'Given list: {days}')

del days[days.index('tues')]

print(f'Final list: {days}')

It will print the same output.

Download it on GitHub

How to check if an object is an array or not in JavaScript

Wed, 01 Nov 2023 09:39:27 GMT

JavaScript program to check if an object is an Array:

In this post, we will learn different ways to check if an object is an Array or not. The typeof operator returns object for an Array as it is a non-primitive data type.

For example,

let a1 = [1, 2, 3, 4];
let a2 = [{i: 1}, 2, 3];
let a3 = 5;
let a4 = 'hello';
let a5 = undefined;
let a6 = {'name': 'Alex'};

console.log(typeof a1); // object
console.log(typeof a2); // object
console.log(typeof a3); // number
console.log(typeof a4); // string
console.log(typeof a5); // undefined
console.log(typeof a6); // object

If you run this program, it will print object for the arrays a1 and a2. The easiest way to check if an object is array is by using the Array.isArray method.

How to use `Array.isArray()` method to check if an object is an Array or not:

The Array.isArray() method is used to check if an object is array or not. The syntax of the Array.isArray() method is:

Array.isArray(value)

It takes one value as its parameter and returns one boolean value. It returns true if value is an Array. Else, it returns false.

Let’s try it with different parameters:

let a1 = [1, 2, 3, 4];
let a2 = [{i: 1}, 2, 3];
let a3 = 5;
let a4 = 'hello';
let a5 = undefined;
let a6 = {'name': 'Alex'};

console.log(Array.isArray(a1)); // true
console.log(Array.isArray(a2)); // true
console.log(Array.isArray(a3)); // false
console.log(Array.isArray(a4)); // false
console.log(Array.isArray(a5)); // false
console.log(Array.isArray(a6)); // false

As this is a boolean value, we can use it with any conditional statement:

let a1 = [1, 2, 3, 4];
let a2 = [{i: 1}, 2, 3];
let a3 = 5;
let a4 = 'hello';
let a5 = undefined;
let a6 = {'name': 'Alex'};

if(Array.isArray(a1)){
    console.log('a1 is an array');
}

Download it on GitHub

How to use `instanceOf` operator to check if an object is an Array:

The instanceOf operator is used to check if an object is an instance of a class or not. It is used to check the instance runtime. It returns one boolean value, true if the object is an instance of the class, or else false.

Let’s check how it works with the above example:

let a1 = [1, 2, 3, 4]; // true
let a2 = [{i: 1}, 2, 3]; // true
let a3 = 5; // false
let a4 = 'hello'; // false
let a5 = undefined; // false
let a6 = {'name': 'Alex'}; // false

console.log(a1 instanceof Array);
console.log(a2 instanceof Array);
console.log(a3 instanceof Array);
console.log(a4 instanceof Array);
console.log(a5 instanceof Array);
console.log(a6 instanceof Array);

Download it on GitHub

As you can see, it returns the same result.

`Array.isArray()` or `instanceOf`:

Although both Array.isArray() method and instanceOf operator gives the same result, Array.isArray() method is preferred to check if an object is Array over instanceOf.

The instanceOf doesn’t work across different globals like iframes. For example,

let iframe = document.createElement('iframe');
document.body.appendChild(iframe);
iframeArray = window.frames[window.frames.length - 1].Array;

let arr = new iframeArray(1, 2, 3);

console.log(arr instanceof Array);  // false    
console.log(Array.isArray(arr));  // true

Download it on GitHub

If you run this, arr instanceOf Array will return false.

4 ways to add the digits of a number in JavaScript

Sun, 17 Sep 2023 09:39:27 GMT

JavaScript program to add the digits of a number:

In this post, I will show you how to write a JavaScript program to add the digits of a given number or it will find the sum of the digits of a number. For example, if the number is 234, it will print 9.

Method 1: Find the sum of digits of a number by using a `while` loop:

With this approach, we will use one while loop to find the sum. It will follow the following steps:

Initialize one variable sum as 0 to hold the final sum.
Run one while loop until the number is greater than 0.
In the loop, get the rightmost digit of the number and add it to the sum variable.
At the end of each iteration, remove the rightmost digit from the number.

The loop will stop once all the digits are removed from the number or the number become 0.

The following program shows how to write it in JavaScript:

let n = 234;
let sum = 0;

while(n){
    sum += n % 10;
    n = Math.floor(n/10);
}

console.log(`Sum: ${sum}`);

The number is assigned to the variable n. The sum variable is initialized to 0.
It uses the modulo operator, %, to get the rightmost digit of the number. The operation n % 10 returns the remainder of the division operation n / 10 or the rightmost digit of the number n.
Math.floor(n/10) removes the rightmost digit of n. The value of n is updated by this value at the end of each loop iteration.

If you run this program, it will print 9.

The above example will update the value of n to 0. We can initialize one new variable before the loop starts:

let n = 234;
let sum = 0;

let no = n;
while(no){
    sum += no % 10;
    no = Math.floor(no/10);
}

console.log(`Sum of digits of ${n}: ${sum}`);

Download it on GitHub

It created a new variable no before the while loop starts. If you run this program, it will not modify the value of n:

Sum of digits of 234: 9

Method 2: By using a `for` loop:

We can use the same approach with a for loop to find the sum. The syntax of for loop is:

for(initialize, condition, update){
 // body   
}

The first step initialize runs once. This is used to initialize a variable.
The second step condition checks for a condition. The loop will run until it is True.
The third step update runs at the end of each iteration. This is used mainly to update a variable.

The body of the loop runs until the condition is True. We can use a for loop to find the sum of all digits of a number as shown below:

let n = 679;
let sum = 0;

for(let no = n; no > 0; no = Math.floor(no/10)){
    sum += no % 10;
}

console.log(`Sum of digits of ${n}: ${sum}`);

Download it on GitHub

It initializes the variable no as n when the loop starts.
At the end of each iteration of the loop, it assigns Math.floor(no/10) to the variable no i.e. it removes the last digit of the number.
The loop runs until the value of no is greater than 0.
In the body of the loop, it adds the last digit of no to the sum variable.

It will print the below result:

Sum of digits of 679: 22

Method 3: By converting the number to `String`:

The number can be converted to a String and we can find the digits by iterating over the characters of the string. The following example shows how it works:

let n = 679;
let sum = 0;

String(n).split('').forEach(e => sum += Number(e));

console.log(`Sum of digits of ${n}: ${sum}`);

Download it on GitHub

It uses the String() constructor to convert the number n to String.
It use the split() method to split the string to an array of digits. For example, for the number 679, it will return the array ['6', '7', '9'].
The forEach loop iterates over the characters of the array. It converts the characters to a number with the Number() constructor and adds it to the sum variable.

Method 4: By using the `reduce()` function:

The reduce() function is an array operation. It uses a reducer function on each element of the array and calculates a final result. We can use these function to find the sum of all digits of a number.

let n = 679;

let initialValue = 0;
let sum = String(n).split('').reduce((accumulator, currentValue) => accumulator + Number(currentValue), initialValue);

console.log(`Sum of digits of ${n}: ${sum}`);

Download it on GitHub

The number n is converted to a String and with the split() method we get an array of characters.
The reduce function takes the second parameter initialValue as the starting value of the accumulator.
On each step, it converts the current character to number and adds it to the current value of the accumulator. This value is passed as the accumulator value on next call.

It will return the sum of all digits of the number n.

If you run the program, it will print:

Sum of digits of 679: 22

6 ways in JavaScript to iterate over an array of objects

Mon, 11 Sep 2023 09:39:27 GMT

How to iterate over an array of objects in JavaScript:

There are different ways to loop through array in JavaScript. This post will show you 6 different ways with examples.

Method 1: How to iterate over an object array with a `for` loop:

This is the traditional way to iterate over an array. The for loop uses a variable and it runs until a certain condition is true. We can run from i = 0 to i = array length - 1. Since the array index starts at 0 and ends at array length - 1, we can access the array items with i as index position on each iteration.

At the end of each iteration, it will increment the value of i by 1.

The following program uses a for loop to iterate over an array of objects:

const arr = [{id: 1, name: 'Alex', age: 20}, {id: 2, name: 'Bob', age: 22}, {id: 3, name: 'Chandler', age: 21}];

for(let i = 0; i < arr.length; i++){
    console.log(arr[i]);
}

Download it on GitHub

It will run from i = 0 to i = arr.length - 1 and at the end of each iteration it increases the value of i by 1. If you run this program, it will print:

{ id: 1, name: 'Alex', age: 20 }
{ id: 2, name: 'Bob', age: 22 }
{ id: 3, name: 'Chandler', age: 21 }

Method 2: By using a `while` loop:

The while loop checks a condition and executes the body of the loop until the condition is true. If we want to write the above example with a while loop, we need to initialize the value of i before the loop starts and increment its value at the end of each iteration.

const arr = [{ id: 1, name: 'Alex', age: 20 }, { id: 2, name: 'Bob', age: 22 }, { id: 3, name: 'Chandler', age: 21 }];

let i = 0;

while (i < arr.length) {
    console.log(arr[i]);
    i++;
};

Download it on GitHub

It will print the same output.

Method 3: By using a `do...while` loop:

The do...while loop is similar to a while loop. It runs the code in the do block before it checks the while condition.

const arr = [{ id: 1, name: 'Alex', age: 20 }, { id: 2, name: 'Bob', age: 22 }, { id: 3, name: 'Chandler', age: 21 }];

let i = 0;

do {
    console.log(arr[i]);
    i++;
}while(i < arr.length);

Download it on GitHub

It will print the same result. But, the do block will run always as it checks the condition after the do block is executed. So, if you run the following program:

const arr = [];

let i = 0;

do {
    console.log(arr[i]);
    i++;
}while (i < arr.length);

It will print undefined. The do block will try to access the first element of arr, which is undefined as it is an empty array. We need to add an additional check to make this work:

const arr = [];

let i = -1;

do {
    if(i >= 0){
        console.log(arr[i]);
    }
    i++;
}while (i < arr.length);

Method 4: Iterate over the array elements with a `forEach` method:

The forEach method executes a given function once for each element of the array. We can access the current array element and its index position in that function. The following example shows how to use the forEach method to iterate over an array of objects.

const arr = [{id: 1, name: 'Alex', age: 20}, {id: 2, name: 'Bob', age: 22}, {id: 3, name: 'Chandler', age: 21}];

arr.forEach((item, index)=> {
    console.log(`Item at index ${index}: `, item);
});

Download it on GitHub

If you run this program, it will print the following output:

Item at index 0:  { id: 1, name: 'Alex', age: 20 }
Item at index 1:  { id: 2, name: 'Bob', age: 22 }
Item at index 2:  { id: 3, name: 'Chandler', age: 21 }

Method 5: By using a `for...of` loop:

The for...of loop provides direct access to the elements of an array. The syntax of this loop is:

for (item of iterable){

}

On each iteration, it will pick one item of the iterable. The following program uses a for...of loop to iterate over the objects of an array:

const arr = [{ id: 1, name: 'Alex', age: 20 }, { id: 2, name: 'Bob', age: 22 }, { id: 3, name: 'Chandler', age: 21 }];

for (let item of arr) {
    console.log(item);
}

Download it on GitHub

It will print:

{ id: 1, name: 'Alex', age: 20 }
{ id: 2, name: 'Bob', age: 22 }
{ id: 3, name: 'Chandler', age: 21 }

Method 6: By using `for...in` loop:

The for...in loop is similar to the for...of loop. It is used to loop through an object. It provides the index of each element if we use for...in with an array.

const arr = [{ id: 1, name: 'Alex', age: 20 }, { id: 2, name: 'Bob', age: 22 }, { id: 3, name: 'Chandler', age: 21 }];

for (let i in arr) {
    console.log(`arr[${i}]: `, arr[i]);
}

Download it on GitHub

It will print:

arr[0]:  { id: 1, name: 'Alex', age: 20 }
arr[1]:  { id: 2, name: 'Bob', age: 22 }
arr[2]:  { id: 3, name: 'Chandler', age: 21 }

How to find all matches in an array of objects in JavaScript

Sun, 10 Sep 2023 09:39:27 GMT

How to find all matches in an array of objects in JavaScript:

In this post, we will explore different ways to find all matches in an array in JavaScript.

Method 1: By using the `filter` method:

The filter method takes one function as its parameter and filters down the elements of the array that are passed by the provided function. It returns a shallow copy of the portion of the array.

Let’s consider the below example:

let studentArr = [{
    id: 1,
    name: 'Alex',
    age: 20
},
{
    id: 2,
    name: 'Bob',
    age: 18
},
{
    id: 3,
    name: 'Chandler',
    age: 19
},
{
    id: 4,
    name: 'Daisy',
    age: 16
},
{
    id: 5,
    name: 'Eva',
    age: 20
}];


let filterArray = studentArr.filter(item => item.id % 2 === 0);

console.log(filterArray);

Download it on GitHub

In this example, we are filtering out the elements with even ids. The filter method checks if the id of an element is even or not with the modulo operator.

If you run this program, it will print:

[ { id: 2, name: 'Bob', age: 18 }, { id: 4, name: 'Daisy', age: 16 } ]

As you can see here, it filtered out the elements with even ids.

Updating the values of the filtered array elements:

The filter method returns a shallow copy of the array elements. So, if we modify any property of these elements, it will reflect on the original array. For example:

let studentArr = [{
    id: 1,
    name: 'Alex',
    age: 20
},
{
    id: 2,
    name: 'Bob',
    age: 18
},
{
    id: 3,
    name: 'Chandler',
    age: 19
},
{
    id: 4,
    name: 'Daisy',
    age: 16
},
{
    id: 5,
    name: 'Eva',
    age: 20
}];


let filterArray = studentArr.filter(item => item.id % 2 === 0);


console.log(`filterArray before update: `,filterArray);

filterArray[0].id = 33;

console.log(`filterArray after update: `,filterArray);
console.log(`studentArr: `, studentArr);

The id of the 0th element of filterArray is changed to 33. If you run this program, it will print:

filterArray before update:  [ { id: 2, name: 'Bob', age: 18 }, { id: 4, name: 'Daisy', age: 16 } ]
filterArray after update:  [ { id: 33, name: 'Bob', age: 18 }, { id: 4, name: 'Daisy', age: 16 } ]
studentArr:  [
  { id: 1, name: 'Alex', age: 20 },
  { id: 33, name: 'Bob', age: 18 },
  { id: 3, name: 'Chandler', age: 19 },
  { id: 4, name: 'Daisy', age: 16 },
  { id: 5, name: 'Eva', age: 20 }
]

Download it on GitHub

You can see that the updated value is also reflected in the original array studentArr.

Method 2: How to filter out objects with multiple properties:

We can filter out elements based on multiple conditions. For example, if we want to pick the objects with even id and age greater than 16, we can use a separate function with these conditions and that function can be passed as the parameter to the filter method. The following example shows how to write it:

const studentFilter = (student) => student?.id % 2 === 2 && student?.age > 16;

let studentArr = [{
    id: 1,
    name: 'Alex',
    age: 20
},
{
    id: 2,
    name: 'Bob',
    age: 18
},
{
    id: 3,
    name: 'Chandler',
    age: 19
},
{
    id: 4,
    name: 'Daisy',
    age: 16
},
{
    id: 5,
    name: 'Eva',
    age: 20
}];

let filterArray = studentArr.filter(studentFilter);

console.log(`filterArray: `,filterArray);
console.log(`studentArr: `, studentArr);

Download it on GitHub

The studentFilter function is passed as the parameter to the filter method. If you run this program, it will print:

filterArray:  [ { id: 2, name: 'Bob', age: 18 } ]
studentArr:  [
  { id: 1, name: 'Alex', age: 20 },
  { id: 2, name: 'Bob', age: 18 },
  { id: 3, name: 'Chandler', age: 19 },
  { id: 4, name: 'Daisy', age: 16 },
  { id: 5, name: 'Eva', age: 20 }
]

Method 3: How to create a deep copy with the `filter()` method:

The return value of the filter() method is a shallow copy of objects. We need to deep-clone the objects to create a new copy. There are different ways in JavaScript to deep copy an object. One of the simplest ways to do it is with the JSON.parse(JSON.stringify(obj)) method. It will return a new deep copied object of the original object obj.

The following example shows how we can use this method with the return array of filter:

let studentArr = [{
    id: 1,
    name: 'Alex',
    age: 20
},
{
    id: 2,
    name: 'Bob',
    age: 18
},
{
    id: 3,
    name: 'Chandler',
    age: 19
},
{
    id: 4,
    name: 'Daisy',
    age: 16
},
{
    id: 5,
    name: 'Eva',
    age: 20
}];


let filterArray = studentArr.filter(item => item.id % 2 === 0).map(item => JSON.parse(JSON.stringify(item)));


console.log(`filterArray before update: `,filterArray);

filterArray[0].id = 33;

console.log(`filterArray after update: `,filterArray);
console.log(`studentArr: `, studentArr);

Download it on GitHub

If you run this program, it will print the below output:

filterArray before update:  [ { id: 2, name: 'Bob', age: 18 }, { id: 4, name: 'Daisy', age: 16 } ]
filterArray after update:  [ { id: 33, name: 'Bob', age: 18 }, { id: 4, name: 'Daisy', age: 16 } ]
studentArr:  [
  { id: 1, name: 'Alex', age: 20 },
  { id: 2, name: 'Bob', age: 18 },
  { id: 3, name: 'Chandler', age: 19 },
  { id: 4, name: 'Daisy', age: 16 },
  { id: 5, name: 'Eva', age: 20 }
]

Even though we changed the id of the element of the filtered array, it didn’t change the property of the original array.

JavaScript program to check if an element is present in an Array or not

Sun, 20 Aug 2023 15:19:00 GMT

How to check if an element is present in an Array or not in `JavaScript`:

In this JavaScript example, we will learn how to check if an element is present in an Array or not in different ways. We can use a for loop or we can use the predefined array functions. Let me show you how it works with example programs.

Method 1: By using a loop:

We can use a for or while loop to iterate over an array and find if an element is present in an Array or not. The following program shows how to use a for loop to check if a number is an array:

const isInArray = (arr, n) => {
    for(let i = 0; i < arr.length; i++){
        if(arr[i] === n) return true;
    }
    return false;
}

console.log(`2 is in [1, 2, 3, 4, 5, 6]: ${isInArray([1, 2, 3, 4, 5, 6], 2)}`);
console.log(`7 is in [1, 2, 3, 4, 5, 6]: ${isInArray([1, 2, 3, 4, 5, 6], 7)}`);

In this example, the isInArray method checks if the element n is in the array arr or not. It returns one boolean value. It iterates over the array element and compares each element with n. If you run the above program, it will print:

2 is in [1, 2, 3, 4, 5, 6]: true
7 is in [1, 2, 3, 4, 5, 6]: false

Download it on GitHub

We can also use a while loop similar to the for loop.

Method 2: With `indexOf`:

The indexOf method returns the first index of an element in an Array. If the element is not found in the array, it returns -1. The following program shows how to use the indexOf method to verify if an element is in an array:

const isInArray = (arr, n) => {
    return arr.indexOf(n) !== -1;
}

console.log(`2 is in [1, 2, 3, 4, 5, 6]: ${isInArray([1, 2, 3, 4, 5, 6], 2)}`);
console.log(`7 is in [1, 2, 3, 4, 5, 6]: ${isInArray([1, 2, 3, 4, 5, 6], 7)}`);

Download it on GitHub

It will print the same output.

2 is in [1, 2, 3, 4, 5, 6]: true
7 is in [1, 2, 3, 4, 5, 6]: false

It finds the index of n in the array arr and returns false if the result of indexOf is -1. Else, it returns true.

Method 3: By using the `includes` method:

The includes() method checks if an element is included in an array or not and returns one boolean value. It returns true if the element is in the array. Else, it returns false.

The syntax of the includes() method is:

includes(e)
includes(e, from)

Where,

The parameter e is the element to search in the array.
The second parameter from is an optional parameter. This is the index to start the search. We can also use negative index for from. It will count back from the array end. It will use array-length + from if from < 0.
If the value of from is greater than or equal to the length of the array, it will return false. If its value is smaller than -array.length, it will search the entire array.

The includes method returns a boolean value. It returns true if the element is found.

Let me modify the above example to use the includes method to check if an element is in an array or not:

const isInArray = (arr, n) => {
    return arr.includes(n);
}

console.log(`2 is in [1, 2, 3, 4, 5, 6]: ${isInArray([1, 2, 3, 4, 5, 6], 2)}`);
console.log(`7 is in [1, 2, 3, 4, 5, 6]: ${isInArray([1, 2, 3, 4, 5, 6], 7)}`);

Download it on GitHub

It will print similar output.

How to use the `includes` method to start the search from a specific index:

We can use the includes method with the second parameter to search from a specific index. For example,

const isInArray = (arr, n, from) => {
    return arr.includes(n, from);
}

const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

console.log(`Search for 3 starting index 3: ${isInArray(arr, 3, 3)}`);
console.log(`Search for 3 starting index 1: ${isInArray(arr, 3, 1)}`);

Download it on GitHub

One new parameter, from is added to the isInArray method. This parameter is passed as the second parameter to the includes method.

The first one is starting the search from index 3 and the second example is starting the search from index 1. Since the index starts at 0, the first example will print false and the second example will print true.

Search for 3 starting index 3: false
Search for 3 starting index 1: true

Java program to read user input numbers with blank spaces

Wed, 16 Aug 2023 15:19:00 GMT

Java program to read user input numbers with blank spaces:

In this post, we will learn how to get user-input numbers with blank spaces and add them to an array. We will assume that the input will include only numbers with blank spaces. I will show you different ways to solve this.

Method 1: By using a loop:

If we know the total count of numbers, we can use a loop to read the numbers to an array. For example:

import java.util.Arrays;
import java.util.Scanner;

public class Example {
    public static void main(String[] args) {
        try (Scanner scanner = new Scanner(System.in)) {
            System.out.println("Please enter three numbers with space:");

            int[] intArray = new int[3];
            for (int i = 0; i < 3; i++) {
                intArray[i] = scanner.nextInt();
            }

            System.out.println("You have entered: " + Arrays.toString(intArray));
        }
    }
}

Download it on GitHub

Here,

The program assumes that the user will always enter three numbers, separated with space.
It created one Scanner object to read the user input values.
It initialized an integer array intArray of size 3 to hold the numbers.
The for loop runs from i = 0 to i = 3 and on each iteration, it uses the nextInt() method to read the integers. It assigns the numbers to the intArray.
The last line is printing the values of the intArray.

If you run this program, it will print outputs as below:

Please enter three numbers with space:
22 34 4
You have entered: [22, 34, 4]

We can also enter more than three numbers, but it will read only the first three numbers:

Please enter three numbers with space:
22 34 4 55 67
You have entered: [22, 34, 4]

Method 2: By split the string:

The above program will work if we know the total count of numbers the user will enter. If we don’t know the count, we can read the input as a String and split it to get the numbers. The following example program shows how we can read any amount of user input numbers:

import java.util.Arrays;
import java.util.Scanner;

public class Example {
    public static void main(String[] args) {
        try (Scanner scanner = new Scanner(System.in)) {
            System.out.println("Please enter the numbers separated with space:");

            String numString = scanner.nextLine();
            String[] nums = numString.split(" ");

            int[] intArray = new int[nums.length];

            for (int i = 0; i < nums.length; i++) {
                intArray[i] = Integer.parseInt(nums[i]);
            }

            System.out.println("You have entered: " + Arrays.toString(intArray));
        }
    }
}

Download it on GitHub
The scanner variable is using the nextLine() method to read all the numbers as a string and assigns this value to the numString variable.
The split() method will break the string around white spaces and return one array holding the numbers as strings. It is assigned to the nums variable.
The integer array intArray is initialized with a length equal to the list nums.
The for loop is iterating over the elements of the array nums. On each step, it uses the Integer.parseInt function to convert the character at ith position of the nums array to integer and assigns it to the ith element of the intArray.
The last line is printing the elements of the array intArray.

If you run this program, it will print outputs as below:

Please enter the numbers separated with space:
1 2 3
You have entered: [1, 2, 3]

Please enter the numbers separated with space:
1 2 3 4 5
You have entered: [1, 2, 3, 4, 5]

It will work with any number of elements.

How to take user inputs with spaces in C program

Thu, 27 Jul 2023 15:19:00 GMT

How to take user inputs with spaces in C:

In this post, we will learn how to take user inputs with blank spaces in C. I will show you different approaches with drawbacks.

Problem with reading string inputs with `scanf`:

We can use the scanf function to read a string input. The scanf function is used to read data from stdin or standard input stream. The first parameter of the scanf function is used to define the data to read. For strings, we can provide %s as the first parameter. For example,

 #include<stdio.h>

int main()
{
    char input[30];
    printf("Enter a string: ");
    scanf("%s", input);

    printf("You have entered: %s\n", input);
    return 0;
}

This example asks the user to enter a string. It uses the scanf function to read that value and assigns it to the character array input. The second printf function is printing that value.

If you run the above program, it will work as below:

Enter a string: hello
You have entered: hello

Enter a string: hello world
You have entered: hello

i.e. it reads the character until a blank space is found.

Approach 1: How to use `scanf` with a different format specifier:

We can use the scanf function with a different format specifier to read strings with spaces. If we pass the format specifier %[^\n] as the first parameter of scanf, it will read all characters until a newline character, \n is found. We can use this format specifier to read a string with blank spaces in it.

Let me change the above program to use this format specifier:

#include<stdio.h>

int main()
{
    char input[30];
    printf("Enter a string: ");
    scanf("%[^\n]", input);

    printf("You have entered: %s\n", input);
    return 0;
}

Download it on GitHub

If you run this code, it will read a string with blank spaces.

Enter a string: hello world
You have entered: hello world

Drawbacks of this approach:

If the user hits the enter before the scanf function executes, this will not read that string. For example,

#include<stdio.h>

int main()
{
    char input[30], secondInput[30];
    
    printf("Enter a string: ");
    scanf("%[^\n]", input);

    printf("Enter another string: ");
    scanf("%[^\n]", secondInput);

    printf("First string: %s\n", input);
    printf("Second string: %s\n", secondInput);
    return 0;
}

This program is trying to read two strings one after another. But, since the user will hit enter after the first string is entered, the second scanf function will read that value and since this is a newline character, it will stop reading any more value. So, if you run this program, it will print output as below:

Enter a string: hello world
Enter another string: First string: hello world
Second string:

The second string was not captured.

To avoid it, we can read that intermediate character with a getchar() function.

#include<stdio.h>

int main()
{
    char input[30], secondInput[30];
    
    printf("Enter a string: ");
    scanf("%[^\n]", input);

    getchar();

    printf("Enter another string: ");
    scanf("%[^\n]", secondInput);

    printf("First string: %s\n", input);
    printf("Second string: %s\n", secondInput);
    return 0;
}

Download it on GitHub

It will work as expected:

Enter a string: hello world
Enter another string: hello universe
First string: hello world
Second string: hello universe

Approach 2: Read a string with blank spaces with the `fgets()` method:

We can use the fgets() method to read a string with blank spaces. The syntax of this method is:

char *fgets(char *str, int n, FILE *file)

The first parameter, str is a pointer to the character array. It stores the string in this array.
The second parameter, n is the maximum number of characters from the string to read.
The third parameter, file is the pointer to the FILE. We can pass stdin to read the string from console.

Note that fgets adds a new-line character at the end of the string automatically.

Let’s use fgets to read strings with blank spaces from console:

#include<stdio.h>

int main()
{
    char input[30], secondInput[30];
    
    printf("Enter a string: ");
    fgets(input, 30, stdin);

    printf("Enter another string: ");
    fgets(secondInput, 30, stdin);

    printf("First string: %s", input);
    printf("Second string: %s", secondInput);
    return 0;
}

Download it on GitHub

It will give output as below:

Enter a string: hello world
Enter another string: hello universe
First string: hello world
Second string: hello universe

We removed the newline characters \n from the last two printf statements as fgets adds a newline character to the end of input and secondInput.

Show hide a div in JavaScript on button click

Tue, 25 Jul 2023 09:39:27 GMT

On button click hide and show div using JavaScript:

In this post, we will learn how to hide and show a div with a button click in JavaScript. We will add one onClick listener to the button and we will toggle the visibility of the div in that listener.

We will use the CSS display properties block and none to show and hide a div.

CSS display property:

The display property of CSS can be used to change the display type. We will use the block and the none properties. The block property will generate a block element box and the none property will remove the element box from the DOM.

Let’s consider the below example:

<!DOCTYPE html>
<html lang="en">
  <head>
    <style>
      #first {
        display: block;
      }

      #second {
        display: none;
      }
    </style>
  </head>

  <body>
    <div id="first">Hello World</div>
    <div id="second">Second Hello World</div>
  </body>
</html>

It is showing two <div> components. The ids of these components are first and second.
In the CSS style sheet, display: block style is applied to the first div and display: none is applied to the second div.

It will hide the second div:

So, we can change the display property of a div to change its visibility.

JavaScript program to show and hide a div on clicking a button:

We need to get the reference of a <div> component to change its display property. The following program shows how to toggle the visibility of a <div> component programmatically with JavaScript:

<!DOCTYPE html>
<html lang="en">
  <head>
    <script>
      function toggleVisibility() {
        const div = document.getElementById("first");
        div.style.display = div.style.display === "none" ? "block" : "none";
      }
    </script>
  </head>

  <body>
    <div id="first">Hello World</div>
    <div id="second">Second Hello World</div>
    <br />
    <button onclick="toggleVisibility()">Click me</button>
  </body>
</html>

Download it on Github
We added a button. On clicking the button, it calls the toggleVisibility method.
In toggleVisibility, we are changing the display property of the div with id first. If the display value is none, it changes it to block and vice versa.

How to change the visibility of different div with the same method:

We can get the id of a div as the parameter and change the visibility of that div with the same method.

<!DOCTYPE html>
<html lang="en">
  <head>
    <script>
      function toggleVisibility(id) {
        const div = document.getElementById(id);
        div.style.display = div.style.display === "none" ? "block" : "none";
      }
    </script>
  </head>

  <body>
    <div id="first">First div</div>
    <div id="second">Second div</div>
    <div id="third">Third div</div>
    <br />
    <button onclick="toggleVisibility('first')">1st div</button>
    <button onclick="toggleVisibility('second')">2nd div</button>
    <button onclick="toggleVisibility('third')">3rd div</button>
  </body>
</html>

Download it on Github

Here, the toggleVisibility method takes the id as its parameter and changes the visibility for the item with the given id. We added three buttons to handle the visibility for the first, second and third div.

How to find simple interest with JavaScript

Sun, 23 Jul 2023 09:39:27 GMT

How to find Simple Interest with JavaScript:

Let’s learn how to calculate and print the simple interest in JavaScript with examples. The program will take the values as inputs from the user and print the calculated Simple Interest.

How to calculate Simple Interest:

To calculate the simple interest, we need to get the pricipal amount, rate of interest, and the time period in years to calculate the interest. If P, r, and n are the values of the principal amount, rate of interest, and time-period, we can calculate the simple interest by using the below formula:

Simple Interest = (P * n * r)/100

We need these three values as inputs from the user and we can calculate the simple interest.

Method 1: By using predefined values:

In this method, we will use predefined principal amount, interest rate, and time period values. The program will calculate the result with the above formula.

const p = 1200;
const n = 5;
const r = 0.2;

const simpleInterest = (p * n * r) / 100;

console.log(`Simple Interest: ${simpleInterest}`);

Download it on Github

Here, we are using predefined values for p, n, and r. The calculated simple interest is assigned to the simpleInterest variable. If you run this program, it will print the calculated simple interest value.

Simple Interest: 12

Method 2: By using user-input values:

The following example will take the values as inputs from the user and print the calculated simple interest. Create one file index.html and add the below code to it:

<!DOCTYPE html>
<html lang="en">
  <head>
    <script>
      function calculateSI() {
        let p = document.getElementById("inputP").value;
        let n = document.getElementById("inputN").value;
        let r = document.getElementById("inputR").value;

        let simpleInterest = (p * n * r) / 100;

        document.getElementById("result").innerHTML = simpleInterest;
      }
    </script>
  </head>
  <body>
    <h4>Enter the principal amount:</h4>
    <input id="inputP" />
    <h4>Enter the rate of interest:</h4>
    <input id="inputR" />
    <h4>Enter the time:</h4>
    <input id="inputN" />
    <br /><br />
    <button onclick="calculateSI()">Calculate Simple Interest</button>
    <p id="result"></p>
  </body>
</html>

Download it on Github

Here,

We have three input fields to take the principal value, rate of interest, and time.
There is one button, on clicking this button, it calls the calculateSI function. This function calculates the simple interest with the user-provided value.
- Inside the function, it reads the value of the principal amount, interest rate, and the number of years and assigns these values to three different variables.
- It calculates the simple interest value and assigns it to the simpleInterest variable.
- This value is assigned to the p component result.

If you open this file in a browser, it will look as below:

5 ways to check if Dart LinkedHashMap contains a key or value

Thu, 06 Jul 2023 09:39:27 GMT

Dart program to check if a `LinkedHashMap` contains a key or value:

The LinkedHashMap class is a hash table-based Map implementation that remembers the insertion order of the key-value pairs. It provides a couple of different properties and methods. In this post, I will show you four different ways to check if a LinkedHashMap contains a key or value with examples.

Method 1: Find in the iterable of keys if the `LinkedHashMap` contains a key:

The keys property of a LinkedHashMap returns an iterable of keys of the LinkedHashMap. We can use this iterable to find out if a specific key is in the LinkedHashMap or not. The syntax of the keys property is:

keys → Iterable<K>

Let’s try it with an example:

import 'dart:collection';

void main() {
  final linkedHMap = LinkedHashMap.from(
      {1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five', 6: 'six'});

  final key = 5;

  final isAvailable = linkedHMap.keys.any((element) => element == key);

  print('isAvailable: ${isAvailable}');
}

Download it on Github

We are using the any method to check if the key is found in the iterable returned by the keys property. The return value is printed at the end of the program.

Output:

isAvailable: true

Method 2: Find in the iterable of values if the `LinkedHashMap` contains a value:

Similar to the above example, we have another property of LinkedHashMap, values, to get all the values of a LinkedHashMap. The following example shows how to check if a value is available in a given LinkedHashMap or not:

import 'dart:collection';

void main() {
  final linkedHMap = LinkedHashMap.from(
      {1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five', 6: 'six'});

  final value = 'six';

  final isAvailable = linkedHMap.values.any((element) => element == value);

  print('isAvailable: ${isAvailable}');
}

Download it on Github

It will also print true as the value ‘six’ is in the given LinkedHashMap.

Method 3: Check if both key and value exist in a LinkedHashMap:

The entries property of LinkedHashMap returns an iterable of MapEntry objects those hold both key and value. We can use this property to check if a LinkedHashMap contains a given key-value pair.

The syntax of the entries property is:

entries → Iterable<MapEntry<K, V>>

Example program:

import 'dart:collection';

void main() {
  final linkedHMap = LinkedHashMap.from(
      {1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five', 6: 'six'});

  final value = 'six';
  final key = 6;

  final isAvailable = linkedHMap.entries
      .any((entry) => entry.key == key && entry.value == value);

  print('isAvailable: ${isAvailable}');
}

Download it on Github

The example is comparing both key and value with each item of the entries. The any method returns a boolean value if an item is found. It will print:

isAvailable: true

Method 4: By using the `containsKey` method:

There is one method called containsKey is available to check if a LinkedHashMap contains a key or not.

containsKey(Object? key) → bool

This method takes a key and returns one boolean value. We can directly use this method to check if a key exists or not.

import 'dart:collection';

void main() {
  final linkedHMap = LinkedHashMap.from(
      {1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five', 6: 'six'});

  final key = 6;

  final isAvailable = linkedHMap.containsKey(key);

  print('isAvailable: ${isAvailable}');
}

It prints true.

Download it on Github

Method 5: By using the `containsValue` method:

Similar to the containsKey method, there is another method called containsValue to check if a value exists in a LinkedHashMap or not.

import 'dart:collection';

void main() {
  final linkedHMap = LinkedHashMap.from(
      {1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five', 6: 'six'});

  final value = 'five';

  final isAvailable = linkedHMap.containsValue(value);

  print('isAvailable: ${isAvailable}');
}

Download it on Github

It returns one boolean value similar to the previous method. Output:

isAvailable: true

3 ways to remove items to a LinkedHashMap in Dart

Sat, 22 Apr 2023 09:39:27 GMT

How to remove items from a LinkedHashMap in Dart:

In this post, we will learn how to remove a single item or multiple items from a LinkedHashMap in Dart. We can remove a single element or multiple elements by using a given function. Let’s learn how to use these methods with examples.

Method 1: Remove a single element from a LinkedHashMap by using the remove method:

The remove method takes one key as the parameter and it removes the key-value pair with that given key from the LinkedHashMap. The syntax of this method is:

remove(Object? k) → V?

It will look for the key k in the LinkedHashMap and if this is found it removes the key-value pair. It returns the value of the key k before it is removed. If the key is not found, it returns null.

For example,

import 'dart:collection';

void main() {
  final linkedHMap = LinkedHashMap.from({1: 'Mango', 4: 'Banana', 3: 'Orange'});

  print('Given map: ${linkedHMap}');

  linkedHMap.remove(4);

  print('Final LinkedHashMap: ${linkedHMap}');
}

It will print:

Given map: {1: Mango, 4: Banana, 3: Orange}
Final LinkedHashMap: {1: Mango, 3: Orange}

The key-value pair with key 4 is removed from the LinkedHashMap.

Method 2: Remove multiple elements with a given function:

There is another method called removeWhere to remove all elements of a LinkedHashMap as satisfied by a given function. This function is useful to remove multiple items from a LinkedHashMap.

The syntax of this method is:

removeWhere(bool f(K key, V value)) -> void

It takes one function f as the parameter and it removes all entries that are satisfied by this function. The following example removes all entries with even keys:

import 'dart:collection';

void main() {
  final linkedHMap = LinkedHashMap.from({
    1: 'Sun',
    2: 'Mon',
    3: 'Tues',
    4: 'Wed',
    5: 'Thurs',
    6: 'Fri',
    7: 'Sat'
  });

  print('Given LinkedHashMap: ${linkedHMap}');
  linkedHMap.removeWhere((key, value) => key % 2 == 0);
  print('Final LinkedHashMap: ${linkedHMap}');
}

In this example, entries with even keys are removed from the linkedHMap LinkedHashMap. If you run this program, it will print:

Given LinkedHashMap: {1: Sun, 2: Mon, 3: Tues, 4: Wed, 5: Thurs, 6: Fri, 7: Sat}
Final LinkedHashMap: {1: Sun, 3: Tues, 5: Thurs, 7: Sat}

Method 3: Remove all entries of a LinkedHashMap:

The clear() method removes all entries of a given LinkedHashMap. The syntax of the clear method is:

clear() -> void

Let’s try it with an example:

import 'dart:collection';

void main() {
  final linkedHMap = LinkedHashMap.from({
    1: 'Sun',
    2: 'Mon',
    3: 'Tues',
    4: 'Wed',
    5: 'Thurs',
    6: 'Fri',
    7: 'Sat'
  });

  print('Given LinkedHashMap: ${linkedHMap}');
  linkedHMap.clear();
  print('Final LinkedHashMap: ${linkedHMap}');
}

If you run this program, it will print:

Given LinkedHashMap: {1: Sun, 2: Mon, 3: Tues, 4: Wed, 5: Thurs, 6: Fri, 7: Sat}
Final LinkedHashMap: {}

Dart program to update single or multiple items of a LinkedHashMap

Sat, 22 Apr 2023 09:39:27 GMT

How to update the items of a LinkedHashMap in Dart:

In this post, we will learn how to update the items of a LinkedHashMap in Dart with different ways. The Dart class provides two methods to update a single item or multiple items of a LinkedHashMap. Let’s learn how these methods works with examples.

Update a single item with the update method:

The update method updates a single item of the LinkedHashMap. This method is defined as:

update(K key, V update(V value), {V ifAbsent()?}) → V

It updates the key with the provided value.
It will update the value of the key if it is present in the LinkedHashMap. Else, it throws Invalid argument (key) exception.
If we want to add the key, we have to provide the ifAbsent function as the third parameter which returns the value for the key.
This method returns the updated value.

Let’s take a look at the below example:

import 'dart:collection';

void main() {
  final linkedHMap = LinkedHashMap.from({1: 'Mango', 2: 'Banana', 3: 'Orange'});

  print('Original LinkedHashMap: ${linkedHMap}');

  linkedHMap.update(1, (value) => 'Apple');

  print('Updated LinkedHashMap: ${linkedHMap}');
}

In this example, we are updating the value of the key 1. It will print:

Original LinkedHashMap: {1: Mango, 2: Banana, 3: Orange}
Updated LinkedHashMap: {1: Apple, 2: Banana, 3: Orange}

If I try to update the value of an invalid key, it will throw an exception:

import 'dart:collection';

void main() {
  final linkedHMap = LinkedHashMap.from({1: 'Mango', 2: 'Banana', 3: 'Orange'});

  print('Original LinkedHashMap: ${linkedHMap}');

  linkedHMap.update(4, (value) => 'Apple');

  print('Updated LinkedHashMap: ${linkedHMap}');
}

It will throw Invalid argument exception:

Update multiple items of a LinkedHashMap:

To update multiple items of a LinkedHashMap, we have to use the updateAll method. The syntax of this method is:

 updateAll(V update(K key, V value)) → void

It takes one function as the parameter and updates all the pairs defined by this function. It iterates over the elements of the LinkedHashMap and updates them using the update function.

For example,

import 'dart:collection';

void main() {
  final linkedHMap = LinkedHashMap.from({1: 'Mango', 2: 'Banana', 3: 'Orange'});

  print('Original LinkedHashMap: ${linkedHMap}');

  linkedHMap.updateAll((key, value) => value.toUpperCase());

  print('Updated LinkedHashMap: ${linkedHMap}');
}

It will update the values of the LinkedHashMap to upperCase.

Original LinkedHashMap: {1: Mango, 2: Banana, 3: Orange}
Updated LinkedHashMap: {1: MANGO, 2: BANANA, 3: ORANGE}

We can use this method to add a check with the keys. For example, the below example will change the value of the even keys to uppercase:

import 'dart:collection';

String update(key, value) {
  return key % 2 == 0 ? value.toUpperCase() : value;
}

void main() {
  final linkedHMap = LinkedHashMap.from({1: 'Mango', 2: 'Banana', 3: 'Orange'});

  print('Original LinkedHashMap: ${linkedHMap}');

  linkedHMap.updateAll(update);

  print('Updated LinkedHashMap: ${linkedHMap}');
}

It will give:

Original LinkedHashMap: {1: Mango, 2: Banana, 3: Orange}
Updated LinkedHashMap: {1: Mango, 2: BANANA, 3: Orange}

3 ways to add items to a LinkedHashMap in Dart

Wed, 19 Apr 2023 09:39:27 GMT

How to add items to a LinkedHashMap in Dart:

There are different methods available to add items to a LinkedHashMap in Dart. In this post, we will learn how to use these methods with examples for each.

Method 1: By using the addAll method:

The addAll method is used to add all items of one map to another map. The syntax of this method is:

void addAll(Map<K, V> o)

It will add all the pairs of the Map o to the current LinkedHashMap. If any key of the parameter Map already exists in the current LinkedHashMap, it will overwrite the value for that key.

For example,

import 'dart:collection';

void main() {
  final linkedHMap = LinkedHashMap.identity();
  final map = <int, String>{1: 'Apple', 2: 'Orange', 3: 'Mango'};

  linkedHMap.addAll(map);

  print('LinkedHashMap: ${linkedHMap}');
}

This program added the content of the map to the LinkedHashMap linkedHMap. If you run this program, it will print:

LinkedHashMap: {1: Apple, 2: Orange, 3: Mango}

As you can see here, the items are added to the LinkedHashMap.

Now let’s see how it updates the existing values. As I’ve mentioned before, it will replace the value if the key is already present in the LinkedHashMap. For the following example,

import 'dart:collection';

void main() {
  final linkedHMap = LinkedHashMap.from({1: 'Mango', 4: 'Banana'});
  final map = <int, String>{1: 'Apple', 2: 'Orange', 3: 'Mango'};

  linkedHMap.addAll(map);

  print('LinkedHashMap: ${linkedHMap}');
}

It will change the value of key 1 as it was already in the LinkedHashMap. If you run this program, it will print:

LinkedHashMap: {1: Apple, 4: Banana, 2: Orange, 3: Mango}

Also, the order of the pairs is not changed.

Method 2: How to add entries to a LinkedHashMap:

We can use the addEntries method to add an iterable of entries to a LinkedHashMap. The syntax of the method is:

addEntries(Iterable<MapEntry<K, V>> entries) → void

It takes one parameter, an iterable of MapEntry objects. It doesn’t return anything, i.e. its return type is void.

Let’s change the above example to use the addEntries method:

import 'dart:collection';

void main() {
  final linkedHMap = LinkedHashMap.identity();
  final map = <int, String>{1: 'Apple', 2: 'Orange', 3: 'Mango'};

  linkedHMap.addEntries(map.entries);

  print('LinkedHashMap: ${linkedHMap}');
}

It will print:

LinkedHashMap: {1: Apple, 2: Orange, 3: Mango}

Similar to the addAll method, this method also overwrites the value if the key is already in the LinkedHashMap. For example,

import 'dart:collection';

void main() {
  final linkedHMap = LinkedHashMap.from({1: 'Mango', 4: 'Banana'});
  final map = <int, String>{1: 'Apple', 2: 'Orange', 3: 'Mango'};

  linkedHMap.addEntries(map.entries);

  print('LinkedHashMap: ${linkedHMap}');
}

It will overwrite the value ‘Mango’ with ‘Apple’ for key 1 since the key already exists in the LinkedHashMap. It will print:

LinkedHashMap: {1: Apple, 4: Banana, 2: Orange, 3: Mango}

Method 3: Add an entry if the key is not in the LinkedHashMap:

The map class provides a method called putIfAbsent that can be used to check if a key exists in a Map or not and add a pair if it doesn’t exist. Its syntax is:

V putIfAbsent(K key, V ifAbsent());

The first parameter key is the key to look for in the LinkedHashMap.
If the key is found, it will return the value associated with that key.
Else, it uses the ifAbsent method to find the value and adds the key-value pair to the LinkedHashMap. It will return the new value.

For example,

import 'dart:collection';

void main() {
  final linkedHMap = LinkedHashMap.from({1: 'Mango', 4: 'Banana'});

  final returnedValue = linkedHMap.putIfAbsent(5, () => 'Orange');

  print('Returned value: ${returnedValue}, LinkedHashMap: ${linkedHMap}');
}

It will find the key 5 in the LinkedHashMap linkedHMap. As this key is not there, it will add the key-value pair (5, ‘Orange’) to the LinkedHashMap. If you run this program, it will print:

Returned value: Orange, LinkedHashMap: {1: Mango, 4: Banana, 5: Orange}

The returned value of putIfAbsent is ‘Orange’, the value of the new key-value pair.

If the key is found in the LinkedHashMap, it will return its value:

import 'dart:collection';

void main() {
  final linkedHMap = LinkedHashMap.from({1: 'Mango', 4: 'Banana'});

  final returnedValue = linkedHMap.putIfAbsent(1, () => 'Orange');

  print('Returned value: ${returnedValue}, LinkedHashMap: ${linkedHMap}');
}

It will print:

Returned value: Mango, LinkedHashMap: {1: Mango, 4: Banana}

It didn’t modify the LinkedHashMap.

7 ways to create a LinkedHashMap in Dart

Tue, 18 Apr 2023 09:39:27 GMT

How to create LinkedHashMap in Dart:

There are different ways to create a LinkedHashMap in dart. This post will show you how to create a LinkedHashMap object with examples in dart.

Method 1: LinkedHashMap.from(Map o)

This constructor takes one Map as the parameter and adds the pairs of the map to the LinkedHashMap.

import 'dart:collection';

void main() {
  final map = <int, String>{1: 'one', 2: 'two', 3: 'three', 4: 'four'};
  final hMap = LinkedHashMap.from(map);

  print('Given map: ${map}');
  print('LinkedHashMap: ${hMap}');
}

Here, map is the given map and hMap is the LinkedHashMap created from this map.

Method 2: LinkedHashMap.of(Map o)

This method takes one Map as its parameter and creates a LinkedHashMap from this map.

Example:

import 'dart:collection';

void main() {
  final map = <int, String>{1: 'one', 2: 'two', 3: 'three', 4: 'four'};
  final hMap = LinkedHashMap<int, Object>.of(map);

  print('Given map: ${map}');
  print('LinkedHashMap: ${hMap}');
}

It will print:

Given map: {1: one, 2: two, 3: three, 4: four}
LinkedHashMap: {1: one, 2: two, 3: three, 4: four}

Method 3: LinkedHashMap.fromEntries(Iterable<MapEntry<K, V>> e)

We can pass a map-entries as the parameter to this method and it creates a LinkedHashMap object.

import 'dart:collection';

void main() {
  final strList = ['a', 'ab', 'abc', 'abcd', 'abcde'];
  final strEntries = strList.map((str) => MapEntry(str.length, str));

  final linkedHMap = LinkedHashMap.fromEntries(strEntries);

  print('Given map: ${strList}');
  print('LinkedHashMap: ${linkedHMap}');
}

The strList is a list of strings.
We created an iterable of entries by using the map function. It uses the length of the string as its key and the string as its value.
The LinkedHashMap is created by using the fromEntries method.

If you run this program, it will print:

Given map: [a, ab, abc, abcd, abcde]
LinkedHashMap: {1: a, 2: ab, 3: abc, 4: abcd, 5: abcde}

Method 4: LinkedHashMap.fromIterables(Iterable k, Iterable v)

The fromIterables method takes two iterables as its parameters. The content of the first iterable is used as the key of the LinkedHashMap and the content of the second iterable is used as the values of the LinkedHashMap.

import 'dart:collection';

void main() {
  final intList = [1, 2, 3, 4, 5];
  final strList = ['a', 'ab', 'abc', 'abcd', 'abcde'];

  final linkedHMap = LinkedHashMap.fromIterables(intList, strList);

  print('LinkedHashMap: ${linkedHMap}');
}

It will print:

LinkedHashMap: {1: a, 2: ab, 3: abc, 4: abcd, 5: abcde}

If we try to provide arrays of different lengths, it will throw an error.

For example,

import 'dart:collection';

void main() {
  final intList = [1, 2, 3, 4, 5, 6, 7];
  final strList = ['a', 'ab', 'abc', 'abcd', 'abcde'];

  final linkedHMap = LinkedHashMap.fromIterables(intList, strList);

  print('LinkedHashMap: ${linkedHMap}');
}

It will throw the following error:

Method 5: LinkedHashMap.fromIterable(Iterable it, {K key(dynamic element)?, V value(dynamic element)?})

This constructor takes one iterable and computes the keys and values from the content of the iterable. The key and value calculator functions are optional, if we don’t provide these values, it will use the identify function as default.

import 'dart:collection';

void main() {
  final strList = ['a', 'ab', 'abc', 'abcd', 'abcde'];

  final linkedHMap = LinkedHashMap.fromIterable(strList,
      key: (e) => e.length, value: (e) => "_${e}");

  print('LinkedHashMap: ${linkedHMap}');
}

This function is calculating the keys and values from the iterable strList. The keys are length of each item. Output:

LinkedHashMap: {1: _a, 2: _ab, 3: _abc, 4: _abcd, 5: _abcde}

If we don’t provide the second and the third parameter:

import 'dart:collection';

void main() {
  final strList = ['a', 'ab', 'abc', 'abcd', 'abcde'];

  final linkedHMap = LinkedHashMap.fromIterable(strList);

  print('LinkedHashMap: ${linkedHMap}');
}

It will give:

LinkedHashMap: {a: a, ab: ab, abc: abc, abcd: abcd, abcde: abcde}

Method 6: LinkedHashMap({bool equals(K, K)?, int hashCode(K)?, bool isValidKey(dynamic)?})

This is the default constructor. Optionally, it takes three parameters:

The equals function is used as the comparison function, it uses Object.== by default.
The hashCode function finds the hash-code of an element. It is Object.hashCode method by default.
The third parameter isValidKey checks if a key is valid or not.

import 'dart:collection';

void main() {
  final map = <int, String>{
    1: 'one',
    2: 'two',
    3: 'three',
    4: 'four',
    5: 'five'
  };

  final linkedHMap = LinkedHashMap<int, String>(
      equals: (int a, int b) => (b - a) % 3 == 0, hashCode: (int e) => e % 3);
  linkedHMap.addAll(map);

  print('LinkedHashMap: ${linkedHMap}');
}

It considers two keys as equal if the difference is divisible by 3. The hashcode is equal to the modulo value of the key.

It will print:

LinkedHashMap: {1: four, 2: five, 3: three}

Both 1 and 4 are considered equal. So, it updated the key with the second value. Similarly, for 2, it updated the value of 5.

Method 7: LinkedHashMap.identity()

This method creates one identity-based LinkedHashMap.

import 'dart:collection';

void main() {
  final linkedHMap = LinkedHashMap.identity();

  print('LinkedHashMap: ${linkedHMap}');
}

Output:

LinkedHashMap: {}

Introduction to Dart LinkedHashMap class

Sun, 16 Apr 2023 09:39:27 GMT

Introduction to Dart LinkedHashMap class:

The LinkedHashMap class of Dart is a hash-table-based Map implementation. The advantage of this class is that it remembers the insertion order of the keys and if we iterate over the map, it iterates in the same order they were inserted.

If we remove a key-value pair and add it again, it will be inserted at the end. Otherwise, the iteration order won’t be changed. Even if we change the value of an existing key, the iteration order will remain the same.

This post will list down all the constructors, methods and properties of a Dart LinkedHashMap.

Constructors of LinkedHashMap:

We can use the following constructors to create a LinkedHashMap object:

LinkedHashMap({bool equals(K, K)?, int hashCode(K)?, bool isValidKey(dynamic)?})

This constructor creates a LinkedHashMap. It takes three optional parameters:

The first parameter equals defines the comparison function of the keys. It uses Object.== by default.
The second parameter hashCode is used to create hash code for the keys. By default, Object.hashCode is used.
The third parameter isValidKey is used to check if the key is valid or not.

LinkedHashMap.from(Map o)

This constructor creates a LinkedHashMap from another map o.

LinkedHashMap.fromEntries(Iterable<MapEntry<K, V>> e)

This constructor creates a LinkedHashMap from a given map-entries.

LinkedHashMap.fromIterable(Iterable it, {K key(dynamic element)?, V value(dynamic element)?})

Create one LinkedHashMap from an iterable, the keys and values are derived from the iterable.

LinkedHashMap.fromIterables(Iterable k, Iterable v)

It takes two parameters, the first one is iterable for the keys and the second one is iterable for the values.

LinkedHashMap.of(Map<K, V> o)

It creates a LinkedHashMap with the key-value pairs of the Map o.

LinkedHashMap.identity()

Create one identity-based LinkedHashMap.

Properties of LinkedHashMap:

All the properties of LinkedHashMap are inherited. The following are the available properties:

hashCode → int

It is the hash code for the LinkedHashMap object.

isEmpty → bool

This property returns one boolean value. It is true if the LinkedHashMap is empty, else false.

isNotEmpty → bool

It returns false for an empty LinkedHashMap, and true otherwise.

length → int

The length of the LinkedHashMap, i.e. the number of pairs it has.

keys → Iterable

It returns an iterable holding the keys of the LinkedHashMap.

values → Iterable

Iterable with the values.

entries → Iterable<MapEntry<K, V>>

The map entries of the current LinkedHashMap.

runtimeType → Type

Runtime type of the current object.

Methods of LinkedHashMap:

Following are the inherited methods available in a LinkedHashMap object:

forEach(void action(K k, V v)) → void

Applies the function action to each key-value pair of the object.

map<K2, V2>(MapEntry<K2, V2> convert(K k, V v)) → Map<K2, V2>

It uses the convert function to convert all entries of the current map and a new map is returned with the new values.

addAll(Map<K, V> o) → void

Adds all pairs of the other map o to this map.

addEntries(Iterable<MapEntry<K, V>> entries) → void

Add all pairs of entries to this map.

putIfAbsent(K k, V ifAbsent()) → V

Add a new entry with the pair if not available in the current object.

update(K key, V update(V value), {V ifAbsent()?}) → V

Update the value with the key in the current LinkedHashMap.

updateAll(V update(K key, V value)) → void

Update all the values defined by the update function.

remove(Object? k) → V?

Remove the key-value pair with the key k from the current LinkedHashMap.

removeWhere(bool test(K key, V value)) → void

Remove all the pairs that are satisfied by the given function test.

clear() → void

Remove all pairs from the current object.

containsKey(Object? key) → bool

Check if the LinkedHashMap contains the key or not.

containsValue(Object? value) → bool

Check if the LinkedHashMap contains the value or not.

cast<RK, RV>() → Map<RK, RV>

Cast the map.

noSuchMethod(Invocation invocation) → dynamic

This is invoked if the program is trying to access any invalid method or property.

toString() → String

Return one string representation of the current object.

Refer:

LinkedHashMap doc

Dart HashSet skip and skipWhile methods explanation with example

Fri, 14 Apr 2023 09:39:27 GMT

Dart HashSet skip and skipWhile methods:

The skip and skipWhile methods are used to get iterable of a HashSet by skipping the first elements of a HashSet. This post will show you how to use the skip and skipWhile methods with examples.

Dart HashSet skip method:

The skip method is used to get one iterable by skipping a given number of elements of a HashSet. The syntax of the skip method is:

skip(int count) → Iterable<E>

It takes one integer variable as its parameter. It will return one iterable by skipping the first count number of elements of the HashSet.

For example:

import 'dart:collection';

void main() {
  final hashSet = HashSet.of([1, 2, 3, 4, 5, 6, 7, 8, 9]);

  final newValuesIterable = hashSet.skip(4);

  print('Original HashSet: ${hashSet}');
  print('Iterable: ${newValuesIterable}');
}

If you run this program, it will print:

Original HashSet: {1, 2, 3, 4, 5, 6, 7, 8, 9}
Iterable: (5, 6, 7, 8, 9)

As you can see here, it created one iterable by skipping the first 4 numbers of the HashSet.

If the value of the variable count is equal or greater than the length of the HashSet, it will return one empty iterable.

For example,

import 'dart:collection';

void main() {
  final hashSet = HashSet.of([1, 2, 3, 4, 5, 6, 7, 8, 9]);

  final newValuesIterable = hashSet.skip(14);

  print('Original HashSet: ${hashSet}');
  print('Iterable: ${newValuesIterable}');
}

It will print:

Original HashSet: {1, 2, 3, 4, 5, 6, 7, 8, 9}
Iterable: ()

Dart HashSet skipWhile method:

The skipWhile method of Dart uses a function to skip the first elements of a HashSet. The syntax of this method is:

skipWhile(bool fn(E e)) → Iterable<E>

It also returns one iterable. It uses the function fn to find out the starting elements to skip. It will skip all the elements for those the function returns true. Starting from the element for which it returns false, it will add all the elements of the HashSet to the iterable in the same order.

For example,

import 'dart:collection';

void main() {
  final hashSet = HashSet.of([1, 2, 3, 4, 5, 6, 7, 8, 9]);

  final newValuesIterable = hashSet.skipWhile((e) => e < 5);

  print('Original HashSet: ${hashSet}');
  print('Iterable: ${newValuesIterable}');
}

In this example, the skipWhile method will skip all the elements that are smaller than 5. So, the program will print:

Original HashSet: {1, 2, 3, 4, 5, 6, 7, 8, 9}
Iterable: (5, 6, 7, 8, 9)

If the function skips all the elements of the HashSet, it will return an empty iterable.

import 'dart:collection';

void main() {
  final hashSet = HashSet.of(['a', 'b', 'c', 'd']);

  final newValuesIterable = hashSet.skipWhile((e) => e.length > 1);

  print('Original HashSet: ${hashSet}');
  print('Iterable: ${newValuesIterable}');
}

Output:

Original HashSet: {c, a, b, d}
Iterable: (c, a, b, d)

As you can see here, the skipWhile function is skipping all the elements that have a length greater than one in the HashSet. But, since all the strings of the HashSet are of length one, it will skip all the elements and the iterable will hold all the strings of the HashSet.

Dart HashSet fold and reduce methods explanation with examples

Thu, 13 Apr 2023 09:39:27 GMT

How to use the fold and reduce methods of Dart HashSet:

Both fold and reduce methods are used to get a single value from a HashSet. Both of these methods are different. In this post, we will learn how to use these methods with example programs.

HashMap.reduce method:

The reduce method reduces one HashSet to a single value. It takes one function as its parameter to combine the results. It uses the function to iteratively combine the values to get the final result.

The syntax of the reduce method is:

reduce(E combine(E v, E e)) → E

Here, the combine function is the function that the reduce function uses to combine the values. The first parameter, v is the current calculated value and the second parameter e is the current iterating value.

For example:

import 'dart:collection';

void main() {
  final hashSet = HashSet.of([1, 2, 3, 4, 5, 6, 7, 8, 9]);

  final reducedValue = hashSet.reduce((v, e) => v + e);

  print('Original HashSet: ${hashSet}');
  print('Reduced value: ${reducedValue}');
}

In this example, the reduced function returns the sum of both the current value and the current calculated value. Finally, the reducedValue variable will hold the sum of all the numbers of the HashSet.

If you run this program, it will print:

Original HashSet: {1, 2, 3, 4, 5, 6, 7, 8, 9}
Reduced value: 45

To understand how this program works, let me modify the above program:

import 'dart:collection';

int combine(int v, int e) {
  print('v: ${v}, e: ${e}');
  return v + e;
}

void main() {
  final hashSet = HashSet.of([1, 2, 3, 4, 5, 6, 7, 8, 9]);

  final reducedValue = hashSet.reduce(combine);

  print('Original HashSet: ${hashSet}');
  print('Reduced value: ${reducedValue}');
}

We added a new function combine and passed this function to the HashSet.of method. The values of v and e are printed in the function and the sum of these values is returned from the function.

If you run this program, it will print:

v: 1, e: 2
v: 3, e: 3
v: 6, e: 4
v: 10, e: 5
v: 15, e: 6
v: 21, e: 7
v: 28, e: 8
v: 36, e: 9
Original HashSet: {1, 2, 3, 4, 5, 6, 7, 8, 9}
Reduced value: 45

The first element is passed as the first parameter and the second parameter is the second parameter.
The first element is the last step calculated value and the second element is the current value.
It starts the iteration from the second element.
The final calculated value is returned from the function.

HashMap.fold method:

The fold method is similar to the reduce method. But it takes one initial value and that value is used with the combine function. The syntax of this method is:

fold<T>(T initial, T combine(T previous, E element)) → T

Here,

The initial parameter is the initial value.
The combine function is used to combine the values. Here, the previous parameter is the previous calculate value and the element parameter is the current element.

For example,

import 'dart:collection';

void main() {
  final hashSet = HashSet.of([1, 2, 3, 4, 5, 6, 7, 8, 9]);

  final foldValue =
      hashSet.fold(10, ((previousValue, element) => previousValue + element));

  print('Original HashSet: ${hashSet}');
  print('Fold value: ${foldValue}');
}

Here,

The initial value is 10 and the combine function is returning the sum of the previous value and the current value.

If you run this program, it will print:

Original HashSet: {1, 2, 3, 4, 5, 6, 7, 8, 9}
Fold value: 55

The sum of the values of the HashSet is 45 and since the initial value is 10, the final fold value is 55.

Let’s use a different function to understand how it works:

import 'dart:collection';

int combine(int previous, int element) {
  print("Previous: ${previous}, element: ${element}");
  return previous + element;
}

void main() {
  final hashSet = HashSet.of([1, 2, 3, 4, 5, 6, 7, 8, 9]);

  final foldValue = hashSet.fold(10, combine);

  print('Original HashSet: ${hashSet}');
  print('Fold value: ${foldValue}');
}

We created a new function combine and that function is printing the previous and the element values. It returns the sum of these two values.

It will print:

Previous: 10, element: 1
Previous: 11, element: 2
Previous: 13, element: 3
Previous: 16, element: 4
Previous: 20, element: 5
Previous: 25, element: 6
Previous: 31, element: 7
Previous: 38, element: 8
Previous: 46, element: 9
Original HashSet: {1, 2, 3, 4, 5, 6, 7, 8, 9}
Fold value: 55

The previous value is the initial value we passed to the combine function.
On each step, it returns the calculated value as the previous parameter and the current value as the element.
It iterates over all the numbers of the HashSet.

Dart HashSet where and whereType explanation with examples

Wed, 12 Apr 2023 09:39:27 GMT

How to use where and whereType in Dart HashSet:

The where and whereType methods of Dart HashSet are used to get an iterable of elements satisfied by a given function. In this post, we will learn how to use where and whereType with examples.

How to use the where method:

The syntax of the where method is:

where(bool fn(E e)) → Iterable<E>

It takes one function as its parameter and returns one iterable.
The function must return a boolean value. If the return value for any element is true, it will add that element to the iterable. Otherwise, it will skip that element.

Let’s take one example to understand how this method works:

import 'dart:collection';

void main() {
  final hashSet = HashSet.of([1, 2, 3, 4, 5, 6, 7, 8, 9]);
  final evenIterable = hashSet.where((e) => e.isEven);

  print('Original HashSet: ${hashSet}');

  print('Content of the evenIterable: ');
  evenIterable.forEach((e) {
    print(e);
  });
}

The hashSet is a HashSet of numbers.
It uses the where method to find the even numbers of the hashSet and assigns the returned iterable to the evenIterable variable.
The last two print statements are printing the content of the original HashSet and the content of the iterable.

It will give the below result:

Original HashSet: {1, 2, 3, 4, 5, 6, 7, 8, 9}
Content of the evenIterable: 
2
4
6
8

As you can see that the even numbers are picked from the given HashSet.

How to use the whereType method:

The whereType method is used to pick elements of a specific type. For example, if a HashSet contains both string and integer values, we can pick only the string or integer values by using whereType.

The syntax of the whereType method is:

whereType<T>() → Iterable<T>

Where T is the type. It returns one lazy iterable.

The below example program shows how to use the whereType method:

import 'dart:collection';

void main() {
  final hashSet = HashSet.of(['a', 1, 'b', 2, 'c', 3, 'd', 4, 'e', 5]);
  final stringSetIterable = hashSet.whereType<String>();
  final integerSetIterable = hashSet.whereType<int>();

  print('Original HashSet: ${hashSet}');

  print('String values of the HashSet: ${stringSetIterable}');
  print('Integer values of the HashSet: ${integerSetIterable}');
}

Here,

The HashSet holds both string and integer variables.
We are using the whereType method to filter out string and integer values of the HashSet. The string values are assigned to the stringSetIterable and the integer values are assigned to the integerSetIterable variable.

If you run this program, it will print:

Original HashSet: {e, 1, a, 2, 3, 4, 5, d, c, b}
String values of the HashSet: (e, a, d, c, b)
Integer values of the HashSet: (1, 2, 3, 4, 5)

As you can see, the strings and integer values of the HashSet are picked by the whereType method.

Dart HashSet.take and HashSet.takeWhile methods

Tue, 11 Apr 2023 09:39:27 GMT

How to use HashSet.take and HashSet.takeWhile methods in Dart:

The HashSet class in Dart provides two methods take() and takeWhile() to get a lazy iterable of its elements. Both of these methods are different. This post will show you how to use these methods with examples.

HashSet.take():

The take method takes one integer value as its parameter and returns one lazy iterable of the first count elements of the HashSet.

The syntax of take is:

take(int count) → Iterable<E>

The count is the only parameter it takes.
It returns one lazy iterable of the first count elements of the HashSet. We can use this iterable to iterate over the elements.

Let’s learn this method with an example:

import 'dart:collection';

void main() {
  final givenSet = HashSet.of([1, 2, 3, 4, 5, 6, 7, 8, 9]);
  final it = givenSet.take(5);

  print('Given HashSet: ${givenSet}');

  print('Content of take(5): ');
  it.forEach((element) {
    print(element);
  });
}

In this example,

We created one HashSet of nine numbers. It is assigned to the variable givenSet.
It used the take method with the count variable as 5 to get the first five values of the HashSet. It is assigned to the it variable.
We are using forEach on this iterable variable to iterate over the content and print the values.

If you run this program, it will print:

Given HashSet: {1, 2, 3, 4, 5, 6, 7, 8, 9}
Content of take(5): 
1
2
3
4
5

As you can see here, the take(5) method returns the first five elements of the HashSet.

HashSet.takeWhile:

We have another method takeWhile, which can be used to get a lazy iterable as defined by a given function. Instead of a number, this method takes one function as its parameter and picks the elements defined by that function. Note that this function will pick the elements until it returns false.

The syntax of HashSet.takeWhile is:

takeWhile(bool fn(E e)) → Iterable<E>

It takes one function as its parameter and returns one lazy iterable.
The function defines the values to pick from the HashSet. It must return one boolean value. The iterable will include the elements till which this function returns true.

Let’s learn how this work with an example:

import 'dart:collection';

void main() {
  final givenSet = HashSet.of([1, 2, 3, 4, 5, 6, 7, 8, 9]);
  final it = givenSet.takeWhile((e) => e < 6);

  print('Given HashSet: ${givenSet}');

  print('Content of takeWhile: ${it}');
  it.forEach((element) {
    print(element);
  });
}

We are using the same example used before. It will pick all the elements which are smaller than 6. If it finds any number which is equal to or smaller than 6, it will stop.

If you run this program, it will print:

Given HashSet: {1, 2, 3, 4, 5, 6, 7, 8, 9}
Content of takeWhile: (1, 2, 3, 4, 5)
1
2
3
4
5

As you can see here, it picked all the elements from 1 to 5. Let’s try one more example:

import 'dart:collection';

void main() {
  final givenSet = HashSet.of([1, 2, 3, 4, 5, 6, 7, 8, 9]);
  final it = givenSet.takeWhile((e) => e.isEven);

  print('Given HashSet: ${givenSet}');

  print('Content of takeWhile: ${it}');
  it.forEach((element) {
    print(element);
  });
}

It will give:

Given HashSet: {1, 2, 3, 4, 5, 6, 7, 8, 9}
Content of takeWhile: ()

As you can see here, it returns an empty iterator because the function is looking for even numbers and since the first number of the hashSet is odd, it will stop the iteration.

3 ways to find if a HashSet is empty or not in Dart

Mon, 10 Apr 2023 09:39:27 GMT

Different ways to find if a HashSet is empty or not in Dart:

There are different ways in HashSet to check if it is empty or not in Dart. Dart HashSet provides a couple of properties to check if a HashSet is empty or not.

Method 1: How to check if a HashSet is empty with the isEmpty property:

The isEmpty property of HashSet is used to check if a HashSet is empty or not. This property is defined as:

isEmpty → bool

This is a boolean property. It returns true if the HashSet is empty, else it returns false.

Let’s try this with an example:

import 'dart:collection';

void main() {
  final firstSet = HashSet.of([1, 2, 3]);
  final secondSet = HashSet();

  print("firstSet isEmpty: ${firstSet.isEmpty}");
  print("secondSet isEmpty: ${secondSet.isEmpty}");
}

In this program, we are checking the isEmpty values of firstSet and secondSet. Here, secondSet is the empty set. If you run this program, it will print:

firstSet isEmpty: false
secondSet isEmpty: true

As you can see, the value of isEmpty is true for the empty HashSet.

Method 2: By using the isNonEmpty property:

The isNonEmpty property returns one boolean value based on if the HashSet is not empty or not. This property is defined as:

isNotEmpty → bool

It returns true if the HashSet is not empty and false otherwise.

Example:

import 'dart:collection';

void main() {
  final firstSet = HashSet.of([1, 2, 3]);
  final secondSet = HashSet();

  print("firstSet isNotEmpty: ${firstSet.isNotEmpty}");
  print("secondSet isNotEmpty: ${secondSet.isNotEmpty}");
}

This is the same example we used before. It will print:

firstSet isNotEmpty: true
secondSet isNotEmpty: false

Method 3: By finding the length of the HashSet:

We can use the length property to find the length of the HashSet. This property is defined as:

length → int

It is an integer value. If the length is greater than zero, the HashSet is not empty, else it is.

Example:

import 'dart:collection';

void main() {
  final firstSet = HashSet.of([1, 2, 3]);
  final secondSet = HashSet();

  print("firstSet length: ${firstSet.length}");
  print("secondSet length: ${secondSet.length}");
}

It will print:

firstSet length: 3
secondSet length: 0

Although we can use the length property to check if a HashSet is empty or not, it is not recommended. Because we already have two predefined boolean properties to check that. The length property is used mainly to find the length of a HashSet.

Union and intersection of two HashSet in Dart

Thu, 06 Apr 2023 09:39:27 GMT

How to find the union and intersection of two HashSet in Dart:

In this post, we will discuss on union and intersection of two HashSets. If SetA and SetB are two sets, the union of these two sets will include all the elements which are either in one of these sets. Similarly, the intersection will hold only the common elements of these sets.

The union of SetA and SetB is denoted by SetA ∪ SetB and the intersection is denoted by SetA ∩ SetB.

To find the union and intersection of two HashSets, this class provides two methods. We can use these methods without writing our own utility functions.

How to find the union of two HashSet:

To find the union of two HashSet, we can use the union method. This method is defined as:

union(Set<E> o) → Set<E>

It takes another HashSet o as the parameter and returns the union hashSet of the two sets.

For example,

import 'dart:collection';

void main() {
  final firstSet = HashSet.of([1, 2, 3, 4]);
  final secondSet = HashSet.of([5, 6, 7, 8]);

  final unionSet = firstSet.union(secondSet);

  print('Union HashSet: ${unionSet}');
}

In this example, we are using the union method to find the union of the sets firstSet and secondSet. If you run this program, it will print:

Union HashSet: {1, 2, 3, 4, 5, 6, 7, 8}

The content of both of these HashSet shouldn’t be different. Otherwise, it will throw an error. For example,

import 'dart:collection';

void main() {
  final firstSet = HashSet.of([1, 2, 3, 4]);
  final secondSet = HashSet.of(['a', 'b']);

  final unionSet = firstSet.union(secondSet);

  print('Union HashSet: ${unionSet}');
}

This program will throw one error because the data types of firstSet and secondSet are different.

How to find the intersection of two HashSet:

Similar to union, we have another method to find the intersection of two HashSets. This method is:

intersection(Set<Object?> o) → Set<E>

It takes another HashSet as its parameter and returns one new set holding the intersection result. Let’s try it with an example:

import 'dart:collection';

void main() {
  final firstSet = HashSet.of([1, 2, 3, 4]);
  final secondSet = HashSet.of([5, 6, 7, 3, 9, 4]);

  final intersectionSet = firstSet.intersection(secondSet);

  print('Intersection HashSet: ${intersectionSet}');
}

It will print the intersection of firstSet and secondSet:

Intersection HashSet: {3, 4}

If no common element is found in the sets, it will print an empty set:

import 'dart:collection';

void main() {
  final firstSet = HashSet.of([1, 2, 3, 4]);
  final secondSet = HashSet.of([5, 6, 7, 8, 9]);

  final intersectionSet = firstSet.intersection(secondSet);

  print('Intersection HashSet: ${intersectionSet}');
}

It will print:

Intersection HashSet: {}

Chain operation of union and intersection:

Since both union and intersection methods return a new set, we can use these in a chain. For example,

import 'dart:collection';

void main() {
  final firstSet = HashSet.of([1, 2, 3, 4]);
  final secondSet = HashSet.of([5, 6, 7, 3, 9]);
  final thirdSet = HashSet.of([8, 10, 3]);

  final intersectionSet =
      firstSet.intersection(secondSet).intersection(thirdSet);
  final unionSet = firstSet.union(secondSet).union(thirdSet);

  print('Intersection HashSet: ${intersectionSet}');
  print('Union HashSet: ${unionSet}');
}

This program will print the intersection and union of the three sets firstSet, secondSet and thirdSet.

Intersection HashSet: {3}
Union HashSet: {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

Other dart examples:

How to add and remove items from a HashSet in Dart

Wed, 05 Apr 2023 09:39:27 GMT

How to add and remove items from a HashSet in Dart:

The HashSet is a hash-table based set implementation. This post will show you how to add and remove items from a HashSet in different ways.

Add elements to a HashSet:

We have two different methods to add single or multiple elements to a HashSet:

add(E e) → bool
addAll(Iterable<E> it) → void

Add a single element to HashSet with the add method:

The add method adds a single element to the HashSet. This is defined as:

add(E e) → bool

This method adds one single element to the HashSet. It returns one boolean value, true if the element is added, else false.

For example,

import 'dart:collection';

void main() {
  final hashSet = HashSet<String>();

  final vowels = ['A', 'E', 'I', 'O', 'U', 'E'];

  for (var e in vowels) {
    if (hashSet.add(e)) {
      print('Added ${e}');
    } else {
      print('Failed to add ${e}');
    }
  }

  print('Final HashSet: ${hashSet}');
}

In this example, we are using a loop to add the strings of vowels to the HashSet. Based on the return value of add(), it prints a message to the user.

Output:

Added A
Added E
Added I
Added O
Added U
Failed to add E
Final HashSet: {A, O, I, E, U}

It failed to add E because it was already added to the HashSet. HashSet is unordered. Hence the final HashSet is not following the order of data insertion.

Add multiple items to a HashSet with addAll:

The addAll method is defined as:

addAll(Iterable<E> it) → void

It adds all the items of the iterable it to the HashSet.

import 'dart:collection';

void main() {
  final hashSet = HashSet<String>();

  final vowels = ['A', 'E', 'I', 'O', 'U', 'E'];

  hashSet.addAll(vowels);

  print('Final HashSet: ${hashSet}');
}

It will print:

Final HashSet: {A, O, I, E, U}

Remove elements from a HashSet:

The following methods are available to remove and retain specific elements of a HashSet.

remove(Object? o) → bool
removeAll(Iterable<Object?> it) → void
clear() → void
removeWhere(bool fn(E e)) → void
retainWhere(bool fn(E e)) → void
retainAll(Iterable<Object?> it) → void

Remove a single element:

We can use the remove method to remove a single element from a HashSet. This method takes one object as its parameter and removes the object from HashSet. It returns one boolean value.

remove(Object? o) → bool

Let’s try this method with an example:

import 'dart:collection';

void main() {
  final hashSet = HashSet<String>();

  final vowels = ['A', 'E', 'I', 'O', 'U'];

  hashSet.addAll(vowels);

  for (var e in ['A', 'B']) {
    if (hashSet.remove('A')) {
      print('${e} is removed');
    } else {
      print("${e} can't be removed");
    }
  }

  print('Final HashSet: ${hashSet}');
}

In this example, we are trying to remove the strings of [‘A’, ‘B’] from the HashSet hashSet. Based on its return value, it prints one message.

It will give the below output:

A is removed
B can't be removed
Final HashSet: {O, I, E, U}

Remove multiple elements from a HashSet:

There is a method called removeAll to remove multiple elements from a HashSet. This method takes one iterable and removes all elements of the iterable from the HashSet.

removeAll(Iterable<Object?> it) → void

For example,

import 'dart:collection';

void main() {
  final hashSet = HashSet<String>();

  final vowels = ['A', 'E', 'I', 'O', 'U'];

  hashSet.addAll(vowels);

  hashSet.removeAll(['A', 'U', 'B']);

  print('Final HashSet: ${hashSet}');
}

It will print:

Final HashSet: {O, I, E}

Remove all elements of a HashSet:

The clear() method removes all the elements of a HashSet.

clear() → void

Example:

import 'dart:collection';

void main() {
  final hashSet = HashSet<String>();

  final vowels = ['A', 'E', 'I', 'O', 'U'];

  hashSet.addAll(vowels);

  hashSet.clear();

  print('Final HashSet: ${hashSet}');
}

Output:

Final HashSet: {}

Remove and retain all the elements with a function:

There are two methods removeWhere and retainWhere can be used to remove and retain all the elements of a HashSet with a given function.

removeWhere(bool fn(E e)) → void
retainWhere(bool fn(E e)) → void

For example,

import 'dart:collection';

void main() {
  final hashSet = HashSet<int>();

  final numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

  hashSet.addAll(numbers);

  hashSet.removeWhere((e) => e % 2 == 0);

  print('Final HashSet: ${hashSet}');
}

The function passed to the removeWhere method is checking if the current element is even or not, i.e. it will remove all the even numbers from the HashSet.

Output:

Final HashSet: {1, 3, 5, 7, 9}

If we replace removeWhere with retainWhere, it will keep the even numbers and remove the odd numbers.

Retain all the elements of an iterable:

There is one method called retainAll to retain all the elements of a given iterable. We need to pass one iterable to this method and it will remove the elements those are not in the iterable.

retainAll(Iterable<Object?> it) → void

Example program:

import 'dart:collection';

void main() {
  final hashSet = HashSet<int>();

  final numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

  hashSet.addAll(numbers);

  hashSet.retainAll([1, 2, 5, 6, 7, 20]);

  print('Final HashSet: ${hashSet}');
}

It will print:

Final HashSet: {1, 2, 5, 6, 7}

HashSet in Dart and its methods and properties

Mon, 03 Apr 2023 09:39:27 GMT

Introduction to HashSet in Dart:

The HashSet class of Dart is used for a hash-table based Set implementation. The Set collection is used to hold unique elements, i.e. we can’t have any duplicates in a set. The elements of a HashSet should provide an equivalence relation and should provide an implementation of hashCode.

It is unordered. So, the iteration order might differ. The HashSet class provides a couple of properties and methods.

Constructors of a HashSet:

There are four constructors available for a HashSet.

HashSet({bool equals(E, E)?, int hashCode(E)?, bool isValidKey(dynamic)?})

This constructor is used to create one HashSet and it uses the equals method as the equality method, hashCode method for the hash-code.

HashSet.from(Iterable it)

It creates one HashSet with all the items of the iterable it.

HashSet.identity()

It creates one identity-based HashSet.

HashSet.of(Iterable it)

Creates one HashSet with all the items of the iterable it.

Properties of a HashSet:

The following properties are available for a HashSet:

isEmpty → bool

Check if the HashSet is empty.

isNotEmpty → bool

Check if the HashSet is not empty.

length → int

Get the length of the HashSet.

first → E

Get the first element.

last → E

Get the last element.

single → E

Check if it has only one element and returns that.

iterator → Iterator

Get an iterator to iterate over the HashSet.

hashCode → int

Get the hashCode.

runtimeType → Type

Get the runtime type.

Methods of HashSet:

The following methods are available for a HashSet:

remove(Object? o) → bool

It removes the object o from the HashSet.

removeAll(Iterable<Object?> it) → void

Remove all the elements of the set.

clear() → void

It removes all elements of the HashSet

removeWhere(bool fn(E e)) → void

Removes all elements as defined by the function fn.

retainAll(Iterable<Object?> it) → void

Removes all elements that are not in the iterable it.

retainWhere(bool fn(E e)) → void

Removes all elements that are failed to the function fn.

add(E e) → bool

Add the element e to the HashSet.

addAll(Iterable it) → void

Adds all the elements of the iterable it to this set.

contains(Object? o) → bool

Check if the object o is in the HashSet or not.

containsAll(Iterable<Object?> it) → bool

This method can be used to check if all the items of the iterable are in the HashSet or not.

any(bool fn(E e)) → bool

Find if any element in the set satisfies the function fn.

every(bool fn(E e)) → bool

Find if all elements of the set satisfy the function fn.

elementAt(int i) → E

Return the element at index i of the HashSet.

firstWhere(bool fn(E element), {E orElse()?}) → E

Get the first element that satisfies the fn.

singleWhere(bool fn(E element), {E orElse()?}) → E

Get the single element that satisfies the fn.

lastWhere(bool fn(E element), {E orElse()?}) → E

Get the last element that satisfies the fn.

lookup(Object? o) → E?

Get the element equal to o in the set.

difference(Set<Object?> o) → Set

Get a new set with the elements that are in the current set but not in o.

intersection(Set<Object?> o) → Set

Get the intersection between the current set and o.

union(Set o) → Set

Get the union of the elements of the current set and the o.

skip(int count) → Iterable

Get one iterable by skipping the first count elements of the set.

skipWhile(bool fn(E e)) → Iterable

Get one iterable by skipping all the elements defined by the function fn.

forEach(void fn(E e)) → void

Call the function fn on each of the elements of the set.

map(T toElement(E e)) → Iterable

Modify the elements by the toElement function.

take(int count) → Iterable

Get one lazy iterable of the first count elements of the set.

takeWhile(bool fn(E e)) → Iterable

Get one lazy iterable of the first elements defined by the function fn.

where(bool fn(E e)) → Iterable

Get one lazy iterable of the elements satisfied by the predicate fn.

whereType() → Iterable

Get one lazy iterable of the elements of type T.

followedBy(Iterable it) → Iterable

Get one lazy iterable of this set and it.

reduce(E combine(E v, E e)) → E

Reduce the set to a single value by combining iteratively with the combine function.

fold(T initial, T combine(T previous, E element)) → T

It is similar to the reduce function, but it uses an initial value with the combine function.

expand(Iterable toElements(E e)) → Iterable

Expand each of the items of the set to one or more elements.

join([String separator = ""]) → String

Returns one string by concatenating the elements of the HashSet. It converts the elements to string.

toList({bool growable = true}) → List

It returns one list with the set elements.

toSet() → Set

Get one set with the elements of the HashSet.

toString() → String

Get the string representation of the HashSet.

cast() → Set

Get a set of R instance.

noSuchMethod(Invocation invocation) → dynamic

This is invoked if any undefined method is called.

How to iterate a HashMap in Dart in different ways

Sat, 01 Apr 2023 09:39:27 GMT

How to iterate a HashMap in Dart:

This post will show you how to iterate over a HashMap in Dart with examples. We can use the forEach method to iterate over a HashMap. Let’s understand how forEach works.

Definition and example of forEach:

The forEach method is defined as:

forEach(void f(K k, V v)) → void

We can pass one function to the forEach method. It will use that function with each pairs of the HashMap.

import 'dart:collection';

void main() {
  final Map<int, String> hashMap =
      HashMap.from({1: "one", 2: "two", 3: "three", 4: "four", 5: "five"});

  print("Following are the contents of the HashMap: ");
  hashMap.forEach((k, v) => print('{${k}, ${v}}'));
}

It will print:

Following are the contents of the HashMap: 
{1, one}
{2, two}
{3, three}
{4, four}
{5, five}

How to use forEach to iterate over the keys of a HashMap:

We can get the keys of a HashMap with the keys property. This returns an iterable:

Iterable<K> get keys

We can use a forEach loop to iterate over these keys:

import 'dart:collection';

void main() {
  final Map<int, String> hashMap =
      HashMap.from({1: "one", 2: "two", 3: "three", 4: "four", 5: "five"});

  print("Following are the keys of the HashMap: ");

  final keys = hashMap.keys;

  keys.forEach((k) => print(k));
}

Output:

How to use forEach to iterate over the values of a HashMap:

Similar to the above example, we can also read the values of a HashMap to get all values. It returns one Iterable:

Iterable<V> get values;

As this is an Iterable, we can use a forEach loop to iterate over the values:

import 'dart:collection';

void main() {
  final Map<int, String> hashMap =
      HashMap.from({1: "one", 2: "two", 3: "three", 4: "four", 5: "five"});

  print("Following are the values of the HashMap: ");

  final values = hashMap.values;

  values.forEach((v) => print(v));
}

It will print the values:

Following are the values of the HashMap: 
one
two
three
four
five

If we have to check anything in the values or keys of a HashMap, we can iterate over its values or keys instead of iterating over its key-value pairs.

Reference:

HashMap class Flutter doc

How to add and remove items of a HashMap in Dart

Fri, 31 Mar 2023 09:39:27 GMT

How to add and remove items of a HashMap in Dart:

In this post, we will learn how to add and remove items from a HashMap in Dart. There are different ways to add and remove items from a Dart HashMap.

How to add items to a HashMap with a square bracket operator:

We can use the [] operator to add key-value pairs to a HashMap. We need to put the key in the operator and the value can be assigned with an equal operator.

For example:

import 'dart:collection';

void main() {
  final Map<int, String> hashMap = HashMap();

  hashMap[1] = "one";
  hashMap[2] = "two";
  hashMap[3] = "three";
  hashMap[4] = "four";
  hashMap[5] = "five";

  print("HashMap: ${hashMap}");
}

It created one empty HashMap and inserted five key-value pairs into the HashMap. It will print:

HashMap: {1: one, 2: two, 3: three, 4: four, 5: five}

Add items with addAll():

The addAll method takes one Map as its parameter and adds the key-value pairs of the Map to the HashMap.

addAll(Map<K, V> o) → void

This method is useful to add multiple key-value pairs to a HashMap in one go. For example,

import 'dart:collection';

void main() {
  final Map<int, String> hashMap = HashMap();

  hashMap.addAll({1: "one", 2: "two", 3: "three", 4: "four", 5: "five"});

  print("HashMap: ${hashMap}");
}

It will print:

HashMap: {1: one, 2: two, 3: three, 4: four, 5: five}

Add items with addEntries:

With this method, we can add the pairs of a given entries. This is defined as:

addEntries(Iterable<MapEntry<K, V>> e) → void

For example,

import 'dart:collection';

void main() {
  final Map<int, String> hashMap = HashMap();
  final data = {1: "one", 2: "two", 3: "three", 4: "four", 5: "five"};

  hashMap.addEntries(data.entries);

  print("HashMap: ${hashMap}");
}

It will print:

putIfAbsent:

This method adds one pair if the provided key is not found in the HashMap. Else, it returns the pair found in the HashMap.

V putIfAbsent(K key, V ifAbsent())

The ifAbsent is a method to get the value for the key. It will add the pair if the key is not found in the HashMap.

import 'dart:collection';

String ifAbsent() {
  return "six";
}

void main() {
  final Map<int, String> hashMap = HashMap();
  final data = {1: "one", 2: "two", 3: "three", 4: "four", 5: "five"};

  hashMap.addAll(data);
  final returnValue = hashMap.putIfAbsent(6, ifAbsent);

  print("Return value: ${returnValue}, HashMap: ${hashMap}");
}

In this example, since 6 is not in the HashMap, it will add the pair {6, “six”} to it. The return value of putIfAbsent is “six”.

It will print:

Return value: six, HashMap: {1: one, 2: two, 3: three, 4: four, 5: five, 6: six}

Now, if we try to add {5, “six”} to the hashmap, it will fail:

import 'dart:collection';

String ifAbsent() {
  return "six";
}

void main() {
  final Map<int, String> hashMap = HashMap();
  final data = {1: "one", 2: "two", 3: "three", 4: "four", 5: "five"};

  hashMap.addAll(data);
  final returnValue = hashMap.putIfAbsent(5, ifAbsent);

  print("Return value: ${returnValue}, HashMap: ${hashMap}");
}

It will fail to add as 5 is already there in the hashmap. The returned value will be ‘five’, i.e. the value of the key 5 in the hashmap.

It will print:

Return value: five, HashMap: {1: one, 2: two, 3: three, 4: four, 5: five}

How to remove a single object from the HashMap:

We can use the remove method to remove a single object from a HashMap. This method takes the key as its parameter and removes the key-value pair if the key is found in the HashMap.

remove(Object? k) → V?

It returns the value.

import 'dart:collection';

void main() {
  final Map<int, String> hashMap = HashMap();
  final data = {1: "one", 2: "two", 3: "three", 4: "four", 5: "five"};

  hashMap.addAll(data);
  print("Original HashMap: ${hashMap}");

  final removedValue = hashMap.remove(5);

  print("Removed value: ${removedValue}, HashMap: ${hashMap}");
}

It will remove the pair with key 5 from the HashMap.

Output:

Original HashMap: {1: one, 2: two, 3: three, 4: four, 5: five}
Removed value: five, HashMap: {1: one, 2: two, 3: three, 4: four}

Remove multiple values from a HashMap with a given condition:

The removeWhere method takes one function and removes all elements for those it returns true.

removeWhere(bool f(K k, V v)) → void

For example,

import 'dart:collection';

bool canRemove(int key, String value) {
  return key % 2 == 0;
}

void main() {
  final Map<int, String> hashMap = HashMap();
  final data = {1: "one", 2: "two", 3: "three", 4: "four", 5: "five"};

  hashMap.addAll(data);
  print("Original HashMap: ${hashMap}");

  hashMap.removeWhere(canRemove);

  print("Final HashMap: ${hashMap}");
}

In this example, we are passing the canRemove function to the removeWhere method. It will remove all the pairs with a key with even value.

It will print:

Original HashMap: {1: one, 2: two, 3: three, 4: four, 5: five}
Final HashMap: {1: one, 3: three, 5: five}

Remove all items of a HashMap:

The clear method removes all the items of a HashMap.

clear() → void

Example:

import 'dart:collection';

void main() {
  final Map<int, String> hashMap = HashMap();
  final data = {1: "one", 2: "two", 3: "three", 4: "four", 5: "five"};

  hashMap.addAll(data);
  print("Original HashMap: ${hashMap}");

  hashMap.clear();

  print("Final HashMap: ${hashMap}");
}

It will print:

Original HashMap: {1: one, 2: two, 3: three, 4: four, 5: five}
Final HashMap: {}

Reference:

HashMap class Flutter doc

Dart HashMap explanation with examples

Thu, 30 Mar 2023 09:39:27 GMT

Introduction to HashMap<K,V> class in Dart:

The HashMap class can be used to store key-value pairs. We can use the keys to access and modify its values.

The keys of a HashMap can be any object but they should implement the Object.== and Object.hashCode methods.

The HashMap is an unordered implementation. So the iteration doesn’t follow any order. If the map is modified, the iteration order changes.

Constructors of HashMap:

We can create a HashMap in different ways. Following are the constructors available:

HashMap({bool equals(K, K)?, int hashCode(K)?, bool isValidKey(dynamic)?})

This constructor creates a HashMap.

HashMap.from(Map o)

Create one HashMap from another Map o with the same key-value pairs.

HashMap.fromEntries(Iterable<MapEntry<K, V>> e)

Create one HashMap from the given iterable entries.

HashMap.fromIterable(Iterable iterable, {K key(dynamic element)?, V value(dynamic element)?})

Creates one HashMap from the Iterable.

HashMap.fromIterables(Iterable k, Iterable v)

Creates a HashMap associating the keys k to values v.

HashMap.identity()

Creates an unordered identity-based map.

HashMap.of(Map<K, V> o)

Create one HashMap containing the key-value pairs of the Map o.

Properties of HashMap:

Following properties are available in a dart HashMap:

entries → Iterable<MapEntry<K, V>>

It is the entries of this HashMap.

hashCode → int

It holds the hash code.

isEmpty → bool

It is a boolean value, true if the HashMap is empty, false otherwise.

isNotEmpty → bool

It is the opposite of isEmpty.

keys → Iterable

It is the keys of the HashMap.

length → int

Length of the HashMap.

values → Iterable

The values of the HashMap.

runtimeType → Type

Runtime type of the HashMap.

Methods of HashMap:

Following methods are available for a HashMap:

containsKey(Object? k) → bool

Checks if the key k is in the HashMap or not.

addAll(Map<K, V> m) → void

This method adds all the key-value pairs of another map m to the current HashMap.

containsValue(Object? v) → bool

Check if the value v is in the HashMap or not.

addEntries(Iterable<MapEntry<K, V>> e) → void

Add the key-value pairs of the entries e to the HashMap.

forEach(void f(K k, V v)) → void

Use the function f on each item of the HashMap.

cast<RK, RV>() → Map<RK, RV>

Get a view of this map.

map<K2, V2>(MapEntry<K2, V2> convert(K k, V v)) → Map<K2, V2>

It converts the current HashMap to a new Map by using the given convert function.

update(K k, V update(V v), {V ifAbsent()?}) → V

It updates the value v for the key k.

clear() → void

It removes all items from the HashMap.

noSuchMethod(Invocation i) → dynamic

This method is invoked when we try to access any invalid method or property of the HashMap.

updateAll(V update(K k, V v)) → void

This method updates all values.

putIfAbsent(K k, V ifAbsent()) → V

It checks for the key k in the HashMap and adds it if not found.

remove(Object? k) → V?

It removes the pair with key k from the HashMap if found in the HashMap.

removeWhere(bool f(K k, V v)) → void

It removes all pairs from a map for those the function f returns true.

toString() → String

Get the string representation.

Reference:

HashMap class Flutter doc

Dart Queue reduce function example

Wed, 29 Mar 2023 09:39:27 GMT

Dart Queue reduce function:

The reduce function will reduce one queue to a single value, it takes one combine function and it combines all elements to a single value. In this post, we will learn how reduce function works with different examples.

Syntax of the reduce function:

The syntax of the reduce function is:

reduce(E combine(E value, E element)) → E

It takes one function combine and with the help of this function, it will reduce the queue elements to a single value. It is a method defined for dart iterable. It starts with the first element and uses the combine function to combine all other values to reduce it to a single value. If the queue has only one element, it will return that element.

Example of the reduce function to find the sum of all values:

The following program uses the reduce method to find the sum of all digits of the given queue:

import 'dart:collection';

void main() {
  var q = Queue.of([1, 2, 3, 4, 5]);
  print("Given queue: ${q}");

  var sum = q.reduce((v, e)=> v + e);
  print("Sum: ${sum}");
}

In this program, q is the given queue of numbers. The reduce function returns the sum of the two values passed as its parameters.

If you run this program, it will print:

Given queue: {1, 2, 3, 4, 5}
Modified queue: 15

As you can see here, it is printing the total sum of the digits of the queue.

Example of the reduce function with objects:

Let’s try the reduce function with a queue of objects:

import 'dart:collection';

class Item {
  String? name;
  int? price;

  Item(String name, int price) {
    this.name = name;
    this.price = price;
  }
}

void main() {
  var q =
      Queue.of([Item("Item-1", 100), Item("Item-2", 24), Item("Item-3", 55)]);

  var result =
      q.reduce((value, element) => Item("", value.price! + element.price!));
  print("Sum of all prices: ${result.price}");
}

Here,

Item is a class to hold the name and price of an item.
We created one queue, q, of three different items with different prices.
The combine function should return a Item object. It adds the price of both value and element objects and creates a new object.
The reduced value is assigned to the result variable.

If you run this program, it will print:

Sum of all prices: 179

i.e. the final Item variable holds the sum of the prices of all the objects.

Refer:

Flutter Queue Doc

How to remove and retain items from Queue in Dart with condition

Mon, 27 Mar 2023 09:39:27 GMT

How to remove and retain items from Queue with given conditions in Dart:

In this post, I will show you how to remove and retain items of a Queue in Dart by using a specific condition. The Queue class provides two methods to remove and retain the Queue items by using a condition.

removeWhere and
retainWhere

Let’s learn how to use these methods with examples.

removeWhere:

This method takes one function and removes all the elements those are matched by the function. It is defined as:

removeWhere(bool removeFunction(E e)) -> void

The removeFunction is the function we need to pass to this method.

Example of removeWhere:

Let’s try it with an example:

import 'dart:collection';

void main() {
  var givenQueue = Queue.of([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
  givenQueue.removeWhere((e) => e % 3 == 0);

  print(givenQueue);
}

In this program, the givenQueue variable holds one queue of few numbers. We are removing all the elements which are divisible by 3. It modifies the original queue.

If you run this program, it will print:

{1, 2, 4, 5, 7, 8, 10}

We can also write a separate function to check each number:

import 'dart:collection';

bool canRemove(int n) {
  return n % 3 == 0;
}

void main() {
  var givenQueue = Queue.of([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
  givenQueue.removeWhere(canRemove);

  print(givenQueue);
}

Example of removeWhere with a Queue of objects:

Let’s try removeWhere with objects. The following program creates one queue of objects and remove objects based on a certain condition:

import 'dart:collection';

class Student {
  String? name;
  int? age;
  String? gender;

  Student(String name, int age, String gender) {
    this.name = name;
    this.age = age;
    this.gender = gender;
  }

  @override
  String toString() {
    return "[Name: ${this.name}, Age: ${this.age}, Gender: ${this.gender}]";
  }
}

bool isMale(Student s) {
  return s.gender == "Male";
}

void main() {
  var givenQueue = Queue.of([Student("Alex", 10, "Male"), Student("Daisy", 14, "Female"), Student("Bob", 9, "Male")]);
  print("Given queue: ${givenQueue}");
  
  givenQueue.removeWhere(isMale);
  print("Modified queue: ${givenQueue}");
}

In this program,

We created a class Student to hold the name, age and gender of a student.
The givenQueue is a Queue object of three different Student objects.
The removeWhere is removing all Male students from the queue.

If you run this program, it will print:

retainWhere:

The retainWhere method is similar to removeWhere. It takes one function and removes all items from the queue for those the function returns false. It is opposite to removeWhere.

Let’s try this method with an example:

import 'dart:collection';

class Car {
  String? color;

  Car(String color) {
    this.color = color;
  }

  @override
  String toString() {
    return "[Car color: ${this.color}]";
  }
}

bool isRedOrWhite(Car c) {
  return c.color == "Red" || c.color == "White";
}

void main() {
  var givenQueue = Queue.of(
      [Car("Red"), Car("Blue"), Car("Green"), Car("Black"), Car("White")]);
  print("Given queue: ${givenQueue}");

  givenQueue.retainWhere(isRedOrWhite);
  print("Modified queue: ${givenQueue}");
}

The Car can hold the color of a car.
We created one Queue with five different Car objects.
The retainWhere is using the isRedOrWhite function to retain only cars with Red or White color.

If you run this program, it will print:

Given queue: {[Car color: Red], [Car color: Blue], [Car color: Green], [Car color: Black], [Car color: White]}
Modified queue: {[Car color: Red], [Car color: White]}

Refer:

Flutter Queue Doc

How to add and remove items from a Queue in Dart

Sun, 26 Mar 2023 09:39:27 GMT

How to add and remove items from a Queue in Dart:

The Queue class of Dart can be used to create a queue. There are different methods available to add and remove items from a queue. In this post, we will learn how to create a Queue and how to remove and add items from it with different examples.

How to create a queue with elements:

We can create an empty queue with the Queue() constructor. There is one more constructor available to create a queue with all elements from an iterable. It is:

Queue.from(Iterable it)

You can also use Queue.of:

Queue.of(Iterable<E> it)

import 'dart:collection';

void main() {
  var q = Queue.of([1, 2, 3, 4]);
  print(q);
}

It keeps adding the elements of the iterable to the end of the queue. It will print:

{1, 2, 3, 4}

Add a single element with add():

The add() method takes one single element and adds it to the queue. It is defined as:

add(E e) -> void

Let’s try it with an example:

import 'dart:collection';

void main() {
  var q = Queue();
  q.add(1);
  q.add(2);
  print(q);
}

It will add 1 and 2 to the queue. It will print:

{1, 2}

Add all elements of an iterable, addAll:

The addAll method adds all elements of an iterable to the end of the queue. It is defined as:

addAll(Iterable<E> it) -> void

Example:

import 'dart:collection';

void main() {
  var q = Queue();
  q.addAll([1, 2, 3, 4]);
  q.addAll([5, 6]);
  
  print(q);
}

Output:

{1, 2, 3, 4, 5, 6}

Add elements to the beginning and end of a queue:

The Queue class provides two methods to add an element to the start and end of a queue. These are:

addFirst(E e) -> void
addLast(E e) -> void

For example,

import 'dart:collection';

void main() {
  var q = Queue.of([1, 2, 3, 4]);
  q.addFirst(0);
  q.addLast(5);

  print(q);
}

It created the queue q with Queue.of and added 0 to the start and 5 to the end.

Output:

{0, 1, 2, 3, 4, 5}

Remove all elements from a queue:

The clear() method removes all elements of a queue:

import 'dart:collection';

void main() {
  var q = Queue.of([1, 2, 3, 4]);
  q.clear();

  print(q);
}

It will print:

{}

Remove a single item from a queue:

We can pass an object to the remove method to remove a single instance from the queue.

import 'dart:collection';

void main() {
  var q = Queue.of([1, 2, 3, 4]);
  q.remove(2);

  print(q);
}

It will print:

{1, 3, 4}

It removes a single instance of the value. If we have two instances, it will remove only one:

import 'dart:collection';

void main() {
  var q = Queue.of([1, 2, 3, 4, 2]);
  q.remove(2);

  print(q);
}

It will remove only the first 2:

{1, 3, 4, 2}

Remove the first and the last element of a queue:

We can use the following methods to remove the first and the last elements of a queue:

removeFirst() -> E

removeLast() -> E

For example:

import 'dart:collection';

void main() {
  var q = Queue.of([1, 2, 3, 4, 5]);
  q.removeFirst();
  q.removeLast();

  print(q);
}

It will remove 1 and 5.

{2, 3, 4}

Remove specific elements with removeWhere:

The removeWhere function takes one function as its parameter and removes all elements for those the function returns true. Its syntax is:

removeWhere(bool fn(E e)) -> void

Example:

import 'dart:collection';

void main() {
  var q = Queue.of([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
  q.removeWhere((e) => e % 2 == 0);

  print(q);
}

This program will remove all even items from the queue.

{1, 3, 5, 7, 9}

Refer:

Flutter Queue Doc

Introduction to Queue in Dart and its methods

Sat, 25 Mar 2023 09:39:27 GMT

How to implement Queue in dart:

The dart:collection library provides a class Queue to implement the Queue data structure. It also provides a couple of methods to iterate, add, remove items and a few properties to access different states of a Queue. In this post, we will learn how to use this class and its methods and properties with examples.

Constructor to create a Queue object:

The Queue class provides three constructors to create one object:

Queue()

This is the default constructor, it creates one queue.

Queue.from(Iterable it)

By using this constructor, we can create one Queue from a given iterable. It will include the elements of the iterable to the Queue.

Queue.of(Iterable it)

It will create a Queue from the elements of the Iterable it.

Properties of Queue:

The following properties are available for a Queue:

first:

It returns the first element of the Queue.

last:

It returns the last element of the Queue.

hashCode:

It returns the hash code of the queue object.

isEmpty:

It returns one boolean value defining if the queue is empty or not.

isNonEmpty:

It returns one boolean defining if the queue is not empty or empty.

iterator:

It returns one iterator to iterate over the elements of the queue.

length:

It returns an integer value holding the total number of elements in the queue.

single:

It checks if the queue has only one element or not and returns that element if yes.

runtimeType:

The runtime type of the queue object.

Methods of Queue:

The following methods are defined in the Queue class:

add(E e) -> void

It adds one element e at the end of the queue.

addAll(Iterable it) -> void

This method adds all the elements of the iterable to the end of the queue.

addFirst(E e) -> void

It adds the element to the start of the queue.

addLast(E e) -> void

It adds the element to the end of the queue.

clear() -> void

This method removes all elements from the queue.

remove(Object o) -> bool

This method removes one instance of the object o from the queue.

removeFirst() -> E

This method removes the first element of the queue and returns this.

removeLast() -> E

This method removes the last element of the queue and returns that element.

removeWhere(bool fn(E e)) -> void

This method takes one function and removes all elements matched by the function from the queue.

retainWhere(bool fn(E e)) -> void

This method removes all elements not matched by the function fn.

Inherited methods:

Other than the above methods, there are a couple of inherited methods of Queue:

any(bool test(E e)) -> bool

This method can be used to check if any element of the queue satisfies the provided function or not.

elementAt(int i) -> E

This method returns the element at index i of the queue.

contains(Object? e) -> bool

This method checks if the queue contains any element equal to e or not.

every(bool fn(E e)) -> bool

This method takes one function and checks if every element satisfies the function or not.

firstWhere(bool fn(E e), {E orElse()?}) -> E

Returns the first element of the queue satisfied by the given predicate.

expand(Iterable toElements(E e)) -> Iterable

Expands each element of the queue to zero or more elements.

fold(T initialValue, T combine(T previousValue, E element)) → T

Reduce the queue to a single value by combining each element iteratively.

followedBy(Iterable o) → Iterable

Get a lazy concatenation of this queue and another queue.

forEach(void action(E element)) → void

Use this to iterate over the queue elements.

join([String separator = ""]) → String

Get a string by concatenating the elements of the queue.

lastWhere(bool fn(E element), {E orElse()?}) → E

Get the last element that satisfies the provided predicate.

map(T toElement(E e)) → Iterable

Get the elements of the queue.

noSuchMethod(Invocation invocation) → dynamic

This method is invoked if we try to access a non-existent property or method.

reduce(E combine(E value, E element)) → E

Reduce the queue to a single value by iterating and combining the elements with the help of the combine function.

singleWhere(bool fn(E element), {E orElse()?}) → E

Get the element that is satisfied by the function fn.

skip(int n) → Iterable

Get one iterable with all the elements skipped by the first n elements.

skipWhile(bool fn(E value)) → Iterable

Get one iterable by skipping the elements satisfied by the function fn.

take(int n) → Iterable

Get a lazy iterable of the first n elements of the queue.

takeWhile(bool fn(E value)) → Iterable

Get a lazy iterable of the elements satisfying the function fn.

toList({bool growable = true}) → List

Get one List with queue elements.

toSet() → Set

Get one Set with the queue elements.

toString() → String

Get the string representation.

where(bool fn(E element)) → Iterable

It returns one lazy iterable with all the elements satisfies the predicate.

whereType() → Iterable

It returns one new lazy iterable.

Refer:

Flutter Queue Doc

5 ways in Dart to print the multiplication table

Fri, 24 Mar 2023 09:39:27 GMT

Write a dart program to print the multiplication table for a given number:

This post will show you how to write a program in dart to print the multiplication table for any given number. We can take the number as an input from the user or we can use a constant number.

We need to use a loop to write this program. You will learn how to take user inputs and how to use different loops in dart.

Method 1: By using a for loop:

We can use a for loop to print the table. The syntax of for loop is:

for(<initialization>, <condition>, <end-operation>){
    //loop content
}

It has three parts.

In the initialization, we initialize a constant.
In the condition, it checks for a condition and keeps running the content of the loop until this condition is true.
In the end-operation, it performs certain operations at the end of each iteration.

We can use a for loop to print the multiplication table for a number as below:

void main() {
  int n = 10;

  for (var i = 1; i <= 10; i++) {
    print("${n}*${i}=${n * i}");
  }
}

If you run this program, it will print:

10*1=10
10*2=20
10*3=30
10*4=40
10*5=50
10*6=60
10*7=70
10*8=80
10*9=90
10*10=100

This program can be changed to take the number as input from the user:

import 'dart:io';

void main() {
  print("Enter a number: ");
  int n = int.parse(stdin.readLineSync()!);

  for (var i = 1; i <= 10; i++) {
    print("${n}*${i}=${n * i}");
  }
}

It will print:

Enter a number: 
12
12*1=12
12*2=24
12*3=36
12*4=48
12*5=60
12*6=72
12*7=84
12*8=96
12*9=108
12*10=120

Method 2: By using a while loop:

Similar to for-loops, we can also use while loops in dart. The while loop checks for a condition and runs until the condition is true. The following program uses a while loop to print the multiplication table for a number:

import 'dart:io';

void main() {
  print("Enter a number: ");
  int n = int.parse(stdin.readLineSync()!);

  var i = 1;
  while (i <= 10) {
    print("${n}*${i}=${n * i}");
    i++;
  }
}

You can see that we are initializing the value of i before the loop starts and its value is incremented by 1 at the end of each iteration. The loop runs until the value of i is less than or equal to 10.

It will print similar output as the previous example.

Enter a number: 
13
13*1=13
13*2=26
13*3=39
13*4=52
13*5=65
13*6=78
13*7=91
13*8=104
13*9=117
13*10=130

By using do..while loop:

The do..while loop runs the code in the do block and then it checks the while condition. The following program uses do..while loop to print the multiplication table:

import 'dart:io';

void main() {
  print("Enter a number: ");
  int n = int.parse(stdin.readLineSync()!);

  var i = 1;
  do {
    print("${n}*${i}=${n * i}");
    i++;
  } while (i <= 10);
}

Output:

Enter a number: 
9
9*1=9
9*2=18
9*3=27
9*4=36
9*5=45
9*6=54
9*7=63
9*8=72
9*9=81
9*10=90

Method 4: By using for..in loop:

The for..in loop takes one iterator and iterates over the items of the iterator. We can create one list of numbers from 1 to 10 and iterate over the list to print the multiplication table.

import 'dart:io';

void main() {
  print("Enter a number: ");
  int n = int.parse(stdin.readLineSync()!);

  var numberList = List<int>.generate(10, (i) => i + 1);

  for (var i in numberList) {
    print("${n}*${i}=${n * i}");
  }
}

The numberList is the list of integers 1, 2, 3, 4, 5, 6, 7, 8, 9, 10. The for..in loop iterates over this list and prints the multiplication table for the given number.

It will print:

Enter a number: 
6
6*1=6
6*2=12
6*3=18
6*4=24
6*5=30
6*6=36
6*7=42
6*8=48
6*9=54
6*10=60

Method 5: By using forEach loop:

Similar to the for..in loop, we can also use the forEach loop. It will iterate over the list elements to print the multiplication table:

import 'dart:io';

void main() {
  print("Enter a number: ");
  int n = int.parse(stdin.readLineSync()!);

  var numberList = List<int>.generate(10, (i) => i + 1);

  numberList.forEach((var i) => print("${n}*${i}=${n * i}"));
}

Output:

Enter a number:
3
3*1=3
3*2=6
3*3=9
3*4=12
3*5=15
3*6=18
3*7=21
3*8=24
3*9=27
3*10=30

Dart StringBuffer class explanation with examples

Thu, 23 Mar 2023 09:39:27 GMT

StringBuffer class in Dart:

The StringBuffer class of Dart is used to concatenate strings efficiently in Dart. In this post, we will learn how to use the StringBuffer class of dart with examples.

Constructor of StringBuffer:

The constructor of StringBuffer is:

StringBuffer([Object content = ""])

We have to pass the content to the StringBuffer constructor and it creates a StringBuffer with the given content.

For example:

void main() {
  final buffer = StringBuffer('Hello World!!');
  print(buffer);
}

It will create one StringBuffer object buffer. The parameter is optional. It will create the StringBuffer even if you don’t pass it to the constructor.

This program will print:

Hello World!!

How to add strings to the StringBuffer:

We can use the write function to add a string to the StringBuffer. It is defined as:

write(Object? object) → void

The below example shows how to use the write function:

void main() {
  final buffer = StringBuffer();
  buffer.write("Hello ");
  buffer.write("World ");
  buffer.write(123);

  print(buffer);
}

It will print:

Hello World 123

How to add a newline:

We can use the writeln method to write one object with a new line at the end.

It is defined as:

writeln([Object? obj = ""]) → void

Let’s try it with an example:

void main() {
  final buffer = StringBuffer();
  buffer.writeln("Hello");
  buffer.writeln();
  buffer.writeln("World");

  print(buffer);
}

It will add one new line at the end with the string. It will print:

Hello

World

How to add an iterable of objects:

There is one method in the StringBuffer class called writeAll that can be used to add all objects of an iterable.

writeAll(Iterable objects, [String separator = ""]) → void

Optionally, it also takes one separator as the second parameter. It will write all objects separated by the given separator.

void main() {
  final buffer = StringBuffer();
  buffer.writeAll([1, 2, 3, 4, 5], '-');

  print(buffer);
}

It will print:

1-2-3-4-5

How to get the length of the StringBuffer:

The length property returns the length of a StringBuffer. This is an integer property.

void main() {
  final buffer = StringBuffer();
  buffer.write("Hello");

  print(buffer.length);
}

It will print 5.

How to write character code to a StringBuffer:

The writeCharCode method of the StringBuffer class can write the string representation of a character code to the buffer.

writeCharCode(int charCode) → void

We can use this method as below:

void main() {
  final buffer = StringBuffer();
  buffer.writeCharCode(72);
  buffer.writeCharCode(101);
  buffer.writeCharCode(108);
  buffer.writeCharCode(108);
  buffer.writeCharCode(111);

  print(buffer);
}

It will print Hello.

How to clear a StringBuffer:

We can use the clear() method to clear a buffer.

void main() {
  final buffer = StringBuffer();
  buffer.write("Hello");

  print(buffer.length); //5

  buffer.clear();

  print(buffer.length); //0
}

The length of the buffer is 0 once it is cleared.

How to check if a StringBuffer is empty or not:

There are two properties to check if a StringBuffer is empty or not:

isEmpty -> bool

isNonEmpty -> bool

Both of these return boolean values.

How to create a string from ASCII values in Dart

Wed, 22 Mar 2023 09:39:27 GMT

Dart program to create a string from ASCII values:

The full form of ASCII is American Standard Code for Information Interchange. It is a character encoding standard for electronic communication(wikipedia). For example, the ASCII value of A is 65 and Z is 90.

You may face scenarios where you need to build the string from a list of ASCII values in your Flutter app. For example, if the server is sending the data in ASCII format, you need to convert it to a user-readable format. Or, you can convert a string to a list of ASCII values and send that to the server. Both of these can be achieved easily in Dart.

Let’s learn how to convert a list of ASCII values to a string and vice versa.

Example 1: By using String.fromCharCode() method:

We can use the fromCharCode method defined in the String class to convert a ASCII value to a string. If the ASCII values are given in a list, we can iterate over the list items and build the final string.

void main() {
  List<int> input = [
    72,
    101,
    108,
    108,
    111,
    32,
    87,
    111,
    114,
    108,
    100,
    33,
    33
  ];
  String result = "";

  for (int i in input) {
    result += String.fromCharCode(i);
  }

  print("Given String: " + result);
}

In this example, input is the given list of ASCII values. We used a for loop to iterate over the numbers of the list and appended the decoded string to the final string result.

If you run this program, it will print:

Example 2: By using String.fromCharCodes() method:

We can also use the String.fromCharCodes method, which takes an array of values and returns the final string. This is a better approach than the previous one because we don’t have to run a loop to iterate over the characters.

void main() {
  List<int> input = [
    72,
    101,
    108,
    108,
    111,
    32,
    87,
    111,
    114,
    108,
    100,
    33,
    33
  ];
  String result = String.fromCharCodes(input);

  print("Given String: " + result);
}

It will print:

Given String: Hello World!!

Example 3: Converting a string to a list of ASCII values:

The codeUnitAt method of dart string takes one index as its parameter and returns the ASCII value at that index. We can iterate over the string indices and append all ASCII values of all the indices to get the final list of ASCII values.

void main() {
  String inputStr = "Hello World!!";
  List<int> result = [];

  for (int i = 0; i < inputStr.length; i++) {
    result.add(inputStr.codeUnitAt(i));
  }

  print("Final list: " + result.toString());
}

Here, result is the final list of integers. The for loop is iterating over the indices of the string and adds the ASCII values of each character to the final list.

It will print:

Final list: [72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33, 33]

Example 4: codeUnits property of string:

There is also another property called codeUnits that returns a list of code units of the string. We can use this property directly instead of using a loop to get the list of ASCII values.

void main() {
  String inputStr = "Hello World!!";
  List<int> result = inputStr.codeUnits;

  print("Final list: " + result.toString());
}

It will print:

Final list: [72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33, 33]

C++ program to find the smallest and the second smallest numbers

Tue, 21 Mar 2023 09:39:27 GMT

Find the smallest and the second smallest numbers in an array in C++:

We will learn how to find the smallest and second smallest numbers in an array of numbers in C++. For example, if the array is [1, 3, 5, 7, 2], the smallest number will be 1 and the second smallest number will be 2.

We can solve it in different ways. One traditional approach is to use two variables to hold the smallest and second smallest numbers and update the values with a loop. Another way is to sort the array and pick the first and the second element from the sorted array. Let’s learn how to write the programs for both of these approaches.

Method 1: By using a loop:

The program will follow the below steps:

Initialize two variables to hold the smallest and second smallest numbers.
Assign INT_MAX to both of these variables. So, the smallest and the second smallest values will be the maximum integer value when the program starts.
Start a loop from the first element to the end of the array. On each iteration, compare the current value pointed by the loop with the smallest and second smallest variables.
- If it is smaller than both of these variables, assign the smallest variable value to the second smallest variable and assign the current number to the smallest variable.
- If it is smaller than the second smallest variable, assign it to the second smallest variable.
Once the loop ends, print the smallest and second smallest variables, which are the required values.

#include <iostream>
#include <climits>
using namespace std;

int main()
{
    int arr[8] = {1, 4, 2, 7, 4, 12, 0, 9};
    int smallest = INT_MAX;
    int secondSmallest = INT_MAX;

    for (int i = 0; i < size(arr); i++)
    {
        if (arr[i] < smallest && arr[i] < secondSmallest)
        {
            secondSmallest = smallest;
            smallest = arr[i];
        }
        else if (arr[i] < secondSmallest)
        {
            secondSmallest = arr[i];
        }
    }

    cout << "Smallest value: " << smallest << endl;
    cout << "Second smallest value: " << secondSmallest << endl;
}

The arr is the given array of integers. It is following the same steps we have discussed above. It will print:

Method 2: By using loop and user input values:

We can take the numbers as inputs from the user. The following program takes the numbers as inputs and insert these numbers to the array before it finds the smallest and second smallest values:

#include <iostream>
#include <climits>
using namespace std;

int main()
{
    int size, arr[100];
    int smallest = INT_MAX;
    int secondSmallest = INT_MAX;

    cout << "Enter the size of the array: " << endl;
    cin >> size;

    for (int i = 0; i < size; i++)
    {
        cout << "Enter the number for index " << i << ": ";
        cin >> arr[i];
    }

    for (int i = 0; i < size; i++)
    {
        if (arr[i] < smallest && arr[i] < secondSmallest)
        {
            secondSmallest = smallest;
            smallest = arr[i];
        }
        else if (arr[i] < secondSmallest)
        {
            secondSmallest = arr[i];
        }
    }

    cout << "Smallest value: " << smallest << endl;
    cout << "Second smallest value: " << secondSmallest << endl;
}

If you run this program, it will give results as below:

Method 3: By sorting the array elements:

If we sort the array elements in ascending order, the first element of the sorted array will be the smallest element and the second element will be the second smallest element of the array. We can use the inbuilt std::sort() function to sort the array.

#include <iostream>
using namespace std;

int main()
{
    int size, arr[100];
    cout << "Enter the size of the array: " << endl;
    cin >> size;

    for (int i = 0; i < size; i++)
    {
        cout << "Enter the number for index " << i << ": ";
        cin >> arr[i];
    }

    sort(arr, arr + size);

    int smallest = arr[0];
    int secondSmallest = arr[1];

    cout << "Smallest value: " << smallest << endl;
    cout << "Second smallest value: " << secondSmallest << endl;
}

It will print similar output.

You can use any of the approaches we discussed above. The sorting method is a quick and concise way to find the smallest and second smallest values.

JavaScript replace multiple characters using single replace call

Mon, 20 Mar 2023 09:39:27 GMT

JavaScript program to replace multiple characters of a string with one replace call:

This is a frequently faced problem in development. You need to replace multiple occurrences of a character in a string with one replace call. You can iterate over the string characters and replace the characters one by one. But, JavaScript provides an easy way to do that.

In this post, we will learn how to replace multiple characters with one single replace call and how replace and replaceAll functions work.

replace() function:

The inbuilt replace function takes two parameters:

replace(old, new)

It replaces the old value with the new value and returns the modified string. We can pass a character or a string to replace. But, it will replace only the first occurrence of old.

For example,

givenStr = 'Hello@World@';

newStr = givenStr.replace('@', ' ');

console.log(newStr);

In this example, we are using the replace function to replace @ with a blank space in the string givenStr. The new returned string is assigned to the newStr variable.

If you run this program, it will print:

Hello World@

You can see that only the first occurrence of @ is replaced.

To replace all the occurrences of @, we have to use a chain of replace function call.

givenStr = 'Hello@World@!!@';

newStr = givenStr.replace('@', ' ').replace('@', ' ').replace('@', ' ');

console.log(newStr);

It will replace all the occurrences of @.

Hello World !!

Example 2: By using a regular expression with replace():

We can pass a regular expression to match all occurrences of a character. For example, if we pass @\g as the first argument to replace(), it will match all occurrences of @ in the string.

givenStr = 'Hello@World@!!@';

newStr = givenStr.replace(/@/g, ' ');

console.log(newStr);

It will print:

Hello World !!

Regular expression to match different characters:

This method has other advantages. If we want to replace different types of characters, we can put them in a square bracket. You can build any type of regex pattern.

For example, /[@#&]/g will match all occurrences of @, # and & in the string.

givenStr = 'Hello@World&!!#';

newStr = givenStr.replace(/[@#&]/g, ' ');

console.log(newStr);

It will print:

Hello World !!

Regular expression with pipe character:

The pipe character, | represents OR in a regular expression. We can also use it in a regex pattern to match all occurrences of characters:

givenStr = 'Hello@World&!!#';

newStr = givenStr.replace(/@|#|&/g, ' ');

console.log(newStr);

This will print the same output:

Hello world !!

replaceAll() function to replace all occurrences of a character:

The replaceAll function replaces all matches of a character in a string. The syntax of this function is similar to the replace function:

replaceAll(old, new)

It returns one new string. So, if you want to replace the occurrences of different characters, you can use chain function call.

givenStr = "Hello@World&!!#";

newStr = givenStr
  .replaceAll("@", " ")
  .replaceAll("&", " ")
  .replaceAll("#", " ");

console.log(newStr);

It will print:

Hello World !!

If you pass a regex, it will work similarly to replace. For example, the following program will print the same output:

givenStr = "Hello@World&!!#";

newStr = givenStr.replaceAll(/@|#|&/g, " ");

console.log(newStr);

Python id() function explanation with examples

Sat, 18 Mar 2023 09:39:27 GMT

Learn how Python id() function works with examples:

The id function is used to get the identity of an object. It returns one integer value which is a unique value and constant value for that object. We may get unique ids if two objects have a non-overlapping lifetime.

Syntax of id() function:

The syntax of id() function is:

id(object)

We need to pass the object and it returns the identity of the object, which is an integer value.

Other than objects, we can also pass a string, list, tuple, integer etc. to this function.

Example of id() function with numbers:

The below program shows how the id() function works with numbers:

x = 10
y = 20
z = 10
x1 = x

print('id of x: ',id(x))
print('id of y: ',id(y))
print('id of z: ',id(z))
print('id of x1: ',id(x1))

It will print:

id of x:  2347957709392
id of y:  2347957709712
id of z:  2347957709392
id of x1:  2347957709392

As you can see here, the id() function returns different numbers as the ids. The ids of x, z and x1 are the same because these variables are equal i.e. 10.

Example of id() function with strings:

The below program shows how the id() function works with different strings:

str1 = 'hello'
str2 = 'world'
str3 = 'hello'
str4 = str2

print('id of str1: ',id(str1))
print('id of str2: ',id(str2))
print('id of str3: ',id(str3))
print('id of str4: ',id(str4))

It will print:

id of str1:  3068235986800
id of str2:  3068235897968
id of str3:  3068235986800
id of str4:  3068235897968

The ids of str1 and str3 are equal because the strings are the same.
The ids of str2 and str4 are equal because both are referring to the same string.

Example of id() function with list:

Let’s use it with lists:

list1 = ['hello', 'world']
list2 = ['hello', 'world']
list3 = ['hello']

print('id of list1: ',id(list1))
print('id of list2: ',id(list2))
print('id of list3: ',id(list3))

Even though the contents of list1 and list2 are the same, it will produce different ids for both.

id of list1:  2280471356352
id of list2:  2280471644992
id of list3:  2280471706816

Example of id() function with custom objects:

We can use the id() function with custom objects. It will produce different ids even if the content of the objects is similar.

class Student:
    name = 'Alex'

std1 = Student()
std2 = Student()
std3 = std1

print('id of std1: ',id(std1))
print('id of std2: ',id(std2))
print('id of std3: ',id(std3))

In this example, the Student class has only one property name, which is equal to ‘Alex’.

If you run this program, it will print:

id of std1:  1538234523264
id of std2:  1538234523216
id of std3:  1538234523264

The ids of std1 and std2 are different. Since both std3 and std1 are referring to the same objects, the ids are the same for these two.

C++ class destructor explanation with examples

Fri, 17 Mar 2023 09:39:27 GMT

C++ destructor:

In this post, we will learn about destructors in C++ with examples. Destructors are special functions in C++ objects those are called when the object is destroyed. These are called automatically.

Constructors are called when the class objects are created and destructors are called when these are destroyed. Destructors are mostly used to free all resources that might be held by the class objects. This is required to avoid memory leaks.

How the destructors are defined:

There is only one destructor defined in a class. The name of the destructor is the same as its class name prefixed with a tilde(~) symbol.

So, it is similar to the constructor with a tilde prefix.

Let’s learn how it works with examples.

Example of C++ destructor:

Let’s consider the following example:

#include <iostream>
using namespace std;

class Student{
    public:
        Student()
        {
            cout<<"Constructor called"<<endl;
        }
        ~Student(){
            cout<<"Destructor called"<<endl;
        }
};

int main()
{
    Student s;
}

In this program, we created a class Student with a constructor and a destructor.

Student() is the constructor, which is called when the class object is created.
~Student() is the destructor, which is called when the class object is destroyed.

If you run this program, it will print:

Constructor called
Destructor called

The program is creating a Student object and it stops. So, it calls the constructor and then calls the destructor.

Example of multiple objects:

Let’s create multiple objects to check how constructors and destructors are called:

#include <iostream>
using namespace std;

class Student{
    public:
        Student()
        {
            cout<<"Constructor called"<<endl;
        }
        ~Student(){
            cout<<"Destructor called"<<endl;
        }
};

int main()
{
    Student s1, s2, s3, s4;
}

It is creating four Student objects. It will call the constructors of these objects sequentially and then call the destructors sequentially.

Constructor called
Constructor called
Constructor called
Constructor called
Destructor called
Destructor called
Destructor called
Destructor called

Can we call a destructor explicitly:

Yes, we can call a destructor explicitly. We can call it similar to any other function call.

#include <iostream>
using namespace std;

class Student{
    public:
        Student()
        {
            cout<<"Constructor called"<<endl;
        }
        ~Student(){
            cout<<"Destructor called"<<endl;
        }
};

int main()
{
    Student s1;
    s1.~Student();
}

In this example, we called the destructor explicitly, s1.~Student(). It will invoke the destructor two times, when we invoked it and when the object is destroyed.

So, it will print the message mentioned in the destructor twice:

Constructor called
Destructor called
Destructor called

Java ArithmeticException explanation with examples

Thu, 16 Mar 2023 09:39:27 GMT

Java ArithmeticException explanation with examples:

The ArithmeticException is an exception that is thrown by an arithmetic condition. For example, if we are trying to divide a number by zero, it will throw an ArithmeticException.

In this post, I will show you how ArithmeticException works with examples.

ArithmeticException class:

The full package of ArithmeticException is java.lang.ArithmeticException. Its parent class is java.lang.RuntimeException and the parent class of RuntimeException is java.lang.Exception.

As you can see that it is a RuntimeException. So, the compiler will not show any error.

Constructors of ArithmeticException:

Following are the constructors of ArithmeticException:

ArithmeticException()

ArithmeticException(String s)

The first one will create one object of ArithmeticException without any detailed message and the second one will create one ArithmeticException object with a detailed message.

Example: Dividing by zero:

This is a common cause of ArithmeticException. If you try to divide a number by zero, it will throw an ArithmeticException.

For example:

public class Main {
    public static void main(String[] args) {
        System.out.println(10/0);
    }
}

As this is a RuntimeException, the compiler will not show any error and we can run the program. It will throw the following error:

Exception in thread "main" java.lang.ArithmeticException: / by zero
	at com.company.Main.main(Main.java:5)

How to handle ArithmeticException:

We can use a try-catch block to handle ArithmeticException:

public class Main {
    public static void main(String[] args) {
        try {
            System.out.println(10 / 0);
        } catch (ArithmeticException e) {
            System.out.println("ArithmeticException occurred: " + e.getMessage());
        }
    }
}

In the catch block, we can log this exception or we can add a meaningful message. In this example, I have added a message with the return value of getMessage(). The getMessage() method returns the detailed message string of the exception.

It will give the below result:

Java method overloading explanation with example

Wed, 15 Mar 2023 09:39:27 GMT

Java method overloading:

In this post, we will learn what is method overloading in Java and how it works with examples.

A Java class can have multiple methods with the same name but different parameters and different return types. This is called method overloading and the method is called overloaded method.

We can change the number of arguments that method is accepting and also the data type of the arguments. The return type is also changeable. With method overloading, the readability of the program can be improved. Let me show you an example how method overloading works.

Example of method overloading:

Let’s consider the below program:

class Util{
    public static int getHalf(int number){
        return number/2;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(Util.getHalf(10));
    }
}

In this program, the Util class has one static method getHalf that takes one integer number as its parameter and returns the integer value of half of that number.

But, if we want to find half of a floating point number, we can’t use this method. We can create another method with a different name, but instead of using a different name for the same use case, we can create another method with the same name but a different parameter type and return type.

class Util{
    public static int getHalf(int number){
        return number/2;
    }

    public static float getHalf(float number){
        return number/2;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(Util.getHalf(4));
        System.out.println(Util.getHalf(11f));
    }
}

I created a new method that takes one float number as its parameter and returns the result in float.

It will print:

2
5.5

This is method overloading and the method getHalf is overloaded in this example.

Example of overloading with a different number of parameters:

We can use method overloading with a different number of parameters. The number of parameters can differ for the overloaded methods. For example,

class Log {
    public static void debug(String message) {
        System.out.println("Log: " + message);
    }

    public static void debug(String message, int error) {
        System.out.println("Log: " + message + ", Error: " + error);
    }
}

public class Main {
    public static void main(String[] args) {
        Log.debug("This is a debug message");
        Log.debug("Error occurred!! ", 404);
    }
}

In this example, we created a class Log with an overloaded method debug. We can either pass one string or one string with an integer error code to it.

If you run this program, it will print:

Log: This is a debug message
Log: Error occurred!! , Error: 404

As you can see here, we can have different body and parameters with the same method name for overloaded methods.

Can we use method overloading with only change in return type:

We can’t use method overloading without changing anything in the parameters. Even if we change the return type, the compiler will throw an error. For example:

class Util{
    public static int getHalf(int number){
        return number/2;
    }

    public static float getHalf(int number){
        return (float)number/2;
    }
}

For this class, we are trying to overload the getHalf method with a change in the return type. But the compiler will throw an error:

It is showing an error that the method is already defined in the class.

Java method overriding explanation with example

Tue, 14 Mar 2023 09:39:27 GMT

An introduction to method overriding in Java:

Inheritance is one of the important features of Object Oriented Programming(OOP). With this concept, one class inherits the methods and attributes of another class. The original class is called parent class and the second class is called child class. Child class inherits the methods and attributes of the parent class. Parent and Child classes are also called super class and sub class.

If the child class has the same method as the parent class, it is called method overriding. In this blog post, we will learn how method overriding works in Java with different examples.

Rules of method overriding:

Following are the rules of method overriding:

Methods that are declared as final and static are not available for override.
Abstract methods of superclass should be always overridden.
For all overridden methods, the method name, return type and parameters list shouldn’t be different in both parent and child classes.

Example of method overriding:

Let’s take an example of method overriding:

class Vehicle {
    public void print() {
        System.out.println("Inside Vehicle");
    }
}

class Car extends Vehicle {
    @Override
    public void print() {
        System.out.println("Inside Car");
    }
}


public class Main {
    public static void main(String[] args) {
        Car car = new Car();
        car.print();
    }
}

The Vehicle class is the parent class and the Car class is the child class. The Car class is extending the Vehicle class.
The print method is defined in the Vehicle class. Since the Car class is extending the Vehicle class, we can also write the same method in the Car class.
Inside the Main class, we are creating one object of the Car class and calling the print method. It will call the overriding print method, i.e. the method defined in the Car class.

It will print:

Inside Car

It is using the @Override annotation to define that the method is overriding its parent class method. It is not mandatory to use this annotation but if we use it, the method should follow the overriding rules we have mentioned before.

How to access the method of superclass inside the overriding method:

We can access the method of the superclass inside the overriding method. We have to use the super keyword for that. For example:

class Vehicle {
    public void print() {
        System.out.println("Inside Vehicle");
    }
}

class Car extends Vehicle {
    @Override
    public void print() {
        super.print();
        System.out.println("Inside Car");
    }
}


public class Main {
    public static void main(String[] args) {
        Car car = new Car();
        car.print();
    }
}

Inside the override print() method, we are calling super.print(), which will call the print method in the superclass.

If you run this program, it will print:

Inside Vehicle
Inside Car

As you can see, the first line is printed by the print method defined in the superclass Vehicle. The second line is printed by the print method defined in the class Car.

How Access Specifier works in Overriding:

The access specifier of an overriding method can be different that the one defined in the superclass. But its access shouldn’t be less than the one defined in the superclass.

For example, if the method of the superclass is protected, the override method can be either public or protected, not private. Else, it will throw a compile-time error.

Let’s take a look at the below example:

class Vehicle {
    protected void print() {
        System.out.println("Inside Vehicle");
    }
}

class Car extends Vehicle {
    @Override
    private void print() {
        super.print();
        System.out.println("Inside Car");
    }
}

The Vehicle class is the parent class and the Car class is the child class. The print method in the Vehicle class is protected but the override method in the Car class is private.

It will throw one compile-time error as below:

Since the access modifier in the parent class is protected, we can’t use private in the child class.

Method overriding of static method:

We can’t override a static method because the static method is a class method, not an object method. Similarly, we can’t override a main method because it is a static method.

How to format a Date in AM/PM in Java

Mon, 13 Mar 2023 09:39:27 GMT

How to format a Date in AM/PM in Java:

In this post, we will learn how to format a Date to AM/PM in Java. The SimpleDateFormat class makes it easy to format a given date to a specific pattern. Let’s learn how this class can be used to convert a date to a 12 Hour format with AM/PM.

SimpleDateFormat:

The SimpleDateFormat class is a useful class to parse a Date in Java. We can pass one pattern while creating one object of SimpleDateFormat and it will use this pattern to format the date.

We can use any of the following letters in the pattern:

Letter	Description
G	Era designator, e.g. AD
y	year
Y	Week year
M	Month of a year
w	Week of a year
W	Week of a month
D	Day of a year
d	Day of a month
F	Day of a week for a month
E	Day name of a week
u	Day number of a week, 1 is for Monday…7 is for Sunday
a	Am/pm
H	hour in a day, it is in between 0 to 23
k	hour in a day in between 1 to 24
K	hour in am/pm, in between 0 to 11
h	hour in am/pm, in between 1 to 12
m	minute in hour
s	second in minute
S	millisecond
z	Time zone
Z	Time zone
X	Time zone

Let me show you how it works with an example:

import java.text.SimpleDateFormat;
import java.util.Date;

public class Main {
    public static void main(String[] args) {
        Date currentDate = new Date();

        SimpleDateFormat formatter = new SimpleDateFormat("dd-MM-yyyy");
        String formattedDate = formatter.format(currentDate);

        System.out.println(formattedDate);
    }
}

The currentDate object is the current Date object.
We created one SimpleDateFormat object with pattern ‘dd-MM-yyyy’. It will format the date with day, month and year.
The format method formats the date object and returns the result as a string.

If you run this program, it will print:

08-03-2023

Example to format a date in AM/PM:

Let’s use SimpleDateFormat class to display the time in AM/PM format. We can use the following patterns to format the date:

hh to display the time in 12 hours format
mm to display the minute
aa for AM/PM

The following program displays the current Date time in AM/PM format:

import java.text.SimpleDateFormat;
import java.util.Date;

public class Main {
    public static void main(String[] args) {
        Date currentDate = new Date();

        SimpleDateFormat formatter = new SimpleDateFormat("hh:mm aa");
        String formattedDate = formatter.format(currentDate);

        System.out.println(formattedDate);
    }
}

We are using the hh:mm aa pattern. This will print output as below:

12:47 pm

We can also use the pattern “hh.mm aa” to print the date as 12.51 pm.

Example 2: Convert a 24 hour time to 12 hour with AM/PM:

Suppose a string is given in 24 hour format. We can use the SimpleDateFormat class to parse a string and convert it to a Date object. The parse() method of SimpleDateFormat is used to parse a string to Date.

Once the string is parsed, we can use another SimpleDateFormat object as shown in the previous example to convert it to a 12 hour AM/PM value.

Let me show you how to do that with one example:

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Main {
    public static void main(String[] args) {
        String time = "21.15";
        SimpleDateFormat format = new SimpleDateFormat("HH.mm");

        try {
            Date date = format.parse(time);
            SimpleDateFormat formatter = new SimpleDateFormat("hh.mm aa");
            String formattedDate = formatter.format(date);

            System.out.println(formattedDate);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        
    }
}

The given time is 21.15. It is in 24 hours format and it is a string.
We created one SimpleDateFormat object and used the parse() method to convert this value to a Date object.
Once the date is created, we used another SimpleDateFormat object to convert it to a 12 hour AM/PM value.
The final output is assigned to the string formattedDate and its value is printed.

It will print:

09.15 pm

Note that we have to use a try-catch block as the parse method might throw an ParseException. If any exception is thrown, it will print the stacktrace.

What is hybrid inheritance in java

Sun, 12 Mar 2023 09:39:27 GMT

What is hybrid inheritance in java:

Inheritance is an important part of object-oriented programming. A class can inherit features from another class. One is called the parent class and the other one is called the child class. The child class inherits properties from the parent class.

There are different types of inheritance in Java and hybrid inheritance is one of its types. In this post, we will learn how hybrid inheritance works in Java with examples.

What is Inheritance:

Suppose we have a few methods and properties defined in one class and we need to create one separate class that will use the same methods and properties. Instead of rewriting these, we can inherit these properties from the old class to the new class. Inheritance helps to achieve this.

These classes are in a parent-child relationship or Is-A relationship. The child class can reuse all the methods and properties defined in the parent class.

All classes in Java have a parent class. The Object class is the parent of all the classes.

Following are the categories of inheritance in Java:

Single inheritance
Multi-level inheritance
Hierarchical inheritance
Multiple inheritance
Hybrid inheritance

Hybrid inheritance:

Hybrid inheritance is achieved if a set of classes uses more than one inheritance. Let me show you different examples of Hybrid inheritance:

Example of Hybrid inheritance:

Let’s take a look at the below diagram:

Here, ClassB and ClassC are extending from ClassA. Also, ClassD is extending from ClassB and ClassC. It creates a hybrid inheritance.

But, multiple inheritance is not supported in Java. We can use interfaces to implement this.

class ClassA {
    public void printA() {
        System.out.println("Inside A");
    }
}

interface InterfaceB {
    public void printB();
}

interface InterfaceC {
    public void printC();
}

class ClassD extends ClassA implements InterfaceB, InterfaceC {

    public void printD() {
        System.out.println("Inside D");
    }

    @Override
    public void printB() {
        System.out.println("Inside B");
    }

    @Override
    public void printC() {
        System.out.println("Inside C");
    }
}

public class Main {
    public static void main(String[] args) {
        ClassD classD = new ClassD();
        classD.printA();
        classD.printB();
        classD.printC();
        classD.printD();
    }
}

We created two interfaces InterfaceB and InterfaceC.
The ClassD is extending ClassA and implements the interfaces.

If you run this program, it will print:

Inside A
Inside B
Inside C
Inside D

Example 2: Implementation of Hybrid inheritance using single and Hierarchical inheritances:

Let’s take another Hybrid inheritance example. We will use single and hierarchical inheritances to build the hybrid inheritance. The following diagram will help you to understand how it works:

Here,

GrandFather and Father classes are single inheritance. Father is the child class and GrandFather is the parent class.
Son and Daughter classes are extending Father class. These three classes represents Hierarchical inheritance.
Combining all of these classes, a Hybrid inheritance is formed.

We can write it as below in code,

class GrandFather {
    public void print() {
        System.out.println("Inside GrandFather");
    }
}

class Father extends GrandFather {
    public void print() {
        System.out.println("Inside Father");
    }
}

class Son extends Father {
    public void print() {
        System.out.println("Inside Son");
    }
}

class Daughter extends Father {
    public void print() {
        System.out.println("Inside Daughter");
    }
}

Similar to the above two examples, we can combine different inheritances to build a hybrid inheritance.

Java checked and unchecked exceptions example

Sat, 11 Mar 2023 09:39:27 GMT

Java checked vs unchecked exceptions:

In this post, we will learn the differences between checked and unchecked exceptions in Java. I will also give an introduction to exceptions and how exceptions are handled with different examples.

A brief intro to Exceptions:

An exception disrupts the flow of a program in Java. The Throwable class in Java is the parent class of all exceptions. The exception object holds the information about the cause. An exception can be raised in different scenarios. Suppose the program is trying to open a file but the file is not available, user entered an invalid value etc.

If an exception is not handled, it will terminate the program abnormally. So, we should always handle a code block that might throw an exception.

Handling an exception in Java:

To handle exceptions, try-catch block is used. It is defined as:

try{
    // code that is prone to throw exception
}catch(<Name of Exception> e){
    // catch block
}

If the code written inside the try block throws an exception, it will not terminate the program. Instead, it will move to the catch block and the rest of the program will run normally.

Exception handling is useful in many ways. For example, we can show a meaningful message to the user instead of terminating the program or we can use a different way to fix this.

We can also use multiple catch blocks.

try{
    // code that is prone to throw exception
}catch(<Name of Exception1> e1){
    // catch block for exception 1
}catch(<Name of Exception2> e2){
    // catch block for exception 2
}catch(<Name of Exception3> e3){
    // catch block for exception 3
}

This is useful to handle different type of exceptions.

Checked and Unchecked exceptions:

Exceptions are categorized into:

Checked exceptions and
Unchecked exceptions

Checked exceptions:

Checked exceptions are also called compile-time exceptions. These exceptions should be handled in the program. A few examples of checked exceptions are FileNotFoundException, ClassNotFoundException, SQLException etc.

These are also called compile-time exceptions because the compiler will show a warning if we don’t handle these exceptions.

Let’s take a look at the below example:

import java.io.FileReader;

public class Main {
    public static void main(String[] args) {
        FileReader fileReader = new FileReader("hello.java");
    }
}

This example is using a java.io.FileReader class to open a file. Your code editor will show one compile-time error:

If you hover over the FileReader word, it will show that Unhandled exception: java.io.FileNotFoundException i.e. we have to handle the exception for FileNotFoundException. This exception is thrown if the file is not found or for some other reason, it couldn’t open the file.

To make the code work, we can use a try-catch block to handle this.

import java.io.FileNotFoundException;
import java.io.FileReader;

public class Main {
    public static void main(String[] args) {
        try {
            FileReader fileReader = new FileReader("hello.java");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

Unchecked exceptions:

Unchecked exceptions are also called Runtime exceptions. These are not checked by the compiler. So, even if we don’t handle them, these exceptions will work. For example, ArithmeticException, ClassCastException are unchecked exceptions.

For example,

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.println("Enter a number: ");
        int firstNumber = sc.nextInt();

        System.out.println("Enter another number: ");
        int secondNumber = sc.nextInt();

        System.out.println("The result of first-number/second-number is: " + firstNumber / secondNumber);
    }
}

This program reads two numbers as inputs from the user and print the result of dividing the first number by the second number.

This program will work fine if the user enters any valid value. For example:

Enter a number: 
10
Enter another number: 
2
The result of first-number/second-number is: 5

But if the second number is 0, it will throw an ArithmeticException:

Enter a number: 
10
Enter another number: 
0
Exception in thread "main" java.lang.ArithmeticException: / by zero
	at com.company.Main.main(Main.java:15)

We can use a try-catch block to handle these type of exceptions.

try {
    System.out.println("The result of first-number/second-number is: " + firstNumber / secondNumber);
}catch(ArithmeticException e){
    System.out.println("Please enter valid inputs!!");
}

7 ways to sort an ArrayList of objects in Java

Fri, 10 Mar 2023 09:39:27 GMT

How to sort an ArrayList of objects in Java:

In this post, I will show you how to sort an ArrayList of objects in Java in different ways. I will try to keep the tutorial simple with a small number of sample objects. We will learn to sort an ArrayList of objects by comparing one single field or multiple fields.

Java program to use in the examples:

The following program will be used in the below examples:

Create a file Car.java:

public class Car {
    int id;
    String color;

    public int getId() {
        return id;
    }

    public String getColor() {
        return color;
    }

    public Car(int id, String color) {
        this.id = id;
        this.color = color;
    }

    @Override
    public String toString() {
        return "id: " + id + ", color: " + color;
    }
}

And the Main class as below:

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<Car> cars = new ArrayList<>();
        cars.add(new Car(1, "Red"));
        cars.add(new Car(5, "Blue"));
        cars.add(new Car(4, "Green"));
        cars.add(new Car(3, "Raspberry"));
        cars.add(new Car(2, "Gamboge"));

        for (Car car : cars) {
            System.out.println(car);
        }
    }
}

In this example, we created one class Car to hold the information of a car, one integer id and one String color.
We created an ArrayList car and inserted five Car objects to the ArrayList. The for loop prints the content of the ArrayList.

If you run this program, it will print the below output:

id: 1, color: Red
id: 5, color: Blue
id: 4, color: Green
id: 3, color: Raspberry
id: 2, color: Gamboge

We will use this program in the below examples to sort the array.

Method 1: By using Collections.sort() and Comparator.comparing():

We can use the Collections.sort() method to sort the ArrayList. The first parameter is the ArrayList to sort and the second parameter is a Comparator object that defines the order of the list.

The following code snippet will sort the elements by their ids:

Collections.sort(cars, Comparator.comparingInt(Car::getId));

for (Car car : cars) {
    System.out.println(car);
}

We have passed Comparator.comparingInt method as the comparator to this method. It will sort the items by their ids:

id: 1, color: Red
id: 2, color: Gamboge
id: 3, color: Raspberry
id: 4, color: Green
id: 5, color: Blue

If you want to compare the elements by their names, you can write as below:

Collections.sort(cars, Comparator.comparing(Car::getColor));

for (Car car : cars) {
    System.out.println(car);
}

It will sort the items by their names:

id: 5, color: Blue
id: 2, color: Gamboge
id: 4, color: Green
id: 3, color: Raspberry
id: 1, color: Red

Method 2: By using List.sort():

We can also use the List.sort() method instead of Collections.sort. This method takes one Comparator object and sorts the items of the ArrayList.

cars.sort(Comparator.comparing(Car::getColor));

for (Car car : cars) {
    System.out.println(car);
}

It will sort the items by their names.

Method 3: By using stream:

We can convert the ArrayList to a stream, sort the items and convert the stream back to ArrayList.

ArrayList<Car> sortedCars = (ArrayList<Car>)cars.stream()
        .sorted(Comparator.comparing(Car::getColor))
        .collect(Collectors.toList());

for (Car car : sortedCars) {
    System.out.println(car);
}

This example is sorting the items by their names.

id: 5, color: Blue
id: 2, color: Gamboge
id: 4, color: Green
id: 3, color: Raspberry
id: 1, color: Red

Method 4: Sort by multiple properties:

We can add more comparison conditions to the Comparator object. For example:

ArrayList<Car> cars = new ArrayList<>();
cars.add(new Car(1, "Red"));
cars.add(new Car(5, "Blue"));
cars.add(new Car(5, "Green"));
cars.add(new Car(1, "Raspberry"));
cars.add(new Car(2, "Gamboge"));

cars.sort(Comparator.comparing(Car::getId).thenComparing(Car::getColor));

for (Car car : cars) {
    System.out.println(car);
}

This will sort the items by comparing the ids of the objects, and then it will compare the colors of the objects. For example, if two items have similar ids, the sort will be based on the color.

The above program will print the below result:

id: 1, color: Raspberry
id: 1, color: Red
id: 2, color: Gamboge
id: 5, color: Blue
id: 5, color: Green

Note that you can also use this method with stream sorted() method as explained in the previous example.

Method 5: How to sort the items in reverse:

You can use the reversed() method of the Comparator class to do a reverse sorting:

cars.sort(Comparator.comparing(Car::getId).thenComparing(Car::getColor).reversed());

for (Car car : cars) {
    System.out.println(car);
}

It will print:

id: 5, color: Green
id: 5, color: Blue
id: 2, color: Gamboge
id: 1, color: Red
id: 1, color: Raspberry

Method 6: How to use a custom comparator:

We can create a custom comparator class to write our own comparison logic.

Create one class that implements the Comparator interface
Override the compare method that takes two objects as its parameters and returns one integer value.
- Return zero if both objects are equal.
- Return a negative value if the first object is less than the second object.
- Return a positive value if the first object is greater than the second object.

We can write our own custom logic and return one integer value.

Create one file CarsComparator.java:

import java.util.Comparator;

public class CarsComparator implements Comparator<Car> {
    @Override
    public int compare(Car o1, Car o2) {
        return o1.getColor().length() - o2.getColor().length();
    }
}

This file is implementing the Comparator interface and overrides the compare method. If we use this comparator, it will sort the items in increasing order of the length of colors.

We can use he comparator to sort the ArrayList:

cars.sort(new CarsComparator());

for (Car car : cars) {
    System.out.println(car);
}

It will print:

id: 1, color: Red
id: 5, color: Blue
id: 5, color: Green
id: 2, color: Gamboge
id: 1, color: Raspberry

Method 7: How to use a custom comparator:

Alternate to the above example, we can implement a Comparable interface to the Cars class. It will require to implement a method called compareTo, that will take one Car instance as the parameter. We have to write our own custom logic and return one integer value from this method.

Return zero if both objects are equal.
Return a negative value if the first object is less than the second object.
Return a positive value if the first object is greater than the second object.

We can use Collections.sort() or stream sorted() method to sort an ArrayList.

For example, let’s change the Cars.java file as below:

public class Car implements Comparable<Car>{
    int id;
    String color;

    public int getId() {
        return id;
    }

    public String getColor() {
        return color;
    }

    public Car(int id, String color) {
        this.id = id;
        this.color = color;
    }

    @Override
    public String toString() {
        return "id: " + id + ", color: " + color;
    }

    @Override
    public int compareTo(Car o) {
        return o.getColor().length() - this.getColor().length();
    }
}

It will sort the objects in decreasing order of length of the color of each object.

Collections.sort(cars);

for (Car car : cars) {
    System.out.println(car);
}

It will print:

id: 1, color: Raspberry
id: 2, color: Gamboge
id: 5, color: Green
id: 5, color: Blue
id: 1, color: Red

Java program to check if a number is perfect square or not

Thu, 09 Mar 2023 09:39:27 GMT

Java program to check if a number is perfect square or not:

This post will show you how to check if a number is a perfect square or not. It will take one number as input from the user, check if it is a perfect square and print the result.

There are different ways to check for perfect square. Let’s learn these all:

Example 1: By using Math.sqrt:

If we can express an integer as the square of another integer, this is called a perfect square. For example, 64 is a perfect square as the square of 8 is equal to 64.

The Math.sqrt method is used to find the square root of a number. This method returns a double value. We can convert this value to integer, find the square of that integer value and compare it with the original number to check if the number is a perfect square or not.

import java.util.Scanner;

public class Main {
    private static boolean isPerfectSquare(int number) {
        if (number < 0) return false;

        int sqRt = (int) Math.sqrt(number);
        return sqRt * sqRt == number;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Enter a number: ");

        int no = scanner.nextInt();

        if (isPerfectSquare(no)) {
            System.out.println(no + " is a perfect square.");
        } else {
            System.out.println(no + " is not a perfect square.");
        }
    }
}

It will give output as below:

Enter a number: 
64
64 is a perfect square.

Enter a number: 
67
67 is not a perfect square.

Example 2: By using Math.floor and Math.ceil:

We can use Math.floor and Math.ceil on the return value of Math.sqrt(). If the values of both of these methods are equal, we can say that the number is a perfect square. Else, it is not a perfect square.

import java.util.Scanner;

public class Main {
    private static boolean isPerfectSquare(int number) {
        if (number < 0) return false;

        double sqRt = Math.sqrt(number);
        return Math.floor(sqRt) == Math.ceil(sqRt);
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Enter a number: ");

        int no = scanner.nextInt();

        if (isPerfectSquare(no)) {
            System.out.println(no + " is a perfect square.");
        } else {
            System.out.println(no + " is not a perfect square.");
        }
    }
}

The previous program is changed. It calculates the square root of the number and assigned it to the sqRt double variable. It finds the Math.floor and Math.ceil values and compares these two values to check if the number is a perfect square or not.

It will give similar output:

Enter a number: 
144
144 is a perfect square.

Enter a number: 
111
111 is not a perfect square.

Java program to filter a map by key and value

Wed, 08 Mar 2023 09:39:27 GMT

Java program to filter a map by key and value:

This post will show you how to filter a map by key, value and key-value. We will use a HashMap for the examples. The traditional way is to use a loop to iterate over the map and filter out all the items. These filtered items can be inserted into a new map. Starting from Java 8, we can also use Java Stream filter. This is easy and makes the code concise.

Example 1: How to use a loop to filter a map:

Let’s use a for loop to filter the content. We will use a HashMap in this example.

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

public class Main {
    public static void main(String[] args) {
        HashMap<Integer, String> numberMap = new HashMap<>();
        numberMap.put(0, "Zero");
        numberMap.put(1, "One");
        numberMap.put(2, "Two");
        numberMap.put(3, "Three");
        numberMap.put(4, "Four");

        HashMap<Integer, String> evenNumberMap = new HashMap<>();
        for (Map.Entry<Integer, String> number : numberMap.entrySet()) {
            if (number.getKey() % 2 == 0)
                evenNumberMap.put(number.getKey(), number.getValue());
        }

        System.out.println("Filtered even numbers: " + evenNumberMap);
    }
}

In this example, we created a HashMap with keys of Integer type and values of String type.
The for loop is used to filter out all values with even keys. It iterates over the elements of numberMap and filters out all items that have keys with even values.
The evenNumberMap is another HashMap to hold the output values. We are using the put method to insert the values to this output HashMap.
At the end of the program, it prints the content of evenNumberMap.

If you run this program, it will print:

Filtered even numbers: {0=Zero, 2=Two, 4=Four}

To filter out items based on values, we can use the getValue method. For example,

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

public class Main {
    public static void main(String[] args) {
        HashMap<Integer, String> numberMap = new HashMap<>();
        numberMap.put(0, "Zero");
        numberMap.put(1, "One");
        numberMap.put(2, "Two");
        numberMap.put(3, "Three");
        numberMap.put(4, "Four");

        HashMap<Integer, String> evenNumberMap = new HashMap<>();
        for (Map.Entry<Integer, String> number : numberMap.entrySet()) {
            if (number.getValue().startsWith("T"))
                evenNumberMap.put(number.getKey(), number.getValue());
        }

        System.out.println("Filtered numbers: " + evenNumberMap);
    }
}

This is filtering out the values starting with ‘T’.

It will print:

Filtered numbers: {2=Two, 3=Three}

Example 2: Filtering keys of a map with Java Stream API:

We can use Java Stream API to write the above program.

import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        HashMap<Integer, String> numberMap = new HashMap<>();
        numberMap.put(0, "Zero");
        numberMap.put(1, "One");
        numberMap.put(2, "Two");
        numberMap.put(3, "Three");
        numberMap.put(4, "Four");

        Map<Integer, String> evenNumberMap = numberMap
                .entrySet()
                .stream()
                .filter(item -> item.getKey() % 2 == 0)
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

        System.out.println("Filtered even numbers: " + evenNumberMap);
    }
}

The stream() method returns a sequential stream of the source HashMap.
The filter method is used to filter out values from the source stream. It also returns another stream.
The collect method is used to perform a reduction operation on the stream elements. We are using this method to create a Map with the filtered items.

It will print:

Filtered even numbers: {0=Zero, 2=Two, 4=Four}

Example 3: Filtering values of a map with Java Stream API:

We can use stream with filter() to filter out items based on values.

import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        HashMap<Integer, String> numberMap = new HashMap<>();
        numberMap.put(0, "Zero");
        numberMap.put(1, "One");
        numberMap.put(2, "Two");
        numberMap.put(3, "Three");
        numberMap.put(4, "Four");

        Map<Integer, String> evenNumberMap = numberMap
                .entrySet()
                .stream()
                .filter(item -> item.getValue().startsWith("T"))
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

        System.out.println("Filtered numbers: " + evenNumberMap);
    }
}

In this example, we are filtering the items with values starting with ‘T’.

Filtered numbers: {2=Two, 3=Three}

Example 4: Filtering keys and values of a map with Java Stream class:

We can use multiple filter() methods. Since the filter method returns a Stream, we can use the filter() method again on the returned stream.

import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        HashMap<Integer, String> numberMap = new HashMap<>();
        numberMap.put(0, "Zero");
        numberMap.put(1, "One");
        numberMap.put(2, "Two");
        numberMap.put(3, "Three");
        numberMap.put(4, "Four");

        Map<Integer, String> evenNumberMap = numberMap
                .entrySet()
                .stream()
                .filter(item -> item.getValue().startsWith("T"))
                .filter(item -> item.getKey() % 2 == 0)
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

        System.out.println("Filtered even numbers: " + evenNumberMap);
    }
}

It will print:

Filtered numbers: {2=Two}

We can also combine these two filter() methods:

import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        HashMap<Integer, String> numberMap = new HashMap<>();
        numberMap.put(0, "Zero");
        numberMap.put(1, "One");
        numberMap.put(2, "Two");
        numberMap.put(3, "Three");
        numberMap.put(4, "Four");

        Map<Integer, String> evenNumberMap = numberMap
                .entrySet()
                .stream()
                .filter(item -> item.getValue().startsWith("T") && item.getKey() % 2 == 0)
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

        System.out.println("Filtered numbers: " + evenNumberMap);
    }
}

It will print the same output.

Java program to print from A to Z

Sat, 04 Mar 2023 09:39:27 GMT

Java program to print A to Z:

In this post, we will learn how to print from A to Z in Java. I will show you different ways to do the printing. With this post, you will learn how loops work in Java.

Example 1: Java program to print A to Z by using a for loop:

We can iterate through A to Z with a loop. Instead of an integer variable, we have to use a character variable in the loop.

public class Main {
    public static void main(String[] args) {
        for (char c = 'A'; c <= 'Z'; c++) {
            System.out.print(c + " ");
        }
    }
}

In this post, we are using a for loop that runs from c = ‘A’ to c = ‘Z’ and on each iteration, it increments the value of c by 1. These are characters but since the ASCII values of A to Z are from 65 to 90, the loop iterates over these values and on each increment, it moves to the next character.

It will print the alphabet:

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

We can use the same approach to print the alphabet in lowercase:

public class Main {
    public static void main(String[] args) {
        for (char c = 'a'; c <= 'z'; c++) {
            System.out.print(c + " ");
        }
    }
}

This is similar to the above example. The only difference is that we are looping through 97 to 122 in this example.

It will print:

a b c d e f g h i j k l m n o p q r s t u v w x y z

Example 2: Java program to print A to Z by using a while loop:

Let’s use a while loop to print from A to Z:

public class Main {
    public static void main(String[] args) {
        char c = 'A';
        while (c <= 'Z') {
            System.out.print(c + " ");
            c++;
        }
    }
}

In this approach, we have to initialize the value of c before the loop starts. The value of c is printed inside the loop and at the end of each iteration, its value is incremented by 1.

It will give similar results.

Example 3: By using a do-while loop:

The do…while loop works similarly to a while loop. It executes the code written inside the do block and then checks the condition in the while block.

public class Main {
    public static void main(String[] args) {
        char c = 'A';
        do {
            System.out.print(c + " ");
            c++;
        } while (c <= 'Z');
    }
}

Java program to check if a character is Alphabet or not

Thu, 02 Mar 2023 09:39:27 GMT

Java program to check if a character is Alphabet or not:

In this post, we will learn how to write a Java program to check if a given character is an Alphabet or not. We will learn different ways to check for an Alphabet in uppercase or lowercase format.

Method 1: Java program to find if a character is an Alphabet by comparing ASCII values:

The ASCII value of a is 97 and the ASCII value of z is 122. The ASCII values of all other small case alphabets fall between these values. Similarly, the ASCII value of A is 65 and the ASCII value of Z is 90. Similar to the lowercase characters, the ASCII value of uppercase alphabets falls in between these two values.

We can compare a character directly with these values to check if it is an Alphabet or not.

Let’s write down the Java program:

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("Enter a character: ");
        char ch = scanner.next().charAt(0);

        if ((ch >= 97 && ch <= 122) || (ch >= 65 && ch <= 90)) {
            System.out.println(ch + " is an alphabet.");
        } else {
            System.out.println(ch + " is not an alphabet.");
        }
    }
}

In this program, we are using a Scanner object to read the user-input character. It assigns that character to the character variable ch and compares its value with the upper and lower ASCII levels for alphabets. Based on the comparison result, it prints a message to the user.

If you run this program, it will ask the user to enter a character and it will print if the entered character is an alphabet or not.

This program will print output as below:

Enter a character: 
d
d is an alphabet.

Enter a character: 
#
# is not an alphabet.

Method 2: Java program to find if a character is an Alphabet by comparing characters:

Instead of comparing the ASCII values, we can also compare the user-given character with the uppercase and lowercase characters a, z, A, and Z directly. It will give the same result:

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("Enter a character: ");
        char ch = scanner.next().charAt(0);

        if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) {
            System.out.println(ch + " is an alphabet.");
        } else {
            System.out.println(ch + " is not an alphabet.");
        }
    }
}

This is a better approach as the code is more readable than the previous example.

Method 3: By using a separate method:

In this approach, we will use a separate method to check for an alphabet character. This method will take one character as its parameter and it will return one boolean value.

import java.util.Scanner;

public class Main {

    private static boolean isAlphabet(char ch) {
        return ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'));
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("Enter a character: ");
        char ch = scanner.next().charAt(0);

        if (isAlphabet(ch)) {
            System.out.println(ch + " is an alphabet.");
        } else {
            System.out.println(ch + " is not an alphabet.");
        }
    }
}

We created a new method isAlphabet that takes one character as its parameter and returns one boolean value. It returns true if the character is an alphabet and else it returns false.

The if condition is calling this method and based on its return value it prints if the character is an alphabet or not.

It will print similar results.

Method 4: By using Character.isAlphabetic() method:

The Character class of Java provides a method to find alphabet characters. This method is defined as:

public static boolean isAlphabetic(int codePoint)

This is a static method defined in the Character class. It finds if the specific character or unicode code point is a character or not. We can pass a character directly to this method. It will convert it to its unicode. It returns one boolean value.

Let’s change the above program to use Character.isAlphabetic:

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("Enter a character: ");
        char ch = scanner.next().charAt(0);

        if (Character.isAlphabetic(ch)) {
            System.out.println(ch + " is an alphabet.");
        } else {
            System.out.println(ch + " is not an alphabet.");
        }
    }
}

It will give similar results.

Java program to print X star pattern

Mon, 27 Feb 2023 09:39:27 GMT

Java program to print X star pattern

Learn to print the X pattern with stars in Java. We will learn the algorithm and the Java program to print the X pattern in this blog post. This is a beginner-level Java programming question. We can use star or any other character to print this pattern. Let me first show you how the algorithm works.

Algorithm to print X star pattern in Java:

The X pattern looks as below:

*           * 
  *       *   
    *   *     
      *       
    *   *     
  *       *   
*           *

This pattern is of size 7. We are using blank spaces and stars to print this pattern. Let’s replace all blank spaces with #,

* # # # # # * 
# * # # # * # 
# # * # * # # 
# # # * # # # 
# # * # * # # 
# * # # # * # 
* # # # # # *

So,

For the first line, we need to print stars at the first and last positions.
For the second line, we need to print stars at the second and second last positions etc. For all other places, we have to print blank spaces.

We can use the following algorithm:

Read the size of the pattern as input from the user.
Run one loop from i = 0 to i = size - 1.
Run another inner loop from j = 0 to j = size - 1.
- Inside the inner loop, print a star if the value of i is equal to j or j is equal to size - i - 1. Else, print a blank space.

Example 1: Java program to print star X pattern with for loops:

Below is the complete program:

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("Enter the size of the pattern:");
        int size = scanner.nextInt();

        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                if (i == j || j == size - i - 1)
                    System.out.print("* ");
                else
                    System.out.print("  ");
            }
            System.out.println();
        }
    }
}

The size of the pattern is assigned to the size variable.
The for loops are used to print the pattern as we discussed before.

It will print outputs as below:

Enter the size of the pattern:
6
*         * 
  *     *   
    * *     
    * *     
  *     *   
*         * 

Enter the size of the pattern:
7
*           * 
  *       *   
    *   *     
      *       
    *   *     
  *       *   
*           *

Example 2: Java program to print star X pattern with while loops:

The following program uses while loops to print the X pattern with stars:

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int i = 0, j;

        System.out.println("Enter the size of the pattern:");
        int size = scanner.nextInt();

        while (i < size) {
            j = 0;
            while (j < size) {
                if (i == j || j == size - i - 1)
                    System.out.print("* ");
                else
                    System.out.print("  ");
                j++;
            }
            System.out.println();
            i++;
        }
    }
}

This program prints similar results. Make sure to initialize the variables used in the loops before the loop starts.

Example 3: Java program to print the X pattern with any character:

We can always take the character as input from the user and print the pattern by using that character.

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("Enter the size of the pattern:");
        int size = scanner.nextInt();

        System.out.println("Enter the character to print the pattern:");
        char c = scanner.next().charAt(0);

        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                if (i == j || j == size - i - 1)
                    System.out.print(c + " ");
                else
                    System.out.print("  ");
            }
            System.out.println();
        }
    }
}

One new character variable, c is introduced in this program.
It asks the user to enter the character to print the X pattern. It uses the scanner variable to read that value and assigns it to the variable c.
Inside the loop, it prints the value of c in place of star.

It will print the X pattern with any character you provide:

Enter the size of the pattern:
5
Enter the character to print the pattern:
&
&       & 
  &   &   
    &     
  &   &   
&       & 

Enter the size of the pattern:
6
Enter the character to print the pattern:
#
#         # 
  #     #   
    # #     
    # #     
  #     #   
#         #

Java program to print a plus star pattern

Tue, 14 Feb 2023 09:39:27 GMT

Java program to print a plus star pattern:

In this post, we will write one program to print the plus pattern with star or any other character in Java. This program will read the size of the pattern as input from the user and print the pattern. Before we start writing the program, let me show you how the algorithm works.

Algorithm to print a plus star pattern:

Let’s have a look at the below plus pattern:

     * 
     * 
     * 
     * 
     * 
***********
     * 
     * 
     * 
     * 
     *

This pattern is of height 6. We are using blank space and stars to print the pattern. To understand, how the blank spaces are printed, let me replace all blank spaces with #:

#####*
#####*
#####*
#####*
#####*
***********
#####*
#####*
#####*
#####*
#####*

To print this pattern, we will use one outer for loop and two inner for loops.

The outer loop will run from i = 1 to i = 2*n - 1
In this loop,
- If i is equal to n, run one loop for 2*n - 1 time to print the stars.
- Else, print one loop from j = 1 to j = n. If j is equal to n, print a star. Else, print a blank space.
Add a new-line at the end of each

Example 1: Java program to print a plus pattern with star and for loops:

The below program uses the above algorithm to print a plus pattern with star.

import java.util.Scanner;

public class Main {
    
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Enter the size of the pattern : ");
        int size = scanner.nextInt();

        for (int i = 1; i <= 2 * size - 1; i++) {

            if (i == size) {
                for (int j = 1; j <= 2 * size - 1; j++) {
                    System.out.print("*");
                }
            } else {
                for (int j = 1; j <= size; j++) {
                    if (j == size)
                        System.out.print("*");
                    else
                        System.out.print(" ");
                }
            }

            System.out.println();
        }
    }
}

This program is using the same algorithm explained above. It is using a Scanner object to read the user-input size value.

Sample output:

Enter the size of the pattern : 
5
    *
    *
    *
    *
*********
    *
    *
    *
    *

Enter the size of the pattern : 
7
      *
      *
      *
      *
      *
      *
*************
      *
      *
      *
      *
      *
      *

Example 2: Java program to print a plus pattern with star and while loops:

The above program can be modified to use while loops. The below program uses while loops to print the pattern:

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Enter the size of the pattern : ");
        int size = scanner.nextInt();
        int i = 1, j = 2;
        while (i <= 2 * size - 1) {

            if (i == size) {
                j = 1;
                while (j <= 2 * size - 1) {
                    System.out.print("*");
                    j++;
                }
            } else {
                j = 1;
                while (j <= size) {
                    if (j == size)
                        System.out.print("*");
                    else
                        System.out.print(" ");
                    j++;
                }
            }

            System.out.println();
            i++;
        }
    }
}

With while loops, we have to initialize the variable before the loop starts and increment its value at the end of the loop. It will print similar results.

Example 3: Java program to print a plus pattern with any character:

We can take a character as input from the user and use that character to print the pattern.

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Enter the size of the pattern : ");
        int size = scanner.nextInt();

        System.out.println("Enter the character to print the pattern: ");
        char c = scanner.next().charAt(0);

        for (int i = 1; i <= 2 * size - 1; i++) {

            if (i == size) {
                for (int j = 1; j <= 2 * size - 1; j++) {
                    System.out.print(c);
                }
            } else {
                for (int j = 1; j <= size; j++) {
                    if (j == size)
                        System.out.print(c);
                    else
                        System.out.print(" ");
                }
            }

            System.out.println();
        }
    }
}

We added a new character variable c, which is the character used in the pattern. This value is taken as an input from the user. It will use any character to print the pattern:

Enter the size of the pattern : 
5
Enter the character to print the pattern: 
#
    #
    #
    #
    #
#########
    #
    #
    #
    #

Java program to print hollow diamond star pattern

Sun, 12 Feb 2023 09:39:27 GMT

Java program to print hollow diamond star pattern:

The diamond pattern is similar to printing a hollow triangle pattern. We have to print one hollow triangle and one reverse triangle to print the hollow diamond pattern.

For example, if we have to print the below pattern:

     *
    * *
   *   *
  *     *
 *       *
*         *
 *       *
  *     *
   *   *
    * *
     *

we will print the upper triangle:

     *
    * *
   *   *
  *     *
 *       *
*         *

and the lower triangle:

 *       *
  *     *
   *   *
    * *
     *

We will break the algorithm into two parts: to print the upper triangle and to print the lower triangle. The program will join these parts to print the complete program.

Algorithm to print the upper triangle:

We have to use one loop and two inner loops to print the triangles. To print the upper triangle,

Run one loop from i = 1 to i = height, where height is the height for the upper triangle.
- Run one inner loop from 1 to height - i to print the blank spaces.
- Run another inner loop from 1 to 2*i - 1. For the first and the last iteration, print a star, else print a blank space.
- At the end of each iteration of the main loop, print a new-line character to move to the next line.

Algorithm to print the lower triangle:

To print the lower triangle, we will have to use a similar algorithm.

The outer loop will run from i = height - 1 to i > 0 and on each step, the value of i is decremented by 1.
The inner loops will work in a similar way.

Let’s use these algorithms to print the complete pattern.

Example 1: Java program to print a hollow diamond pattern:

The below program prints a hollow diamond pattern. It uses the above algorithm:

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("Enter the height of the pattern: ");
        int height = scanner.nextInt();

        for (int i = 1; i <= height; i++) {
            for (int j = 1; j <= height - i; j++) {
                System.out.print(" ");
            }
            for (int k = 1; k <= 2 * i - 1; k++) {
                if (k == 1 || k == 2 * i - 1) {
                    System.out.print("*");
                } else {
                    System.out.print(" ");
                }
            }
            System.out.println();
        }

        for (int i = height - 1; i > 0; i--) {
            for (int j = 1; j <= height - i; j++) {
                System.out.print(" ");
            }
            for (int k = 1; k <= 2 * i - 1; k++) {
                if (k == 1 || k == 2 * i - 1) {
                    System.out.print("*");
                } else {
                    System.out.print(" ");
                }
            }
            System.out.println();
        }
    }
}

It reads the height of the pattern and assigns it to the height variable. If you run this program, it will print outputs as below:

Enter the height of the pattern: 
5
    *
   * *
  *   *
 *     *
*       *
 *     *
  *   *
   * *
    *

Example 2: Java program to print a hollow diamond pattern by using a separate method:

We can write a different method and move the logical part to this method. This method will take the height as a parameter and print the pattern.

import java.util.Scanner;

public class Main {

    private static void printHollowDiamond(int height) {
        for (int i = 1; i <= height; i++) {
            for (int j = 1; j <= height - i; j++) {
                System.out.print(" ");
            }
            for (int k = 1; k <= 2 * i - 1; k++) {
                if (k == 1 || k == 2 * i - 1) {
                    System.out.print("*");
                } else {
                    System.out.print(" ");
                }
            }
            System.out.println();
        }

        for (int i = height - 1; i > 0; i--) {
            for (int j = 1; j <= height - i; j++) {
                System.out.print(" ");
            }
            for (int k = 1; k <= 2 * i - 1; k++) {
                if (k == 1 || k == 2 * i - 1) {
                    System.out.print("*");
                } else {
                    System.out.print(" ");
                }
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("Enter the height of the pattern: ");
        int height = scanner.nextInt();

        printHollowDiamond(height);
    }
}

Here, printHollowDiamond is the new method we are using to print the pattern.

You can see that the code in the for loop is similar for both loops. We can move that part to a separate method:

import java.util.Scanner;

public class Main {

    private static void printPattern(int height, int i) {
        for (int j = 1; j <= height - i; j++) {
            System.out.print(" ");
        }
        for (int k = 1; k <= 2 * i - 1; k++) {
            if (k == 1 || k == 2 * i - 1) {
                System.out.print("*");
            } else {
                System.out.print(" ");
            }
        }
        System.out.println();
    }

    private static void printHollowDiamond(int height) {
        for (int i = 1; i <= height; i++) {
            printPattern(height, i);
        }

        for (int i = height - 1; i > 0; i--) {
            printPattern(height, i);
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("Enter the height of the pattern: ");
        int height = scanner.nextInt();

        printHollowDiamond(height);
    }
}

It will make the code clean and concise.

How to print a Hollow Rhombus pattern in Java

Fri, 10 Feb 2023 09:39:27 GMT

How to print a Hollow Rhombus pattern in Java:

In this post, we will learn how to print a hollow Rhombus pattern with star in Java. I will show you how the algorithm works and how to write it in Java.

Algorithm to print a Rhombus:

A Rhombus of height 10 drawn with stars looks as below:

         * * * * * * * * * * 
        *                 * 
       *                 * 
      *                 * 
     *                 * 
    *                 * 
   *                 * 
  *                 * 
 *                 * 
* * * * * * * * * *

To understand how it works, let’s try it with a small Rhombus:

    * * * * * 
   *       * 
  *       * 
 *       * 
* * * * *

This is a Rhombus of height 5. We are using stars and blank spaces to print this pattern. Let me replace all blank spaces with #:

####* * * * * 
###* # # # * 
##* # # # * 
#* # # # * 
* * * * *

If you look closely,

On each row, it prints #, stars or # and stars.
We can run one for loop from i = 1 to i = height
- Inside this loop, run two for loops, the first one will print the starting blank spaces and the second one will print stars and blank spaces.
- The first inner loop will run from j = 1 to j = height - i. On each iteration, it will print a blank space.
- The second inner loop will run from k = 1 to k = height. If the value of i or k is 1 or height, it will print a star, else it will print a blank space on each iteration.

Example 1: Java program to print a hollow Rhombus with for loops:

The below Java program prints a hollow Rhombus pattern with user-input height value:

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Enter the height of the Rhombus: ");

        int height = scanner.nextInt();

        for (int i = 1; i <= height; i++) {
            for (int j = 1; j <= height - i; j++) {
                System.out.print(" ");
            }
            for (int k = 1; k <= height; k++) {
                if (i == 1 || i == height || k == 1 || k == height) {
                    System.out.print("* ");
                } else {
                    System.out.print("  ");
                }
            }
            System.out.println();
        }
    }
}

It reads the height of the Rhombus and assigns it to the variable height. It is following the same algorithm we discussed above. You can run this program to print a Rhombus of any height.

Enter the height of the Rhombus: 
10
         * * * * * * * * * * 
        *                 * 
       *                 * 
      *                 * 
     *                 * 
    *                 * 
   *                 * 
  *                 * 
 *                 * 
* * * * * * * * * *

Example 2: Java program to print a hollow Rhombus with while loops:

We can re-write the above program with while loops. We have to initialize the variable before the loop starts and increment the value at the end of each iteration in the loop.

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Enter the height of the Rhombus: ");

        int height = scanner.nextInt();
        int i = 1, j, k;

        while (i <= height) {
            j = 1;
            while (j <= height - i) {
                System.out.print(" ");
                j++;
            }

            k = 1;
            while (k <= height) {
                if (i == 1 || i == height || k == 1 || k == height) {
                    System.out.print("* ");
                } else {
                    System.out.print("  ");
                }
                k++;
            }
            System.out.println();
            i++;
        }
    }
}

This works exactly like the above program. You will get similar result.

Enter the height of the Rhombus: 
6
     * * * * * * 
    *         * 
   *         * 
  *         * 
 *         * 
* * * * * *

3 ways to find perfect numbers in a range in Java

Thu, 09 Feb 2023 09:39:27 GMT

How to find perfect numbers in a range in Java:

This post will explain how to write a Java program to find all perfect numbers in a given range. You will understand how to check if a number is a perfect number or not and how to find all perfect numbers in a given range.

What is a perfect number:

A number is called a perfect number if the number is equal to the sum of its factors, excluding the number itself.

For example, 6 is a perfect number because the sum of its factors is 1 + 2 + 3 which is equal to 6.

So, we need to find the factors of a number and by comparing the sum of the factors with the number itself, we can say if the number is a perfect number or not.

Example 1: Java program to find the perfect numbers in a given range:

The below program shows how to find all the perfect numbers in a user-given range:

import java.util.Scanner;

public class Main {

    private static boolean isPerfect(int n) {
        int sum = 1;
        for (int i = 2; i < n; i++) {
            if (n % i == 0)
                sum += i;
        }
        return sum == n && n != 1;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int start, end;

        System.out.println("Enter the start of the range: ");
        start = scanner.nextInt();

        System.out.println("Enter the end of the range: ");
        end = scanner.nextInt();

        System.out.println("Perfect numbers in between " + start + " and " + end + " are:");
        for (int no = start; no <= end; no++) {
            if (isPerfect(no)) {
                System.out.println(no);
            }
        }
    }
}

It uses a Scanner variable to read the start and end of the range.
It uses a for loop to find all perfect numbers between start and end(inclusive).
On each iteration, it calls the isPerfect method to check if the number is a perfect number or not.
The isPerfect method takes one number as its parameter and returns one boolean value defining if the number is a perfect number or not.
- It initializes one variable sum as 1 to hold the sum of the factors of the number. It is initialized as 1 as 1 is the factor of all numbers.
- It runs one for loop from i = 2 to i = n - 1, where n is the given number.
- On each iteration, it checks if i can divide the number n or not. If yes, it will add that value to the sum variable.
At the end of this method, it returns true if the calculated sum is equal to the given number and if it is not equal to 1. Else, it returns false.

Example 2: Java program to find the perfect numbers in a given range by iterating up to half of the number:

We can reduce the iteration by half. Instead of iterating from 2 to number - 1, we can iterate from 2 to number/2 as larger than this value can’t be a factor of the number.

The final program become:

import java.util.Scanner;

public class Main {

    private static boolean isPerfect(int n) {
        int sum = 1;
        for (int i = 2; i <= n/2; i++) {
            if (n % i == 0)
                sum += i;
        }
        return sum == n && n != 1;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int start, end;

        System.out.println("Enter the start of the range: ");
        start = scanner.nextInt();

        System.out.println("Enter the end of the range: ");
        end = scanner.nextInt();

        System.out.println("Perfect numbers in between " + start + " and " + end + " are:");
        for (int no = start; no <= end; no++) {
            if (isPerfect(no)) {
                System.out.println(no);
            }
        }
    }
}

The only change in this program is:

...
...
for (int i = 2; i <= n/2; i++) {
    ...

It will work similarly to the above program but it will be faster.

Example 3: Recursive Java program to find the perfect numbers in a given range:

Let’s write down the program recursively. The isPerfect method will recursively check if a number is perfect or not.

import java.util.Scanner;

public class Main {

    private static boolean isPerfect(int n, int i, int sum) {
        if(n == 1)
            return false;

        if (i > n / 2)
            return sum == n;

        if (n % i == 0)
            return isPerfect(n, i + 1, sum + i);
        else
            return isPerfect(n, i + 1, sum);
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int start, end;

        System.out.println("Enter the start of the range: ");
        start = scanner.nextInt();

        System.out.println("Enter the end of the range: ");
        end = scanner.nextInt();

        System.out.println("Perfect numbers in between " + start + " and " + end + " are:");
        for (int no = start; no <= end; no++) {
            if (isPerfect(no, 2, 1)) {
                System.out.println(no);
            }
        }
    }
}

The isPerfect method is changed to take three parameters. It takes n, i and sum variables as the parameters.
This method is called with i = 2 and sum = 1 in the main method.
Once the value of i increases more than number/2, it checks if the value of sum and n are equal or not and returns that value. Else, it checks if the current value of i is a factor of n or not and calls the isPerfect method recursively.

It will give similar output.

Enter the start of the range: 
1
Enter the end of the range: 
10000
Perfect numbers in between 1 and 10000 are:
6
28
496
8128

How to find the product of digits of a number in Java

Wed, 08 Feb 2023 09:39:27 GMT

How to find the product of digits of a number in Java:

We can iterate over the digits of a number and multiply all of the digits to find the final product. The algorithm works in a similar way in all programming languages. If you know how to write the program in any other language, it won’t be difficult to write it in Java.

I will explain how the algorithm works and I will also show you how to write the Java program in this post.

Algorithm to find the product of the digits of a number:

We can use the below algorithm to find the product of digits of a given number:

Take the number as input from the user.
Create a copy of the number. The algorithm will work on the copied number.
Run one loop until the number becomes 0.
Initialize one variable as 1 to hold the final product of the digits of the number.
Inside the loop,
1. Get the rightmost digit of the number by using the modulo operator.
2. Multiply the digit by the product variable and assign that value to the product variable.
3. Remove the rightmost digit from the number.
Once the loop will end, the product variable will hold the final product of the digits of the number.

Example 1: Java program to find the product of digits of a number:

The following Java program uses the above algorithm to find the product of digits of a user-input number:

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int num, copyNum, lastDigit, product = 1;

        System.out.println("Enter a number: ");
        num = scanner.nextInt();

        copyNum = num;

        while (copyNum > 0) {
            lastDigit = copyNum % 10;
            product *= lastDigit;
            copyNum /= 10;
        }

        System.out.println("Product of all digits of " + num + " is: " + product);
    }
}

In this program,

We created one object of Scanner class to read the user input values.
The num variable holds the user input number, the copyNum variable is used to hold the copy of the number, the lastDigit variable is used to hold the last digit of the number and the product variable is used to hold the product of all digits of the number. The product variable is initialized as 1.
In the while loop, it finds the last digit of the number and multiplies it with the product variable. It removes the last digit of the *copyNum variable on each iteration.
At the end of the program, it prints the result.

If you run this program, it will give results as below:

Enter a number: 
55555
Product of all digits of 55555 is: 3125

Example 2: Java program to find the product of digits of a number by using a for loop:

We can also use a for loop to find the product of the digits of a number. This works almost similar to the above program.

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int num, copyNum, lastDigit, product = 1;

        System.out.println("Enter a number: ");
        num = scanner.nextInt();

        copyNum = num;

        for (; copyNum > 0; copyNum /= 10) {
            lastDigit = copyNum % 10;
            product *= lastDigit;
        }

        System.out.println("Product of all digits of " + num + " is: " + product);
    }
}

The initialization part of the for loop is empty as we are not initializing anything. It will run until the value of copyNum is greater than 0 and at the end of each iteration, it removes the last digit of the number.

You will get similar results if you run this program.

Java ArrayList clone method explanation with example

Tue, 07 Feb 2023 09:39:27 GMT

Java ArrayList clone method:

The clone() method of Java ArrayList is used to do a shallow copy of an ArrayList in Java. In this post, we will learn how this method works with examples.

Definition of ArrayList.clone() method:

The clone() method is defined in java.util.ArrayList class as:

public Object clone()

This method returns a shallow copy of the ArrayList instance. Note that it is a shallow copy. This method doesn’t take any parameter and it returns a copy of the ArrayList.

Example 1: Example of ArrayList.clone() method with an integer ArrayList:

Let’s write one program that uses the ArrayList.clone() method to clone an ArrayList:

import java.util.ArrayList;

class Example {
    public static void main(String[] args) {

        ArrayList<Integer> numList = new ArrayList<>();

        numList.add(1);
        numList.add(2);
        numList.add(3);
        System.out.println("Given ArrayList: " + numList);

        ArrayList<Integer> cloneList = (ArrayList<Integer>) numList.clone();

        System.out.println("New cloned ArrayList: " + cloneList);
    }
}

In this example,

The numList is an ArrayList of integers.
We added three numbers to the ArrayList.
The clone method return an Object. So, the value is casted to an ArrayList and assigned to the cloneList variable.
The last line is printing the new cloned ArrayList.

If you run this program, it will print the below output:

Given ArrayList: [1, 2, 3]
New cloned ArrayList: [1, 2, 3]

Example 2: Example of ArrayList.clone() method with an ArrayList of objects:

The following example uses ArrayList.clone() method with an ArrayList of objects:

import java.util.ArrayList;

class Student {
    String name;
    int age;

    public Student(String mName, int mAge) {
        this.name = mName;
        this.age = mAge;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

class Example {
    public static void main(String[] args) {

        ArrayList<Student> givenList = new ArrayList<>();

        givenList.add(new Student("Alex", 12));
        givenList.add(new Student("Daisy", 10));
        givenList.add(new Student("Bob", 11));
        System.out.println("Given ArrayList: " + givenList);

        ArrayList<Student> cloneList = (ArrayList<Student>) givenList.clone();

        System.out.println("New cloned ArrayList: " + cloneList);
    }
}

We created a class Student and three different objects of this class are added to the ArrayList givenList. The clone() method is called on this ArrayList and the returned value is assigned to the cloneList variable.

This works similar to the previous example and it will print the below output.

Given ArrayList: [Student{name='Alex', age=12}, Student{name='Daisy', age=10}, Student{name='Bob', age=11}]
New cloned ArrayList: [Student{name='Alex', age=12}, Student{name='Daisy', age=10}, Student{name='Bob', age=11}]

What will happen if we modify an item in the cloned ArrayList:

Let’s make some changes to the above example:

import java.util.ArrayList;

class Student {
    String name;
    int age;

    public Student(String mName, int mAge) {
        this.name = mName;
        this.age = mAge;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

class Example {
    public static void main(String[] args) {

        ArrayList<Student> givenList = new ArrayList<>();

        givenList.add(new Student("Alex", 12));
        givenList.add(new Student("Daisy", 10));
        givenList.add(new Student("Bob", 11));

        System.out.println("Given ArrayList: " + givenList);
        ArrayList<Student> cloneList = (ArrayList<Student>) givenList.clone();
        System.out.println("New cloned ArrayList: " + cloneList);

        cloneList.get(0).setAge(10);

        System.out.println("Given ArrayList after modification: " + givenList);
        System.out.println("New cloned ArrayList after modification: " + cloneList);
    }
}

We added a new method setAge to the Student class that can be used to change the age of a Student object.
It updates the age of the first object to 10 on the cloned list.
Both original and cloned lists are printed after the age is changed.

If you run this program, it will print:

Given ArrayList: [Student{name='Alex', age=12}, Student{name='Daisy', age=10}, Student{name='Bob', age=11}]
New cloned ArrayList: [Student{name='Alex', age=12}, Student{name='Daisy', age=10}, Student{name='Bob', age=11}]
Given ArrayList after modification: [Student{name='Alex', age=10}, Student{name='Daisy', age=10}, Student{name='Bob', age=11}]
New cloned ArrayList after modification: [Student{name='Alex', age=10}, Student{name='Daisy', age=10}, Student{name='Bob', age=11}]

As the method clone() returns a shallow copy, once we made any changes to the cloned list, it also updates the object of the original list.

Java ArrayList ensureCapacity method

Mon, 06 Feb 2023 09:39:27 GMT

Java ArrayList ensureCapacity method:

The ensureCapacity method is used to increase the capacity of an ArrayList if required. This method is defined in java.util.ArrayList class. In this post, we will learn how to use this method with examples.

Definition of ensureCapacity:

The ensureCapacity method is defined as:

public void ensureCapacity(int minCapacity)

It takes one parameter, minCapacity. The ArrayList ensures that it will hold at least minCapacity number of elements.

Let’s try this method with an example.

Example of ensureCapacity:

Let’s take a look at the below example:

import java.util.ArrayList;  
  
public class Main {  
  
    public static void main(String[] args) {  
        ArrayList<Integer> numList = new ArrayList<>();  
        numList.add(1);  
        numList.add(2);  
        numList.add(3);  
        numList.ensureCapacity(40);  
  
        System.out.println(numList);  
    }  
}

In this example, numList is an ArrayList of integers. Three numbers are added to this ArrayList and the ensureCapacity method is used with 40 as its parameter.

If you run this program, you will see that it will print only the numbers we added to the ArrayList:

[1, 2, 3]

Example of ensureCapacity with a smaller minCapacity than the number of items:

We can add a smaller minCapacity value than the number of items added to the ArrayList:

import java.util.ArrayList;

public class Main {

    public static void main(String[] args) {
        ArrayList<Integer> numList = new ArrayList<>();
        numList.add(1);
        numList.add(2);
        numList.add(3);
        numList.ensureCapacity(1);

        System.out.println(numList);
    }
}

In this example, we added three items to the ArrayList and called the ensureCapacity method with 1 as its parameter.

Since minCapacity can define the minimum number of elements an ArrayList can hold, it will not make any difference.

If you run this program, it will print:

[1, 2, 3]

Example of ensureCapacity with a negative value:

We can also provide a negative value to the ensureCapacity method. It will not throw any exceptions:

import java.util.ArrayList;

public class Main {

    public static void main(String[] args) {
        ArrayList<Integer> numList = new ArrayList<>();
        numList.add(1);
        numList.add(2);
        numList.add(3);
        numList.ensureCapacity(-10);

        System.out.println(numList);
    }
}

It will not throw any exceptions and it will print the same output.

4 different Java program to find the HCF or GCD of two numbers

Mon, 23 Jan 2023 09:39:27 GMT

Java program to find the HCF or GCD of two numbers:

Let’s learn how to find the HCF of two numbers in Java. HCF is also called GCD. The full form of HCF is Highest Common Factor and the full form of GCD is Greatest Common Divisor.

The HCF or GCD of two or more numbers is the largest non-zero common factor of these numbers. For example, the GCD of 8 and 12 is 4. Because

The factors of 8 are 1, 2, 4, 8
The factors of 12 are 1, 2, 3, 4, 6, 12

The highest common factor is 4.

Let me explain the algorithm before we start writing the program.

Algorithm to find the HCF or GCD of two numbers:

The program will take the numbers as inputs from the user.

Take the numbers as inputs from the user and assign the values to two different variables.
Initialize one variable to hold the HCF value.
Run one loop from 1 to the smaller value of the two numbers.
- Inside the loop, check if the current variable used in the loop can divide both numbers or not. If yes, assign this value to the HCF variable.
Once the loop ends, the HCF variable will hold the required HCF or GCD.

Basically, we are using a loop from 1 to the smaller number and dividing both the numbers by the loop variable to find the GCD or HCF. The largest value that can divide both of these numbers is the GCD of the two numbers.

Method 1: Java program to find the GCD or HCF by using a for loop:

The below Java program uses the above algorithm to find the GCD:

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        int first, second, hcf = 1;
        Scanner scanner = new Scanner(System.in);

        System.out.println("Enter the first number: ");
        first = scanner.nextInt();

        System.out.println("Enter the second number: ");
        second = scanner.nextInt();

        for (int i = 2; i <= first || i <= second; i++) {
            if (first % i == 0 && second % i == 0) {
                hcf = i;
            }
        }

        System.out.println("HCF: " + hcf);
    }
}

The integer variables first and second are used to hold the first and the second numbers, hcf is used to hold the calculated HCF. It is initialized as 1.
This program uses a Scanner object to read the user input numbers.
The for loop runs from i = 2. We have already defined hcf as 1. So, we need to find any value that can divide both the numbers and which is greater than 1.
The value of hcf is updated if i can divide both the numbers.
At the end of the program, it prints the calculated HCF value.

Sample result:

Enter the first number: 
4
Enter the second number: 
12
HCF: 4

Method 2: Java program to find HCF or GCD by using a while loop:

We can easily convert the above program to use a while loop instead of a for loop. The only change we need is to initialize the variable i before the loop starts and increment its value at the end of each iteration of the loop.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        int first, second, hcf = 1, i = 2;
        Scanner scanner = new Scanner(System.in);

        System.out.println("Enter the first number: ");
        first = scanner.nextInt();

        System.out.println("Enter the second number: ");
        second = scanner.nextInt();

        while (i <= first || i <= second) {
            if (first % i == 0 && second % i == 0) {
                hcf = i;
            }
            i++;
        }

        System.out.println("HCF: " + hcf);
    }
}

This program will print similar results.

Method 3: Java program to find HCF with repeated subtraction:

This is another way to find HCF. We will run a while loop until the numbers become equal. On each iteration, it will subtract the smaller number from the bigger number and assign this to the bigger number variable.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        int first, second;
        Scanner scanner = new Scanner(System.in);

        System.out.println("Enter the first number: ");
        first = scanner.nextInt();

        System.out.println("Enter the second number: ");
        second = scanner.nextInt();

        while (first != second) {
            if (first > second)
                first = first - second;
            else
                second = second - first;
        }

        System.out.println("HCF: " + first);
    }
}

The number variable holds the required HCF.

Method 4: By using the Euclidean Algorithm:

This is one of the most efficient algorithms to find the GCD.

import java.util.Scanner;

public class Main {
    static int findGCD(int first, int second){
        if(second == 0)
            return first;
        return findGCD(second , first % second);
    }

    public static void main(String[] args) {
        int first, second;
        Scanner scanner = new Scanner(System.in);

        System.out.println("Enter the first number: ");
        first = scanner.nextInt();

        System.out.println("Enter the second number: ");
        second = scanner.nextInt();

        System.out.println("GCD: " + findGCD(first, second));
    }
}

This algorithm is based on a similar fact as the previous algorithm. If we keep subtracting the smaller number from the larger number, we will get the GCD once both become equal. We can also divide the first number by the second number and assign the remainder to the second number and assign the original second number to the first number. When the second number will become 0, the first number will hold the GCD value. This program will also give similar results.

3 ways to convert System.nanoTime to seconds in Java

Thu, 19 Jan 2023 09:39:27 GMT

How to convert System.nanoTime to seconds in Java:

In this post, we will learn how to convert System.nanoTime to seconds in Java in different ways. The System.nanoTime method is used to get the current value of the JVM’s time source in nanoseconds. The return value of System.nanoTime should only be used to find elapsed time. It is not related to system time.

System.nanoTime:

The nanoTime is a static method defined in the System class:

public static native long nanoTime();

It returns the time in long format.

This method is used mostly to find out the execution time in code. We can calculate this value in two places and find the difference to get the execution time between the two points. Let’s learn how to convert the nanoseconds value to seconds in different ways in Java with examples.

Method 1: By division:

We know that 1 second is equal to 1000000000 nanoseconds. So, if we divide the nanoseconds value by 1000000000, it will return the value in seconds.

public class Main {
    public static void main(String[] args) {
        long startTime = System.nanoTime();
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        long timeDiff = System.nanoTime() - startTime;
        double timeDiffInSeconds = (double) timeDiff / 1_000_000_000;

        System.out.println("Time difference in nanoseconds: " + timeDiff);
        System.out.println("Time difference in seconds: " + timeDiffInSeconds);
    }
}

In this example, we captured the time at the start of the program. The program is halted for 10 seconds by using Thread.sleep. It captured the time again and time difference is calculated.

The variable time is used to hold the time difference in nanoseconds. We divided this time by 1000000000 to find the difference in seconds and the value is assigned to timeDiffInSeconds variable.

If you run this program, it will print:

Time difference in nanoseconds: 10004324181
Time difference in seconds: 10.004324181

Method 2: By using TimeUnit.toSeconds():

The TimeUnit class provides a method toSeconds to convert a value to seconds. We can use this method to convert a nanoseconds value to seconds.

This method returns the converted value in long format.

public long toSeconds(long duration)

Let me show you how it works with an example:

import java.util.concurrent.TimeUnit;

public class Main {
    public static void main(String[] args) {
        long startTime = System.nanoTime();
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        long timeDiff = System.nanoTime() - startTime;
        long timeDiffInSeconds = TimeUnit.NANOSECONDS.toSeconds(timeDiff);

        System.out.println("Time difference in nanoseconds: " + timeDiff);
        System.out.println("Time difference in seconds: " + timeDiffInSeconds);
    }
}

This is similar to the first example. I am using TimeUnit.NANOSECONDS.toSeconds method to convert the nanoseconds value to seconds.

It will print:

Method 3: By using TimeUnit.convert():

There is one more method in the TimeUnit class called convert() for time conversion. We can use it to convert the nanoseconds time to seconds. This method takes two parameters:

public long convert(long sourceDuration, TimeUnit sourceUnit)

The first parameter is the time in long that we wants to convert. The second parameter is the unit of the source time that we are converting. It returns the converted time in long format.

import java.util.concurrent.TimeUnit;

public class Main {
    public static void main(String[] args) {
        long startTime = System.nanoTime();
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        long timeDiff = System.nanoTime() - startTime;
        long timeDiffInSeconds = TimeUnit.SECONDS.convert(timeDiff, TimeUnit.NANOSECONDS);

        System.out.println("Time difference in nanoseconds: " + timeDiff);
        System.out.println("Time difference in seconds: " + timeDiffInSeconds);
    }
}

We are passing the time difference in nanoseconds as the first parameter and TimeUnit.NANOSECONDS as the second parameter. This method returns the time in seconds:

Time difference in nanoseconds: 10003272169
Time difference in seconds: 10

Java String charAt method explanation with examples

Wed, 18 Jan 2023 09:39:27 GMT

Java String charAt method:

The charAt method of Java string is used to find a character at any given index. This is a predefined method of Java string class and we can use it on any string object in Java.

Let’s learn how this method is defined in Java and how to use it with examples.

Definition of Java String charAt:

The charAt method is defined as below:

public char charAt(int i)

This method takes only one parameter. It is i, i.e. the index of the character we want.
It returns the character at index i.
The index starts from 0 and ends at length of the string - 1.

Exception:

This method might throw IndexOutOfBoundsException if the index i is not valid.

Example to use charAt:

Let’s try this method with an example. The below program takes the index as input from the user and prints the character at that index:

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        String givenString = "The quick brown fox jumps over the lazy dog";
        int index;
        Scanner scanner = new Scanner(System.in);

        System.out.println("Given String: " + givenString);
        System.out.println("Enter the index of the character: ");
        index = scanner.nextInt();

        System.out.println("Character at this index is: " + givenString.charAt(index));
    }
}

In this example,

givenString is the given string.
It asks the user to enter the index of the character. It reads that index and assigns that value to the index variable.
The last line is printing the character at the user-given index.

It will give output as below:

Given String: The quick brown fox jumps over the lazy dog
Enter the index of the character: 
5
Character at this index is: u

Exception on charAt:

If the user provides any invalid index, it throws an exception. For example, if the input is -1, it will throw an exception:

Given String: The quick brown fox jumps over the lazy dog
Enter the index of the character: 
-1
Exception in thread "main" java.lang.StringIndexOutOfBoundsException: String index out of range: -1
	at java.base/java.lang.StringLatin1.charAt(StringLatin1.java:48)
	at java.base/java.lang.String.charAt(String.java:711)
	at com.company.Main.main(Main.java:15)

We can use a try-catch block to handle this exception.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        String givenString = "The quick brown fox jumps over the lazy dog";
        int index;
        Scanner scanner = new Scanner(System.in);

        System.out.println("Given String: " + givenString);
        System.out.println("Enter the index of the character: ");
        index = scanner.nextInt();

        try {
            System.out.println("Character at this index is: " + givenString.charAt(index));
        } catch (StringIndexOutOfBoundsException e) {
            System.out.println("Please enter a valid index.");
        }
    }
}

This will print a message on any exception.

Different ways to add elements to an ArrayList in Java

Wed, 11 Jan 2023 09:39:27 GMT

How to add elements to an ArrayList in Java:

Java ArrayList provides a method called add that can be used to add elements to the ArrayList. This method is used to append an element to the end of the ArrayList or we can use it to add the element at any specific position.

Let’s learn how to use this with examples.

Append an element to the end of the ArrayList:

The add method is defined as:

public boolean add(E e)

Where, e is the element to append to the ArrayList. It will append the element to the end of the ArrayList and return true.

Let’s try it with an example:

import java.util.ArrayList;  
  
public class Main {  
    public static void main(String[] args) {  
        ArrayList<Integer> givenList = new ArrayList<>();  
        givenList.add(1);  
        givenList.add(2);  
        givenList.add(3);  
  
        System.out.println(givenList);  
    }  
}

In this example, we created an empty ArrayList and it used add() to append three numbers to the ArrayList. If you run this program, it will print the below output:

Example 2: Append an element at any specific position:

We can use the add method to append an element at any specific position. Following is the method definition:

public void add(int index, E e)

Here,

index is the index at which the element needs to be inserted.
e is the element to insert.

Note that this method will throw IndexOutOfBoundsException if the given index is invalid. For example, if we pass a negative index or any value that is greater than the size of the ArrayList, it will throw IndexOutOfBoundsException.

Let’s try it with an example:

import java.util.ArrayList;  
  
public class Main {  
    public static void main(String[] args) {  
        ArrayList<Integer> givenList = new ArrayList<>();  
        givenList.add(0);  
        givenList.add(1);  
        givenList.add(3);  
  
        givenList.add(2, 2);  
  
        System.out.println(givenList);  
    }  
}

At first, it appended 0, 1 and 3 to the ArrayList. It appended 2 at index 2. So, the final ArrayList becomes:

[0, 1, 2, 3]

As you can see here, it added 2 to the ArrayList.

Can we execute a Java program without the main method

Sun, 08 Jan 2023 09:39:27 GMT

Java program to execute a program without the main method:

The main method runs when we run a class in Java. For example, if we create a Main.java file with the following code:

public class Main {
    public static void main(String[] args) {
        System.out.println("Inside main");
    }
}

and if we run this program, it will print the string Inside main.

But, if I remove the main method,

public class Main {
    public void hello() {
        System.out.println("Inside main");
    }
}

It will throw an exception:

Error: Main method not found in class com.company.Main, please define the main method as:
   public static void main(String[] args)
or a JavaFX application class must extend javafx.application.Application

How to run a Java program without the main() method:

We can write a Java program without the main method with a static block only up to Java 1.5. A static block is written with the static keyword. This method runs as soon as the class file is loaded to the memory. You have to write your code in the static block:

static{
    // your code
}

You can have more than one static block. These blocks are executed before the main method. The execution order is similar to the order these are added to the class. If you need to run anything before the main method executes, you can add the code in a static block.

So, the below program will work(upto Java 1.5):

public class Main {
    static {
        System.out.println("Inside main");
    }
}

For the later Java versions, we don’t have any other way to run a program without the main method.

How to handle multiple exceptions in Java

Sat, 07 Jan 2023 09:39:27 GMT

How to handle multiple exceptions in Java:

Let’s learn what are multiple exceptions and how to handle multiple exceptions in Java with different examples. For handling exceptions, we use try-catch blocks in Java. We can use a single catch block or we can use multiple catch blocks to handle the exceptions. Let’s learn how to do that with examples.

Handling multiple exceptions with different catch blocks:

This example will show you how to handle multiple exceptions with different catch blocks.

class Example {
    public static void main(String[] args) {
        try {
            String n = null;
            System.out.println(n.charAt(0));
        } catch (NullPointerException e) {
            e.printStackTrace();
        } catch (ArrayIndexOutOfBoundsException e) {
            e.printStackTrace();
        }
    }
}

In this example program, we are trying to read the character at index 0 of the string n. There are two catch blocks to handle the following exceptions:

NullPointerException and
ArrayIndexOutOfBoundsException

If you run this program, it will execute the first exception block i.e. NullPointerException as the value of the string n is null.

If it will get an ArrayIndexOutOfBoundsException before a NullPointerException, it will execute the second catch block. For example:

class Example {
    public static void main(String[] args) {
        try {
            String arr[] = new String[4];
            String n = null;

            System.out.println(arr[10]);
            System.out.println(n.charAt(0));
        } catch (NullPointerException e) {
            e.printStackTrace();
        } catch (ArrayIndexOutOfBoundsException e) {
            e.printStackTrace();
        }
    }
}

This code will run the second catch block.

Handling multiple exceptions with different catch blocks:

We can merge the two exceptions in the above example into one. We have to separate the exceptions with pipe symbol or |. Note that this option is available from Java SE 7.

class Example {
    public static void main(String[] args) {
        try {
            String arr[] = new String[4];
            String n = null;

            System.out.println(arr[10]);
            System.out.println(n.charAt(0));
        } catch (NullPointerException | ArrayIndexOutOfBoundsException e) {
            e.printStackTrace();
        }
    }
}

It will throw ArrayIndexOutOfBoundsException because this exception is raised first.

Handling multiple exceptions with the Exception class:

Since the Exception class is the base class of all other classes, we can use this class in the catch block. We don’t have to add other classes with the Exception class as all other classes are sub-class of this class.

class Example {
    public static void main(String[] args) {
        try {
            String arr[] = new String[4];
            String n = null;

            System.out.println(arr[10]);
            System.out.println(n.charAt(0));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

It will print the following exception:

java.lang.ArrayIndexOutOfBoundsException: 10
	at Example.main(Example.java:9)

Can we have multiple public Java classes in one file

Thu, 05 Jan 2023 09:39:27 GMT

Can we have two public classes in one file in Java:

This is a common Java interview question. The short answer is No. We can’t define more than one public class in the same file. To understand this, let’s take one example.

Learn with an example:

public class Main {
    public static void main(String[] args) {

    }
}

public class SecondClass {
    public static void main(String[] args) {

    }
}

In this example, we created one file Main.java and created two public classes in it. It will throw compile time error. If you are using IntelliJ-Idea, you will see an error as like below:

It is showing an error that the class is public and we should create a new file for that class.

If you click on the More actions button, it will show you two options:

You can create another file for the second public class or
You can change it non-public.

So, we can either create a new file or change the class to non-public.

Example 1: Change the class to non-public:

We can change the second class to non-public class and the program will work:

public class Main {
    public static void main(String[] args) {

    }
}

class SecondClass {
    public static void main(String[] args) {

    }
}

Note that the name of the file should be the same as the public class. In the above example, the file name should be Main.java as the name of the public class is Main.

Example 2: Use the class as a nested class:

Another way is to use the class as a nested class. We can create one class inside another class. These are called inner and outer class.

public class Main {
    public static void main(String[] args) {

    }

    class SecondClass {
        public void main(String[] args) {

        }
    }
}

Here, Main is the outer class and SecondClass is the inner class. These are called nested class. For example,

public class Main {
    public static void main(String[] args) {

    }

    class SecondClass {
        
    }
    
    class ThirdClass {
        
    }

    class FourthClass {

    }
}

3 different Java programs to find the next prime number

Mon, 02 Jan 2023 09:39:27 GMT

Java program to find the next prime number:

In this post, we will learn how to find the next prime number in Java. The program will take one number as its input and it will find the next prime number starting from that number.

The program will use one function to check if a number is a prime number or not. We can use a loop to iterate over the numbers starting from the given number and for each number, the program will check for the prime number. Once a prime number is found, it will print that number and exit from the loop.

What is a prime number:

A number is called a prime number if the number is greater than 1 and it is divisible only by 1 and the number itself.

For example, 23 is a prime number. Because there is no number other than 1 and 23 that can divide it.

Similarly, 20, 21, 22 etc. are not prime numbers.

Example 1: Java program to find the next prime number:

Let’s take a look at the below example program:

import java.util.Scanner;

public class Main {

    private static boolean isPrime(int no) {
        for (int i = 2; i < no; i++) {
            if (no % i == 0) {
                return false;
            }
        }
        return true;
    }

    private static int getNextPrime(int no) {
        for (int i = no + 1; ; i++) {
            if (isPrime(i)) {
                return i;
            }
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int no;

        System.out.println("Enter a number: ");
        no = scanner.nextInt();

        System.out.println("Next prime is: " + getNextPrime(no));
    }
}

This Java program finds the next prime number. It reads the user input number and assigns it to the no variable.
The getNextPrime function finds the next prime number.
- It uses a for loop that runs from one number after the given number and on each iteration, it checks if the current number is prime or not.
To check for a prime number, we are using the isPrime method.
- This method uses a for loop to run from i = 2 to i = number - 1 and if any value of i can divide the number, it returns false. Else, it returns true.

It prints output as below:

Example 2: By iterating up to half of the number:

We can improve the prime number checking method to run the loop from 2 to number/2 as all other numbers larger than number/2 can’t divide the number. It will reduce the loop iteration.

import java.util.Scanner;

public class Main {

    private static boolean isPrime(int no) {
        for (int i = 2; i <= no/2; i++) {
            if (no % i == 0) {
                return false;
            }
        }
        return true;
    }

    private static int getNextPrime(int no) {
        for (int i = no + 1; ; i++) {
            if (isPrime(i)) {
                return i;
            }
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int no;

        System.out.println("Enter a number: ");
        no = scanner.nextInt();

        System.out.println("Next prime is: " + getNextPrime(no));
    }
}

The only change in the program is the for loop of isPrime method. It will give similar results.

Enter a number: 
20
Next prime is: 23

Enter a number: 
100
Next prime is: 101

Enter a number: 
101
Next prime is: 103

Example 3: By iterating up to the square root of the number:

We can further optimize the above program by iterating up to the square root of the number. The loop will run from 2 to square root of the number.

import java.util.Scanner;

public class Main {

    private static boolean isPrime(int no) {
        for (int i = 2; i <= Math.sqrt(no); i++) {
            if (no % i == 0) {
                return false;
            }
        }
        return true;
    }

    private static int getNextPrime(int no) {
        for (int i = no + 1; ; i++) {
            if (isPrime(i)) {
                return i;
            }
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int no;

        System.out.println("Enter a number: ");
        no = scanner.nextInt();

        System.out.println("Next prime is: " + getNextPrime(no));
    }
}

We are using Math.sqrt method to find the square root. It gives similar output.

Java program to calculate student's grades in 2 different ways

Sun, 01 Jan 2023 09:39:27 GMT

Java program to calculate student’s grades:

In this post, we will learn different ways to calculate the grade of a student in Java. We will write one Java program that will ask the user to enter the marks of different subjects for a student. It will then calculate the average of the marks and based on the average value, it will print the grade.

We will use predefined grade mapping i.e. the grades will be defined before the average is calculated. The number of subjects might be different for different students. So, this program will also take the number of subjects as another input.

Defining the grades:

The program will use the following average marks and grade mapping:

Average marks	Grade
>=80	A
>=60 and <80	B
>=30 and <60	C
<30	D

To find the average marks, we will have to add the marks and divide the total sum by the number of subjects.

Example 1: Java program to calculate student grade by using a for loop:

In this program, we will use a for loop to calculate the grade. Below is the complete program:

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        float totalSubjects, totalMarks = 0, averageMarks;
        Scanner scanner = new Scanner(System.in);

        System.out.println("Enter the total number of subjects: ");
        totalSubjects = scanner.nextFloat();

        for (int i = 1; i <= totalSubjects; i++) {
            System.out.println("Enter the marks for subject " + i + ": ");
            totalMarks += scanner.nextFloat();
        }

        averageMarks = totalMarks / totalSubjects;

        if (averageMarks >= 80) {
            System.out.println("Average Marks: " + averageMarks + ", Grade A");
        } else if (averageMarks >= 60) {
            System.out.println("Average Marks: " + averageMarks + ", Grade B");
        } else if (averageMarks >= 30) {
            System.out.println("Average Marks: " + averageMarks + ", Grade C");
        } else {
            System.out.println("Average Marks: " + averageMarks + ", Grade D");
        }
    }
}

Here,

We created three floating point variables, totalSubjects is used to keep the total number of subjects, totalMarks is used to keep the total marks of all subjects and averageMarks is used to keep the average marks of all subjects. Also, one Scanner object is created to read the user input values.
Once the user enters the total number of subjects, it reads that value and assigns it to the totalSubjects variable.
The for loop is used to read the marks of the subjects one by one. It asks the user to enter the marks and it adds that value to the totalMarks variable.
The average mark is calculated by dividing the total marks by the total number of subjects.
The final if, else-if, else statements are used to find the grade. It compares the average mark and prints out the grade and average marks calculated.

This program will give the output as below:

Enter the total number of subjects: 
3
Enter the marks for subject 1: 
92
Enter the marks for subject 2: 
85
Enter the marks for subject 3: 
89
Average Marks: 88.666664, Grade A

Enter the total number of subjects: 
3
Enter the marks for subject 1: 
87
Enter the marks for subject 2: 
88
Enter the marks for subject 3: 
35
Average Marks: 70.0, Grade B

This program will work with any number of subjects.

Example 2: Java program to calculate student’s grade by using separate functions:

We can also use a separate function to calculate the student’s grade with separate functions. We can create one function to read the marks and another function to print the grades. Let’s write down the program:

import java.util.Scanner;

public class Main {

    private static float getAverage() {
        float totalSubjects, totalMarks = 0, averageMarks;
        Scanner scanner = new Scanner(System.in);

        System.out.println("Enter the total number of subjects: ");
        totalSubjects = scanner.nextFloat();

        for (int i = 1; i <= totalSubjects; i++) {
            System.out.println("Enter the marks for subject " + i + ": ");
            totalMarks += scanner.nextFloat();
        }

        return totalMarks / totalSubjects;
    }

    private static void printGrade(float averageMarks) {
        if (averageMarks >= 80) {
            System.out.println("Average Marks: " + averageMarks + ", Grade A");
        } else if (averageMarks >= 60) {
            System.out.println("Average Marks: " + averageMarks + ", Grade B");
        } else if (averageMarks >= 30) {
            System.out.println("Average Marks: " + averageMarks + ", Grade C");
        } else {
            System.out.println("Average Marks: " + averageMarks + ", Grade D");
        }
    }

    public static void main(String[] args) {
        printGrade(getAverage());
    }
}

We created two functions:

The getAverage function reads the marks and calculates the average mark. It returns the average mark.
The printGrade function takes the average mark as its parameter and prints the grade.
In the main function, we are calling the printGrade function and the value that is returned by getAverage is passed.

You will get a similar result with this program.

How to change the values of a dictionary in Python

Fri, 30 Dec 2022 09:39:27 GMT

How to change the values of a dictionary in Python:

In this post, we will learn how to change the values of a dictionary in Python. Python dictionaries are used to store key-value pairs. We can use the keys to access the value associated with that key. To change any value of the dictionary, we can use the key.

Let’s learn different ways to change the dictionary values in Python with examples.

Example 1: Change the value of a Python dictionary by using its key:

Let’s learn how to change the value of a dictionary by using its key. We can refer an item with its key and change its value:

given_dict = {'one': 'Jan', 'two': 'Feb', 'three': 'March'}

print(f'Dictionary before change: {given_dict}')

given_dict['two'] = 2;

print(f'Dictionary after change: {given_dict}')

In this program, we changed the value of the dictionary with the key two. This program prints the value before and after the dictionary is updated.

It will print:

Dictionary before change: {'one': 'Jan', 'two': 'Feb', 'three': 'March'}
Dictionary after change: {'one': 'Jan', 'two': 2, 'three': 'March'}

As you can see here, it updated the value of the key ‘two’.

Example 2: By using Python dictionary update() method:

The update method is an inbuilt method of python dictionary and it is used to update multiple key-value pairs of a dictionary at one go. It is defined as:

dict.update(itr)

This method takes one single parameter. It is an iterable with key-value pairs or another dictionary. It updates the key-value pairs of the original dictionary dict. It doesn’t return anything.

Let’s take a look at the below example:

given_dict = {'one': 'Jan', 'two': 'Feb', 'three': 'March'}
updated_dict = {'one': 1, 'two': 2}

print(f'Dictionary before change: {given_dict}')

given_dict.update(updated_dict)

print(f'Dictionary after change: {given_dict}')

In this example, we passed another dictionary updated_dict to the update() method which is called on given_dict. If you run this program, it will print:

Dictionary before change: {'one': 'Jan', 'two': 'Feb', 'three': 'March'}
Dictionary after change: {'one': 1, 'two': 2, 'three': 'March'}

If the keys are not found in the dictionary, it will append those pairs to the dictionary.

given_dict = {'one': 'Jan', 'two': 'Feb', 'three': 'March'}
updated_dict = {'four': 'April', 'five': 'May'}

print(f'Dictionary before change: {given_dict}')

given_dict.update(updated_dict)

print(f'Dictionary after change: {given_dict}')

In this example, the keys four and five are not in the original dictionary given_dict. So, these pairs will be appended to the dictionary.

Dictionary before change: {'one': 'Jan', 'two': 'Feb', 'three': 'March'}
Dictionary after change: {'one': 'Jan', 'two': 'Feb', 'three': 'March', 'four': 'April', 'five': 'May'}

How to use Python dictionary update() method with an iterable:

We can also pass an iterable to the update() method instead of passing a dictionary.

given_dict = {'one': 'Jan', 'two': 'Feb', 'three': 'March'}
updated_dict = [("one", 1), ("two", 2), ("three", 3)]

print(f'Dictionary before change: {given_dict}')

given_dict.update(updated_dict)

print(f'Dictionary after change: {given_dict}')

We passed a tuple to the update method in this example. It will print similar result.

Dictionary before change: {'one': 'Jan', 'two': 'Feb', 'three': 'March'}
Dictionary after change: {'one': 1, 'two': 2, 'three': 3}

How to remove items from a dictionary in Python

Thu, 22 Dec 2022 09:39:27 GMT

How to remove items from a dictionary in Python:

Python dictionary provides a couple of methods to remove single or multiple items from a dictionary. The dictionaries are used to store key-value pairs in Python. Each value is associated with one key. We can use a key to access the value associated with that key.

Let’s take a look at the below dictionary:

given_dict = {1: 'one', 2: 'two', 3: 'three'}

print(given_dict)

Here, we initialized a dictionary given_dict and print the content of the dictionary. It will give the below output:

{1: 'one', 2: 'two', 3: 'three'}

It is a simple program. It is printing the content of the dictionary.

To delete these items, we have four different methods, del, pop, popItem and clear. Let’s learn how these works with example for each:

del:

The del keyword can be used to remove a specific pair from a dictionary or we can delete the complete dictionary.

The following example removes a specific key-value pair from a dictionary:

given_dict = {'one': 'Jan', 'two': 'Feb', 'three': 'March'}

del given_dict['three']

print(given_dict)

It will remove the pair 'three': 'March' from the dictionary.

{'one': 'Jan', 'two': 'Feb'}

You can also delete the complete dictionary variable:

given_dict = {'one': 'Jan', 'two': 'Feb', 'three': 'March'}

del given_dict

print(given_dict)

Since the dictionary is deleted and we are trying to print it after it got deleted, it will throw one error.

NameError: name 'given_dict' is not defined

pop:

The pop method takes the key value as its parameter and removes that key-value pair from the dictionary. This method also returns the value of that key. For example,

given_dict = {'one': 'Jan', 'two': 'Feb', 'three': 'March'}

print(given_dict.pop('three'))

print(given_dict)

I am also printing the return value of pop in this example. The first print statement prints the return value of pop and the second print statement prints the final dictionary.

March
{'one': 'Jan', 'two': 'Feb'}

popitem():

The popitem method doesn’t take any argument. It removes the last inserted pairs from a dictionary and returns a tuple. The tuple holds both key and value. Let me modify the previous example:

given_dict = {'one': 'Jan', 'two': 'Feb', 'three': 'March'}

print(given_dict.popitem())

print(given_dict)

It will print:

('three', 'March')
{'one': 'Jan', 'two': 'Feb'}

clear():

The clear method removes all elements of a dictionary. The difference between del and clear() is that clear() doesn’t delete the dictionary variable. It empties the dictionary items.

given_dict = {'one': 'Jan', 'two': 'Feb', 'three': 'March'}

given_dict.clear()

print(given_dict)

It will print an empty dictionary.

{}

JavaScript program to find if a number is a Magic number or not

Tue, 20 Dec 2022 09:39:27 GMT

JavaScript program to find if a number is a Magic number or not:

In this post, we will learn how to find if a number is a Magic number or not with JavaScript. We will write a program that will take one number as input from the user, check if it is a Magic number and print out the result.

What is a Magic number:

A number is called a Magic number if the repeated sum of digits of that number is equal to 1. 9721 is a Magic number. Let me show you how:

The sum of digits of 9721 is 9 + 7 + 2 + 1 or 19.
Since 19 is a two digit number, we have to find the sum of digits of 19 which is 10. Similarly, the sum of digits of 10 is 1. Hence, the repeated sum of digits of the number is equal to 1 and so 9721 is a Magic number.

Similarly, 2179, 10 etc. are Magic numbers.

We will have to find the repeated sum of digits of a number first and if we compare it with 1, we can find if a number is a Magic number or not.

Example 1: Magic number program with a while loop:

The following program uses a while loop to check if a number is Magic number or not:

let no = 9721;
let copyNo = no;
let sum = no;

while(copyNo > 9){
    sum = 0;
    while(copyNo > 0){
        sum += copyNo%10;
        copyNo = parseInt(copyNo/10);
    }
    copyNo = sum;
}

if(sum == 1){
    console.log(`${no} is a Magic number`)
}else{
    console.log(`${no} is not a Magic number`)
}

In this program,

The variable no holds the given number. We created a copy of the number, copyNo. The program works on this copied number. It also initialized another sum variable to hold the repeated sum.
There are two while loops used in the program.
- The outer loop runs until the value of copyNo is greater than 9. Inside this loop, it finds the sum of digits of the number and assigns that sum to copyNo. So, at the end of this loop, the sum variable will hold the repeated sum of digits of the number.
- The inner loop finds the sum of digits of the number copyNo. It finds the last digit of the number, adds it to the sum variable and removes it from copyNo.
Once the loop ends, we can compare the value of the sum variable with 1. If it is equal to 1, it is a Magic number. Else, it is not a Magic number.

You can try this program with different numbers to check for Magic numbers.

Example 2: Magic number program with HTML, JS:

We can also write this program with HTML and JavaScript. Create one index.html file with the below content:

<!DOCTYPE html>
<html lang="en">

<head>
  <script>
    function checkMagic() {
      let no = document.getElementById("no").value;
      let copyNo = no;
      let sum = no;

      while (copyNo > 9) {
        sum = 0;
        while (copyNo > 0) {
          sum += copyNo % 10;
          copyNo = parseInt(copyNo / 10);
        }
        copyNo = sum;
      }
      if (sum == 1) {
        document.getElementById("result").innerText = `${no} is a Magic number`;
      } else {
        document.getElementById("result").innerText = `${no} is not a Magic number`;
      }
    }
  </script>
</head>

<body>
  <input type="text" id="no" placeholder="Enter the number" />
  <button onclick="checkMagic()">Check</button>
  <text id="result"></text>
</body>

</html>

You can open this file in any web browser to check the result.

It has one input field to take the number input. The user will enter the number in that field.
One button is there. On clicking the button, it will call the checkMagic function.
- The checkMagic function checks if the entered number is a Magic number or not.
- It updates the result in the text field.

It will give result as below:

Example 3: Find all Magic numbers in a range in JavaScript:

Let’s change the above program to find all Magic numbers in a range with JavaScript.

function isMagic(no) {
  let copyNo = no;
  let sum = no;

  while (copyNo > 9) {
    sum = 0;
    while (copyNo > 0) {
      sum += copyNo % 10;
      copyNo = parseInt(copyNo / 10);
    }
    copyNo = sum;
  }
  return sum == 1;
}

console.log(`Magic numbers between 1 and 100 are: `);
for(let i = 1; i <= 100; i++){
    if(isMagic(i)){
        console.log(i);
    }
}

We moved the code to a new function isMagic. This function takes one number as its parameter and returns one boolean value. It is finding all magic numbers in between 1 and 100 by using a for loop. The loop runs from 1 to 100 and on each iteration, it checks if the current value is a Magic number or not. If yes, it prints that value.

It prints the below output:

Magic numbers between 1 and 100 are: 
1
10
19
28
37
46
55
64
73
82
91
100

How to convert an image to Base64 in JavaScript

Fri, 16 Dec 2022 09:39:27 GMT

How to convert an image to Base64 in JavaScript:

In this post, I will show you different ways to convert an image to Base64 in JavaScript. Base64 is an encoding scheme that is used for binary data. This is a popular encoding scheme and used to transmit binary data across different channels. Base64 is widely used in email attachments.

The following examples will show two different ways to find the Base64 value. The first example will find the value of a local file and the second example will find it from a remote URL.

In both of these examples, we will use the FileReader API. This is a File API and we can use it to read the content of a file asynchronously. We will use the HTML component <input type="file"> to allow the user to pick the file from the system.

Example 1: Find the Base64 value of a local image:

In this example, we are using an input component that will allow the user to pick an image. It will calculate the Base64 of that image and show it with an alert.

<!DOCTYPE html>
<html lang="en">

<head>
  <script>
    function findBase64(e) {
      const file = e.files[0];
      const fileReader = new FileReader();
      fileReader.onloadend = function () {
        alert(fileReader.result.split(',')[1]);
      };
      fileReader.readAsDataURL(file);
    }
  </script>
</head>

<body>
  <p>Select an Image:</p>
  <input type="file" onchange="findBase64(this)" />
</body>

</html>

If you save the above code snippet in a html file and open that file in any web browser, it will show one input field as below:

You can click on the choose file button and select an image.

It will:

trigger the findbase64 method.
It will create one FileReader object.
It will call the readAsDataURL method. The selected file is passed to this method.
This method will read the content of the file and onloadend function will be called. We need to split the result to get the required Base64 value from the DataURL.

It will show the Base64 value with an alert.

Example 2: Find the Base64 value from a remote URL:

With this example, we will get the Base64 value of an image from any given URL. We will add an input component to get the URL from the user.

<!DOCTYPE html>
<html lang="en">

<head>
  <script>
    function findBase64() {
      const url = document.getElementById('idInput').value;
      fetch(url)
        .then((res) => res.blob())
        .then((blob) => {
          var fileReader = new FileReader();
          fileReader.onloadend = function () {
            alert(fileReader.result.split(',')[1]);
          };
          fileReader.readAsDataURL(blob);
        });

    }
  </script>
</head>

<body>
  <p>Enter the URL of the image:</p>
  <input id="idInput" />
  <button onclick="findBase64()">Find Base64</button>
</body>

</html>

This will add one input field and one button. You can enter the URL of the image in that field and click on the button to find the Base64 result. It is using a similar approach to find the Base64 value. It uses the fetch api call to get the blob object from the url. We can pass a blob to the readAsDataURL method of a FileReader object. It works similar to the previous example.

Reference:

FileReader reference

CodeVsColor

Learn to create a custom progress button in React Native and TypeScript

How to create a custom progress button in React Native with TypeScript:

props of the button:

Button component:

App.tsx file changes:

Output:

You might also like:

How to hide the keyboard on scrolling through a FlatList in React Native

How to hide the keyboard on scrolling through a list in React Native:

Basic program with a FlatList:

How to dismiss the keyboard automatically once user scroll through the FlatList:

a. Import Keyboard from react-native:

b. Dismiss it on scroll:

Complete program:

You might also like:

3 ways to detect if Keyboard is opened or closed in React Native

How to detect if Keyboard is opened or closed in React Native:

Method 1: By using the addListener() method:

Keyboard hidden:

Keyboard showing:

Method 2: Using a custom hook:

useKeyboardListener.tsx:

App.tsx:

Method 3: With Keyboard.isVisible():

You might also like:

How to hide the keyboard in React Native on tapping outside of TextInput

How to hide the keyboard in React Native on tapping outside of TextInput:

Method 1: By using a ScrollView:

Method 2: By using the Keyboard module:

By using a HOC:

You might also like:

How to change the text size of TextInput in React Native

How to change the text size of TextInput in React Native:

Create a basic React Native project:

Edit your App.tsx file:

How to change the font size of TextInput component:

Make sure to adjust the height of the TextInput:

You might also like:

How to remove the first occurrence of an item in a list in Python

How to remove the first occurrence of an item in a list in Python:

Method 1: By using the remove() method:

Method 2: By using the pop() method:

Method 3: By using the del operator:

You might also like:

How to check if an object is an array or not in JavaScript

JavaScript program to check if an object is an Array:

How to use Array.isArray() method to check if an object is an Array or not:

How to use instanceOf operator to check if an object is an Array:

Array.isArray() or instanceOf:

You might also like:

4 ways to add the digits of a number in JavaScript

JavaScript program to add the digits of a number:

Method 1: Find the sum of digits of a number by using a while loop:

Method 2: By using a for loop:

Method 3: By converting the number to String:

Method 4: By using the reduce() function:

You might also like:

6 ways in JavaScript to iterate over an array of objects

How to iterate over an array of objects in JavaScript:

Method 1: How to iterate over an object array with a for loop:

Method 2: By using a while loop:

Method 3: By using a do...while loop:

Method 4: Iterate over the array elements with a forEach method:

Method 5: By using a for...of loop:

Method 6: By using for...in loop:

You might also like:

How to find all matches in an array of objects in JavaScript

How to find all matches in an array of objects in JavaScript:

Method 1: By using the filter method:

Updating the values of the filtered array elements:

Method 2: How to filter out objects with multiple properties:

Method 3: How to create a deep copy with the filter() method:

You might also like:

JavaScript program to check if an element is present in an Array or not

How to check if an element is present in an Array or not in JavaScript:

Method 1: By using a loop:

Method 2: With indexOf:

Method 3: By using the includes method:

How to use the includes method to start the search from a specific index:

`props` of the button:

`App.tsx` file changes:

Basic program with a `FlatList`:

How to dismiss the keyboard automatically once user scroll through the `FlatList`:

a. Import `Keyboard` from `react-native`:

Method 1: By using the `addListener()` method:

Method 3: With `Keyboard.isVisible()`:

How to hide the keyboard in React Native on tapping outside of `TextInput`:

Method 1: By using a `ScrollView`:

Method 2: By using the `Keyboard` module:

How to change the text size of `TextInput` in React Native:

How to change the font size of `TextInput` component:

Make sure to adjust the height of the `TextInput`:

How to remove the first occurrence of an item in a list in `Python`:

Method 1: By using the `remove()` method:

Method 2: By using the `pop()` method:

Method 3: By using the `del` operator:

How to use `Array.isArray()` method to check if an object is an Array or not:

How to use `instanceOf` operator to check if an object is an Array:

`Array.isArray()` or `instanceOf`:

Method 1: Find the sum of digits of a number by using a `while` loop:

Method 2: By using a `for` loop:

Method 3: By converting the number to `String`:

Method 4: By using the `reduce()` function:

Method 1: How to iterate over an object array with a `for` loop:

Method 2: By using a `while` loop:

Method 3: By using a `do...while` loop:

Method 4: Iterate over the array elements with a `forEach` method:

Method 5: By using a `for...of` loop:

Method 6: By using `for...in` loop:

Method 1: By using the `filter` method:

Method 3: How to create a deep copy with the `filter()` method:

How to check if an element is present in an Array or not in `JavaScript`:

Method 2: With `indexOf`:

Method 3: By using the `includes` method:

How to use the `includes` method to start the search from a specific index:

Problem with reading string inputs with `scanf`:

Approach 1: How to use `scanf` with a different format specifier:

Approach 2: Read a string with blank spaces with the `fgets()` method:

Dart program to check if a `LinkedHashMap` contains a key or value:

Method 1: Find in the iterable of keys if the `LinkedHashMap` contains a key:

Method 2: Find in the iterable of values if the `LinkedHashMap` contains a value:

Method 4: By using the `containsKey` method:

Method 5: By using the `containsValue` method: