Explicação sobre manipulação de data:


A manipulação de data e hora são frequentemente usadas nos aplicativos de banco de dados. A operação de conversão e formatação são fundamentais para tais programas.

A conversão consiste na transformação de um texto em um objeto capaz de encapsular uma data, um horário ou ambos. Geralmente depois da entrada dos dados e gravados em uma string.

A formatação consiste na transformação de um objeto que representa uma data, um horário ou ambos em um texto. Faz uso das classes java.util.Date e java.text.DateFormat, para formatar os vários tipos de valores numéricos, pode-se usar as classes java.text.NumberFormat e java.text.DecimatFormat.

A classe java.util.Date mede o tempo através de um número inteiro longo em milissegundo transcorrido a partir de um instante de referência. Este instante de referência é o marco inicial que esta classe utiliza para a contagem do tempo e sobre o qual é somado o número supracidado para inferir qual é o instante representado por um objeto desta classe. Esta contagem se inicia no 01/01/1970 no seguinte horário: 00:00:00:0000. Note que este horário é composto por horas, minutos, segundos e milissegundos e que todos os dígitos estão zerados. Isso significa que a contagem se inicia no primeiro instante do dia 01/01/1970.

A terra está dividida em 24 diferentes fusos horários. A contagem supracitada refere-se ao fuso horário que é tomado como marcador oficial de tempo, que é o GMT. Este é o acrônimo para Greenwich Mean Time e que significa a Hora Média de Greenwich. Trata-se do fuso horário das regiões que se encontram no meridiano de Greenwich. As regiões que se encontram a oeste deste fuso horário utilizam um fuso horário negativo e as que se encontram a leste dele utilizam um fuso horário positivo.


O Brasil se encontra a oeste do meridiano de Greenwich e, tendo em vista a sua grande extensão longitudinal, utiliza três diferentes fusos horários. O primeiro fuso horário tem duas horas a menos que o fuso horário de Greenwich, o segundo fuso horário tem três horas a menos e o terceiro fuso horário tem quatro horas a menos. Os fusos horários são representados utilizando o acrônimo GMT seguido do número de horas de diferença em relação ao fuso horário de Greenwich. Assim os fusos horários brasileiros são representados da seguinte forma: GMT -02:00, GMT -03:00 (Brasília) e GMT -04:00.

A classe Date tem dois construtores, o Date( ), sem parâmetro, pode ser empregado para criar uma instncia desta classe que representa o instante atual. Êsse construtor obtém a data e o horário do sistema operacional da máquina em que esta instrução tiver sido executada. Com parâmetro, essa classe cria uma instância desta mesma classe que representa o instante que ela utiliza como marco inicial para contagem do tempo.

1. Data e hora com  java.util

1.1. Declaração de variável do tipo data:

java.util.Date data;

1.2. Declaração de variável do tipo data com import:

import java.util.*;

...

Date data;

1.3. Atribuição de valor em data (criação de objeto):

O objeto data do tipo Date receberá a Data/Hora do relógio do computador. 

Exemplo 1:

import java.util.Date;

public class Data1 {

    public static void main(String[] args) {

        Date data = new Date();

        System.out.println(data);

    }

}

Execução do programa:

run:

Sat Feb 23 10:23:08 BRT 2013

Obs: esta é a data da execução do exemplo acima.

Exemplo 2:

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.GregorianCalendar;
import javax.swing.JOptionPane;

public class Data2 {
    public static void main (String [] args){
        GregorianCalendar calendario =new GregorianCalendar();
        SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
        String data = sdf.format(calendario.getTime());
        exiba(data);    
       
    }
        private static void exiba(String msg) {
        JOptionPane.showMessageDialog(null, msg);
        }
}

Execução do programa:


Exemplo 3:

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import javax.swing.JOptionPane;

public class Data3 {
    public static void main (String [] args){

        GregorianCalendar calendario =new GregorianCalendar();
        SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
        String data = sdf.format(calendario.getTime());
        exiba(data);
        new Data3().calcularIdade();
    }

        private static void exiba(String msg) {
        JOptionPane.showMessageDialog(null, msg);
        }
       
        int calcularIdade (){
            GregorianCalendar atual= new GregorianCalendar();
            GregorianCalendar dataNasc = new GregorianCalendar();
            String dataNascStr = leia();
            int dia =Integer.parseInt(dataNascStr.substring(0,2));
            int mes =Integer.parseInt(dataNascStr.substring(3,5));
            int ano =Integer.parseInt(dataNascStr.substring(6,10));
            dataNasc.set(Calendar.DAY_OF_MONTH, dia);
            dataNasc.set(Calendar.MONTH, mes+1);
            dataNasc.set(Calendar.YEAR, ano);
            long diff=atual.getTimeInMillis()-dataNasc.getTimeInMillis();
           
            double anos = diff/(1000*60*60*24*365.6);
            int anoInt=(int) anos;
            exiba(anoInt+"");
            return anoInt;  
        }
              
         private static String leia() {
        String valorDigitado = JOptionPane.showInputDialog("digite o valor");
       
        return valorDigitado;       
    }  
}

Execução do programa:


Observe que a data atual é 23/02/2013, quando foi executado esse exemplo, clicando em Ok para dar continuidade na execução.

Exemplo 4:

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import javax.swing.JOptionPane;

public class Data4 {
    public static void main (String [] args){
        GregorianCalendar calendario =new GregorianCalendar();
        SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
        String data = sdf.format(calendario.getTime());
        exiba(data);
        new Data4().calcularIdade();
    }
        private static void exiba(String msg) {
        JOptionPane.showMessageDialog(null, msg);
        }
       
        int calcularIdade (){
           try{
            GregorianCalendar atual= new GregorianCalendar();
           
            String dataNascStr = leia();
            Date dataNascimento=new SimpleDateFormat("dd/MM/yyyy").parse(dataNascStr);
           
            long diff = atual.getTime().getTime()- dataNascimento.getTime();
                     
           
            double anos = diff/(1000*60*60*24*365.6);
            int anoInt=(int) anos;
            exiba(anoInt+"");
            return anoInt;
           } catch (ParseException ex){
               exiba(ex.getMessage());
           }
           
            return 0;
        }
       
         private static String leia() {
        String valorDigitado = JOptionPane.showInputDialog("digite o valor");
       
        return valorDigitado;       
    }    
}





2. A tabela abaixo relaciona os pacotes e classes para manipulação de datas e horas até a versão 6 do Java.

Pacote
Classes
java.util Date, Calendar, GregorianCalendear, TimeZone, SimpleTimeZone
java.text DateFormat, SimpleDateFormat, FormatSymbols
java.sql Date, Time, Timestamp

A classe Date pertence a dois pacotes diferentes, (util e sql), com características e comportamento diferentes em cada um.

Date, do pacote util, representa um instante no tempo, sem levar em consideração sua representação ou localização geográfica, com precisão de milissegundos.

DateFormat, representa uma data com formato String de acordo com um determinado fuso horário e calendário.

SimpleDateFormat, permite a especificação de diferentes formatos para data.

Calendar, representa um instante no tempo de acordo com um sistema particular de  calendário e fuso horário.

Para declarar e inicializar um objeto do tipo data, a sintaxe pode ser:


NomeClasse nomeObjeto = new Data();

Para a classe Date fica assim:

Date minhaData = new Date();

O compilador compreende que MinhaData será um objeto declarado a partir da classe Date, minhaData será iniciada com data e hora atuais do sistema, requer o uso de import.java.util.Date.

Exemplo:

Date data = new Date();
JoptionPane.showMessegeDialog(null,data);

A classe Date representa um instante no tempo. Esse processo é realizado pelo método getTime. Para marcar o tempo, é considerado o número de milissegundos decorridos deste 1º de janeiro de 1970. Cada segundo possui 1.000 milissegundo, cada minuto possui 60 segundos, cada hora possui 60 minutos e cada dia possui 24 horas. Para saber o correspondente em dias, basta multiplicar 1.000 x 60 x 24, ou seja, cada dia corresponde a 86.400.000 milissegundos. Quando um objeto do tipo Date é criado, o número de milissegundo decorridos desde 1970 é armazenado no objeto e pode ser retornado pelo método getTime, que retorna um inteiro do tipo long que permite representar milissegundos decorridos por milhares de anos. O uso de getTime torna possível realizar o cálculo entre datas, bastando calcular a diferença entre os milissegundos

A classe Date não fornece um mecanismo de controle sobre a formatação de uma data e não permite converter uma string com informações sobre uma data em um objeto Date. Essas funções cabem à classe DateFormate que permite apresentar a data com diferentes formatações, dependendo das necessidades de utilização, tornando sua visualização mais agradável aos usuários. Diferentes países e usuários preferem visualizar a data com formatos diferentes. Um usuário norte-americano pode preferir ver January 03, 2013

Para obter a data atual se basta criar um objeto Date sem nenhum parâmetro: Date d = new Date();


Calendar(java.util.Calendar)


A classe Calendar sendo uma classe abstrata não pode ser instanciada com o operador new, ela deve ser criada utilizando um operador estático sobrecarregado getInstance(). Na maioria das vezes você vai receber uma instância de Java.util.GregorianCalendar.

Calendar c = Calendar.getIntance();

Com a instância de Calendar devemos configurar uma data e podemos fazer isso de duas formas:

Métodos set

c.set(ano,mes,dia);
c.set(ano,mês,dia,hora,minuto);
c.set(ano,mês,dia,hora,minuto,segundo);

Método setTime

c.setTime(new Date() );

A classe Calendar fornece várias constantes para manipulação de suas data.

Com a data devidamente configurada pode-se realizar diversas operações com a data:

Para adicionar ou subtrair um dia, hora, mês ou ano utilizamos o método add. O método add aceita dois parâmetros, sendo o primeiro um constante inteira que representa a unidade da data que queremos modificar(dia, mês , ano, etc…) e o segundo quantas vezes será adicionada/subtraída esta unidade.

A unidade é informada utilizando constantes fornecidas pela classe Calendar que pode ser:
Dia:
Calendar.DAY_OF_MONTH
Calendar.DAY_OF_WEEK
Calendar.DAY_OF_YEAR

Mês: Calendar c = Calendar.getIntance();
Calendar.MONTH

Ano: 
Calendar.YEAR

Hora:
Calendar.HOUR
Calendar.HOUR_OF_DAY

Segundos:
Calendar.SECOND

Exemplos:

   
Date d= new Date();
Calendar c = Calendar.getInstance();
c.add(Calendar.DAY_OF_YEAR,5 );//adicionamos 5 dias a data aual
c.add(Calendar.MONTH,3 );//adicionamos 3 mêses a data atual
c.add(Calendar.YEAR,1 );//adicionamos 1 ano a data atual
DateFormat(java.text.DateFormat)

A classe DateFormat nos fornece uma maneira simples de formar data e permite a internacionalização a partir da classe Locale.

   
Date d = new Date();
Calendar c = Calendar.getInstance();
c.setTime(d);
 
DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT);
System.out.println( df.format(c.getTime()) );

Para obtermos uma String da data utilizamos o método format que retorna uma String no formato especificado no método getDateInstance(). A saída do exemplo acima será algo como 03/04/10.

A classe DateForma fornece vários tipos de formato para data como:

Dateformat.SHORT: 03/04/10
Dateformat.MEDIUM: 03/04/2010
Dateformat.LONG: 3 de Abril de 2010
Dateformat.FULL: Sábado, 3 de Abril de 2010

Algumas vezes necessita-se de uma formato personalizado. Isso pode ser feio através de subclasse SimpleDateFormat da classe DateFormat.

Date hoje  = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
System.out.println( sdf.format(hoje));

O construtor de SimpleDateFormat recebe uma String que representa o formato da data. Os símbolos utilizados para cada campo da data pode ser visto na tabela abaixo abaixo:


Caractere
Descrição
Formato
Exemplo
G designator de era Texto
AD
y
ano
Year
2013
M
mês do ano
Moth
Jun; 02
w
semana do ano
Number
15
W
semana do mês
Number
3
D
dia do ano
Number
152
d
dia do mês
Number
10
F
dia da semana no mês
Number
3
E
dia da semana
Text
Monday
a
am/pm
Text
PM
H
hora do dia (0 - 23)
Number
2
k
hora do dia (1 - 24)
Number
15
K
hara em am/pm (0 - 11)
Number
3
h
hora em am/pm (1 - 12)
Number
7
m
minuto da hora
Number
21
s
segundos do minuto
Number
43
S
milissegundos
Number
450
z
fuso horário
Text
BRST


Utilizar-se a internacionalização com a classe Locate que recebe em seu construtor a língua e o país que se quer utilizar:

Locale brasil = new Locale("pt","br");//portugues do brasil

Locale japao = new Locale("ja");// japao

O objeto locale de Locale pode ser utilizado tanto com a classe DateFormat quanto com a classe SimpleDateFormat.


Novo exemplo:

import java.awt.event.*;
import javax.swing.*;
import java.util.Date;

public class Data5 extends JFrame {
    private JTextArea taTexto;
    private JButton btMostrar;
    private Date agora;
    final long MILI_SEGUNDOS_POR_DIA = 1000 * 60 * 60 * 24;

    public static void main(String[] args) {
        JFrame janela = new Data5();
        janela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        janela.setVisible(true);
    }
   
    public Data5(){
        inicializarComponentes();
        definirEventos();
    }

    public void inicializarComponentes() {
        setTitle("Manipulação de Datas e Horas");
        setBounds(100,100,300,200);
        taTexto = new JTextArea();
        btMostrar = new JButton("Mostrar");
        add(taTexto,"Center");
        add(btMostrar,"North");
        agora = new Date();
    }

    public void definirEventos() {
       btMostrar.addActionListener(new ActionListener() {
           public void actionPerformed(ActionEvent e) {
                long tempo = agora.getTime();
                Date novaData = new Date(agora.getTime() + (MILI_SEGUNDOS_POR_DIA * 10));
                taTexto.setText("Milisegundos desde 1970: " + tempo +
                  "\nDias: "  + tempo / MILI_SEGUNDOS_POR_DIA +
                  "\nMeses: " + tempo / MILI_SEGUNDOS_POR_DIA / 30 +
                  "\nAnos: "  + tempo / MILI_SEGUNDOS_POR_DIA / 365 +
                  "\nData: " + novaData);
            }
       });
    }
}

Execução do programa:


Novo exemplo:

import java.awt.event.*;
import javax.swing.*;
import java.util.Date;
import java.text.DateFormat;
public class Data6 extends JFrame {
    private JTextArea taTexto;
    private JButton btMostrar;
    private Date agora;
    final long MILI_SEGUNDOS_POR_DIA = 1000 * 60 * 60 * 24;

    public static void main(String[] args) {
        JFrame janela = new Data6();
        janela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        janela.setVisible(true);
    }
   
    public Data6(){
        inicializarComponentes();
        definirEventos();
    }

    public void inicializarComponentes() {
        setTitle("Manipulação de Datas e Horas");
        setBounds(100,100,300,200);
        taTexto = new JTextArea();
        btMostrar = new JButton("Mostrar");
        add(taTexto,"Center");
        add(btMostrar,"North");
        agora = new Date();
    }

    public void definirEventos() {
       btMostrar.addActionListener(new ActionListener() {
          public void actionPerformed(ActionEvent e) {
                  DateFormat dateFormat = DateFormat.getDateInstance(DateFormat.MEDIUM);
                  taTexto.setText("Data Normal: " + agora +
                    "\nData Formatada: "  + dateFormat.format(agora));
            }
        });
    }
}


Execução:


Novo exemplo:

import java.awt.event.*;
import javax.swing.*;
import java.util.Date;
import java.text.DateFormat;
import java.text.SimpleDateFormat;

public class Data7 extends JFrame {
    private JTextArea taTexto;
    private JButton btMostrar;
    private Date agora;
    final long MILI_SEGUNDOS_POR_DIA = 1000 * 60 * 60 * 24;

    public static void main(String[] args) {
        JFrame janela = new Data7();
        janela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        janela.setVisible(true);
    }
    
    public Data7(){
        inicializarComponentes();
        definirEventos();
    }

    public void inicializarComponentes() {
        setTitle("Manipulação de Datas e Horas");
        setBounds(100,100,300,200);
        taTexto = new JTextArea();
        btMostrar = new JButton("Mostrar");
        add(taTexto,"Center");
        add(btMostrar,"North");
        agora = new Date();
    }

    public void definirEventos() {
       btMostrar.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                  String formato = "dd/MM/yyyy, hh:mm:ss";
                  DateFormat dateFormat =  new SimpleDateFormat(formato);
                  taTexto.setText("Data Normal: " + agora +
                    "\nData Formatada: "  + dateFormat.format(agora));
            }
        });
    }
}

Execução:


Novo exemplo:

import java.awt.event.*;
import javax.swing.*;
import java.util.Date;
import java.util.Calendar;
public class Data8 extends JFrame {
    private JTextArea taTexto;
    private JButton btMostrar;
    private Date agora;
    final long MILI_SEGUNDOS_POR_DIA = 1000 * 60 * 60 * 24;

    public static void main(String[] args) {
        JFrame janela = new Data8();
        janela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        janela.setVisible(true);
    }
   
    public Data8(){
        inicializarComponentes();
        definirEventos();
    }

    public void inicializarComponentes() {
        setTitle("Manipulação de Datas e Horas");
        setBounds(100,100,300,200);
        taTexto = new JTextArea();
        btMostrar = new JButton("Mostrar");
        add(taTexto,"Center");
        add(btMostrar,"North");
        agora = new Date();
    }

    public void definirEventos() {
       btMostrar.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                Calendar calendario = Calendar.getInstance();
                calendario.setTime(agora);
                int dia = calendario.get(Calendar.DATE);
                int mes = calendario.get(Calendar.MONTH);
                int ano = calendario.get(Calendar.YEAR);
                int hora = calendario.get(Calendar.HOUR_OF_DAY);
                int minuto = calendario.get(Calendar.MINUTE);
                int segundo = calendario.get(Calendar.SECOND);
                int diaDaSemana = calendario.get(Calendar.DAY_OF_WEEK);
                String semana = "";
                if (diaDaSemana == Calendar.SATURDAY || diaDaSemana == Calendar.SUNDAY)
                    semana = "Fim de Semana";
                else
                    semana = "Dia util";
                taTexto.setText("Dia = " + dia +
                  "\nMes = " + mes +
                  "\nAno = " + ano +
                  "\nHora = " + hora +
                  "\nMinuto = " + minuto +
                  "\nSegundo = " + segundo +
                  "\nDia da semana = " + diaDaSemana +
                  "\n" + semana
                );
            }
        });
    }
}

Execução:


Novo exemplo:

import java.awt.event.*;
import javax.swing.*;
import java.util.Date;
import java.text.DateFormat;
import java.util.Calendar;
public class Data9 extends JFrame {
    private JTextArea taTexto;
    private JButton btMostrar;
    private Date agora;
    final long MILI_SEGUNDOS_POR_DIA = 1000 * 60 * 60 * 24;

    public static void main(String[] args) {
        JFrame janela = new Data9();
        janela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        janela.setVisible(true);
    }
    
    public Data9(){
        inicializarComponentes();
        definirEventos();
    }

    public void inicializarComponentes() {
        setTitle("Manipulação de Datas e Horas");
        setBounds(100,100,300,200);
        taTexto = new JTextArea();
        btMostrar = new JButton("Mostrar");
        add(taTexto,"Center");
        add(btMostrar,"North");
        agora = new Date();
    }

    public void definirEventos() {
       btMostrar.addActionListener(new ActionListener() {

           public void actionPerformed(ActionEvent e) {
                DateFormat df = DateFormat.getDateInstance(DateFormat.MEDIUM);
                Calendar calendario = Calendar.getInstance();
                calendario.setTime(agora);
                int hora = calendario.get(Calendar.HOUR_OF_DAY);
                int minuto = calendario.get(Calendar.MINUTE);
                int segundo = calendario.get(Calendar.SECOND);
                String men = "Boa Noite!";
                if(hora<6) men = "Boa Madrugada!";
                else if(hora<12) men = "Bom Dia!";
                      else if(hora<18) men = "Boa Tarde!";
                taTexto.setText("Data Atual " + df.format(agora) +
                  "\nHora atual " + hora + "h:" + minuto + "m:" + segundo + "s" +
                  "\n" + men
                );
            }
        });
    }

Execução:


Novo exemplo:

import java.awt.event.*;
import javax.swing.*;
import java.util.Date;
import java.text.DateFormat;
import java.util.Calendar;
import java.text.ParseException;
public class Data10 extends JFrame {
    private JTextArea taTexto;
    private JButton btMostrar;
    private Date agora;
    final long MILI_SEGUNDOS_POR_DIA = 1000 * 60 * 60 * 24;

    public static void main(String[] args) {
        JFrame janela = new Data10();
        janela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        janela.setVisible(true);
    }

    public Data10() {
        inicializarComponentes();
        definirEventos();
    }

    public void inicializarComponentes() {
        setTitle("Manipulação de Datas e Horas");
        setBounds(100, 100, 300, 200);
        taTexto = new JTextArea();
        btMostrar = new JButton("Mostrar");
        add(taTexto, "Center");
        add(btMostrar, "North");
        agora = new Date();
    }

    public void definirEventos() {
        btMostrar.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {
                DateFormat df = DateFormat.getDateInstance(DateFormat.MEDIUM);
                Calendar calendario1 = Calendar.getInstance();
                Calendar calendario2 = Calendar.getInstance();
                Calendar calendario3 = Calendar.getInstance();
                Calendar calendario4 = Calendar.getInstance();
                try {
                    Date data1 = df.parse("01/01/2010"); // pode gerar erro (ParseException)
                    calendario1.setTime(data1);
                    Date data2 = df.parse("01/03/2010");
                    calendario2.setTime(data2);
                    long diaData1 = calendario1.getTimeInMillis();
                    long diaData2 = calendario2.getTimeInMillis();
                    long dif = (diaData2 - diaData1) / MILI_SEGUNDOS_POR_DIA;
                    calendario2.add(Calendar.DAY_OF_YEAR,30);
                    Date trinta = calendario2.getTime();
                    Date data3 = df.parse("31/12/2009");
                    calendario3.setTime(data3);
                    calendario4.setTime(data3);
                    calendario3.add(Calendar.DAY_OF_YEAR,1);
                    calendario4.roll(Calendar.DAY_OF_YEAR,1);
                    Date dia1 = calendario3.getTime();
                    Date dia2 = calendario4.getTime();                    
                    taTexto.setText("Data 1 = " + df.format(data1) +
                        "\nData 2 = " + df.format(data2) +
                        "\nDiferenca de dias = " + (dif) +
                        "\n30 dias apos Data 2   = " + df.format(trinta) +
                        "\nDia primeiro com add  = " + df.format(dia1) +
                        "\nDia primeiro com roll = " + df.format(dia2)  
                    );                    
                } catch (ParseException erro) {
                    JOptionPane.showMessageDialog(null, "Data Invalida " + erro.getErrorOffset());
                }
            }
        });
    }
}

Execução:



Java Time: API já está disponível no Java 8

A implementação de referência da JSR 310 (API Date and Time), denominada ThreeTen, foi inserida no JDK 8 Early Access b75 sob o pacote java.time, diferentemente das versões anteriores, em que ficava no pacote javax.time. O rascunho do Javadoc da API também foi disponibilizado.

Todas as classes da API Java Time são imutáveis e thread-safe. Além disso, são baseadas na norma ISO 8601, o calendário internacional segundo as regras Gregorianas. Outros sistemas de calendário também são suportados pelos pacotes java.time.calendar e java.time.temporal. Além das classes para data e hora, a API também fornece classes para relógios, períodos e intervalos de tempo, e enumerações para meses e dias da semana.

Há muitas classes na API Java Time, mas a maioria das aplicações podem iniciar com os seguintes tipos de data/hora:

Instant
    É um timestamp numérico armazenado com precisão de nanossegundos. Útil para capturar um instante no tempo, similar ao método System.currentTimeMillis(). A classe Instant é a mais próxima em equivalência à classe java.util.Date. Quando impreso, um instante assemelha-se a '2000-12-01T12:30:00.000Z'.
LocalDate
    Representa uma data sem hora ou fuso horário. Útil, por exemplo, para armazenar datas como a de um aniversário. Quando impressa, uma data assemelha-se a '2000-12-01'.
LocalTime
    Representa um horário sem data ou fuso horário. Um exemplo de utilização é o armazenamento de horários de lojas. Quando impresso, um horário assemelha-se a '12:30:00.000'.
LocalDateTime
    Representa uma data e hora sem o fuso horário. A impressão de uma data/hora assemelha-se a '2000-12-01T12:30:00.000'.
ZonedDateTime
    Representa uma data e hora com o fuso horário. Útil para realizar cálculos que levam em consideração o fuso horário, como 'America/New_York'. A classe ZonedDateTime é a mais próxima em equivalência à classe java.util.GregorianCalendar. A impressão de uma data/hora assemelha-se a '2000-12-01T12:30:00.000-05:00[America/New_York]'.

Sempre que possível, é recomendável utilizar classes mais simples e sem fuso horário para modelar os objetos de domínio, como LocalDate, LocalTime e LocalDateTime. O uso generalizado de fusos horários pode adicionar uma complexidade considerável a uma aplicação. Muitas aplicações podem utilizar classes mais simples e adicionar o fuso horário somente na camada de apresentação.

Outras classes notáveis na API Java Time são:

Clock
    Um clock fornece acesso ao instante corrente, data e hora, usando um fuso horário. Pode ser utilizado no lugar dos métodos System.currentTimeMillis() e TimeZone.getDefault(). Embora todas as principais classes de data e hora tenham um metódo de fábrica denominado now(), que utiliza o relógio do sistema, o principal objetivo desta abstração é permitir que relógios alternativos sejam injetados, o que simplifica bastante os testes.
Duration
    Representa uma duração entre dois instantes na linha do tempo, armazenada com a precisão de nanossegundos. Esta classe modela uma duração de tempo sem estar ligada a qualquer instante. O modelo é direcionado, significando que a duração pode ser negativa. Na impressão, uma duração assemelha-se a 'PT3600S'.
Period
    Representa um período de tempo expresso em unidades que fazem sentido aos humanos, como '1 ano, 2 meses e 3 dias'. O modelo é direcionado, significando que partes individuais do período podem ser negativas. A impressão de um período é semelhante a 'P1Y2M3D'.
ZoneId
    Representa um identificador de fuso horário (área), como America/New_York.
ZoneOffset
    Representa a diferença de horário a partir do meridiano de Greenwich/UTC. Como, por exemplo, +02:00.

O pacote java.time.zone fornece suporte a fusos horários, suas regras e as lacunas ou sobreposições na linha do tempo local, causadas tipicamente pelos períodos de Horário de Verão. Há também o pacote java.time.format para impressão e parsing de objetos do tipo data/hora (embora na maioria dos casos os métodos toString() e parse() dessas classes sejam suficientes). O pacote java.time.temporal fornece acesso à data e hora através do uso de campos e unidades, além de classes adicionais para as subpartes mais importantes de uma data, e suporte base para calendários que não atendam aos padrões ISO. Fornece também funcionalidades adicionais para os casos mais avançados.

Os usuários que quiserem testar a nova API Java Time, podem baixar o JDK 8 b75 e utilizar o Javadoc como guia. Se quiserem também uma IDE com suporte ao JDK

Exemplo:

import java.awt.event.*;
import javax.swing.*;
import javax.time.calendar.*;
public class Data12 extends JFrame {
    private JTextArea taTexto;
    private JButton btMostrar;

    public static void main(String[] args) {
        JFrame janela = new Data12();
        janela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        janela.setVisible(true);
    }

    public Data12() {
        inicializarComponentes();
        definirEventos();
    }

    public void inicializarComponentes() {
        setTitle("Manipulação de Datas e Horas");
        setBounds(100, 100, 300, 200);
        taTexto = new JTextArea();
        btMostrar = new JButton("Mostrar");
        add(taTexto, "Center");
        add(btMostrar, "North");
    }

    public void definirEventos() {
        btMostrar.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {
                LocalDate data = LocalDate.date(2010, 2, 1);
                LocalTime hora = LocalTime.time(21, 29, 40);
                taTexto.setText("Data = " + data + "\n20 dias depois = " + data.plusDays(20) +
                     "\nHora = " + hora + "\n10 minutos depois = " + hora.plusMinutes(10) +
                     "\nMes = " + data.getMonthOfYear().getValue() +
                     "\n15 meses depois = " + data.plusMonths(15));
            }
        });
    }