Like 0
Fork 0

Last active 1741098222

kristofer's Avatar kristofer revised this gist 1741098222. Go to revision

1 file changed, 2 deletions

introarraylists.md

@@ -167,5 +167,3 @@ Choose ArrayLists when you:
167 167 ArrayLists provide a powerful, flexible alternative to traditional arrays in Java.
168 168 While slightly less efficient for fixed-size operations, they offer significant advantages
169 169 through their dynamic sizing and rich set of methods. As you develop more complex Java applications, ArrayLists will become an indispensable tool in your programming toolkit.
170 -
171 - In your next programming exercises, try replacing some of your fixed arrays with ArrayLists and explore how this flexibility simplifies your code and expands your capabilities.

kristofer's Avatar kristofer revised this gist 1740491348. Go to revision

1 file changed, 0 insertions, 0 deletions

introarraylists renamed to introarraylists.md

File renamed without changes

kristofer's Avatar kristofer revised this gist 1740491339. Go to revision

1 file changed, 171 insertions

introarraylists(file created)

@@ -0,0 +1,171 @@
1 + # Java ArrayLists: A Dynamic Alternative to Arrays
2 +
3 + While Java arrays are powerful, they have a significant complication: their size is fixed once created. Enter ArrayLists - a more flexible, dynamic alternative that automatically grows and shrinks as needed. ArrayLists are part of Java's Collections Framework and offer enhanced functionality for managing groups of objects.
4 +
5 + ## What Is an ArrayList?
6 +
7 + An ArrayList is a resizable array implementation of the List interface. Unlike regular arrays, ArrayLists can dynamically change in size during program execution. They store objects rather than primitive types, though Java's autoboxing feature allows them to work seamlessly with primitives too.
8 +
9 + ## ArrayList vs. Array
10 +
11 + Key differences between ArrayLists and traditional arrays:
12 +
13 + - **Dynamic Size**: ArrayLists grow automatically as elements are added
14 + - **Object Storage**: ArrayLists store objects, not primitives
15 + - **Built-in Methods**: ArrayLists come with useful methods for common operations
16 + - **Type Safety**: Generic type parameters ensure type safety at compile time
17 + - **Performance**: Traditional arrays have slightly better performance for fixed-size operations
18 +
19 + ## Creating an ArrayList
20 +
21 + ```java
22 + // Import ArrayList class
23 + import java.util.ArrayList;
24 +
25 + // Create an ArrayList of Strings
26 + ArrayList<String> names = new ArrayList<String>();
27 +
28 + // Since Java 7, you can use the diamond operator
29 + ArrayList<String> names = new ArrayList<>();
30 +
31 + // Initialize with elements
32 + ArrayList<String> fruits = new ArrayList<>(Arrays.asList("Apple", "Banana", "Orange"));
33 + ```
34 +
35 + The `<String>` syntax represents a generic type parameter, specifying that this ArrayList will contain String objects.
36 +
37 + ## Common ArrayList Operations
38 +
39 + ### Adding Elements
40 +
41 + ```java
42 + ArrayList<String> languages = new ArrayList<>();
43 +
44 + // Add element at the end
45 + languages.add("Java");
46 + languages.add("Python");
47 +
48 + // Add element at specific index
49 + languages.add(1, "JavaScript"); // Inserts at index 1
50 + // Now contains: [Java, JavaScript, Python]
51 + ```
52 +
53 + ### Accessing Elements
54 +
55 + ```java
56 + // Get element at specific index
57 + String language = languages.get(0); // Returns "Java"
58 +
59 + // Find index of specific element
60 + int index = languages.indexOf("Python"); // Returns 2
61 + ```
62 +
63 + ### Modifying Elements
64 +
65 + ```java
66 + // Change element at specific index
67 + languages.set(1, "C++"); // Replaces "JavaScript" with "C++"
68 + // Now contains: [Java, C++, Python]
69 + ```
70 +
71 + ### Removing Elements
72 +
73 + ```java
74 + // Remove by index
75 + languages.remove(2); // Removes "Python"
76 +
77 + // Remove by value
78 + languages.remove("Java"); // Removes "Java"
79 +
80 + // Remove all elements
81 + languages.clear();
82 + ```
83 +
84 + ### Checking Size and Contents
85 +
86 + ```java
87 + // Check if empty
88 + boolean isEmpty = languages.isEmpty(); // Returns true if no elements
89 +
90 + // Get current size
91 + int size = languages.size();
92 +
93 + // Check if contains element
94 + boolean hasJava = languages.contains("Java");
95 + ```
96 +
97 + ## Iterating Through ArrayLists
98 +
99 + ```java
100 + // Using standard for loop
101 + for (int i = 0; i < languages.size(); i++) {
102 + System.out.println(languages.get(i));
103 + }
104 +
105 + // Using enhanced for loop (for-each)
106 + for (String language : languages) {
107 + System.out.println(language);
108 + }
109 +
110 + // Using Iterator
111 + import java.util.Iterator;
112 + Iterator<String> iterator = languages.iterator();
113 + while (iterator.hasNext()) {
114 + System.out.println(iterator.next());
115 + }
116 + ```
117 +
118 + ## AutoBoxing with Primitive Types
119 +
120 + Since ArrayLists store objects, Java uses autoboxing to convert primitives to their wrapper classes:
121 +
122 + ```java
123 + // ArrayList of Integers (not int)
124 + ArrayList<Integer> numbers = new ArrayList<>();
125 + numbers.add(5); // Autoboxing: int to Integer
126 + int num = numbers.get(0); // Auto-unboxing: Integer to int
127 + ```
128 +
129 + ## Practical Examples
130 +
131 + ### Building a Dynamic To-Do List
132 +
133 + ```java
134 + ArrayList<String> todoList = new ArrayList<>();
135 + todoList.add("Complete assignment");
136 + todoList.add("Read chapter 5");
137 + todoList.add("Call John");
138 +
139 + // Mark a task as complete by removing it
140 + todoList.remove("Call John");
141 +
142 + // Add a high-priority task at the beginning
143 + todoList.add(0, "Submit application");
144 + ```
145 +
146 + ### Converting Between Arrays and ArrayLists
147 +
148 + ```java
149 + // Convert Array to ArrayList
150 + String[] namesArray = {"Alice", "Bob", "Charlie"};
151 + ArrayList<String> namesList = new ArrayList<>(Arrays.asList(namesArray));
152 +
153 + // Convert ArrayList to Array
154 + String[] backToArray = namesList.toArray(new String[0]);
155 + ```
156 +
157 + ## When to Use ArrayLists
158 +
159 + Choose ArrayLists when you:
160 + - Don't know the exact size needed in advance
161 + - Need to frequently add or remove elements
162 + - Need to use the built-in methods for searching, sorting, etc.
163 + - Want to avoid manual array resizing logic
164 +
165 + ## Summary
166 +
167 + ArrayLists provide a powerful, flexible alternative to traditional arrays in Java.
168 + While slightly less efficient for fixed-size operations, they offer significant advantages
169 + through their dynamic sizing and rich set of methods. As you develop more complex Java applications, ArrayLists will become an indispensable tool in your programming toolkit.
170 +
171 + In your next programming exercises, try replacing some of your fixed arrays with ArrayLists and explore how this flexibility simplifies your code and expands your capabilities.
Newer Older

Powered by Opengist ⋅ Load: 14ms⋅

English