Can you write javadoc for the following: import java.util.*; /** * Write a descr

Question

Can you write javadoc for the following:

import java.util.*;
/**
* Write a description of class ArrayFunctions here.
*
* @author  
* @version
*/
class ArrayFunctions implements ArrayFunctionsInterface{
// create array
public double [] sortMe(double [] array){
double [] newArray = new double[array.length];

for(int i = 0; i < array.length - 1; i++){
int index = i;

for(int j = i + 1; j < array.length; j ++){
if (array[j] < array[index])
index = j;
double smallNumber = array[index];
array[index] = array[i];
array[i] = smallNumber;
}
return array;
}
}
  
public double getMax(double [] array){
sortMe(array);
return array[array.length - 1];
}

public double getMin(double [] array){
sortMe(array);
return array[0];
}

public int whereAmI(double [] array, double searchValue){
int index = 0;
for (int i = 0; i < array.length; i++){
if(array[i] == searchValue){
index = i;
}
}
return index;
}

public double sumMeUp(double [] array){
double sum = 0;
for(int i = 0; i < array.length; i++){
sum += array[i];
}
return sum;
}

public double[] reverseMe(double [] array){
for(int i = 0; i < array.length/2; i ++){
double temp = array[i];
array[i] = array[array.length - i - 1];
array[array.length - i - 1] = temp;
}
return array;
}

public void printMe(double [] array){
for(int i = 0; i < array.length; i++){
System.out.println(array[i] + " ");
}
}
public double[] doubleMyCapactiy(double[] array){
double [] newArray = new double[array.length * 2];
for(int i = 0; i < array.length; i++){
newArray[i] = array[i];
}
return newArray;
}
}

-------------------------------------

public interface ArrayFunctionsInterface{
double [ ] sortMe(double [ ] array);
double getMax(double [ ] array);
double getMin(double [ ] array);
int whereAmI(double [ ] array, double searchValue);
double sumMeUp(double [ ] array);
double [ ] reverseMe(double [ ] array);
void printMe(double [ ] array);
double[ ] doubleMyCapacity(double [ ] array);
}

-------------------------------------

public interface ArrayFunctionsInterface<T extends Comparable<T>> {
T[] sortMe(T[] array);

T getMax(T[] array);

T getMin(T[] array);

int whereAmI(T[] array, T searchValue);

T[] reverseMe(T[] array);

void printMe(T[] array);

T[] doubleMyCapacity(T[] array);
}

------------------------------------

class ArrayFunctionsImpl<T extends Comparable<T>> implements ArrayFunctionsInterface<T> {

public T[] sortMe(T[] array) {
for (int i = 0; i < array.length; i++) {
for (int j = i; j < array.length; j++) {
if (array[i].compareTo(array[j]) < 0) {
T a = array[i];
array[i] = array[j];
array[j] = a;
}
}
}
return array;
}

public T getMax(T[] array) {
if (array == null || array.length == 0) {
return null;
}

T max = array[0];
for (int i = 0; i < array.length; i++) {
if (array[i].compareTo(max) > 0)
max = array[i];
}
return max;
}

public T getMin(T[] array) {
if (array == null || array.length == 0) {
return null;
}

T min = array[0];
for (int i = 0; i < array.length; i++) {
if (array[i].compareTo(min) < 0)
min = array[i];
}
return min;
}

public int whereAmI(T[] array, T searchValue) {
for (int i = 0; i < array.length; i++) {
if (array[i].equals(searchValue)) {
return i;
}
}
return -1;
}

public T[] reverseMe(T[] original) {
T doubleArray[] = (T[]) new Object[original.length];
for (int i = 0; i < original.length; i++) {
doubleArray[original.length - i - 1] = original[i];
}
return doubleArray;
}

public void printMe(T[] array) {
for (T x : array) {
System.out.println(x);
}
System.out.println();
}
  
public T[] doubleMyCapacity(T[] array) {
T doubleArray[] = (T[]) new Object[2 * array.length];
for (int i = 0; i < doubleArray.length; i++) {
if (i < array.length)
doubleArray[i] = array[i];
else
doubleArray[i] = null;
}
return doubleArray;
}

}

Explanation / Answer

/*

* import @ArrayFunctions

*Use {@link sortMe(double [] array)

* @param double [] array [Array to be sorted]

* @Sorting Technique: Bubble sort

* @return double[] (Array)

* Use {@link getMin(double[] array)

*@param array[] (Array in which to fing min)

@since sortMe()

@return array[0] (i.e Min element will be at the 0th index)

* Use {@link getMax(double[] array)

*@param array[] (Array in which to fing max)

*@since sortMe()

*@return array[0] (i.e Max element will be at the 0th index)

*   Use {@link whereamI(double[] array,double searchValue)

* @param array[]

@param searchValue i.e To search element in the array

* @param index

@return int (Index where element found)

*Use {@link sumMeUp(double[] array)

* @param array [Array to be calculated)

* @return dounble (sum)

* Use {@link reverseMe(double[] array)

*@param array

*@return double [Array]

* Use {@link printMe(double[] array)

*@param array

*Just Prints Values in STDOUT

*Use {@link doubleMyCapacity(double[] array)

*@param array

*@variable newArray

* @return Array(double)

*/

Hope it helps

Happy Learning

Related Questions

Navigate

• Browse (All)
• Browse C
• Subjects

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.