Maximum value in an array

Maximum value in a byte array

 
public class Main {
  public static byte max(byte[] array) {
      if (array == null) {
          throw new IllegalArgumentException("The Array must not be null");
      } else if (array.length == 0) {
          throw new IllegalArgumentException("Array cannot be empty.");
      }
      byte max = array[0];
      for (int i = 1; i < array.length; i++) {
          if (array[i] > max) {
              max = array[i];
          }
      }
      return max;
  }
}

Maximum value in a double-type array.

 
public class Main {
  public static double max(double[] array) {
      if (array== null) {
          throw new IllegalArgumentException("The Array must not be null");
      } else if (array.length == 0) {
          throw new IllegalArgumentException("Array cannot be empty.");
      }

      // Finds and returns max
      double max = array[0];
      for (int j = 1; j < array.length; j++) {
          if (Double.isNaN(array[j])) {
              return Double.NaN;
          }
          if (array[j] > max) {
              max = array[j];
          }
      }

      return max;
  }
}

Maximum value in a float-type array.

 
public class Main {
  public static float max(float[] array) {
      if (array == null) {
          throw new IllegalArgumentException("The Array must not be null");
      } else if (array.length == 0) {
          throw new IllegalArgumentException("Array cannot be empty.");
      }

      // Finds and returns max
      float max = array[0];
      for (int j = 1; j < array.length; j++) {
          if (Float.isNaN(array[j])) {
              return Float.NaN;
          }
          if (array[j] > max) {
              max = array[j];
          }
      }

      return max;
  }
}

Maximum value in a long-value array.

 
public class Main {
  public static long max(long[] array) {
      // Validates input
      if (array == null) {
          throw new IllegalArgumentException("The Array must not be null");
      } else if (array.length == 0) {
          throw new IllegalArgumentException("Array cannot be empty.");
      }

      // Finds and returns max
      long max = array[0];
      for (int j = 1; j < array.length; j++) {
          if (array[j] > max) {
              max = array[j];
          }
      }

      return max;
  }
}

Maximum value in a short-type array.

 
public class Main {
  public static short max(short[] array) {
      if (array == null) {
          throw new IllegalArgumentException("The Array must not be null");
      } else if (array.length == 0) {
          throw new IllegalArgumentException("Array cannot be empty.");
      }
      // Finds and returns max
      short max = array[0];
      for (int i = 1; i < array.length; i++) {
          if (array[i] > max) {
              max = array[i];
          }
      }

      return max;
  }
}

Maximum value in an int-type array.

 
public class Main {
  public static int max(int[] array) {
      if (array == null) {
          throw new IllegalArgumentException("The Array must not be null");
      } else if (array.length == 0) {
          throw new IllegalArgumentException("Array cannot be empty.");
      }

      // Finds and returns max
      int max = array[0];
      for (int j = 1; j < array.length; j++) {
          if (array[j] > max) {
              max = array[j];
          }
      }

      return max;
  }
}

Returns the minimum value in a double-type array.

 
public class Main {
 public static double min(double[] array) {
     if (array == null) {
         throw new IllegalArgumentException("The Array must not be null");
     } else if (array.length == 0) {
         throw new IllegalArgumentException("Array cannot be empty.");
     }
     // Finds and returns min
     double min = array[0];
     for (int i = 1; i < array.length; i++) {
         if (Double.isNaN(array[i])) {
             return Double.NaN;
         }
         if (array[i] < min) {
             min = array[i];
         }
     }
     return min;
  }
}

Returns the minimum value in a float-value array.

 
public class Main {
  public static float min(float[] array) {
      if (array == null) {
          throw new IllegalArgumentException("The Array must not be null");
      } else if (array.length == 0) {
          throw new IllegalArgumentException("Array cannot be empty.");
      }

      // Finds and returns min
      float min = array[0];
      for (int i = 1; i < array.length; i++) {
          if (Float.isNaN(array[i])) {
              return Float.NaN;
          }
          if (array[i] < min) {
              min = array[i];
          }
      }

      return min;
  }
}

Returns the minimum value in a short-type array.

 
public class Main {
  public static byte min(byte[] array) {
      if (array == null) {
          throw new IllegalArgumentException("The Array must not be null");
      } else if (array.length == 0) {
          throw new IllegalArgumentException("Array cannot be empty.");
      }

      // Finds and returns min
      byte min = array[0];
      for (int i = 1; i < array.length; i++) {
          if (array[i] < min) {
              min = array[i];
          }
      }

      return min;
  }
}
Home 
  Java Book 
    Runnable examples  

Data Type Array:
  1. Append item to array
  2. Append an object to an array.
  3. Append one array to another
  4. Clone Array
  5. Clones two dimensional float array
  6. Compare two arrays by reference
  7. Compare Two byte Arrays
  8. Compare Two boolean Arrays
  9. Compare Two char Arrays
  10. Compare Two double Arrays
  11. Compare Two float Arrays
  12. Compare Two int Arrays
  13. Compare Two long Arrays
  14. Compare two object arrays
  15. Compare Two short Arrays
  16. Compare two two-dimensional array
  17. Concatenate arrays
  18. Convert array to set
  19. Convert string array to string
  20. Convert string array to List
  21. Convert multi-dimensional array to string
  22. Convert an array to a Map
  23. Copy array
  24. Copy Elements from One Array to Another
  25. Copy and add an array at the end of the new array
  26. Extend an array with additional extra space
  27. Extend to Double the size of an array
  28. Fill boolean, byte, char,short, int, long, float array
  29. Get array upperbound
  30. Get the number of dimensions
  31. Insert an Element into a Sorted Array
  32. Insert the specified element at the specified position in the array
  33. Insert source array in the target array at offset
  34. Maximum value in an array
  35. Minimum value in an array.
  36. Merge two arrays
  37. Remove duplicate element from array
  38. Remove the element at the specified position from the specified array.
  39. Reverses the order of an array(byte, long, int)
  40. Search an element in an array and return the index and last index
  41. Binary Search on an Array
  42. Shift all elements right by one
  43. Shift all elements left by one
  44. Shuffle an array
  45. Sort byte(char,double, float, int) Array
  46. Sort char array
  47. Sort int Array
  48. Sort long Array
  49. Sort short Array
  50. Sort string type array in case insensitive order and case sensitive order
  51. Sort an Array in Descending (Reverse) Order
  52. Start with one array
  53. Subarray from array that starts at offset