StringBuilder
Esta classe é praticamente idêntica a classe StringBuffer, com a única diferença que todos os métodos desta não são sincronizados. A utilização dessa classe é recomendável em lugar de StringBuffer, pois o ganho de desempenho é notável. Claro quando se estiver trabalhando com mais de uma thread no programa, então deve-se utilizar StringBuffer.
Varargs
A novidade de argumentos variáveis é a possibilidade de escrever métodos onde não se sabe quantos parâmetros de entrada vai ter. Vou mostrar um problema comum que atinge a maioria de nós e como varargs resolve ester problema.
Digamos que você queira escrever métodos sobrecarregados, um para uma certa quantidade de parâmetros.
public double sum(double a, double b)
public double sum(double a, double b, double c)
public double sum(double a, double b, double c, double d)
...
O código acima é muito ruim de se trabalhar, você vê que vai existir uma
cópia absurda de código, além de ficar muito feio. A solução de imediato seria
o código abaixo:
public double sum(double[] array)
Foi uma boa opção, substituir a sobrecarga de métodos anterior por um único método que aceita como parâmetro um array. Mas isso gera um inconveniente, digamos que você queira passar para o método apenas duas variáveis, então o código seria:
double x = 5.2, y = 3.2;
double temp[] = {x,y};
Vejam o inconveniente, ter que criar um array para empacotar as variáveis apenas para passagem de parâmetro de um método. Varargs é a solução para isso, vejam o método agora com a utilização de varargs:
public double sum(double... var)
Para mostrar que o parâmetro passado não tem quantidade limitada, usa-se varargs, onde você define com "tipo..." fica caracterizado. Agora o inconveniente de antes foi pro inferno. Testem o código abaixo para ver:
public class Test
{
public Teste()
{
double array[] = {1.5,2.1,3.4};
double x = 9.5, y = 2.5;
System.out.println(this.sum(x,y));
System.out.println(this.sum(array));
}
private double sum(double... var)
{
double soma = 0.0;
for(double k:var)
{
soma += k;
}
return soma;
}
public static void main(String args[])
{
new Test();
}
}
Enums
Uma enumeração é um tipo definido pelo usuário. Uma enumeração, introduzida pela palavra chave "enum" e seguida por um nome de tipo, é um conjunto de constantes representadas por identificadores. Os valores dessas constantes começam em 0, a menos que seja especificado de outra forma e são incrementados por 1.
Na verdade uma enumeração é definida na classe Enum que faz parte da classe java.lang, então pode-se estender dessa classe a vontade esta classe.
import java.util.*;
public class Teste
{
public enum Planet{MERCURY,VENUS,EARTH,MARS,JUPITER,SATURN,URANUS,NEPTUNE,PLUTO};
public Teste()
{
for(Planet planet:Planet.values())
{
System.out.print(planet.name() + " - ");
System.out.print(planet.ordinal() + "\n");
}
}
public static void main(String args[])
{
new Teste();
}
}
No exemplo acima MERCURY recebe o valor 0, VENUS o valor 1, EARTH o valor 2, etc.
Generic ArrayList
Em muitas linguagens de programação você tem que fixar o tamanho
de um array em tempo de compilação. Isso é problemático, uma vez que
você estipula um valor, mas muitas vezes esse valor ou é pequeno demais,
ocasionando um ArrayIndexOutOfBondsException em tempo de execução e se
for grande demais ocasiona a alocação desnecessária de memória.
A solução para isso era utilizar uma classe que se dimensionava com a
necessidade do programa, um array dinâmico. Essa é a classe Vector,
bem conhecida de de todos nós. Posteriormente criaram a classe ArrayList,
que é um grande melhoramento em relação a classe Vector. Mesmo assim
muitos programadores teimavam em continuar a utilizar a classe Vector.
Agora vou mostrar a classe ArrayList melhorada. A classe ArrayList
tornou-se genérica melhorando e muito nossa vida como programador, uma
vez que não será mais necessário fazer algum cast para capturar algum
objeto. Como no exemplo abaixo:
Integer k = (Integer) vector.get(5);
Com ArrayList esse inconveniente deixa de existir:
Integer k = arraylist.get(5);
Abaixo mostro a declaração de um ArrayList contendo objetos Integer:
ArrayList<Integer> array = new ArrayList<Integer>();
Ou então, determinar no construtor a capacidade inicial de ArrayList:
ArrayList<Integer> array = new ArrayList<Integer>(100);
Pode-se também inicializar ArrayList como uma classe ordinária (não genérica), em que o tipo de parâmetro interno seria Objetct:
ArrayList array = new ArrayList();
Formatter
Você já viu na seção anterior a função printf() incorporada ao pacote System.out, que cria formatação de saída para o terminal. Digamos que você precise dessa função para mandar uma saída formatada para um JTextArea. A solução é a classe Formatter, incorporada ao pacote java.util de Java.
Concurrency
Novos pacotes de tratamento de Threads foram introduzidos em Java. Eles fazem parte do novo pacote de API o java.util.concurrent, java.util.concurrent.atomic e java.util.concurrent.locks, que dentre outras coisas contém sincronizadores, bloqueadores, inclusão de pools de threads, variáveis atômicas, utilitários para sincronização, etc. Enfim, as mudanças na programação paralela em Java sofreram grandes mudanças e tornaram a linguagem perfeita para se utilizar Threads.
AWT
A melhor novidade do pacote AWT foi a adição da nova classe MouseInfo. Com ela é possível determinar a localização do ponteiro do mouse no desktop. Também foi adicionada a classe PointerInfo que descreve as coordenadas e associa com o objeto GraphicsDevice no momento em que PointerInfo é instanciado.
Monitoring and Management
O update de J2SE provê APIs de monitoração e gerenciamento para a plataforma Java que fazem parte do pacote java.lang.management e mais algumas novas ferramentas.