精华内容
下载资源
问答
  • 常见压缩算法

    2013-12-19 11:00:05
    再学习了haffman算法之后发现压缩算法很有意思,上网查了...几个常见压缩算法(转) (一) 字典算法 字典算法是最为简单的压缩算法之一。它是把文本中出现频率比较多的单词或词汇组合做成一个对应的字典列表,并

    再学习了haffman算法之后发现压缩算法很有意思,上网查了点资料,这是做好的一篇(主要是我能理解)。前面几种都能看懂,关键是那个LZ77算法。这个是很强大的压缩算法,zip,rar用得都是这种算法,让我们来感叹下两个犹太人的强大!!!

     

    几个常见的压缩算法(转)

    (一) 字典算法
    字典算法是最为简单的压缩算法之一。它是把文本中出现频率比较多的单词或词汇组合做成一个对应的字典列表,并用特殊代码来表示这个单词或词汇。例如:
    有字典列表:
    00=Chinese
    01=People
    02=China
    源文本:I am a Chinese people,I am from China 压缩后的编码为:I am a 00 01,I am from 02。压缩编码后的长度显著缩小,这样的编码在SLG游戏等专有名词比较多的游戏中比较容易出现,比如《SD高达》。

    (二) 固定位长算法(Fixed Bit Length Packing)
    这种算法是把文本用需要的最少的位来进行压缩编码。
    比 如八个十六进制数:1,2,3,4,5,6,7,8。转换为二进制为:00000001,00000010,00000011,00000100, 00000101,00000110,00000111,00001000。每个数只用到了低4位,而高4位没有用到(全为0),因此对低4位进行压缩编 码后得到:0001,0010,0011,0100,0101,0110,0111,1000。然后补充为字节得到:00010010, 00110100,01010110,01111000。所以原来的八个十六进制数缩短了一半,得到4个十六进制数:12,34,56,78。
    这也是比较常见的压缩算法之一。

    (三) RLE算法
    这种压缩编码是一种变长的编码,RLE根据文本不同的具体情况会有不同的压缩编码变体与之相适应,以产生更大的压缩比率。

      变体1:重复次数+字符
    文本字符串:A A A B B B C C C C D D D D,编码后得到:3 A 3 B 4 C 4 D。

      变体2:特殊字符+重复次数+字符
    文本字符串:A A A A A B C C C C B C C C,编码后得到:B B 5 A B B 4 C B B 3 C。编码串的最开始说明特殊字符B,以后B后面跟着的数字就表示出重复的次数。

      变体3:把文本每个字节分组成块,每个字符最多重复 127 次。每个块以一个特殊字节开头。那个特殊字节的第 7 位如果被置位,那么剩下的7位数值就是后面的字符的重复次数。如果第 7 位没有被置位,那么剩下 7 位就是后面没有被压缩的字符的数量。例如:文本字符串:A A A A A B C D E F F F。编码后得到:85 A 4 B C D E 83 F(85H= 10000101B、4H= 00000100B、83H= 10000011B)

      以上3种不RLE变体是最常用的几种,其他还有很多很多变体算法,这些算法在Winzip Winrar这些软件中也是经常用到的。

    (四) LZ77算法
    LZ77算法是由 Lempel-Ziv 在1977发明的,也是GBA内置的压缩算法。LZ77算法有许多派生算法(这里面包括 LZSS算法)。它们的算法原理上基本都相同,无论是哪种派生算法,LZ77算法总会包含一个动态窗口(Sliding Window)和一个预读缓冲器(Read Ahead Buffer)。动态窗口是个历史缓冲器,它被用来存放输入流的前n个字节的有关信息。一个动态窗口的数据范围可以从 0K 到 64K,而LZSS算法使用了一个4K的动态窗口。预读缓冲器是与动态窗口相对应的,它被用来存放输入流的前n个字节,预读缓冲器的大小通常在0 – 258 之间。这个算法就是基于这些建立的。用下n个字节填充预读缓存器(这里的n是预读缓存器的大小)。在动态窗口中寻找与预读缓冲器中的最匹配的数据,如果匹 配的数据长度大于最小匹配长度 (通常取决于编码器,以及动态窗口的大小,比如一个4K的动态窗口,它的最小匹配长度就是2),那么就输出一对〈长度(length),距离 (distance)〉数组。长度(length)是匹配的数据长度,而距离(distance)说明了在输入流中向后多少字节这个匹配数据可以被找到。

      例如:(假设一个 10个字节的动态窗口, 以及一个5个字节的预读缓冲器)
    文本:A A A A A A A A A A A B A B A A A A A
    --------------------- =========
    动态窗口 预读缓存器
    动 态窗口中包含10个A ,这就是最后读取的10个字节。预读缓冲器包含了 B A B A A。编码的第一步就是寻找动态窗口与预读缓存器相似长度大于2的字节部分。在动态窗口中找不到B A B A A,所以B就被按照字面输出。然后动态窗口滑过1个字节,现在暂时输出了一个B。
    第二步:A A A A A A A A A A A B A B A A A A A
    --------------------- =========
    动态窗口 预读缓存器
    现 在预读缓冲器包含A B A A A,然后再和动态窗口进行比较。这时,在动态窗口找到了相似长度为2的A B,因此一对〈长度, 距离〉就被输出了。长度(length)是2 并且向后距离也是2,所以输出为<2,2>,然后动态窗口滑过2个字节。现在已经输出了B <2,2>。
    第三步:A A A A A A A A A A A B A B A A A A A
    --------------------- =========
    动态窗口 预读缓存器
    继续上面的方法得到输出结果<5,8>。现在已经输出了B <2,2> <5,8>。
    最终的编码结果是:A A A A A A A A A A A B <2,2> <5,8>。
    但 数组是无法直接用二进制来表示的,LZ77会把编码每八个数分成一组,每组前用一个前缀标示来说明这八个数的属性。比如数据流:A B A C A C B A C A按照LZ77的算法编码为:A B A C<2,2> <4,5>,刚好八个数。按照LZ77的规则,用“0”表示原文输出,“1”表示数组输出。所以这段编码就表示为:00001111B(等于 0FH),因此得到完整的压缩编码表示:F A B A C 2 2 4 5。虽然表面上只缩短了1个字节的空间,但当数据流很长的时候就会突出它的优势,这种算法在zip格式中是经常用到。

      除此之外还有很多压缩算法,像霍夫曼编码(Huffman Encoding)等等。这些编码也是非常的著名而且压缩效率极高,不过这些编码的算法相对比较繁琐,规则也很复杂,由于篇幅就不逐一介绍了。如果大家对这方面感兴趣可以到网站相关网站查询资料。

    展开全文
  • hadoop6-常见压缩算法

    2014-12-10 10:20:05
    常见的数据压缩算法 Deflate gzip bzip2 LZO LZ4 Snappy LZO和LZ4算法已经不再hadoop1.x 1)DEFLATW是同时使用LZ77算法和哈夫曼编码的一个无损数据压缩算法,源代码可以在zlib库中找到 gzip是以DEFLATW算法为基础扩展...

    常见的数据压缩算法

    Deflate

    gzip

    bzip2

    LZO

    LZ4

    Snappy

    LZO和LZ4算法已经不再hadoop1.x

    1)DEFLATW是同时使用LZ77算法和哈夫曼编码的一个无损数据压缩算法,源代码可以在zlib库中找到

    gzip是以DEFLATW算法为基础扩展出来的一种算法

    2)压缩算法都是空间和时间的转换,更快的压缩时间还是更小的压缩比,可以通过参数来制定

    -1意味着速度,-9意味着空间。拿gzip来做个例子,下面就意味着更快速的压缩。

    gzip -1 file

    3)gzip在时间和空间上比较适中,bzip2压缩比gzip更有效,但速度更慢。

    bzip2的压缩速度比它的压缩速度更快,但是和其他压缩格式相比又是最慢的,单

    是压缩效果明显是组号的。snappy和LZ4d的压缩速度比LZ0好很多

    4)splittable表示的是压缩格式是否可以被分割,也是就是否支持随机读。阿索数据是否被mapreduce使用,

    压缩数据是否能被分割就很关键了。

    存放压缩算法

    /home/hadoop-1.2.1/src/core/org/apache/hadoop/io/compress


    如何使用Snappy & Zlib

    下载http://code.google.com/p/snappy/downloads/list


    配置:

    1)hadoop.native.lib参数

    2)设置LD_LIBRAEY_PATH环境变量或者java.library.path属性

    这两个路径必须包含hadoop native library 和snappy library

     hadoop native library(libhadoop.so)

    $HADOOP_HOME/lib/native/Linux-amd64-64/

    snappy library(libsnappy.so):/usr/local/lib/ (默认安装位置)


    同样需要安装Zlib库,直接使用yum 命令安装zlib 、zlib-devel

    在安装snappy1.1.1.tar.gz过程中可能会遇到一些问题

    检查gcc-c++, autoconf, automake, libtool, Java 6, JAVA_HOME set, Maven 3

    是否安装配置好

    如果在make时出现错误二:./libtool: line 1125: g++: command not found错误

    解决方案:sudo yum -y install gcc-c++

    如果还是出现问题,将snappy1.1.1目录删除,重新解压缩

    然后执行./configrue  make && make install

    通过查看 ls /usr/local/lib下确认是否安装成功

    通过代码来展示不同效果

    Snappy压缩

    public static void main(String[] args) throws ClassNotFoundException, IOException{
    		String codecClassName ="org.apache.hadoop.io.compress.SnappyCodec";
    		Class<?> cls = Class.forName(codecClassName);
    		Configuration conf = new Configuration();
    		CompressionCodec codec =(CompressionCodec)ReflectionUtils.newInstance(cls, conf);
    		String inputFile = "/home/data";
    		String outFile = inputFile + codec.getDefaultExtension();
    		FileOutputStream fileout = new FileOutputStream(outFile);
    		CompressionOutputStream out = codec.createOutputStream(fileout);
    		FileInputStream in = new FileInputStream(inputFile); 
    		IOUtils.copyBytes(in, out, 4096,false);
    		in.close();
    		out.close();
    		
    	}


    Bz2压缩

    public static void main(String[] args) throws ClassNotFoundException, IOException{
    		String codecClassName ="org.apache.hadoop.io.compress.BZip2Codec";
    		Class<?> cls = Class.forName(codecClassName);
    		Configuration conf = new Configuration();
    		CompressionCodec codec =(CompressionCodec)ReflectionUtils.newInstance(cls, conf);
    		String inputFile = "/home/data";
    		String outFile = inputFile + codec.getDefaultExtension();
    		FileOutputStream fileout = new FileOutputStream(outFile);
    		CompressionOutputStream out = codec.createOutputStream(fileout);
    		FileInputStream in = new FileInputStream(inputFile); 
    		IOUtils.copyBytes(in, out, 4096,false);
    		in.close();
    		out.close();
    		
    	}

    BZ2的压缩比非常高,但是BZ2的压缩时间会比较长

    deflate方式压缩比较快

    public static void main(String[] args) throws ClassNotFoundException, IOException{
    		String codecClassName ="org.apache.hadoop.io.compress.DefaultCodec";
    		Class<?> cls = Class.forName(codecClassName);
    		Configuration conf = new Configuration();
    		CompressionCodec codec =(CompressionCodec)ReflectionUtils.newInstance(cls, conf);
    		String inputFile = "/home/data";
    		String outFile = inputFile + codec.getDefaultExtension();
    		FileOutputStream fileout = new FileOutputStream(outFile);
    		CompressionOutputStream out = codec.createOutputStream(fileout);
    		FileInputStream in = new FileInputStream(inputFile); 
    		IOUtils.copyBytes(in, out, 4096,false);
    		in.close();
    		out.close();
    		
    	}

    gzip压缩

    public static void main(String[] args) throws ClassNotFoundException, IOException{
    		String codecClassName ="org.apache.hadoop.io.compress.GzipCodec";
    		Class<?> cls = Class.forName(codecClassName);
    		Configuration conf = new Configuration();
    		CompressionCodec codec =(CompressionCodec)ReflectionUtils.newInstance(cls, conf);
    		String inputFile = "/home/data";
    		String outFile = inputFile + codec.getDefaultExtension();
    		FileOutputStream fileout = new FileOutputStream(outFile);
    		CompressionOutputStream out = codec.createOutputStream(fileout);
    		FileInputStream in = new FileInputStream(inputFile); 
    		IOUtils.copyBytes(in, out, 4096,false);
    		in.close();
    		out.close();
    		
    	}

    怎么选择压缩算法:

    1)用一些包含了压缩算法并制裁splittable的文件格式,比如Sequence File RCFIle或者Avro文件

    2)使用提供splittable的压缩格式,比如bzip2和索引后可以制裁splittable的lzo

    3)提前把文件分层几个块,每个块单独压缩,这样就无需考虑splittable的问题

    4)不要压缩文件,以不支持splittable的压缩格式存储一个很大的数据文件是不合适的,非本地处理效率会非常低。

    展开全文
  • GZIP压缩算法: 注意 :如果输入流没有经过压缩,那么就不能使用GZIPinputStream 。因为没有压缩会抛出异常。 主要应用于IO的操作。只要使用GZIP封装了相应的IO流,就会自动实现压缩。 如何判断网络数据...

    1) 将客户端在进行网址请求的时候,如果网址中使用了非ASCII码形式的内。比如百度可以使用中文搜索但是sougou搜索那么就需要进行编码
    2)URLEncoding:在编码的时候保留所有的英文字母、数字、下划线、以及特定的字符,这些字符全都是ASCII中的,除此之外将会转换成十六进制,并且将会在每一个十六进制之前加上%。
    3)内容中的“ ”空格全都采用“+” 代替
    4)URLEncoding就是为了将网址中的非ASCII的内容转换成可以传输的字符;

    5)注意多有的GET请求的网址中的参数。以及post请求中的请求参数都要进行Decoding

        @Override
        public void run() {
            try {
                String word = URLEncoder.encode("T am a变形金刚","utf-8");
    
                Log.d("De",word);
                //---------------------------------
                //URLEncoder的解码
                String query = URLDecoder.decode(word, "utf-8");
                Log.d("DE","解码  "+ query);
    
    
                URL url = new URL("http://news.baidu.com/ns?word="+word);
                HttpURLConnection conn = (HttpURLConnection) url.openConnection();
    
                int code = conn.getResponseCode();
                Log.d("De", "联网的状态码: "+code);
    
                if(code == 200){
                    //TODO 进行内容的获取
                    byte[] bytes = StreamUtil.readStream(conn.getInputStream());
                    String str = new String (bytes,"utf-8");
                    Log.d("De", "联网的状态码: "+str);
    
    
                }
    
                conn.disconnect();
    
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    

    ==所有的大于1K的JSON是数据从服务器传递过来之后就会经过压缩这样我们解析出来的数据是不正确的。==

    回顾知识:
    1)FileInputStream fin = new FileInputStream(..);
    2)DataInputStream din = new DataInputStream(fin);
    相当于DataINputStream封装了FileInputStream,每次都想到DIN读字节的时候,都会直接调用FIS的读取方法,当Din需要读取特定格式/内容的时候,同样,会在内部通过Fis来读取,并且在自身的方法中,进行数据的处理。
    当din.readInt() 的时候将会拼接成一个整数,叫作处理留
    

    GZIP压缩算法:

    注意 :如果输入流没有经过压缩,那么就不能使用GZIPinputStream 。因为没有压缩会抛出异常。
    
    主要应用于IO的操作。只要使用GZIP封装了相应的IO流,就会自动实现压缩。

    如何判断网络数据是不是经过压缩

    1)服务器能搞都客户端,返回的数据是不是经过压缩的
    2)服务器会通过网络放回一个HTTP头,名称叫做Content-Encoding字段,就会告诉你是不是经过压缩的。
    加上这段:
    
      //TODO 进行内容的获取
                    InputStream inputStream = conn.getInputStream();
       //如何判断
                    String encoding = conn.getContentEncoding();
    
                    //判断是不是经过GZIP压缩的
                    if("gzip".equals(encoding)){
                        inputStream = new GZIPInputStream(inputStream);
                    }
     这就能实现解压缩
    
    

    加密

    什么叫做加密:只有有密码的才叫加密,分为对称加密和非对称加密.
    1.Cipher:
    
    

    最后上今天的源码

    package com.bluezhang.base64test_1016_class;
    
    import EncryptUtil.EncryptUtil;
    import android.content.Context;
    import android.content.SharedPreferences;
    import android.os.Environment;
    import android.support.v7.app.AppCompatActivity;
    import android.os.Bundle;
    import android.util.Base64;
    import android.util.Log;
    import android.view.Menu;
    import android.view.MenuItem;
    import android.view.View;
    import android.widget.EditText;
    import android.widget.Toast;
    import com.bluezhang.bitmapdisplay_1012_class.imagesutil.ImageUtils;
    import com.google.gson.Gson;
    
    import javax.crypto.Cipher;
    import javax.crypto.NoSuchPaddingException;
    import javax.crypto.SecretKey;
    import javax.crypto.SecretKeyFactory;
    import javax.crypto.spec.DESKeySpec;
    import java.io.*;
    import java.math.BigInteger;
    import java.security.*;
    import java.security.interfaces.RSAPrivateKey;
    import java.security.interfaces.RSAPublicKey;
    import java.security.spec.InvalidKeySpecException;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.security.spec.X509EncodedKeySpec;
    
    public class SythEncriptActivity extends AppCompatActivity {
    
        private EditText txtContent ;
        private EditText txtpass ;
        private EditText txtResoul ;
        private EditText jiemi ;
    
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_syth_encript);
    
            txtContent = (EditText) findViewById(R.id.txt_content);
            txtpass = (EditText) findViewById(R.id.txt_password);
            txtResoul = (EditText) findViewById(R.id.txt_resout);
            jiemi = (EditText) findViewById(R.id.txt_resoutafter);
    
    
    
        }
    
    
        /**
         * 对称加密
         * DES加密
         * @param view
         */
        public void btnDESEncriypt(View view) {
    
            String content = txtContent.getText().toString();
            String password = txtpass.getText().toString();
            byte [] keyData = password.getBytes();
    
            byte[] contentData = content.getBytes();//需要加密的内容
    
            //DES 加密
            //所有的加密解密都用到Cipher
            if(keyData.length==8) {
                try {
                    byte[] encryptData = EncryptUtil.desEncrypt(contentData, keyData);
                    String str = Base64.encodeToString(encryptData,Base64.NO_WRAP);
                    txtResoul.setText(str);
    
                } catch (InvalidKeyException e) {
                    e.printStackTrace();
                }
            }
        }
    
        /**
         * Des解密
         * @param view
         */
        public void btnDESDeEncripe(View view) {
            String encriptedStr = txtResoul.getText().toString();
            if(encriptedStr.length()>0){
                String password = txtpass.getText().toString();
                //因为加密方法使用那个Base64对加密的内容进行编码,解密的时候
                //要进行Base64 的解码
                byte[] encrryptedData = Base64.decode(encriptedStr, Base64.NO_WRAP);
    
                byte[] keyData = password.getBytes();
    
                //DES 要求八个字节
                if(keyData.length==8){
                    //2.创建解密引擎Cipher
                    try {
                        Cipher cipher = Cipher.getInstance("DES");
    
                        //4准备key对象
                        DESKeySpec keySpec = new DESKeySpec(keyData);
                        //4.2 SecretKeyFactory
                        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
                        //生成key对象
                        SecretKey key = keyFactory.generateSecret(keySpec);
    
                        //3初始化
                        cipher.init(Cipher.DECRYPT_MODE,key);
    
                        //Cipher doFinal 就是将制定的参数 进行转换生成的结果
    
                        byte[] data  = cipher.doFinal(encrryptedData);
    
                        String str = new String (data);
    
                        Toast.makeText(this, "str = " + str, Toast.LENGTH_SHORT).show();
                        jiemi.setText(str);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
    
            }
        }
    
        public void clear(View view) {
            txtResoul.setText("");
            txtContent.setText("");
            jiemi.setText("");
        }
    
        public void createKey(View view) {
            //生成密钥 包含了 公钥和私钥
            SharedPreferences sharedPreferences = getSharedPreferences("key", Context.MODE_PRIVATE);
            SharedPreferences.Editor editor = sharedPreferences.edit();
            KeyPair keyPair = EncryptUtil.generateRSAKeyPir(1024);
            PublicKey publicKey = keyPair.getPublic();
            PrivateKey privateKey = keyPair.getPrivate();
            byte[] keypri = privateKey.getEncoded();
            byte[] keypub = publicKey.getEncoded();
            String strBasePri = Base64.encodeToString(keypri, Base64.NO_WRAP);
            String strBasePub = Base64.encodeToString(keypub,Base64.NO_WRAP);
    
    
    
    
            Log.d("pri",strBasePri);
            Toast.makeText(this, "存储成功", Toast.LENGTH_SHORT).show();
            editor.putString("pri", strBasePri);
            editor.putString("pub", strBasePub);
            editor.commit();
    
    
        }
    
    
        public void jiamizifuchuan(View view) {
            //生成密钥 包含了 公钥和私钥
            SharedPreferences sharedPreferences = getSharedPreferences("key", Context.MODE_PRIVATE);
            SharedPreferences.Editor editor = sharedPreferences.edit();
            if(sharedPreferences.getString("pri",null)!=null&&sharedPreferences.getString("pub",null)!=null) {
    
    
    
                try {
                    String pub = sharedPreferences.getString("pub", null);
                    String pri = sharedPreferences.getString("pri", null);
    
                    Log.d("pri",pri);
    
                    byte[] keypri = Base64.decode(pri.getBytes(), Base64.NO_WRAP);
                    byte[] keypub = Base64.decode(pub.getBytes(), Base64.NO_WRAP);
    
    
    
                    KeyFactory keyFactory = KeyFactory.getInstance("RSA");
                    PrivateKey privateKey = keyFactory.generatePrivate(new PKCS8EncodedKeySpec(keypri));
                    PublicKey publicKey = keyFactory.generatePublic(new X509EncodedKeySpec(keypub));
    
                    String a = "我是张凡";
                    byte[] p = EncryptUtil.rsaEncrypt(a.getBytes(), privateKey);
                    Gson gson = new Gson();
    
    
                    byte[] n = EncryptUtil.rsaEncrypt(p, publicKey);
                    String s = new String (n);
                    Toast.makeText(getApplicationContext(),"啊哈哈!! 出来了"+s,Toast.LENGTH_SHORT).show();
    
                } catch (NoSuchAlgorithmException e) {
                    e.printStackTrace();
                } catch (InvalidKeySpecException e) {
                    e.printStackTrace();
                }
            }
    
    
        }
    }
    

    Hex的工具类:

    package com.bluezhang.bitmapdisplay_1012_class.imagesutil;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    import android.graphics.Bitmap;
    import android.graphics.BitmapFactory;
    import android.graphics.Bitmap.CompressFormat;
    import android.os.Environment;
    
    public class ImageUtils {
        public static final String CACHEDIR = Environment
                .getExternalStorageDirectory() + "/blueZhang/images";
    
        public static boolean isMounted() {
            return Environment.MEDIA_MOUNTED.equals(Environment
                    .getExternalStorageState());
        }
    
        /**
         * 将Bitmap图片保存到存储卡中
         *
         * @param url
         * @param bitmap
         * @throws IOException
         */
        public static void saveImg(String url, Bitmap bitmap) throws IOException {
            if (!isMounted())
                return;
    
            File dir = new File(CACHEDIR);
            if (!dir.exists())
                dir.mkdirs();
    
            // 将图片对象写入到指定输出流中
            FileOutputStream fos = new FileOutputStream(new File(dir, getName(url)));
            bitmap.compress(getFormat(url), 100, fos);
    
        }
    
        /**
         * 获取图片的格式
         *
         * @param url
         */
        public static CompressFormat getFormat(String url) {
            String fileName = getName(url);
            if (fileName.endsWith("png")) {
                return CompressFormat.PNG;
            }
            return CompressFormat.JPEG;
        }
    
        public static void saveImg(String url, byte[] bytes) throws IOException {
            if (!isMounted())
                return;
    
            File dir = new File(CACHEDIR);
            if (!dir.exists())
                dir.mkdirs();
    
            FileOutputStream fos = new FileOutputStream(new File(dir, getName(url)));
            fos.write(bytes);
            fos.close();
    
        }
    
        public static Bitmap getImg(String url) {
            if (!isMounted())
                return null;
    
            File imgFile = new File(CACHEDIR, getName(url));
            if (imgFile.exists()) {
                return BitmapFactory.decodeFile(imgFile.getAbsolutePath());
            }
    
            return null;
        }
    
        public static String getName(String url) {
            String a = url.substring(0,url.lastIndexOf("/"));
    
    
            return a.substring(a.lastIndexOf("/") + 1)+".jpg";
        }
    
        public String getName(String url, int end) {
            return url.substring(url.lastIndexOf("/") + 1, end);
        }
    
    }
    

    测试类的创建:

    
    import java.util.Arrays;
    
    /**
     * Author: blueZhang
     * DATE:2015/10/16
     * Time: 11:54
     * AppName:Base64Test_1016_Class
     * PckageName:com.bluezhang.base64test_1016_class.EncryptUtilTest
     */
    public class EncryptUtilTest extends TestCase {
        public void testToHex(){
            byte [] data = new byte[]{20,20};
    
            String hex = EncryptUtil.toHex(data);
            //检查Hex是不是0102
            //参数1代表期望的值 2 实际参数
            assertEquals("1414", hex);
    
            byte [] d1 = EncryptUtil.fromHex(hex);
    
            //比较数组返回是不是相同的相同返回True false抛出异常
    
            assertTrue(Arrays.equals(d1, data));
    
    
    
        }
    
    
        public void testFromHex(){
            byte[] data = EncryptUtil.fromHex("abab");
            byte [] d2 = new byte[]{(byte)0xab,(byte)0xab};
            assertTrue(Arrays.equals(d2, data));
    
        }
    }
    展开全文
  • 对于算法研究而言,本身就是要先知道哪个地方可以努力,哪些地方行不通。这些原理,就是指明方向的。 一.视频压缩的可行性 1.空间冗余 一幅静态图像,比如人脸。背景,人脸,头发等处的亮度,颜色,都是...


    转载地址:

    http://blog.csdn.net/iloveyin/article/details/24367863


    对于算法研究而言,本身就是要先知道哪个地方可以努力,哪些地方行不通。这些原理,就是指明方向的。

    一.视频压缩的可行性

    1.空间冗余

    一幅静态图像,比如人脸。背景,人脸,头发等处的亮度,颜色,都是平缓变化的。相邻的像素和色度信号值比较接近。具有强相关性,如果直接用采样数来表示亮度和色度信息,数据中存在较多的空间冗余。如果先去除冗余数据再编码,表示每个像素的平均比特数就会下降,这就是通常说的图像的帧内编码,即以减少空间冗余进行数据压缩。

    2.时间冗余

    视频是时间轴方向的帧图像序列,相邻帧图像的相关性也很强。通常用降低帧间的方法来减少时间冗余。采用运动估计和运动补偿的技术满足解码重建图像的质量要求。

    3.符号冗余

    用相同码表示概率不同的符号,会造成比特数的浪费。比如10,11,13三个数,如果我们都用1bytes来表示,就是3bytes(即3×8 = 24bits),但是如果我们表00b表示10,01b表示11,02b表示13,这样,三个数合起来才用了6bits,较之前可以节省18bits。

    可变长编码技术的原理就如此,概论大的用较短的码字,概率小的用较长的码字。

    4.结构冗余

    对于图像内部,各个部分也存在某种关系。我们可以通过这种关系,减少信息的码字表达。比如:分形图像编码

    5.视觉冗余

    1),人眼对彩色信号的亮度分辨率高于色彩分辨率,比如rgb-->yuv就是这个原理

    2),人眼对静止图像的空间的分辨率大于运动图像的分辨率。

    3),人眼对亮度的细小变化不敏感

    4),中心敏感,四周不敏感。

    其实我们虽然知道了这些,我们知道有冗余,但是如何把这些冗余找出来,是个很复杂的过程。也是我们的算法不断追求的过程。

    上面的一段,是所有视频压缩标准的基石。mpeg2,mpeg4,h264,h265这些标准,与其说他们是标准,不如他们提供了一些算法的组合,或简单或复杂,当然简单的算法压缩掉的冗余小,复杂的压缩掉的冗余大。通过算法找到冗余信息在哪,然后压缩掉,实现数据量的减小。这就是我们的目录。

    更近一步的说,就是我们如何找出数据的相关性

    二,常见算法的名词解释

    大的分类有两种,一个变换,一个是编码

    先说变换

    我们要找出信号的相关性,时间上不好找怎么办,变换到另外一个空间上去。这就是我们在信号与系统,数字信号处理,高等数学得到的结论

    变换

    傅里叶变换

    walsh-hadamard(沃尔什哈达玛变换)

    正弦变换

    余弦变换----应用最广

    斜变换

    哈尔变换

    k-L变换

    小波变换

    对于这些变换来说,很多东西只在数学上有意义,对于工程来说,或者没有快速算法,或者变换后相关性比较低,或者其他原因。只有余弦变换是最最广泛的,为了减小我们的学习压力(当然如果你是要对比其中的差异的另当别论),我们只掌握余弦变换就可以了。

    编码

    又分无失真编码与限失真编码,从名字上我们就可以看出差异了。呵呵,不多解释

    无失真编码的种类:

    哈夫曼编码,算术编码,游程编码

    限失真编码

    预测编码,变换编码,矢量量化,基于模型的编码。

    对于编码这块,上述的算法,基本要全部掌握才行。

    jpeg/mpeg2先用了游程编码减小的0这个数占用的比特位,然后用了哈夫曼压缩。

    h264用了算术编码来做最后一道压缩工序

    运动补偿与运动估计,用到预测编码。

    mpeg4用到了基于模型的编码

    变换完成后,进行了矢量量化。

    
    展开全文
  • 常见的文本压缩算法

    万次阅读 2017-08-15 14:32:18
    1.目前主要的文本压缩算法 文本压缩是根据一定的方法对大量数据进行编码处理以达到信息压缩存储的过程,被压缩的数据应该能够通过解码恢复到以前的状态,而不会发生信息丢失的现象。2.文本压缩的分类 3.算法描述...
  • 几个常见压缩算法

    2014-09-01 12:39:57
    几个常见压缩算法(转) (一) 字典算法 字典算法是最为简单的压缩算法之一。它是把文本中出现频率比较多的单词或词汇组合做成一个对应的字典列表,并用特殊代码来表示这个单词或词汇。例如: 有字典列表: ...
  • 常见压缩算法

    千次阅读 2013-04-24 09:49:33
    一、 行程长度压缩   原理是将一扫描行中的颜色值相同的相邻像素用一个计数值和那些像素的颜色值来代替。例如:aaabccccccddeee,则可用3a1b6c2d3e来代替。对于拥有大面积,相同颜色区域的图像,用RLE压缩方法非常...
  • 常见的无损压缩算法

    万次阅读 2018-12-01 16:17:00
    无损压缩算法 LZ77 算法 LZ77 算法的关键是搜索,即在已经处理过的符号序列(数据流)中,寻找与待编码符号序列相同的模式,如果找到匹配的模式,就设法对这个模式进行索引,也就是生成一个指针,然后输出该索引...
  • RLE 又叫 Run Length Encoding ,是一个针对无损压缩的非常简单的算法。它用重复字节和重复的次数来简单描述来代替重复的字节。尽管简单并且对于通常的压缩非常低效,但它有的时候却非常有用(例如, JPEG 就使用它...
  • Android之常见的图片压缩算法

    千次阅读 2016-04-18 09:28:19
    这里为大家提供一些常用的图片压缩算法,帮助大家在日常开发过程中解决图片上传时,图片压缩的问题。上一篇的博文http://blog.csdn.net/loveyaozu/article/details/51160482中其实已经为大家提供了图片的
  • 几个常见压缩算法(转)

    千次阅读 2013-09-24 22:53:54
    字典算法是最为简单的压缩算法之一。它是把文本中出现频率比较多的单词或词汇组合做成一个对应的字典列表,并用特殊代码来表示这个单词或词汇。例如: 有字典列表: 00=Chinese 01=People 02=China 源文本:I ...
  • (一) 字典算法 字典算法是最为简单的压缩算法之一。它是把文本中出现频率比较多的单词或词汇组合做成一个对应的字典列表,并用特殊代码来表示这个单词或词汇。例如: 有字典列表: 00=Chinese 01=People 02=...
  • 常见压缩工具和算法的压缩比率及资源消耗情况压缩算法比较
  • 数据压缩算法—2无损压缩算法

    千次阅读 2018-12-12 20:55:43
      字典算法是最为简单的压缩算法之一。它是把文本中出现频率比较多的单词或词汇组合做成一个对应的字典列表,并用特殊代码来表示这个单词或词汇。例如:   有字典列表:   00=Chinese   01=People   02=...
  • LZW压缩算法

    千次阅读 2015-02-27 19:24:18
    LZW算法是非常常见的一种压缩算法,他的压缩原理是对于多次重复出现的字符串,进行压缩,至于怎么压缩,在后文中会细细描述,LZW算法可以用在很多的场合,诸如图像压缩,文本压缩等等,而且算法简单易懂,并不是人们...
  • 常见数据压缩算法压缩文件压缩主要有两个好处,一是减少了存储文件所占空间,另一个就是为数据传输提速。在hadoop大数据的背景下,这两点尤为重要,那么我现在就先来了解下hadoop中的文件压缩。hadoop里支持很多种...
  • 绪论 JPEG-LS是在ISO/ITU的新标准中用于对静态连续色调图像进行无损或进无损压缩...1.压缩算法简介与评估 1.1 压缩算法简介 无损压缩就是指经过压缩并重建后的图像和原图像完全一样,没有任何损失。如果重建图像和原图
  • br压缩算法

    千次阅读 2020-03-29 12:27:56
    虽然Brotli 还是非主流,但是如新贴吧知乎就支持Brotli压缩。...“智能压缩”按照又拍云的说法是,同时支持 Gzip 和 Brotli 压缩算法。根据用于浏览器开启自动选择不同压缩方式。 Gzip 压缩算法 Gzip 基于 DE...
  • 压缩算法

    千次阅读 2007-12-03 14:14:00
    压缩算法一、 行程长度压缩 原理是将一扫描行中的颜色值相同的相邻像素用一个计数值和那些像素的颜色值来代替。例如:aaabccccccddeee,则可用3a1b6c2d3e来代替。对于拥有大面积,相同颜色区域的图像,用RLE压缩方法...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 102,791
精华内容 41,116
关键字:

常见压缩算法