BigInteger Mathematical Operations Examples

---

BigInteger Mathematical Operations Examples

BigInteger is in an immutable object, so you need to assign the results of any mathematical operation, to a new BigInteger instance.

import java.math.BigInteger;
 
public class BigIntegerOperations {
    public static void main(String[] args) {
        // Addition: 20 + 20 = 40
        BigInteger num1 = new BigInteger("20");
        BigInteger num2 = new BigInteger("20");
        BigInteger sum = num1.add(num2);
        System.out.println("Addition: " + sum);
 
        // Subtraction: 20 - 18 = 2
        BigInteger num3 = new BigInteger("20");
        BigInteger num4 = new BigInteger("18");
        BigInteger sub = num3.subtract(num4);
        System.out.println("Subtraction: " + sub);
 
        // Division: 20 / 5 = 4
        BigInteger num5 = new BigInteger("20");
        BigInteger num6 = new BigInteger("5");
        BigInteger div = num5.divide(num6);
        System.out.println("Division: " + div);
 
        // Multiplication: 20 * 5 = 100
        BigInteger num7 = new BigInteger("20");
        BigInteger num8 = new BigInteger("5");
        BigInteger mul = num7.multiply(num8);
        System.out.println("Multiplication: " + mul);
 
        // Power: 20 ^ 3 = 8000
        BigInteger num9 = new BigInteger("20");
        BigInteger power = num9.pow(3);
        System.out.println("Power: " + power);
 
        // Remainder: 20 % 6 = 2
        BigInteger num10 = new BigInteger("20");
        BigInteger num11 = new BigInteger("6");
        BigInteger remainder = num10.remainder(num11);
        System.out.println("Remainder: " + remainder);
 
        // GCD: Greatest Common Divisor (GCD) for 24 and 36 is 12
        BigInteger num12 = new BigInteger("24");
        BigInteger num13 = new BigInteger("36");
        BigInteger gcd = num12.gcd(num13);
        System.out.println("GCD: " + gcd);
 
        // Maximum of two BigIntegers
        BigInteger num14 = new BigInteger("20");
        BigInteger num15 = new BigInteger("25");
        BigInteger max = num14.max(num15);
        System.out.println("Maximum: " + max);
 
        // Minimum of two BigIntegers
        BigInteger num16 = new BigInteger("20");
        BigInteger num17 = new BigInteger("25");
        BigInteger min = num16.min(num17);
        System.out.println("Minimum: " + min);
    }
}
 

---

Binary Logic Operations on BigInteger

BigInteger supports the binary logic operations that are available to Number types as well. As with all operations they are implemented by calling a method.

import java.math.BigInteger;
 
public class BigIntegerOperations {
    public static void main(String[] args) {
        // Binary Or: 20 | 15 = 31
        BigInteger num1 = new BigInteger("20");
        BigInteger num2 = new BigInteger("15");
        BigInteger orResult = num1.or(num2);
        System.out.println("Binary Or: " + orResult);
 
        // Binary And: 20 & 15 = 4
        BigInteger num3 = new BigInteger("20");
        BigInteger num4 = new BigInteger("15");
        BigInteger andResult = num3.and(num4);
        System.out.println("Binary And: " + andResult);
 
        // Binary Xor: 20 ^ 15 = 27
        BigInteger num5 = new BigInteger("20");
        BigInteger num6 = new BigInteger("15");
        BigInteger xorResult = num5.xor(num6);
        System.out.println("Binary Xor: " + xorResult);
 
        // Right Shift: 20 >> 2 = 5
        BigInteger num7 = new BigInteger("20");
        BigInteger rightShift = num7.shiftRight(2);
        System.out.println("Right Shift: " + rightShift);
 
        // Left Shift: 20 << 2 = 80
        BigInteger num8 = new BigInteger("20");
        BigInteger leftShift = num8.shiftLeft(2);
        System.out.println("Left Shift: " + leftShift);
 
        // Binary Inversion (Not): ~20 = -21
        BigInteger num9 = new BigInteger("20");
        BigInteger notResult = num9.not();
        System.out.println("Binary Inversion (Not): " + notResult);
 
        // NAND (And-Not): 20 & ~15 = 5
        BigInteger num10 = new BigInteger("20");
        BigInteger num11 = new BigInteger("15");
        BigInteger nandResult = num10.andNot(num11);
        System.out.println("NAND (And-Not): " + nandResult);
    }
}
 

• Previous
• Next

Basic Programs

---

• Creating Your First Java Program
• Type Conversion
• Getters and Setters
• Reference Data Types
• Java Compiler - javac
• Documenting Java Code
• Command line Argument Processing
• Java Command - java and javaw
• Literals
• Primitive Data Types

Strings in Java

• Comparing Strings
• Changing the case of characters within a String
• Finding a String Within Another String
• String pool and heap storage
• Splitting Strings
• Joining Strings with a delimiter and Reversing Strings
• String concatenation and StringBuilders
• Substrings and Platform Independent new line Separator
• Adding toString() method for custom objects
• Remove Whitespace from the Beginning and End of a String and Case insensitive switch
• Replacing parts of Strings and Getting the nth character in a String
• Counting occurrences of a substring or character in a string

StringBuffer and StringBuilder

• String Buffer
• String Builder
• String Tokenizer and Splitting a string into fixed length parts

Date Class

• Convert java.util.Date to java.sql.Date and Basic date
• LocalDate and LocalDateTime objects
• Creating a Specific Date and Converting Date to String format
• Convert formatted string representation of date to Date object
• Comparing Date objects
• Converting String into Date and Time Zones and java.util.Date

Dates and Time (java.time.*)

• Dates and Time
• Date Time Formatting and Date Manipulations
• LocalTime

BigDecimal

• Comparing and Using BigDecimals
• BigDecimal.valueOf()
• Mathematical operations with BigDecimal

BigInteger

• Initialization and Generating random BigIntegers
• BigInteger Mathematical Operations Examples
• NumberFormat

Bit Manipulation

• Checking, setting, clearing, and toggling individual bits. Using long as bit mask
• Checking if a number is a power of 2
• Signed vs unsigned shift and Expressing the power of 2

Arrays

• Creating and Initializing Arrays
• Creating a List from an Array
• Multidimensional and Jagged Arrays
• Array Covariance and Arrays to Stream
• Iterating over arrays
• Sorting arrays and Length of an Array
• Finding an element in an array nd change the size of an array
• Primitives and boxed types and Remove an element from an array
• Comparing arrays for equality and Copying arrays

Collections

• Removing items from a List within a loop
• Constructing collections from existing data
• ArrayList and adding objects and Iterating over Collections
• Immutable Empty , Sub and Unmodifiable Collection
• Removing matching items from Lists and Join lists
• Creating your own Iterable structure for use with Iterator or for-each loop

Lists

• Sorting a generic list
• Classes implementing List
• Replacement of a List element and Moving objects around in the list
• Creating, Adding and Removing element from an ArrayList
• Positional Access Operations and Iterating over elements in a list

Sets

• Initialization and Basics of Set
• Types and Usage of Sets

Maps

• Iterating Map Entries Effciently
• Using Default Methods of Map from Java 8
• Usage of HashMap and Iterating through the contents of a Map
• Merging, combine and composing Maps and Add multiple items
• Creating and Initializing Maps
• Check if key exists, Add an element and Clear the map
• LinkedHashMap, WeakHashMap and SortedMap

TreeMap and TreeSet

• TreeMap and TreeSet of a simple Java type
• TreeMap and TreeSet of a custom Java type
• TreeMap and TreeSet Thread Safety

Queues and Deques

• Usage of the Queue and Deque
• Stacks and BlockingQueue
• LinkedList as a FIFO Queue and Queue Interface
• Dequeue Interface

Enums

• Declaring and using a basic enum
• Enums with constructors and Abstract Methods
• Implements Interface and Singleton pattern
• Using methods and static blocks and Zero instance enum
• Enum constant specific body and Getting the values of an enum
• Compare and Contains for Enum values and Get enum constant by name
• Convert enum to String and Enums with static fields
• Enum Map , EnumSet class, Enum starting with number and Hashtable

Operators

• Increment/Decrement and Conditional Operator
• Bitwise, Logical and String Concatenation Operators
• Arithmetic Operators
• Shift and Instanceof Operators
• Assignment Operators
• Conditional-and ,Conditional-or and Relational Operators
• Equality and Lambda operator

Constructors

• Default and Call parent Constructor

Object Class Methods and Constructor

• hashCode() method
• toString() and finalize() method
• equals() method
• wait(), notify(), getClass(), clone() methods
• Object constructor

Annotations

• Defining annotation types
• Built-in annotations
• Compile time processing using annotation processor
• Repeating and Inherited Annotations
• Getting Annotation values at run-time and Annotations for 'this' and receiver parameters

Immutable Class

• What is the advantage of immutability and Rules and Example

Immutable Objects

• Creating an immutable version of a type using defensive copying
• Typical design flaws which prevent a class from being immutable

Visibility (controlling access to members of a class)

• Private ,Public ,Package and Protected Visibility

Generics

• Creating a Generic Class
• Diamond and Declaring a Generic Method
• Generic parameter and Benefits of Generic class and interface
• Creating a Bounded Generic Class
• Generics to auto-cast and Use of instanceof with Generics

Classes and Objects

• Method Overloading and Overriding
• Constructors and Initializing static final
• Basic Object Construction and Use

Nested and Inner Classes

• Static vs Non Static Nested Classes
• Anonymous Inner Classes and non-static inner class

The java.util.Objects Class

• Basic use for object null check and Objects.nonNull() method

Default Methods

• Why Use, Usage and Accessing overridden of default methods
• interface methods, multiple inheritance and Abstract class

Packages

• Using Packages to create classes and Protected Scope

Inheritance

• What is Inheritance
• Abstract Classes
• Abstract class and Interface usage
• Programming to an interface
• Overriding in Inheritance, Variable shadowing and Narrowing and Widening

Reference Types

• Different Reference Types

Console I/O

• Reading user input from the console
• Aligning strings in console and Implementing Basic Command-Line Behavior

Streams

• Using Streams
• Creating a Frequency Map, Infinite and Consuming Streams
• Collect Elements of a Stream into a Collection
• Flatten Streams, Parallel Stream and Implement Mathematical Functions
• Creating a Stream and Finding Statistics about Numerical Streams
• Concatenate Streams and Reduction with Streams
• IntStream to String and Finding the First Element that Matches a Predicate
• Create a Map based on a Stream and Joining a stream to a single String
• Streams of Primitives and Stream operations categories

InputStreams and OutputStreams

• Reading,Writing,Copying,Closing,Wrapping and InputStream

Readers and Writers

• BufferedReader and StringWriter Example

Preferences

• Using preferences, Adding event listeners and Getting sub-nodes of Preferences
• Exporting, Importing preferences and Getting, Setting preferences values

Collection Factory Methods

• List<E>, Set<E> and Map<K, V> Factory Method Examples

Alternative Collections

• Multimap in Guava, Apache and Eclipse Collections
• Apache HashBag, Guava HashMultiset and Eclipse HashBag
• Compare operation with collections - Create collections

Concurrent Collections

• Insertion into ConcurrentHashMap, Thread-safe and Concurrent Collections

super keyword

• Super keyword use with examples

Serialization

• Basic and Custom Serialization
• Serialization with Gson, Versioning and serialVersionUID
• Custom JSON Deserialization with Jackson

Optional

• Map,Return default value and Throw an exception
• Filter, FlatMap andUsing Optional containers for primitive number types

Object References

• Object References as method parameters

Exceptions and exception handling

• Catching an exception with try-catch
• The try-with-resources statement
• Custom Exceptions and Handling InterruptedException
• Introduction and Return statements in try catch block
• The Java Exception Hierarchy - Unchecked and Checked Exceptions
• Creating and reading stacktraces
• Throwing an exception and Advanced features of Exceptions
• try-catch-finally statements and throws clause in a method declaration

Calendar and its Subclasses

• Creating, Subtracting and Finding AM/PM Calendar

Using the static keyword

• Reference to non-static member from static context

Properties Class

• Reference to non-static member from static context

Lambda Expressions

• Introduction to Java lambdas
• Using Lambda Expressions to Sort a Collection
• Implementing multiple interfaces, Listener and Java Closures with lambda expressions
• Memory utilization, own functional interface and Traditional style to Lambda
• return only returns from the lambda and Execute-around Pattern

Basic Control Structures

• Switch, do while, For Each, Continue Statement in Java
• If, Else If, Else Control, For Loops and Ternary Operator
• Try-Catch-Finally, Break, While Loops, If Else and Nested break / continue

BufferedWriter

• Write a line of text to File

New File I/O

• Creating paths, Manipulating, Retrieving, Reading and Writing files

File I/O

• Migrating from java.io.File to Java 7 NIO
• Reading an image, File Read/Write, Reading all bytes and Copying a file
• Stream vs Writer/Reader API and Reading a file with a Scanner
• Copying a file using InputStream and OutputStream
• Blocking or redirecting standard output / error
• Reading a file using BufferedInputStream

Scanner

• General Pattern that does most commonly asked about tasks
• Custom delimiters, Reading system input and Reading file input using Scanner

Interfaces

• Implementing multiple interfaces, Declaring and Implementing an Interface
• Usefulness of interfaces and Default methods
• Using Interfaces with Generics and Strengthen bounded type parameters

Regular Expressions

• Using capture groups and Escape Characters
• Matching a backslash, Not matching string and Matching with a regex literal

Comparable and Comparator

• Sorting a List using Comparable<T> or a Comparator<T>
• compareTo, compare Methods and Natural vs explicit sorting

Java Floating Point Operations

• Comparing floating point values
• OverFlow and UnderFlow, Formatting the floating point values

Currency and Money

• Add custom currency

Object Cloning

• Cloning performing a deep copy and copy factory
• Cloning using a copy constructor and implementing Clonable interface

Recursion

• Basic idea of Recursion
• StackOverflowError & recursion to loop
• Computing the Nth Fibonacci Number and power of a number

Converting to and from Strings

• Converting String to other datatypes
• Converting other datatypes to String

Random Number Generation

• Pseudo Random Numbers in Specific Range
• Generating Random Numbers with a Specified Seed

Singletons

• Enum Singleton and Singleton without use of Enum, Thread safe Singleton
• Extending singleton (singleton inheritance)

Autoboxing

• Using int and Integer interchangeably and Auto-unboxing may lead to NullPointerException
• Different Cases When Integer and int can be used interchangeably

---

Learn All in Tamil © Designed & Developed By Tutor Joes | Privacy Policy | Terms & Conditions