Aleksei Briukhachev’s Post

Most Java performance problems weren't caused by bad algorithms. They were caused by objects no one thought twice about creating. Here's the hidden cost most developers overlook: Every object you create in Java lands on the heap. The Garbage Collector is responsible for cleaning it up. And that cleanup isn't free — it consumes CPU, and at worst, it pauses your entire application. Here's how it unfolds: → Every new object is born in Eden — a small, fast memory space → Fill it too quickly with throwaway objects and Java triggers a GC sweep → Most short-lived objects die there — that part is cheap and fast → But survivors get promoted deeper into memory (Old Generation) → When Old Generation fills up, Java runs a Full GC — and your app pauses That final pause isn't milliseconds. In heavy systems, it can be seconds. Users feel it. And the surprising part? Most of this pressure comes from innocent-looking code: ❌ new String("hello") instead of just "hello" ❌ String concatenation inside loops ❌ Autoboxing primitives (int → Integer) without thinking ❌ Calling Pattern.compile() inside a method that runs thousands of times ❌ Creating SimpleDateFormat repeatedly instead of using java.time None of these feel dangerous when you write them. But at scale, they add up to thousands of short-lived objects per second — and a GC that's constantly playing catch-up. The fix isn't complicated: ✅ Prefer primitives over wrapper types ✅ Use StringBuilder for string building in loops ✅ Cache reusable objects as static final constants ✅ Embrace immutable java.time classes — they're designed for reuse The best object, from a GC perspective, is the one you never created. I'm curious — what's the worst unnecessary allocation you've come across in a real codebase? And did it actually cause a production issue? Drop your story below 👇 Let's learn from each other. #Java #SoftwareEngineering #Performance #GarbageCollection #BackendDevelopment #CleanCode #CodeReview

Quick Sort in Java may look complex, but most mistakes happen because: • we don’t clearly understand how the pivot divides the array • we mix up the partition logic • we think recursion is doing the sorting The core idea is straightforward: choose a pivot, place it in the correct position, and recursively apply the same process to the left and right parts. What really happens: – A pivot element is selected – The array is rearranged so that elements smaller than pivot go to the left – Elements greater than pivot go to the right – The pivot lands at its final sorted position Then: – The left subarray is partitioned again using a new pivot – The right subarray is partitioned again – This continues until subarrays have 0 or 1 element – A single element is already sorted by definition So: – First, one pivot divides the array into two parts – Then each part is divided again – Then those smaller parts are divided further – And so on, until everything is positioned correctly The key insight: 👉 All the real sorting happens during partitioning, not after recursion finishes. Once you understand that: • recursion just keeps reducing the problem size • partition logic ensures correct positioning • average time complexity stays O(n log n) Quick Sort isn’t about guaranteed worst-case performance — it’s about speed, in-place efficiency, and practical performance. That’s what makes it a foundation algorithm for: ✔ in-memory sorting ✔ competitive programming ✔ high-performance systems #Java #QuickSort #DSA #Algorithms #DivideAndConquer #ProblemSolving #BackendEngineering

📄Java clone() 1️⃣ What clone means Shallow copy → copy the Object reference Deep copy → copy the Object reference+ copy their fields deeply 2️⃣ What Java actually does by default super.clone() ➡ Copies object structure ➡ Inner objects are shared So Java clone copies: ✔ primitives ❌ references (pointer copied, not object) 3️⃣ How we make it Deep Copy Manually clone inner objects: new Location(this.location) So: super.clone() + manual cloning = Deep Copy 4️⃣ Return Type Confusion Java forces method signature: Object clone() Compiler only sees Object So we cast: User copy = (User) original.clone(); 🧠 Casting does NOT create or convert objects It only changes how compiler views the reference 5️⃣ What actually happens internally clone() → memory duplication (no constructor called) Casting → only permission to access methods Object ref = userClone; ((User)ref).getName(); // allowed after cast No new object created here. 6️⃣ Important internal fact clone() in Object is a native method Real implementation exists inside JVM (C/C++), so IDE cannot open its source code. return (User) super.clone(); → works, but only shallow copy return new User(this); → works and can be deep copy GitHub Link: https://lnkd.in/g5Zj48m6 🔖Frontlines EduTech (FLM) #java #coreJava #BackendDevelopment #Programming #CleanCode #ResourceManagement #AustraliaJobs #SwitzerlandJobs #NewZealandJobs #USJobs #cloneMethod #deepCopy #shallowCopy

Threads state & Priority in java 🧵 After understanding what thread is and how to create one, the next question is: ➡️What state my thread is and how does the JVM schedule it? 🧠Threads States in Java A thread can be in one of these states during its lifecycle: 🔸NEW Thread is created but not yet started (start() method is not called) 🔸RUNNABLE Thread is ready to run or concurrently running 🔸BLOCKED Waiting to acquire a monitor lock (synchronized block) 🔸 WAITING Waiting indefinitely for another thread to act 🔸TIMED_WAITING Waiting for a specified time( sleep(), wait(timeout), join(timeout) ) 🔸TERMINATED Execution completed 👉A thread doesn't move linearly - it can jump between states multiple times. ---------------------------------------------------------------------- ⚡Thread Priority in Java Each thread has a priority that hints the scheduler: ✓MIN_PRIORITY — 1 ✓NORM_PRIORITY — 5(default) ✓MAX_PRIORITY — 10 ☘️Example: Thread t = new Thread(task); t.setPriority(Thread.MAX_PRIORITY); IMPORTANT ⚠️ 1.Priority is a hint, not a guarantee. 2.Behaviour is OS and JVM dependent. 3.High priority doesn't mean it will always run first. #Java #Threads #Concurrency #Multithreading #SoftwareEngineering #Backend #Programming

🚀 Java Deep Dive — Daemon Threads (Something many developers overlook) In Java, not all threads behave the same way. There are two types: • User Threads • Daemon Threads The JVM keeps running as long as at least one user thread is alive. But daemon threads work differently. They are background service threads used for supporting tasks like: • Garbage Collection • Monitoring • Background cleanup If all user threads finish, the JVM will terminate immediately, even if daemon threads are still running. Example: Java Example Thread thread = new Thread(() -> { while(true){ System.out.println("Running..."); } }); thread.setDaemon(true); thread.start(); If the main thread finishes, this daemon thread will not keep the JVM alive. Important rule: You must call "setDaemon(true)" before starting the thread, otherwise Java throws "IllegalThreadStateException". 💡 Key Insight Daemon threads are useful for background tasks that should not block application shutdown. #Java #Multithreading #BackendDevelopment #SoftwareEngineering #LearningInPublic

One subtle difference between Java and Rust that says everything about language philosophy. In Java, mutating a Map inside computeIfAbsent compiles fine — then explodes at runtime with a ConcurrentModificationException. In Java 8, it won't even crash. It silently corrupts your data. In Rust, the same pattern doesn't compile. At all. That's not a limitation. That's the point. I broke down both examples with the actual compiler output on my blog → https://lnkd.in/gqPgnebP #Rust #Java #SoftwareEngineering #MemorySafety

Why Java isn't just "Write Once, Run Anywhere"—It’s "Check Once, Execute Twice." Most developers know that Java has a Compile-time and a Runtime. But internally, the "Brain" of Java switches focus during these two phases. 🚀 The Core Difference: Compile-time (The Architect): Works strictly on the Reference Type. Runtime (The Builder): Works strictly on the Actual Object Type. Let’s break down the internals: 🔹 Compile-time (The Static Phase): The Compiler (javac) is like a strict security guard. It only looks at the "Label" (Reference Type). If you have Animal myDog = new Dog();, the compiler only sees Animal. It checks if the method you are calling exists in the Animal class. It doesn't care what is actually sitting in memory yet. 🔹 Runtime (The Dynamic Phase): The JVM (Java Virtual Machine) is the executor. It looks at the actual memory heap. It sees the new Dog() object. When you call makeSound(), the JVM uses Dynamic Method Dispatch to look up the method in the Dog class, even if the reference was Animal. Key Takeaway: If your code doesn't pass the "Reference Check" at compile-time, it will never get to the "Object Execution" at runtime. #Java #Programming #Backend #SoftwareEngineering #JVM #CodingTips

Java Array A data structure that stores multiple values of the same data type in a single variable. Arrays Class A utility class in Java that provides methods to perform operations on arrays such as sorting and searching. String A class used to represent a sequence of characters in Java; String objects are immutable. String Methods Predefined methods used to manipulate and retrieve information from String objects. StringBuffer and StringBuilder Classes used to create mutable strings; StringBuffer is thread-safe, while StringBuilder is faster but not thread-safe. Immutable and Mutable Immutable objects cannot be changed after creation, while mutable objects can be modified. Exception Handling A mechanism to handle runtime errors and maintain the normal flow of program execution. Shallow Copy and Deep Copy Shallow copy copies object references, while deep copy creates a new independent object. File Handling A process of creating, reading, writing, and deleting files in Java. Multithreading A feature that allows multiple threads to execute concurrently within a program. Synchronization A mechanism used to control access to shared resources in a multithreaded environment. Interthread Communication A technique that allows threads to communicate with each other during execution. Deadlock A situation where two or more threads wait indefinitely for each other’s resources. Daemon Thread A background thread that runs to support user threads and terminates when they finish. Inner Class A class defined inside another class to logically group related classes. Object Class The root superclass of all Java classes from which every class implicitly inherits. pdf Link :- https://lnkd.in/gXEWSAJ2 #Java #CoreJava #JavaDeveloper #JavaInterview #ProgrammingBasics  #SoftwareDevelopment #LearnJava #StudentDeveloper #TechLearning

Day 8-What I Learned In a Day Today, I learned about Primitive and Non-Primitive Variables in Java. Primitive Variables: Primitive variables store the actual data value directly in memory. They are basic built-in data types and store only a single value. Primitive Data Types: • byte • short • int • long • float • double • char • boolean Syntax: For Single Variable: PrimitiveDatatype varname; For multiple Variable: PrimitiveDatatype v1,v2; Non-Primitive Variables: Non-primitive variables store the reference (address) of an object, not the actual value. They can store single or multiple values and provide more functionality. Non-Primitive Types: • String • Arrays • Classes • Interfaces Syntax: For Single Variable: Non-PrimitiveDatatype varname; For multiple Variable: Non-PrimitiveDatatype v1,v2; Somebody Can relate the Songs +Coding= 👌 (Like the Song What I Played) #java # javaprogramming #coding #DailyGrowth #consistency

𝐎𝐮𝐭 𝐰𝐢𝐭𝐡 𝐭𝐡𝐞 𝐎𝐥𝐝, 𝐈𝐧 𝐰𝐢𝐭𝐡 𝐭𝐡𝐞 𝐍𝐞𝐰 Java has evolved, and with it, a simpler, more modern approach to writing immutable data types records. In previous versions of Java, creating simple value objects required a significant amount of boilerplate code. 𝐓𝐡𝐞 𝐎𝐥𝐝 𝐖𝐚𝐲 public class Point {   private final int x, y;   public Point(int x, int y) {     this.x = x;     this.y = y;   }   public int getX() { return x; }   public int getY() { return y; }       @Override   public boolean equals(Object obj) { ... }   @Override   public int hashCode() { ... }   @Override   public String toString() { ... } } 𝐓𝐡𝐞 𝐍𝐞𝐰 𝐖𝐚𝐲 Now, with records, all that boilerplate is handled for you. A record automatically generates A constructor equals(), hashCode(), and toString() methods public record Point(int x, int y) {} When you have simple value objects with immutable data. When you don’t need additional logic like setters, mutable fields, or complex methods. #Java #JavaRecords #Programming #Coding #ImmutableData #BoilerplateCode #CleanCode #Java14 #ModernJava #SoftwareDevelopment #CodeSimplification #ObjectOrientedProgramming #JavaBestPractices #JavaTips #JavaDeveloper #TechTrends #DeveloperLife #JavaSyntax #JavaProgramming #RecordClass #TechInnovation #CodingTips #JavaCommunity