💡 Accessing Map Elements in Different Ways (Java Edition) In Java, a Map is one of the most powerful data structures for key-value management — but many learners limit themselves to just one way of accessing its elements. Let’s explore a few efficient ways to iterate and access map elements 👇 --- 🔹 1️⃣ Using for-each with entrySet() Best when you need both key and value. Map<String, Integer> scores = Map.of( "Alice", 90, "Bob", 85, "Charlie", 92 ); for (Map.Entry<String, Integer> entry : scores.entrySet()) { System.out.println(entry.getKey() + " → " + entry.getValue()); } ✅ Why use it? Direct access to both key and value. Efficient — avoids multiple lookups. --- 🔹 2️⃣ Using keySet() and get() Best when you only have keys and want to fetch values. for (String name : scores.keySet()) { System.out.println(name + " → " + scores.get(name)); } ⚠️ Note: This performs a lookup for each key — slightly less efficient than entrySet() for large maps. --- 🔹 3️⃣ Using values() When you only care about the values. for (Integer value : scores.values()) { System.out.println("Score: " + value); } --- 🔹 4️⃣ Using forEach() (Java 8+) A cleaner and modern approach. scores.forEach((name, value) -> System.out.println(name + " → " + value) ); ✅ Why use it? Concise and expressive. Perfect for lambda-based stream operations. --- 🚀 Takeaway: 👉 entrySet() → When you need both key & value efficiently. 👉 keySet() + get() → When keys matter most. 👉 values() → When you only need values. 👉 forEach() → When you want modern, readable code. --- 💬 What’s your preferred way to loop through a Map — traditional or functional? Let’s discuss 👇 #Java #Programming #CodingTips #CollectionsFramework #LearningJava
How to Access Map Elements in Java
More Relevant Posts
-
🚀 Top Modern Java Features - Part 1🤔 🔥 Modern Java = Cleaner Code + More Power + Zero Boilerplate. 👇 1️⃣ LAMBDAS + STREAMS 🔹Java finally got functional, no loops, no clutter, just logic. 🔹E.g., list. stream().filter(x -> x > 5).forEach(System.out::println); 2️⃣ VAR (TYPE INFERENCE) 🔹Java got modern syntax, infers types automatically based on data value. 🔹E.g., var message = "Hello Java"; 3️⃣ TRY-WITH-RESOURCES 🔹Because you deserve auto-cleanup, no more closing connections manually. 🔹E.g., try (var conn = getConnection()) { } 4️⃣ TEXT BLOCKS (""" … """) 🔹Java said goodbye string chaos, Java’s multi-line strings keep it clean now. 🔹E.g., String html = """<html><body>Hello</body></html>"""; 5️⃣ OPTIONAL API 🔹The official cure for NullPointerException, safe, elegant, and expressive. 🔹E.g., Optional.ofNullable(user).ifPresent(System.out::println); 💬 Which feature changed the way you write Java? #Java #Java21 #ModernJava #Developers #Programming #CodingTips #SoftwareEngineering
-
🚀 Top 3 Java Features for Cleaner & Shorter Code 🤔 Cut the clutter in your Java code with these 3 modern features. 👇 1️⃣ VAR – Local Variable 🔹E.g., var i = 1; var message = "Hello"; 🔹Java infers types automatically based on data value 🔹BEFORE Java 10, you had to declare types explicitly like below 🔹E.g., int i = 1; String message = "Hello"; 2️⃣ SWITCH EXPRESSIONS – Smarter Branching 🔹Cleaner syntax, returns values directly. 🔹E.g., int result = switch(day) { case MONDAY -> 1; default -> 0; }; 🔹BEFORE Java 14, switch was like below 🔹E.g., switch(day) { case MONDAY: result = 1; break; default: result = 0; } 3️⃣ RECORDS – Lightweight Data Carriers 🔹Below one line is enough to create data class 🔹E.g., record User(String name) {} 🔹Compact and auto-generates constructor & methods. 🔹BEFORE Java 16, creating data classes needed boilerplate like below 🔹E.g., class User { private final String name; User(String name) 🔹E.g., { this. name = name; } public String name() { return name; } } 💬 Which one’s your favorite new feature? #Java #ModernJava #JavaFeatures #CleanCode #CodeSimplified #Programming #SoftwareDevelopment #Developers #CodingTips
-
Primitives vs Wrappers in Java: A Practical Balance for Performance and API Design 💡 In Java, choosing between primitive types (int, boolean, long) and their wrapper counterparts (Integer, Boolean, Long) isn’t just a speed race—it shapes how you model nullability, API contracts, and data flows. 🚀 Primitives win on performance and memory: fewer objects, no nulls, and straightforward arithmetic. They’re the default for local variables and tight loops. 🧭 Wrappers unlock object‑oriented conveniences: nullability, easy use in generics, and compatibility with reflection or frameworks. But boxing/unboxing and higher memory usage can sneak into hot paths. Key takeaways: - Use primitives in performance‑sensitive code and internal math. - Use wrappers in DTOs, API surfaces, or data stores where nulls or optional values matter. - Prefer primitive streams (IntStream, LongStream) to avoid boxing in data pipelines. - If you need to express absence with primitives, consider OptionalInt/OptionalLong rather than nulls. - When working with large, memory‑sensitive collections, consider primitive‑specific collections from third‑party libraries. - Be mindful of NPEs when a wrapper value is null. Bottom line: balance is design‑driven, not dogmatic. Align your choice with API guarantees and performance budgets. What’s your take? Have you faced a scenario where the primitive vs wrapper choice changed performance or design outcomes? What specific suggestions would you add to improve this post (e.g., with a short code snippet)? #Java #JavaPerformance #PrimitivesVsWrappers #SoftwareEngineering #Programming
-
🧠 Inside Java’s Map: How It Really Works! Ever wondered what happens under the hood when you put a key-value pair into a Map in Java? 🤔 Let’s peel back the layers and see how the magic happens! ⚙️ 🔍 What is a Map? A Map in Java stores data as key-value pairs — where each key is unique and maps to a specific value. Common implementations include: HashMap LinkedHashMap TreeMap ConcurrentHashMap But the real star of the show is HashMap — the most commonly used one! 🌟 ⚙️ How HashMap Works Internally When you call: map.put("Apple", 10); Here’s what happens step by step 👇 ➡️ Hashing the Key The hashCode() of the key ("Apple") is computed. The hash value is processed (via a hashing algorithm) to find the bucket index in the underlying array. ➡️ Storing in a Bucket Each bucket is a linked list (or tree after Java 8). If no key exists in that bucket, a new Node is created and stored there. ➡️ Handling Collisions If two keys map to the same bucket, they form a linked list (chaining). In Java 8+, if the list grows beyond 8 elements, it’s converted into a balanced Red-Black Tree — improving lookup time from O(n) to O(log n)! ➡️ Retrieval During get(key), Java again computes the hash and goes to the right bucket. It compares keys using equals() to find the exact match. 🧩 Key Methods Used hashCode() → Generates hash for locating the bucket equals() → Ensures uniqueness of keys resize() → Expands the array when load factor (default 0.75) is exceeded 💡 Fun Fact: HashMap’s design balances speed, memory efficiency, and collision handling — a masterpiece of data structure engineering! 📘 In short: HashMap = Array + Linked List + Red-Black Tree + Hashing = ⚡Fast Key-Value Lookup #Java #HashMap #DataStructures #JavaDeveloper #Coding #SoftwareEngineering #Internals #Performance
-
Why Every Java Object Size Is a Multiple of 8 Bytes Many developers write Java for years without ever asking “Why does every object size end up being a multiple of 8 bytes?” It sounds mysterious — but it’s just JVM being efficient. Every Java object in memory has three parts: 1. Header – Metadata managed by the JVM. It stores identity hash code, GC information, lock state, and a reference to the class. Typically 12 bytes on 32-bit JVMs or 16 bytes on 64-bit ones. 2. Instance Data – Your actual fields and variables (int, boolean, object references, etc.). The total size depends on the number and types of these fields. 3. Padding (Alignment) – The invisible filler bytes that make the total object size a multiple of 8 bytes. Why 8? Because CPUs prefer reading aligned memory blocks — usually in 8-byte chunks. Misaligned data forces the CPU to do extra reads, slowing performance. So, the JVM quietly adds padding to keep your objects aligned and access efficient. Even if your object’s natural size is 26 bytes, the JVM will round it up to 32 bytes for better performance. Think of it as the JVM saying: “I’ll waste a few bytes to save you a few microseconds.” This may sound complex, but once you grasp the logic, it’s actually simple — it’s all about hardware efficiency. My upcoming blog, “Java Object Internals: Size, Alignment & Behavior,” dives deeper into this topic with diagrams and code examples. It’s part of my ongoing series “Java for Newbies.” Progress of the Series: Introduction to the Series — Done Setting Up Your Java Environment — Done Hello World: Operation & Deep Dive — Done Constructor: Building an Object — Blog ready, video pending Java Object Internals: Size, Alignment & Behavior — In progress Java Object: Instance, References & Heap — In progress Follow the full journey here: https://lnkd.in/grmmWGn7 You can subscribe here: - nitinsingh717.substack.com Watch my YouTube videos here: youtube.com/@nitinsingh717 Repost to help others for learning. Follow me for more. Nitin Singh #java #learning #blog
-
-
⚡ Day 9: Jump Statements in Java Today I explored jump statements — the control breakers that change the normal flow of execution in a program. 💡 What I Learned Today break → Used to exit from a loop or switch statement early. continue → Skips the current iteration and moves to the next one. return → Exits from the current method and optionally returns a value. Jump statements make loops more flexible and improve flow control. 🧩 Example Code public class JumpStatements { public static void main(String[] args) { for (int i = 1; i <= 5; i++) { if (i == 3) { continue; // Skip 3 } if (i == 5) { break; // Stop loop at 5 } System.out.println("i = " + i); } System.out.println("Loop ended"); System.out.println("Sum: " + add(3, 4)); } static int add(int a, int b) { return a + b; // Return statement } } 🗣️ Caption for LinkedIn ⏩ Day 9 – Jump Statements in Java Today I learned about break, continue, and return — the control flow masters in Java! These statements help make loops and methods more powerful by deciding when to stop, skip, or exit. #CoreJava #JavaLearning #CodingJourney #Programming #LearnJava
-
-
🧠 Day 7: Java Conditional Statements Today’s focus is on decision-making in Java — how programs choose what to do based on conditions. 💡 What I Learned Today if Statement – executes code only if condition is true if-else – executes one block if true, another if false else-if ladder – checks multiple conditions sequentially nested if – an if statement inside another if switch – used for multiple fixed options (like menus) 🧩 Example Code public class ConditionalExample { public static void main(String[] args) { int marks = 85; if (marks >= 90) { System.out.println("Grade: A+"); } else if (marks >= 75) { System.out.println("Grade: A"); } else if (marks >= 60) { System.out.println("Grade: B"); } else { System.out.println("Grade: C"); } } } 🗣️ Caption for LinkedIn 🚀 Day 7 of my #30DaysOfJava challenge! Today I learned about Conditional Statements – how Java makes decisions based on logic and data. Mastering if, else, and switch helps build smart, dynamic programs! 💻 #Java #CodingJourney #LearnJava #CoreJava #LinkedInLearning
-
-
💡 Before Starting with Streams in Java 8 — Understand Lambda Expressions First! A Lambda Expression in Java is nothing but an anonymous function — no name, no return type, just clean and concise code. It’s one of the biggest reasons why Java 8 became a favorite among developers ❤️ But before diving into Streams, let’s understand a few key functional interfaces that make Lambdas so powerful 👇 🔹 Function<T, R> → Takes an input T, returns a result R. 🧠 Example: Function<String, Integer> length = s -> s.length(); 🔹 Predicate<T> → Takes input T, returns boolean (used for conditions). 🧠 Example: Predicate<Integer> isEven = n -> n % 2 == 0; 🔹 Consumer<T> → Takes input T, performs an action, returns nothing. 🧠 Example: Consumer<String> print = s -> System.out.println(s); 🔹 Supplier<T> → Takes no input, returns a result T. 🧠 Example: Supplier<Double> random = () -> Math.random(); ✨ When you mix all these with Lambda Expressions, your code becomes cleaner, more expressive, and far easier to maintain. Behind the scenes, these are all part of functional interfaces—interfaces with just one abstract method (plus optional default methods). 🚀 So before you explore Streams, make sure you understand Lambdas—they’re the foundation of Java 8’s functional magic. #Java #Java8 #LambdaExpressions #FunctionalProgramming #Streams #CleanCode #SoftwareDevelopment #Coding #Developers #TechLearning
-
☕ Day 12 of my “Java from Scratch” Series – “Relational Operators in Java”. When we want to compare two values or variables, we use Relational Operators in Java. These comparisons always give a boolean result — either true ✅ or false ❌. 🔹 List of Relational Operators 1. Equals (==) 2. Greater than (>) 3. Less than (<) 4. Greater than or equal to (>=) 5. Less than or equal to (<=) 6. Not equal to (!=) 📘 Example 1: int a = 5; int b = 5; if (a == b) { System.out.println("a and b are equal"); } ✅ Output: a and b are equal Because both a and b have the same value. 📘 Example 2: int a = 5; int b = 10; if (a >= b) { System.out.println("a is greater or equal to b"); } Result: ❌ This won’t print anything, because a is less than b, so the condition is false. 💡 In simple words: Relational operators help the program make decisions by comparing values. They are mainly used inside conditions (like if, while, etc.). 👉 Question for you: What will be the output of this code? 👇 int x = 7; int y = 10; System.out.println(x != y); (Comment your answer below ⬇️) #Java #Programming #Coding #JavaDeveloper #SoftwareEngineering #RelationalOperatorsInJava #Learning #Developers #JavaFromScratch #Tech #Technology #NeverGiveUp
Explore content categories
- Career
- Productivity
- Finance
- Soft Skills & Emotional Intelligence
- Project Management
- Education
- Technology
- Leadership
- Ecommerce
- User Experience
- Recruitment & HR
- Customer Experience
- Real Estate
- Marketing
- Sales
- Retail & Merchandising
- Science
- Supply Chain Management
- Future Of Work
- Consulting
- Writing
- Economics
- Artificial Intelligence
- Employee Experience
- Workplace Trends
- Fundraising
- Networking
- Corporate Social Responsibility
- Negotiation
- Communication
- Engineering
- Hospitality & Tourism
- Business Strategy
- Change Management
- Organizational Culture
- Design
- Innovation
- Event Planning
- Training & Development