1 //Java ArrayList Methods – Scenarios & Practice Programs

2 //Prepared By : Sumathi R
3 //https://www.linkedin.com/in/sumathi1989/
4
5
6 // 1. Add few names to an ArrayList and print them using a loop.
7
8 import java.util.ArrayList;
9 import java.util.List;
10
11 public class ArrayListExample {
12
13 public List<String> addNames() {
14 ArrayList<String> nameList = new ArrayList<>();
15 nameList.add("Sumathi");
16 nameList.add("Malathi");
17 nameList.add("Karthick");
18 nameList.add("Rajendiran");
19 nameList.add("Tamilselvi");
20
21 for (String name : nameList) {
22 System.out.println(name);
23 }
24 return nameList;
25 }
26
27 public static void main(String[] args) {
28 ArrayListExample example = new ArrayListExample();
29 example.addNames();
30 }
31 }
32
33
34
35 // 2. Check if a specific name exists in the ArrayList.
36
37 import java.util.List;
38 public class ArrayListCheckExample {
39
40 public void checkIfNameExists(List<String> neededList) {
41 for (String name : neededList) {
42 if (name.contains("Malathi")) {
43 System.out.println("\nYes! Malathi exists!!!!");
44 return;
45 }
46 }
47 System.out.println("Nope!");
48 }
49
50 public static void main(String[] args) {
51 List<String> sampleNames = java.util.Arrays.asList(
52 "Sumathi", "Malathi", "Karthick", "Rajendiran", "Tamilselvi"
53 );
54
55 ArrayListCheckExample example = new ArrayListCheckExample();
56 example.checkIfNameExists(sampleNames);
57 }
58 }
59
60
61
62 //3. Remove a name from the ArrayList.
63
64 import java.util.List;
65 import java.util.ArrayList;
66 import java.util.Arrays;
67
68 public class ArrayListRemoveExample {
69
 70 public void deleteElement(List<String> neededList) {
71 if (neededList.contains("Malathi")) {
72 neededList.remove("Sumathi");
73 }
74
75 System.out.println("New Name List::: ");
76 for (String name : neededList) {
77 System.out.println(name);
78 }
79 }
80
81 public static void main(String[] args) {
82 List<String> sampleNames = new ArrayList<>(Arrays.asList(
83 "Sumathi", "Malathi", "Karthick", "Rajendiran", "Tamilselvi"
84 ));
85
86 ArrayListRemoveExample example = new ArrayListRemoveExample();
87 example.deleteElement(sampleNames);
88 }
89 }
90
91
92
93 // 4. Replace the 3rd element with another name.
94
95 import java.util.List;
96 import java.util.ArrayList;
97 import java.util.Arrays;
98
99 public class ArrayListReplaceExample {
100
101 public void replaceElement(List<String> neededList) {
102 if (neededList.size() >= 3) {
103 neededList.set(2, "Mohith");
104 }
105
106 System.out.println("After replacing 3rd element.....");
107 for (String name : neededList) {
108 System.out.println(name);
109 }
110
111 }
112
113 public static void main(String[] args) {
114 List<String> sampleNames = new ArrayList<>(Arrays.asList(
115 "Sumathi", "Malathi", "Karthick", "Rajendiran", "Tamilselvi"
116 ));
117
118 ArrayListReplaceExample example = new ArrayListReplaceExample();
119 example.replaceElement(sampleNames);
120 }
121 }
122
123
124
125 // 5/6. Sort the ArrayList alphabetically and in reverse order.
126
127 import java.util.List;
128 import java.util.ArrayList;
129 import java.util.Arrays;
130 import java.util.Collections;
131
132 public class ArrayListSortExample {
133
134 public void sortElement(List<String> inputList) {
135 /// Sort alphabetically
136 Collections.sort(inputList);
137 System.out.println("After sorting element alphabetically.....");
138 for (String s : inputList) {
139 System.out.println(s);
140 }
141
142 /// Sort in reverse order
143 Collections.sort(inputList, Collections.reverseOrder());
144 System.out.println("After sorting element in reverse order.....");
145 for (String s : inputList) {
146 System.out.println(s);
147 }
148 }
149
150 public static void main(String[] args) {
151 List<String> sampleNames = new ArrayList<>(Arrays.asList(
152 "Sumathi", "Malathi", "Karthick", "Rajendiran", "Tamilselvi"
153 ));
154
155 ArrayListSortExample example = new ArrayListSortExample();
156 example.sortElement(sampleNames);
157 }
158 }
159
160
161
162 // 7. Print only names longer than 5 characters.
163
164 import java.util.List;
165 import java.util.ArrayList;
166 import java.util.Arrays;
167
168 public class ArrayListFilterExample {
169
170 public void printingList(List<String> inputString) {
171 for (String sname : inputString) {
172 if (sname.length() > 5) {
173 System.out.println(sname);
174 }
175 }
176 }
177
178 public static void main(String[] args) {
179 List<String> sampleNames = new ArrayList<>(Arrays.asList(
180 "Sumathi", "Malathi", "Karthick", "Rajendiran", "Tamilselvi", "Raj"
181 ));
182
183 ArrayListFilterExample example = new ArrayListFilterExample();
184 example.printingList(sampleNames);
185 }
186 }
187
188
189
190 // 8. Count how many names start with 'S'.
191
192 import java.util.List;
193 import java.util.ArrayList;
194 import java.util.Arrays;
195
196 public class ArrayListCountExample {
197
198 public void countingList(List<String> inputList) {
199 int count = 0;
200 for (String s : inputList) {
201 if (s.startsWith("S")) {
202 count++;
203 }
204 }
205 System.out.println("Count is::::: " + count);
206 }
207
208 public static void main(String[] args) {
209 List<String> sampleNames = new ArrayList<>(Arrays.asList(
210 "Sumathi", "Malathi", "Suresh", "Rajendiran", "Tamilselvi", "Saravanan"
211 ));
212
213 ArrayListCountExample example = new ArrayListCountExample();
214 example.countingList(sampleNames);
215 }
216 }
217
218
219 // 9. Check if the ArrayList is empty.
220
221 import java.util.List;
222 import java.util.ArrayList;
223 import java.util.Arrays;
224
225 public class ArrayListEmptyCheckExample {
226
227 public void checkList(List<String> checkingString) {
228 if (checkingString.isEmpty()) {
229 System.out.println("ArrayList is Empty!..");
230 } else {
231 int listSize = checkingString.size();
232 System.out.println("ListSize:::: " + listSize);
233 }
234 }
235
236 public static void main(String[] args) {
237 /// Example 1: Non-empty list
238 List<String> sampleNames = new ArrayList<>(Arrays.asList(
239 "Sumathi", "Malathi", "Karthick"
240 ));
241
242 /// Example 2: Empty list
243 List<String> emptyList = new ArrayList<>();
244
245 ArrayListEmptyCheckExample example = new ArrayListEmptyCheckExample();
246 example.checkList(sampleNames);
247 example.checkList(emptyList);
248 }
249 }
250
251
252
253 // 10. Clear the ArrayList and print it.
254 import java.util.List;
255 import java.util.ArrayList;
256 import java.util.Arrays;
257
258 public class ArrayListClearExample {
259
260 public void clearList(List<String> inputList) {
261 inputList.clear();
262 for (String s : inputList) {
263 System.out.println(s);
264 }
265 }
266
267 public static void main(String[] args) {
268 List<String> sampleNames = new ArrayList<>(Arrays.asList(
269 "Sumathi", "Malathi", "Karthick", "Rajendiran"
270 ));
271
272 ArrayListClearExample example = new ArrayListClearExample();
273 example.clearList(sampleNames);
274 }
275 }
276
277
278
279 // 11. Remove all names that contain the letter 'a'.
280 import java.util.List;
281 import java.util.ArrayList;
282 import java.util.Arrays;
283
284 public class ArrayListRemoveByLetterExample {
285
286 public void removingParticularElement(List<String> inputString) {
287 List<String> needToDelete = new ArrayList<>();
288 for (String name : inputString) {
289 if (name.contains("a")) {
290 needToDelete.add(name);
291 }
292 }
293 System.out.println("After removing names that contain the letter 'a'....");
294 inputString.removeAll(needToDelete);
295 System.out.println(inputString);
296 }
297
298 public static void main(String[] args) {
299 List<String> sampleNames = new ArrayList<>(Arrays.asList(
300 "Sumathi", "Malathi", "Karthick", "Rajendiran", "Tamilselvi", "Mohith"
301 ));
302
303 ArrayListRemoveByLetterExample example = new ArrayListRemoveByLetterExample();
304 example.removingParticularElement(sampleNames);
305 }
306 }
307
308
309 // 12. Create two ArrayLists and find common names (intersection).
310 import java.util.List;
311 import java.util.ArrayList;
312
313 public class ArrayListIntersectionExample {
314
315 public List<List<String>> findIntersectionOfLists() {
316
317 List<String> list1 = new ArrayList<>();
318 List<String> list2 = new ArrayList<>();
319
320 list1.add("Sumathi");
321 list1.add("Malathi");
322 list1.add("Karthik");
323 list1.add("Tamilselvi");
324 list1.add("Rajendiran");
325
326 System.out.println("List1 names ::: " + list1);
327
328 list2.add("Muthuveerappan");
329 list2.add("Sathyavani");
330 list2.add("Jawahar");
331 list2.add("Sumathi");
332 list2.add("Mohith");
333
334 System.out.println("List2 names ::: " + list2);
335
336 ArrayList<String> commonList = new ArrayList<>();
337
338 for (String name : list1) {
339 if (list2.contains(name)) {
340 commonList.add(name);
341 }
342 }
343 System.out.println("Common List is :::: " + commonList);
344
345 List<List<String>> bothLists = new ArrayList<>();
346 bothLists.add(list1);
347 bothLists.add(list2);
348
349 return bothLists;
350 }
351
352 public static void main(String[] args) {
353 ArrayListIntersectionExample example = new ArrayListIntersectionExample();
354 example.findIntersectionOfLists();
355 }
356 }
357
358
359 // 13. Merge two ArrayLists and remove duplicates.
360
361 import java.util.List;
362 import java.util.ArrayList;
363 import java.util.Arrays;
364
365 public class ArrayListMergeRemoveDuplicatesExample {
366
367 public void mergingListThenRemovingDuplicates(List<String> list1, List<String> list2)
{
368
369 System.out.println("List1 is :::: " + list1);
370 System.out.println("List2 is :::: " + list2);
371
372 /// Merging two lists
373 list1.addAll(list2);
374
375 System.out.println("After merging two lists ::: " + list1);
376
377 List<String> uniqueList = new ArrayList<>();
378
379 for (String name : list1) {
380 if (!uniqueList.contains(name)) {
381 uniqueList.add(name);
382 }
383 }
384
385 System.out.println("UniqueList Names::: " + uniqueList);
386 }
387
388 public static void main(String[] args) {
389 List<String> list1 = new ArrayList<>(Arrays.asList(
390 "Sumathi", "Malathi", "Karthick"
391 ));
392 List<String> list2 = new ArrayList<>(Arrays.asList(
393 "Rajendiran", "Malathi", "Mohith"
394 ));
395
396 ArrayListMergeRemoveDuplicatesExample example = new
ArrayListMergeRemoveDuplicatesExample();
397 example.mergingListThenRemovingDuplicates(list1, list2);
398 }
399 }
400
401
402 // 14. Print names that start and end with the same letter.
403
404 import java.util.List;
405 import java.util.ArrayList;
406
407 public class ArrayListSameFirstLastExample {
408
409 public List<String> printingList() {
410
411 List<String> nameList = new ArrayList<>();
412 nameList.add("Sumathi");
413 nameList.add("BhB");
414 nameList.add("KarishmaK");
415 nameList.add("Malathi");
416 nameList.add("AmalA");
417
418 System.out.println("Original List: " + nameList);
419
420 List<String> newList = new ArrayList<>();
421
422 for (String name : nameList) {
423 if (name == null || name.isEmpty()) {
424 continue;
425 }
426 char first = name.charAt(0);
427 char last = name.charAt(name.length() - 1);
428
429 if (first == last) {
430 newList.add(name);
431 }
432 }
433 System.out.println("Printing names that start and end with the same letter :::::
" + newList);
434 return nameList;
435 }
436
437 public static void main(String[] args) {
438 ArrayListSameFirstLastExample example = new ArrayListSameFirstLastExample();
439 example.printingList();
440 }
441 }
442
443
444 // 15. Find the longest name in the ArrayList.
445
446 import java.util.List;
447 import java.util.ArrayList;
448 import java.util.Arrays;
449
450 public class ArrayListLongestNameExample {
451
452 public String longestNameInTheList(List<String> nameList) {
453 String longestName = null;
454 int max = 0;
455 for (String name : nameList) {
456 int curr = name.length();
457 if (curr > max) {
458 max = curr;
459 longestName = name;
460 }
461 }
462 System.out.println("Longest name is :::: " + longestName);
463 return longestName;
464 }
465
466 public static void main(String[] args) {
467 List<String> sampleNames = new ArrayList<>(Arrays.asList(
468 "Sumathi", "Malathi", "Karthick", "Rajendiran", "Tamilselvi", "Mohith"
469 ));
470
471 ArrayListLongestNameExample example = new ArrayListLongestNameExample();
472 example.longestNameInTheList(sampleNames);
473 }
474 }
475
476
477
478
479
480
481 // 16.Remove duplicate names using a Set.
482
483 public List<Integer> removingDuplicates() {
484
485 ArrayList<Integer> ar = new ArrayList<Integer>();
486 ar.add(8);
487 ar.add(10);
488 ar.add(15);
489 ar.add(12);
490 ar.add(8);
491 ar.add(6);
492 ar.add(10);
493
494 System.out.println("Original List :::: " + ar);
495
496 Set<Integer> set = new HashSet<Integer>(ar);
497
498 List<Integer> uniqueList = new ArrayList<Integer>(set);
499
500 System.out.println("After removing duplicates :::: " + uniqueList);
501
502 return uniqueList;
503 }
504
505
506
507 // 17.Reverse the ArrayList without using Collections.reverse().
508
509 import java.util.ArrayList;
510 import java.util.List;
511
512 public class ReverseArrayListExample {
513
514 public List<Integer> reverseList(List<Integer> list) {
515
516 ///with using collections.reverse()
517 ///Collections.sort(list, Collections.reverseOrder());
518
519 /// without using collections.reverse()
520 System.out.println("Original List: " + list);
521
522 int size = list.size();
523 for (int i = 0; i < size / 2; i++) {
524 Integer temp = list.get(i);
525 list.set(i, list.get(size - 1 - i));
526 list.set(size - 1 - i, temp);
527 }
528
529 System.out.println("Reversed List: " + list);
530 return list;
531 }
532
533 public static void main(String[] args) {
534 ReverseArrayListExample obj = new ReverseArrayListExample();
535
536 List<Integer> numbers = new ArrayList<Integer>();
537 numbers.add(10);
538 numbers.add(20);
539 numbers.add(30);
540 numbers.add(40);
541 numbers.add(50);
542
543 obj.reverseList(numbers);
544 }
545 }
546
547
548
549
550 // 18. Find duplicates in the ArrayList without using a Set
551
552 import java.util.ArrayList;
553 import java.util.List;
554
555 public class DuplicateFinder {
556
557 public List<String> findingDuplicatesWithoutSet(List<String> inputList) {
558
559 inputList.add("Sumathi");
560 inputList.add("Malathi");
561 inputList.add("Sumathi");
562 inputList.add("Anu");
563 inputList.add("Malathi");
564
565 System.out.println("Original List is ::: " + inputList);
566
567 List<String> uniqueList = new ArrayList<String>();
568 List<String> duplicatesList = new ArrayList<String>();
569
570 for (String name : inputList) {
571 if (uniqueList.contains(name)) {
572 if (!duplicatesList.contains(name)) {
573 duplicatesList.add(name);
574 }
575 } else {
576 uniqueList.add(name);
577 }
578 }
579
580 System.out.println("Duplicate List is :::: " + duplicatesList);
581 return duplicatesList;
582 }
583
584 public static void main(String[] args) {
585 DuplicateFinder obj = new DuplicateFinder();
586 obj.findingDuplicatesWithoutSet(new ArrayList<String>());
587 }
588 }
589
590
591
592 // 19. Convert the ArrayList into an array and print.
593
594 import java.util.ArrayList;
595 import java.util.Arrays;
596 import java.util.List;
597
598 public class ArrayListToArrayExample {
599
600 public void convertingIntoArray() {
601
602 List<Integer> list = new ArrayList<Integer>();
603 list.add(20);
604 list.add(24);
605 list.add(22);
606 list.add(23);
607
608 Integer[] arrayL = list.toArray(new Integer[0]);
609
610 System.out.println(Arrays.toString(arrayL));
611 }
612
613 public static void main(String[] args) {
614 ArrayListToArrayExample obj = new ArrayListToArrayExample();
615 obj.convertingIntoArray();
616 }
617 }
618
619
620
621 // 20. Remove all even numbers from a list
622
623 import java.util.ArrayList;
624 import java.util.List;
625
626 public class ArrayListEvenRemove {
627
628 public List<Integer> removingEven() {
629 List<Integer> arr1 = new ArrayList<Integer>();
630 arr1.add(11);
631 arr1.add(20);
632 arr1.add(15);
633 arr1.add(22);
634 arr1.add(16);
635
636 List<Integer> arr2 = new ArrayList<Integer>();
637
638 for (int no : arr1) {
639 if (no % 2 != 0) {
640 arr2.add(no);
641 }
642 }
643 System.out.println("After removing even numbers from list is ::: " + arr2);
644 return arr2;
645 }
646
647 public static void main(String[] args) {
648 ArrayListEvenRemove obj = new ArrayListEvenRemove();
649 obj.removingEven();
650 }
651 }
652
653
654 // 21. Remove all names with less than 5 letters
655
656 import java.util.ArrayList;
657 import java.util.List;
658
659 public class RemoveNames {
660
661 public void removingNames() {
662
663 List<String> li = new ArrayList<String>();
664 li.add("Sumathi");
665 li.add("Tamilselvi");
666 li.add("Jawahar");
667 li.add("Puma");
668 li.add("Eli");
669 li.add("Rajesh");
670
671 List<String> li2 = new ArrayList<String>();
672
673 for (String name : li) {
674 if (name.length() >= 5) {
675 li2.add(name);
676 }
677 }
678 System.out.println("After removing names with less than 5 characters::: " + li2);
679 }
680
681 public static void main(String[] args) {
682 RemoveNames obj = new RemoveNames();
683 obj.removingNames();
684 }
685 }
686
687
688
689
690 // 22. Remove null or blank values from a list
691
692 import java.util.ArrayList;
693 import java.util.List;
694
695 public class RemoveBlankValues {
696
697 public static void main(String[] args) {
698 new RemoveBlankValues().removingBlank();
699 }
700 public void removingBlank() {
701
702 List<String> list1 = new ArrayList<String>();
703 list1.add("Sumathi");
704 list1.add(null);
705 list1.add("Karthi");
706 list1.add("");
707 list1.add(" ");
708 list1.add("Jawahar");
709
710 List<String> list2 = new ArrayList<String>();
711 for (String name : list1) {
712 if (name != null && !name.trim().isEmpty()) {
713 list2.add(name);
714 }
715 }
716 System.out.println("After removing blank and null values :::: " + list2);
717 }
718 }
719
720
721 // 23. Remove duplicate integers from list
722
723 import java.util.ArrayList;
724 import java.util.List;
725
726 public class RemoveDuplicatesDemo {
727
728 public static void main(String[] args) {
729 RemoveDuplicatesDemo obj = new RemoveDuplicatesDemo();
730 obj.removingDup();
731 }
732
733 public List<Integer> removingDup() {
734
735 List<Integer> orgList = new ArrayList<Integer>();
736 orgList.add(10);
737 orgList.add(20);
738 orgList.add(12);
739 orgList.add(10);
740 orgList.add(12);
741 orgList.add(30);
742
743 System.out.println("Original List is :::: " + orgList);
744
745 List<Integer> uniqueList = new ArrayList<Integer>();
746 List<Integer> dupList = new ArrayList<Integer>();
747
748 for (Integer no : orgList) {
749 if (uniqueList.contains(no)) {
750 if (!dupList.contains(no))
751 dupList.add(no);
752 } else {
753 uniqueList.add(no);
754 }
755 }
756
757 System.out.println("Duplicate List is ::: " + dupList);
758 System.out.println("After removing duplicates :::: " + uniqueList);
759
760 return uniqueList;
761 }
762 }
763
764
765
766 // 24. Keep only names that start with "S" or "M" (case-insensitive)
767 public List<String> filteringList() {
768
769 List<String> list1 = new ArrayList<String>();
770 list1.add("Sumathi");
771 list1.add("Malathi");
772 list1.add("Sowndraya");
773 list1.add("malavika");
774 list1.add("Karthik");
775 list1.add("Vignesh");
776
777 List<String> list2 = new ArrayList<String>();
778
779 for (String name : list1) {
780 if (name != null && !name.isEmpty()) { /// avoid null pointer
781 String firstLetter = name.substring(0, 1).toUpperCase();
782 if (firstLetter.equals("S") || firstLetter.equals("M")) {
783 list2.add(name);
784 }
785 }
786 }
787 System.out.println("Names starting with 'S' or 'M' ::: " + list2);
788 return list2;
789 }
790
791
792 // 25. Count the frequency of each name in a list
793
794 import java.util.ArrayList;
795 import java.util.HashMap;
796 import java.util.List;
797 import java.util.Map;
798
799 public class FrequencyExample {
800
801 public static void main(String[] args) {
802 FrequencyExample obj = new FrequencyExample();
803 obj.frequencyChecking();
804 }
805
806 public void frequencyChecking() {
807
808 List<String> nameList = new ArrayList<String>();
809 nameList.add("Sumathi");
810 nameList.add("Mohith");
811 nameList.add("Jawahar");
812 nameList.add("Sumathi");
813 nameList.add("Mohith");
814 nameList.add("Rejany");
815 nameList.add("Arulselvi");
816 nameList.add("Mohith");
817 nameList.add("Rejany");
818
819 Map<String, Integer> freqMap = new HashMap<String, Integer>();
820
821 for (String name : nameList) {
822 if (freqMap.containsKey(name)) {
823 freqMap.put(name, freqMap.get(name) + 1);
824 } else {
825 freqMap.put(name, 1);
826 }
827 }
828
829 for (Map.Entry<String, Integer> entry : freqMap.entrySet()) {
830 System.out.println(entry.getKey() + " occurs " + entry.getValue() + " times "
);
831 }
832 }
833 }
834
835
836 // 26. Find first repeated integer element
837
838 import java.util.ArrayList;
839 import java.util.List;
840
841 public class FirstRepeatedIntegerExample {
842
843 public void findingFirstRepeated() {
844
845 List<Integer> elementList = new ArrayList<Integer>();
846 elementList.add(10);
847 elementList.add(20);
848 elementList.add(30);
849 elementList.add(20);
850 elementList.add(10);
851
852 List<Integer> uniqueList = new ArrayList<Integer>();
853
854 for (Integer no : elementList) {
855 if (uniqueList.contains(no)) {
856 System.out.println("First repeated integer ::: " + no);
857 return;
858 } else {
859 uniqueList.add(no);
860 }
861 }
862 System.out.println("No repeated integer found");
863 }
864
865 public static void main(String[] args) {
866 FirstRepeatedIntegerExample example = new FirstRepeatedIntegerExample();
867 example.findingFirstRepeated();
868 }
869 }
870
871 // 27. Find first non - repeated character element in a list
872
873 import java.util.ArrayList;
874 import java.util.HashMap;
875 import java.util.List;
876 import java.util.Map;
877
878 public class FirstNonRepeatedCharacter {
879
880 public static void main(String[] args) {
881 findingFirstNonRepeated();
882 }
883
884 public static void findingFirstNonRepeated() {
885
886 List<String> li = new ArrayList<String>();
887 li.add("c");
888 li.add("h");
889 li.add("g");
890 li.add("o");
891 li.add("o");
892 li.add("h");
893 li.add("c");
894
895 System.out.println("The original list is ::: " + li);
896
897 Map<String, Integer> mapList = new HashMap<String, Integer>();
898
899 for (String c : li) {
900 if (mapList.containsKey(c)) {
901 mapList.put(c, mapList.get(c) + 1);
902 } else {
903 mapList.put(c, 1);
904 }
905 }
906
907 for (String ch : li) {
908 if (mapList.get(ch) == 1) {
909 System.out.println("First non-repeated element is ::: " + ch);
910 break; /// stop after finding the first one
911 }
912 }
913 }
914 }
915
916
917 //28. You have two lists of student names — one for students who registered for a
workshop and another for those who actually attended.
918 //Use retainAll() to find the students who both registered and attended.
919
920 import java.util.ArrayList;
921 import java.util.List;
922
923 public class RetainAllExample {
924
925 public void usingRetainAll() {
926
927 List<String> registeredList = new ArrayList<String>();
928 registeredList.add("Sumathi");
929 registeredList.add("Menaka");
930 registeredList.add("Ishwarya");
931 registeredList.add("Benny");
932 registeredList.add("Stephyrose");
933 registeredList.add("KavithaMalar");
934 registeredList.add("Senthamarai");
935 registeredList.add("Yasothai");
936 registeredList.add("SoniaKumari");
937 registeredList.add("MerinJose");
938
939 System.out.println("Registered List is :::: " + registeredList);
940
941 List<String> attendedList = new ArrayList<String>();
942 attendedList.add("KavithaMalar");
943 attendedList.add("Sumathi");
944 attendedList.add("Yasothai");
945 attendedList.add("Benny");
946
947 System.out.println("Attended List is :::: " + attendedList);
948
949 registeredList.retainAll(attendedList);
950
951 System.out.println("The students who both registered and attended :::");
952 for (String name : registeredList) {
953 System.out.println(name);
954 }
955 }
956
957 public static void main(String[] args) {
958 RetainAllExample example = new RetainAllExample();
959 example.usingRetainAll();
960 }
961 }
 962
963
964
965
966 //29. You are managing a list of students who registered for a session and another list
of students who attended the session.
967 //Write a Java program to find the names of students who registered but did not attend
the session.//use removeAll()
968
969 import java.util.ArrayList;
970 import java.util.List;
971
972 public class RemoveAllExample {
973
974 public static void main(String[] args) {
975 RemoveAllExample example = new RemoveAllExample();
976 example.usingRemoveAll();
977 }
978
979 public void usingRemoveAll() {
980
981 List<String> registeredList = new ArrayList<String>();
982 registeredList.add("Sumathi");
983 registeredList.add("Menaka");
984 registeredList.add("Ishwarya");
985 registeredList.add("Benny");
986 registeredList.add("Stephyrose");
987 registeredList.add("KavithaMalar");
988 registeredList.add("Senthamarai");
989 registeredList.add("Yasothai");
990 registeredList.add("SoniaKumari");
991 registeredList.add("MerinJose");
992
993 System.out.println("Registered List is :::: " + registeredList);
994
995 List<String> attendedList = new ArrayList<String>();
996 attendedList.add("KavithaMalar");
997 attendedList.add("Sumathi");
998 attendedList.add("Yasothai");
999 attendedList.add("Benny");
1000
1001 System.out.println("Attended List is :::: " + attendedList);
1002
1003 registeredList.removeAll(attendedList);
1004
1005 System.out.println("The names of students who registered but did not attend the
session...");
1006
1007 for (String name : registeredList) {
1008 System.out.println(name);
1009 }
1010 }
1011 }
1012
1013
1014 //30.Merge Two Department Employee Lists.
1015
1016 import java.util.ArrayList;
1017 import java.util.List;
1018
1019 class Employee {
1020 private String name;
1021 private String department;
1022 private int id;
1023
1024 public Employee(String name, String department, int id) {
1025 this.name = name;
1026 this.department = department;
1027 this.id = id;
1028 }
1029
1030 @Override
1031 public String toString() {
1032 return name + " (" + department + ", " + id + ")";
1033 }
1034 }
1035
1036 public class MergeEmployeeLists {
1037
1038 public void mergingEmp() {
1039 List<Employee> teamA = new ArrayList<Employee>();
1040 teamA.add(new Employee("Sumathi", "Gems", 1581));
1041 teamA.add(new Employee("Rejany", "Gems", 1234));
1042 teamA.add(new Employee("Arul", "Gems", 1641));
1043 teamA.add(new Employee("Geethanjali", "Gems", 1598));
1044
1045 List<Employee> teamB = new ArrayList<Employee>();
1046 teamB.add(new Employee("Krithika", "BFS", 1582));
1047 teamB.add(new Employee("Jagadhaaranya", "BFS", 1584));
1048 teamB.add(new Employee("Malini", "BFS", 1345));
1049 teamB.add(new Employee("Padmapriya", "BFS", 2345));
1050
1051 List<Employee> allEmployees = new ArrayList<Employee>();
1052 allEmployees.addAll(teamA);
1053 allEmployees.addAll(teamB);
1054
1055 System.out.println("Two Department Employee Lists ::: " + allEmployees);
1056 }
1057
1058 public static void main(String[] args) {
1059 MergeEmployeeLists obj = new MergeEmployeeLists();
1060 obj.mergingEmp();
1061 }
1062 }
1063
1064
1065 // 31. Find the First Occurrence of an Item in a Shopping List
1066
1067 import java.util.ArrayList;
1068 import java.util.List;
1069
1070 public class ShoppingListSearch {
1071
1072 public static void main(String[] args) {
1073 findingFirstOccurance();
1074 }
1075
1076 public static void findingFirstOccurance() {
1077
1078 List<String> shoppingList = new ArrayList<String>();
1079 shoppingList.add("Maggi");
1080 shoppingList.add("Maida");
1081 shoppingList.add("Veggies");
1082 shoppingList.add("Pulses");
1083 shoppingList.add("Maida");
1084 shoppingList.add("Nuts");
1085
1086 /// String searchItem = "Veggies"; // Hardcoded example
1087 String searchItem = "Veggies";
1088 System.out.println("The search item is ::: " + searchItem);
1089
1090 int occurance = shoppingList.indexOf(searchItem);
1091 int last = shoppingList.lastIndexOf(searchItem);
1092
1093 if (occurance != -1) {
1094 System.out.println("The first occurrence of the search item \"" + searchItem
+ "\" occurs at index " + occurance);
1095 System.out.println("The last occurrence of the search item is at index " +
 last);
1096 } else {
1097 System.out.println("Your search item is not in your shopping list");
1098 }
1099 String grocery = shoppingList.get(2);
1100 System.out.println("The grocery at index 2 is: " + grocery);
1101 }
1102 }
1103
1104
1105 //32. You are maintaining a List<String> for your daily to-do tasks. You want to extract
only the tasks planned
1106 //between 11:00 AM and 2:00 PM, which are stored at positions 3 to 6 (inclusive of 3,
exclusive of 7).
1107
1108 import java.util.ArrayList;
1109 import java.util.List;
1110 class Task {
1111 String name;
1112 int time; /// hour in 24h format (e.g., 7 = 7AM, 12 = Noon)
1113
1114 public Task(String name, int time) {
1115 this.name = name;
1116 this.time = time;
1117 }
1118 @Override
1119 public String toString() {
1120 return name + "(" + time + "h)";
1121 }
1122 }
1123 public class TaskFilterExample {
1124
1125 public List<Task> filteringRange() {
1126
1127 List<Task> dailyTasks = new ArrayList<>();
1128 dailyTasks.add(new Task("Wakeup", 7));
1129 dailyTasks.add(new Task("Walking", 8));
1130 dailyTasks.add(new Task("Bathing", 9));
1131 dailyTasks.add(new Task("Eating", 10));
1132 dailyTasks.add(new Task("Studying", 11));
1133 dailyTasks.add(new Task("Writing", 12));
1134
1135 List<Task> filtered = new ArrayList<>();
1136 for (Task t : dailyTasks) {
1137 if (t.time >= 8 && t.time <= 11) {
1138 filtered.add(t);
1139 }
1140 }
1141 System.out.println("Filtered to do list from 8 to 11 ::: " + filtered);
1142 return filtered;
1143 }
1144 /// Using subList to get tasks between indexes 3 (inclusive) and 6 (exclusive)
1145 public void usingSublist() {
1146 List<String> toDoList = new ArrayList<>();
1147 toDoList.add("Walking"); ///0
1148 toDoList.add("Bathing"); ///1
1149 toDoList.add("Eating"); ///2
1150 toDoList.add("Studying"); ///3
1151 toDoList.add("Sleeping"); ///4
1152 toDoList.add("Writing"); ///5
1153 toDoList.add("Speaking"); ///6
1154 toDoList.add("Chatting"); ///7
1155 toDoList.add("Painting"); ///8
1156
1157 List<String> filteredList = toDoList.subList(3, 6); /// from index 3 to 5
1158 System.out.println("Filtered to do list from index 3 to 5 ::: " + filteredList);
1159 }
1160 public static void main(String[] args) {
1161 TaskFilterExample example = new TaskFilterExample();
1162 example.filteringRange();
1163 example.usingSublist();
1164 }
1165 }
1166
1167
1168 // 33.Backup cart before discount to restore if needed.
1169
1170 import java.util.ArrayList;
1171
1172 public class CartBackupExample {
1173
1174 private void backupCart() {
1175
1176 ArrayList<String> cartList = new ArrayList<String>();
1177 cartList.add("Shampoo");
1178 cartList.add("Soap");
1179 cartList.add("Towel");
1180 cartList.add("Brush");
1181 cartList.add("TennisBall");
1182
1183 System.out.println("The original cartlist is ::: " + cartList);
1184
1185 /// Clone the cartList to create a backup
1186 ArrayList<String> backupCart = (ArrayList<String>) cartList.clone();
1187 System.out.println("Backup cart is ::: " + backupCart);
1188
1189 /// Remove one item from original list
1190 cartList.remove("Brush");
1191 System.out.println("After removing one item from org list is ::: " + cartList);
1192
1193 /// Backup remains unchanged
1194 System.out.println("Backup cart is ::: " + backupCart);
1195 }
1196
1197 public static void main(String[] args) {
1198 CartBackupExample example = new CartBackupExample();
1199 example.backupCart();
1200 }
1201 }
1202
1203
1204 //34. Write a Java program that reads product IDs from a file (or generates them) and
stores them in an ArrayList.
1205 //Use ensureCapacity() to prepare the list for all elements before insertion, so
resizing happens only once.
1206
1207 import java.util.ArrayList;
1208
1209 public class EnsureCapacityExample {
1210
1211 public void usingEnsureCapacity() {
1212 ArrayList<String> productList = new ArrayList<String>();
1213 productList.ensureCapacity(1000); /// Pre-allocate capacity for 1000 elements
1214
1215 for (int i = 1; i <= 100; i++) {
1216 productList.add("Product-" + i);
1217 }
1218 System.out.println(productList);
1219 }
1220
1221 public static void main(String[] args) {
1222 EnsureCapacityExample example = new EnsureCapacityExample();
1223 example.usingEnsureCapacity();
1224 }
1225 }
1226
1227
1228
1229 // 35.showing methods of arraylist used in this file.
1230
1231 import java.util.ArrayList;
1232 import java.util.List;
1233
1234 public class ArrayListMethodsDemo {
1235
1236 public List<String> showMethodsofArrayList() {
1237
1238 List<String> methodsList = new ArrayList<String>();
1239 List<String> methodsList1 = new ArrayList<String>();
1240
1241 System.out.println("ArrayList Specific methods :: ");
1242 methodsList.add("add");
1243 methodsList.add("contains");
1244 methodsList.add("remove");
1245 methodsList.add("get");
1246 methodsList.add("set");
1247 methodsList.add("size");
1248 methodsList.add("sort");
1249 methodsList.add("clear");
1250 methodsList.add("remove");
1251 methodsList.add("isEmpty /isBlank");
1252 methodsList.add("toArray");
1253 methodsList.add("retainAll");
1254 methodsList.add("removeAll");
1255 methodsList.add("addAll");
1256 methodsList.add("subList");
1257 methodsList.add("indexOf");
1258 methodsList.add("lastIndexOf");
1259 methodsList.add("clone");
1260
1261 for (String method : methodsList) {
1262 System.out.println(method);
1263 }
1264
1265 System.out.println("\nString specific methods used in list elements :::");
1266 methodsList1.add("toString");
1267 methodsList1.add("charAt");
1268 methodsList1.add("startsWith");
1269 methodsList1.add("endsWith");
1270 methodsList1.add("equals");
1271 methodsList1.add("equalsIgnoreCase");
1272 methodsList1.add("trim");
1273
1274 for (String method : methodsList1) {
1275 System.out.println(method);
1276 }
1277
1278 return methodsList;
1279 }
1280
1281 public static void main(String[] args) {
1282 ArrayListMethodsDemo demo = new ArrayListMethodsDemo();
1283 demo.showMethodsofArrayList();
1284 }
1285 }
1286
1287
1288 //Prepared By - Sumathi R // https://www.linkedin.com/in/sumathi1989/
1289