Binghamton University. CS-140 Fall Chapter 7.7. Lists. Java Library Data Structures

Transcription

1 Chapter 7.7 Lists Java Library Data Structures 1

2 Java Library Data Structures A data structure is a way of organizing data The Java Library supports many different data structures Let s start with one of the simpler ones a collection of data 2

3 Collection A collection of data is a group of data items of the same type Collection can ONLY be references not primitives (autoboxing) There are several things you can do to collections: Create a collection (empty, or initialized) Check to see if data item(s) are is in the collection (contains) Check to see if the same data items are in a different collection (equals) Check to see if the collection is empty (isempty) Convert the data items to an array add an item(s) to the collection (add) remove item(s) from the collection (remove, clear) 3

4 Collection Implementations There is no Collection class in the Java library Many classes implement the concept of Collection ArrayList, PriorityQue, CopyOnWriteArrayList, HashSet, Two different flavors of collections: Collections without duplicates (sets) Collections with order (lists) 4

5 Lists Lists are just collections with order (sequence) So lists can be indexed Duplicates are allowed Lists support all Collection methods plus: add/remove allows index argument get(index), set(index,element) indexof() No List Class, but several classes implement List concept Static methods such as List.of(1,2,3) creates an immutable list in some class that supports all the list methods (of Integers) 5

6 Java Coding Practice Declare as general as possible Instantiate using a specific implementation (class) List<Integer> nums = new ArrayList<Integer>(); General Implementation 6

7 ArrayLists One implementation of a List Is it an array, or is it a list? 7

8 Problem with Arrays Arrays are great if you know how big they need to be when you write the code, but we don t always know how big it needs to be One alternative Start out with medium sized array If it needs to grow bigger, create a bigger array, copy the medium to the bigger array repeat as necessary If it grows smaller, create a smaller array, copy the medium to the smaller array repeat as necessary Lots of array copying and wasted space Another alternative: Java ArrayList class its here! 8

9 Arrays vs. ArrayLists Similarities Indexed list of data elements of a specific type Allow you to determine the number of elements Allow you to read (get) or write (set) individual elements Both have a size number of elements currently available Differences Arrays are built-in, ArrayLists are objects in the library Arrays elements: array[i], ArrayLists elements: list.get(i) or list.set(i). Array size is in array.length; list size is in list.size() You can changes the size of an ArrayList Arrays may be arrays of either primitive types or reference types, ArrayLists can ONLY be lists of reference types! 9

10 Contrarian Argument An array OBJECT is a fixed size, but a REFERENCE to an array object may be changed to reference a different sized array int[] nums={1,2,3,4}; // nums-> array of size 4 nums = new int[5]; // nums ->array of size 5 nums int[] length

11 Contrarian Argument An array OBJECT is a fixed size, but a REFERENCE to an array object may be changed to reference a different sized array int[] nums={1,2,3,4}; // nums-> array of size 4 nums = new int[5]; // nums ->array of size 5 nums int[] length int[] length

12 Note on Garbage Collection Periodically, Java Garbage Collection throws away any unreferenced objects nums int[] length int[] length

13 ArrayList Example List<> grades = new ArrayList<>(); grades.add(17.5); // index 0 grades.add(15.5); // index 1 grades.add(12.75); // index 2 grades.add(19.25); // index 3 grades.add(13.5); // index 4 grades.add(11.25); // index 5 grades.add(17.0); // index 6 System.out.println(grades); prints: [17.5, 15.5, 12.75, 19.25, 13.5, 11.25, 17.0] 13

14 Instantiating Lists List<Integer> numlist = new ArrayList<Integer>(); List<String> wordlist = new ArrayList<String>(); List<BankAccount> alist = new ArrayList<BankAccount>(); List<> grades = new ArrayList<>(); 14

15 Inserting Elements into Lists For Arrays, we used assignment: gds[5]=25.0; For Lists grades.set(5,25.0); grades.add(25.0); grades.add(5,25.0); Replaces the value of the 6 th element with 25.0 Works only if there is already a 6 th element of grades Increases the size of grades by 1, and puts 25.0 at the end Move indexes past 5 down 1 then put 25.0 at index 5 15

16 Reading Data from an ArrayList For arrays, use the index: double d = grds[5]; For ArrayLists, use the get method: double d = grades.get(5); If grades does not have at least 6 elements (0,1,2,3,4,5), throws IndexOutOfBoundsExeption You can write: if (grades.size()>5) { d = grades.get(5); } else 16

17 ArrayList Example ArrayList<> grades = new ArrayList<>(); grades.add(17.5); // index 0 grades.add(15.5); // index 1 grades.add(12.75); // index 2 grades.add(19.25); // index 3 grades.add(13.5); // index 4 grades.add(11.25); // index 5 grades.add(17.0); // index 6 System.out.println(grades); prints [17.5, 15.5, 12.75, 19.25, 13.5, 11.25, 17.0] Java autoboxes this grades.add(new (17.5)); 17

18 Autoboxing is Picky [ ] dbs = {1, 2, 3, 4}; // is illegal The compiler says it cannot convert from int to [ ] dbs = {1.0, 2.0, 3.0, 4.0}; // legal The compiler can autobox double value constants into references to. 18

19 Add method inserts System.out.println(grades); [17.5, 15.5, 12.75, 19.25, 13.5, 11.25, 17.0] grades.add(3, 16.5); System.out.println(grades); [17.5, 15.5, 12.75, 16.5,19.25, 13.5, 11.25, 17.0] 19

20 ArrayList Internals grades Backing Store ArrayList<> size 7 elementdata [] length value 17.5 value 15.5 value value value 13.5 value value 17.0

21 ArrayList Internals grades ArrayList size 8 elementdata value 16.5 [] length value 17.5 value 15.5 value value value 13.5 value value 17.0

22 ArrayList Internals When backing store array gets full, create a new array that is 1.5 times larger It is possible to tweak the growth factor, but no-one bothers Efficient because we copy/move references not the actual data! 22

23 Reading a File Java Library File class reference to a file Create using the file name Usually, assume that file is in the current directory May specify a fully qualified path May specify relative to current directory Current directory is the directory in which the java command was invoked Java Library Scanner class read a file Create using a File object May throw FileNotFoundException Reads file AND performs type conversion if needed (from ASCII to?) 23

24 Read Lines into an ArrayList List<String> text = new ArrayList<>( ); Scanner inputfile = new Scanner(new File("test.txt")); while (inputfile.hasnextline( )) { text.add(inputfile.nextline( )); } inputfile.close(); System.out.println( Read + text.size() + lines ); 24

25 Notes on List of lines This way we do not care much how many lines there are The size of an List is the number of elements stored in the list. (The implementation often has more capacity, but not too much more) When you use the List text, do not forget to check if there are any lines in the list. If the size was 0 and you did not check, you could easily get an error in later code 25

26 Converting ArrayList to Array We can write String[ ] lines = new String[text.size( )]; for(int i = 0; i < text.size( ); i++) { lines[ i ] = text.get( i ); } another way is String[ ] lines = new String[text.size( )]; text.toarray(lines); Simpler yet String[ ] lines = { }; lines = text.toarray(lines); 26

27 Turning Arrays into ArrayLists String[ ] arr = { "abc", "acd", }; List<String> list = new ArrayList<>(); Write your own loop: for(string str : arr) { list.add(str); } Use addall : list.addall(arrays.aslist(arr)); Use ArrayList constructor List<String> list = new ArrayList<>(Arrays.asList(arr)); You can find these tricks on the internet (Google, Sourceforge, ) 27

28 Lists must be lists of References You can write: int[ ] arr = {1, 2, 3}; But you cannot write List<Integer> list = new ArrayList<>(Arrays.asList(arr)); Because arr is an array of primitives not references You must use a wrapper class, and depend on AutoBoxing: Integer[ ] arr = {1, 2, 3}; // autoboxing List<Integer> list = new ArrayList<>(Arrays.asList(arr)); 28