code vereinfachen

[mikachu]

hi,

ich wollt mal fragen, wie man folgenden code einfacher und mit weniger schleifen bauen kann.
ich komm einfach nicht auf ne formel ???:L

   public final void writeXML() throws IOException
   {
      // einrückungen zusammenbauen
      String[] tabs = new String[DEPTH];  // DEPTH wird im konstruktor gesetzt
      for( int i = 0; i < DEPTH; ++i )
      {
         tabs[i] = "";
         for( int j = 0; j < i; ++j )
            tabs[i] += "\t";
      }

      _fos = new FileWriter( new File( OUTPUT_FILE_PATH ) );
      _fos.write( "?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" );
      _fos.write( "<ROOT>\n" );

      for( int a = 0; a < DEPTH; ++a )
      {
         _fos.write( tabs[0] + startElName( a ) );
         for( int b = 0; b < DEPTH; ++b )
         {
            _fos.write( tabs[1] + startElName( b ) );
            for( int c = 0; c < DEPTH; ++c )
            {
               _fos.write( tabs[2] + startElName( c ) );
               for( int d = 0; d < DEPTH; ++d )
               {
                  _fos.write( tabs[3] + startElName( d ) );
                  for( int e = 0; e < DEPTH; ++e )
                  {
                     _fos.write( tabs[4] + startElName( e ) );
                     for( int f = 0; f < DEPTH; ++f )
                     {
                        _fos.write( tabs[5] + startElName( f ) );
                        for( int g = 0; g < DEPTH; ++g )
                        {
                           _fos.write( tabs[6] + startElName( g ) );
                           for( int h = 0; h < DEPTH; ++h )
                           {
                              _fos.write( tabs[7] + "<" + Character.toString( (char) ( 'A' + h ) ) + "/>\n" );
                           }
                           _fos.write( tabs[6] + endElName( g ) );
                        }
                        _fos.write( tabs[5] + endElName( f ) );
                     }
                     _fos.write( tabs[4] + endElName( e ) );
                  }
                  _fos.write( tabs[3] + endElName( d ) );
               }
               _fos.write( tabs[2] + endElName( c ) );
               System.out.println( a + "" + b + "." + c + "%" );
            }
            _fos.write( tabs[1] + endElName( b ) );
         }
         _fos.write( tabs[0] + endElName( a ) );
      }
      _fos.write( "</ROOT>\n" );
   }

vielen wird bestimmt die übersichtlichkeit zum hals raushängen... mir ebenfalls.
und es ist auch nicht so variable

aber wie gesagt, komm ich nicht auf eine einfachere funktionalität.

danke im voraus

 

[SlaterB]

wenn du oft einzeln schreibst, verwende BufferedWriter, dann gehts schneller

ansonsten hast du nicht verraten, was passieren soll, ich nehme mal grob an:

verwende ein int[] der Länge 7 (a-g);
Anfangsbelegung: 0,0,0,0,0,0,0

dann eine große while-Schleife, die wie ein Kilometerzähler am Auto funktioniert:
0000000
0000001
0000002
...
0000008
0000009 (9 = DEPTH bzw. DEPTH-1)
0000010
0000011
...
9999998
9999999

um das int-Array in jedem while-Schritt um EINS zu erhöhen,
brauchst du eine for-Schleife, die am Ende anfängt und die 7.te Stelle um 1 erhöht,
Überlauf (>= DEPTH) merken und bei der 6.ten Stelle berücksichten,
bei Überlauf zur 5.Stelle,
aber nicht alles mit if-else, die Schleife wandert da das Array durch,
falls mal kein Überlauf mehr ist kann die Schleife abgebrochen werden

das ganze ist recht schwierig, nciht verzweifeln wenn du daran verzweifelst
Tipp: mit einem Array der Länge 2 und DEPTH = 4 oder so anfangen, von klein auf lernen

 

[Rock Lobster]

1) Was genau soll der Code anstellen?
2) Was sind startElName und endElName?

 

[Yzebär]

1) Was genau soll der Code anstellen?
2) Was sind startElName und endElName?

1) Das sieht man doch... es soll eine XML-Datei geschrieben werden.
2) Das sind offensichtlich Methoden, die aus einem index ein Start- oder Endtag erzeugen.

Mich würde vielmehr interessieren, wozu man eine solche XMLDatei brauchen kann, wo alle Tags mit Ziffern von 0 bis DEPTH - 1 bezeichnet sind und ganz innen mal ein Buchstabe (A+index) steht. Einfach nur so aus Spaß an der Freude?

 

[WieselAc]

Wie wärs mit einer Rekursions Methoden in der Art:

private void write(FileWriter writer, String padding, Iteratotr tags) {
   if(!tags.hasNext()){
       return;
   }
   int currentTag = ((Integer )tags.next()).intVaule();
   String newPadding = padding + "\t";

   writer.write( padding + startElName( currentTag  ) ); 

   for(int i = currentTag; i< DEPTH, i++){
       write(writer, newPadding, tags);
   }

   writer.write( padding + endElName( currentTag  ) ); 
}

Dazu müsstest du lediglich deine A-G Elemente in einer Liste o.ä haben.

 

[mikachu]

hi,

ich sehe, der code oder die erklärung sind noch etwas unvollständig... dafür entschuldige ich mich!

die startElName( int ) und endElName( int ) geben mir eigentlich nur einen buchstaben nach dem muster ( 'A' + int ) zurück.

und aussehen soll das dann folgendermaßen:

<ROOT> // beispiel für 3 elemente... mehr wäre zu viel code ;)
  <A>
    <A>
      <A/>
      <B/>
      <C/>
    </A>
    [B]
      <A/>
      <B/>
      <C/>
    [/B]
    <C>
      <A/>
      <B/>
      <C/>
    </C>
  [B]
    <A>
      <A/>
      <B/>
      <C/>
    </A>
    [B]
      <A/>
      <B/>
      <C/>
    [/B]
    <C>
      <A/>
      <B/>
      <C/>
    </C>
  [/B]
  <C>
    <A>
      <A/>
      <B/>
      <C/>
    </A>
    [B]
      <A/>
      <B/>
      <C/>
    [/B]
    <C>
      <A/>
      <B/>
      <C/>
    </C>
  </C>
</ROOT>

 

[mikachu]

Wie wärs mit einer Rekursions Methoden in der Art...

keine rekursion... denn die dauert zu lange und frisst zuviel ressourcen...
da kann ich maximal eine tiefe von 6 ebenen erstellen, bei 7 ebenen kommt ein Java Heap Space Error...

ich würde da gerne schon xmls mit einer tiefe von maximal 10 ebenen erstellen...
mit der oben genannten methode geht das schon, ist aber sehr statisch, man kann also nix ändern im ablauf, wenn man z.b. nur 4 ebenen haben will...

#edit 1:
ich weiß, mit rekursion lässt sich das in 4 zeilen bewerkstelligen... aber geht eben nich weit in die tiefe der xml :cry:
aber ich muss xmls fürs testen von xpath ausdrücken bauen, und die sollten schon seeehr lang sein

#edit 2:
rekursion hab ich schon folgendermaßen realisiert

   private final void addNodes( final Node toAdd, int step )
   {
      for( int i = 0; i < _depth; ++i )
      {
         Node curN = _xmlDoc.createElement( elName( i ) ); // elName( int ) ist wieder eine methode, die mir einen buchstaben liefert
         if( step < _depth )
            addNodes( curN, step + 1 );
  //         addTextNode( curN );
  //         addAttribute( curN );
         toAdd.appendChild( curN );
      }
   }

...aber geht eben nicht tief genug...

 

[SlaterB]

> keine rekursion... denn die dauert zu lange und frisst zuviel ressourcen...
> da kann ich maximal eine tiefe von 6 ebenen erstellen, bei 7 ebenen kommt ein Java Heap Space Error...

einen HeapSpace-Error wirst du nicht bekommen,
eine richtige Rekursion wie die von WieselAc geht für 7 Ebenen auch nur bis Tiefe 7,
nicht bis 7^7 oder wovor du Angst hast und vielleicht in deinem ungenauen edit-Beispiel hast

Ressourcenaufwand + Dauer kann man vernachlässigen, paar ms/ kb

 

[Rock Lobster]

1) Das sieht man doch... es soll eine XML-Datei geschrieben werden.

Jo, das sehe ich in der Tat, aber ein bißchen mehr Informationen hätte ich mir eben gewünscht. Für mich sieht es so aus, als würde der Code deshalb so kompliziert aussehen, weil er irgendwelche Einrückungen erstellen will, aber da ich mir nicht sicher war, dachte ich, der Originalposter könnte eben kurz mal in 2-3 Sätzen erläutern, was GENAU passieren soll (daher lautete meine Frage auch: "Was genau soll der Code anstellen?").

Ich habe auch schon oft XML-Daten erzeugt und in Dateien geschrieben, auch mit Einrückungen usw., allerdings kann ich nichts dazu sagen, wenn ich nicht weiß, wie der Vorgang bzw. der Zweck aussehen soll.

 

[mikachu]

habs gelöst...

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.util.Collections;
import java.util.Iterator;
import java.util.Vector;

public class SimpleXMLGenerator
{
   private String OUTPUT_FILE_PATH;

   private String[] _tabs;

   public SimpleXMLGenerator()
   {
   }

   public final void writeXML( String s ) throws IOException
   {
      final int length = s.length();
      OUTPUT_FILE_PATH = "files/strXML_" + length + ".xml";
      final char maxChar = (char) ( 'A' + length - 1 );
      PrintStream ps = new PrintStream( new FileOutputStream( new File(
            OUTPUT_FILE_PATH ) ) );
      ps.println( "?xml version=\"1.0\" encoding=\"UTF-8\"?>" );
      ps.println( "<ROOT>" );

      char[] sChars = s.toCharArray();
      print( sChars, sChars, ps );

      long total = (long)Math.pow( length, length );
      for( long i = 0; i < total; ++i )
      {
         char[] old = sChars.clone();
         sChars[length - 1]++;

         for( int ii = length - 1; ii >= 0; --ii )
         {
            if( sChars[ii] > maxChar )
            {
               sChars[ii] = 'A';
               if( ii > 0 )
                  sChars[ii - 1]++;
            }
         }
         print( sChars, old, ps );
      }
      ps.println( "</ROOT>" );
      ps.close();
   }

   public final void print( final char[] c, final char[] old, final PrintStream ps )
   {
      final Vector<Integer> changed = new Vector<Integer>();
      Vector<Integer> vHelp = new Vector<Integer>();

      // alle geänderten indizes finden
      for( int i = 0; i < c.length; ++i )
         if( c[i] != old[i] )
            changed.add( i );

      // andersrum, damit größter index gaaanz oben steht
      Collections.reverse( changed );

      // das ist nur für den anfang der fall
      if( changed.size() > 0 && changed.elementAt( 0 ).equals( c.length - 1 ) )
      {
         int index = changed.remove( 0 ).intValue();
         ps.println( _tabs[index] + "<" + old[index] + "/>" );
      }
      else
      {
         for( int i = 0; i < c.length - 1; ++i )
         {
            ps.println( _tabs[i] + "<" + c[i] + ">" );
         }
      }

      for( Iterator<Integer> it = changed.iterator(); it.hasNext(); )
      {
         int cur = it.next().intValue();
         ps.println( _tabs[cur] + "</" + old[cur] + ">" );
         if( c[cur] == 'A' && old[cur] == 'A' + c.length - 1 )
            vHelp.add( cur );
         else
            ps.println( _tabs[cur] + "<" + c[cur] + ">" );
      }
      if( vHelp.size() > 0 && vHelp.size() != c.length - 1 )
      {
         Collections.reverse( vHelp );
         while( vHelp.size() > 0 )
         {
            int cur = vHelp.remove( 0 );
            ps.println( _tabs[cur] + "<A>" );
         }
      }
   }

   public static void main( String[] args ) throws IOException
   {
      SimpleXMLGenerator sxg = new SimpleXMLGenerator();
      long t = System.currentTimeMillis();
      sxg.writeXML( "AAAA" );
      System.out.println( System.currentTimeMillis() - t );
   }
}

sieht zwar noch etwas durch den wind aus, aber funzt

danke

 

[Leroy42]

Toll! :applaus:

Und was soll der Schrott jetzt? :shock:
Was hast du jetzt damit bewiesen?

Einfach nur dein Ego ein bischen gestreichelt? ???:L

(Leute gibt's... :roll: )

 

[Leroy42]

keine rekursion... denn die dauert zu lange und frisst zuviel ressourcen...
da kann ich maximal eine tiefe von 6 ebenen erstellen

:shock:
Wie kommst du denn darauf? :shock:

Ich würde dir vorschlagen, dich erstmal richtig mit
Rekursion zu befassen (Potential dazu hast du ja) bevor
du dich (und uns) mit solchem sinnfreien Gecode zumüllst. ???:L

 

[mikachu]

Toll! :applaus:

Danke

Und was soll der Schrott jetzt? :shock:
Was hast du jetzt damit bewiesen?

schrott würd ich dazu nicht gleich sagen, aber wenn es deine ansicht zufriedenstellt, will ich nix gesagt haben.
Beweisen will ich gar nix!

Einfach nur dein Ego ein bischen gestreichelt? ???:L

kann sein.

keine rekursion... denn die dauert zu lange und frisst zuviel ressourcen...
da kann ich maximal eine tiefe von 6 ebenen erstellen

:shock:
Wie kommst du denn darauf? :shock:

weil ichs getestet hab ?!?


sorry, wenn ich nicht euren idealen entspreche :roll:


mit rekursion hab ich mich in dieser sache auch schon befasst... war mir aber nicht genug und es kam desöfteren ein java heap error

und des weiteren wollt ich mal sehen, ob es denn so schwer ist, wie man sagt, aus einer rekursion eine iteration zu machen... in diesem konkreten falle

 

[Leroy42]

Toll! :applaus:

Danke

Gern geschehen!
Meine Ironie hast du ja gut gekontert und

Einfach nur dein Ego ein bischen gestreichelt? ???:L

kann sein.

ehrlich bist du ja anscheinend!

mit rekursion hab ich mich in dieser sache auch schon befasst... war mir aber nicht genug und es kam desöfteren ein java heap error

Das sagt mir eindeutig, daß du in deiner rekursiven Version etwas falsch
gemacht haben mußt.

und des weiteren wollt ich mal sehen, ob es denn so schwer ist, wie man sagt, aus einer rekursion eine iteration zu machen...

Das hängt stark davon ab, was für eine Art rekursiven Algorithmus's, bzw.,
welche Art Datenstruktur zugrunde liegt. Da deinem Beispiel eine nicht
tail-rekursive Datenstruktur zugrunde liegt, ist es prinzipiell nicht
ohne weiteres möglich, dies iterativ ohne Implementierung
eines eigenen Stacks zu lösen.

Dein Beispiel geht vermutlich (habs nicht ausprobiert) dennoch, weil
die zu erzeugende Datenstruktur vollständig ist; das sieht man
z.B. daran, daß du eine Anweisung wie

Math.pow( length, length );

benutzt.

 

[mikachu]

mit der anweisung

Math.pow( length, length );

hab ich die obergrenze des zählers ermittelt und somit die anzahl der elemente ("tiefe" soll gleich "länge" sein).

alle knoten von beispielsweise AAAA bis ZZZZ.

Das hängt stark davon ab, was für eine Art rekursiven Algorithmus's, bzw.,
welche Art Datenstruktur zugrunde liegt. Da deinem Beispiel eine nicht
tail-rekursive Datenstruktur zugrunde liegt, ist es prinzipiell nicht
ohne weiteres möglich, dies iterativ ohne Implementierung
eines eigenen Stacks zu lösen.

???:L ich hab doch nur das wissen über rekursion, was ich in der ausbildung gelernt habe, denn ich weiß nicht, was du mit dem "tail-rekursiv" meinst

 

[Leroy42]

Tail-rekursiv oder neudeutsch: Endrekursion