un blog de opiniones con mate lavado

custom made array util classes and methods

custom made array util classes and methods

Hola que tal? Lamento importunar con este post que solo le interesa a una minoría de las personas que visitan este blog. La verdad es que no tenía otro lugar mejor donde guardarlo y compartirlo de manera que acá lo posteo. Aún si no eres programdor/a, puede que te pique la curiosidad. Al respecto decir que se trata del código fuente de tres programas (clases) escritos en lenguaje Java. El primero es una librería de utilidad para manejo de arrays (un array es un conjuntos de objetos que pueden ser strings o cadenas (entre otras cosas, “esto es una cadena” es una cadena :P); el segundo es una clase especializada en crear arrays de cualquier tipo de objetos, y el tercero es un test de Junit necesario para “ejercitar” (testear, verificar que funcionan correctamente) las clases precedentes… Bueno, queda hecha la disculpa, cualquier cosa me dejas un comentario, visitas esta página, o me envías un email. Muchas gracias, saludos! -gerardo 😛

ArrayUtils.java







package com.scriptorum.util;

import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class ArrayUtils<T> {

  private ArrayUtils() {
  }

  public static <T> T[] concat(T[] firstArray, T[] secondArray) {

    try {
      T[] result = Arrays.copyOf(firstArray, firstArray.length
          + secondArray.length);
      System.arraycopy(secondArray, 0, result, firstArray.length,
          secondArray.length);
      return result;
    catch (Exception e) {
      return firstArray;
    }

  }

  public static <T> T[] concat(T[] anArray, T object) {

    if (null == object)
      return anArray;
    try {
      T[] result = Arrays.copyOf(anArray, anArray.length + 1);
      result[anArray.length= object;
      return result;
    catch (Exception e) {
      return anArray;
    }

  }

  public static <T> T[] merge(T[] firstArray, T[] secondArray) {

    try {
      return (T[]) removeDuplicates(concat(firstArray, secondArray));
    catch (Exception e) {
      return firstArray;
    }

  }

  /**
   
   @param <T>
   @param mayHaveDuplicates
   @return T[]
   
   *         <LI>converts data from an array to a list, <LI>then to a set (to
   *         discard duplicates), <LI>then converts it back to the generic
   *         type
   */
  public static <T> T[] removeDuplicates(T[] mayHaveDuplicates) {
    List<T> list = Arrays.asList(mayHaveDuplicates);
    Set<T> set = new HashSet<T>(list);
    T[] array = (T[]) set.toArray(new GenericArrayBuilder<T>(
        mayHaveDuplicates, set.size()).build());
    return array;

  }

}


GenericArrayBuilder.java







package com.scriptorum.util;

import java.lang.reflect.Array;

/**
 * Helper class, hides reflection -used to build the generic array- from its
 * clients
 */

public class GenericArrayBuilder<E> {

  private E[] arrayBuilt;

  @SuppressWarnings("unchecked")
  public GenericArrayBuilder(E[] array, int size) {
    getGenericArrayBuilder((Class<E[]>array.getClass(), size);
  }

  private void getGenericArrayBuilder(Class<E[]> clazz, int length) {
    arrayBuilt = clazz.cast(Array.newInstance(clazz.getComponentType(),
        length));
  }

  public E[] build() {
    return arrayBuilt;
  }

}


ArrayUtilsTest.java







package com.scriptorum.util;

import junit.framework.TestCase;

public class ArrayUtilsTest extends TestCase {

  public final void testConcatTwoEmptyArrays() {

    String[] expected = ArrayUtils.concat(new String[] {}new String[] {});
    assertNotNull(expected);

  }

  public final void testConcatNullToANonEmptyArray() {

    String[] nonEmptyArray = "something" };
    String[] expected = "something" };
    String[] received = ArrayUtils.concat(nonEmptyArray, null);
    assertTrue(expected.length == received.length);
    assertTrue(((Stringexpected[0]).equals((Stringreceived[0]));

  }

  public final void testConcatTwoArrays() {

    String[] firstArray = "first element""second element" };
    String[] secondArrray = "third element""fourth element" };
    String[] expected = "first element""second element",
        "third element""fourth element" };
    String[] received = ArrayUtils.concat(firstArray, secondArrray);
    assertTrue(expected.length == received.length);
    for (int i = 0; i < 4; i++)
      assertTrue(((Stringexpected[i]).equals((Stringreceived[i]));

  }

  public final void testConcatNullStringToAnArray() {

    String[] anArray = "first element""second element" };
    String anString = null;
    String[] expected = "first element""second element" };
    String[] received = ArrayUtils.concat(anArray, anString);
    assertTrue(expected.length == received.length);
    for (int i = 0; i < 2; i++)
      assertTrue(((Stringexpected[i]).equals((Stringreceived[i]));

  }

  public final void testConcatAnStringToAnArray() {

    String[] anArray = "first element""second element" };
    String anString = "third element";
    String[] expected = "first element""second element",
        "third element" };
    String[] received = ArrayUtils.concat(anArray, anString);
    assertTrue(expected.length == received.length);
    for (int i = 0; i < 3; i++)
      assertTrue(((Stringexpected[i]).equals((Stringreceived[i]));

  }

  public final void testMergeTwoArrays() {

    String[] anArray = "first element""second element" };
    String[] anotherArray = "second element" };
    String[] expected = "first element""second element" };
    String[] received = ArrayUtils.merge(anArray, anotherArray);
    assertTrue(expected.length == received.length);
    for (int i = 0; i < 2; i++)
      assertTrue(((Stringexpected[i]).equals((Stringreceived[i]));

  }

  public final void testGenericArrayBuilder() {

    int maxStoreSize = 2500;
    Foo[] emptyFooArray = {};
    Object[] fooStore = getTemplateArray(emptyFooArray, maxStoreSize);

    // ASSERTIONS

    // 1st, make sure the array is of requested lenght
    assertTrue(fooStore.length == maxStoreSize);

    // 2nd, make sure each array component is NOT of Object type
    // (even if it has been received as an Object [])
    assertFalse((fooStore).getClass().getComponentType()
        .equals(Object.class));

    // 3rd, make sure each array member is of the type requested by
    // parameter
    assertTrue((fooStore).getClass().getComponentType().equals(Foo.class));

    // 4th, make sure whe can store an instance of the requested type into
    // the array
    assertTrue((fooStore[0new Foo()) != null);

  }

  private <T> T[] getTemplateArray(T[] foos, int size) {
    return new GenericArrayBuilder<T>(foos, size).build();
  }

  public class Foo {
  }

}


que opinas tu?

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s