matriz de fechas en Java

Question

sé cómo crear una matriz de cadenas o enteros, pero ¿cómo se puede crear una serie de fechas:/

Answer 1

De la misma manera lo hace para Cuerdas y Int, que acaba de colocar diferentes tipos inside:

Date [] dates = { 
    new Date(), 
    new Date() 
}; 

Se declaró una matriz de tamaño dos con dos fechas.

También puede inicializar con valores nulos:

Date [] dates = new Date[2]; 

o añadir valores más significativos:

Date [] dates = { 
    getDateFromString("25/11/2009"), 
    getDateFromString("24/12/2009") 
}; 

.... 
public Date getDateFromString(String s) { 
    Date result = ...// parse the string set the value etc. 
    return result; 
} 

EDIT

... pero de todos modos hay que puede terminar lo que estaba haciendo en el método getDateFromString?

Claro, no lo hice inicialmente porque mi punto era mostrar, que podía poner cualquier cosa del tipo "Fecha" allí.

sólo hay que utilizar el SimpleDateFormate.parse() método (heredado de DateFormat clase)

simpleDateFormatInstance.parse("24/12/2009"); // returns christmas 2009. 

He aquí una muestra de trabajo completo:

import java.text.SimpleDateFormat; 
import java.text.ParseException; 
import java.util.Date; 
import static java.lang.System.out; 

public class DateArrayTest { 

    private static final SimpleDateFormat dateFormat 
        = new SimpleDateFormat("dd/MM/yyyy"); 
    private static final Date invalidDate = new Date(0); 


    // test creating a date from a string. 
    public static void main(String [] args) { 
     Date [] randomDates = { 
      fromString("01/01/2010"), // new year 
      fromString("16/09/2010"), // 200 yrs Mex indepence 
      fromString("21/03/2010"), // uhhmm next spring? 
      fromString("this/should/fail"), // invalid date. 
     }; 

     for(Date date: randomDates) { 
      print(date); 
     } 
    } 

    /** 
    * Creates a date from the given string spec. 
    * The date format must be dd/MM/yyyy ie. 
    * 24 december 2009 would be: 24/12/2009 
    * @return invalidDate if the format is invalid. 
    */ 
    private static final Date fromString(String spec) { 
     try { 
      return dateFormat.parse(spec); 
     } catch(ParseException dfe) { 
      return invalidDate; 
     } 
    } 
    private static final void print(Date date) { 
     if(date == invalidDate) { 
      out.println("Invalid date"); 
     } else { 
      out.println(dateFormat.format(date)); 
     } 
    } 
} 

Answer 2

puede utilizar una gran variedad de java.util.Date (documentos de la API son here)

Date[] dates = new Date[] { 
    new Date(), 
    new Date(), 
}; 

Puedes crear comió una matriz de cualquier tipo de objeto en java - toda referencia y tipo primitivo

Answer 3

O puede utilizar la API y el calendario de clases Colecciones,

import java.util.*; 

List<Calendar> dates = new ArrayList<Calendar>(5); // initial size 
dates.add(Calendar.getInstance()); 

Answer 4

Puede tener en cuenta (y esto no es la realidad, pero en cierto modo de obras de esta manera) que las primitivas son algo como esto (me hago realidad más adelante ... así que sigue leyendo):

int.7, int.42 (no compilará) donde int es una clase (no lo es) y 7 y 42 son variables finales estáticas públicas (no lo son).

y que las cadenas son algo como esto:.

cadena "Hola", String "mundo" (no se compilará) Donde cadena es una clase (es) y "Hola" y "mundo". son variables finales estáticas públicas (no lo son).

Si mi falsa realidad fuera cierto que tendría que tener algo como:

// again, won't compile. 
public class int 
{ 
    public static final int 7 = new int(7); 
    public static final int 42 = new int(42); 
    private final ??? data; 

    public int(??? val) 
    { 
     data = val; 
    } 
} 

y

// also will not compile 
public class String 
{ 
    public final String "Hello" = new String("Hello); 
    public final String "world" = new String("world); 
    private final ??? data; 

    public String(final ??? val) 
    { 
     data = val; 
    } 
} 

ahora hacer una una matriz como (todavía no se compilará):

int[] array = new int[] { int.7, int.42 }; 
String[] array = new String[] {String."Hello", String."world" }; 

En el caso de String mi realidad alternativa sería muy tonta ya que es imposible para la clase String kno w de antemano cada cadena posible (para int es posible).

Así que se desharía de las variables static final públicas en cadena y hacer esto en su lugar:

String[] array = new String[] { new String("Hello"), new String("world") }; 

ahora a la realidad:

Cuando el compilador de Java, cuando se ve "Hola" o " world "hace algo similar a" new String ("Hello") "- es un poco más inteligente por lo que si tiene" Hello "20 veces en un archivo, solo hay una copia (y algunas otras cosas también).

Cuando dicen:

new int[100]; you get an array of 100 ints all set to 0. 
new String[100]; you get an array of 100 Strings all pointing to null. 
new Data[100]; you get 100 Dates all pointing to null. 

ya que la cadena y los Fecha apuntan a nulo es necesario asignar un nuevo objeto para cada uno. La razón por la que no tiene que decir "nuevo" con String es que el compilador trata especialmente. La razón por la que no tiene que decir "nuevo" con int es que es una primitiva en lugar de un objeto.

Por lo tanto, la respuesta fácil a su pregunta es, usted tiene que asignar una nueva fecha para cada elemento de la matriz :-)

Answer 5

Quizás quiso decir la introducción de una serie de dates.This código ayudaría ..

import java.text.ParseException; 
import java.text.SimpleDateFormat; 
import java.util.ArrayList; 
import java.util.Date; 
import java.util.Scanner; 

public class Datinput { 

    public static void main(String args[]) { 
     int n; 
     ArrayList<String> al = new ArrayList<String>(); 
     Scanner in = new Scanner(System.in); 
     n = in.nextInt(); 
     String da[] = new String[n]; 
     SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy"); 
     sdf.setLenient(false); 
     Date date[] = new Date[n]; 
     in.nextLine(); 
     for (int i = 0; i < da.length; i++) { 
      da[i] = in.nextLine(); 
     } 
     for (int i = 0; i < da.length; i++) { 

      try { 
       date[i] = sdf.parse(da[i]); 
      } catch (ParseException e) { 

       e.printStackTrace(); 
      } 
     } 

     in.close(); 
    } 
}