Diferencia entre revisiones de «Google Guava»

De Dos Ideas.
Saltar a: navegación, buscar
(→‎transform)
(→‎Ver también)
 
(No se muestran 34 ediciones intermedias de 2 usuarios)
Línea 19: Línea 19:
 
Determina verdadero o falso para cualquier carácter java, también ofrece  métodos básicos de tratamiento de texto.
 
Determina verdadero o falso para cualquier carácter java, también ofrece  métodos básicos de tratamiento de texto.
  
−
==== And / Or ====
+
==== and / or ====
  
 
<code java>
 
<code java>
Línea 30: Línea 30:
 
</code>
 
</code>
  
−
==== Negate ====
+
==== negate ====
  
 
<code java>
 
<code java>
Línea 103: Línea 103:
 
Divide cadenas de texto en subcadenas mediante el reconocimiento de un separador (también conocido como delimitador), este se puede definir mediante un carácter, una cadena literal, una expresión regular, un CharMatcher, o mediante el uso de una longitud fija.
 
Divide cadenas de texto en subcadenas mediante el reconocimiento de un separador (también conocido como delimitador), este se puede definir mediante un carácter, una cadena literal, una expresión regular, un CharMatcher, o mediante el uso de una longitud fija.
  
−
==== Split ====
+
==== split ====
  
 
Split retorna una instancia de Iterable en lugar de un Array.
 
Split retorna una instancia de Iterable en lugar de un Array.
Línea 146: Línea 146:
  
 
<code java>
 
<code java>
−
List<String> input = newArrayList("Josefina","Nacho","lali");
+
List<String> input = newArrayList("Josefina","Nacho","Lali");
 
Collection<String> output =  
 
Collection<String> output =  
 
     Collections2.filter(input, new Predicate<String>() {
 
     Collections2.filter(input, new Predicate<String>() {
Línea 160: Línea 160:
 
System.out.println(output);
 
System.out.println(output);
  
−
// Salida: [Josefina, lali]
+
// Salida: [Josefina, Lali]
 
</code>
 
</code>
  
Línea 166: Línea 166:
  
 
<code java>
 
<code java>
−
List<String> input = newArrayList("Josefina", "Nacho", "lali");
+
List<String> input = newArrayList("Josefina", "Nacho", "Lali");
 
Collection<String> output =  
 
Collection<String> output =  
 
     Collections2.transform(input, new Function<String, String>() {
 
     Collections2.transform(input, new Function<String, String>() {
Línea 177: Línea 177:
 
System.out.println(output);
 
System.out.println(output);
  
−
// Salida: [Jose, Nacho, lali]
+
// Salida: [Jose, Nacho, Lali]
 
</code>
 
</code>
 +
 +
=== Constraints ===
 +
 +
Restringe la carga de las colecciones medinate limitaciones.
 +
 +
==== constrainedCollection ====
 +
 +
<code java>
 +
Constraint<String> debeContenerJoL = new Constraint<String>() {
 +
 +
    @Override
 +
    public String checkElement(String s) {
 +
      checkNotNull(s);
 +
      if (!s.contentEquals("JL")) {
 +
        throw new IllegalArgumentException("No contiene J ni L");
 +
      }
 +
      return s;
 +
    }
 +
};
 +
       
 +
Collection<String> input = newArrayList("Josefina");
 +
Collection<String> output = constrainedCollection(input, debeContenerJoL);
 +
output.add("Nacho");
 +
 +
// Salida:
 +
Exception in thread "main" java.lang.IllegalArgumentException: No contiene J ni L
 +
</code>
 +
 +
<code java>
 +
Collection<String> input = newArrayList("Josefina");
 +
Collection<String> output = constrainedCollection(input, notNull());
 +
output.add(null);
 +
 +
// Salida:
 +
Exception in thread "main" java.lang.NullPointerException
 +
</code>
 +
 +
=== Ordering ===
 +
 +
Comparador con métodos para soportar funciones comunes.
 +
 +
==== sortedCopy ====
 +
 +
<code java>
 +
List<String> input = newArrayList("Josefina","Nacho","Lali");
 +
 +
Ordering<String> ordering = Ordering.from(new Comparator< String>() {
 +
 +
        @Override
 +
        public int compare(String string1, String string2) {
 +
            return Ints.compare(string1.length(), string2.length());
 +
               
 +
        }
 +
});
 +
 +
List<String> output = ordering.sortedCopy(input);
 +
System.out.println(output);
 +
 +
// Salida: [Lali, Nacho, Josefina]
 +
</code>
 +
 +
 +
=== Multimap ===
 +
 +
Basicamente es un map en el que se pueden asignar muchos valores a una sola clave.
 +
 +
<code java>
 +
Multimap<Integer, String> output = HashMultimap.create();
 +
        output.put(1, "Josefina");
 +
        output.put(2, "nacho");
 +
        output.put(3, "Lali");
 +
        output.put(1, "Josefina_2");
 +
System.out.println(output);
 +
 +
// Salida: {1=[Josefina, Josefina_2], 2=[Bacho], 3=[lali]}
 +
</code>
 +
 +
==== ImmutableSetMultimap ====
 +
 +
===== inline =====
 +
<code java>
 +
Multimap<Integer, String> output =
 +
ImmutableSetMultimap.of(1, "Josefina", 2, "Nacho", 3, "Lali", 1, "Josefina_2");
 +
System.out.println(output);
 +
 +
// Salida: {1=[Josefina, Josefina_2], 2=[Nacho], 3=[Lali]}
 +
</code>
 +
 +
===== builder =====
 +
 +
<code java>
 +
Multimap<Integer, String> output =
 +
                new ImmutableSetMultimap.Builder<Integer, String>()
 +
                    .put(1, "Josefina")
 +
                    .put(2, "Nacho")
 +
                    .put(3, "Lali")
 +
                    .put(1, "Josefina_2")
 +
                    .build();
 +
System.out.println(output);
 +
 +
// Salida: {1=[Josefina, Josefina_2], 2=[Bacho], 3=[Lali]}
 +
</code>
 +
 +
=== Tables ===
 +
 +
Es una colección con columnas filas y valores. Permite el traspaso de una tabla a otra.
 +
 +
<code java>
 +
Table<Integer, String, String> table = HashBasedTable.create();
 +
table.put(1, "Hija", "Josefina");
 +
table.put(1, "Sobrino", "Nacho");
 +
table.put(1, "Pareja", "Lali");
 +
       
 +
Table output = Tables.transpose(table);
 +
 +
System.out.println(output);
 +
       
 +
// Salida: {Sobrino={1=Nacho}, Hija={1=Josefina}, Pareja={1=Lali}}
 +
</code>
 +
 +
=== BiMap ===
 +
 +
Es un Map que solo permite valores únicos.
 +
 +
<code java>
 +
BiMap<Integer, String> output = HashBiMap.create();
 +
output.put(1, "Josefina");
 +
output.put(2, "Lali");
 +
output.put(3, "Josefina"); //IllegalArgumentException
 +
 +
// Salida:
 +
Exception in thread "main" java.lang.IllegalArgumentException: value already present: Josefina
 +
 +
</code>
 +
 +
=== Throwables ===
 +
 +
Clase utilitaria que contiene métodos estáticos para el manejo de excepciones.
 +
 +
==== propagate ====
 +
 +
En el caso de que la excepción sea del tipo RuntimeException la lanza, de lo contrario crea una RuntimeException con la excepción recibida y la lanza.
 +
 +
<code java>
 +
    try {
 +
      throw new Exception("Error !!!");
 +
    } catch (Throwable t) {
 +
      throw Throwables.propagate(t);
 +
    }
 +
 +
// Salida:
 +
Exception in thread "main" java.lang.RuntimeException: java.lang.Exception: Error !!!
 +
at com.google.common.base.Throwables.propagate(Throwables.java:155)
 +
at com.dosideas.guavalibrarydemo.Ejemplo.main(Ejemplo.java:92)
 +
Caused by: java.lang.Exception: Error !!!
 +
at com.dosideas.guavalibrarydemo.Ejemplo.main(Ejemplo.java:90)
 +
</code>
 +
 +
=== Files ===
 +
 +
Clase con métodos útiles para el manejo de archovs.
 +
 +
==== readLines ====
 +
 +
<code java>
 +
ClassLoader cla = App.class.getClassLoader();
 +
File file = new File(cla.getResource("prueba.txt").getFile());
 +
List<String> lines = Files.readLines(file, Charsets.UTF_8);
 +
</code>
 +
 +
==Ver también==
 +
* [[Ejemplo con Google Guava Comparator]]
 +
* [http://code.google.com/p/dosideas-aplicaciones-modelo/source/browse/#svn Descargar con svn de nuestro proyecto en google-code la aplicación demo de Google Guava]
 +
* [http://www.javacodegeeks.com/2011/09/google-guava-libraries-essentials.html Google Guava Libraries Essentials]
 +
* [http://guava-libraries.googlecode.com/svn/tags/release09/javadoc/index.html Google Guava API]
 +
 +
[[Category:Java]]

Revisión actual del 14:23 23 may 2012

Google Guava es un proyecto de Google que reúne un conjunto de librerías usadas internamente dentro de Google para sus proyectos que emplean Java. El propósito de la librería es simplificar el código empleado para realizar tareas que son comunes dentro de Java y que no están soportadas por las librerías estándar, de esta manera busca eliminar código propenso a errores.

Maven

<dependency> 

  <groupId>com.google.guava</groupId>
  <artifactId>guava</artifactId>
  <version>r09</version>

</dependency>

Controlara última versión aquí.

Ejemplos

CharMatcher

Determina verdadero o falso para cualquier carácter java, también ofrece métodos básicos de tratamiento de texto.

and / or

String input = "La fecha es : 01/01/2011"; CharMatcher charMatcher = CharMatcher.DIGIT.or(CharMatcher.is('/')); String output = charMatcher.retainFrom(input); System.out.println(output);

// Salida : 01/01/2011

negate

String input = "MAYUSCULA minuscula"; CharMatcher charMatcher = CharMatcher.JAVA_LOWER_CASE.or(CharMatcher.WHITESPACE).negate(); String output = charMatcher.retainFrom(input); System.out.println(output);

// Salida: MAYUSCULA

inRange

String input = "Solo quedan los numeros 1, 2, 3, 4 que son menores a 5 "; CharMatcher charMatcher = CharMatcher.inRange('0', '4').or(CharMatcher.WHITESPACE); String output = charMatcher.retainFrom(input); System.out.println(output);

// Salida: 1 2 3 4

Joiner

Une fragmentos de texto mediante un separador. también ofrece métodos básicos de tratamiento de texto.

join

String[] nombres = {"Josefina", "Nacho", "Lali", "Coco"}; String output = Joiner.on(", ").join(nombres); System.out.println(output);

// Salida: Josefina, Nacho, Lali, Coco

skipNulls

String[] nombres = {null, "Josefina", null, "Nacho", null, "Lali", null, "Coco"}; String output = Joiner.on(", ").skipNulls().join(nombres); System.out.println(output);

// Salida: Josefina, Nacho, Lali, Coco

useForNull

String[] nombres = {null, "Josefina", null, "Nacho", null, "Lali", null, "Coco"}; String output = Joiner.on(", ").useForNull("n/a").join(nombres); System.out.println(output);

// Salida: n/a, Josefina, n/a, Nacho, n/a, Lali, n/a, Coco

withKeyValueSeparator

Map<Integer, String> map = newHashMap(); map.put(1, "Josefina"); map.put(2, "Nacho"); map.put(3, "Lali"); String output = Joiner.on(", ").withKeyValueSeparator(" -> ").join(map); System.out.println(output);

// Salida: 1 -> Josefina, 2 -> Nacho, 3 -> Lali

Splitter

Divide cadenas de texto en subcadenas mediante el reconocimiento de un separador (también conocido como delimitador), este se puede definir mediante un carácter, una cadena literal, una expresión regular, un CharMatcher, o mediante el uso de una longitud fija.

split

Split retorna una instancia de Iterable en lugar de un Array.

String input = "Josefina|Nacho|Lali"; Iterable<String> split = Splitter.on("|").split(input); List<String> output = newArrayList(split); System.out.println(output);

// Salida: [Josefina, Nacho, Lali]

fixedLength

String input ="Josefina Nacho Lali "; Iterable<String> splitted = Splitter.fixedLength(10).trimResults().split(input); List<String> output = newArrayList(splitted); System.out.println(output);

//Salida: [Josefina, Nacho, Lali]

onPattern

String input ="Josefina Nacho Lali"; Iterable<String> splitted = 

           Splitter.onPattern("[a-z&&[aeiou]]").omitEmptyStrings().split(input);

List<String> output = newArrayList(splitted); System.out.println(output);

// Salida: [J, s, f, n, N, ch, L, l]

Collection2

Proporciona métodos estáticos para trabajar con colecciones.

filter

List<String> input = newArrayList("Josefina","Nacho","Lali"); Collection<String> output = 

    Collections2.filter(input, new Predicate<String>() {

               public boolean apply(String t) {
                   if (t.contains("i")) {
                       return true;
                   }
                   return false;
               }
           });

System.out.println(output);

// Salida: [Josefina, Lali]

transform

List<String> input = newArrayList("Josefina", "Nacho", "Lali"); Collection<String> output = 

    Collections2.transform(input, new Function<String, String>() {

           public String apply(String f) {
               return f.replaceAll("fina","");
           }
       });

System.out.println(output);

// Salida: [Jose, Nacho, Lali]

Constraints

Restringe la carga de las colecciones medinate limitaciones.

constrainedCollection

Constraint<String> debeContenerJoL = new Constraint<String>() { 

    @Override
    public String checkElement(String s) {
      checkNotNull(s);
      if (!s.contentEquals("JL")) {
        throw new IllegalArgumentException("No contiene J ni L");
      }
      return s;
    }

};

Collection<String> input = newArrayList("Josefina"); Collection<String> output = constrainedCollection(input, debeContenerJoL); output.add("Nacho");

// Salida: Exception in thread "main" java.lang.IllegalArgumentException: No contiene J ni L

Collection<String> input = newArrayList("Josefina"); Collection<String> output = constrainedCollection(input, notNull()); output.add(null);

// Salida: Exception in thread "main" java.lang.NullPointerException

Ordering

Comparador con métodos para soportar funciones comunes.

sortedCopy

List<String> input = newArrayList("Josefina","Nacho","Lali");

Ordering<String> ordering = Ordering.from(new Comparator< String>() { 

       @Override
       public int compare(String string1, String string2) {
            return Ints.compare(string1.length(), string2.length());
               
       }

});

List<String> output = ordering.sortedCopy(input); System.out.println(output);

// Salida: [Lali, Nacho, Josefina]


Multimap

Basicamente es un map en el que se pueden asignar muchos valores a una sola clave.

Multimap<Integer, String> output = HashMultimap.create(); 

       output.put(1, "Josefina");
       output.put(2, "nacho");
       output.put(3, "Lali");
       output.put(1, "Josefina_2");

System.out.println(output);

// Salida: {1=[Josefina, Josefina_2], 2=[Bacho], 3=[lali]}

ImmutableSetMultimap

inline

Multimap<Integer, String> output = ImmutableSetMultimap.of(1, "Josefina", 2, "Nacho", 3, "Lali", 1, "Josefina_2"); System.out.println(output);

// Salida: {1=[Josefina, Josefina_2], 2=[Nacho], 3=[Lali]}

builder

Multimap<Integer, String> output = 

               new ImmutableSetMultimap.Builder<Integer, String>()
                   .put(1, "Josefina")
                   .put(2, "Nacho")
                   .put(3, "Lali")
                   .put(1, "Josefina_2")
                   .build();

System.out.println(output);

// Salida: {1=[Josefina, Josefina_2], 2=[Bacho], 3=[Lali]}

Tables

Es una colección con columnas filas y valores. Permite el traspaso de una tabla a otra.

Table<Integer, String, String> table = HashBasedTable.create(); table.put(1, "Hija", "Josefina"); table.put(1, "Sobrino", "Nacho"); table.put(1, "Pareja", "Lali");

Table output = Tables.transpose(table);

System.out.println(output);

// Salida: {Sobrino={1=Nacho}, Hija={1=Josefina}, Pareja={1=Lali}}

BiMap

Es un Map que solo permite valores únicos.

BiMap<Integer, String> output = HashBiMap.create(); output.put(1, "Josefina"); output.put(2, "Lali"); output.put(3, "Josefina"); //IllegalArgumentException

// Salida: Exception in thread "main" java.lang.IllegalArgumentException: value already present: Josefina

Throwables

Clase utilitaria que contiene métodos estáticos para el manejo de excepciones.

propagate

En el caso de que la excepción sea del tipo RuntimeException la lanza, de lo contrario crea una RuntimeException con la excepción recibida y la lanza. 

   try {
     throw new Exception("Error !!!");
   } catch (Throwable t) {
     throw Throwables.propagate(t);
   }

// Salida: Exception in thread "main" java.lang.RuntimeException: java.lang.Exception: Error !!! at com.google.common.base.Throwables.propagate(Throwables.java:155) at com.dosideas.guavalibrarydemo.Ejemplo.main(Ejemplo.java:92) Caused by: java.lang.Exception: Error !!! at com.dosideas.guavalibrarydemo.Ejemplo.main(Ejemplo.java:90)

Files

Clase con métodos útiles para el manejo de archovs.

readLines

ClassLoader cla = App.class.getClassLoader(); File file = new File(cla.getResource("prueba.txt").getFile()); List<String> lines = Files.readLines(file, Charsets.UTF_8);

Ver también

Obtenido de «https://dosideas.com/wiki/index.php?title=Google_Guava&oldid=6612»