^ Linux - Friheden til at programmere i Java: Version 0.7.20040516 - 2020-12-31 ^|
| [[java:java-obj-rekt-strenge|forrige]] | Kapitel 4. Objekter | [[java:java-obj-eksempel|næste]] |

----

==== 4.5. Lister (klassen Vector) ====

 En Vector er en liste af andre objekter, nummereret efter et indeks.

 **Figur 4-11. Java**

 {linuxbog:java:Nordfalk515371.png}

 Konstruktører og metoder er beskrevet i appendiks,[[java:java-obj-apppendix#java-obj-appendix-vector|Afsnit 4.7.4.2]].


> En Vector er en liste af andre objekter

 Man opretter en vektor med f.eks.:

<code>Vector v;
  v = new Vector();</code>

 Derefter kan man tilføje et objekt i enden af listen med //addElement// ( objekt ), f.eks.:

<code>v.addElement("æh");</code>

 tilføjer strengen "æh" sidst i vektoren.

 Man kan sætte ind midt i listen med v. //insertElementAt// ( objekt, int indeks ), f.eks.:

<code>v.insertElementAt("øh",0);</code>

 indsætter "øh" på plads nummer 0, sådan at vektoren nu indeholder først "øh" og så "æh". Alle elementerne fra og med det indeks hvori man indsætter, får altså rykket deres indeks et frem.

 Man henter elementerne ud igen med //elementAt// ( indeks ).

 Med v. //size// () får man antallet af elementer i vektoren, i dette tilfælde 2.

 //Nogle af Vector-klassens metoder//

 //Metoder//

 void //addElement// ( objekt )Føjer //objekt// til vektoren. //objekt// kan være et vilkårligt objekt (men ikke en simpel type)

 void //insertElementAt// ( objekt, int indeks )Indsætter //objekt// i vektoren lige før plads nummer //indeks//

 void //removeElementAt// ( int indeks )Sletter objektet på plads nummer //indeks//

 int //size// ()Returnerer antallet af elementer

 Object //elementAt// (int indeks)Returnerer en reference til objektet på plads nummer //indeks// . Husk at lave en typekonvertering af referencen til den rigtige klasse før resultatet lægges i en variabel (se Point-eksemplet nedenfor).

 String //toString// ()Returnerer vektorens indhold som en streng. Dette sker ved at konvertere hver af elementerne til en streng.

 //Vector-klassen skal importeres medimport java.util.*;før den kan bruges//

 Her er et lille eksempel:

<code>import java.util.*;

public class Vectortest
{
  public static void main(String args[])
  {
    Vector v; //v = new Vector();//  //v.addElement("æh");//  //v.addElement("bæh");//  //v.addElement("buh");// System.out.println("v har elementerne " //+v.toString()// ); //v.insertElementAt("og",2);// System.out.println("Nu har v elementerne " //+v// ); ////toString() kaldes implicit//  //v.removeElementAt(0);// System.out.println("Nu har v elementerne "+v+" og størrelsen "+ //v.size()// );

    System.out.println("På plads nummer 2 er: "+ //v.elementAt(2)// );
  }
}</code>

<code>v har elementerne [æh, bæh, buh]
Nu har v elementerne [æh, bæh, og, buh]
Nu har v elementerne [bæh, og, buh] og størrelsen 3
På plads nummer 2 er: buh</code>

 Vi indsætter først tre (referencer til) strenge i vektoren. I hukommelsen ser det sådan ud:

 **Figur 4-12. Java**

 {linuxbog:java:Nordfalk515372.png}

 Dernæst lægges "og" ind på plads nummer 2, dvs. efter "bæh" og før "buh". Til sidst fjernes "æh" på plads nummer 0.

 Vector-objekter kan blive vilkårligt lange. De sørger selv for at reservere mere hukommelse, hvis det bliver nødvendigt.

=== 4.5.1. Eksempel med Point ===

 I det næste eksempel lægges tre Point-objekter ind i en vektor, og vektoren gennemløbes for at finde punktet med den mindste afstand til (0,0) (origo).

 Læg mærke til, hvordan man kan gennemløbe en vektor:

<code>for (int n=0; //n<pv.size()// ;n++)
    {
      Point p; //p=(Point) pv.elementAt(n)// ; //// punkt nr n hentes ud af vektoren//  //// (typekonvertering nødvendig)//  ////...// }</code>

 Da vektorer kan indeholde objekter af alle mulige typer, er man nødt til at lave en typekonvertering af den objekt-reference, som elementAt() returnerer.

<code>import java.awt.*;
import java.util.*;
 
public class MindsteAfstand
{
  public static void main(String args[])
  {
    Vector pv; //// punkt-vektor// Point origo, p1, p2, p3;
    double mindist=10000;

    pv=new Vector();
    origo=new Point(0,0);
    p1=new Point(0,65);
    p2=new Point(50,50);
    p3=new Point(120,10);
    
    pv.addElement(p1);
    pv.addElement(p2);
    pv.addElement(p3);
    
    for (int n=0;n<pv.size();n++)
    {
      double dist;
      Point p;

      p=(Point) pv.elementAt(n); //// punkt nr n hentes ud af vektoren//  //// (typekonvertering nødvendig)// dist = origo.distance(p);
      if (dist<minDist)
      {
        mindist=dist;
      }
    }

    System.out.println("Den mindste afstand mellem punkterne "
      +pv+" og (0,0) er "+minDist);
  }
}</code>

<code>Den mindste afstand mellem punkterne [java.awt.Point[x=0,y=65], java.awt.Point[x=50,y=50], java.awt.Point[x=120,y=10]] og (0,0) er 65.0</code>

 Her er en lille stump programkode, der i stedet finder den mindste afstand mellem to punkter, der ligger ved siden af hinanden i vektoren:

<code>for (int n=0;n< //pv.size()-1// ;n++)
    {
      double dist;
      Point p //,q// ;

      p=(Point) pv.elementAt(n); //q=(Point) pv.elementAt(n+1);// dist = q.distance(p);
      if (dist<minDist)
      {
        mindist=dist;
      }
    }</code>

 Og herunder er vist, hvordan man kan finde den mindste afstand mellem to vilkårlige punkter i vektoren:

<code>for (int n=0;n<pv.size();n++)
    {
      for (int //k=n// ; //k// <pv.size(); //k++// )
      {
        double dist;
        Point p,q;
        p=(Point) pv.elementAt( //n// );
        q=(Point) pv.elementAt( //k// );

        dist = q.distance(p);
        if (dist<minDist)
        {
          mindist=dist;
        }
      }
    }</code>

----

| [[java:java-obj-rekt-strenge|forrige]] | [[java:index|hjem]] | [[java:java-obj-eksempel|næste]] |
| Tekststrenge (klassen String) | [[java:java-obj|op]] | Ekstra eksempler |