# Prozente falsch errechnet?



## Rex (9. Okt 2006)

Liebe Freunde,

zunächst der Code:


```
private static void pipe(InputStream in, OutputStream out) throws IOException {
        byte[] buf = new byte[500000];
        int nread;
        int navailable;
        int total = 0; //Menge an Bytes bisher gesendet
        long percentage; //Percent done...

        synchronized (in) {
            while((nread = in.read(buf, 0, buf.length)) >= 0) {
                total += nread; //Wieviel bereits gesendet?
                percentage = (filesize/total)*100;   
                out.write(buf, 0, nread);
                System.out.println(percentage+"%");
            }
        }
        out.flush();
        buf = null;
    }
```

Ehm... Leider kommt bei großen Files (4 MB) zunächst 1800 % dann 1200 % .... usw. bis es bei 100 % steckenbleibt und dann fertig ist.

Dabei müsste die Berechnung stimmen!

Vielen Dank!
MFG
Rex


----------



## thE_29 (9. Okt 2006)

Nimm dir ganz einfach ein Bsp!

Deine fileSize = 1000

total ist 10

wie kommst du jetzt auf 1 %?

1000/10 * 100 != 1


----------



## Rex (9. Okt 2006)

Mache ich also was falsch?
ich habe es schon versucht - kann mir jemand die Formel dazu geben  

Hab gerade keine Zeit.


Vielen Dank!
MFG
Rex


----------



## thE_29 (9. Okt 2006)

Probier mal

(total * 100) / fileSize


----------



## byte (9. Okt 2006)

http://de.wikipedia.org/wiki/Prozentrechnung



> Hab gerade keine Zeit.



Kann ich mir kaum vorstellen. Schließlich fragst Du ständig jede Kleinigkeit nach, anstatt dir selbst mal Gedanken zu machen oder nachzuschlagen. :roll:

Kleiner Tipp am Rande: Zum Lernen gehört auch dazu, selbst mal kurz nachzudenken. Und vor allem muss man Lernen, wo man gezielt und schnell Informationen über einen Sachverhalt findet. Wenn Du jede Kleinigkeit in Foren erfragst, also andere für Dich die Arbeit erledigen lässt, wirst Du Dich kaum verbessern und immer von anderen abhängig sein. In meinen Augen kein wirklich erstrebenswertes Ziel...


----------



## Rex (9. Okt 2006)

Ehm..
Mein aktueller Code:

```
synchronized (in) {
            while((nread = in.read(buf, 0, buf.length)) >= 0) {
                total += nread; //Wieviel bereits gesendet?
        percentage = (total/filesize)*100;   
        System.out.println("Filegröße insgesamt: " + filesize);
        System.out.println("Menge bereits gesendet: " + total);
                out.write(buf, 0, nread);
                System.out.println(percentage+"%");
            }
        }
        out.flush();
        buf = null;
    }
```

Obwohl noch immer fleißig die Bytes durch die Leitung fließen, sagt der mir
Filegröße insgesamt: 9177462
Menge bereits gesendet: 9177462


Und damit 100%. - Aber dass stimmt nicht, denn die File wird immer noch gesendet.
Die 100% kommen schon nach ca. 3 Sekunden.

Einen soo schnellen DSL-Anschluss habe ich nun auch wieder nicht.
Woran liegt das?

Das ganze wird doch Byte für Byte ausgelesen - dann müsste ich doch für jeden Byte einen akzeptablen Float-Prozentwert erhalten!



MFG
Rex


----------



## thE_29 (9. Okt 2006)

Blind?

http://www.java-forum.org/de/viewtopic.php?p=225840#225840


----------



## SlaterB (9. Okt 2006)

ich hatte das vor ein paar Tagen in einem anderen Thread auch schon erwähnt,
aber es ist ja Rex, also nochmal 

-----------
->


es muss natürlich total/filesize heißen, 
bei int kann es sein dass da auf 0 oder 1 gerundet wird, 
insofern vielleicht wirklich so, dass bis kurz vor Schluss (0.99) immer bei 0 bleibt und erst mit dem letzten byte auf 1 = 100% umspringt  

wieso ist eigentlich percentage ein long? 


das sind aber nur Spielereien bei der Rechnung, denen man wiederum mit einfach System.out.prinltn auf die Schliche kommt, 
erst mit 100 malnehmen und dann teilen, 

50/150 = 0 -> 50/150 * 100 = 0% 

50 * 100 = 5000 -> (50 * 100)/150 = 33%


----------



## Ark (9. Okt 2006)

```
System.out.println((float)(100*total)/filesize);
```
So braucht man keine Variable. Du solltest das aber vllt. nicht immer ausgeben, das kostet nämlich verdammt viel Zeit. Besser wäre es, Du machst die Ausgabe davon abhängig, dass eine bestimmte Menge gesendet wurde. Modulo ist zwar langsamer, liefert aber „schönere“ Zahlen. Die UND-Verknüpfung ist schneller, aber die Zahlen sehen dann sehr „computermäßig“ aus.

… Hat jetzt eigentlich jemand verstanden, was ich sagen wollte? xD

MfG
Ark


----------



## Rex (9. Okt 2006)

Aber WO wird bei mir INT verwendet???


MFG
Rex


----------



## Rex (9. Okt 2006)

@Ark:
Leider passiert bei mir nichts 


```
private static void pipe(InputStream in, OutputStream out) throws IOException {
        byte[] buf = new byte[500000];
        int nread;
        int navailable;
        int total = 0; //Menge an Bytes bisher gesendet
        long percentage; //Percent done...

        synchronized (in) {
            while((nread = in.read(buf, 0, buf.length)) >= 0) {
                total += nread; //Wieviel bereits gesendet?
        System.out.println((float)(100*total)/filesize);
        System.out.println("Filegröße insgesamt: " + filesize);
        System.out.println("Menge bereits gesendet: " + total);
                out.write(buf, 0, nread);
            }
        }
        out.flush();
        buf = null;
    }
```

Es bleibt bei dem Sprunghaften 0% - 100% - 100% obwohl er noch sendet!


Vielen Dank!
MFG
Rex


----------



## SlaterB (9. Okt 2006)

Rex hat gesagt.:
			
		

> Aber WO wird bei mir INT verwendet???


----------> int total = 0; //Menge an Bytes bisher gesendet  <---------
----------> long percentage; <---------------------------------------------

long bezeichne ich jetzt auch mal als int,
Ganzzahl eben wo gerundet dividiert wird statt wie bei double und float auf Kommastellen genau,


wie auch schon damals geschrieben:
wenn du nicht weißt was Java da rechnet,
dann lass dir eben Zwischenwerte ausgeben und rechne selber nach

System.out.println((float)(100*total)/filesize); = was unverständliches, weiß nicht weiter
hilft nicht


besser:
System.out.println("nread: "+nread);
System.out.println("filesize: "+filesize);
System.out.println("total: "+total);
System.out.println("100*total: "+(100*total));
System.out.println("100*total / filesize: "+(((float) (100*total))/filesize);


baue das bei dir ein poste bitte mal, was bei jeder Runde rauskommt,
Rechenfehler lassen sich dann leicht erklären,

(edit: ein paar der erweiterten Ausgaben hast du ja auch schon, dann poste doch mal was die so sagen  )


----------



## Rex (9. Okt 2006)

Ähem:
Der Output:


> init:
> deps-jar:
> compile-single:
> run-applet:
> ...





MFG
Rex


----------



## SlaterB (9. Okt 2006)

sieht doch toll aus, da wird von 0 bis 100% in vielen Zwischschritten korrekt gerechnet,
was ist nun das Problem?

edit: zu schnell geantwortet,
Problem ist vielleicht das flush, das erst am Ende alles wirklich wegschreibt,
mach doch mal flush in jedem Durchlauf


----------



## Rex (9. Okt 2006)

...00*total: 917746200
100*total / filesize: 100.0


[macht hier eine lange Pause - Daten werden trotzdem weiterhin gesendet! - Warum?]



Sendevorgang abgeschlossen.!


----------



## SlaterB (9. Okt 2006)

ein Wiederholungsspiel?

Problem ist vielleicht das flush, das erst am Ende alles wirklich wegschreibt, 
mach doch mal flush in jedem Durchlauf


----------



## Rex (9. Okt 2006)

Sorry - aber das Problem besteht ungelindert weiter:
Obwohl 100 pro erreicht sind, wird noch lange weiter fleißig gesendet.
Das Applet reagiert für diesen Zeitraum nicht (soll es auch nicht).



```
private static void pipe(InputStream in, OutputStream out) throws IOException {
        byte[] buf = new byte[500000];
        int nread;
        int navailable;
        int total = 0; //Menge an Bytes bisher gesendet
        int percentage; //Percent done...

        synchronized (in) {
            while((nread = in.read(buf, 0, buf.length)) >= 0) {
                total += nread; //Wieviel bereits gesendet?
System.out.println("nread: "+nread);
System.out.println("filesize: "+filesize);
System.out.println("total: "+total);
System.out.println("100*total: "+(100*total));
System.out.println("100*total / filesize: "+(((float) (100*total))/filesize)); 
                out.write(buf, 0, nread);
                out.flush();
            }
        }        
        buf = null;
    }
```


MFG
vielen Dank!
Rex


----------



## Rex (9. Okt 2006)

Da ich echt verzweifle:


```
import java.net.URLConnection;
import java.net.URL;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.io.File;
import java.io.InputStream;
import java.util.Random;
import java.io.OutputStream;
import java.io.FileInputStream;
import java.util.Iterator;
import javax.swing.JProgressBar;

/**
 * 

Title: Client HTTP Request class</p>
 * 

Description: this class helps to send POST HTTP requests with various form data,
 * including files. Cookies can be added to be included in the request.</p>
 *
 * @author Vlad Patryshev
 * @version 1.0
 */
public class ClientHttpRequest {
    URLConnection connection;
    OutputStream os = null;
    Map cookies = new HashMap();
    static long filesize;
    
    protected void connect() throws IOException {
        if (os == null) os = connection.getOutputStream();
    }
    
    protected void write(char c) throws IOException {
        connect();
        os.write(c);
    }
    
    protected void write(String s) throws IOException {
        connect();
        os.write(s.getBytes());
    }
    
    protected void newline() throws IOException {
        connect();
        write("\r\n");
    }
    
    protected void writeln(String s) throws IOException {
        connect();
        write(s);
        newline();
    }
    
    private static Random random = new Random();
    
    protected static String randomString() {
        return Long.toString(random.nextLong(), 36);
    }
    
    String boundary = "---------------------------" + randomString() + randomString() + randomString();
    
    private void boundary() throws IOException {
        write("--");
        write(boundary);
    }
    
    /**
     * Creates a new multipart POST HTTP request on a freshly opened URLConnection
     *
     * @param connection an already open URL connection
     * @throws IOException
     */
    public ClientHttpRequest(URLConnection connection) throws IOException {
        this.connection = connection;
        connection.setDoOutput(true);
        connection.setRequestProperty("Content-Type",
                "multipart/form-data; boundary=" + boundary);
        connection.addRequestProperty("Accept-Encoding", "gzip,deflate"); //Bugfix by AS: needed for PHP.
    }
    
    /**
     * Creates a new multipart POST HTTP request for a specified URL
     *
     * @param url the URL to send request to
     * @throws IOException
     */
    public ClientHttpRequest(URL url) throws IOException {
        this(url.openConnection());
    }
    
    /**
     * Creates a new multipart POST HTTP request for a specified URL string
     *
     * @param urlString the string representation of the URL to send request to
     * @throws IOException
     */
    public ClientHttpRequest(String urlString) throws IOException {
        this(new URL(urlString));
    }
    
    
    private void postCookies() {
        StringBuffer cookieList = new StringBuffer();
        
        for (Iterator i = cookies.entrySet().iterator(); i.hasNext();) {
            Map.Entry entry = (Map.Entry)(i.next());
            cookieList.append(entry.getKey().toString() + "=" + entry.getValue());
            
            if (i.hasNext()) {
                cookieList.append("; ");
            }
        }
        if (cookieList.length() > 0) {
            connection.setRequestProperty("Cookie", cookieList.toString());
        }
    }
    
    /**
     * adds a cookie to the requst
     * @param name cookie name
     * @param value cookie value
     * @throws IOException
     */
    public void setCookie(String name, String value) throws IOException {
        cookies.put(name, value);
    }
    
    /**
     * adds cookies to the request
     * @param cookies the cookie "name-to-value" map
     * @throws IOException
     */
    public void setCookies(Map cookies) throws IOException {
        if (cookies == null) return;
        this.cookies.putAll(cookies);
    }
    
    /**
     * adds cookies to the request
     * @param cookies array of cookie names and values (cookies[2*i] is a name, cookies[2*i + 1] is a value)
     * @throws IOException
     */
    public void setCookies(String[] cookies) throws IOException {
        if (cookies == null) return;
        for (int i = 0; i < cookies.length - 1; i+=2) {
            setCookie(cookies[i], cookies[i+1]);
        }
    }
    
    private void writeName(String name) throws IOException {
        newline();
        write("Content-Disposition: form-data; name=\"");
        write(name);
        write('"');
    }
    
    /**
     * adds a string parameter to the request
     * @param name parameter name
     * @param value parameter value
     * @throws IOException
     */
    public void setParameter(String name, String value) throws IOException {
        boundary();
        writeName(name);
        newline(); newline();
        writeln(value);
    }
    
    private static void pipe(InputStream in, OutputStream out) throws IOException {
        byte[] buf = new byte[500000];
        int nread;
        int navailable;
        int total = 0; //Menge an Bytes bisher gesendet
        int percentage; //Percent done...
       JProgressBar progress = new JProgressBar(0, 100);
        progress.setValue(0);
        synchronized (in) {
            while((nread = in.read(buf, 0, buf.length)) >= 0) {
                total += nread; //Wieviel bereits gesendet?
System.out.println("nread: "+nread);
System.out.println("filesize: "+filesize);
System.out.println("total: "+total);
System.out.println("100*total: "+(100*total));
System.out.println("100*total / filesize: "+(((float) (100*total))/filesize));
progress.setValue((int)((100*total)/filesize));
                out.write(buf, 0, nread);
                out.flush();
            }
        }        
        buf = null;
        progress.setValue(100);
        progress = null;
    }
    
    /**
     * adds a file parameter to the request
     * @param name parameter name
     * @param filename the name of the file
     * @param is input stream to read the contents of the file from
     * @throws IOException
     */
    public void setParameter(String name, String filename, InputStream is) throws IOException {
        boundary();
        writeName(name);
        write("; filename=\"");
        write(filename);
        write('"');
        newline();
        write("Content-Type: ");
        String type = connection.guessContentTypeFromName(filename);
        if (type == null) type = "application/octet-stream";
        writeln(type);
        newline();
        pipe(is, os);
        newline();
    }
    
    /**
     * adds a file parameter to the request
     * @param name parameter name
     * @param file the file to upload
     * @throws IOException
     */
    public void setParameter(String name, File file) throws IOException {
        filesize = file.length();
        setParameter(name, file.getPath(), new FileInputStream(file));
    }
    
    /**
     * adds a parameter to the request; if the parameter is a File, the file is uploaded, otherwise the string value of the parameter is passed in the request
     * @param name parameter name
     * @param object parameter value, a File or anything else that can be stringified
     * @throws IOException
     */
    public void setParameter(String name, Object object) throws IOException {
        if (object instanceof File) {
            setParameter(name, (File) object);
        } else {
            setParameter(name, object.toString());
        }
    }
    
    /**
     * adds parameters to the request
     * @param parameters "name-to-value" map of parameters; if a value is a file, the file is uploaded, otherwise it is stringified and sent in the request
     * @throws IOException
     */
    public void setParameters(Map parameters) throws IOException {
        if (parameters == null) return;
        for (Iterator i = parameters.entrySet().iterator(); i.hasNext();) {
            Map.Entry entry = (Map.Entry)i.next();
            setParameter(entry.getKey().toString(), entry.getValue());
        }
    }
    
    /**
     * adds parameters to the request
     * @param parameters array of parameter names and values (parameters[2*i] is a name, parameters[2*i + 1] is a value); if a value is a file, the file is uploaded, otherwise it is stringified and sent in the request
     * @throws IOException
     */
    public void setParameters(Object[] parameters) throws IOException {
        if (parameters == null) return;
        for (int i = 0; i < parameters.length - 1; i+=2) {
            setParameter(parameters[i].toString(), parameters[i+1]);
        }
    }
    
    /**
     * posts the requests to the server, with all the cookies and parameters that were added
     * @return input stream with the server response
     * @throws IOException
     */
    public InputStream post() throws IOException {
        boundary();
        writeln("--");
        os.close();
        return connection.getInputStream();
    }
    
    /**
     * posts the requests to the server, with all the cookies and parameters that were added before (if any), and with parameters that are passed in the argument
     * @param parameters request parameters
     * @return input stream with the server response
     * @throws IOException
     * @see setParameters
     */
    public InputStream post(Map parameters) throws IOException {
        setParameters(parameters);
        return post();
    }
    
    /**
     * posts the requests to the server, with all the cookies and parameters that were added before (if any), and with parameters that are passed in the argument
     * @param parameters request parameters
     * @return input stream with the server response
     * @throws IOException
     * @see setParameters
     */
    public InputStream post(Object[] parameters) throws IOException {
        setParameters(parameters);
        return post();
    }
    
    /**
     * posts the requests to the server, with all the cookies and parameters that were added before (if any), and with cookies and parameters that are passed in the arguments
     * @param cookies request cookies
     * @param parameters request parameters
     * @return input stream with the server response
     * @throws IOException
     * @see setParameters
     * @see setCookies
     */
    public InputStream post(Map cookies, Map parameters) throws IOException {
        setCookies(cookies);
        setParameters(parameters);
        return post();
    }
    
    /**
     * posts the requests to the server, with all the cookies and parameters that were added before (if any), and with cookies and parameters that are passed in the arguments
     * @param cookies request cookies
     * @param parameters request parameters
     * @return input stream with the server response
     * @throws IOException
     * @see setParameters
     * @see setCookies
     */
    public InputStream post(String[] cookies, Object[] parameters) throws IOException {
        setCookies(cookies);
        setParameters(parameters);
        return post();
    }
    
    /**
     * post the POST request to the server, with the specified parameter
     * @param name parameter name
     * @param value parameter value
     * @return input stream with the server response
     * @throws IOException
     * @see setParameter
     */
    public InputStream post(String name, Object value) throws IOException {
        setParameter(name, value);
        return post();
    }
    
    /**
     * post the POST request to the server, with the specified parameters
     * @param name1 first parameter name
     * @param value1 first parameter value
     * @param name2 second parameter name
     * @param value2 second parameter value
     * @return input stream with the server response
     * @throws IOException
     * @see setParameter
     */
    public InputStream post(String name1, Object value1, String name2, Object value2) throws IOException {
        setParameter(name1, value1);
        return post(name2, value2);
    }
    
    /**
     * post the POST request to the server, with the specified parameters
     * @param name1 first parameter name
     * @param value1 first parameter value
     * @param name2 second parameter name
     * @param value2 second parameter value
     * @param name3 third parameter name
     * @param value3 third parameter value
     * @return input stream with the server response
     * @throws IOException
     * @see setParameter
     */
    public InputStream post(String name1, Object value1, String name2, Object value2, String name3, Object value3) throws IOException {
        setParameter(name1, value1);
        return post(name2, value2, name3, value3);
    }
    
    /**
     * post the POST request to the server, with the specified parameters
     * @param name1 first parameter name
     * @param value1 first parameter value
     * @param name2 second parameter name
     * @param value2 second parameter value
     * @param name3 third parameter name
     * @param value3 third parameter value
     * @param name4 fourth parameter name
     * @param value4 fourth parameter value
     * @return input stream with the server response
     * @throws IOException
     * @see setParameter
     */
    public InputStream post(String name1, Object value1, String name2, Object value2, String name3, Object value3, String name4, Object value4) throws IOException {
        setParameter(name1, value1);
        return post(name2, value2, name3, value3, name4, value4);
    }
    
    /**
     * posts a new request to specified URL, with parameters that are passed in the argument
     * @param parameters request parameters
     * @return input stream with the server response
     * @throws IOException
     * @see setParameters
     */
    public static InputStream post(URL url, Map parameters) throws IOException {
        return new ClientHttpRequest(url).post(parameters);
    }
    
    /**
     * posts a new request to specified URL, with parameters that are passed in the argument
     * @param parameters request parameters
     * @return input stream with the server response
     * @throws IOException
     * @see setParameters
     */
    public static InputStream post(URL url, Object[] parameters) throws IOException {
        return new ClientHttpRequest(url).post(parameters);
    }
    
    /**
     * posts a new request to specified URL, with cookies and parameters that are passed in the argument
     * @param cookies request cookies
     * @param parameters request parameters
     * @return input stream with the server response
     * @throws IOException
     * @see setCookies
     * @see setParameters
     */
    public static InputStream post(URL url, Map cookies, Map parameters) throws IOException {
        return new ClientHttpRequest(url).post(cookies, parameters);
    }
    
    /**
     * posts a new request to specified URL, with cookies and parameters that are passed in the argument
     * @param cookies request cookies
     * @param parameters request parameters
     * @return input stream with the server response
     * @throws IOException
     * @see setCookies
     * @see setParameters
     */
    public static InputStream post(URL url, String[] cookies, Object[] parameters) throws IOException {
        return new ClientHttpRequest(url).post(cookies, parameters);
    }
    
    /**
     * post the POST request specified URL, with the specified parameter
     * @param name parameter name
     * @param value parameter value
     * @return input stream with the server response
     * @throws IOException
     * @see setParameter
     */
    public static InputStream post(URL url, String name1, Object value1) throws IOException {
        return new ClientHttpRequest(url).post(name1, value1);
    }
    
    /**
     * post the POST request to specified URL, with the specified parameters
     * @param name1 first parameter name
     * @param value1 first parameter value
     * @param name2 second parameter name
     * @param value2 second parameter value
     * @return input stream with the server response
     * @throws IOException
     * @see setParameter
     */
    public static InputStream post(URL url, String name1, Object value1, String name2, Object value2) throws IOException {
        return new ClientHttpRequest(url).post(name1, value1, name2, value2);
    }
    
    /**
     * post the POST request to specified URL, with the specified parameters
     * @param name1 first parameter name
     * @param value1 first parameter value
     * @param name2 second parameter name
     * @param value2 second parameter value
     * @param name3 third parameter name
     * @param value3 third parameter value
     * @return input stream with the server response
     * @throws IOException
     * @see setParameter
     */
    public static InputStream post(URL url, String name1, Object value1, String name2, Object value2, String name3, Object value3) throws IOException {
        return new ClientHttpRequest(url).post(name1, value1, name2, value2, name3, value3);
    }
    
    /**
     * post the POST request to specified URL, with the specified parameters
     * @param name1 first parameter name
     * @param value1 first parameter value
     * @param name2 second parameter name
     * @param value2 second parameter value
     * @param name3 third parameter name
     * @param value3 third parameter value
     * @param name4 fourth parameter name
     * @param value4 fourth parameter value
     * @return input stream with the server response
     * @throws IOException
     * @see setParameter
     */
    public static InputStream post(URL url, String name1, Object value1, String name2, Object value2, String name3, Object value3, String name4, Object value4) throws IOException {
        return new ClientHttpRequest(url).post(name1, value1, name2, value2, name3, value3, name4, value4);
    }
}
```

Das Problem ist, dass
a) mir leider nicht die ProgressBar angezeigt wird.
und
b) obwohl intern (Debug) 100 % erreicht sind aber trotzdem noch gesendet wird.

VIelen Dank!
MFG
Rex


----------



## Roar (9. Okt 2006)

du bist derbst der noob eh.
erstens: wo sollte deine progressbar angezeigt werden. in deiner total sinnlosen methode pipe() erzeugst du eine progressbar, spielst damit rum, und setzt sie am ende der methode wieder auf null - wozu?
zweitens: dir wurde jetz schon x-mal gesagt, dass int / int wieder einen int ergbit.
drittens: dass deine URLConnection die daten den du in deinen OutputStream schreibst bufferst is dir schon klar?
viertens: hörst mah auf jedesmal die selben 500 zeilen code hier zu posten
fünftens: mein angebot steht übrigens noch immer: 50 euro :O


----------



## SlaterB (9. Okt 2006)

das JProgressbar in eine GUI gehört und der Pipe-Code in einen Thread, das dürfte dir wirklich bekannt vorkommen,

nun liegt es an dieser URLConnection, was damit los ist weiß ich nicht, kann ich auch schlecht testen,

es gibt dort eine Operation setUseCaches(false), vielleicht hilft die dir,

damit es auch mal bisschen vorangeht hier ein lauffähiges Beispiel, welches allerdings nur mit Datei-Streams arbeitet,
Achtung, erzeugt eine 50 MB-Datei:


```
package test;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.FileOutputStream;
import java.io.OutputStream;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JProgressBar;

public class TestFrame extends JFrame {

    JProgressBar bar = new JProgressBar();

    public TestFrame() {
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        JButton button = new JButton("start Thread");
        button.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {
                TestFrame.this.setValue(0);
                new Thread(new Runnable() {

                    public void run() {
                        try {
                            doRun();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }

                    public void doRun() throws Exception {
                        OutputStream out = new FileOutputStream("test.txt");

                        int bufSize = 500000;
                        int rounds = 100;
                        int fileSize = bufSize * rounds;

                        byte[] buf = new byte[bufSize];
                        for (int i = buf.length - 1; i >= 0; i--) {
                            buf[i] = 55;
                        }

                        long total = 0;
                        for (int i = 0; i < rounds; i++) {
                            out.write(buf, 0, bufSize);
                            out.flush();
                            total += bufSize;
                            int percent = (int) ( ( total * 100 ) / fileSize );
                            System.out.println("%: " + percent);
                            TestFrame.this.setValue(percent);

                        }
                        out.close();
                        Thread.sleep(500); // wait 0.5 seconds
                        TestFrame.this.setValue(0);
                    }

                }).start();
            }
        });

        JPanel p = new JPanel();
        p.add(button);
        p.add(bar);
        bar.setValue(0);
        getContentPane().add(p);
        setSize(200, 100);
        setVisible(true);

    }

    public void setValue(int value) {
        bar.setValue(value);
    }

    public static void main(String[] args) {
        new TestFrame();
    }
}
```

------

wenn die erste Datei geschrieben wurde kann man genauso gut diese einlesen und wieder schreiben, um deinen Input/ Output möglichst nahezukommen,

Achtung, erzeugt eine zweite 50 MB-Datei  :


```
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JProgressBar;

public class TestFrame extends JFrame {

    JProgressBar bar = new JProgressBar();

    public TestFrame() {
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        JButton button = new JButton("start Thread");
        button.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {
                TestFrame.this.setValue(0);
                new Thread(new Runnable() {

                    public void run() {
                        try {
                            doRun();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }

                    public void doRun() throws Exception {
                        InputStream in = new FileInputStream("test.txt");
                        OutputStream out = new FileOutputStream("test2.txt");

                        int bufSize = 500000;
                        int rounds = 100;
                        int nread = 0;
                        int fileSize = bufSize * rounds;

                        byte[] buf = new byte[bufSize];

                        long total = 0;
                        while (nread >= 0) {
                            nread = in.read(buf, 0, buf.length);
                            System.out.println("nread: " + nread);
                            if (nread >= 0) {
                                out.write(buf, 0, bufSize);
                                out.flush();
                                total += nread;
                                int percent = (int) ( ( total * 100 ) / fileSize );
                                System.out.println("%: " + percent);
                                TestFrame.this.setValue(percent);
                            }
                        }
                        in.close();
                        out.close();
                        Thread.sleep(500); // wait 0.5 seconds
                        TestFrame.this.setValue(0);
                    }

                }).start();
            }
        });

        JPanel p = new JPanel();
        p.add(button);
        p.add(bar);
        bar.setValue(0);
        getContentPane().add(p);
        setSize(200, 100);
        setVisible(true);

    }

    public void setValue(int value) {
        bar.setValue(value);
    }

    public static void main(String[] args) {
        new TestFrame();
    }
}
```


----------



## Rex (9. Okt 2006)

```
private static void pipe(InputStream in, OutputStream out) throws IOException {
        byte[] buf = new byte[500000];
        int nread;
        int navailable;
        int total = 0; //Menge an Bytes bisher gesendet
        int percentage; //Percent done...

        synchronized (in) {
            while((nread = in.read(buf, 0, buf.length)) >= 0) {
                total += nread; //Wieviel bereits gesendet?
            int percent = (int) ( ( total * 100 ) / filesize );
             System.out.println("%: " + percent); 
                out.write(buf, 0, nread);
                out.flush();
            }
        }        
        buf = null;
    }
```

So sieht's jetzt aus!
Ehm... Allerdings dasselbe Problem   
100 % aber trotzdem sendet der noch 


MFG
Rex


----------



## SlaterB (9. Okt 2006)

tolle Antwort,
dass es gar nicht mehr um die Prozentrechnung geht, hast du inzwischen mitbekommen? 


egal was du in pipe machst, die richtige Arbeit wird anscheinend erst nach Pipe durchgeführt
(mache zur Sicherheit mal ein System.out.println am Ende der Operation),

z.B. wenn der Thread, in dem pipe läuft, fertig ist,
aber davon hast du bisher ja noch gar nix gepostet 
(und wage nicht noch mal ClientHttpRequest zu posten, das ist NICHT der Code, der das alles ins Rollen bringt  )

na ich geb's erstmal auf


----------



## Rex (9. Okt 2006)

Aha - dass ist die zweite Class "DFApplet"


```
import java.applet.*;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.MediaTracker;
import java.awt.event.*;
import java.awt.datatransfer.*;
import java.awt.dnd.*;
import java.awt.image.BufferedImage;
import java.io.*;
import java.net.*;
import java.util.*;
import javax.swing.*;
import javax.swing.JOptionPane;

public class DFApplet extends Applet {
    private String SID;
    private String TID;
    private String receiveURL;
    private String orderno;
    private Image img;
    
    public void init() {
        System.out.println("Init. Vers. 1.1 - WAYW_");
        //Parameter aus der Webseite auslesen
        SID = getParameter("SID");
        TID = getParameter("TID");
        receiveURL = getParameter("receiveURL");
        orderno = getParameter("OID");
        
        //TEST;
        SID = "221212112";
        orderno = "1";
        receiveURL = "djdjd";
        TID = "383883";
        //
        
        new DropTarget(this, new DropTargetAdapter() {
            public void drop(DropTargetDropEvent e) {
                try {
                    Transferable t = e.getTransferable();
                    DataFlavor d = e.getCurrentDataFlavors()[0];
                    e.acceptDrop(e.getDropAction());
                    List a = (List) t.getTransferData(d);
                    for (int i = 0; i < a.size(); i++) {
                        processFile((File) a.get(i));
                    }
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
        });
        
    }
    public void processFile(File f) {
        System.out.println("Datei erhalten!\nSende...");
        
        try {
            InputStream serverInput = ClientHttpRequest.post(
                    new URL("http://www.xxx.de/test/uptest.php"),
                    new Object[] {
                "orderno", orderno,
                "SID", SID,
                "data", f
            });
            
            
            System.out.println("Sendevorgang abgeschlossen.");
     }        
   
}
```

Vielen Dank!
MFG
Rex


----------



## SlaterB (10. Okt 2006)

was in der Operation drop-steht muss in einen Thread,
die JProgressBar in das Applet falls möglich,
ansonsten im Applet-Forum einen Thread eröffnen 
(auch wenn die da sicher nicht erfreut wären,
selber Java lernen wäre passender  )

------

was ist denn mit 'Sendevorgang abgeschlossen',
erscheint dies vor oder nach dem lange dauernden Senden,

was ist mit dem Vorschlag
connection.setUseCaches(false);
?

ansonsten ist URLConnection sicherlich ein sehr spezielles Thema,
da ist ein neuer Thread im Unterforum 'Netzwerprogrammierung' sicherlich berechtigt,
aber wage nicht, nochmal deine 500 Zeilen zu posten 
verlinke stattdessen auf diesen Thread hier
(URL aus dem Adress-Fenster des Browsers kopieren)


----------



## Rex (10. Okt 2006)

Ja... und jetzt?
Weiß jemand eine Lösung zu diesem Problem?
Liegt es am Buffer?

Vielen Dank!
MFG
Rex


----------



## Bert Brenner (10. Okt 2006)

Du berechnest nach dem Lesen des InputStreams in deinen Puffer den Fortschritt, vielleicht solltest du das immer erst wenn die Daten auch im OutputStream gelandet sind.

Bei einem 500000 Byte grossem Puffer kann das evtl. die Zeit sein die dir fehlt.


----------



## Rex (10. Okt 2006)

Aha - ich habe jetzt

den Buffer auf 1
gesetzt.

Und es scheint zu gehen.

Gibt es eigentlich Perfomance-Verluste, wenn man den Buffer aus 1 - also quasi ganz - reduziert?

MFG
vielen Dank!
Rex


----------



## Rex (10. Okt 2006)

```
private static void pipe(InputStream in, OutputStream out) throws IOException {
        byte[] buf = new byte[1];
        int nread;
        int navailable;
        int total = 0; //Menge an Bytes bisher gesendet
        int oldpercent = 0;
        int percentage = 0; //Percent done...
   
        synchronized (in) {
            while((nread = in.read(buf, 0, buf.length)) >= 0) {
                total += nread; //Wieviel bereits gesendet?
            int percent = (int) ( ( total * 100 ) / filesize ); 
            if(oldpercent < percent){
             System.out.println("%: " + percent); 
            }
                out.write(buf, 0, nread);
                out.flush();  
                oldpercent = percent;   
            }
        }        
        buf = null;
    }
```

so sieht's aus.

Leider stimmen die 100 pro immer noch nicht!


Warum?

Vielen Dank!
MFG
Rex


----------

