List in Java

<style>

/* Base Reset & Variables */

.premium-blog-post * {

box-sizing: border-box;

}

/* Desktop Base Styling */

.premium-blog-post {

font-family: 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;

color: #334155;

line-height: 1.8;

font-size: 16px;

max-width: 850px;

margin: 0 auto;

padding: 40px 20px;

background-color: #ffffff;

}

.premium-blog-post h1 {

font-size: 2.6rem;

color: #0f172a;

margin-bottom: 24px;

font-weight: 800;

letter-spacing: -0.5px;

border-bottom: 4px solid #3b82f6;

display: inline-block;

padding-bottom: 10px;

}

.premium-blog-post h2 {

font-size: 1.8rem;

color: #1e293b;

margin-top: 50px;

margin-bottom: 20px;

font-weight: 700;

border-left: 5px solid #3b82f6;

padding-left: 15px;

background: linear-gradient(to right, #f1f5f9, transparent);

padding-top: 8px;

padding-bottom: 8px;

border-radius: 0 8px 8px 0;

}

.premium-blog-post p {

margin-bottom: 20px;

font-size: 1.05rem;

}

/* Lists */

.premium-list {

margin-bottom: 25px;

padding-left: 20px;

}

.premium-list li {

margin-bottom: 12px;

position: relative;

padding-left: 5px;

}

.premium-list li b {

color: #0f172a;

}

/* Custom Checkmark List */

.check-list {

list-style: none;

padding-left: 0;

}

.check-list li {

padding-left: 35px;

margin-bottom: 15px;

position: relative;

font-weight: 500;

color: #1e293b;

}

.check-list li::before {

content: '✅';

position: absolute;

left: 0;

top: 0;

color: #10b981;

font-size: 1.2rem;

}

/* Code Blocks */

.code-block {

background-color: #1e1e1e;

color: #d4d4d4;

font-family: 'Consolas', 'Courier New', monospace;

font-size: 15px;

padding: 25px;

border-radius: 10px;

overflow-x: auto;

margin-bottom: 30px;

border-left: 4px solid #3b82f6;

box-shadow: 0 8px 16px rgba(0,0,0,0.15);

line-height: 1.5;

white-space: pre;

}

.code-keyword { color: #569cd6; font-weight: bold; }

.code-type { color: #4ec9b0; }

.code-string { color: #ce9178; }

.code-function { color: #dcdcaa; }

.code-comment { color: #6a9955; font-style: italic; }

/* Premium Tables */

.table-wrapper {

overflow-x: auto;

margin-bottom: 40px;

border-radius: 10px;

box-shadow: 0 4px 20px rgba(0, 0, 0, 0.08);

border: 1px solid #e2e8f0;

}

.premium-table {

width: 100%;

border-collapse: collapse;

background-color: #ffffff;

text-align: left;

min-width: 600px;

}

.premium-table th {

background-color: #0f172a;

color: #ffffff;

font-weight: 600;

padding: 18px 20px;

letter-spacing: 0.5px;

}

.premium-table td {

padding: 16px 20px;

border-bottom: 1px solid #e2e8f0;

color: #475569;

vertical-align: middle;

}

.premium-table tr:last-child td {

border-bottom: none;

}

.premium-table tr:nth-child(even) {

background-color: #f8fafc;

}

.premium-table tr:hover {

background-color: #f1f5f9;

}

.method-name {

font-family: 'Consolas', 'Courier New', monospace;

color: #ef4444;

font-weight: 600;

background: #fee2e2;

padding: 4px 8px;

border-radius: 6px;

font-size: 0.9rem;

}

/* Info Cards */

.info-card {

background: linear-gradient(135deg, #eff6ff 0%, #ffffff 100%);

border-left: 5px solid #3b82f6;

padding: 30px;

border-radius: 0 12px 12px 0;

box-shadow: 0 10px 25px rgba(0, 0, 0, 0.05);

margin: 40px 0;

border: 1px solid #dbeafe;

}

.info-card h3 {

margin-top: 0;

color: #1d4ed8;

font-size: 1.4rem;

margin-bottom: 15px;

}

/* Hierarchy Visual CSS */

.hierarchy-box {

background: #f8fafc;

border: 2px dashed #cbd5e1;

border-radius: 12px;

padding: 30px;

text-align: center;

margin: 30px 0;

overflow-x: auto;

}

.tree-node {

display: inline-block;

padding: 10px 20px;

background: #0f172a;

color: white;

font-weight: bold;

border-radius: 8px;

margin: 10px;

position: relative;

box-shadow: 0 4px 6px rgba(0,0,0,0.1);

}

.tree-interface {

background: #3b82f6;

}

.tree-arrow {

font-size: 1.5rem;

color: #94a3b8;

display: block;

margin: 5px 0;

}

.tree-row {

display: flex;

justify-content: center;

gap: 15px;

flex-wrap: wrap;

margin-top: 20px;

}

.tree-class {

background: #10b981;

padding: 12px 20px;

border-radius: 8px;

color: white;

font-weight: 600;

flex: 1 1 120px;

max-width: 160px;

box-shadow: 0 4px 6px rgba(0,0,0,0.1);

}

/* Responsive Mobile & Tablet Adjustments */

@media (max-width: 768px) {

.premium-blog-post {

padding: 20px 15px;

font-size: 15px;

}

.premium-blog-post h1 {

font-size: 2rem;

border-bottom-width: 3px;

}

.premium-blog-post h2 {

font-size: 1.5rem;

margin-top: 40px;

padding-top: 6px;

padding-bottom: 6px;

}

.code-block {

font-size: 13px;

padding: 15px;

border-radius: 8px;

}

.premium-table th, .premium-table td {

padding: 12px 15px;

}

.info-card {

padding: 20px;

margin: 30px 0;

}

.tree-row {

gap: 10px;

}

.tree-class {

flex: 1 1 45%;

max-width: none;

}

</style>

<h1>Java List Interface: Complete Deep Dive</h1>

<p>The <code>List</code> interface is arguably the most utilized and important data structure in the entire Java Collection Framework. It forms the backbone of ordered data manipulation in Java backend development.</p>

<p>You should instantly reach for a <code>List</code> when your requirements meet these conditions:</p>

<li><b>Order matters:</b> You need to preserve the exact chronological order of insertion.</li>

<li><b>Duplicates are allowed:</b> You need to store the exact same value multiple times.</li>

<li><b>Index-based access:</b> You need to retrieve elements via mathematical positions (e.g., "Give me the 5th element").</li>

<li><b>Dynamic size is needed:</b> Standard arrays are fixed in size; Lists grow and shrink automatically.</li>

</ul>

<h2>1. Collection Framework Hierarchy</h2>

<p>To master the <code>List</code>, you must first understand where it lives inside the JVM's architecture. It is an interface that inherits from <code>Collection</code>, which inherits from <code>Iterable</code>.</p>

<div class="tree-node tree-interface">Iterable (Interface)</div>

<div class="tree-node tree-interface">Collection (Interface)</div>

<div class="tree-node tree-interface">List (Interface)</div>

<div class="tree-class">ArrayList</div>

<div class="tree-class">LinkedList</div>

<div class="tree-class">Vector</div>

<div class="tree-class">Stack</div>

</div>

<h2>2. Package Structure</h2>

<p>All the major interfaces, classes, and utility helpers for the List architecture reside in the core <code>java.util</code> package. To utilize them, you must import them into your classes.</p>

<span class="code-keyword">import</span> java.util.List;

<span class="code-keyword">import</span> java.util.ArrayList;

<span class="code-keyword">import</span> java.util.LinkedList;

<span class="code-keyword">import</span> java.util.Vector;

<span class="code-keyword">import</span> java.util.Stack;

<span class="code-keyword">import</span> java.util.Arrays;

<span class="code-keyword">import</span> java.util.Collections;

</div>

<h2>3. What exactly is a List?</h2>

<p>In Java, <code>List</code> is an interface. This means you cannot instantiate it directly (e.g., <code>new List()</code> is illegal). You must use one of its concrete implementation classes.</p>

<span class="code-keyword">public interface</span> <span class="code-type">List</span><E> <span class="code-keyword">extends</span> <span class="code-type">Collection</span><E> { ... }

</div>

<h3>Core Features of a List</h3>

<li><b>Ordered Collection:</b> It guarantees that the iteration order will match the exact sequence in which you inserted the items.</li>

<li><b>Duplicate Friendly:</b> Unlike a <code>Set</code>, a List will happily accept <code>list.add("Java");</code> a million times.</li>

<li><b>Null Values:</b> It fully supports storing multiple <code>null</code> values.</li>

</ul>

</div>

<h3>Code Example:</h3>

<span class="code-type">List</span><<span class="code-type">String</span>> list = <span class="code-keyword">new</span> <span class="code-type">ArrayList</span><>();

list.<span class="code-function">add</span>(<span class="code-string">"Java"</span>);

list.<span class="code-function">add</span>(<span class="code-keyword">null</span>);

System.out.<span class="code-function">println</span>(list);

<span class="code-comment">// Output:</span>

</div>

<h2>4. Internal Hierarchy in Detail</h2>

<p>The interface acts as a contract, but the real magic happens in the specific implementation classes. Here is what you need to know about the big four:</p>

<li><b>ArrayList:</b> The default choice for 95% of use cases. It uses a dynamic array under the hood. It offers lightning-fast $O(1)$ read access, but slower $O(n)$ insertions/deletions in the middle of the list.</li>

<li><b>LinkedList:</b> Uses a doubly-linked list. It is faster for inserting and deleting elements in the middle of the collection, but suffers from slow $O(n)$ read access because it must traverse nodes.</li>

<li><b>Vector:</b> The legacy version of ArrayList. It is fully synchronized (thread-safe), making it safe for multithreading but significantly slower due to locking overhead. Rarely used in modern Java.</li>

<li><b>Stack:</b> A child class of Vector. It enforces a LIFO (Last-In, First-Out) data structure architecture.</li>

</ul>

<h2>5. Core Methods of List</h2>

<p>Because these methods are defined in the <code>List</code> interface, they are guaranteed to be available in <i>all</i> implementation classes.</p>

<thead>

<tr>

<th>Method Signature</th>

<th>Description & Purpose</th>

</tr>

</thead>

<tbody>

<tr>

<td>Appends the specified element to the absolute end of the list.</td>

</tr>

<tr>

<td><span class="method-name">add(int index, E e)</span></td>

<td>Inserts the element at the exact specified position, shifting existing elements to the right.</td>

</tr>

<tr>

<td><span class="method-name">get(int index)</span></td>

<td>Returns the element located at the specified mathematical index.</td>

</tr>

<tr>

<td><span class="method-name">set(int index, E e)</span></td>

<td>Replaces the element at the specified index with the new element (updates the value).</td>

</tr>

<tr>

<td><span class="method-name">remove(int index)</span></td>

<td>Removes the element at the specified index and shifts subsequent elements to the left.</td>

</tr>

<tr>

<td><span class="method-name">remove(Object o)</span></td>

<td>Removes the first exact occurrence of the specified object from the list.</td>

</tr>

<tr>

<td><span class="method-name">contains(Object o)</span></td>

<td>Returns <code>true</code> if the list physically contains the specified element.</td>

</tr>

<tr>

<td>Returns the total number of elements currently stored in the list.</td>

</tr>

<tr>

<td><span class="method-name">isEmpty()</span></td>

<td>Returns <code>true</code> if the list contains absolutely zero elements.</td>

</tr>

<tr>

<td><span class="method-name">clear()</span></td>

<td>Violently removes all elements from the list, resetting its size to 0.</td>

</tr>

<tr>

<td><span class="method-name">indexOf(Object o)</span></td>

<td>Returns the index of the <i>first</i> occurrence of the element, or <code>-1</code> if not found.</td>

</tr>

<tr>

<td><span class="method-name">lastIndexOf(Object o)</span></td>

<td>Returns the index of the <i>last</i> occurrence of the element, or <code>-1</code> if not found.</td>

</tr>

<tr>

<td><span class="method-name">subList(int from, int to)</span></td>

<td>Returns a partial view (a slice) of the list between the specified <code>fromIndex</code> (inclusive) and <code>toIndex</code> (exclusive).</td>

</tr>

</tbody>

</table>

</div>

Learn Here Fun Pedia

Search This Blog

List in Java

Labels

Comments

Post a Comment

Popular posts from this blog

How I Got Selected in MNC

Spring Boot Introduction

Strings in C