software - ¿Cuál es / es la (s) forma (s) Scala de implementar esta clase de Java "byte [] to Hex"?





vs python (4)


Quizás hay formas más elegantes, pero algo como:

def valueOf(bytes : List[Byte]) = bytes.map{
  b => String.format("%02X", new java.lang.Integer(b & 0xff)) 
}.mkString

Deberia trabajar.

Estoy especialmente interesado en las técnicas de Scala (2.8) para crear cadenas con formatos, así como las formas interesantes de hacer que esta capacidad sea fácilmente accesible donde sea útil (listas de bytes, cadenas, ...?).

public class Hex {
  public static String valueOf (final byte buf[]) {
    if (null == buf) {
      return null;
    }
    final StringBuilder sb = new StringBuilder(buf.length * 2);
    for (final byte b : buf) {
      sb.append(String.format("%02X", b & 0xff));
    }
    return sb.toString();
  }

  public static String valueOf (final Byteable o) {
    return valueOf(o.toByteArray());
  }
}

Esto es solo un ejercicio de aprendizaje (por lo que la utilidad y la implementación de Java no son una preocupación).

Gracias




Esto no maneja null de la misma manera que su código.

object Hex {

  def valueOf(buf: Array[Byte]): String = buf.map("%02X" format _).mkString

  def valueOf(o: Byteable): String = valueOf(o.toByteArray)

}

Si desea poder manejar matrices posiblemente null , puede que sea mejor hacerlo llamando al código y haciendo:

val bytes: Array[Byte] = // something, possibly null
val string: Option[String] = Option(bytes).map(Hex.valueOf)



Debe usar el tipo de Option de Scala en lugar de null . (Esto se prueba con Scala 2.8.0.RC1)

object Hex {
  def valueOf (buf: Array[Byte]) = {
    if (null == buf) {
      None
    } else {
      val sb = new StringBuilder(buf.length * 2)
      for (b <- buf) {
        sb.append("%02X".format(b & 0xff))
      }
      Some(sb.toString())
    }
  }
  /*
  def valueOf(o: Byteable) = {
    return valueOf(o.toByteArray());
  }
  */
}

println(Hex.valueOf(Array(-3, -2, -1, 0, 1, 2, 3)))
println(Hex.valueOf(null))



En JDK1.8 puede usar operaciones agregadas y una expresión lambda:

String[] strArray = new String[] {"John", "Mary", "Bob"};

// #1
Arrays.asList(strArray).stream().forEach(s -> System.out.println(s));

// #2
Stream.of(strArray).forEach(System.out::println);

// #3
Arrays.stream(strArray).forEach(System.out::println);

/* output:
John
Mary
Bob
*/




java scala