Et par hurtige..

1:
int tal = 12345;
String str = "" + tal;
int tal2;
try
{
tal2 = Integer.parseInt(str);
}
catch(NumberFormatException e)
{
  e.printStackTrace();
}

2:
lav et Integer objekt.
vect.add(new Integer(12345));

Du kan godt gemme de basale typer i en Vector vha. de klasser der hører til de basale typer.

int i=5;
Vector v = new Vector();
v.addElement(new Integer(i));
int j=((Integer)v.elementAt(0)).intValue();
System.out.println(j);

Hvis du vil lagre en double så bruges klassen Double osv.

Overvej at lave en type-safe wrapper a la:

public class MyArrayList ArrayList {
  private ArrayList list;
  public MyArrayList() {
      list = new ArrayList();
  }
  public put(String key, int v) {
      list.put(key, new Integer(v));
  }
  public getInt(String key) {
      return ((Integer)list.get(key)).intValue();
  }
}

Der er ikke alle som kan lide den slags klasser, men de er meget udbredte.

Der mangler vist noger:
public class MyArrayList ArrayList

skal vel være:
public class MyArrayList extends ArrayList

Ups.

Vrøvl.

Det skal naturligvis være enten:

public class MyHashMap {
  private HashMap map;
  public MyHashMap() {
      map = new HashMap();
  }
  public put(String key, int v) {
      map.put(key, new Integer(v));
  }
  public getInt(String key) {
      return ((Integer)map.get(key)).intValue();
  }
}

eller:

public class MyArrayList {
  private ArrayList list;
  public MyArrayList() {
      list = new ArrayList();
  }
  public put(int v) {
      list.put(new Integer(v));
  }
  public getInt(int ix) {
      return ((Integer)list.get(ix)).intValue();
  }
}

Jeg - fik rodet nogle forskellige ting sammen.

Og så lige den sidste rettelse:

list.add(new Integer(v)); // add ikke put

Jeg håber folk forstår hvad jeg forsøger at forklare.

Og så skal der vel også return types på dine metoder getInt ??

selvfølgelig.

og void på de andre.

jeps

Jeg fik vist tastet lige hurtigt nok.

For en god ordens skyld:

MyArrayList.java
----------------

import java.util.ArrayList;

public class MyArrayList {
    private ArrayList list;
    public MyArrayList() {
        list = new ArrayList();
    }
    public void add(int v) {
        list.add(new Integer(v));
    }
    public void add(double v) {
        list.add(new Double(v));
    }
    public void add(boolean v) {
        list.add(new Boolean(v));
    }
    public void add(String v) {
        list.add(v);
    }
    public int getInt(int ix) {
        return ((Integer) list.get(ix)).intValue();
    }
    public double getDouble(int ix) {
        return ((Double) list.get(ix)).doubleValue();
    }
    public boolean getBoolean(int ix) {
        return ((Boolean) list.get(ix)).booleanValue();
    }
    public String getString(int ix) {
        return ((String) list.get(ix));
    }
    public int size() {
        return list.size();
    }
}

MyHashMap.java
--------------

import java.util.HashMap;

public class MyHashMap {
    private HashMap map;
    public MyHashMap() {
        map = new HashMap();
    }
    public void put(String key, int v) {
        map.put(key, new Integer(v));
    }
    public void put(String key, double v) {
        map.put(key, new Double(v));
    }
    public void put(String key, boolean v) {
        map.put(key, new Boolean(v));
    }
    public void put(String key, String v) {
        map.put(key, v);
    }
    public int getInt(String key) {
        return ((Integer) map.get(key)).intValue();
    }
    public double getDouble(String key) {
        return ((Double) map.get(key)).doubleValue();
    }
    public boolean getBoolean(String key) {
        return ((Boolean) map.get(key)).booleanValue();
    }
    public String getString(String key) {
        return ((String) map.get(key));
    }
}

MyTest.java
-----------

public class MyTest {
    public static void main(String[] args) {
        MyArrayList al = new MyArrayList();
        al.add(123);
        al.add(123.456);
        al.add(true);
        al.add("abc");
        System.out.println(al.getInt(0));
        System.out.println(al.getDouble(1));
        System.out.println(al.getBoolean(2));
        System.out.println(al.getString(3));
        MyHashMap hm = new MyHashMap();
        hm.put("k1", 123);
        hm.put("k2", 123.456);
        hm.put("k3", true);
        hm.put("k4", "abc");
        System.out.println(hm.getInt("k1"));
        System.out.println(hm.getDouble("k2"));
        System.out.println(hm.getBoolean("k3"));
        System.out.println(hm.getString("k4"));
    }
}

og nu er det testet !

:-)

Som sagt så kan den slags wrappere hjælpe meget til at gøre noget
kode let-læselig, fordi man skjuler alle de obskure konverteringer
mellem objekter og simple data typer.

Var det ikke noget med at SDK1.5 skulle indeholde templates ?

Det vil gøre tingene lidt nemmere (hvis man har samme datatype i datastrukturen..).

J2SE 1.5 vil efter sigende indeholde:
  enumerations
  autoboxing
  static import
  generics (templates)

Jeg tror faktisk at det mere er autoboxing end generics der vil løse dette
problem.

Fornem service som altid :-)

Med hensyn til 1.5, så er der en fremragende artikel på:
  http://java.sun.com/features/2003/05/bloch_qa.html

Det lyder da som noget spændende er i vente.
Men lidt en sjov ide med det nye "for" loop.

Der er faktisk en del "very high level" sprog der har tilsvarende
konstruktioner.

Ofte kendt som "for each".

Der er også visse "ikke helt så high level sprog" der har den
som f.eks. DOS/WINDOWS FOR løkke.