<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Md Marzukul Islam</title>
    <description>The latest articles on DEV Community by Md Marzukul Islam (@marzuk16).</description>
    <link>https://dev.to/marzuk16</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F1242839%2Fd660cd10-bce2-4551-879a-b392f5bcb875.jpg</url>
      <title>DEV Community: Md Marzukul Islam</title>
      <link>https://dev.to/marzuk16</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/marzuk16"/>
    <language>en</language>
    <item>
      <title>From Spring Boot to EF Core: Understanding Concurrency a Little Differently</title>
      <dc:creator>Md Marzukul Islam</dc:creator>
      <pubDate>Mon, 26 Oct 2026 09:10:07 +0000</pubDate>
      <link>https://dev.to/marzuk16/from-spring-boot-to-ef-core-understanding-concurrency-a-little-differently-39mj</link>
      <guid>https://dev.to/marzuk16/from-spring-boot-to-ef-core-understanding-concurrency-a-little-differently-39mj</guid>
      <description>&lt;p&gt;Coming from Spring Boot to EF Core, I expected version-based concurrency control to work more or less the same way.&lt;/p&gt;

&lt;p&gt;The goal was familiar: prevent one update from silently overwriting another.&lt;/p&gt;

&lt;p&gt;But while working with SQL Server's &lt;code&gt;rowversion&lt;/code&gt; in EF Core, I noticed a small difference that made me rethink what a version column actually represents.&lt;/p&gt;

&lt;h2&gt;
  
  
  What I was used to in Spring Boot
&lt;/h2&gt;

&lt;p&gt;When working with JPA/Hibernate, we can use &lt;a class="mentioned-user" href="https://dev.to/version"&gt;@version&lt;/a&gt; to enable optimistic locking.&lt;/p&gt;

&lt;p&gt;For example:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight java"&gt;&lt;code&gt;&lt;span class="nd"&gt;@Entity&lt;/span&gt;
&lt;span class="kd"&gt;public&lt;/span&gt; &lt;span class="kd"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Product&lt;/span&gt; &lt;span class="o"&gt;{&lt;/span&gt;

    &lt;span class="nd"&gt;@Id&lt;/span&gt;
    &lt;span class="kd"&gt;private&lt;/span&gt; &lt;span class="nc"&gt;Long&lt;/span&gt; &lt;span class="n"&gt;id&lt;/span&gt;&lt;span class="o"&gt;;&lt;/span&gt;

    &lt;span class="kd"&gt;private&lt;/span&gt; &lt;span class="nc"&gt;String&lt;/span&gt; &lt;span class="n"&gt;name&lt;/span&gt;&lt;span class="o"&gt;;&lt;/span&gt;

    &lt;span class="nd"&gt;@Version&lt;/span&gt;
    &lt;span class="kd"&gt;private&lt;/span&gt; &lt;span class="nc"&gt;Long&lt;/span&gt; &lt;span class="n"&gt;version&lt;/span&gt;&lt;span class="o"&gt;;&lt;/span&gt;
&lt;span class="o"&gt;}&lt;/span&gt;

&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Hibernate manages the version field. When an entity is updated, its version is incremented, and the version is checked during the update.&lt;/p&gt;

&lt;p&gt;Conceptually, it might look like this:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Operation&lt;/th&gt;
&lt;th&gt;Version&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Product created&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Product updated&lt;/td&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Product updated again&lt;/td&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The version belongs to that entity's row. Updating a different product doesn't increment this product's version.&lt;/p&gt;

&lt;p&gt;That was the mental model I had in mind.&lt;/p&gt;

&lt;h2&gt;
  
  
  Then I encountered .IsRowVersion() in EF Core
&lt;/h2&gt;

&lt;p&gt;In EF Core, SQL Server can manage the concurrency token for us:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight csharp"&gt;&lt;code&gt;&lt;span class="n"&gt;modelBuilder&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;Entity&lt;/span&gt;&lt;span class="p"&gt;&amp;lt;&lt;/span&gt;&lt;span class="n"&gt;Product&lt;/span&gt;&lt;span class="p"&gt;&amp;gt;()&lt;/span&gt;
    &lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;Property&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;p&lt;/span&gt; &lt;span class="p"&gt;=&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;p&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;RowVersion&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;IsRowVersion&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The corresponding property is typically a byte[]:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight csharp"&gt;&lt;code&gt;&lt;span class="k"&gt;public&lt;/span&gt; &lt;span class="k"&gt;class&lt;/span&gt; &lt;span class="nc"&gt;Product&lt;/span&gt;
&lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;public&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;Id&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="k"&gt;get&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="k"&gt;set&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;

    &lt;span class="k"&gt;public&lt;/span&gt; &lt;span class="kt"&gt;string&lt;/span&gt; &lt;span class="n"&gt;Name&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="k"&gt;get&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="k"&gt;set&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="p"&gt;=&lt;/span&gt; &lt;span class="kt"&gt;string&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;Empty&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

    &lt;span class="k"&gt;public&lt;/span&gt; &lt;span class="kt"&gt;byte&lt;/span&gt;&lt;span class="p"&gt;[]&lt;/span&gt; &lt;span class="n"&gt;RowVersion&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="k"&gt;get&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="k"&gt;set&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="p"&gt;=&lt;/span&gt; &lt;span class="n"&gt;Array&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;Empty&lt;/span&gt;&lt;span class="p"&gt;&amp;lt;&lt;/span&gt;&lt;span class="kt"&gt;byte&lt;/span&gt;&lt;span class="p"&gt;&amp;gt;();&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;At first glance, it serves the same purpose as JPA's &lt;a class="mentioned-user" href="https://dev.to/version"&gt;@version&lt;/a&gt;. But the way SQL Server generates the value is different.&lt;/p&gt;

&lt;p&gt;SQL Server's rowversion is an automatically generated 8-byte binary value based on a database-wide counter.&lt;/p&gt;

&lt;p&gt;Whenever a row containing a rowversion column is inserted or updated, SQL Server assigns it a new value.&lt;/p&gt;

&lt;p&gt;Here's the part I found interesting: the counter isn't maintained separately for each row.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why does that matter?
&lt;/h2&gt;

&lt;p&gt;Imagine a Products table containing three products.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Operation&lt;/th&gt;
&lt;th&gt;Product&lt;/th&gt;
&lt;th&gt;Rowversion (illustrative)&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Insert&lt;/td&gt;
&lt;td&gt;Laptop&lt;/td&gt;
&lt;td&gt;0x0000000000000001&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Insert&lt;/td&gt;
&lt;td&gt;Keyboard&lt;/td&gt;
&lt;td&gt;0x0000000000000002&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Update&lt;/td&gt;
&lt;td&gt;Keyboard&lt;/td&gt;
&lt;td&gt;0x0000000000000003&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Insert&lt;/td&gt;
&lt;td&gt;Mouse&lt;/td&gt;
&lt;td&gt;0x0000000000000004&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Update&lt;/td&gt;
&lt;td&gt;Laptop&lt;/td&gt;
&lt;td&gt;0x0000000000000005&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;These values are illustrative, but they demonstrate the idea.&lt;/p&gt;

&lt;p&gt;The laptop was inserted once and updated once. Yet its final rowversion is 0x0000000000000005, not 0x0000000000000002.&lt;/p&gt;

&lt;p&gt;Why?&lt;/p&gt;

&lt;p&gt;Because other rows were inserted or updated in between.&lt;/p&gt;

&lt;p&gt;Those operations advanced the database-wide counter. When the laptop was updated, SQL Server assigned it the next applicable value.&lt;/p&gt;

&lt;p&gt;Importantly, updating the keyboard did not change the laptop's stored rowversion. The laptop received a new value only when the laptop itself was updated.&lt;/p&gt;

&lt;h2&gt;
  
  
  How does this help prevent lost updates?
&lt;/h2&gt;

&lt;p&gt;Suppose two users load the same product.&lt;/p&gt;

&lt;p&gt;Both read the current rowversion, say 0x0000000000000005.&lt;/p&gt;

&lt;p&gt;The first user updates the product. SQL Server assigns a new rowversion.&lt;/p&gt;

&lt;p&gt;When the second user tries to save their changes using the original token, EF Core includes that original value in the update condition.&lt;/p&gt;

&lt;p&gt;Conceptually, the SQL looks like this:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight sql"&gt;&lt;code&gt;&lt;span class="k"&gt;UPDATE&lt;/span&gt; &lt;span class="n"&gt;Products&lt;/span&gt;
&lt;span class="k"&gt;SET&lt;/span&gt; &lt;span class="n"&gt;Name&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="o"&gt;@&lt;/span&gt;&lt;span class="n"&gt;newName&lt;/span&gt;
&lt;span class="k"&gt;WHERE&lt;/span&gt; &lt;span class="n"&gt;Id&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="o"&gt;@&lt;/span&gt;&lt;span class="n"&gt;id&lt;/span&gt;
  &lt;span class="k"&gt;AND&lt;/span&gt; &lt;span class="n"&gt;RowVersion&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="o"&gt;@&lt;/span&gt;&lt;span class="n"&gt;originalRowVersion&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;If the first update has already changed the rowversion, the second update matches zero rows.&lt;/p&gt;

&lt;p&gt;EF Core then throws a DbUpdateConcurrencyException, allowing the application to handle the conflict instead of silently overwriting the first user's changes.&lt;/p&gt;

&lt;p&gt;That's optimistic concurrency control in action.&lt;/p&gt;

&lt;h2&gt;
  
  
  The takeaway
&lt;/h2&gt;

&lt;p&gt;Both JPA/Hibernate's &lt;a class="mentioned-user" href="https://dev.to/version"&gt;@version&lt;/a&gt; and EF Core's .IsRowVersion() help protect against conflicting updates. However, their version generation mechanisms are different.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;JPA/Hibernate &lt;a class="mentioned-user" href="https://dev.to/version"&gt;@version&lt;/a&gt;:&lt;/strong&gt; typically uses an entity level numeric version managed by the ORM.&lt;br&gt;
&lt;strong&gt;SQL Server rowversion:&lt;/strong&gt; uses a database wide counter to generate binary values for affected rows.&lt;/p&gt;

&lt;p&gt;Understanding this difference helped me separate two ideas that I had previously treated as the same thing, a record's version and a database generated concurrency token.&lt;/p&gt;

&lt;p&gt;It's a small implementation detail, but these are the kinds of details that make working across frameworks interesting.&lt;/p&gt;

&lt;p&gt;Sometimes, understanding how something works under the hood is more valuable than simply knowing which annotation or method to use.&lt;/p&gt;

</description>
      <category>efcore</category>
      <category>sqlserver</category>
      <category>optimisticlocking</category>
    </item>
    <item>
      <title>Understanding Integer Caching in Java, The Hidden Optimization You Might’ve Missed</title>
      <dc:creator>Md Marzukul Islam</dc:creator>
      <pubDate>Mon, 10 Nov 2025 10:03:59 +0000</pubDate>
      <link>https://dev.to/marzuk16/understanding-integer-caching-in-java-the-hidden-optimization-you-mightve-missed-ggi</link>
      <guid>https://dev.to/marzuk16/understanding-integer-caching-in-java-the-hidden-optimization-you-mightve-missed-ggi</guid>
      <description>&lt;p&gt;Ever wondered why sometimes two seemingly identical Integer objects in Java are actually the same object in memory, and sometimes they aren’t?&lt;/p&gt;

&lt;p&gt;Welcome to the fascinating world of Integer Caching, a small but clever optimization built right into the Java Virtual Machine (JVM) that quietly boosts performance and saves memory.&lt;/p&gt;

&lt;h2&gt;
  
  
  What Is &lt;code&gt;Integer Caching&lt;/code&gt;?
&lt;/h2&gt;

&lt;p&gt;In Java, objects like &lt;code&gt;Integer&lt;/code&gt;, &lt;code&gt;Long&lt;/code&gt;, &lt;code&gt;Byte&lt;/code&gt;, and &lt;code&gt;Character&lt;/code&gt; are &lt;strong&gt;immutable wrapper classes&lt;/strong&gt; around primitive types. Whenever you use autoboxing, such as:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight java"&gt;&lt;code&gt;    &lt;span class="nc"&gt;Integer&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;100&lt;/span&gt;&lt;span class="o"&gt;;&lt;/span&gt;  &lt;span class="c1"&gt;// autoboxing of int to Integer&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;the JVM doesn’t always create a &lt;em&gt;new&lt;/em&gt; &lt;code&gt;Integer&lt;/code&gt; object. Instead, it might reuse an existing one, thanks to &lt;strong&gt;Integer caching&lt;/strong&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  How It Works
&lt;/h2&gt;

&lt;p&gt;By default, Java maintains a &lt;strong&gt;cache of Integer objects&lt;/strong&gt; for values between &lt;strong&gt;-128 and +127&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;So when you write:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight java"&gt;&lt;code&gt;    &lt;span class="nc"&gt;Integer&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;100&lt;/span&gt;&lt;span class="o"&gt;;&lt;/span&gt;
    &lt;span class="nc"&gt;Integer&lt;/span&gt; &lt;span class="n"&gt;y&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;100&lt;/span&gt;&lt;span class="o"&gt;;&lt;/span&gt;
    &lt;span class="nc"&gt;System&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="na"&gt;out&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="na"&gt;println&lt;/span&gt;&lt;span class="o"&gt;(&lt;/span&gt;&lt;span class="n"&gt;x&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="n"&gt;y&lt;/span&gt;&lt;span class="o"&gt;);&lt;/span&gt;  &lt;span class="c1"&gt;// true&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Both &lt;code&gt;x&lt;/code&gt; and &lt;code&gt;y&lt;/code&gt; refer to the &lt;strong&gt;same cached object&lt;/strong&gt; from the JVM’s internal pool.&lt;/p&gt;

&lt;p&gt;However, when you go beyond this range:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight java"&gt;&lt;code&gt;    &lt;span class="nc"&gt;Integer&lt;/span&gt; &lt;span class="n"&gt;p&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;128&lt;/span&gt;&lt;span class="o"&gt;;&lt;/span&gt;
    &lt;span class="nc"&gt;Integer&lt;/span&gt; &lt;span class="n"&gt;q&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;128&lt;/span&gt;&lt;span class="o"&gt;;&lt;/span&gt;
    &lt;span class="nc"&gt;System&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="na"&gt;out&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="na"&gt;println&lt;/span&gt;&lt;span class="o"&gt;(&lt;/span&gt;&lt;span class="n"&gt;p&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="n"&gt;q&lt;/span&gt;&lt;span class="o"&gt;);&lt;/span&gt;  &lt;span class="c1"&gt;// false&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2F5eeoam6ylqv0nnqlvzz7.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2F5eeoam6ylqv0nnqlvzz7.jpg" alt=" " width="800" height="445"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Each value gets a &lt;strong&gt;new Integer object&lt;/strong&gt;, since &lt;em&gt;128&lt;/em&gt; is outside the default cache range.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why -128 to 127?
&lt;/h2&gt;

&lt;p&gt;This range was chosen because:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;These values are commonly used (especially in loops, small counters, array indexes, etc.).&lt;/li&gt;
&lt;li&gt;-128 to 127 fits neatly within a single byte (&lt;code&gt;Byte&lt;/code&gt; range).&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;This small range gives a big payoff, fewer object allocations and faster comparisons for the most frequently used numbers.&lt;/p&gt;

&lt;h1&gt;
  
  
  JVM Customization For Caching Range
&lt;/h1&gt;

&lt;p&gt;The upper limit of the cache can actually be &lt;strong&gt;customized!&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;You can modify it using the JVM option:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight ini"&gt;&lt;code&gt;    &lt;span class="py"&gt;-Djava.lang.Integer.IntegerCache.high&lt;/span&gt;&lt;span class="p"&gt;=&lt;/span&gt;&lt;span class="s"&gt;&amp;lt;value&amp;gt;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;For example, if your application heavily uses numbers up to &lt;code&gt;1000&lt;/code&gt;, you could extend the cache like this:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight ini"&gt;&lt;code&gt;    &lt;span class="py"&gt;-Djava.lang.Integer.IntegerCache.high&lt;/span&gt;&lt;span class="p"&gt;=&lt;/span&gt;&lt;span class="s"&gt;1000&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h1&gt;
  
  
  A Common Pitfall
&lt;/h1&gt;

&lt;p&gt;It’s important to remember that &lt;code&gt;==&lt;/code&gt; &lt;strong&gt;compares object references&lt;/strong&gt;, not values.&lt;/p&gt;

&lt;p&gt;That’s why you might see confusing results:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight java"&gt;&lt;code&gt;    &lt;span class="nc"&gt;Integer&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;100&lt;/span&gt;&lt;span class="o"&gt;;&lt;/span&gt;
    &lt;span class="nc"&gt;Integer&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;100&lt;/span&gt;&lt;span class="o"&gt;;&lt;/span&gt;
    &lt;span class="nc"&gt;System&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="na"&gt;out&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="na"&gt;println&lt;/span&gt;&lt;span class="o"&gt;(&lt;/span&gt;&lt;span class="n"&gt;a&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="o"&gt;);&lt;/span&gt; &lt;span class="c1"&gt;// true (cached)&lt;/span&gt;

    &lt;span class="nc"&gt;Integer&lt;/span&gt; &lt;span class="n"&gt;c&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;128&lt;/span&gt;&lt;span class="o"&gt;;&lt;/span&gt;
    &lt;span class="nc"&gt;Integer&lt;/span&gt; &lt;span class="n"&gt;d&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;128&lt;/span&gt;&lt;span class="o"&gt;;&lt;/span&gt;
    &lt;span class="nc"&gt;System&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="na"&gt;out&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="na"&gt;println&lt;/span&gt;&lt;span class="o"&gt;(&lt;/span&gt;&lt;span class="n"&gt;c&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="n"&gt;d&lt;/span&gt;&lt;span class="o"&gt;);&lt;/span&gt; &lt;span class="c1"&gt;// false (not cached)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;When comparing numeric values, always use &lt;code&gt;.equals()&lt;/code&gt; instead:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight java"&gt;&lt;code&gt;    &lt;span class="nc"&gt;System&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="na"&gt;out&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="na"&gt;println&lt;/span&gt;&lt;span class="o"&gt;(&lt;/span&gt;&lt;span class="n"&gt;c&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="na"&gt;equals&lt;/span&gt;&lt;span class="o"&gt;(&lt;/span&gt;&lt;span class="n"&gt;d&lt;/span&gt;&lt;span class="o"&gt;));&lt;/span&gt; &lt;span class="c1"&gt;// true&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



</description>
      <category>java</category>
      <category>jvm</category>
      <category>performance</category>
      <category>techexplained</category>
    </item>
    <item>
      <title>A Tiny Decimal That Caused Big Trouble, Until I Learned About BigDecimal</title>
      <dc:creator>Md Marzukul Islam</dc:creator>
      <pubDate>Mon, 03 Nov 2025 07:02:35 +0000</pubDate>
      <link>https://dev.to/marzuk16/a-tiny-decimal-that-caused-big-trouble-until-i-learned-about-bigdecimal-30ji</link>
      <guid>https://dev.to/marzuk16/a-tiny-decimal-that-caused-big-trouble-until-i-learned-about-bigdecimal-30ji</guid>
      <description>&lt;p&gt;If you’ve ever wondered why developers always say “never use double for money”, here’s the real reason, and why BigDecimal solves the problem perfectly.&lt;/p&gt;

&lt;h2&gt;
  
  
  1. The Root Cause: &lt;code&gt;Binary&lt;/code&gt; VS &lt;code&gt;Decimal&lt;/code&gt; Representation
&lt;/h2&gt;

&lt;p&gt;A &lt;code&gt;double&lt;/code&gt; in Java uses &lt;strong&gt;IEEE 754 binary floating point&lt;/strong&gt;, meaning it represents numbers as sums of powers of &lt;strong&gt;2&lt;/strong&gt;, not &lt;strong&gt;10&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;That works fine for many numbers, but not for decimals like &lt;code&gt;0.1&lt;/code&gt; or &lt;code&gt;0.2&lt;/code&gt;, because they can’t be represented exactly in binary.&lt;br&gt;
They become repeating binary fractions:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;    0.1₁₀ = 0.0001100110011001100...₂ (infinite)
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;So this simple code:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight java"&gt;&lt;code&gt;    &lt;span class="nc"&gt;System&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="na"&gt;out&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="na"&gt;println&lt;/span&gt;&lt;span class="o"&gt;(&lt;/span&gt;&lt;span class="mf"&gt;0.1&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="mf"&gt;0.2&lt;/span&gt;&lt;span class="o"&gt;);&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;prints:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;    0.30000000000000004
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;That tiny error is a &lt;em&gt;rounding artifact&lt;/em&gt;, and in finance or accounting, it’s unacceptable.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. How &lt;code&gt;BigDecimal&lt;/code&gt; Fixes It
&lt;/h2&gt;

&lt;p&gt;&lt;code&gt;BigDecimal&lt;/code&gt; doesn’t use floating-point math at all.&lt;br&gt;
Internally, it stores two things:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight java"&gt;&lt;code&gt;    &lt;span class="nc"&gt;BigInteger&lt;/span&gt; &lt;span class="n"&gt;intVal&lt;/span&gt;&lt;span class="o"&gt;;&lt;/span&gt;  &lt;span class="c1"&gt;// exact integer value&lt;/span&gt;
    &lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;scale&lt;/span&gt;&lt;span class="o"&gt;;&lt;/span&gt;          &lt;span class="c1"&gt;// how many digits after the decimal point&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;For example:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight java"&gt;&lt;code&gt;    &lt;span class="nc"&gt;BigDecimal&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nc"&gt;BigDecimal&lt;/span&gt;&lt;span class="o"&gt;(&lt;/span&gt;&lt;span class="s"&gt;"123.45"&lt;/span&gt;&lt;span class="o"&gt;);&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;is stored as:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;    intVal = 12345
    scale  = 2
    value  = 12345 × 10^-2 = 123.45
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Which is 100% exact, no rounding errors.&lt;/p&gt;

&lt;p&gt;That’s because:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;code&gt;BigInteger&lt;/code&gt; holds &lt;strong&gt;whole numbers&lt;/strong&gt; precisely in binary.&lt;/li&gt;
&lt;li&gt;The &lt;strong&gt;scale&lt;/strong&gt; simply shifts the decimal point in base &lt;strong&gt;10&lt;/strong&gt;.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  3. Why &lt;code&gt;BigDecimal&lt;/code&gt; Is Perfect for Money
&lt;/h2&gt;

&lt;p&gt;Money works in decimal, not binary.&lt;/p&gt;

&lt;p&gt;&lt;code&gt;BigDecimal&lt;/code&gt; uses &lt;strong&gt;decimal arithmetic&lt;/strong&gt;, so values like &lt;code&gt;0.1&lt;/code&gt;, &lt;code&gt;19.99&lt;/code&gt;, or &lt;code&gt;123456.78&lt;/code&gt; are stored and calculated exactly as written, no binary drift, no rounding surprises.&lt;/p&gt;

&lt;p&gt;Yes, it’s slower than &lt;code&gt;double&lt;/code&gt;, but it’s correct and correctness is what matters in financial systems.&lt;/p&gt;

</description>
      <category>java</category>
      <category>bigdecimal</category>
      <category>fintech</category>
      <category>backend</category>
    </item>
  </channel>
</rss>
