actualizar - Conversión de cadena Java hasta la fecha
java offline (13)
¿Cuál es la mejor manera de convertir una String en el formato ''2 de enero de 2010'' a una Date en Java?
En última instancia, quiero desglosar el mes, el día y el año como enteros para poder usar
Date date = new Date();
date.setMonth()..
date.setYear()..
date.setDay()..
date.setlong currentTime = date.getTime();
para convertir la fecha en hora.
Además, SimpleDateFormat no está disponible con algunas de las tecnologías del lado del cliente, como GWT .
Es una buena idea ir a Calendar.getInstance (), y su requisito es comparar dos fechas; ir para larga cita
Ah sí, la discusión de Java Date, de nuevo. Para lidiar con la manipulación de la fecha, usamos Date , Calendar , GregorianCalendar y SimpleDateFormat . Por ejemplo, usando tu fecha de enero como entrada:
Calendar mydate = new GregorianCalendar();
String mystring = "January 2, 2010";
Date thedate = new SimpleDateFormat("MMMM d, yyyy", Locale.ENGLISH).parse(mystring);
mydate.setTime(thedate);
//breakdown
System.out.println("mydate -> "+mydate);
System.out.println("year -> "+mydate.get(Calendar.YEAR));
System.out.println("month -> "+mydate.get(Calendar.MONTH));
System.out.println("dom -> "+mydate.get(Calendar.DAY_OF_MONTH));
System.out.println("dow -> "+mydate.get(Calendar.DAY_OF_WEEK));
System.out.println("hour -> "+mydate.get(Calendar.HOUR));
System.out.println("minute -> "+mydate.get(Calendar.MINUTE));
System.out.println("second -> "+mydate.get(Calendar.SECOND));
System.out.println("milli -> "+mydate.get(Calendar.MILLISECOND));
System.out.println("ampm -> "+mydate.get(Calendar.AM_PM));
System.out.println("hod -> "+mydate.get(Calendar.HOUR_OF_DAY));
Entonces puedes manipular eso con algo como:
Calendar now = Calendar.getInstance();
mydate.set(Calendar.YEAR,2009);
mydate.set(Calendar.MONTH,Calendar.FEBRUARY);
mydate.set(Calendar.DAY_OF_MONTH,25);
mydate.set(Calendar.HOUR_OF_DAY,now.get(Calendar.HOUR_OF_DAY));
mydate.set(Calendar.MINUTE,now.get(Calendar.MINUTE));
mydate.set(Calendar.SECOND,now.get(Calendar.SECOND));
// or with one statement
//mydate.set(2009, Calendar.FEBRUARY, 25, now.get(Calendar.HOUR_OF_DAY), now.get(Calendar.MINUTE), now.get(Calendar.SECOND));
System.out.println("mydate -> "+mydate);
System.out.println("year -> "+mydate.get(Calendar.YEAR));
System.out.println("month -> "+mydate.get(Calendar.MONTH));
System.out.println("dom -> "+mydate.get(Calendar.DAY_OF_MONTH));
System.out.println("dow -> "+mydate.get(Calendar.DAY_OF_WEEK));
System.out.println("hour -> "+mydate.get(Calendar.HOUR));
System.out.println("minute -> "+mydate.get(Calendar.MINUTE));
System.out.println("second -> "+mydate.get(Calendar.SECOND));
System.out.println("milli -> "+mydate.get(Calendar.MILLISECOND));
System.out.println("ampm -> "+mydate.get(Calendar.AM_PM));
System.out.println("hod -> "+mydate.get(Calendar.HOUR_OF_DAY));
Al tratar con la clase SimpleDateFormat, es importante recordar que Date no es seguro para subprocesos y que no puede compartir un solo objeto Date con varios subprocesos.
También hay una gran diferencia entre "m" y "M" donde el caso pequeño se usa por minutos y el caso capital se usa por mes. Lo mismo con "d" y "D". Esto puede causar errores sutiles que a menudo se pasan por alto. Consulte SimpleDateFormat o la Guía para convertir cadenas a fecha en Java para obtener más detalles.
Con Java 8 obtenemos una nueva API de fecha / hora ( JSR 310 ).
La siguiente forma se puede usar para analizar la fecha en Java 8 sin depender de JodaTime :
String str = "January 2, 2010";
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MMMM d, yyyy", Locale.ENGLISH);
LocalDate date = LocalDate.parse(str, formatter);
// access date fields
int year = date.getYear(); // 2010
int day = date.getDayOfMonth(); // 2
Month month = date.getMonth(); // JANUARY
int monthAsInt = month.getValue(); // 1
LocalDate es la clase estándar de Java 8 para representar una fecha (sin hora). Si desea analizar los valores que contienen información de fecha y hora, debe usar LocalDateTime . Para valores con zonas horarias use ZonedDateTime . Ambos proporcionan un método parse() similar a LocalDate :
LocalDateTime dateWithTime = LocalDateTime.parse(strWithDateAndTime, dateTimeFormatter);
ZonedDateTime zoned = ZonedDateTime.parse(strWithTimeZone, zoneFormatter);
La lista de caracteres de formato de DateTimeFormatter :
All letters ''A'' to ''Z'' and ''a'' to ''z'' are reserved as pattern letters.
The following pattern letters are defined:
Symbol Meaning Presentation Examples
------ ------- ------------ -------
G era text AD; Anno Domini; A
u year year 2004; 04
y year-of-era year 2004; 04
D day-of-year number 189
M/L month-of-year number/text 7; 07; Jul; July; J
d day-of-month number 10
Q/q quarter-of-year number/text 3; 03; Q3; 3rd quarter
Y week-based-year year 1996; 96
w week-of-week-based-year number 27
W week-of-month number 4
E day-of-week text Tue; Tuesday; T
e/c localized day-of-week number/text 2; 02; Tue; Tuesday; T
F week-of-month number 3
a am-pm-of-day text PM
h clock-hour-of-am-pm (1-12) number 12
K hour-of-am-pm (0-11) number 0
k clock-hour-of-am-pm (1-24) number 0
H hour-of-day (0-23) number 0
m minute-of-hour number 30
s second-of-minute number 55
S fraction-of-second fraction 978
A milli-of-day number 1234
n nano-of-second number 987654321
N nano-of-day number 1234000000
V time-zone ID zone-id America/Los_Angeles; Z; -08:30
z time-zone name zone-name Pacific Standard Time; PST
O localized zone-offset offset-O GMT+8; GMT+08:00; UTC-08:00;
X zone-offset ''Z'' for zero offset-X Z; -08; -0830; -08:30; -083015; -08:30:15;
x zone-offset offset-x +0000; -08; -0830; -08:30; -083015; -08:30:15;
Z zone-offset offset-Z +0000; -0800; -08:00;
Esa es la manera más difícil, y esos métodos java.util.Date setter han quedado en desuso desde Java 1.1 (1997). Simplemente formatee la fecha usando SimpleDateFormat usando un patrón de formato que coincida con la cadena de entrada .
En su caso específico de "2 de enero de 2010" como cadena de entrada:
- "Enero" es el mes de texto completo, así que usa el patrón
MMMMpara ello - "2" es el día corto del mes, así que usa el patrón
dpara ello. - "2010" es el año de 4 dígitos, así que usa el patrón
yyyypara ello.
String string = "January 2, 2010";
DateFormat format = new SimpleDateFormat("MMMM d, yyyy", Locale.ENGLISH);
Date date = format.parse(string);
System.out.println(date); // Sat Jan 02 00:00:00 GMT 2010
Note la importancia del argumento de Locale explícito. Si lo omite, utilizará la configuración regional predeterminada que no es necesariamente el inglés como se usa en el nombre del mes de la cadena de entrada. Si la configuración regional no coincide con la cadena de entrada, entonces obtendría confusamente una java.text.ParseException aunque el patrón de formato parezca válido.
Aquí hay un extracto de relevancia del javadoc , que enumera todos los patrones de formato disponibles:
Letter Date or Time Component Presentation Examples
------ ---------------------- ------------------ -------------------------------------
G Era designator Text AD
y Year Year 1996; 96
Y Week year Year 2009; 09
M/L Month in year Month July; Jul; 07
w Week in year Number 27
W Week in month Number 2
D Day in year Number 189
d Day in month Number 10
F Day of week in month Number 2
E Day in week Text Tuesday; Tue
u Day number of week Number 1
a Am/pm marker Text PM
H Hour in day (0-23) Number 0
k Hour in day (1-24) Number 24
K Hour in am/pm (0-11) Number 0
h Hour in am/pm (1-12) Number 12
m Minute in hour Number 30
s Second in minute Number 55
S Millisecond Number 978
z Time zone General time zone Pacific Standard Time; PST; GMT-08:00
Z Time zone RFC 822 time zone -0800
X Time zone ISO 8601 time zone -08; -0800; -08:00
Tenga en cuenta que los patrones distinguen entre mayúsculas y minúsculas y que los patrones basados en texto de cuatro o más caracteres representan la forma completa; de lo contrario, se utiliza una forma abreviada o abreviada, si está disponible. Así que, por ejemplo, MMMMM o más no es necesario.
Aquí hay algunos ejemplos de patrones válidos de SimpleDateFormat para analizar una cadena dada hasta la fecha:
Input string Pattern
------------------------------------ ----------------------------
2001.07.04 AD at 12:08:56 PDT yyyy.MM.dd G ''at'' HH:mm:ss z
Wed, Jul 4, ''01 EEE, MMM d, ''''yy
12:08 PM h:mm a
12 o''clock PM, Pacific Daylight Time hh ''o''''clock'' a, zzzz
0:08 PM, PDT K:mm a, z
02001.July.04 AD 12:08 PM yyyyy.MMMM.dd GGG hh:mm aaa
Wed, 4 Jul 2001 12:08:56 -0700 EEE, d MMM yyyy HH:mm:ss Z
010704120856-0700 yyMMddHHmmssZ
2001-07-04T12:08:56.235-0700 yyyy-MM-dd''T''HH:mm:ss.SSSZ
2001-07-04T12:08:56.235-07:00 yyyy-MM-dd''T''HH:mm:ss.SSSXXX
2001-W27-3 YYYY-''W''ww-u
Una nota importante es que SimpleDateFormat no es seguro para subprocesos. En otras palabras, nunca debe declararlo y asignarlo como una variable estática o de instancia y luego reutilizarlo desde diferentes métodos / subprocesos. Siempre debe crearlo nuevo dentro del alcance del método local.
Actualización de Java 8
Si está en Java 8 o más reciente, use DateTimeFormatter (también aquí, haga clic en el enlace para ver todos los formateadores predefinidos y los patrones de formato disponibles; el tutorial está disponible aquí ). Esta nueva API está inspirada en JodaTime .
String string = "January 2, 2010";
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MMMM d, yyyy", Locale.ENGLISH);
LocalDate date = LocalDate.parse(string, formatter);
System.out.println(date); // 2010-01-02
Nota: si su patrón de formato también contiene la parte de tiempo, use LocalDateTime#parse(text, formatter) lugar de LocalDate#parse(text, formatter) . Y, si su patrón de formato también contiene la zona horaria, use ZonedDateTime#parse(text, formatter) lugar.
Aquí hay un extracto de relevancia del DateTimeFormatter , que enumera todos los patrones de formato disponibles:
Symbol Meaning Presentation Examples
------ -------------------------- ------------ ----------------------------------------------
G era text AD; Anno Domini; A
u year year 2004; 04
y year-of-era year 2004; 04
D day-of-year number 189
M/L month-of-year number/text 7; 07; Jul; July; J
d day-of-month number 10
Q/q quarter-of-year number/text 3; 03; Q3; 3rd quarter
Y week-based-year year 1996; 96
w week-of-week-based-year number 27
W week-of-month number 4
E day-of-week text Tue; Tuesday; T
e/c localized day-of-week number/text 2; 02; Tue; Tuesday; T
F week-of-month number 3
a am-pm-of-day text PM
h clock-hour-of-am-pm (1-12) number 12
K hour-of-am-pm (0-11) number 0
k clock-hour-of-am-pm (1-24) number 0
H hour-of-day (0-23) number 0
m minute-of-hour number 30
s second-of-minute number 55
S fraction-of-second fraction 978
A milli-of-day number 1234
n nano-of-second number 987654321
N nano-of-day number 1234000000
V time-zone ID zone-id America/Los_Angeles; Z; -08:30
z time-zone name zone-name Pacific Standard Time; PST
O localized zone-offset offset-O GMT+8; GMT+08:00; UTC-08:00;
X zone-offset ''Z'' for zero offset-X Z; -08; -0830; -08:30; -083015; -08:30:15;
x zone-offset offset-x +0000; -08; -0830; -08:30; -083015; -08:30:15;
Z zone-offset offset-Z +0000; -0800; -08:00;
Tenga en cuenta que tiene varios formateadores predefinidos para los patrones más populares. Así que en lugar de, por ejemplo, DateTimeFormatter.ofPattern("EEE, d MMM yyyy HH:mm:ss Z", Locale.ENGLISH); , puede usar DateTimeFormatter.RFC_1123_DATE_TIME . Esto es posible porque, al contrario de SimpleDateFormat , son seguros para subprocesos. Por lo tanto, también puede definir su propio, si es necesario.
Para un formato de cadena de entrada en particular, no necesita usar un DateTimeFormatter explícito: una fecha estándar ISO 8601 , como 2016-09-26T17: 44: 57Z, se puede analizar directamente con LocalDateTime#parse(text) como ya usa ISO_LOCAL_DATE_TIME formateador ISO_LOCAL_DATE_TIME . De manera similar, LocalDate#parse(text) analiza una fecha ISO sin el componente de tiempo (ver ISO_LOCAL_DATE ), y ZonedDateTime#parse(text) analiza una fecha ISO con un desplazamiento y una zona horaria agregada (ver ISO_ZONED_DATE_TIME ).
Hemos utilizado dos formateadores simples:
- ¿Qué fecha de formato queremos?
- ¿Qué fecha de formato está realmente presente?
Analizamos el formato completo de fecha a hora:
date="2016-05-06 16:40:32";
public static String setDateParsing(String date) throws ParseException {
// This is the format date we want
DateFormat mSDF = new SimpleDateFormat("hh:mm a");
// This format date is actually present
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-mm-dd hh:mm");
return mSDF.format(formatter.parse(date));
}
Mi humilde programa de pruebas. Lo uso para jugar con el formateador y buscar fechas largas que encuentro en los archivos de registro (pero quién los ha puesto allí ...).
Mi programa de prueba:
package be.test.package.time;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.TimeZone;
public class TimeWork {
public static void main(String[] args) {
TimeZone timezone = TimeZone.getTimeZone("UTC");
List<Long> longs = new ArrayList<>();
List<String> strings = new ArrayList<>();
//Formatting a date needs a timezone - otherwise the date get formatted to your system time zone.
//Use 24h format HH. In 12h format hh can be in range 0-11, which makes 12 overflow to 0.
DateFormat formatter = new SimpleDateFormat("dd-MM-yyyy HH:mm:ss.SSS");
formatter.setTimeZone(timezone);
Date now = new Date();
//Test dates
strings.add(formatter.format(now));
strings.add("01-01-1970 00:00:00.000");
strings.add("01-01-1970 00:00:01.000");
strings.add("01-01-1970 00:01:00.000");
strings.add("01-01-1970 01:00:00.000");
strings.add("01-01-1970 10:00:00.000");
strings.add("01-01-1970 12:00:00.000");
strings.add("01-01-1970 24:00:00.000");
strings.add("02-01-1970 00:00:00.000");
strings.add("01-01-1971 00:00:00.000");
strings.add("01-01-2014 00:00:00.000");
strings.add("31-12-1969 23:59:59.000");
strings.add("31-12-1969 23:59:00.000");
strings.add("31-12-1969 23:00:00.000");
//Test data
longs.add(now.getTime());
longs.add(-1L);
longs.add(0L); //Long date presentation at - midnight 1/1/1970 UTC - The timezone is important!
longs.add(1L);
longs.add(1000L);
longs.add(60000L);
longs.add(3600000L);
longs.add(36000000L);
longs.add(43200000L);
longs.add(86400000L);
longs.add(31536000000L);
longs.add(1388534400000L);
longs.add(7260000L);
longs.add(1417706084037L);
longs.add(-7260000L);
System.out.println("===== String to long =====");
//Show the long value of the date
for (String string: strings) {
try {
Date date = formatter.parse(string);
System.out.println("Formated date : " + string + " = Long = " + date.getTime());
} catch (ParseException e) {
e.printStackTrace();
}
}
System.out.println("===== Long to String =====");
//Show the date behind the long
for (Long lo : longs) {
Date date = new Date(lo);
String string = formatter.format(date);
System.out.println("Formated date : " + string + " = Long = " + lo);
}
}
}
Resultados de la prueba:
===== String to long =====
Formated date : 05-12-2014 10:17:34.873 = Long = 1417774654873
Formated date : 01-01-1970 00:00:00.000 = Long = 0
Formated date : 01-01-1970 00:00:01.000 = Long = 1000
Formated date : 01-01-1970 00:01:00.000 = Long = 60000
Formated date : 01-01-1970 01:00:00.000 = Long = 3600000
Formated date : 01-01-1970 10:00:00.000 = Long = 36000000
Formated date : 01-01-1970 12:00:00.000 = Long = 43200000
Formated date : 01-01-1970 24:00:00.000 = Long = 86400000
Formated date : 02-01-1970 00:00:00.000 = Long = 86400000
Formated date : 01-01-1971 00:00:00.000 = Long = 31536000000
Formated date : 01-01-2014 00:00:00.000 = Long = 1388534400000
Formated date : 31-12-1969 23:59:59.000 = Long = -1000
Formated date : 31-12-1969 23:59:00.000 = Long = -60000
Formated date : 31-12-1969 23:00:00.000 = Long = -3600000
===== Long to String =====
Formated date : 05-12-2014 10:17:34.873 = Long = 1417774654873
Formated date : 31-12-1969 23:59:59.999 = Long = -1
Formated date : 01-01-1970 00:00:00.000 = Long = 0
Formated date : 01-01-1970 00:00:00.001 = Long = 1
Formated date : 01-01-1970 00:00:01.000 = Long = 1000
Formated date : 01-01-1970 00:01:00.000 = Long = 60000
Formated date : 01-01-1970 01:00:00.000 = Long = 3600000
Formated date : 01-01-1970 10:00:00.000 = Long = 36000000
Formated date : 01-01-1970 12:00:00.000 = Long = 43200000
Formated date : 02-01-1970 00:00:00.000 = Long = 86400000
Formated date : 01-01-1971 00:00:00.000 = Long = 31536000000
Formated date : 01-01-2014 00:00:00.000 = Long = 1388534400000
Formated date : 01-01-1970 02:01:00.000 = Long = 7260000
Formated date : 04-12-2014 15:14:44.037 = Long = 1417706084037
Formated date : 31-12-1969 21:59:00.000 = Long = -7260000
Para android
Calendar.getInstance (). GetTime () da
Thu Jul 26 15:54:13 GMT+05:30 2018
Utilizar
String oldDate = "Thu Jul 26 15:54:13 GMT+05:30 2018";
DateFormat format = new SimpleDateFormat("EEE LLL dd HH:mm:ss Z yyyy");
Date updateLast = format.parse(oldDate);
Prueba esto
String date = get_pump_data.getString("bond_end_date");
DateFormat format = new SimpleDateFormat("yyyy-MM-dd", Locale.ENGLISH);
Date datee = (Date)format.parse(date);
Puede usar SimpleDateformat para cambiar la cadena hasta la fecha
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
String strDate = "2000-01-01";
Date date = new Date(sdf.parse(strDate).getTime());
Si bien algunas de las respuestas son técnicamente correctas, no son recomendables.
- Las clases java.util.Date & Calendar son notoriamente problemáticas. Debido a fallas en el diseño e implementación, evítelas. Afortunadamente, tenemos nuestra elección de otras dos excelentes bibliotecas de fecha y hora:
- JodaTime
Esta popular biblioteca gratuita de código abierto se puede usar en varias versiones de Java. Muchos ejemplos de su uso se pueden encontrar en . Leer algunos de estos te ayudará a ponerte al día rápidamente. - java.time. * paquete
Este nuevo conjunto de clases está inspirado en Joda-Time y definido por JSR 310. Estas clases están integradas en Java 8. Hay un proyecto en marcha para realizar una backport de estas clases a Java 7, pero Oracle no está respaldado por backporting.
- JodaTime
- Como Kristopher Johnson observó correctamente en su comentario sobre la pregunta, las otras respuestas ignoran cuestiones vitales de:
- Hora del dia
La fecha tiene una parte de fecha y una parte de hora del día) - Zona horaria
El comienzo de un día depende de la zona horaria. Si no puede especificar una zona horaria, se aplica la zona horaria predeterminada de la JVM. Eso significa que el comportamiento de su código puede cambiar cuando se ejecuta en otras computadoras o con una configuración de zona horaria modificada. Probablemente no es lo que quieres. - Lugar
El idioma de Locale especifica cómo interpretar las palabras (nombre del mes y del día) encontradas durante el análisis. (La respuesta de BalusC maneja esto correctamente). Además, la configuración regional afecta la salida de algunos formateadores al generar una representación de cadena de su fecha y hora.
- Hora del dia
Tiempo de joda
Algunas notas sobre Joda-Time siguen.
Zona horaria
En JodaTime , un objeto DateTime realmente conoce su propia zona horaria asignada. Esto contrasta la clase java.util.Date, que parece tener una zona horaria pero no la tiene.
Observe en el código de ejemplo a continuación cómo pasamos un objeto de zona horaria al formateador que analiza la cadena. Esa zona horaria se utiliza para interpretar que la fecha y la hora se han producido en esa zona horaria. Por lo tanto, debe pensar y determinar la zona horaria representada por esa entrada de cadena.
Como no tiene una porción de tiempo en su cadena de entrada, Joda-Time asigna el primer momento del día de la zona horaria especificada como la hora del día. Por lo general, esto significa 00:00:00 pero no siempre, debido al horario de verano u otras anomalías. Por cierto, puedes hacer lo mismo con cualquier instancia de DateTime llamando withTimeAtStartOfDay .
Patrón del formateador
Los caracteres utilizados en el patrón de un formateador son similares en Joda-Time a los de java.util.Date/Calendar pero no son exactamente los mismos. Lea atentamente el doc.
Inmutabilidad
Usualmente usamos las clases inmutables en Joda-Time. En lugar de modificar un objeto de fecha y hora existente, llamamos a los métodos que crean una nueva instancia nueva basada en el otro objeto con la mayoría de los aspectos copiados, excepto cuando se deseaban alteraciones. Un ejemplo es la llamada a withZone en la última línea a continuación. Immutability ayuda a hacer que Joda-Time sea muy seguro para los subprocesos, y también puede hacer que el trabajo sea más claro.
Conversión
Necesitará los objetos java.util.Date para usar con otras clases / framework que no conozcan los objetos Joda-Time. Afortunadamente, es muy fácil moverse de un lado a otro.
Pasando de un objeto java.util.Date (aquí llamado date ) a Joda-Time DateTime ...
org.joda.time.DateTime dateTime = new DateTime( date, timeZone );
Yendo en la otra dirección de Joda-Time a un objeto java.util.Date ...
java.util.Date date = dateTime.toDate();
Código de muestra
String input = "January 2, 2010";
java.util.Locale locale = java.util.Locale.US;
DateTimeZone timeZone = DateTimeZone.forID( "Pacific/Honolulu" ); // Arbitrarily chosen for example.
DateTimeFormatter formatter = DateTimeFormat.forPattern( "MMMM d, yyyy" ).withZone( timeZone ).withLocale( locale );
DateTime dateTime = formatter.parseDateTime( input );
System.out.println( "dateTime: " + dateTime );
System.out.println( "dateTime in UTC/GMT: " + dateTime.withZone( DateTimeZone.UTC ) );
Cuando se ejecuta ...
dateTime: 2010-01-02T00:00:00.000-10:00
dateTime in UTC/GMT: 2010-01-02T10:00:00.000Z
DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
Date date;
try {
date = dateFormat.parse("2013-12-4");
System.out.println(date.toString()); // Wed Dec 04 00:00:00 CST 2013
String output = dateFormat.format(date);
System.out.println(output); // 2013-12-04
}
catch (ParseException e) {
e.printStackTrace();
}
Funciona bien para mí.
String str_date = "11-June-07";
DateFormat formatter;
Date date;
formatter = new SimpleDateFormat("dd-MMM-yy");
date = formatter.parse(str_date);