long ipToLong (String ip)
    {
    	try
    	{
	    	String[] splittedIP = ip.split("\\.");
	    	if (splittedIP.length > 0) {
		    	int A = Integer.parseInt (splittedIP[0]);
		    	int B = Integer.parseInt (splittedIP[1]);
		    	int C = Integer.parseInt (splittedIP[2]);
		    	int D = Integer.parseInt (splittedIP[3]);

		    	return (A * (256*256*256) + B * (256*256) + C * 256 + D);
	    	}

	    	return 0;
	    } catch (Exception e) {
    		System.out.println ("IP Convert failed: " + e);
    		return 0;
    	}

    }

int i = 12;
System.out.println(i.toString ());

so bekommt man allerdings einen unschönen “Can´t invoke a method on an int.” Fehler

Also bin ich auf folgende 2 Lösungen gekommen:

int i = 12;

System.out.println ("" + i); // die unschöne Variante

System.out.println (String.valueOf(i)); // die wohl beste Lösung

Von String zu InputStream ist das nur ein Einzeiler:

// Die benötigten Imports
import java.io.ByteArrayInputStream;
import java.io.InputStream;

String text = "test";
InputStream is = new ByteArrayInputStream(text.getBytes("UTF-8"));

Von InputStream zu String sind es allerdings ein paar Zeilen mehr

// Die benötigten Imports
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
import java.io.Writer;
import java.io.Reader;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class StreamToString {

    public static void main(String[] args) throws Exception {
        StreamToString sts = new StreamToString();

        /*
         * Get input stream of our data file. This file can be in
         * the root of you application folder or inside a jar file
         * if the program is packed as a jar.
         */
        InputStream is =
                sts.getClass().getResourceAsStream("/data.txt");

        /*
         * Call the method to convert the stream to string
         */
        System.out.println(sts.convertStreamToString(is));
    }

    public String convertStreamToString(InputStream is)
            throws IOException {
        /*
         * To convert the InputStream to String we use the
         * Reader.read(char[] buffer) method. We iterate until the
         * Reader return -1 which means there's no more data to
         * read. We use the StringWriter class to produce the string.
         */
        if (is != null) {
            Writer writer = new StringWriter();

            char[] buffer = new char[1024];
            try {
                Reader reader = new BufferedReader(
                        new InputStreamReader(is, "UTF-8"));
                int n;
                while ((n = reader.read(buffer)) != -1) {
                    writer.write(buffer, 0, n);
                }
            } finally {
                is.close();
            }
            return writer.toString();
        } else {
            return "";
        }
    }
}

Ich habe den Test gemacht und das Ergebnis ist nicht verwunderlich.

Das ist mein PHP Code ohne des unsetten der Klassen:

<?php
class Foo
{
    public $var = '3.1415962654';
}

$baseMemory = memory_get_usage();

for ( $i = 0; $i <= 100000; $i++ )
{
        $a = new Foo;
        $a->self = $a;
}

echo ((memory_get_peak_usage()) / 1024 /024). " MB\n";
echo ((memory_get_usage() - $baseMemory) / 1024 / 1024) . " MB\n";
?>

Dabei kam folgendes Resultat heraus:

Der Memory Peak lad bei unglaublichen 3395,21 MB Das sind 3,3GB!!!
Und der ganze Memory Verbrauch lad bei 66,23 MB.
[/sourcecode]

Also habe ich das ganze nochmal mit unsetten der Klasse im PHP Code gemacht:

<?php
class Foo
{
    public $var = '3.1415962654';

    // Das ist die neue Funktion zum vernichten der Klasse
    function destroy()
    {
        $this->self = null;
    }

}

$baseMemory = memory_get_usage();

for ( $i = 0; $i <= 100000; $i++ )
{
        $a = new Foo;
        $a->self = $a;
        $a->destroy(); // Hier wird die Klasse bei jedem Aufruf vernichtet
}

echo ((memory_get_peak_usage()) / 1024 /024). " MB\n";
echo ((memory_get_usage() - $baseMemory) / 1024 / 1024) . " MB\n";
?>

Und siehe da…. es ist sogar sehr wichtig, dass wir in unserem PHP Code Klassen, Variablen und Mehtoden unsetten!

Der Memory Peak beträgt jetzt nur noch 5,10 MB!!!
Und der komplette Memory Verbraucht liegt bei gerade mal 0,0014 MB was ca. 1,4 KB sind.

Hier nochmal die Zusammenfassung mit und ohne unsetten der Klassen im PHP Code.

Verbraucht mit reset:
5.1078125 MB
0.00140380859375 MB

Verbrauch ohne reset:
3395.219140625 MB
66.230880737305 MB

Und so sieht die Funktion aus:

function get_dpi($filename){

    // open the file and read first 20 bytes.
    $a = fopen($filename,'r');
    $string = fread($a,20);
    fclose($a);

    // get the value of byte 14th up to 18th
    $data = bin2hex(substr($string,14,4));
    $x = substr($data,0,4);
    $y = substr($data,4,4);
    return array(hexdec($x),hexdec($y));

}

Die Funktion funktioniert allerdings nicht bei Bildern von einer Digitalkamera…
Wenn man z.B. ein Bild in Photoshop erstellt kann man die exakten DPI auslesen.

Und natürlich gibt es auch wie immer ein Stück Sample Code dazu:

print_r(get_dpi2('filename.jpg'));

App Store Review Guidelines

Auch in einem zweiten, oft kritisierten Punkt geht Apple auf seine Kritiker zu: Das Unternehmen veröffentlicht erstmals die Richtlinien, die beim Prüfen einer App für die Zulassung im App Store angewandt werden. Die App Store Review Guidelines sollen Entwicklern helfen zu verstehen, wie Apple eingereichte Apps prüft.

Darüber hinaus bietet Apple ein Formular an, mit dem Entwickler, deren Applikationen abgelehnt wurden, Einspruch einlegen und weitere Details zur Funktion ihrer Applikationen einreichen können.

Letztendlich will Apple damit dem Argument begegnen, Applikationen würden willkürlich abgelehnt und Investitionen in eine Entwicklung von iOS-Applikationen seien entsprechend unsicher. In einem Punkt, der vor allem für Verlage relevant ist, aber bleibt Apple hart: Entwickler dürfen ohne explizite Erlaubnis von Apple keine weiteren Funktionen oder Inhalte für eine Applikation freischalten, es sei denn, sie verwenden dafür Apples Funktion für In-App-Verkäufe. (ji)