Question

Please code this in java:

The purpose of this assignment is to:

• Read double data in to a TreeSet where each datum inserted is Math.abs(datum) (i.e., no negative values are inserted).
  • NOTE: This will (i) sort the data placed into the TreeSet, and, (ii) remove duplicate values since no duplicates are allowed (i.e., duplicates will not be inserted).
• Create a list iterator.
• Iterate backwards through the TreeSet (i.e., from the largest value to the smallest) outputting all elements * -1.0.
• Iterator forwards through the TreeSet (i.e., from the smallest value to the largest) outputting all element.

This assignment must be a public class called A5 in the package called comp2120. You will only need this class with a main() method to do this assignment. To help you do the assignment, the code in main() must be as follows:

• Remember to declare this class in the comp2120 package at the top of the file.
  • This will require you to place this class in a comp2120 subdirectory.
• Scanner, TreeSet, etc. are all in java.util. You can save yourself some typing by having import java.util.*;
• Declare a TreeSet variable called sorted_set. Initialize it to an empty TreeSet.
• Declare a Scanner variable that processes System.in (i.e., standard input).
• Using a (for or while) loop, add the absolute value of all double values found in the System.in stream:
  • TIP: You want sorted_set.add(Math.abs(in.nextDouble());
• Declare an ArrayList variable called sorted_seq. Initialize it to an ArrayList passing in sorted_set to its constructor.
  • NOTE 1: One cannot get a list iterator from a TreeSet as it is not an AbstractList. This is why an ArrrayList is being made --it provides a list iterator.
  • NOTE 2: Notice that all of the containers have a constructor that accepts any other container object. These constructors create an iterator from the object passed in and automatically insert each element into the container being constructed.
• Declare a ListIterator variable called li and set its value to be sorted_seq.listIterator(sorted_seq.size());
  • NOTE 3: To get an iterator at the "starting position" of a container one calls the iterator() method of that container. Such iterators can only go "forwards" by calling the "next()" method, however. In this example, you want to start a the end --not the beginning-- which means you want to be able to go backwards too. List iterators permit such.
  • NOTE 4: To get a list iterator at the "starting position" of a container one calls the listIterator() method of that container. If one passes an "index" (i.e., position) to the listIterator() method then one gets an iterator pointing to that position. In the above code, by passing sorted_seq.size() the iterator returned is positioned at the "end" of the container. This implies that hasNext() will return false. This is okay since you'll be using hasPrevious() and previous() instead of hasNext() and next() below.
• Create a while loop as follows:
  • while loop test: li.hasPrevious()
  • while loop body: Call System.out.println() with the result of li.previous * -1.0.
  • i.e., you are moving "backwards" through the container from the largest to the smallest value.
• Create another while loop as follows:
  • NOTE: Do NOT create another iterator! You already have one at the position you need! :-)
  • while loop test: lt.hasNext()
  • while loop body: Call System..out.println() with the result of li.next().
  • i.e., you are moving "forwards" through the container from the smallest to the largest value

Sample Completed Program Output

Given the following input data:

$ cat testdata.txt
1.1 2.2 -1.5 3.3 2.2 1.1 4.4
$

Then the completed program would output:

$ java comp2120.A5 <testdata.in
-4.4
-3.3
-2.2
-1.5
-1.1
1.1
1.5
2.2
3.3
4.4
$ 

NOTE: Your code must handle all input without exceptions occurring. This includes when no double values are provided. Use java.util.Scanner's hasNextDouble() method to do this!

Answer 1

Here is the completed code for this problem. Comments are included, go through it, learn how things work and let me know if you have any doubts or if you need anything to change. If you are satisfied with the solution, please rate the answer. Thanks

// A5.java

import java.util.ArrayList;

import java.util.ListIterator;

import java.util.Scanner;

import java.util.TreeSet;

public class A5 {

      public static void main(String[] args) {

            // creating a TreeSet of doubles

            TreeSet<Double> sorted_set = new TreeSet<Double>();

            // creating a Scanner

            Scanner scanner = new Scanner(System.in);

            // looping and adding all double values until there is no more

            // if you are using manual input, enter ctrl+Z or ctrl+D to trigger eof

            while (scanner.hasNextDouble()) {

                  // note: adding the absolute value (no sign)

                  sorted_set.add(Math.abs(scanner.nextDouble()));

            }

            // creating an array list from sorted_set

            ArrayList<Double> sorted_seq = new ArrayList<Double>(sorted_set);

            // creating a list iterator from the rear position

            ListIterator<Double> iterator = sorted_seq.listIterator(sorted_seq

                        .size());

            // looping and printing each element multiplied by -1.0 from rear to

            // front

            while (iterator.hasPrevious()) {

                  System.out.println(iterator.previous() * -1.0);

            }

            // looping and printing each element from front to rear

            while (iterator.hasNext()) {

                  System.out.println(iterator.next());

            }

      }

}

/*OUTPUT*/

1.1 2.2 -1.5 3.3 2.2 1.1 4.4

<eof triggered by ctrl+Z>

-4.4

-3.3

-2.2

-1.5

-1.1

1.1

1.5

2.2

3.3

4.4