-
Notifications
You must be signed in to change notification settings - Fork 0
/
Collection Running Notes.txt
875 lines (628 loc) · 24.4 KB
/
Collection Running Notes.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
Day #1: Date: 03.01.2023
=========================
Collection Framework:
=====================
int x=10;
int y=20;
int z=30;
int []x=new int[100];
Array: It is an indexed collection of fixed number of homogeneous elements.
Advantage of Array:
====================
The main advatage of array is we can represent multiple values by using single variable,
so readability of the code will be improved.
Ex:int[] x =new int[10];
Limiations of Array:
====================
1. Arrays are of fixed in size i.e. depending on requirement we can't increse or decrese the sze.
Hence arrays are not recommended to use because it is not always possible to know the size of the array from the beginning.
2. Array can hold homogeneous type of elements.
Student[]s=new Student[120];
s[0]=new Student();
s[1]=new Student();
s[2]=new Employee(); //CE
Object[] obj=new Object[120];
obj[0]=new Student();
obj[1]=new Employee();
obj[2]=new Customer();
3. Arrays dont have any underlying data structure.For any requirement being a programmer we have to write the code exlicitly.We will not get any inbuilt method support.
Collection Framework:
=====================
1. Collection is growable in nature.
2. Collection can hold homogeneous and heterogeneous elements.
3. For every collection interface implemented class we have underlying data structure and hence ready-made support is avialable.Being a programmer we are responsible to use those methods and we are not responsible to implement those methods.
Q#1. What are the differences between Array and Colelction?
Ans.
1. Arrays are fixed in size.
Colelctions are growable in nature.
2. With respect memory point of view Collection is recommended to use.
With respect memory point of view Array is not recommended to use.
3. With respect to performance Array is recommended to use.
With respect to performance Colelction is not recommended to use.
4. Array can hold only homogeneous type of elements.
Collection can hold both homogeneous and heterogeneous type of elemnts.
5. For array there is no underlying data structure is avialble.Hence for every requirement we have to write the code explicitly.
For every collection class underlying data structire is available hence ready made method support is available.
6. Array can hold both primitive and objects.
Collection can hold only object types but not primitives.
int[] i=new int[10];
String[] s=new String[5];
Collection(I):
-> It is a predefined interface and present in java.uitl package.
Q>When should we go for Collection ?
Ans.
If we want to represent a group of individual object as a single entity then we should go for Colelction concept.
9 key interface of Collection Framework:
----------------------------------------
1. Collection
2. List
3. Set
4. SortedSet
5. NavigableSet
6. Queue
7. Map
8. SortedMap
9. NavigableMap
1. Collection(I):
-------------------
=> If we want to represent a group of individual object as a single entity
then we should go for Collection concept.
=> In general it is considered as the root interface of Collection Framework.
=> It contains the most common methods which are applicable for any collection object [Collection interface implemented class object]
=> It does not have any direct implementation class.
Q#2. What is the difference between Collection and Collections.
Ans.
Collection is an interface.
Collections is a class.
If we want to represent a group of individual object as a single entity
then we should go for Collection concept.
Collctions is an utily class present in java.util package whcih consists of several utility methods which are applicable for Collection interface implemented class object.
2. List (I):
----------
-> It is the child interface of Collection.
-> If we want to represent a group of individual objects as a single entity where duplicates are allowed and insertion order is preserved, then we should go for List concpet.
Ex:
package com.wipro.test;
import java.util.ArrayList;
public class Test {
public static void main(String[] args) {
ArrayList<String>al=new ArrayList<>();
al.add("CSE3");
al.add("ECE3");
al.add("CSE3");
System.out.println(al);
}
}
Day #2: Date: 10.01.2023
=========================
3. Set :
---------
-> It is the child interface of Collection.
-> If we want to represent a group of individual objects as a single entity where duplicates are not allowed and insertion order is not preserved, then we should go for Set concpet.
package com.wipro.test;
import java.util.HashSet;
public class Test {
public static void main(String[] args) {
HashSet<String>hs=new HashSet<>();
hs.add("AAA");
hs.add("BBB");
hs.add("CCC");
System.out.println(hs);
}
}
4.SortedSet(I):
---------------
-> It is a child interface of Set interface.
-> If we want to represent a group of individual objects as a single entity where
duplicates are not allowed and and all objects should be inserted according to some sorting order then we should go for SortedSet interface.
5.NavigableSet(I):
------------------
-> It is the child interface of SortedSet interface.
-> It contains the methods for navigation purpose.
6.Queue(I):
---------
-> It is child interface of Collection.
-> If we want to represent a group of individual objects prior to processing as a single entity then we should go for Queue.
-> Usually queue follows First-In-First-Out.But based on our requirement we can implement our own priority order also.
Example:Before sending a mail all maid id's we have to store in some data structure.In which order we added mail id's in the same order mail will be delivered.
For this requirement Queue is the best choice.
7.Map(I):
----------
-> It is not the child interface if collection.
-> If we want to represent a group of individual objects as a key-value pair then we should go for Map Interace.
-> Key is unique but value can be duplicated.
-> Key and value must be objects.
Strudent Roll No(Key) Student Name(Value)
----------------- -------------------
111 AAA
222 BBB
333 CCC
8.SortedMap(I):
--------------
-> It is the child interface of Map.
-> If we want to represent a group of key-value pair according to some sorting order of keys then we should go for SortedMap.
-> In SortedMap sorting should be based key but not based on value.
9.NavigableMap(I):
------------------
-> It is the child interface of SortedMap.
-> It contains the methods for navigation purpose.
The important methods of Collection interface:
---------------------------------------------
1. boolean add(Object obj):
---------------------------
->This method appends the specified element to the end of the Collection.
-> If the specified element added succesfully then add(-) method will return "true" value.
-> If the specified element is not added successfully then add(-)method will return "false" value.
package com.wipro.test;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class Test {
public static void main(String[] args) {
List<String> al=new ArrayList<>();
al.add("AAA");
System.out.println(al.add("AAA"));
Set<String>hs =new HashSet<>();
hs.add("AAA");
System.out.println(hs.add("AAA"));
}
}
2. boolean addAll(Collection c):
--------------------------------
-> This method can be used to add all the elements of the specified Collection to this Collection.
->If addition opertaion is success then addAll(-) method will return "true" value.
->If addition operaton is failure then addAll(-)method will return "false" value.
package com.wipro.test;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class Test {
public static void main(String[] args) {
List<String> al=new ArrayList<>();
al.add("AAA");
al.add("BBB");
al.add("CCC");
System.out.println("ArrayList :"+al);
Set<String>hs =new HashSet<>();
hs.add("DDD");
hs.add("EEE");
hs.add("FFF");
System.out.println("HashSet:"+hs);
al.addAll(hs);
System.out.println("Final ArrayList:"+al);
}
}
In the above example specified collection is HashSet and this Collection is ArrayList.
3. boolean remove(Object) :
---------------------------
--> It is used to simply remove objects from Collection.
--> If there are multiple such objects , the the first occurance of the object will be removed.
-->If remove operation is success then remove() method will return true value.
-->If remove operaton is failure then remove() method will return false value.
package com.wipro.test;
import java.util.ArrayList;
import java.util.List;
public class Test {
public static void main(String[] args) {
List<String> al=new ArrayList<>();
al.add("AAA");al.add("BBB");al.add("CCC");al.add("DDD");
System.out.println("Before Removal :"+al);
System.out.println(al.remove("BBB"));
System.out.println("After Removal :"+al);
System.out.println(al.remove("XXX"));
}
}
4. boolean removeAll(Collection c) :
------------------------------------
--> The removeAll() method is used to remove from the list all of its elements that are contained in the specified collection.
-->If remove operation is success then removeAll() method will return true value.
-->If remove operaton is failure then removeAll() method will return false value.
package com.wipro.test;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class Test {
public static void main(String[] args) {
List<String> al=new ArrayList<>();
al.add("AAA");
al.add("BBB");
al.add("CCC");
System.out.println("Before Removal :"+al);
Set<String>hs=new HashSet<>();
hs.add("AAA");
hs.add("BBB");
al.removeAll(hs);
System.out.println("After Removal :"+al);
}
}
In the above example specified collection is HashSet and this Collection is ArrayList.
Absent List:
============
CSE#3:
------
130,133,136,137,140,141,142,147,148,150,151,156,159,160,164,167,168,171,172,173,174,
176,181,183,184,186,187,188,189.
L-199,204
ECE #3:
-------
131,132,133,134,138,139,140,141,146,147,149,150,152,155,156,157,158,159,161,162,
164,167,168,172,173,174,177,178,180,181,182
L-205,207,
Day #3: Date: 14.01.2023
=========================
5. boolean contains(Object obj)
-------------------------------
-->This method is used for checking if the specified element exists in the given ArrayList or not.
-->If the specified element is existed then this method will return "true" value.
-->If the specified element is not existed then this method will return "false" value.
package com.wipro.test;
import java.util.ArrayList;
class Test{
public static void main(String[] args){
ArrayList<Integer> al=new ArrayList<>();
al.add(10);al.add(20);al.add(30);al.add(40);
System.out.println(al.contains(30));
System.out.println(al.contains(50));
}
}
6. booelan containsAll(Collection c)
------------------------------------
--> This method will check whether all the elements of the specified Colllection are avaialable or not.
-->If all the specified element is existed then this method will return "true" value.
-->If atleast one element is not existed then this method will return "false" value.
package com.wipro.test;
import java.util.ArrayList;
class Test{
public static void main(String[] args){
ArrayList<String> al=new ArrayList<>();
al.add("AAA");al.add("BBB");al.add("CCC");al.add("DDD");al.add("EEE");al.add("FFF");
ArrayList<String> all=new ArrayList<>();
all.add("BBB");all.add("CCC");all.add("DDD");
// ArrayList al contains all the elements of all
System.out.println(al.containsAll(all));
all.add("XXX");
all.add("YYY");
System.out.println(al.containsAll(all));
}
}
7. boolean retainAll(Collection c)
----------------------------------
--> This method remove all the elements from the present Collection object except the elements which are existed in the specified Collection.
--> If at least one element is removed then retainAll() method will return true value.
--> If no element are removed then it will return false value.
package com.wipro.test;
import java.util.ArrayList;
class Test{
public static void main(String[] args){
ArrayList<String> al=new ArrayList<>();
al.add("AAA");al.add("BBB");al.add("CCC");al.add("DDD");al.add("EEE");al.add("FFF");
ArrayList<String> all=new ArrayList<>();
all.add("BBB");all.add("CCC");all.add("DDD");
System.out.println(al);
System.out.println(al.retainAll(all));
System.out.println(al);
//al : [BBB,CCC,DDD] all: [BBB,CCC,DDD]
System.out.println(al.retainAll(all));
}
}
8. int size()
-------------
-> This method can be used return an integer value representing th eno of element existed in any Collection interface implemented class object.
package com.wipro.test;
import java.util.ArrayList;
class Test{
public static void main(String[] args){
ArrayList<String> al=new ArrayList<>();
System.out.println("Size ?"+al.size());
al.add("AAA");al.add("BBB");al.add("CCC");al.add("DDD");al.add("EEE");al.add("FFF");
System.out.println("Size ?"+al.size());
}
}
9. boolean isEmpty():
---------------------
--> This method can be used to check whether Collection interface implemented class object is empty or not.
If the Collection interface implemented class object is empty then isEmpty() method will return "true" value.
If the Collection interface implemented class object is not empty then isEmpty() method will return "false" value.
package com.wipro.test;
import java.util.ArrayList;
class Test{
public static void main(String[] args){
ArrayList<String> al=new ArrayList<>();
System.out.println("Is Empty ?"+al.isEmpty());
al.add("AAA");al.add("BBB");al.add("CCC");al.add("DDD");al.add("EEE");al.add("FFF");
System.out.println("Is Empty ?"+al.isEmpty());
}
}
10. void clear():
------------------
->This method can be used to remove all the elements from Collection interface implemented class object.
package com.wipro.test;
import java.util.ArrayList;
class Test{
public static void main(String[] args){
ArrayList<String> al=new ArrayList<>();
al.add("AAA");al.add("BBB");al.add("CCC");al.add("DDD");al.add("EEE");al.add("FFF");
System.out.println("Size Before Clear:"+al.size());
al.clear();
System.out.println("Size After Clear:"+al.size());
}
}
for-each loop(Enhanced for loop):
---------------------------------
1. It is introduced in Java 1.5 Version.
2. It is applicable only for Arrays and Collection.
3. It can move only if forward direction.
Ex:
--
package com.wipro.test;
import java.util.ArrayList;
class Test{
public static void main(String[] args){
ArrayList<String> al=new ArrayList<>();
al.add("AAA");al.add("BBB");al.add("CCC");al.add("DDD");al.add("EEE");al.add("FFF");
System.out.println(al);
for(String str:al) // for each String str present in al
System.out.print(str+" ");
}
}
11. Object[] toArray():
-----------------------
-> This method will return all the elements of the Collection interafce implemented class object in the form of Object[].
package com.wipro.test;
import java.util.ArrayList;
class Test{
public static void main(String[] args){
ArrayList<String> al=new ArrayList<>();
al.add("AAA");al.add("BBB");al.add("CCC");al.add("DDD");al.add("EEE");al.add("FFF");
System.out.println(al);
Object []obj =al.toArray();
for(Object o: obj)
System.out.println(o);
}
}
Loose coupling:
---------------
1. Super class reference variable can be used to hold sub class object.
2. Abstract class reference variable can be used to hold child class object.
3. Interface reference variable can be used to hold implemented class object.
*****
Int Q #1: What are the differences between String Vs. StringBuffer
-----------------------------------------------------------------
Ans.
Creation :
----------
1. String can be created in two different ways.
Approach #1 : With using new keyword: String s =new String("CSE#3ECE#3");
Approach #2 : Without using new keyword i.e. by using String literal String s="CSE#3ECE#3";
StringBuffer can be created only by uisng new keyword.
StringBuffer sb=new StringBuffer();
Modification:
-------------
2. String object is immutable(non-modifiable/non editable)
i.e once we create a string object and try to perform modification onString object we can't perform any modification.
With the modification a new object will be created.
package com.wipro.test;
public class Test {
public static void main(String[] args) {
String s=new String("CSE#3");
System.out.println(s);
s.concat("ECE#3");
System.out.println(s);
}
}
O.P:CSE#3
CSE#3
StringBuffer is mutable.
package com.wipro.test;
public class Test {
public static void main(String[] args) {
StringBuffer sb=new StringBuffer("CSE#3");
System.out.println(sb);
sb.append("ECE#3");
System.out.println(sb);
}
}
O.P:
CSE#3
CSE#3ECE#3
3. Memory
---------
String consumes more memory during concatenation.
Stringbuffer consumes less memory during concatenantion.
4. Performance
--------------
String is slower during concatenation.
StringBuffer is faster during concatenation.
equals() method
5. Object class equals method is meant for reference comparison.
Inside String class it is overridden for content comparison.
It means if two objects are having same content then it returns true value.
Inside StringBuffer class equals() method is not overridden,hence Object class equals() method will be excuted, which is meant for reference comparison.
It means if two objects are having different reference though the content are same it will return false value.
package com.wipro.test;
class Test{
public static void main (String[] args){
String str1=new String("CSE#3ECE#3");
String str2=new String("CSE#3ECE#3");
System.out.println(str1.equals(str2)); // true
StringBuffer sb1=new StringBuffer("CSE#3ECE#3");
StringBuffer sb2=new StringBuffer("CSE#3ECE#3");
System.out.println(sb1.equals(sb2)); //false
}
}
Day #4: Date: 17.01.2023
=========================
List Interface:
---------------
-> It is the child interface of Collection.
-> If we want to represent a group of individual objects as a single entity where duplicates are allowed and insertion order is preserved, then we should go for List concpet.
-> In case of List interafce index plays a very important role.
List Interface Methods:
------------------------
1.void add(int index, Object obj)
2.boolean addAll(int index, Collection c)
3.Object remove(int index)
4.Object get(index)
5.Object set(int index, Object obj)
6.int indexOf(Object obj)
7.int lastIndexOf(Object obj)
1.void add(int index, Object obj):
--------------------------------
->This method inserts the specified element at the specified position.
->It shifts the element currently at that position(if any) and any subsequent elements to the right.(will add one to their indices).
package com.wipro.test;
import java.util.ArrayList;
import java.util.List;
class Test{
public static void main (String[] args){
List<Integer>list=new ArrayList<>();
list.add(10);
list.add(20);
list.add(30);
list.add(40);
// 0 1 2 3
System.out.println("ArrayList :"+list); // 10 20 30 40
list.add(2, 35);
System.out.println("ArrrayList:"+list); // 10 20 35 30 40
}
}
2. boolean addAll(int index, Collection c)
------------------------------------------
-->This method inserts all the elements of the specified collection to the present Collection at the specified starting index.It shifts the element currently at that position and any subsequent element to the right.
package com.wipro.test;
import java.util.ArrayList;
import java.util.List;
class Test{
public static void main (String[] args){
List<Integer>list1=new ArrayList<>();
list1.add(10);
list1.add(20);
list1.add(30);
list1.add(40);
// 0 1 2 3
System.out.println("First ArrayList :"); // 10 20 30 40
for(Integer I: list1)
System.out.println(I);
List<Integer>list2=new ArrayList<>();
list2.add(100);
list2.add(200);
list2.add(300);
list2.add(400);
System.out.println("Second ArrayList :");
for(Integer I: list2)
System.out.println(I);
list1.addAll(2, list2); // [10,20, 100,200,300,400,30,40]
System.out.println("First ArrayList :"); // 10 20 30 40
for(Integer I: list1)
System.out.println(I);
}
}
3. Object remove(int index)
---------------------------
->It removes the element presennt at the specific index.
-->After removing the element all the elements are moved to left to fill the space i.e the indices of the objects are updated.
package com.wipro.test;
import java.util.ArrayList;
import java.util.List;
class Test{
public static void main (String[] args){
List<String> list=new ArrayList<>();
list.add("AAA");
list.add("BBB");
list.add("CCC");
list.add("DDD");
System.out.println("Before Removal:"+list);
list.remove(2);
System.out.println("After Removal:"+list);
}
}
4. Object get(index):
---------------------
-> This method will return an element at the specified index value.
package com.wipro.test;
import java.util.ArrayList;
import java.util.List;
class Test{
public static void main (String[] args){
List<String> list=new ArrayList<>();
list.add("AAA");
list.add("BBB");
list.add("CCC");
list.add("DDD");
System.out.println(list);
System.out.println(list.get(2));
System.out.println(list);
}
}
5. Object set(int index, Object obj)
------------------------------------
--> This method is used to replace/set the element at the specified index in the Collection with the specified element.
package com.wipro.test;
import java.util.ArrayList;
import java.util.List;
class Test{
public static void main (String[] args){
List<String> list=new ArrayList<>();
list.add("AAA");
list.add("BBB");
list.add("CCC");
list.add("DDD");
System.out.println(list);
System.out.println(list.set(2, "EEE"));
System.out.println(list);
}
}
6. int indexOf(Object obj)
--------------------------
--> This method will return index value of the first occuarance of the specified element.
package com.wipro.test;
import java.util.ArrayList;
import java.util.List;
class Test{
public static void main (String[] args){
List<String> list=new ArrayList<>();
list.add("AAA");
list.add("BBB");
list.add("AAA");
list.add("AAA");
System.out.println(list.indexOf("AAA"));
}
}
7. int lastIndexOf(Object obj)
-------------------------------
-> This method will return index value of the last occurance of the specified element.
package com.wipro.test;
import java.util.ArrayList;
import java.util.List;
class Test{
public static void main (String[] args){
List<String> list=new ArrayList<>();
list.add("AAA");
list.add("BBB");
list.add("AAA");
list.add("AAA");
System.out.println(list.lastIndexOf("AAA"));
}
}
*****
Singleton class
---------------
*****
Factory methods:
---------------
Object Type Casting:
--------------------
Syntax:
A b =(C) d;
A : Class Name or Interface Name
b : Name of reference variable.
C : Class Name or Interface Name
d : Name of the object
Rule #1(Compiler):
Rule #2(Compiler):
Rule #3(JVM):
Generics:
11.