Returns the index in the source array where the first occurrence of the specified text (a String, converted to a byte array) is found : Array Sort Search « Collections Data Structure « Java

1. Java
2. Collections Data Structure
3. Array Sort Search

Returns the index in the source array where the first occurrence of the specified text (a String, converted to a byte array) is found

      
/**********************************************************************************
 *
 * Copyright (c) 2003, 2004 The Regents of the University of Michigan, Trustees of Indiana University,
 *                  Board of Trustees of the Leland Stanford, Jr., University, and The MIT Corporation
 *
 * Licensed under the Educational Community License Version 1.0 (the "License");
 * By obtaining, using and/or copying this Original Work, you agree that you have read,
 * understand, and will comply with the terms and conditions of the Educational Community License.
 * You may obtain a copy of the License at:
 *
 *      http://cvs.sakaiproject.org/licenses/license_1_0.html
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
 * AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 **********************************************************************************/


/**
 * Byte utilities
 */
public class ByteUtils {

  /**
   * Returns the index in the source array where the first occurrence of the
   * specified text (a String, converted to a byte array) is found
   * 
   * @param source
   *          Byte array to examine
   * @param matchString
   *          String to locate in <code>source</code>
   * @return Index of the first matching character (-1 if no match)
   */
  public static int indexOf(byte[] source, String matchString) {
    return indexOf(source, matchString.getBytes());
  }

  /**
   * Returns the index in the source array where the first occurrence of the
   * specified byte pattern is found
   * 
   * @param source
   *          Byte array to examine
   * @param match
   *          Byte array to locate in <code>source</code>
   * @return Index of the first matching character (-1 if no match)
   */
  public static int indexOf(byte[] source, byte[] match) {
    for (int i = 0; i < source.length; i++) {
      if (startsWith(source, i, match)) {
        return i;
      }
    }
    return -1;
  }

  /**
   * Returns the index in the source array where the last occurrence of the
   * specified text (a String, converted to a byte array) is found
   * 
   * @param source
   *          Byte array to examine
   * @param matchString
   *          String to locate in <code>source</code>
   * @return Index of the first matching character (-1 if no match)
   */
  public static int lastIndexOf(byte[] source, String matchString) {
    return lastIndexOf(source, matchString.getBytes());
  }

  /**
   * Returns the index in the source array where the last occurrence of the
   * specified byte pattern is found
   * 
   * @param source
   *          Byte array to examine
   * @param match
   *          Byte array to locate in <code>source</code>
   * @return Index of the last matching character (-1 if no match)
   */
  public static int lastIndexOf(byte[] source, byte[] match) {

    if (source.length < match.length) {
      return -1;
    }

    for (int i = (source.length - match.length); i >= 0; i--) {
      if (startsWith(source, i, match)) {
        return i;
      }
    }
    return -1;
  }

  /**
   * Does this byte array begin with match array content?
   * 
   * @param source
   *          Byte array to examine
   * @param match
   *          Byte array to locate in <code>source</code>
   * @return true If the starting bytes are equal
   */
  public static boolean startsWith(byte[] source, byte[] match) {
    return startsWith(source, 0, match);
  }

  /**
   * Does this byte array begin with match array content?
   * 
   * @param source
   *          Byte array to examine
   * @param offset
   *          An offset into the <code>source</code> array
   * @param match
   *          Byte array to locate in <code>source</code>
   * @return true If the starting bytes are equal
   */
  public static boolean startsWith(byte[] source, int offset, byte[] match) {

    if (match.length > (source.length - offset)) {
      return false;
    }

    for (int i = 0; i < match.length; i++) {
      if (source[offset + i] != match[i]) {
        return false;
      }
    }
    return true;
  }

  /**
   * Does the source array equal the match array?
   * 
   * @param source
   *          Byte array to examine
   * @param offset
   *          An offset into the <code>source</code> array
   * @param match
   *          Byte array to locate in <code>source</code>
   * @return true If the two arrays are equal
   */
  public static boolean equals(byte[] source, byte[] match) {

    if (match.length != source.length) {
      return false;
    }
    return startsWith(source, 0, match);
  }

  /**
   * Copies bytes from the source byte array to the destination array
   * 
   * @param source
   *          The source array
   * @param srcBegin
   *          Index of the first source byte to copy
   * @param srcEnd
   *          Index after the last source byte to copy
   * @param destination
   *          The destination array
   * @param dstBegin
   *          The starting offset in the destination array
   */
  public static void getBytes(byte[] source, int srcBegin, int srcEnd, byte[] destination,
      int dstBegin) {
    System.arraycopy(source, srcBegin, destination, dstBegin, srcEnd - srcBegin);
  }

  /**
   * Return a new byte array containing a sub-portion of the source array
   * 
   * @param srcBegin
   *          The beginning index (inclusive)
   * @param srcEnd
   *          The ending index (exclusive)
   * @return The new, populated byte array
   */
  public static byte[] subbytes(byte[] source, int srcBegin, int srcEnd) {
    byte destination[];

    destination = new byte[srcEnd - srcBegin];
    getBytes(source, srcBegin, srcEnd, destination, 0);

    return destination;
  }

  /**
   * Return a new byte array containing a sub-portion of the source array
   * 
   * @param srcBegin
   *          The beginning index (inclusive)
   * @return The new, populated byte array
   */
  public static byte[] subbytes(byte[] source, int srcBegin) {
    return subbytes(source, srcBegin, source.length);
  }

  /*
   * Test
   */
  public static void main(String[] args) throws Exception {
    byte byteText[];
    int index, last;

    byteText = "XXXXXXXXXX".getBytes();
    index = indexOf(byteText, "XXX");
    last = lastIndexOf(byteText, "XXX");

  }
}

   
    
    
    
    
    
  

Related examples in the same category