ejemplo - text box java

Características ocultas de Java

Question

Después de leer Características ocultas de C # Me pregunté: ¿Cuáles son algunas de las características ocultas de Java?

Answer 1

¿Qué hay de los tipos de retorno covariante que han estado en vigor desde JDK 1.5? Es bastante poco publicitado, ya que es una adición poco atractiva, pero como lo entiendo, es absolutamente necesario para que los genéricos funcionen.

Esencialmente, el compilador ahora permite que una subclase reduzca el tipo de retorno de un método anulado para que sea una subclase del tipo de retorno del método original. Así que esto está permitido:

class Souper {
    Collection<String> values() {
        ...
    }
}

class ThreadSafeSortedSub extends Souper {
    @Override
    ConcurrentSkipListSet<String> values() {
        ...
    }
}

Puede llamar al método de los values la subclase y obtener un Set de String seguras de hilos ordenados sin tener que realizar una conversión descendente al ConcurrentSkipListSet .

Answer 2

A partir de Java 1.5, Java ahora tiene una sintaxis mucho más clara para escribir funciones de aridad variable. Entonces, en lugar de solo pasar una matriz, ahora puede hacer lo siguiente

public void foo(String... bars) {
   for (String bar: bars)
      System.out.println(bar);
}

barras se convierte automáticamente a la matriz del tipo especificado. No es una gran victoria, pero una victoria, no obstante.

Answer 3

Cada archivo de clase comienza con el valor hexadecimal 0xCAFEBABE para identificarlo como un bytecode JVM válido.

( Explanation )

Answer 4

Creo que otra característica "pasada por alto" de Java es la JVM en sí misma. Es probablemente la mejor VM disponible. Y es compatible con muchos idiomas interesantes y útiles (Jython, JRuby, Scala, Groovy). Todos esos idiomas pueden cooperar fácilmente y sin problemas.

Si diseña un nuevo idioma (como en el caso de Scala), inmediatamente tiene disponibles todas las bibliotecas existentes y, por lo tanto, su idioma es "útil" desde el principio.

Todos esos idiomas hacen uso de las optimizaciones HotSpot. La VM está muy bien monitoreada y se puede depurar.

Answer 5

Cuando trabajo en Swing me gusta la función Ctrl - Shift - F1 oculta.

Vuelca el árbol de componentes de la ventana actual.
(Suponiendo que no hayas vinculado esa pulsación a otra cosa).

Answer 6

El método asList en java.util.Arrays permite una buena combinación de varargs, métodos genéricos y autoboxing:

List<Integer> ints = Arrays.asList(1,2,3);

Answer 7

Esto no es exactamente "características ocultas" y no es muy útil, pero puede ser extremadamente interesante en algunos casos:
Class sun.misc.Unsafe: le permitirá implementar la administración directa de memoria en Java (incluso puede escribir código Java auto modificable con esto si intenta mucho):

public class UnsafeUtil {

    public static Unsafe unsafe;
    private static long fieldOffset;
    private static UnsafeUtil instance = new UnsafeUtil();

    private Object obj;

    static {
        try {
            Field f = Unsafe.class.getDeclaredField("theUnsafe");
            f.setAccessible(true);

            unsafe = (Unsafe)f.get(null);
            fieldOffset = unsafe.objectFieldOffset(UnsafeUtil.class.getDeclaredField("obj"));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    };
}

Answer 8

JDK 1.6_07 + contiene una aplicación llamada VisualVM (bin / jvisualvm.exe) que es una buena interfaz gráfica de usuario además de muchas de las herramientas. Parece más completo que JConsole.

Answer 9

La adición de la construcción de bucle para cada en 1.5. Yo <3 lo.

// For each Object, instantiated as foo, in myCollection
for(Object foo: myCollection) {
  System.out.println(foo.toString());
}

Y se puede utilizar en instancias anidadas:

for (Suit suit : suits)
  for (Rank rank : ranks)
    sortedDeck.add(new Card(suit, rank));

La construcción for-each también es aplicable a matrices, donde oculta la variable de índice en lugar del iterador. El siguiente método devuelve la suma de los valores en una matriz int:

// Returns the sum of the elements of a
int sum(int[] a) {
  int result = 0;
  for (int i : a)
    result += i;
  return result;
}

Enlace a la documentación del sol.

Answer 10

Los comodines de Classpath desde Java 6.

java -classpath ./lib/* so.Main

En lugar de

java -classpath ./lib/log4j.jar:./lib/commons-codec.jar:./lib/commons-httpclient.jar:./lib/commons-collections.jar:./lib/myApp.jar so.Main

Consulte http://java.sun.com/javase/6/docs/technotes/tools/windows/classpath.html

Answer 11

Los parámetros de tipo para métodos genéricos se pueden especificar explícitamente así:

Collections.<String,Integer>emptyMap()

Answer 12

Me sorprendieron los inicializadores de instancia el otro día. Estaba eliminando algunos métodos de código plegado y terminé creando varios inicializadores de instancia:

public class App {
    public App(String name) { System.out.println(name + "''s constructor called"); }

    static { System.out.println("static initializer called"); }

    { System.out.println("instance initializer called"); }

    static { System.out.println("static initializer2 called"); }

    { System.out.println("instance initializer2 called"); }

    public static void main( String[] args ) {
        new App("one");
        new App("two");
  }
}

Ejecutando el método main se mostrará:

static initializer called
static initializer2 called
instance initializer called
instance initializer2 called
one''s constructor called
instance initializer called
instance initializer2 called
two''s constructor called

Supongo que esto sería útil si tuviera varios constructores y necesitara un código común

También proporcionan azúcar sintáctica para inicializar tus clases:

List<Integer> numbers = new ArrayList<Integer>(){{ add(1); add(2); }};

Map<String,String> codes = new HashMap<String,String>(){{ 
  put("1","one"); 
  put("2","two");
}};

Answer 13

Mi favorito: volcar todas las trazas de la pila de hilos a estándar.

windows: CTRL - Rompe tu java cmd / consola de ventana

unix: kill -3 PID

Answer 14

Mi voto va a java.util.concurrent con sus colecciones concurrentes y ejecutores flexibles que permiten, entre otros, grupos de subprocesos, tareas programadas y tareas coordinadas. El DelayQueue es mi favorito personal, donde los elementos están disponibles después de un retraso específico.

java.util.Timer y TimerTask pueden ponerse a descansar de manera segura.

Además, no está exactamente oculto pero en un paquete diferente de las otras clases relacionadas con la fecha y la hora. java.util.concurrent.TimeUnit es útil al convertir entre nanosegundos, microsegundos, milisegundos y segundos.

Lee mucho mejor que el habitual someValue * 1000 o someValue / 1000.

Answer 15

No es realmente parte del lenguaje Java, pero el desensamblador javap que viene con el JDK de Sun no es ampliamente conocido o usado.

Answer 16

No es realmente una característica, sino un truco divertido que descubrí recientemente en alguna página web:

class Example
{
  public static void main(String[] args)
  {
    System.out.println("Hello World!");
    http://Phi.Lho.free.fr

    System.exit(0);
  }
}

Es un programa Java válido (aunque genera una advertencia). ¡Si no ve por qué, vea la respuesta de Gregory! ;-) Bueno, el resaltado de sintaxis aquí también da una pista.

Answer 17

No he visto a nadie mencionar la instancia de implementación de tal manera que no sea necesario verificar el valor nulo.

En lugar de:

if( null != aObject && aObject instanceof String )
{
    ...
}

Solo usa:

if( aObject instanceof String )
{
    ...
}

Answer 18

Para la mayoría de las personas que entrevisté para los puestos de desarrollador de Java, los bloques etiquetados son muy sorprendentes. Aquí hay un ejemplo:

// code goes here

getmeout:{
    for (int i = 0; i < N; ++i) {
        for (int j = i; j < N; ++j) {
            for (int k = j; k < N; ++k) {
                //do something here
                break getmeout;
            }
        }
    }
}

¿Quién dijo que goto en java es solo una palabra clave? :)

Answer 19

Permitir métodos y constructores en enums me sorprendió. Por ejemplo:

enum Cats {
  FELIX(2), SHEEBA(3), RUFUS(7);

  private int mAge;
  Cats(int age) {
    mAge = age;
  }
  public int getAge() {
    return mAge;
   }
}

Incluso puede tener un "cuerpo de clase específico constante" que permite que un valor de enumeración específico anule los métodos.

Más documentación here .

Answer 20

Puede definir una subclase anónima y llamar directamente a un método incluso si no implementa interfaces.

new Object() {
  void foo(String s) {
    System.out.println(s);
  }
}.foo("Hello");

Answer 21

Puede utilizar enumeraciones para implementar una interfaz.

public interface Room {
   public Room north();
   public Room south();
   public Room east();
   public Room west();
}

public enum Rooms implements Room {
   FIRST {
      public Room north() {
         return SECOND;
      }
   },
   SECOND {
      public Room south() {
         return FIRST;
      }
   }

   public Room north() { return null; }
   public Room south() { return null; }
   public Room east() { return null; }
   public Room west() { return null; }
}

EDITAR: años más tarde ....

Yo uso esta característica aquí

public enum AffinityStrategies implements AffinityStrategy {

https://github.com/peter-lawrey/Java-Thread-Affinity/blob/master/src/main/java/vanilla/java/affinity/AffinityStrategies.java

Mediante el uso de una interfaz, los desarrolladores pueden definir sus propias estrategias. Usar una enum significa que puedo definir una colección (de cinco) incorporada.

Answer 22

Transferencia de control en un bloque finalmente elimina cualquier excepción. El siguiente código no lanza RuntimeException - se pierde.

public static void doSomething() {
    try {
      //Normally you would have code that doesn''t explicitly appear 
      //to throw exceptions so it would be harder to see the problem.
      throw new RuntimeException();
    } finally {
      return;
    }
  }

De http://jamesjava.blogspot.com/2006/03/dont-return-in-finally-clause.html

Answer 23

Un par de personas han publicado sobre inicializadores de instancia, aquí hay un buen uso para ello:

Map map = new HashMap() {{
    put("a key", "a value");
    put("another key", "another value");
}};

Es una forma rápida de inicializar mapas si solo está haciendo algo rápido y simple.

O usándolo para crear un prototipo de marco de giro rápido:

JFrame frame = new JFrame();

JPanel panel = new JPanel(); 

panel.add( new JLabel("Hey there"){{ 
    setBackground(Color.black);
    setForeground( Color.white);
}});

panel.add( new JButton("Ok"){{
    addActionListener( new ActionListener(){
        public void actionPerformed( ActionEvent ae ){
            System.out.println("Button pushed");
        }
     });
 }});


 frame.add( panel );

Por supuesto que se puede abusar:

    JFrame frame = new JFrame(){{
         add( new JPanel(){{
               add( new JLabel("Hey there"){{ 
                    setBackground(Color.black);
                    setForeground( Color.white);
                }});

                add( new JButton("Ok"){{
                    addActionListener( new ActionListener(){
                        public void actionPerformed( ActionEvent ae ){
                            System.out.println("Button pushed");
                        }
                     });
                 }});
        }});
    }};

Answer 24

Unión conjunta en tipo varianza parámetro:

public class Baz<T extends Foo & Bar> {}

Por ejemplo, si desea tomar un parámetro que sea comparable y una colección:

public static <A, B extends Collection<A> & Comparable<B>>
boolean foo(B b1, B b2, A a) {
   return (b1.compareTo(b2) == 0) || b1.contains(a) || b2.contains(a);
}

Este método creado devuelve verdadero si las dos colecciones dadas son iguales o si cualquiera de ellas contiene el elemento dado, de lo contrario es falso. El punto a tener en cuenta es que puede invocar métodos de Comparable y Collection en los argumentos b1 y b2.

Answer 25

Uso de esta palabra clave para acceder a los campos / métodos de contener una clase de una clase interna. En el siguiente ejemplo, más bien artificial, queremos usar el campo sortAscending de la clase contenedora de la clase interna anónima. Usar ContainerClass.this.sortAscending en lugar de this.sortAscending hace el truco.

import java.util.Comparator;

public class ContainerClass {
boolean sortAscending;
public Comparator createComparator(final boolean sortAscending){
    Comparator comparator = new Comparator<Integer>() {

        public int compare(Integer o1, Integer o2) {
            if (sortAscending || ContainerClass.this.sortAscending) {
                return o1 - o2;
            } else {
                return o2 - o1;
            }
        }

    };
    return comparator;
}
}

Answer 26

Los proxies dinámicos (agregados en 1.3) le permiten definir un nuevo tipo en tiempo de ejecución que se ajuste a una interfaz. Ha sido útil un sorprendente número de veces.

Answer 27

La inicialización de Double Brace me tomó por sorpresa hace unos meses, cuando la descubrí por primera vez, nunca antes había oído hablar de ella.

ThreadLocals generalmente no se conocen tan ampliamente como una forma de almacenar el estado por hilo.

Dado que JDK 1.5 Java ha tenido herramientas de concurrencia extremadamente sólidas y muy bien implementadas más allá de los bloqueos, viven en java.util.concurrent y un ejemplo específicamente interesante es el subpaquete java.util.concurrent.atomic que contiene primitivas seguras para subprocesos que implementan la compare-and-swap , y pueden asignarse a versiones reales soportadas por hardware nativo de estas operaciones.

Answer 28

La inicialización final puede ser pospuesta.

Se asegura de que, incluso con un flujo complejo de valores lógicos, los valores de retorno siempre se establezcan. Es demasiado fácil perder un caso y devolver el nulo por accidente. No hace que el regreso sea nulo, simplemente es obvio que es a propósito:

public Object getElementAt(int index) {
    final Object element;
    if (index == 0) {
         element = "Result 1";
    } else if (index == 1) {
         element = "Result 2";
    } else {
         element = "Result 3";
    }
    return element;
}

Answer 29

Palabra clave de afirmación de nivel de idioma.

Answer 30

Lo descubrí personalmente java.lang.Voidmuy tarde: mejora la legibilidad del código junto con los genéricos, por ejemplo,Callable<Void>