it-swarm.com.ru

Как я могу сжать и разархивировать строку, используя GZIPOutputStream, который совместим с .Net?

Мне нужен пример для сжатия строки с помощью GZip в Android. Я хочу отправить строку типа «привет» в метод и получить следующую сжатую строку:

BQAAAB + LCAAAAAAABADtvQdgHEmWJSYvbcp7f0r1StfgdKEIgGATJNiQQBDswYjN5pLsHWlHIymrKoHKZVZlXWYWQMztnbz33nvvvffee ++ 997o7nU4n99 // P1xmZAFs9s5K2smeIYCqyB8/fnwfPyLmeVlW/ш + GphA2BQAAAA ==

Тогда мне нужно распаковать его. Кто-нибудь может дать мне пример и выполнить следующие методы?

private String compressString(String input) {
    //...
}

private String decompressString(String input) {
    //...
}

Спасибо,


Обновление

Согласно ответу сессора , теперь у меня есть следующие 4 метода. Android и .net сжимают и распаковывают методы. Эти методы совместимы друг с другом, за исключением одного случая. Я имею в виду, что они совместимы в первых 3 штатах, но несовместимы в 4-м:

  • состояние 1) Android.compress <-> Android.decompress: (OK)
  • состояние 2) Net.compress <-> Net.decompress: (OK)
  • состояние 3) Net.compress -> Android.decompress: (OK)
  • состояние 4) Android.compress -> .Net.decompress: (НЕ ОК)

кто-нибудь может решить это?

Методы Android:

public static String compress(String str) throws IOException {

    byte[] blockcopy = ByteBuffer
            .allocate(4)
            .order(Java.nio.ByteOrder.LITTLE_ENDIAN)
            .putInt(str.length())
            .array();
    ByteArrayOutputStream os = new ByteArrayOutputStream(str.length());
    GZIPOutputStream gos = new GZIPOutputStream(os);
    gos.write(str.getBytes());
    gos.close();
    os.close();
    byte[] compressed = new byte[4 + os.toByteArray().length];
    System.arraycopy(blockcopy, 0, compressed, 0, 4);
    System.arraycopy(os.toByteArray(), 0, compressed, 4,
            os.toByteArray().length);
    return Base64.encode(compressed);

}

public static String decompress(String zipText) throws IOException {
    byte[] compressed = Base64.decode(zipText);
    if (compressed.length > 4)
    {
        GZIPInputStream gzipInputStream = new GZIPInputStream(
                new ByteArrayInputStream(compressed, 4,
                        compressed.length - 4));

        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        for (int value = 0; value != -1;) {
            value = gzipInputStream.read();
            if (value != -1) {
                baos.write(value);
            }
        }
        gzipInputStream.close();
        baos.close();
        String sReturn = new String(baos.toByteArray(), "UTF-8");
        return sReturn;
    }
    else
    {
        return "";
    }
}

.Net методы:

public static string compress(string text)
{
    byte[] buffer = Encoding.UTF8.GetBytes(text);
    MemoryStream ms = new MemoryStream();
    using (GZipStream Zip = new GZipStream(ms, CompressionMode.Compress, true))
    {
        Zip.Write(buffer, 0, buffer.Length);
    }

    ms.Position = 0;
    MemoryStream outStream = new MemoryStream();

    byte[] compressed = new byte[ms.Length];
    ms.Read(compressed, 0, compressed.Length);

    byte[] gzBuffer = new byte[compressed.Length + 4];
    System.Buffer.BlockCopy(compressed, 0, gzBuffer, 4, compressed.Length);
    System.Buffer.BlockCopy(BitConverter.GetBytes(buffer.Length), 0, gzBuffer, 0, 4);
    return Convert.ToBase64String(gzBuffer);
}

public static string decompress(string compressedText)
{
    byte[] gzBuffer = Convert.FromBase64String(compressedText);
    using (MemoryStream ms = new MemoryStream())
    {
        int msgLength = BitConverter.ToInt32(gzBuffer, 0);
        ms.Write(gzBuffer, 4, gzBuffer.Length - 4);

        byte[] buffer = new byte[msgLength];

        ms.Position = 0;
        using (GZipStream Zip = new GZipStream(ms, CompressionMode.Decompress))
        {
            Zip.Read(buffer, 0, buffer.Length);
        }

        return Encoding.UTF8.GetString(buffer);
    }
}
54
Bobs

Методы GZIP:

public static byte[] compress(String string) throws IOException {
    ByteArrayOutputStream os = new ByteArrayOutputStream(string.length());
    GZIPOutputStream gos = new GZIPOutputStream(os);
    gos.write(string.getBytes());
    gos.close();
    byte[] compressed = os.toByteArray();
    os.close();
    return compressed;
}

public static String decompress(byte[] compressed) throws IOException {
    final int BUFFER_SIZE = 32;
    ByteArrayInputStream is = new ByteArrayInputStream(compressed);
    GZIPInputStream gis = new GZIPInputStream(is, BUFFER_SIZE);
    StringBuilder string = new StringBuilder();
    byte[] data = new byte[BUFFER_SIZE];
    int bytesRead;
    while ((bytesRead = gis.read(data)) != -1) {
        string.append(new String(data, 0, bytesRead));
    }
    gis.close();
    is.close();
    return string.toString();
}

И тест:

final String text = "hello";
try {
    byte[] compressed = compress(text);
    for (byte character : compressed) {
        Log.d("test", String.valueOf(character));
    }
    String decompressed = decompress(compressed);
    Log.d("test", decompressed);
} catch (IOException e) {
    e.printStackTrace();
}

=== Обновление ===

Если вам нужна совместимость с .Net, мой код должен быть немного изменен:

public static byte[] compress(String string) throws IOException {
    byte[] blockcopy = ByteBuffer
        .allocate(4)
        .order(Java.nio.ByteOrder.LITTLE_ENDIAN)
        .putInt(string.length())
        .array();
    ByteArrayOutputStream os = new ByteArrayOutputStream(string.length());
    GZIPOutputStream gos = new GZIPOutputStream(os);
    gos.write(string.getBytes());
    gos.close();
    os.close();
    byte[] compressed = new byte[4 + os.toByteArray().length];
    System.arraycopy(blockcopy, 0, compressed, 0, 4);
    System.arraycopy(os.toByteArray(), 0, compressed, 4, os.toByteArray().length);
    return compressed;
}

public static String decompress(byte[] compressed) throws IOException {
    final int BUFFER_SIZE = 32;
    ByteArrayInputStream is = new ByteArrayInputStream(compressed, 4, compressed.length - 4);
    GZIPInputStream gis = new GZIPInputStream(is, BUFFER_SIZE);
    StringBuilder string = new StringBuilder();
    byte[] data = new byte[BUFFER_SIZE];
    int bytesRead;
    while ((bytesRead = gis.read(data)) != -1) {
        string.append(new String(data, 0, bytesRead));
    }
    gis.close();
    is.close();
    return string.toString();
}

Вы можете использовать тот же тестовый скрипт.

83
scessor

Как бы то ни было, сжатый «Hello» в BQAAAB + LC ... является особенно плохой реализацией gzipper. Он расширил «Hello» намного, намного больше, чем необходимо, используя динамический блок вместо статического блока в формате deflate. После удаления четырехбайтового префикса в потоке gzip (который всегда начинается с шестнадцатеричного 1f 8b), «Hello» был расширен до 123 байтов. В мире сжатия это считается преступлением.

Метод Compress, на который вы жалуетесь, работает правильно и правильно. Он генерирует статический блок с общим выходом 25 байтов. Формат gzip имеет десятибайтовый заголовок и восьмибайтовый заголовок трейлера, в результате чего пятибайтовый ввод был закодирован в семь байтов. Это больше походит на это.

Потоки, которые не сжимаются, будут расширены, но это не должно быть слишком много. Формат deflate, используемый gzip, добавит пять байтов к каждому 16K-64K для несжимаемых данных.

Чтобы получить фактическое сжатие, в общем, вам нужно дать компрессору гораздо больше для работы с этими пятью байтами, чтобы он мог найти повторяющиеся строки и смещенную статистику в сжимаемых данных. Я понимаю, что вы просто делали тесты с короткой строкой. Но в реальном приложении вы бы никогда не использовали универсальный компрессор с такими короткими строками, так как всегда было бы лучше просто отправить строку.

14
Mark Adler

Я попробовал ваш код в своем проекте и обнаружил ошибку кодирования в методе сжатия на Android:

byte[] blockcopy = ByteBuffer
        .allocate(4)
        .order(Java.nio.ByteOrder.LITTLE_ENDIAN)
        .putInt(str.length())
        .array();
ByteArrayOutputStream os = new ByteArrayOutputStream(str.length());
GZIPOutputStream gos = new GZIPOutputStream(os);
gos.write(str.getBytes());

в приведенном выше коде вы должны использовать исправленную кодировку и заполнить длину байтов, а не длину строки:

byte[] data = str.getBytes("UTF-8");

byte[] blockcopy = ByteBuffer
        .allocate(4)
        .order(Java.nio.ByteOrder.LITTLE_ENDIAN)
        .putInt(data.length)
            .array();

ByteArrayOutputStream os = new ByteArrayOutputStream( data.length );    
GZIPOutputStream gos = new GZIPOutputStream(os);
gos.write( data );
4
Halowb

В вашем методе Decompress() первые 4 байта декодированного ввода Base64 пропускаются перед передачей в GZipInputStream. Обнаружено, что эти байты являются 05 00 00 00 в данном конкретном случае. Таким образом, в методе Compress() эти байты должны быть возвращены непосредственно перед кодированием Base64.

Если я сделаю это, Compress () вернет следующее:

BQAAAB+LCAAAAAAAAADLSM3JyQcAhqYQNgUAAAA=

Я знаю, что это не совсем то, что вы ожидаете, а именно:

BQAAAB+LCAAAAAAABADtvQdgHEmWJSYvbcp7f0r1StfgdKEIgGATJNiQQBDswYjN5pLsHWlHIymrKoHKZVZlXWYWQMztnbz33nvvvffee++997o7nU4n99//P1xmZAFs9s5K2smeIYCqyB8/fnwfPyLmeVlW/w+GphA2BQAAAA==

Но, если мой результат будет снова подключен к Decompress(), я думаю, вы все равно получите "Hello". Попытайся. Разница может быть связана с разным уровнем сжатия, с которым вы получили исходную строку.

Так, каковы загадочные префиксные байты 05 00 00 00? Согласно этот ответ это может быть длина сжатой строки, чтобы программа знала, какой длины должен быть распакованный буфер байтов. Тем не менее, это не соответствует в этом случае.

Это модифицированный код для compress ():

public static String Compress(String text) throws IOException {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();

    // TODO: Should be computed instead of being hard-coded
    baos.write(new byte[]{0x05, 0, 0, 0}, 0, 4);

    GZIPOutputStream gzos = new GZIPOutputStream(baos);
    gzos.write(text.getBytes());
    gzos.close();

    return Base64.encode(baos.toByteArray());
}

Обновление:

Причина, по которой выходные строки в Android и ваш код .NET не совпадают, заключается в том, что реализация .NET GZip обеспечивает более быстрое сжатие (и, следовательно, больший вывод). В этом можно убедиться, посмотрев на необработанные значения Base64 декодированных байтов:

.СЕТЬ:

 1F8B 0800 0000 0000 0400 EDBD 0760 1C49 
 9625 262F 6DCA 7B7F 4AF5 4AD7 E074 A108 
 8060 1324 D890 4010 ECC1 88CD E692 EC1D 
 6947 2329 AB2A 81CA 6556 655D 6616 40CC 
 ED9D BCF7 DE7B BF7FBDFDFBDFBDFBDFBDFBDFBDFBDFBDFDBBBBBBBBBFBFBDBDFBDBBBBBBBBFBFBBBBBBFBFFFBFBFBFBFBFBFBFBFBFBFBFBFBFBBBFBFBFBFBFF. .9D4E 27F7 DFFF 3F5C 6664 016C F6CE 4ADA 
 C99E 2180 AAC8 1F3F 7E7C 1F3F 22E6 7959 
 56FF 0F86 A610 3605 0000 00 

Моя версия Android:

 1F8B 0800 0000 0000 0000 CB48 CDC9 C907 
 0086 A610 3605 0000 00 

Теперь, если мы проверим GZip File Format , мы увидим, что версии .NET и Android в основном идентичны в исходном заголовке и в конечных полях CRC32 и Size. Единственные различия в следующих полях:

  • XFL = 04 (компрессор использовал самый быстрый алгоритм) в случае .NET, тогда как в Android это 00
  • Фактические сжатые блоки

Итак, из поля XFL видно, что алгоритм сжатия .NET дает более длинный вывод.

На самом деле, когда я создаю двоичный файл с этими значениями необработанных данных, а затем распаковываю их с помощью gunzip, обе версии .NET и Android дали точно такой же вывод, что и «привет».

Так что вам не нужно беспокоиться о разных результатах.

4
Dheeraj V.S.

Я сошел с ума с этой проблемой. В конце, в моем случае (.Net 4) не было необходимости добавлять эти дополнительные 4 байта в начале для .Net совместимости. 

Это работает просто так:

Android Compress:

public static byte[] compress(String string) throws IOException {
    ByteArrayOutputStream os = new ByteArrayOutputStream(string.length());
    GZIPOutputStream gos = new GZIPOutputStream(os);
    gos.write(string.getBytes());
    gos.close();
    byte[] compressed = os.toByteArray();
    os.close();
    return compressed;
}

.Net Decompress

public static byte[] DecompressViD(byte[] gzip)
    {
        // Create a GZIP stream with decompression mode.
        // ... Then create a buffer and write into while reading from the GZIP stream.
        using (GZipStream stream = new GZipStream(new MemoryStream(gzip), CompressionMode.Decompress))
        {
            const int size = 4096;
            byte[] buffer = new byte[size];
            using (MemoryStream memory = new MemoryStream())
            {
                int count = 0;
                do
                {
                    count = stream.Read(buffer, 0, size);
                    if (count > 0)
                    {
                        memory.Write(buffer, 0, count);
                    }
                }
                while (count > 0);
                return memory.ToArray();
            }
        }
    }
2
Ivan BASART

Хорошо, я ненавижу звонить, когда есть тонны существующих ответов, но, к сожалению, большинство из них просто неверны по разным причинам:

  • Существуют различия между алгоритмами GZIP в .NET Framework. Если вы используете .NET 4.5, большинство жалоб, которые вы видите в разных ответах, просто не относятся к вам (скорее к тем, кто использует 2.0 или 3.5). Если вы работаете с «фиксированными» версиями кода, вы фактически испортите сжатие/распаковку.
  • Java использует неподписанный байт [], .NET использует подписанный байт []. Это может вызвать проблемы во время передачи в зависимости от того, как именно вы передаете этот байт [].
  • Я использовал Base64 для передачи байта [], что может создать еще больше проблем. Есть множество других причин, но давайте пропустим дальнейшее нытье и перейдем к коду ...

Если вы используете .NET Framework 4.5, вам нужен класс C # (в качестве бонуса Base64):

public class CompressString
{
    private static void CopyTo(Stream src, Stream dest)
    {
        byte[] bytes = new byte[4096];
        int cnt;

        while ((cnt = src.Read(bytes, 0, bytes.Length)) != 0)
        {
            dest.Write(bytes, 0, cnt);
        }
    }

    public static byte[] Zip(string str)
    {
        var bytes = Encoding.UTF8.GetBytes(str);

        using (var msi = new MemoryStream(bytes))
        using (var mso = new MemoryStream())
        {
            using (var gs = new GZipStream(mso, CompressionMode.Compress))
            {
                //msi.CopyTo(gs);
                CopyTo(msi, gs);
            }

            return mso.ToArray();
        }
    }

    public static string Unzip(byte[] bytes)
    {
        using (var msi = new MemoryStream(bytes))
        using (var mso = new MemoryStream())
        {
            using (var gs = new GZipStream(msi, CompressionMode.Decompress))
            {
                //gs.CopyTo(mso);
                CopyTo(gs, mso);
            }

            return Encoding.UTF8.GetString(mso.ToArray());
        }
    }

    // Base64
    public static string ZipBase64(string compress)
    {
        var bytes = Zip(compress);
        var encoded = Convert.ToBase64String(bytes, Base64FormattingOptions.None);
        return encoded;
    }

    public static string UnzipBase64(string compressRequest)
    {
        var bytes = Convert.FromBase64String(compressRequest);
        var unziped = Unzip(bytes);
        return unziped;
    }

    // Testing
    public static bool TestZip(String stringToTest)
    {
        byte[] compressed = Zip(stringToTest);
        Debug.WriteLine("Compressed to " + compressed.Length + " bytes");
        String decompressed = Unzip(compressed);
        Debug.WriteLine("Decompressed to: " + decompressed);

        return stringToTest == decompressed;
    }
}

А вот класс Android/Java вам нужен:

public class CompressString {
    public static byte[] compress(String string) {
        try {
            ByteArrayOutputStream os = new ByteArrayOutputStream(string.length());
            GZIPOutputStream gos = new GZIPOutputStream(os);
            gos.write(string.getBytes());
            gos.close();
            byte[] compressed = os.toByteArray();
            os.close();
            return compressed;
        } catch (IOException ex) {
            return null;
        }
    }

    public static String decompress(byte[] compressed) {
        try {
            final int BUFFER_SIZE = 32;
            ByteArrayInputStream is = new ByteArrayInputStream(compressed);
            GZIPInputStream gis = new GZIPInputStream(is, BUFFER_SIZE);
            StringBuilder string = new StringBuilder();
            byte[] data = new byte[BUFFER_SIZE];
            int bytesRead;
            while ((bytesRead = gis.read(data)) != -1) {
                string.append(new String(data, 0, bytesRead));
            }
            gis.close();
            is.close();
            return string.toString();
        } catch (IOException ex) {
            return null;
        }
    }    

    // Base64
    public static String compressBase64(String strToCompress) {
        byte[] compressed = compress(strToCompress);
        String encoded = Android.util.Base64.encodeToString(compressed, Android.util.Base64.NO_WRAP);
        return encoded;
    }

    public static String decompressBase64(String strEncoded) {
        byte[] decoded = Android.util.Base64.decode(strEncoded, Android.util.Base64.NO_WRAP);
        String decompressed = decompress(decoded);
        return decompressed;
    }


    // test
    public static boolean testCompression(String stringToTest) {
        byte[] compressed = compress(stringToTest);
        Log.d("compress-test", "Compressed to " + compressed.length + " bytes");
        String decompressed = decompress(compressed);
        Log.d("compress-test", "Decompressed to " + decompressed);

        return stringToTest == decompressed;
    }
}

Итак, все - без зависимостей, 100% работающее сжатие классов Android/Java/C #/.NET. Если вы найдете строку, которая не работает с .NET 4.5 (я пробовал все, от "Hello world" до 1000 Word рассказа) - дайте мне знать.

1
kape123

Android метод распаковки не в порядке

Android Compress -> ОК:

public static byte[] compress(String string) throws IOException {
    ByteArrayOutputStream os = new ByteArrayOutputStream(string.length());
    GZIPOutputStream gos = new GZIPOutputStream(os);
    gos.write(string.getBytes());
    gos.close();
    byte[] compressed = os.toByteArray();
    os.close();
    return compressed;
}

.Net Decompress -> ОК:

public static byte[] DecompressViD(byte[] gzip)
{
    // Create a GZIP stream with decompression mode.
    // ... Then create a buffer and write into while reading from the GZIP stream.
    using (GZipStream stream = new GZipStream(new MemoryStream(gzip), CompressionMode.Decompress))
    {
        const int size = 4096;
        byte[] buffer = new byte[size];
        using (MemoryStream memory = new MemoryStream())
        {
            int count = 0;
            do
            {
                count = stream.Read(buffer, 0, size);
                if (count > 0)
                {
                    memory.Write(buffer, 0, count);
                }
            }
            while (count > 0);
            return memory.ToArray();
        }
    }
}

.Net Compress -> ОК:

    public static string compress(string text)
    {
        byte[] buffer = Encoding.UTF8.GetBytes(text);
        MemoryStream ms = new MemoryStream();
        using (GZipStream Zip = new GZipStream(ms, CompressionMode.Compress, true))
        {
            Zip.Write(buffer, 0, buffer.Length);
        }

        ms.Position = 0;
        MemoryStream outStream = new MemoryStream();

        byte[] compressed = new byte[ms.Length];
        ms.Read(compressed, 0, compressed.Length);

        return Convert.ToBase64String(compressed);
    }

Android Decompress -> Не в порядке:  

public static String decompress(String zipText) throws IOException {
    byte[] compressed = Base64.decode(zipText);

    GZIPInputStream os = new GZIPInputStream(new ByteArrayInputStream(compressed));

    GZIPInputStream gzipInputStream = new GZIPInputStream(os);

    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    for (int value = 0; value != -1;) {
        value = gzipInputStream.read();
        if (value != -1) {
            baos.write(value);
        }
    }
    gzipInputStream.close();
    baos.close();

    return new String(baos.toByteArray(), "UTF-8");
}
0
Vitor Hugo Américo

Вот простой пример, с чего можно начать.

public static void main(String[] args) throws IOException 
{
    byte[] buffer = new byte[4096];
    StringBuilder sb = new StringBuilder();

    //read file to compress

    String read = readFile( "spanish.xml", Charset.defaultCharset());

    if( read != null )
    {
        //compress file to output

        FileOutputStream fos = new FileOutputStream("spanish-new.xml");
        GZIPOutputStream gzos = new GZIPOutputStream(fos);
        gzos.write( read.getBytes());
        gzos.close();

        //uncompress and read back

        FileInputStream fis = new FileInputStream("spanish-new.xml");
        GZIPInputStream gzis = new GZIPInputStream(fis);

        int bytes = 0;

        while ((bytes = gzis.read(buffer)) != -1) {
            sb.append( new String( buffer ) );
        }
    }
}

static String readFile(String path, Charset encoding) throws IOException {
    byte[] encoded = Files.readAllBytes(Paths.get(path));
    return new String(encoded, encoding);
}
0
woahguy