Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
import java.text.*;
import java.util.*;
public class ParseDate {
public static void main(String[] args) {
SimpleDateFormat dateFormat = new SimpleDateFormat("dd.MM.yyyy");
Date date = dateFormat.parse("24.03.1995", new ParsePosition(0));
System.out.println(date.toString());
}
}
In der Javadoc findest du mehr Informationen.
Wenn du verschiedene Datumsformate unterstützen willst kannst du ja folgendes versuchen.
Code:
import java.text.*;
import java.util.*;
public class ParseDate {
private static String[] dateFormats = new String[] {
"EEE, MMM d, ''yy",
"h:mm a",
"hh 'o''clock' a, zzzz",
"yyyy.MM.dd 'at' HH:mm:ss",
"K:mm a, z",
"yyyy.MMMMM.dd hh:mm aaa",
"EEE, d MMM yyyy HH:mm:ss Z",
"yyMMddHHmmssZ"
};
public static void main(String[] args) {
Date date = parseDate("24.12.03 12:47");
if (date == null)
System.out.println("Kein erlaubtes Datumsformat");
else {
System.out.println(date);
}
date = parseDate("2003.12.24 at 12:47:33");
if (date == null)
System.out.println("Kein erlaubtes Datumsformat");
else {
System.out.println(date);
}
}
public static Date parseDate(String str){
SimpleDateFormat dateFormat = new SimpleDateFormat(dateFormats[0]);
for(int i=0; i < dateFormats.length; i++){
dateFormat.applyPattern(dateFormats[i]);
ParsePosition pos = new ParsePosition(0);
Date date = dateFormat.parse(str, pos);
int errorIndex = pos.getErrorIndex();
if (errorIndex == -1) {
return date;
}
}
return null;
}
}
hab gleich noch eine frage - hab das erste semester java unterricht und muss die woche ein programm abgeben...
also so ein typisches person-teacher-student beispiel mittels serialisierung löschen, bearbeiten, etc von datensätzen
ich hab jetzt mal einen datensatz in eine datei gespeichert, das funktioniert auch - nur sobald ich auslesen möchte bekomme ich die fehlermeldung writeabortedexception: writing aborted, notserializableexception in student
code
Code:
public void editPerson()
{
try {
FileInputStream fis = new FileInputStream ("C:\\uebung.ser");
ObjectInputStream ois = new ObjectInputStream(fis);
List liste = new ArrayList();
liste = (ArrayList) ois.readObject();
printPersons(liste);
ois.close();
fis.close();
}
catch (ClassNotFoundException cnfe) {
System.err.println(cnfe);
}
catch (ClassCastException cce) {
System.err.println(cce);
}
catch (IOException ioe) {
System.err.println(ioe);
}
}
das kommt daher, weil du das Serializable-Interface nicht implementiert hast.
Das Serializable-Interface definiert keine Methoden. Das kommt daher, weil
alle Methoden in einem Interface public sein müssen. Die Javadoc schreibt aber
vor, dass die zwei Methoden private sein sollen. Also kann man dies nicht im
Interface spezifizieren.
Die zwei Methoden, welche für die Serialisierung zuständig sind, kannst du beliebig
komplex machen oder ganz simple halten. Da die Methoden private sind hast du von
außen keinen Zugriff darauf. Deshalb würde ich dir empfehlen eine Klasse mit load und save-Methode
selbst zu implementieren, diese kannst du dann immer wieder verwenden.
Dann geht die Serialisierung ganz einfach.
Code:
import java.io.*;
public class SimpleClassToSerializeMain {
public static void main(String[] args) {
try {
SimpleClassToSerialize scWrite = new SimpleClassToSerialize(12);
File serFile = new File(scWrite.getClass() + ".ser");
SerializeController.save(scWrite, serFile);
SimpleClassToSerialize scRead = (SimpleClassToSerialize) SerializeController.load(serFile);
System.out.println(scWrite.toString() + " " + scWrite.isSerialized());
System.out.println(scRead.toString() + " " + scRead.isSerialized());
}
catch (Exception ex) {
ex.printStackTrace();
}
}
}
class SerializeController {
private SerializeController(){} // nicht instanzierbar
public static void save(Serializable serObj, File serFile) throws IOException {
FileOutputStream fout = new FileOutputStream(serFile);
ObjectOutputStream oout = new ObjectOutputStream(fout);
oout.writeObject(serObj);
}
public static Serializable load(File serFile) throws IOException{
FileInputStream fin = new FileInputStream(serFile);
ObjectInputStream oin = new ObjectInputStream(fin);
try {
return (Serializable) oin.readObject();
}
catch (ClassNotFoundException ex) {
return null;
}
}
}
class SimpleClassToSerialize implements Serializable{
int x;
private transient boolean serialized = false;
public SimpleClassToSerialize(int x) {
this.x = x;
this.serialized = false;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public boolean isSerialized() {
return serialized;
}
private void writeObject(ObjectOutputStream oos) throws IOException {
oos.defaultWriteObject();
}
private void readObject(ObjectInputStream ois) throws ClassNotFoundException, IOException {
this.serialized = true;
ois.defaultReadObject();
}
}
Schau dir auch noch einmal die Javadoc an.
Übrigens...
Wenn dein Objekt, was du serialisieren möchtest, Instanzvariablen hat die von einem Typ sind, welcher nicht
Serializable ist, werden die auch nicht serialisiert.
Dadurch, dass ich die Instanzvariable serialized mit transient gekennzeichnet habe, erreiche ich auch das diese
nicht serialisiert wird. So ist es mir im obigen Beispiel möglich zu erkennen, ob ein Objekt neu erstellt wurde oder
deserialisiert. Also schon einmal existierte.
puuuh - ich muss dem lehrer das auch erklären können. so fit bin ich im moment nicht wirklich.
wir hatten das semester einen theorie test - der war aber open book und da haben wir noch nicht wirklich collections/interfaces behandelt
kannst du mir vielleicht in ein paar sätzen erklären was das alles genau tut. also wozu und warum. oder ist das selbsterklärend wenn ich mir die javadoc ansehe? das würde mir ein bisschen helfen.
