Java Scanner Performance Issue with Large Inputs

#GenAI #RagforJAVA Few months ago I tried to build a RAG system in Java. I found 47 Python tutorials and exactly zero complete Java examples. So I figured it out the hard way : and wrote down everything I learned. Here's what nobody tells you about RAG in Java: The concept is simple. Two pipelines: #Ingest your docs (chunk → embed → store) #Answer questions (embed query → retrieve → prompt → LLM) The implementation is where it gets interesting. 𝗖𝗵𝘂𝗻𝗸𝗶𝗻𝗴 matters more than the model. I've seen teams obsess over GPT-4 vs Claude while their chunks are 2000 tokens with no overlap. Fix chunking first. 𝗬𝗼𝘂 𝗱𝗼𝗻'𝘁 𝗻𝗲𝗲𝗱 𝗮 𝗳𝗮𝗻𝗰𝘆 𝘃𝗲𝗰𝘁𝗼𝗿 𝗗𝗕 𝘁𝗼 𝘀𝘁𝗮𝗿𝘁. If you already use PostgreSQL, install pgvector. One extension. You're done. 𝗦𝗽𝗿𝗶𝗻𝗴 𝗔𝗜 𝗵𝗮𝘀 𝗺𝗮𝘁𝘂𝗿𝗲𝗱 𝗮 𝗹𝗼𝘁. VectorStore, EmbeddingModel, ChatClient — it's actually pleasant to work with now. 𝗘𝗺𝗯𝗲𝗱𝗱𝗶𝗻𝗴𝘀 𝗮𝗿𝗲 𝗰𝗵𝗲𝗮𝗽. 𝗚𝗲𝗻𝗲𝗿𝗮𝘁𝗶𝗼𝗻 𝗶𝘀 𝗻𝗼𝘁. Stop worrying about embedding costs. Watch your LLM token usage instead. 𝗦𝗶𝗺𝗶𝗹𝗮𝗿𝗶𝘁𝘆 𝘁𝗵𝗿𝗲𝘀𝗵𝗼𝗹𝗱𝘀 𝗮𝗿𝗲 𝗺𝗮𝗻𝗱𝗮𝘁𝗼𝗿𝘆. Without one, your LLM gets handed irrelevant junk and hallucinates confidently. Always set withSimilarityThreshold(). I wrote a full guide: architecture diagrams, working Spring Boot code (IngestionService, RagService, REST controller), pgvector setup, chunking strategies, advanced patterns like HyDE and reranking, and a production checklist. All Java. No Python. #Java #SpringBoot #RAG #GenerativeAI #BackendEngineering #LLM

You'll tell me it's a prompt issue but I tried to make a relatively simple tool written in C that I felt a bit lazy in writing it and while I got it working it was terrible. The tool scans for Java doc like comments for functions and structs in a C header file and gathers their content into an html page and a markdown file. In my head I'm thinking of a naive implementation that isn't too complicated, I mean I was using nob.h so I could have a nice base for working with string slices; too bad that the AI failed about 3 times to use nob and went on to do it's own thing. It decided that short lived variables requiere being allocated and despite pulling the entire file into memory for the whole duration of the file generation it should duplicate the signatures into the heap instead of just making a string slice referencing the file content that's quite literally no freed till it's done. I think the most outrageous part was that it spiralled because I practically forced it to use string views where it created it's own memory corruption faked fixing it twice and monkey patched things thrice untill I said enough and ended up fixing the problem by hand. I spent a day and a half on this, I could've just written the code myself and finished with a better codebase and faster too. Anyways all that to say that I added a reference page for qleei my stack based programming language written in C. The reference has a C reference if you want to play with it as a C library and a language reference to see what are the language constructs. I dislike the code that generates it and will do a rewrite of it eventually if I ever feel like fixing the slop which I haven't even properly looked at. If you want to try out the wackiness of this stack based language there's also a web playground cause I value WASM a well. https://lnkd.in/e6ZNFsSp

🚀 DAY 69/150 — FINDING PATTERNS THROUGH SORTING! 🚀 Day 69 of my 150 Days DSA Challenge in Java and today I solved a problem that highlights the power of sorting and pattern observation 💻🧠 📌 Problem Solved: Minimum Absolute Difference 📌 LeetCode: #1200 📌 Difficulty: Easy–Medium The task is to find all pairs of elements with the minimum absolute difference in a given array. 🔹 Approach Used Instead of comparing every pair (which would take O(n²)), I used a more optimized approach: • First, sort the array • Then check only adjacent elements • Keep track of the minimum difference • Store all pairs that match this minimum difference Sorting helps reduce unnecessary comparisons and simplifies the logic. ⏱ Complexity Time Complexity: O(n log n) (due to sorting) Space Complexity: O(n) (for storing result pairs) 🧠 What I Learned • Sorting can significantly reduce the complexity of comparison-based problems • Adjacent elements in a sorted array often reveal important patterns • Avoid brute-force when a structured approach exists 💡 Key Takeaway This problem taught me that sometimes the simplest optimization is just reordering the data first. Once sorted, many complex problems become easier to solve. It also strengthened my understanding of how pattern recognition + sorting can lead to efficient solutions. ✅ Day 69 completed 🚀 81 days to go 🔗 Java Solution on GitHub: 👉 https://lnkd.in/gYHCJmkv 💡 Sorting is not just a technique — it’s a problem-solving strategy. #DSAChallenge #Java #LeetCode #Sorting #Greedy #150DaysOfCode #ProblemSolving #CodingJourney #InterviewPrep #LearningInPublic

🚀 #Headline: Day 10 — How Arrays Work in Java (Deep Dive into Memory) After learning array syntax in Part 1, today's lecture went beneath the surface. This wasn't about writing more code – it was about understanding what actually happens inside the JVM when you write new int[5]. This is the kind of knowledge that separates surface-level coders from developers who truly understand their tools. Covered in this lecture: ✔️ Why arrays are stored in contiguous memory ✔️ How arrays are allocated in Heap memory (not Stack!) ✔️ Stack vs Heap – what goes where ✔️ What happens inside the JVM during array creation ✔️ How memory indexing actually works (base address + offset) ✔️ Why array access is O(1) – constant time random access ✔️ Performance implications of contiguous storage ✔️ Special case of boolean arrays ✔️ How 2D arrays are stored in memory ✔️ Array of Strings – reference behavior The "aha" moment came when the instructor explained the math behind indexing: address = base + (index × size). This is why arrays are so fast – no traversal needed, just a direct calculation. Understanding that array references live on the Stack while the actual data lives on the Heap clarifies so many concepts about memory management. This lecture truly delivered on its promise: "This is not just coding. This is internal understanding." Learning from: 👨🏫 Aditya Tandon (Instructor) 🚀 Rohit Negi (CoderArmy) 📺 Source: https://lnkd.in/gpFpcpDs Let's connect 🤝 Pankaj Kumar #Java #100DaysOfCode #ProgrammingJourney #JavaBasics #BuildInPublic

🚀 Day 9 of My DSA Journey Today I solved the “Reverse Integer” problem on LeetCode using Java. This problem focuses on number manipulation, loops, and handling integer overflow, which makes it slightly tricky compared to basic problems. 💡 Problem Overview We are given a signed 32-bit integer x, and the task is to reverse its digits. Example: Input: 123 → Output: 321 Input: -123 → Output: -321 However, there is an important condition: ⚠️ If reversing the number causes it to go outside the 32-bit integer range, we must return 0. The valid integer range is: −2³¹ to 2³¹ − 1 ⚙️ Approach I Used I solved this problem using mathematical digit extraction: 1️⃣ Extract the last digit using x % 10 2️⃣ Remove the last digit from the number using x / 10 3️⃣ Build the reversed number using sum = sum * 10 + digit 4️⃣ Before adding the digit, check overflow condition using Integer.MAX_VALUE and Integer.MIN_VALUE. 📊 Complexity Analysis Time Complexity: O(log₁₀ n) Because the number of digits in n determines the number of loop iterations. Space Complexity: O(1) No extra memory is used. 📚 Key Learnings ✔ Practiced digit manipulation using modulus and division ✔ Learned how to handle integer overflow conditions ✔ Strengthened understanding of mathematical logic in algorithms 💻 Result ✅ Accepted ⚡ Runtime: 1 ms (Beats 99.88%) Small progress every day is building a strong foundation in Data Structures and Algorithms. On to Day 10 tomorrow. 💪 #DSA #LeetCode #100DaysOfCode #Java #ProblemSolving #CodingJourney #LearningInPublic #SoftwareDevelopment #Consistency

🚀 DAY 63/150 — FINDING THE FIRST UNIQUE CHARACTER! 🚀 Day 63 of my 150 Days DSA Challenge in Java and today I solved a problem that focuses on frequency counting and efficient string processing 💻🧠 📌 Problem Solved: First Unique Character in a String 📌 LeetCode: #387 📌 Difficulty: Easy–Medium The task is to find the index of the first non-repeating character in a given string. If every character repeats, the result should return -1. 🔹 Approach Used To solve this efficiently, I used a frequency counting technique. • First, count the frequency of each character in the string • Then iterate through the string again and find the first character whose frequency is 1 This approach avoids unnecessary comparisons and ensures an efficient solution. ⏱ Complexity Time Complexity: O(n) Space Complexity: O(1) (since the character set size is fixed) 🧠 What I Learned • Many string problems can be simplified using frequency arrays or hash maps • Breaking the problem into two passes often makes the logic cleaner • Understanding how to track occurrences efficiently helps avoid brute-force solutions 💡 Key Takeaway This problem helped reinforce the idea that choosing the right data structure (like a frequency array or HashMap) can significantly simplify string processing tasks. Even simple problems strengthen the fundamentals that are essential for solving complex interview questions. ✅ Day 63 completed 🚀 87 days to go 🔗 Java Solution on GitHub: 👉 https://lnkd.in/gKxiuZEm 💡 Strong fundamentals in strings and hashing build the base for advanced problem-solving. #DSAChallenge #Java #LeetCode #Strings #HashMap #150DaysOfCode #ProblemSolving #CodingJourney #InterviewPrep #LearningInPublic

Can a Java class have TWO main() methods? Yes. And here is why. Most developers assume main() is sacred. Untouchable. One per class. But Java does not care about the name "main" being special. It only cares about METHOD SIGNATURES. The JVM entry point is strictly: public static void main(String[] args) Any other method named "main" with a DIFFERENT parameter list is just another overloaded method. Nothing special about it. Here is an example: public class Demo {   public static void main(String[] args) {     System.out.println("Entry point: " + args[0]);     Demo d = new Demo();     d.main(42);   }   public static void main(int code) {     System.out.println("Overloaded main: " + code);   } } Run it with: java Demo Hello Output: Entry point: Hello Overloaded main: 42 What is happening here? -> The JVM picks main(String[]) as the entry point -> main(int) is just a regular static method -> Both coexist because their parameter types differ -> This is standard method overloading, nothing exotic The key rule behind this: Java identifies methods by their SIGNATURE = method name + parameter types. Two methods with the same name but different parameters are completely valid. The compiler resolves which one to call at compile time. This applies to ANY method, including main(). When does this matter in practice? -> OCP certification exams love this pattern -> Understanding it prevents confusion with inheritance chains where multiple classes define main() -> It reinforces that method overloading is a COMPILE-TIME decision The takeaway: main() is not a keyword. It is not reserved. It is just a method name with a specific signature that the JVM looks for at startup. Everything else about it follows normal Java rules. Know your fundamentals. They show up when you least expect them. Sources: 📊 Oracle Java Tutorials - Defining Methods (2024) https://lnkd.in/etVdUdGv 📊 Oracle Community - Overloading main method (2011) https://lnkd.in/ea4ipFiD 📊 JEP 512 - Compact Source Files and Instance Main Methods (2025) https://lnkd.in/eR92ttPU #Java #MethodOverloading #SoftwareEngineering #BackendDevelopment #OCP #JavaDeveloper #Programming #TechCommunity

Stop writing `if (obj != null)` checks in every single method. It's 2026, and we still spend hours debugging `NullPointerExceptions` that could have been caught at compile time. The solution isn't more tests; it's better type modeling. Enter Algebraic Data Types (ADTs) and Pattern Matching. This isn't just functional programming jargon; it's the modern standard for clean, safe code across Java, Rust, TypeScript, and more. 💡 Did you know? Recent 2025 data suggests that Null Pointer Exceptions account for roughly 30% of all runtime crashes in Java-based production environments. One simple NPE in Google's Service Control system recently caused a 7-hour global outage. That's the cost of `null`. ADTs let you model your data so that invalid states are unrepresentable. By using Enums (Sum Types) that carry data and Pattern Matching to handle them, you shift error detection from runtime to compile time. 🚀 Why make the switch? ✅ Exhaustiveness Checking: The compiler forces you to handle every possible case. No more forgotten `else` blocks. ✅ Type Safety: You can't accidentally pass a `null` where a value is expected. ✅ Readability: Logic flows naturally with `match` expressions instead of nested `if-else` ladders. Whether you are adopting Sealed Classes in Java 21+, using Rust's powerful enums, or leveraging Discriminated Unions in TypeScript, ADTs are the key to reducing cognitive load and eliminating entire classes of bugs. It's time to stop fighting the type system and start using it to your advantage. How do you handle state modeling in your projects? Are you team `Optional` or team ADTs? #CleanCode #TypeSafety #PatternMatching #CleanCode,#TypeSafety,#PatternMatching,#SoftwareEngineering,#Java,#Rust,#TypeScript Share your favorite ADT pattern in the comments below! 👇

𝘂𝘀𝗲𝗱 𝘁𝗼 𝘁𝗵𝗶𝗻𝗸 “𝗳𝗶𝗻𝗮𝗹 𝗶𝗻 𝗹𝗮𝗺𝗯𝗱𝗮” 𝗶𝘀 𝗷𝘂𝘀𝘁 𝗮𝗻𝗼𝘁𝗵𝗲𝗿 𝗝𝗮𝘃𝗮 𝗿𝘂𝗹𝗲… Until it actually hit me in a real scenario. I was writing a simple async flow using lambda… And suddenly compiler said: 👉 “variable must be final or effectively final” My first reaction: “Why Java is so strict here?” 😅 Then I tried to think deeper… int x = 10; Runnable r = () -> System.out.println(x); x = 20; r.run(); Now honestly… 👉 What should this print? 10? 20? That’s when it clicked 💡 Java doesn’t want you to even enter this confusion zone Lambdas in Java don’t behave like typical closures. They don’t track changing variables… They capture a fixed value snapshot So once captured → it must not change. Then I looked from concurrency angle 🧵 We use lambdas everywhere: ✔ Threads ✔ Async calls ✔ Streams If local variables were mutable: → Race conditions → Visibility issues → Nightmares in debugging That small “final” rule is actually doing a BIG job silently. It’s forcing: ✔ Predictable behavior ✔ Safer multi-threading ✔ Cleaner thinking And the best part? Java even relaxed it with effectively final So you don’t write extra code… But still get safety. Now whenever I see this rule… I don’t see restriction anymore. I see design maturity. 𝗥𝗲𝗮𝗹 𝘁𝗮𝗸𝗲𝗮𝘄𝗮𝘆 🚀 “Good languages don’t just give power… They protect you from misusing it.” Funny how a small compile-time error… Can teach such a deep concept. If you’ve faced this before, you know the pain 😄 If not, you will… and you’ll remember this.

Code Review Graph – 5x Fewer Tokens with Claude Code (MCP) Claude reads your entire codebase on every code review. 200 files. 150k tokens. Every. Single. Time. There's a smarter way — and it's a knowledge graph. `code-review-graph` is an open-source tool that builds a structural graph of your codebase using Tree-sitter, then gives Claude Code only what's actually relevant: → Changed files → Files in the blast radius (dependents, callers, importers) → Nothing else The result: ✅ 5–10x fewer tokens per review ✅ Automatic impact/blast-radius analysis ✅ Incremental updates in <2s after the first build ✅ Supports 12+ languages (Python, TS, Go, Rust, Java, C# and more) ✅ Native Claude Code integration via MCP The architecture is clean: Tree-sitter parses your code → SQLite + NetworkX stores the graph → Git diff detects what changed → MCP server exposes it to Claude. You get three review workflows out of the box: /code-review-graph:build-graph /code-review-graph:review-delta /code-review-graph:review-pr This is exactly the kind of tooling that makes AI-assisted development practical at scale — not just a demo, but a real workflow improvement. Have you thought about token costs in your AI dev workflow? Drop your approach below — I'd love to compare notes. #ClaudeCode #SystemDesign #MCP