记得写丶
记得写丶

VoiceManager的封装

这是一个录音和播放封装，我们有一个封装类：
VoiceManager.class,我们播放音乐，我们的view也需要对应的变化，音乐来控制我们ui控件的变化也就是我们的时间来控制我们的ui变化，所以我们需要的一个计算时间的工具类，也就是我们的VoiceTimeUtils.class

1.播放录音的工具类--- MediaPlayer
(注意，我们可以看到在准备播放的方法里面每一个返回的是布尔值，当我们的播放方法执行了的时候就会放回true，没有执行的时候，放回的是false，这个点子很好，值得我们记住！)

  • 准备工作：
  /**
     * 播放录音准备工作
     */
    private boolean prepareMedia(MediaPlayer mp,String file){
        boolean result = false;
        try {
            mp.setDataSource(file);
            mp.prepare();
            result = true;
        } catch (Exception e) {
        }

        return result;
    }

 /**
     * 播放录音开始
     * @param mp
     * @return
     */
    private boolean playMedia(MediaPlayer mp){
        boolean result = false;
        try {
            if (mp != null) {
                mp.start();
                result = true;
            }
        } catch (Exception e) {
        }

        return result;
    }

 /**
     * 停止播放
     * @param mp
     * @param release
     * @return
     */
    private boolean stopMedia(MediaPlayer mp,boolean release){
        boolean result = false;
        try {
            if (mp != null) {
                mp.stop();

                if (release) {
                    mp.release();


                }
                result = true;
            }
        } catch (Exception e) {
        }

        return result;
    }

 /**
     * 暂停播放
     * @param mp
     * @return
     */
    private boolean pauseMedia(MediaPlayer mp){
        boolean result = false;

        try {
            if (mp != null) {
                mp.pause();
                result = true;
            }
        } catch (Exception e) {
        }

        return result;
    }

此外我们开启一个线程来检测我们的录音声音频率的大小：
(可以看到我们这个类中定义了一个方法叫exit他里面控制一个布尔值为false，然后在我们的run方法中用while循环来检测我们exit方法里面布尔值是否为false，如果为false就停止录音，否则就一直录音)

  /**
     * 监听录音声音频率大小
     */
     private class ObtainDecibelThread extends Thread{
        private volatile boolean running = true;

        public void exit() {
            running = false;
        }
        @Override
        public void run() {
            while (running) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (mMediaRecorder == null || !running) {
                    break;
                }
                try {
                    final double ratio = mMediaRecorder.getMaxAmplitude()/150;
                    if (ratio != 0&&voiceRecordCallBack!=null) {
                        ((Activity)context).runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                double db=0;// 分贝
                                if (ratio > 1)
                                    db = (int) (20 * Math.log10(ratio));
                                voiceRecordCallBack.recVoiceGrade((int)db);
                            }
                        });
                    }
                } catch (RuntimeException e) {
                    e.printStackTrace();
                }

            }
        }
     }

2 . 我们的录音的工具类是我们的---MediaRecorder
（可以看到我们的录音准备方法里面，回调的是我们的文件存放地址，这个就很机智了，还有就是我们的录音准备工作要设置的配置，我们简单缩写一下就是，ASM,AEA,UFR,还有一个就是设置我们的地址）

  • 准备工作：
1. 判断我们的录音的存放地址是否是正确：

   public static File recAudioDir(String path) {
       File file = new File(path);
       if (!file.exists()) {
           file.mkdirs();
       }
       return file;
   }

/**
    * 录音准备工作 ，开始录音
    *
    * @param mr
    * @param start
    * @return
    */
   @SuppressWarnings("deprecation")
   private File prepareRecorder(MediaRecorder mr, boolean start) {
       File recFile = null;
       if (mr == null) return null;
       try {
           String path = recAudioDir(recordFilePath).getAbsolutePath();
           recFile = new File(path, VoiceTimeUtils.getTime() + ".amr");
           mr.setAudioSource(MediaRecorder.AudioSource.MIC);
           mr.setOutputFormat(MediaRecorder.OutputFormat.RAW_AMR);
           mr.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
           mr.setOutputFile(recFile.getAbsolutePath());
           mr.prepare();
           if (start) {
               mr.start();
               if (mThread == null) {
                   mThread = new ObtainDecibelThread();
                   mThread.start();
               }
           }
       } catch (Exception e) {
           e.printStackTrace();
       }
       return recFile;

   }

   /**
    * 停止录音和播放
    */
   public void stopRecordAndPlay(){
       stopRecorder(mMediaRecorder, true);
       mMediaRecorder = null;
       stopMedia(mMediaPlayer, true);
       mMediaPlayer = null;
   }

第二部分 接口

 /**
     * 录音回调监听
     */
    public interface VoiceRecordCallBack{
        //录音中
        void recDoing(long time,String strTime);
        //录音中的声音频率等级;
        void recVoiceGrade(int grade);
        //录音开始
        void recStart(boolean init);
        //录音暂停
        void recPause(String str);
        //录音结束
        void recFinish(long lenth,String strLenth,String path);
    }

 /**
     * 播放录音回调监听
     */
    public interface VoicePlayCallBack{
        /**
         * 音频长度
         * 指定的某个时间段，以秒为单位
         */
        void voiceTotalLenth(long time,String strTime);
        /**
         * 播放中
         * 指定的某个时间段，以秒为单位
         */
        void playDoing (long time,String strTime);
        //播放暂停
        void playPause();
        //播放开始
        void playStart();
        //播放结束
        void  playFinish();
    }

附加一个我们判断我们的sd卡是否存在：
 /**
     * SD卡是否可用
     */
    public static boolean isSDCardAvailable() {
        return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState());
    }

3.第三部分 具体代码

上面我们完成了我们的准备工作，现在开始我们的具体代码：

public class VoiceManager {

    public final int MSG_TIME_INTERVAL = 100;

    private static VoiceManager voiceManager =null;
    private Context context;
    private VoiceRecordCallBack voiceRecordCallBack;
    private VoicePlayCallBack voicePlayCallBack;
    private SeekBar mSBPlayProgress;

    // 多媒体例如声音的状态
    public final int MEDIA_STATE_UNDEFINE = 200;
    public final int MEDIA_STATE_RECORD_STOP = 210;
    public final int MEDIA_STATE_RECORD_DOING = 220;
    public final int MEDIA_STATE_RECORD_PAUSE = 230;
    public final int MEDIA_STATE_PLAY_STOP = 310;
    public final int MEDIA_STATE_PLAY_DOING = 320;
    public final int MEDIA_STATE_PLAY_PAUSE = 330;

    private MediaRecorder mMediaRecorder = null;
    private MediaPlayer mMediaPlayer = null;

    private String mRecTimePrev;
    private long mRecTimeSum = 0;

    private int mSavedState, mDeviceState = MEDIA_STATE_UNDEFINE;

    private ArrayList mRecList = new ArrayList();

    private ObtainDecibelThread mThread;

    /**
     * 录音文件存放的位置(文件夹)
     */
    private String recordFilePath = "";
    /**
     * 播放音频文件位置
     */
    private String playFilePath;

    private VoiceManager(Context context){
        this.context = context;
    }

    public static VoiceManager getInstance(Context context){
        if(voiceManager == null){
            synchronized (VoiceManager.class){
                if(voiceManager == null){
                    voiceManager = new VoiceManager(context);
                }
            }
        }
        return voiceManager;
    }

    /**
     * 播放器结束监听
     */
    private MediaPlayer.OnCompletionListener mPlayCompetedListener = new MediaPlayer.OnCompletionListener(){

        @Override
        public void onCompletion(MediaPlayer mediaPlayer) {
            mDeviceState = MEDIA_STATE_PLAY_STOP;
            mHandler.removeMessages(MSG_TIME_INTERVAL);
            mMediaPlayer.stop();
            mMediaPlayer.release();
            if (mSBPlayProgress != null) {
                mSBPlayProgress.setProgress(0);
            }
            if (voicePlayCallBack != null) {
                voicePlayCallBack.playFinish();
            }
        }
    };
    /**
     * 播放或录音handler
     */
    @SuppressLint("HandlerLeak")
    private final Handler mHandler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            VoiceTimeUtils ts;
            int current;
            try {
                switch (msg.what) {
                    case MSG_TIME_INTERVAL:
                        //录音
                        if(mDeviceState == MEDIA_STATE_RECORD_DOING){
                            ts = VoiceTimeUtils.timeSpanToNow(mRecTimePrev);
                            mRecTimeSum += ts.mDiffSecond;
                            mRecTimePrev = VoiceTimeUtils.getTimeStrFromMillis(ts.mNowTime);
                            ts = VoiceTimeUtils.timeSpanSecond(mRecTimeSum);
                            //回调录音时间
                            if (voiceRecordCallBack != null) {
                                voiceRecordCallBack.recDoing(mRecTimeSum, String.format("%02d:%02d:%02d",
                                        ts.mSpanHour, ts.mSpanMinute, ts.mSpanSecond));
                            }
                            mHandler.sendEmptyMessageDelayed(MSG_TIME_INTERVAL, 1000);
                        }
                        //播放
                        else if (mDeviceState == MEDIA_STATE_PLAY_DOING) {
                            current = mMediaPlayer.getCurrentPosition();
                            if (mSBPlayProgress != null) {
                                mSBPlayProgress.setProgress(current);
                            }
                            ts = VoiceTimeUtils.timeSpanSecond(current / 1000);
                            //回调播放进度
                            if (voicePlayCallBack != null) {
                                voicePlayCallBack.playDoing(current / 1000, String.format("%02d:%02d:%02d",
                                        ts.mSpanHour, ts.mSpanMinute, ts.mSpanSecond));
                            }
                            mHandler.sendEmptyMessageDelayed(MSG_TIME_INTERVAL, 1000);
                        }
                        break;
                    default:
                        break;
                }
            } catch (Exception e) {
            }
        }
    };
    /*********************************录音操作begin***************************/
    /**
     * 设置录音监听
     * @param callback
     */
      public void setVoiceRecordListener(VoiceRecordCallBack callback){
         this.voiceRecordCallBack = callback;
     }

    /**
     * 开始录音（外部调用）
     * @param filePath
     */
     public void startVoiceRecord(String filePath){
         if (!isSDCardAvailable()) return ;
         this.recordFilePath = filePath;
         startVoiceRecord(true);
     }

    /**
     * 继续或暂停录音
     */
    public void pauseOrStartVoiceRecord(){
        if (mDeviceState == MEDIA_STATE_RECORD_DOING) {
            mDeviceState = MEDIA_STATE_RECORD_PAUSE;
            stopRecorder(mMediaRecorder, true);
            mMediaRecorder = null;
            voiceRecordCallBack.recPause("已暂停");
        } else {
            startVoiceRecord(false);
        }
     }

    /**
     * 完成录音
      */
     public void stopVoiceRecord(){
         try {
             mHandler.removeMessages(MSG_TIME_INTERVAL);
             mDeviceState = MEDIA_STATE_RECORD_STOP;
             stopRecorder(mMediaRecorder, true);
             mMediaRecorder = null;
             if (VoiceTimeUtils.timeSpanSecond(mRecTimeSum).mSpanSecond == 0) {
                 Toast.makeText(context, "时间过短", Toast.LENGTH_SHORT).show();
             } else {
                 File file = getOutputVoiceFile(mRecList);
                 if (file != null && file.length() > 0) {
                     cleanFieArrayList(mRecList);
                     //TODO 这里可以返回数据 setResult
                     final VoiceTimeUtils ts = VoiceTimeUtils.timeSpanSecond(mRecTimeSum);
                     //完成录音
                     if (voiceRecordCallBack != null) {
                         voiceRecordCallBack.recFinish(mRecTimeSum, String.format("%02d:%02d:%02d",
                                 ts.mSpanHour, ts.mSpanMinute, ts.mSpanSecond),file.getAbsolutePath());
                     }
                 }
             }

         } catch (Exception e) {
             e.printStackTrace();
         }
     }

    /**
     * 开始录音（内部调用）
     * @param init
     */
     private void startVoiceRecord(boolean init){
         if (!isSDCardAvailable()) return;
         if (init) {
             mRecTimeSum = 0;
             cleanFieArrayList(mRecList);
         }
         //录音前停止播放回调
         if(voicePlayCallBack!=null){
             voicePlayCallBack.playFinish();
         }
         stopRecorder(mMediaRecorder, true);
         mMediaRecorder = null;

         stopMedia(mMediaPlayer, true);
         mMediaPlayer = null;
         mMediaRecorder = new MediaRecorder();
         File file = prepareRecorder(mMediaRecorder, true);
         if (file != null) {
             //开始录音回调
             if (voiceRecordCallBack != null) {
                 voiceRecordCallBack.recStart(init);
             }
             mDeviceState = MEDIA_STATE_RECORD_DOING;
             mRecTimePrev = VoiceTimeUtils.getTimeStrFromMillis(System.currentTimeMillis());
             mRecList.add(file);

             mHandler.removeMessages(MSG_TIME_INTERVAL);
             mHandler.sendEmptyMessage(MSG_TIME_INTERVAL);
         }

     }

    /**
     * 监听录音声音频率大小
     */
     private class ObtainDecibelThread extends Thread{
        private volatile boolean running = true;

        public void exit() {
            running = false;
        }
        @Override
        public void run() {
            while (running) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (mMediaRecorder == null || !running) {
                    break;
                }
                try {
                    final double ratio = mMediaRecorder.getMaxAmplitude()/150;
                    if (ratio != 0&&voiceRecordCallBack!=null) {
                        ((Activity)context).runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                double db=0;// 分贝
                                if (ratio > 1)
                                    db = (int) (20 * Math.log10(ratio));
                                voiceRecordCallBack.recVoiceGrade((int)db);
                            }
                        });
                    }
                } catch (RuntimeException e) {
                    e.printStackTrace();
                }

            }
        }
     }

    /**
     * 合并录音
     * @param list
     * @return
     */
     private File getOutputVoiceFile(ArrayList list){
         String mMinute1 = VoiceTimeUtils.getTime();
         File recDirFile = recAudioDir(recordFilePath);

         // 创建音频文件,合并的文件放这里
         File resFile = new File(recDirFile, mMinute1 + ".amr");
         FileOutputStream fileOutputStream = null;
         try {
             fileOutputStream = new FileOutputStream(resFile);
         } catch (IOException e) {
         }
         // list里面为暂停录音 所产生的 几段录音文件的名字，中间几段文件的减去前面的6个字节头文件
         for (int i = 0; i < list.size(); i++) {
             File file = list.get(i);
             try {
                 FileInputStream fileInputStream = new FileInputStream(file);
                 byte[] myByte = new byte[fileInputStream.available()];
                 // 文件长度
                 int length = myByte.length;
                 // 头文件
                 if (i == 0) {
                     while (fileInputStream.read(myByte) != -1) {
                         fileOutputStream.write(myByte, 0, length);
                     }
                 }
                 // 之后的文件，去掉头文件就可以了
                 else {
                     while (fileInputStream.read(myByte) != -1) {
                         fileOutputStream.write(myByte, 6, length - 6);
                     }
                 }
                 fileOutputStream.flush();
                 fileInputStream.close();
             } catch (Exception e) {
                 e.printStackTrace();
             }
         }
         // 结束后关闭流
         try {
             fileOutputStream.close();
         } catch (IOException e) {
             e.printStackTrace();
         }

         return resFile;

     }

    /**
     * 清空暂停录音所产生的几段录音文件
     * @param list
     */
     private void cleanFieArrayList(ArrayList list){
         for (File file : list) {
             file.delete();
         }
         list.clear();
     }

    /*********************************录音操作end***************************/


    /*********************************播放操作end***************************/
      public void setVoicePlayListener(VoicePlayCallBack callback){
          voicePlayCallBack = callback;
     }

    /**
     * 播放SeekBar监听
     * @param seekBar
     */
     public void setSeekBarListener(SeekBar seekBar){
         mSBPlayProgress = seekBar;
         if (mSBPlayProgress != null) {
             mSBPlayProgress.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
                 @Override
                 public void onStartTrackingTouch(SeekBar seekBar) {
                     mHandler.removeMessages(MSG_TIME_INTERVAL);
                     mSavedState = mDeviceState;
                     if (mSavedState == MEDIA_STATE_PLAY_DOING) {
                         pauseMedia(mMediaPlayer);
                     }
                 }

                 @Override
                 public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
                     mHandler.removeMessages(MSG_TIME_INTERVAL);
                     VoiceTimeUtils ts = VoiceTimeUtils.timeSpanSecond(progress / 1000);
                     //播放进度
                     if (voicePlayCallBack != null) {
                         voicePlayCallBack.playDoing(progress / 1000, String.format("%02d:%02d:%02d",
                                 ts.mSpanHour, ts.mSpanMinute, ts.mSpanSecond));
                     }
                 }

                 @Override
                 public void onStopTrackingTouch(SeekBar seekBar) {
                     seekMedia(mMediaPlayer, mSBPlayProgress.getProgress());

                     if (mSavedState == MEDIA_STATE_PLAY_DOING) {
                         playMedia(mMediaPlayer);
                         mHandler.sendEmptyMessage(MSG_TIME_INTERVAL);
                     }
                 }
             });
         }

     }

    /**
     * 开始播放（外部调用）
     * @param filePath
     */
     public void startPlay(String filePath){
         if (TextUtils.isEmpty(filePath)|| !new File(filePath).exists())
         {
             if (voicePlayCallBack != null) {
                 voicePlayCallBack.playFinish();
             }
             Toast.makeText(context,"文件不存在",Toast.LENGTH_SHORT).show();
             return;
         }else {
             playFilePath = filePath;
             startPlay(true);
         }

     }

    /**
     * 开始播放（内部调用）
     * @param init
     */
     private void startPlay(boolean init){
         try {
             stopRecorder(mMediaRecorder, true);
             mMediaRecorder = null;

             stopMedia(mMediaPlayer, true);
             mMediaPlayer = null;

             mMediaPlayer = new MediaPlayer();
             mMediaPlayer.setOnCompletionListener(mPlayCompetedListener);

             if (prepareMedia(mMediaPlayer, playFilePath)) {
                 mDeviceState = MEDIA_STATE_PLAY_DOING;
                 //总时间长度
                 long totalTime = mMediaPlayer.getDuration() / 1000;
                 VoiceTimeUtils ts = VoiceTimeUtils.timeSpanSecond(totalTime);
                 String voiceLength = String.format("%02d:%02d:%02d",
                         ts.mSpanHour, ts.mSpanMinute, ts.mSpanSecond);
                 //播放进度回调
                 if (voicePlayCallBack != null) {
                     voicePlayCallBack.voiceTotalLenth(totalTime, voiceLength);
                     voicePlayCallBack.playDoing(0, "00:00:00");
                 }
                 if (mSBPlayProgress != null) {
                     mSBPlayProgress.setMax(Math.max(1, mMediaPlayer.getDuration()));
                 }
                 if (init) {
                     if (mSBPlayProgress != null) {
                         mSBPlayProgress.setProgress(0);
                     }
                     seekMedia(mMediaPlayer, 0);
                 } else {
                     seekMedia(mMediaPlayer, mSBPlayProgress.getProgress());
                 }
                 if (playMedia(mMediaPlayer)) {
                     mHandler.removeMessages(MSG_TIME_INTERVAL);
                     mHandler.sendEmptyMessage(MSG_TIME_INTERVAL);
                 }
             }
         } catch (Exception e) {
             Log.e("播放出错了", e.getMessage());
         }

     }

    /**
     * 继续暂停
     */
    public void continueOrPausePlay(){
        if (mDeviceState == MEDIA_STATE_PLAY_DOING) {
            mDeviceState = MEDIA_STATE_PLAY_PAUSE;
            pauseMedia(mMediaPlayer);
            //暂停
            if (voicePlayCallBack != null) {
                voicePlayCallBack.playPause();
            }
        } else if (mDeviceState == MEDIA_STATE_PLAY_PAUSE) {
            mDeviceState = MEDIA_STATE_PLAY_DOING;
            playMedia(mMediaPlayer);
            //播放中
            mHandler.removeMessages(MSG_TIME_INTERVAL);
            mHandler.sendEmptyMessage(MSG_TIME_INTERVAL);
        } else if (mDeviceState == MEDIA_STATE_PLAY_STOP) {
            //播放
            if (!TextUtils.isEmpty(playFilePath)) {
                startPlay(false);
            }
        }

     }

    /**
     * 停止播放
     */
    public void stopPlay(){
        mHandler.removeMessages(MSG_TIME_INTERVAL);
        mDeviceState = MEDIA_STATE_PLAY_STOP;
        stopMedia(mMediaPlayer, true);
        mMediaPlayer = null;
     }

    /**
     * 是否在播放中
     * @return
     */
     public boolean isPlaying(){
         return mDeviceState == MEDIA_STATE_PLAY_DOING;
     }

    /*********************************播放操作end***************************/

    /**
     * 播放录音准备工作
     */
    private boolean prepareMedia(MediaPlayer mp,String file){
        boolean result = false;
        try {
            mp.setDataSource(file);
            mp.prepare();
            result = true;
        } catch (Exception e) {
        }

        return result;
    }

    /**
     * 播放录音开始
     * @param mp
     * @return
     */
    private boolean playMedia(MediaPlayer mp){
        boolean result = false;
        try {
            if (mp != null) {
                mp.start();
                result = true;
            }
        } catch (Exception e) {
        }

        return result;
    }

    /**
     * 拖动播放进度条
     * @param mp
     * @param pos
     * @return
     */
    private boolean seekMedia(MediaPlayer mp,int pos){
        boolean result = false;
        try {
            if (mp != null && pos >= 0) {
                mp.seekTo(pos);
                result = true;
            }
        } catch (Exception e) {
        }
        return result;
    }

    /**
     * 停止播放
     * @param mp
     * @param release
     * @return
     */
    private boolean stopMedia(MediaPlayer mp,boolean release){
        boolean result = false;
        try {
            if (mp != null) {
                mp.stop();

                if (release) {
                    mp.release();


                }
                result = true;
            }
        } catch (Exception e) {
        }

        return result;
    }

    /**
     * 暂停播放
     * @param mp
     * @return
     */
    private boolean pauseMedia(MediaPlayer mp){
        boolean result = false;

        try {
            if (mp != null) {
                mp.pause();
                result = true;
            }
        } catch (Exception e) {
        }

        return result;
    }

    private boolean stopRecorder(MediaRecorder mr, boolean release) {
        boolean result = false;
        try {
            if (mr != null) {
                mr.stop();
                if (release) {
                    mr.release();
                }
                result = true;
            }
            if(mThread!=null){
                mThread.exit();
                mThread=null;
            }
        } catch (Exception e) {
            if(mThread!=null){
                mThread=null;
                mThread.exit();
            }
        }
        return result;

    }

    /**
     * 录音准备工作 ，开始录音
     *
     * @param mr
     * @param start
     * @return
     */
    @SuppressWarnings("deprecation")
    private File prepareRecorder(MediaRecorder mr, boolean start) {
        File recFile = null;
        if (mr == null) return null;
        try {
            String path = recAudioDir(recordFilePath).getAbsolutePath();
            recFile = new File(path, VoiceTimeUtils.getTime() + ".amr");
            mr.setAudioSource(MediaRecorder.AudioSource.MIC);
            mr.setOutputFormat(MediaRecorder.OutputFormat.RAW_AMR);
            mr.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
            mr.setOutputFile(recFile.getAbsolutePath());
            mr.prepare();
            if (start) {
                mr.start();
                if (mThread == null) {
                    mThread = new ObtainDecibelThread();
                    mThread.start();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return recFile;

    }

    /**
     * 停止录音和播放
     */
    public void stopRecordAndPlay(){
        stopRecorder(mMediaRecorder, true);
        mMediaRecorder = null;
        stopMedia(mMediaPlayer, true);
        mMediaPlayer = null;
    }

    /**
     * 录音回调监听
     */
    public interface VoiceRecordCallBack{
        //录音中
        void recDoing(long time,String strTime);
        //录音中的声音频率等级;
        void recVoiceGrade(int grade);
        //录音开始
        void recStart(boolean init);
        //录音暂停
        void recPause(String str);
        //录音结束
        void recFinish(long lenth,String strLenth,String path);
    }
    /**
     * 播放录音回调监听
     */
    public interface VoicePlayCallBack{
        /**
         * 音频长度
         * 指定的某个时间段，以秒为单位
         */
        void voiceTotalLenth(long time,String strTime);
        /**
         * 播放中
         * 指定的某个时间段，以秒为单位
         */
        void playDoing (long time,String strTime);
        //播放暂停
        void playPause();
        //播放开始
        void playStart();
        //播放结束
        void  playFinish();
    }

    /**
     * SD卡是否可用
     */
    public static boolean isSDCardAvailable() {
        return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState());
    }

    public static File recAudioDir(String path) {
        File file = new File(path);
        if (!file.exists()) {
            file.mkdirs();
        }
        return file;
    }
}

本项目的url地址：
https://github.com/jaydenxiao2016/VoiceManager/blob/master/app/src/main/java/com/jaydenxiao/voicemanager/RecordVoiceButton.java

你可能感兴趣的:(VoiceManager的封装)

  • 华为OD机试E卷 - 增强的strstr（Java & Python& JS & C++ & C ） 算法大师 最新华为OD机试java华为odpythonjavascriptc语言c++华为OD机试E卷
    最新华为OD机试真题目录：点击查看目录华为OD面试真题精选：点击立即查看题目描述C语言有一个库函数：char*strstr(constchar*haystack,constchar*needle)，实现在字符串haystack中查找第一次出现字符串needle的位置，如果未找到则返回null。现要求实现一个strstr的增强函数，可以使用带可选段的字符串来模糊查询，与strstr一样返回首次查找到
  • java过滤器---用户登陆校验的简单实例 Winston-Tao javaweb基础serverfilter实例
    核心功能：对于用户的访问进行校验，看用户是否已经登陆1.登陆界面代码如下：InserttitlehereServlet/LoginServlet"method="post">username:passsword:2.过滤器代码如下：packageFilter;importjava.io.IOException;importjava.nio.channels.SeekableByteChannel;
  • Jdbc--实现对数据库的查询，更改，删除，添加等方法 Winston-Tao
    1.先新建一个数据库，代码如下：CREATETABLEuser_t(idINT(11)UNSIGNEDNOTNULLAUTO_INCREMENT,nameVARCHAR(50)NOTNULLDEFAULT'',passwordVARCHAR(50)NOTNULLDEFAULT'',emailVARCHAR(50)NOTNULLDEFAULT'',PRIMARYKEY(id))ENGINE=INNO
  • skynet 源码阅读 -- timer 的实现原理 Winston-Tao skynet源码阅读c语言skynettimer时间轮算法
    1.Timer驱动的核心流程1.1Timer线程驱动以下是timer线程的核心流程代码。Skynet的Timer模块是通过一个单独的线程(thread_timer)来定期更新定时器的状态。每隔2500微秒（2.5ms）更新一次定时器的状态。ps：为什么是2500？staticvoid*thread_timer(void*p){structmonitor*m=p;skynet_initthread(
  • RLHF技术演进：从理论突破到工程实践 XianxinMao 人工智能语言模型
    标题：RLHF技术演进：从理论突破到工程实践文章信息摘要：RLHF技术作为大语言模型发展的关键突破点，在ChatGPT的成功实践中得到验证。文章深入分析了RLHF当前面临的基础设施限制和技术挑战，并介绍了TRLX这一企业级RLHF解决方案的技术架构与实践价值。通过讲述者的职业发展轨迹，展现了AI领域技术人员对专业的执着追求。文章对RLHF的现状、挑战和未来发展进行了全面剖析，为理解这一关键技术提供
  • 采用普罗米修斯（Prometheus ）监控各个指标的含义，类型，以及格式 OpenSani k8s云原生
    1.Prometheus监控指标的类型普罗米修斯主要有四种类型的监控指标：Counter类型的指标：其工作方式和计数器一样，只增不减（除非系统发生重置）。常见的监控指标，如机器的启动时间（node_cpu），HTTP访问量（http_requests_total）等。可以通过PromQL语句对这些指标进行分析，如：查询当前系统中，访问量前10的HTTP地址：topk(10,http_request
  • Python代码用于在Abaqus中提取指定节点集的反作用力数据 Renz_314 python材料工程
    这段代码用于在Abaqus中提取指定节点集的反作用力数据，并显示仿真结果。它通过打开仿真结果数据库（ODB文件），在特定视口中显示仿真结果，并从指定的节点集中提取反作用力数据，供后续分析使用。fromabaqusimport*fromabaqusConstantsimport*importvisualizationimportxyPlot#打开指定路径下的ODB文件odb=visualizatio
  • ABAQUS批量提取节点坐标 不自律的狗 python
    很简单的代码，就不多赘述了，如果是纯小白的话去我B站视频看就好了。ABAQUS批量提取节点坐标_哔哩哔哩_bilibili#-*-coding:utf-8-*-fromodbAccessimportopenOdbfromtextReprimport*fromabaqusimport*fromabaqusConstantsimport*fromcaeModulesimport*importcsvim
  • 什么是JavaScript中的Map和Set数据结构？它们与普通对象有什么不同？ 几何心凉 前端入门之旅javascript数据结构开发语言
    聚沙成塔·每天进步一点点本文回顾⭐专栏简介什么是JavaScript中的Map和Set数据结构？它们与普通对象有什么不同？1.Map数据结构1.1定义和基本用法创建Map添加键值对获取值检查键删除键值对获取Map的大小1.2Map的遍历1.3Map与普通对象的区别2.Set数据结构2.1定义和基本用法创建Set添加值检查值删除值2.2Set的遍历2.3Set与数组的区别3.总结3.1Map与对象的
  • Abaqus中批量对节点施加集中力荷载 有限元术仿真 Abaqus二次开发python
    笔者为科研界最后的摆烂王，目前利用python代码对Abaqus进行二次开发尚在学习中。欢迎各位摆烂的仁人志士们和我一起摆烂！ps：搞什么科研，如果不是被逼无奈，谁要搞科研！先前撰写了一篇关于Abaqus批量施加荷载（位移）的文章，但是很多哥哥们私信小弟的问题，大都是需要施加集中力或者其他节点力。所以昨天也是抽空写了一下，关于Abaqus批量施加集中力荷载在任一节点上的python脚本。在这段过程
  • 常用Python自动化测试框架有哪些？ 字节程序员 软件测试python开发语言压力测试单元测试集成测试
    随着技术的进步和自动化技术的出现，市面上出现了一些自动化测试框架。只需要进行一些适用性和效率参数的调整，这些自动化测试框架就能够开箱即用，大大节省了测试时间。而且由于这些框架被广泛使用，他们具有很好的健壮性，并且具有广泛多样的用例集和技术来轻易发现微小的缺陷。以前，测试团队接手一个项目，他们不得不为这个项目构建一个自动化测试框架。一个测试框架应该具有最佳的测试用例、假设（assumptions）、
  • 华为OD机试E卷 --增强的strstr--24年OD统一考试（Java & JS & Python & C & C++） 飞码创造者 最新华为OD机试题库2024华为odjavajavascriptpythonc语言
    文章目录题目描述输入描述输出描述用例题目解析JS算法源码Java算法源码python算法源码题目描述C语言有一个库函数:char*strstr(constchar*haystack,constchar*needle),实现在字符串haystack中查找第一次出现字符串needle的位置，如果未找到则返回null。现要求实现一个strstr的增强函数，可以使用带可选段的字符串来模糊查询，strstr
  • 分布式微服务系统架构第87集：kafka 掘金-我是哪吒 分布式微服务系统架构kafka架构
    Kafka就是为了解决上述问题而设计的一款基于发布与订阅的消息系统。它一般被称为“分布式提交日志”或者“分布式流平台”。文件系统或数据库提交日志用来提供所有事务的持久记录，通过重放这些日志可以重建系统的状态。同样地，Kafka的数据是按照一定顺序持久化保存的，可以按需读取。此外，Kafka的数据分布在整个系统里，具备数据故障保护和性能伸缩能力。消息和批次消息和批次Kafka的数据单元被称为消息。如
  • 使用 Python 指定内容 爬取百度引擎搜索结果 m0_74825614 python百度开发语言
    在本篇博客中，我将展示如何使用Python编写一个简单的百度搜索爬虫。这个爬虫可以自动化地从百度获取搜索结果，并提取每个结果的标题和链接。我们将使用requests库来发送HTTP请求，使用BeautifulSoup库来解析HTML内容。需求分析在实现爬虫之前，我们需要明确以下需求：通过构建百度搜索的URL来发送搜索请求。解析百度搜索结果页面，提取每个结果的标题和链接。将搜索结果以列表形式返回，方
  • skynet 源码阅读 -- 核心概念服务 skynet_context Winston-Tao skynet源码阅读skynet游戏开发C语言游戏服务器框架lua
    本文从Skynet源码层面深入解读服务（Service）的创建流程。从最基础的概念出发，逐步深入skynet_context_new函数、相关数据结构（skynet_context,skynet_module,message_queue等），并通过流程图、结构图、以及源码片段的细节分析，希望能对Skynet服务的创建有一个由浅入深的系统认识。1.前言在Skynet中，“服务（Service）”是最
  • 安卓动态设置Unity图形API Jack Yan Unity进阶androidunity游戏引擎
    命令行方式Unity图像api设置为自动，安卓动态设置Vulkan、OpenGLESUnity设置安卓设置创建自定义活动并将其设置为应用程序入口点。在自定义活动中，覆盖字符串UnityPlayerActivity。updateunitycommandlineararguments（StringcmdLine）方法。在该方法中，将cmdLine参数与您自己的启动参数连接起来，然后返回结果。重要：cm
  • CTF学记之云影密码 Z时代.bug(゜▽゜*) CTF密码学
    2023.10.22表现形式1，2，4，8这四个数字，可以通过加法来表示0-9中的任何一个数字。之后再用1-26来表示26个英文字母，就有了密文与明文之间的对应关系。引入0来作为间隔，以免出现混乱。所以云影密码又叫“01248密码”。示例1：1A28J1288S2B128K488T12C48L1488U4D148M2488V14E248N12488W24F1248O888X124G88P1888Y
  • Effective C++ 规则42：了解typename的用法 哎呦，帅小伙哦 C++c++
    1、typename的用途typename是一个上下文敏感的关键字，用来告诉编译器某个嵌套类型名是一个类型，而不是变量或其他实体。它有两种主要使用的场景。1.1、在模板定义中声明嵌套类型当在模板中访问嵌套类型（比如类型别名或类型定义），如果该类型是依赖于模板参数的，就必须使用typename。如果不使用typename会导致编译错误，下面是代码示例：templateclassContainer{p
  • stm32内存溢出怎么办 嵌入式小强工作室 stm32java嵌入式硬件
    STM32内存溢出是一个常见的问题，可能由多种原因引起，如数组定义过大、函数调用层级过深、堆栈空间不足等。针对这个问题，可以采取以下几种解决方法：一、增加堆栈大小堆栈溢出通常是由于堆栈空间不足以容纳函数调用和局部变量的信息。因此，增加堆栈大小是一种有效的解决方法。在STM32的工程中，可以通过修改链接脚本文件（.ld文件）中的堆栈大小参数来增加堆栈空间。通常，堆栈大小设置为RAM的一小部分，但需要
  • android14的下拉栏定制 little six androidjava
    将android14的下拉栏进行修改，要求实现要实现这种效果1.修改tile的形状要将形状从之前的长方形改成圆形我们需要对他找到他生成tile的地方，他是通过diff--gita/src/com/android/systemui/qs/tileimpl/QSFactoryImpl.javab/src/com/android/systemui/qs/tileimpl/QSFactoryImpl.ja
  • python连接MYSQL数据库（连接MYSQL数据库报错解决方法） Oblinto 数据库学习数据库mysql
    一、连接前的准备（如果报错可以从以下几个方面检查一下）1.检查mysql服务查看mysql服务是否开启sudosystemctlstatusmysql若没开启，开启mysql服务sudosystemctlstartmysql2.检查mysql的3306端口查看3306端口是否打开netstat-an|grep3306若没打开，打开3306端口sudoufwallow3306/tcp3.修改配置文件
  • RabbitMQ-SpringBoot案例 -topic模式 毕竟尹稳健 RabbitMQSpringBootrabbitmqspringbootjava
    生产者工程1、RabbitTemplate配置类无,其实并不是没有，而是将配置类的方式换成了注解的。但实际上开发建议用配置类，注解也就图一乐。2、消息发送服务packagecom.sky.service.impl;importcom.sky.service.OrderService;importorg.springframework.amqp.rabbit.core.RabbitTemplate;
  • springboot实现webservice的发布和调用 梦星剑魂 springbootmvcjavaspring
    springboot使用cxf发布调用webservice发布webservicepom文件org.apache.cxfcxf-spring-boot-starter-jaxws3.2.5webservice接口packagecom.example.webservicedemo.fabu;importjavax.jws.WebMethod;importjavax.jws.WebParam;impo
  • SpringBoot WebService IDEA版本 客户端调用（postman调用） SmileDark SpringSpringBootWebServiceSpringBootWebServiceWebServicespringbootwspostman调用WebSericepostmanwebservice
    webservice是什么网上的解释很多，其实就是跨语言和操作系统的的远程调用技术。比如亚马逊，可以将自己的服务以webservice的服务形式暴露出来，我们就可以通过web调用这些，无论我们使用的语言是java还是c，这也是SOA应用一种表现形式。注意点讲在前面1.命名空间（nameSpase）.xsd文件targetNamespace==Endpoint的NAMESPACE_URI1.新建sp
  • github上的python代码怎么运行_使用 Python 在 GitHub 上运行你的博客 -Fun言 weixin_39946300
    使用Pelican创建博客，这是一个基于Python的平台，与GitHub配合的不错。GitHub是一个非常流行的用于源代码控制的Web服务，它使用Git同步本地文件和GitHub服务器上保留的副本，这样你就可以轻松地共享和备份你的工作。除了为代码仓库提供用户界面之外，GitHub还运允许用户直接从仓库发布网页。GitHub推荐的网站生成软件包是Jekll，是使用Ruby编写的。因为我是Pytho
  • java jdbc实验_实验七Java之Jdbc weixin_39969976 javajdbc实验
    实验七Jdbc编程1．实验目的(1)掌握通过JDBC方式操作数据库的基本步骤。(2)掌握增、删、改、查记录等的方法。(3)掌握查询记录以及遍历查询结果的方法。2．实验内容实验题1学生信息管理。创建student表，包含学生的学号、姓名、年龄信息。①根据学号，可以查询到学生的姓名和年龄；②给定学生的学号、姓名、年龄，在表中追加一行信息；③给定学生的学号，可以从表中删除该学生的信息；[基本要求]对上面
  • python execjs库_python3调用js的库之execjs 一盏Online pythonexecjs库
    针对现在大部分的网站都是使用js加密，js加载的，并不能直接抓取出来，这时候就不得不适用一些三方类库来执行js语句执行JS的类库：execjs，PyV8，selenium，node这里主要讲一下execjs，一个比较好用且容易上手的类库(支持py2，与py3)，支持JSruntime。(一)安装：pipinstallPyExecJSoreasy_installPyExecJS(二)运行时环境exe
  • Python 执行 javascript PyExecJS 模块 weixin_30376083 pythonjavascriptjsonViewUI
    PyExecJS安装pipinstallPyExecJSPyExecJS的基本使用:>>>importexecjs>>>execjs.eval("'redyellowblue'.split('')")['red','yellow','blue']>>>ctx=execjs.compile("""...functionadd(x,y){...returnx+y;...}...""")>>>ctx.c
  • C++深入学习string类成员函数（4）：字符串的操作 舞武零落 c++学习开发语言
    引言在c++中，std::string提供了许多字符串操作符函数，让我们能够秦松驾驭文本数据，而与此同时，非成员函数的重载更是为string类增添了别样的魅力，输入输出流的重载让我们像处理基本类型的数据一样方便地读取和输出字符串，连接操作符的重载使得字符串的拼接变得简洁直观。在这篇博客中，我们将一同深入剖析C++中string类的字符串操作符和非成员函数的重载，为大家在编程之旅中增添一份有力的武器
  • Transformer大模型实战 BART模型的架构 AI天才研究院 大数据AI人工智能AI大模型企业级应用开发实战AI大模型应用入门实战与进阶计算科学神经计算深度学习神经网络大数据人工智能大型语言模型AIAGILLMJavaPython架构设计AgentRPA
    Transformer大模型实战BART模型的架构作者：禅与计算机程序设计艺术/ZenandtheArtofComputerProgramming/TextGenWebUILLMTransformer大模型实战BART模型的架构1.背景介绍1.1问题的由来随着大规模预训练模型的兴起，如BERT、GPT系列等，研究人员发现基于Transformer架构的模型在自然语言处理任务上表现出了显著的优势。为
  • mondb入手 木zi_鸣 mongodb
    windows 启动mongodb  编写bat文件， mongod --dbpath D:\software\MongoDBDATA mongod --help  查询各种配置 配置在mongob 打开批处理，即可启动，27017原生端口，shell操作监控端口  扩展28017，web端操作端口 启动配置文件配置， 数据更灵活 
  • 大型高并发高负载网站的系统架构 bijian1013 高并发负载均衡
            扩展Web应用程序 一.概念         简单的来说，如果一个系统可扩展，那么你可以通过扩展来提供系统的性能。这代表着系统能够容纳更高的负载、更大的数据集，并且系统是可维护的。扩展和语言、某项具体的技术都是无关的。扩展可以分为两种：         1.
  • DISPLAY变量和xhost(原创) czmmiao display
    DISPLAY 在Linux/Unix类操作系统上, DISPLAY用来设置将图形显示到何处. 直接登陆图形界面或者登陆命令行界面后使用startx启动图形, DISPLAY环境变量将自动设置为:0:0, 此时可以打开终端, 输出图形程序的名称(比如xclock)来启动程序, 图形将显示在本地窗口上, 在终端上输入printenv查看当前环境变量, 输出结果中有如下内容:DISPLAY=:0.0
  • 获取B/S客户端IP 周凡杨 java编程jspWeb浏览器
       最近想写个B/S架构的聊天系统，因为以前做过C/S架构的QQ聊天系统，所以对于Socket通信编程只是一个巩固。对于C/S架构的聊天系统，由于存在客户端Java应用，所以直接在代码中获取客户端的IP，应用的方法为：    String ip = InetAddress.getLocalHost().getHostAddress(); 然而对于WEB
  • 浅谈类和对象 朱辉辉33 编程
        类是对一类事物的总称，对象是描述一个物体的特征，类是对象的抽象。简单来说，类是抽象的，不占用内存，对象是具体的， 占用存储空间。     类是由属性和方法构成的，基本格式是public  class 类名{ //定义属性 private/public 数据类型 属性名； //定义方法 publ
  • android activity与viewpager+fragment的生命周期问题 肆无忌惮_ viewpager
    有一个Activity里面是ViewPager，ViewPager里面放了两个Fragment。 第一次进入这个Activity。开启了服务，并在onResume方法中绑定服务后，对Service进行了一定的初始化，其中调用了Fragment中的一个属性。 super.onResume(); bindService(intent, conn, BIND_AUTO_CREATE);
  • base64Encode对图片进行编码 843977358 base64图片encoder
    /** * 对图片进行base64encoder编码 * * @author mrZhang * @param path * @return */ public static String encodeImage(String path) { BASE64Encoder encoder = null; byte[] b = null; I
  • Request Header简介 aigo servlet
    当一个客户端(通常是浏览器)向Web服务器发送一个请求是，它要发送一个请求的命令行，一般是GET或POST命令，当发送POST命令时，它还必须向服务器发送一个叫“Content-Length”的请求头(Request   Header)   用以指明请求数据的长度，除了Content-Length之外，它还可以向服务器发送其它一些Headers，如：    
  • HttpClient4.3 创建SSL协议的HttpClient对象 alleni123 httpclient爬虫ssl
    public class HttpClientUtils { public static CloseableHttpClient createSSLClientDefault(CookieStore cookies){ SSLContext sslContext=null; try { sslContext=new SSLContextBuilder().l
  • java取反 -右移-左移-无符号右移的探讨 百合不是茶 位运算符 位移
    取反： 在二进制中第一位，1表示符数，0表示正数 byte a = -1; 原码：10000001 反码：11111110 补码：11111111 //异或: 00000000 byte b = -2; 原码：10000010 反码：11111101 补码：11111110 //异或: 00000001
  • java多线程join的作用与用法 bijian1013 java多线程
            对于JAVA的join，JDK 是这样说的：join public final void join （long millis ）throws InterruptedException Waits at most millis milliseconds for this thread to die. A timeout of 0 means t
  • Java发送http请求(get 与post方法请求) bijian1013 javaspring
    PostRequest.java package com.bijian.study; import java.io.BufferedReader; import java.io.DataOutputStream; import java.io.IOException; import java.io.InputStreamReader; import java.net.HttpURL
  • 【Struts2二】struts.xml中package下的action配置项默认值 bit1129 struts.xml
    在第一部份，定义了struts.xml文件，如下所示：   <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN" "http://struts.apache.org/dtds/struts
  • 【Kafka十三】Kafka Simple Consumer bit1129 simple
    代码中关于Host和Port是割裂开的，这会导致单机环境下的伪分布式Kafka集群环境下，这个例子没法运行。 实际情况是需要将host和port绑定到一起，   package kafka.examples.lowlevel; import kafka.api.FetchRequest; import kafka.api.FetchRequestBuilder; impo
  • nodejs学习api ronin47 nodejs api
    NodeJS基础 什么是NodeJS JS是脚本语言，脚本语言都需要一个解析器才能运行。对于写在HTML页面里的JS，浏览器充当了解析器的角色。而对于需要独立运行的JS，NodeJS就是一个解析器。 每一种解析器都是一个运行环境，不但允许JS定义各种数据结构，进行各种计算，还允许JS使用运行环境提供的内置对象和方法做一些事情。例如运行在浏览器中的JS的用途是操作DOM，浏览器就提供了docum
  • java-64.寻找第N个丑数 bylijinnan java
    public class UglyNumber { /** * 64.查找第N个丑数 具体思路可参考 [url] http://zhedahht.blog.163.com/blog/static/2541117420094245366965/[/url] * 题目：我们把只包含因子 2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14
  • 二维数组（矩阵）对角线输出 bylijinnan 二维数组
    /** 二维数组 对角线输出 两个方向 例如对于数组： { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 9, 10, 11, 12 }, { 13, 14, 15, 16 }, slash方向输出： 1 5 2 9 6 3 13 10 7 4 14 11 8 15 12 16 backslash输出： 4 3
  • [JWFD开源工作流设计]工作流跳跃模式开发关键点(今日更新) comsci 工作流
       既然是做开源软件的,我们的宗旨就是给大家分享设计和代码,那么现在我就用很简单扼要的语言来透露这个跳跃模式的设计原理    大家如果用过JWFD的ARC-自动运行控制器,或者看过代码,应该知道在ARC算法模块中有一个函数叫做SAN(),这个函数就是ARC的核心控制器,要实现跳跃模式,在SAN函数中一定要对LN链表数据结构进行操作,首先写一段代码,把
  • redis常见使用 cuityang redis常见使用
    redis 通常被认为是一个数据结构服务器，主要是因为其有着丰富的数据结构 strings、map、 list、sets、 sorted sets 引入jar包 jedis-2.1.0.jar  (本文下方提供下载) package redistest; import redis.clients.jedis.Jedis; public class Listtest
  • 配置多个redis dalan_123 redis
    配置多个redis客户端 <?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi=&quo
  • attrib命令 dcj3sjt126com attr
      attrib指令用于修改文件的属性.文件的常见属性有:只读.存档.隐藏和系统.    只读属性是指文件只可以做读的操作.不能对文件进行写的操作.就是文件的写保护.    存档属性是用来标记文件改动的.即在上一次备份后文件有所改动.一些备份软件在备份的时候会只去备份带有存档属性的文件. 
  • Yii使用公共函数 dcj3sjt126com yii
    在网站项目中，没必要把公用的函数写成一个工具类，有时候面向过程其实更方便。 在入口文件index.php里添加 require_once('protected/function.php'); 即可对其引用，成为公用的函数集合。 function.php如下：   <?php /**   * This is the shortcut to D
  • linux 系统资源的查看（free、uname、uptime、netstat） eksliang netstatlinux unamelinux uptimelinux free
    linux 系统资源的查看 转载请出自出处：http://eksliang.iteye.com/blog/2167081   http://eksliang.iteye.com 一、free查看内存的使用情况 语法如下：   free [-b][-k][-m][-g] [-t] 参数含义 -b:直接输入free时，显示的单位是kb我们可以使用b(bytes),m
  • JAVA的位操作符 greemranqq 位运算JAVA位移<<>>>
    最近几种进制，加上各种位操作符，发现都比较模糊，不能完全掌握，这里就再熟悉熟悉。   1.按位操作符 ：    按位操作符是用来操作基本数据类型中的单个bit,即二进制位，会对两个参数执行布尔代数运算，获得结果。    与（&）运算：    1&1 = 1, 1&0 = 0, 0&0 &
  • Web前段学习网站 ihuning Web
      Web前段学习网站 菜鸟学习：http://www.w3cschool.cc/   JQuery中文网：http://www.jquerycn.cn/   内存溢出：http://outofmemory.cn/#csdn.blog   http://www.icoolxue.com/   http://www.jikexue
  • 强强联合：FluxBB 作者加盟 Flarum justjavac r
    原文：FluxBB Joins Forces With Flarum作者：Toby Zerner译文：强强联合：FluxBB 作者加盟 Flarum译者：justjavac FluxBB 是一个快速、轻量级论坛软件，它的开发者是一名德国的 PHP 天才 Franz Liedke。FluxBB 的下一个版本(2.0)将被完全重写，并已经开发了一段时间。FluxBB 看起来非常有前途的，
  • java统计在线人数（session存储信息的） macroli javaWeb
    这篇日志是我写的第三次了 前两次都发布失败！郁闷极了！   由于在web开发中常常用到这一部分所以在此记录一下，呵呵，就到备忘录了！ 我对于登录信息时使用session存储的，所以我这里是通过实现HttpSessionAttributeListener这个接口完成的。 1、实现接口类，在web.xml文件中配置监听类，从而可以使该类完成其工作。 public class Ses
  • bootstrp carousel初体验 快速构建图片播放 qiaolevip 每天进步一点点学习永无止境bootstrap纵观千象
    img{ border: 1px solid white; box-shadow: 2px 2px 12px #333; _width: expression(this.width > 600 ? "600px" : this.width + "px"); _height: expression(this.width &
  • SparkSQL读取HBase数据，通过自定义外部数据源 superlxw1234 sparksparksqlsparksql读取hbasesparksql外部数据源
    关键字：SparkSQL读取HBase、SparkSQL自定义外部数据源     前面文章介绍了SparSQL通过Hive操作HBase表。   SparkSQL从1.2开始支持自定义外部数据源(External DataSource)，这样就可以通过API接口来实现自己的外部数据源。这里基于Spark1.4.0，简单介绍SparkSQL自定义外部数据源，访
  • Spring Boot 1.3.0.M1发布 wiselyman spring boot
        Spring Boot 1.3.0.M1于6.12日发布，现在可以从Spring milestone repository下载。这个版本是基于Spring Framework 4.2.0.RC1,并在Spring Boot 1.2之上提供了大量的新特性improvements and new features。主要包含以下：   1.提供一个新的sprin
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他