What is a Variable in Java? Types and Examples

Arrays in Java 🧠 Concept: An Array in Java is a container object that holds a fixed number of elements of the same data type. Each element can be accessed using an index number, starting from 0. Arrays are static in size, meaning once created, their length cannot be changed. They can store primitive data types (like int, double, char) or objects (like String, Student, etc.). Types of Arrays in Java: 1. Single-Dimensional Array – Stores elements in a single row. 2. Multi-Dimensional Array – Stores data in rows and columns (like a matrix). 3. Jagged Array – A multi-dimensional array with rows of different lengths. 💡 Why it matters: Arrays are widely used in real-world applications such as: Student result systems (storing marks of multiple subjects) E-commerce apps (storing product prices or stock quantities) Sensor data processing (reading multiple sensor values at once) Games (storing scores, levels, or positions) They make data handling simple, structured, and efficient. Example / Snippet: 1. Single-Dimensional Array public class SingleArrayExample { public static void main(String[] args) { int[] scores = {90, 85, 88, 95, 100}; // Access and display for (int i = 0; i < scores.length; i++) { System.out.println("Score " + (i+1) + ": " + scores[i]); } } } Here, the array scores stores 5 integer values, accessible using indices 0 to 4. 2. Multi-Dimensional Array public class MultiArrayExample { public static void main(String[] args) { int[][] matrix = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} }; // Printing matrix elements for (int i = 0; i < matrix.length; i++) { for (int j = 0; j < matrix[i].length; j++) { System.out.print(matrix[i][j] + " "); } System.out.println(); } } } This represents a 3x3 matrix — useful in mathematical or graphical applications. 3. Jagged Array (Irregular Rows) public class JaggedArrayExample { public static void main(String[] args) { int[][] numbers = { {1, 2, 3}, {4, 5}, {6, 7, 8, 9} }; for (int i = 0; i < numbers.length; i++) { for (int j = 0; j < numbers[i].length; j++) { System.out.print(numbers[i][j] + " "); } System.out.println(); } } } Jagged arrays are used when data rows have varying lengths — for example, storing monthly sales data for stores with different transaction counts. #Java #CoreJava #JavaProgramming #LearnJava #JavaDeveloper #CodingInJava #ArraysInJava #DataStructures #ProgrammingBasics #SoftwareDevelopment #TechLearning #CodingJourney

Record class in Java A record in Java is a special kind of class introduced to reduce boilerplate code when you need an immutable data carriers. Automatically generates: private final fields A canonical constructor equals(), hashCode() toString() accessor methods (getters without get prefix) --- Example: Traditional Employee Class (Before Java 14) public class Employee { private int id; private String name; private double salary; public Employee(int id, String name, double salary) { this.id = id; this.name = name; this.salary = salary; } public int getId() { return id; } public String getName() { return name; } public double getSalary() { return salary; } @Override public String toString() { return "Employee{id=" + id + ", name='" + name + "', salary=" + salary + "}"; } @Override public boolean equals(Object o) { // } @Override public int hashCode() { // } } . Too much boilerplate (getters, constructor, toString, equals, hashCode). --- Example: Employee Record (After Java 16) public record Employee(int id, String name, double salary) { } That’s it! Java automatically generates: Constructor Getters (id(), name(), salary()) equals(), hashCode() toString() --- Example usage: public class Main { public static void main(String[] args) { Employee emp = new Employee(101, "Sreenu", 55000); System.out.println(emp.name()); // Output: Sreenu System.out.println(emp); // Output: Employee[id=101, name=Sreenu, salary=55000.0] } } --- Canonical Constructor (Full Constructor) Records provide a canonical constructor automatically, but you can define it manually if you need validation: public record Employee(int id, String name, double salary) { public Employee { if (salary < 0) throw new IllegalArgumentException("Salary must be positive"); } } --- Compact Constructor Example public record Employee(int id, String name, double salary) { public Employee { if (name == null || name.isBlank()) { throw new IllegalArgumentException("Name cannot be blank"); } } } -- Entity Example (JPA) Usually, JPA entities are mutable, so records are not recommended for entities that Hibernate modifies. But you can use them as read-only projections: public record EmployeeEntity(Long id, String name, Double salary) { } Or use a traditional entity and record DTO for response. Example: @Entity @Table(name = "employees") public class EmployeeEntity { @Id private Long id; private String name; private Double salary; // getters, setters, constructors } Then convert it into DTO using record: public record EmployeeDTO(Long id, String name, Double salary) { } EmployeeDTO dto = new EmployeeDTO(entity.getId(), entity.getName(), entity.getSalary());

☕ Day 6 – Java 2025: Smart, Stable, and Still the Future 💡 🧩 Topic: Data Types in Java Definition: Data types define the kind of values a variable can hold and how much memory it requires. In Java, data types ensure type safety — meaning you can’t assign incompatible values to variables. --- 🔹 Types of Data Types in Java Java has two main categories of data types: 1️⃣ Primitive Data Types 2️⃣ Non-Primitive (Reference) Data Types --- ⚙️ 1️⃣ Primitive Data Types Definition: Primitive data types are the basic building blocks in Java that store simple values like numbers, characters, or booleans. They are predefined by Java and not objects. Total Types: 8 1. byte 2. short 3. int 4. long 5. float 6. double 7. char 8. boolean --- 🧠 Details of Primitive Data Types Data Type Size Default Value Range Example byte 1 byte 0 -128 to 127 byte a = 10; short 2 bytes 0 -32,768 to 32,767 short s = 1000; int 4 bytes 0 -2,147,483,648 to 2,147,483,647 int num = 500; long 8 bytes 0L -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807 long l = 10000L; float 4 bytes 0.0f ~±3.4e−038 to ±3.4e+038 float f = 5.5f; double 8 bytes 0.0d ~±1.7e−308 to ±1.7e+308 double d = 12.345; char 2 bytes '\u0000' 0 to 65,535 (Unicode) char c = 'A'; boolean 1 bit false true / false boolean flag = true; --- 📐 Formula to Calculate Range For integer data types like byte, short, int, and long: 👉 Range = -2ⁿ⁻¹ to (2ⁿ⁻¹) - 1 Where n = number of bits. Example: For byte (8 bits): Range = -2⁷ to (2⁷ - 1) → -128 to 127 --- 💾 2️⃣ Non-Primitive Data Types Definition: Non-primitive data types are created by programmers and refer to objects. They can store multiple values or complex data. Examples: String Array Class Interface Enum They store references (addresses) instead of actual data values. --- 🧩 In Summary Category Definition Examples Primitive Basic, predefined types storing single values int, char, boolean Non-Primitive Reference types storing complex data String, Array, Class --- #Day6OfJava #Java2025 #JavaDataTypes #PrimitiveAndNonPrimitive #LearnJava #JavaForBeginners #CodeWithSneha #JavaLearning #JavaBasics #100DaysOfCode #TechWithLogic

Strings methods in Java 1️⃣ length() Definition: Returns the number of characters in a string (including spaces). 💡 Why it matters: Useful for checking input length (like passwords, usernames) or controlling loops. Example: String name = "Rakshitha"; System.out.println(name.length()); // Output: 9 2️⃣ charAt() Definition: Returns the character at a given index (index starts from 0). 💡 Why it matters: Helps to access or check specific characters, like the first letter of a name. Example: String word = "Java"; System.out.println(word.charAt(2)); // Output: v 3️⃣ toUpperCase() / toLowerCase() Definition: Converts all letters in a string to uppercase or lowercase. 💡 Why it matters: Useful for ignoring case in comparisons or displaying consistent text. Example: String text = "Java"; System.out.println(text.toUpperCase()); // JAVA System.out.println(text.toLowerCase()); // java 4️⃣ equals() / equalsIgnoreCase() Definition: equals() compares two strings exactly, while equalsIgnoreCase() ignores case differences. 💡 Why it matters: Used to compare user inputs like login IDs or names, case-sensitive or not. Example: String a = "Java"; String b = "java"; System.out.println(a.equals(b)); // false System.out.println(a.equalsIgnoreCase(b)); // true 5️⃣ contains() Definition: Checks if a string contains a certain sequence of characters. 💡 Why it matters: Used to search or validate text (like checking if an email contains “@”). Example: String email = "rakshitha@gmail.com"; System.out.println(email.contains("@gmail.com")); // true Awesome 👍 Here are the next 5 common String methods in Java — explained simply with definition, why it matters, and example 👇 6️⃣ substring() Definition: Extracts a part of the string between given start and end indexes. 💡 Why it matters: Used to get a specific portion of text, like extracting username from an email. Example: String word = "JavaDeveloper"; System.out.println(word.substring(0, 4)); // Output: Java 7️⃣ replace() Definition: Replaces all occurrences of a character or substring with another value. 💡 Why it matters: Useful for correcting text, filtering data, or formatting user input. Example: String text = "I love Java"; System.out.println(text.replace("Java", "Python")); // Output: I love Python 8️⃣ split() Definition: Splits a string into multiple parts based on a given delimiter and returns an array. 💡 Why it matters: Used to break text into pieces, such as splitting CSV data or words in a sentence. Example: String data = "apple,banana,grape"; String[] fruits = data.split(","); System.out.println(fruits[1]); // Output: banana 9️⃣ trim() Definition: Removes all leading and trailing spaces from a string. 💡 Why it matters: Essential for cleaning user input before saving or comparing values. Example: String name = " Rakshitha "; System.out.println(name.trim()); // Output: Rakshitha #Java #CoreJava #JavaProgramming #LearnJava #JavaDeveloper

𝐉𝐚𝐯𝐚 𝐌𝐞𝐦𝐨𝐫𝐲 𝐌𝐚𝐧𝐚𝐠𝐞𝐦𝐞𝐧𝐭: 𝐒𝐭𝐚𝐜𝐤, 𝐇𝐞𝐚𝐩 𝐚𝐧𝐝 𝐆𝐚𝐫𝐛𝐚𝐠𝐞 𝐂𝐨𝐥𝐥𝐞𝐜𝐭𝐢𝐨𝐧 Memory is fundamental for Java applications. To handle data effectively, Java divides its memory into two main areas: 𝑡ℎ𝑒 𝑠𝑡𝑎𝑐𝑘 and 𝑡ℎ𝑒 ℎ𝑒𝑎𝑝. Each plays a specific role in storing and managing data, impacting both performance.   1. 𝗦𝘁𝗮𝗰𝗸 𝗠𝗲𝗺𝗼𝗿𝘆 The stack is a special area of memory used for temporary data and method calls. Every time a method is called in Java, the JVM creates a stack frame to hold the method’s local variables, parameters and references to objects stored in the heap.   𝑾𝒉𝒆𝒏 𝒊𝒔 𝒊𝒕 𝒖𝒔𝒆𝒅? 🔸For storing primitive types 🔸For storing references to objects in the heap   𝑾𝒉𝒂𝒕 𝒊𝒔 𝒔𝒕𝒐𝒓𝒆𝒅 𝒊𝒏 𝒕𝒉𝒆 𝒔𝒕𝒂𝒄𝒌? 🔸Local variables 🔸Method parameters 🔸Return addresses 🔸References to heap objects   𝑬𝒙𝒂𝒎𝒑𝒍𝒆: 𝑝𝑢𝑏𝑙𝑖𝑐 𝑐𝑙𝑎𝑠𝑠 𝑆𝑡𝑎𝑐𝑘𝐸𝑥𝑎𝑚𝑝𝑙𝑒 {    𝑝𝑢𝑏𝑙𝑖𝑐 𝑠𝑡𝑎𝑡𝑖𝑐 𝑣𝑜𝑖𝑑 𝑚𝑎𝑖𝑛(𝑆𝑡𝑟𝑖𝑛𝑔[] 𝑎𝑟𝑔𝑠) {        𝑖𝑛𝑡 𝑎 = 10;          // 𝑠𝑡𝑜𝑟𝑒𝑑 𝑖𝑛 𝑠𝑡𝑎𝑐𝑘        𝑖𝑛𝑡 𝑏 = 20;          // 𝑠𝑡𝑜𝑟𝑒𝑑 𝑖𝑛 𝑠𝑡𝑎𝑐𝑘        𝑖𝑛𝑡 𝑠𝑢𝑚 = 𝑎 + 𝑏;     // 𝑠𝑡𝑜𝑟𝑒𝑑 𝑖𝑛 𝑠𝑡𝑎𝑐𝑘        𝑆𝑦𝑠𝑡𝑒𝑚.𝑜𝑢𝑡.𝑝𝑟𝑖𝑛𝑡𝑙𝑛(𝑠𝑢𝑚);    } } 𝑲𝒆𝒚 𝒑𝒐𝒊𝒏𝒕𝒔: 🔸Stack memory is fast, working in LIFO (Last In, First Out) order. 🔸Data is temporary — once the method finishes, the stack frame is removed automatically. 🔸Stack size is limited, so too many method calls can cause a StackOverflowError.   2. 𝗛𝗲𝗮𝗽 𝗠𝗲𝗺𝗼𝗿𝘆  While the stack stores temporary data and method calls, the heap is where Java objects and instance variables live. Every time you create a new object using the new keyword, Java allocates space for it in the heap.   𝑬𝒙𝒂𝒎𝒑𝒍𝒆: 𝑃𝑒𝑟𝑠𝑜𝑛 𝑝𝑒𝑟𝑠𝑜𝑛 = 𝑛𝑒𝑤 𝑃𝑒𝑟𝑠𝑜𝑛("𝐽𝑜ℎ𝑛"); // 𝑜𝑏𝑗𝑒𝑐𝑡 𝑠𝑡𝑜𝑟𝑒𝑑 𝑖𝑛 ℎ𝑒𝑎𝑝 Here, the variable person is stored on the stack, while the actual Person object resides in the heap. Heap memory is slower because managing dynamic memory is more complex, but Garbage Collector automatically frees unreferenced objects.   𝑲𝒆𝒚 𝒑𝒐𝒊𝒏𝒕𝒔: 🔸Heap stores objects and instance variables 🔸Data can live longer than the method that created it   𝗚𝗮𝗿𝗯𝗮𝗴𝗲 𝗖𝗼𝗹𝗹𝗲𝗰𝘁𝗼𝗿 In Java, the Garbage Collector (GC) automatically removes objects in the heap that are no longer referenced. This means you don’t have to manually free memory. 𝑲𝒆𝒚 𝒑𝒐𝒊𝒏𝒕𝒔: 🔸Frees memory for unused objects 🔸Runs in background, letting developers focus on code   In conclusion, having a clear understanding of Java’s memory structure helps developers make better decisions when optimizing applications. 𝑇ℎ𝑒 𝑠𝑡𝑎𝑐𝑘 manages temporary data and method calls, while 𝑡ℎ𝑒 ℎ𝑒𝑎𝑝 stores objects and instance variables, managed automatically by the Garbage Collector. Understanding how these memory areas work helps developers write more stable and memory-safe programs.

In Java, when we want to work with a unique set of data, say String, the Set data structure comes readily to mind. There’s one subtle thing about the Set data structure that if care is not taken, might lead you to begin to debug an inexistent issue. One subtle thing that’s quick to forget about HashSet is that the order of insertion isn’t guaranteed. I was left chasing my tail recently only to remember the nature of HashSet in Java. Say we did the below: Set<String> names = Set.of(“Promise”, “Oberoro”, “Akeni”); If you: System.out.println(names); A couple of times, you would get different outcomes not consistent in the way you added the data. Same as using a HashSet and adding data to it. In my case, I wanted to use the Set in the order in which the data were inserted but while debugging, I would be seeing the last inserted data first 😄. I thought someone was jinxing me until I remembered that orderliness isn’t guaranteed in Set. Oops 😬 poor me! If you want orderliness and uniqueness then go for LinkedHashSet. Set<String> names = new LinkedHashSet<>(); names.add(“Promise”); names.add(“Oberoro”); names.add(“Akeni”); This way, the order of insertion will always be guaranteed and you don’t have to be fooling around like I did. But if order of insertion isn’t important to you then you can use HashSet without issues. The fact that the HashSet isn’t ordered is not a weakness, it’s a design decision made to optimize for speed, which makes insertion, deletion, and look up much faster than its counterparts(LinkedHashset and Treeset) as those would have the overheads of maintaining additional data structure. It’s also worth noting that HashSet under the hood uses Hash table, that’s how it’s able to achieve uniqueness. LinkedHashSet uses hash table + linked list. TreeSet uses Red-Black tree to ensure data are sorted in natural or specified order. Ever had the experience of debugging something that when you eventually figured it out, made you want to punch yourself in the face? Kindly share let’s learn from you 👇 #softwareengineering #programming #coding

ArrayList(C)(1.2V): ============ Java Array List class uses a dynamic array for storing the elements.  It is like an array, but there is no size limit. We can add or remove elements anytime.  So, it is much more flexible than the traditional array. It is found in the java.util package. ArrayList is dynamic data structure in which you can add or remove any number of elements. The important points about Java ArrayList class are: ================================== 1. Java ArrayList class can contain duplicate elements. 2. Java ArrayList class maintains insertion order. 3. Not Synchronized: Array-List is not thread-safe. Multiple thread can be access. 4. Java ArrayList allows random access because array works at the index basis. 5. In ArrayList, manipulation is little bit slower than the LinkedList  in Java because a lot of shifting needs to occur if any element is removed from the array list. 6. We can not create an array list of the primitive types, such as int, float, char, etc.  It is required to use the wrapper class in such cases. For example: ArrayList<int> al = ArrayList<int>(); // does not work   ArrayList<Integer> al = new ArrayList<Integer>(); // works fine  Note: Java new generic collection allows you to have only one type of object in a collection.  Now it is type safe so typecasting is not required at runtime. Advantages of ArrayList: ================ 1. Dynamic Sizing: You don't need to specify the size in advance, and it can grow or shrink dynamically. 2. Indexed Access: Fast access to elements by index, making it ideal for situations where you need to access or modify elements frequently. 3. Supports Duplicates: Can store duplicate elements, unlike Set. 4. Flexibility: It is part of the Collections Framework, so you can easily use it with other collections and utilities (like sorting, searching, etc.). 5. ArrayList is the best choice if our frequent operation is retrieval. Disadvantages of ArrayList: ================= 1. Not Synchronized: ArrayList is not thread-safe by default, so it's not suitable for concurrent modifications by multiple threads. 2. Performance: Inserting or removing elements in the middle or beginning of an ArrayList is slow because it involves shifting elements. 3. Memory Consumption: It may consume more memory than other collections, especially when there are fewer elements than the allocated capacity. 4. ArrayList is the worst choice if our frequent operation is insertion (or) deletion in the middle because it requires several internal shift operations. #InterviewExperience #Java #SpringBoot #BackendDevelopment #Core Java #Basic Concept

🚀 Java Collections — What? Why? How? Mastering Collections Framework is essential for every Java Programmer — it’s where data structure logic meets real-world problem-solving. Let’s break it down simply 👇 --- 🧠 1️⃣ What is the Java Collections Framework (JCF)? What: A unified architecture to store and manipulate groups of objects. Why: Avoids reinventing data structures like arrays or linked lists. How: Provides interfaces ("List", "Set", "Map", "Queue") and classes ("ArrayList", "HashMap", etc.) in "java.util". --- 📋 2️⃣ List What: Ordered collection allowing duplicates. Why: When order matters — like user history. How: - "ArrayList" – Fast random access - "LinkedList" – Fast insert/delete - "Vector", "Stack" – Legacy options --- 🔢 3️⃣ Set What: No duplicates, unordered (usually). Why: For unique elements like IDs or emails. How: - "HashSet" – Fast, unordered - "LinkedHashSet" – Keeps insertion order - "TreeSet" – Sorted order --- 🔑 4️⃣ Map What: Stores key–value pairs (unique keys). Why: Perfect for lookups and caching. How: - "HashMap" – Unordered - "LinkedHashMap" – Insertion order - "TreeMap" – Sorted keys - "ConcurrentHashMap" – Thread-safe --- ⚙️ 5️⃣ Queue & Deque What: Hold elements before processing (FIFO/LIFO). Why: Great for task queues or scheduling. How: - "PriorityQueue" – Orders by priority - "ArrayDeque" – Double-ended queue --- 🔍 6️⃣ Iterator & ListIterator What: Used to traverse collections. Why: Ensures consistent element access. How: "Iterator" → Forward only "ListIterator" → Bidirectional --- 🧩 7️⃣ Comparable vs Comparator What: Interfaces for sorting. Why: Define how objects are ordered. How: - "Comparable" → Inside the class ("compareTo") - "Comparator" → External logic ("compare") --- ⚡ 8️⃣ Fail-Fast vs Fail-Safe What: Behavior on concurrent modification. Why: Prevents data inconsistency. How: - Fail-Fast → Throws "ConcurrentModificationException" - Fail-Safe → Works on a copy ("ConcurrentHashMap") --- 🧰 9️⃣ Collections & Arrays Utility Classes What: Helper classes with static methods. Why: For sorting, searching, synchronization, etc. How: - "Collections.sort()", "reverse()", "max()", "shuffle()" - "Arrays.asList()", "binarySearch()", "sort()" --- 🔒 🔄 10️⃣ Thread-Safe & Immutable Collections Why: For safe concurrent access or fixed data. How: - Thread-safe: "ConcurrentHashMap", "CopyOnWriteArrayList" - Immutable: "List.of("A", "B", "C")" --- 🌊 11️⃣ Streams + Collections What: Functional-style processing on data. How: list.stream() .filter(x -> x.startsWith("A")) .map(String::toUpperCase) .toList(); --- 💡 In short: «Java Collections = Data + Structure + Flexibility 💪» --- 💬 Which Collection type do you use the most — "ArrayList", "HashMap", or "TreeMap"? Drop your go-to in the comments 👇 #Java #Collections #WhatWhyHow #Programming #JavaDeveloper #Coding #Learning #TechTips

Strings in Java Concept: A String in Java is a sequence of characters enclosed within double quotes (" "). It’s not a primitive data type, but a class in the java.lang package — meaning every string in Java is actually an object. Example: String name = "Rakshitha"; Java provides three main classes to handle string-related operations: 1. String – Immutable (cannot be changed after creation). 2. StringBuilder – Mutable and faster (not thread-safe). 3. StringBuffer – Mutable and thread-safe (used in multithreaded programs). 💡 Why it matters: Strings are everywhere in Java programs — from user input and file handling to API calls and database operations. They are used in: 📱 User interfaces (displaying messages) 🌐 Web development (handling form data, URLs) 🧩 Backend systems (storing names, IDs, JSON) 🧠 Data processing (parsing text, logs) Efficient string handling improves memory performance and speed of your applications. Example / Snippet: 1️⃣ String (Immutable) public class StringExample { public static void main(String[] args) { String s1 = "Java"; String s2 = s1.concat(" Programming"); System.out.println(s1); // Output: Java System.out.println(s2); // Output: Java Programming } } Here, s1 remains unchanged. Instead, a new String object (s2) is created — this is called immutability. 2️⃣ StringBuilder (Mutable and Fast) public class StringBuilderExample { public static void main(String[] args) { StringBuilder sb = new StringBuilder("Java"); sb.append(" Developer"); System.out.println(sb); // Output: Java Developer } } Use StringBuilder when you need to modify strings frequently, such as building dynamic SQL queries or large text outputs. 3️⃣ StringBuffer (Mutable and Thread-safe) public class StringBufferExample { public static void main(String[] args) { StringBuffer sb = new StringBuffer("Core"); sb.append(" Java"); System.out.println(sb); // Output: Core Java } } StringBuffer is synchronized, making it safe to use in multi-threaded environments. #Java #CoreJava #StringInJava #JavaProgramming #LearnJava #StringBuilder #StringBuffer #JavaDeveloper #CodingInJava #TechLearning #SoftwareDevelopment #ProgrammingBasics #CodingJourney