Search an element in an array and return the index and last index

 
import java.lang.reflect.Array;

public class Main {
  public static final int INDEX_NOT_FOUND = -1;
  public static int indexOf(int[] array, int valueToFind) {
      return indexOf(array, valueToFind, 0);
  }
  public static int indexOf(int[] array, int valueToFind, int startIndex) {
      if (array == null) {
          return INDEX_NOT_FOUND;
      }
      if (startIndex < 0) {
          startIndex = 0;
      }
      for (int i = startIndex; i < array.length; i++) {
          if (valueToFind == array[i]) {
              return i;
          }
      }
      return INDEX_NOT_FOUND;
  }
  public static int lastIndexOf(int[] array, int valueToFind) {
      return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
  }
  public static int lastIndexOf(int[] array, int valueToFind, int startIndex) {
      if (array == null) {
          return INDEX_NOT_FOUND;
      }
      if (startIndex < 0) {
          return INDEX_NOT_FOUND;
      } else if (startIndex >= array.length) {
          startIndex = array.length - 1;
      }
      for (int i = startIndex; i >= 0; i--) {
          if (valueToFind == array[i]) {
              return i;
          }
      }
      return INDEX_NOT_FOUND;
  }
  public static boolean contains(int[] array, int valueToFind) {
      return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
  }
}

Search long type array

 
import java.lang.reflect.Array;
public class Main {
  public static int indexOf(long[] array, long valueToFind) {
      return indexOf(array, valueToFind, 0);
  }
  public static int indexOf(long[] array, long valueToFind, int startIndex) {
      if (array == null) {
          return -1;
      }
      if (startIndex < 0) {
          startIndex = 0;
      }
      for (int i = startIndex; i < array.length; i++) {
          if (valueToFind == array[i]) {
              return i;
          }
      }
      return -1;
  }
  public static int lastIndexOf(long[] array, long valueToFind) {
      return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
  }
  public static int lastIndexOf(long[] array, long valueToFind, int startIndex) {
      if (array == null) {
          return -1;
      }
      if (startIndex < 0) {
          return -1;
      } else if (startIndex >= array.length) {
          startIndex = array.length - 1;
      }
      for (int i = startIndex; i >= 0; i--) {
          if (valueToFind == array[i]) {
              return i;
          }
      }
      return -1;
  }
  public static boolean contains(long[] array, long valueToFind) {
      return indexOf(array, valueToFind) != -1;
  }
}

Search a short type value array

 
import java.lang.reflect.Array;
public class Main {
  public static final int INDEX_NOT_FOUND = -1;
  public static int indexOf(short[] array, short valueToFind) {
      return indexOf(array, valueToFind, 0);
  }
  public static int indexOf(short[] array, short valueToFind, int startIndex) {
      if (array == null) {
          return INDEX_NOT_FOUND;
      }
      if (startIndex < 0) {
          startIndex = 0;
      }
      for (int i = startIndex; i < array.length; i++) {
          if (valueToFind == array[i]) {
              return i;
          }
      }
      return INDEX_NOT_FOUND;
  }
  public static int lastIndexOf(short[] array, short valueToFind) {
      return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
  }
  public static int lastIndexOf(short[] array, short valueToFind, int startIndex) {
      if (array == null) {
          return INDEX_NOT_FOUND;
      }
      if (startIndex < 0) {
          return INDEX_NOT_FOUND;
      } else if (startIndex >= array.length) {
          startIndex = array.length - 1;
      }
      for (int i = startIndex; i >= 0; i--) {
          if (valueToFind == array[i]) {
              return i;
          }
      }
      return INDEX_NOT_FOUND;
  }
  public static boolean contains(short[] array, short valueToFind) {
      return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
  }
}

Search a char type value array

 
import java.lang.reflect.Array;
public class Main {
  public static final int INDEX_NOT_FOUND = -1;
  public static int indexOf(char[] array, char valueToFind) {
      return indexOf(array, valueToFind, 0);
  }
  public static int indexOf(char[] array, char valueToFind, int startIndex) {
      if (array == null) {
          return INDEX_NOT_FOUND;
      }
      if (startIndex < 0) {
          startIndex = 0;
      }
      for (int i = startIndex; i < array.length; i++) {
          if (valueToFind == array[i]) {
              return i;
          }
      }
      return INDEX_NOT_FOUND;
  }
  public static int lastIndexOf(char[] array, char valueToFind) {
      return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
  }
  public static int lastIndexOf(char[] array, char valueToFind, int startIndex) {
      if (array == null) {
          return INDEX_NOT_FOUND;
      }
      if (startIndex < 0) {
          return INDEX_NOT_FOUND;
      } else if (startIndex >= array.length) {
          startIndex = array.length - 1;
      }
      for (int i = startIndex; i >= 0; i--) {
          if (valueToFind == array[i]) {
              return i;
          }
      }
      return INDEX_NOT_FOUND;
  }
  public static boolean contains(char[] array, char valueToFind) {
      return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
  }
}

Search a byte type array

 
import java.lang.reflect.Array;
public class Main {
  public static final int INDEX_NOT_FOUND = -1;
  public static int indexOf(byte[] array, byte valueToFind) {
      return indexOf(array, valueToFind, 0);
  }
  public static int indexOf(byte[] array, byte valueToFind, int startIndex) {
      if (array == null) {
          return INDEX_NOT_FOUND;
      }
      if (startIndex < 0) {
          startIndex = 0;
      }
      for (int i = startIndex; i < array.length; i++) {
          if (valueToFind == array[i]) {
              return i;
          }
      }
      return INDEX_NOT_FOUND;
  }
  public static int lastIndexOf(byte[] array, byte valueToFind) {
      return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
  }
  public static int lastIndexOf(byte[] array, byte valueToFind, int startIndex) {
      if (array == null) {
          return INDEX_NOT_FOUND;
      }
      if (startIndex < 0) {
          return INDEX_NOT_FOUND;
      } else if (startIndex >= array.length) {
          startIndex = array.length - 1;
      }
      for (int i = startIndex; i >= 0; i--) {
          if (valueToFind == array[i]) {
              return i;
          }
      }
      return INDEX_NOT_FOUND;
  }
  public static boolean contains(byte[] array, byte valueToFind) {
      return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
  }
}

Search a double type array

 
import java.lang.reflect.Array;
public class Main {
  public static final int INDEX_NOT_FOUND = -1;
  public static int indexOf(double[] array, double valueToFind) {
      return indexOf(array, valueToFind, 0);
  }
  public static int indexOf(double[] array, double valueToFind, double tolerance) {
      return indexOf(array, valueToFind, 0, tolerance);
  }
  public static int indexOf(double[] array, double valueToFind, int startIndex) {
      if (isEmpty(array)) {
          return INDEX_NOT_FOUND;
      }
      if (startIndex < 0) {
          startIndex = 0;
      }
      for (int i = startIndex; i < array.length; i++) {
          if (valueToFind == array[i]) {
              return i;
          }
      }
      return INDEX_NOT_FOUND;
  }
  public static int indexOf(double[] array, double valueToFind, int startIndex, double tolerance) {
      if (isEmpty(array)) {
          return INDEX_NOT_FOUND;
      }
      if (startIndex < 0) {
          startIndex = 0;
      }
      double min = valueToFind - tolerance;
      double max = valueToFind + tolerance;
      for (int i = startIndex; i < array.length; i++) {
          if (array[i] >= min && array[i] <= max) {
              return i;
          }
      }
      return INDEX_NOT_FOUND;
  }
  public static int lastIndexOf(double[] array, double valueToFind) {
      return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
  }
  public static int lastIndexOf(double[] array, double valueToFind, double tolerance) {
      return lastIndexOf(array, valueToFind, Integer.MAX_VALUE, tolerance);
  }
  public static int lastIndexOf(double[] array, double valueToFind, int startIndex) {
      if (isEmpty(array)) {
          return INDEX_NOT_FOUND;
      }
      if (startIndex < 0) {
          return INDEX_NOT_FOUND;
      } else if (startIndex >= array.length) {
          startIndex = array.length - 1;
      }
      for (int i = startIndex; i >= 0; i--) {
          if (valueToFind == array[i]) {
              return i;
          }
      }
      return INDEX_NOT_FOUND;
  }
  public static int lastIndexOf(double[] array, double valueToFind, int startIndex, double tolerance) {
      if (isEmpty(array)) {
          return INDEX_NOT_FOUND;
      }
      if (startIndex < 0) {
          return INDEX_NOT_FOUND;
      } else if (startIndex >= array.length) {
          startIndex = array.length - 1;
      }
      double min = valueToFind - tolerance;
      double max = valueToFind + tolerance;
      for (int i = startIndex; i >= 0; i--) {
          if (array[i] >= min && array[i] <= max) {
              return i;
          }
      }
      return INDEX_NOT_FOUND;
  }
  public static boolean contains(double[] array, double valueToFind) {
      return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
  }
  public static boolean contains(double[] array, double valueToFind, double tolerance) {
      return indexOf(array, valueToFind, 0, tolerance) != INDEX_NOT_FOUND;
  }
  public static boolean isEmpty(double[] array) {
      if (array == null || array.length == 0) {
          return true;
      }
      return false;
  }
}

Search a float type value array

 
import java.lang.reflect.Array;

public class Main {
  public static final int INDEX_NOT_FOUND = -1;
  public static int indexOf(float[] array, float valueToFind) {
      return indexOf(array, valueToFind, 0);
  }
  public static int indexOf(float[] array, float valueToFind, int startIndex) {
      if (isEmpty(array)) {
          return INDEX_NOT_FOUND;
      }
      if (startIndex < 0) {
          startIndex = 0;
      }
      for (int i = startIndex; i < array.length; i++) {
          if (valueToFind == array[i]) {
              return i;
          }
      }
      return INDEX_NOT_FOUND;
  }
    public static int lastIndexOf(float[] array, float valueToFind) {
        return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
    }

    public static int lastIndexOf(float[] array, float valueToFind, int startIndex) {
        if (isEmpty(array)) {
            return INDEX_NOT_FOUND;
        }
        if (startIndex < 0) {
            return INDEX_NOT_FOUND;
        } else if (startIndex >= array.length) {
            startIndex = array.length - 1;
        }
        for (int i = startIndex; i >= 0; i--) {
            if (valueToFind == array[i]) {
                return i;
            }
        }
        return INDEX_NOT_FOUND;
    }

    public static boolean contains(float[] array, float valueToFind) {
        return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
    }
  public static boolean isEmpty(float[] array) {
      if (array == null || array.length == 0) {
          return true;
      }
      return false;
  }
}

Search a boolean type array

 
import java.lang.reflect.Array;
public class Main {
  public static final int INDEX_NOT_FOUND = -1;
  public static int indexOf(boolean[] array, boolean valueToFind) {
      return indexOf(array, valueToFind, 0);
  }
  public static int indexOf(boolean[] array, boolean valueToFind, int startIndex) {
      if (isEmpty(array)) {
          return INDEX_NOT_FOUND;
      }
      if (startIndex < 0) {
          startIndex = 0;
      }
      for (int i = startIndex; i < array.length; i++) {
          if (valueToFind == array[i]) {
              return i;
          }
      }
      return INDEX_NOT_FOUND;
  }
  public static int lastIndexOf(boolean[] array, boolean valueToFind) {
      return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
  }
  public static int lastIndexOf(boolean[] array, boolean valueToFind, int startIndex) {
      if (isEmpty(array)) {
          return INDEX_NOT_FOUND;
      }
      if (startIndex < 0) {
          return INDEX_NOT_FOUND;
      } else if (startIndex >= array.length) {
          startIndex = array.length - 1;
      }
      for (int i = startIndex; i >= 0; i--) {
          if (valueToFind == array[i]) {
              return i;
          }
      }
      return INDEX_NOT_FOUND;
  }
  public static boolean contains(boolean[] array, boolean valueToFind) {
      return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
  }
  public static boolean isEmpty(boolean[] array) {
      if (array == null || array.length == 0) {
          return true;
      }
      return false;
  }
}
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