方毅超
方毅超

CopyPasteUtil文件复制黏贴工具类

概述：总结了几篇大牛的文章，左拿右拿，东改西改，取其精华，逐步完善，撸了一个直接能用的文件搬迁的工具类，旨在于易用，易懂，简单，纤瘦。

FileChannel管道流复制文件是基于nio的传输方式。速度上有30%的提升，传统FileOutputStream方式，在复制大文件时。进度打印出现迟滞。综合这两点选择使用FileChannel方案。

该工具类主要用于复制文件、文件夹（批量文件）
以下内容主要包括：

  • 主要核心代码
  • 主要使用方式

主要核心代码：

import android.content.Context;
import android.content.DialogInterface;
import android.util.Log;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class CopyPasteUtil {
    /**
     * copy过程的监听接口
     */
    public interface CopyPasteListener {
        void onSuccess();

        void onProgress(long dirFileCount, long hasReadCount, long dirSize, long hasReadSize);

        void onFail(String errorMsg);

        void onCancle();
    }

    /**
     * 初始化的监听接口
     */
    public interface InitListener {
        void onNext(long dirFileCount, long dirSize, CopyPasteImp imp);
    }

    public static CopyPasteImp build() {
        return new CopyPasteImp();
    }

    public static class CopyPasteImp {
        private long dirSize = 0;// 文件夹总体积
        private long hasReadSize = 0;// 已复制的部分，体积
        private long dirFileCount = 0;// 文件总个数
        private long hasReadCount = 0;// 已复制的文件个数
        private CommonProgressDialog progressDialog;// 进度提示框
        private boolean isNeesDefaulProgressDialog = true;
        private Thread copyFileThread;
        private FileInputStream fileInputStream = null;
        private FileOutputStream fileOutputStream = null;
        private FileChannel fileChannelOutput = null;
        private FileChannel fileChannelInput = null;
        private BufferedInputStream inbuff = null; //todo 屏蔽之后，代码照跑无误，严重怀疑buff是否还有作用，未针对调试。
        private BufferedOutputStream outbuff = null;

        /**
         * 复制单个文件
         */
        public boolean copyFile(final String oldPathName, final String newPathName, Context context) {
            //大于50M时，才显示进度框
            final File oldFile = new File(oldPathName);
            if (oldFile.length() > 50 * 1024 * 1024) {
                if (isNeesDefaulProgressDialog && null == progressDialog) {
                    progressDialog = new CommonProgressDialog(context);
                    progressDialog.setOnCancelListener(new DialogInterface.OnCancelListener() {
                        @Override
                        public void onCancel(DialogInterface dialog) {
                            // TODO Auto-generated method stub
                            copyFileThread.interrupt();
                            copyFileThread = null;
                            try {
                                fileInputStream.close();
                                fileOutputStream.close();
                                fileChannelOutput.close();
                                fileChannelInput.close();
                            } catch (IOException e) {
                                Log.e("CopyPasteUtil", "CopyPasteUtil copyFile error:" + e.getMessage());
                            }
                        }
                    });
                    progressDialog.show();
                }
            }
            Runnable run = new Runnable() {
                @Override
                public void run() {
                    try {
                        File fromFile = new File(oldPathName);
                        File targetFile = new File(newPathName);
                        fileInputStream = new FileInputStream(fromFile);
                        fileOutputStream = new FileOutputStream(targetFile);
                        fileChannelOutput = fileOutputStream.getChannel();
                        fileChannelInput = fileInputStream.getChannel();
                        ByteBuffer buffer = ByteBuffer.allocate(4096);
                        long transferSize = 0;
                        long size = new File(oldPathName).length();
                        int fileVolume = (int) (size / 1024 / 1024);
                        int tempP = 0;
                        int progress = 0;
                        if (null != progressDialog) {
                            progressDialog.setMax(fileVolume * 1024 * 1024);
                        }
                        while (fileChannelInput.read(buffer) != -1) {
                            buffer.flip();
                            transferSize += fileChannelOutput.write(buffer);
                            progress = (int) transferSize / (1024 * 1024);
                            if (progress > tempP) {
                                tempP = progress;
                                if (null != progressDialog) {
                                    progressDialog.setProgress(progress * 1024 * 1024);
                                }
                            }
                            buffer.clear();
                        }
                        fileOutputStream.flush();
                        fileOutputStream.close();
                        fileInputStream.close();
                        fileChannelOutput.close();
                        fileChannelInput.close();
                        if (null != progressDialog && progressDialog.isShowing()) {
                            progressDialog.dismiss();
                        }
                    } catch (Exception e) {
                        Log.e("CopyPasteUtil", "CopyPasteUtil copyFile error:" + e.getMessage());
                    }
                }
            };
            copyFileThread = new Thread(run);
            copyFileThread.start();
            return true;
        }

        /**
         * 复制文件夹
         */
        public void copyDirectiory(Context context, String sourceDir, String targetDir, CopyPasteListener call) {
            if (context != null) {
                if (isNeesDefaulProgressDialog && null == progressDialog) {
                    progressDialog = new CommonProgressDialog(context);
                }
                if (null != progressDialog) {
                    progressDialog.setMessage("文件迁移正在进行中...");
                    progressDialog.setOnCancelListener(new DialogInterface.OnCancelListener() {
                        @Override
                        public void onCancel(DialogInterface dialog) {
                            // TODO Auto-generated method stub
                            copyFileThread.interrupt();
                            copyFileThread = null;
                            try {
                                if (null != fileInputStream) fileInputStream.close();
                                if (null != fileOutputStream) fileOutputStream.close();
                                if (null != inbuff) inbuff.close();
                                if (null != outbuff) outbuff.close();
                                if (null != fileChannelOutput) fileChannelOutput.close();
                                if (null != fileChannelInput) fileChannelInput.close();
                                if (null != call) {
                                    call.onCancle();
                                }
                            } catch (IOException e) {
                                Log.e("CopyPasteUtil", "CopyPasteUtil copyDirectiory error:" + e.getMessage());
                            }
                        }
                    });
                    progressDialog.show();
                }
            }
            Runnable run = new Runnable() {
                @Override
                public void run() {
                    copyDirMethod(0, sourceDir, targetDir, call);
                }
            };
            copyFileThread = new Thread(run);
            copyFileThread.start();
        }

        /**
         * 复制文件夹,真正的执行动作
         */
        private void copyDirMethod(int dirLevel, String sourceDir, String targetDir, CopyPasteListener call) {
            (new File(targetDir)).mkdirs();
            dirLevel++; //进入下一层 层级+1
            File[] file = (new File(sourceDir)).listFiles();// 获取源文件夹当下的文件或目录
            for (int i = 0; i < file.length; i++) {
                if (file[i].isFile()) {
                    File sourceFile = file[i];
                    File targetFile = new File(
                            new File(targetDir).getAbsolutePath() + File.separator + file[i].getName());// 目标文件
                    copyFileMethod(sourceFile, targetFile, call);
                } else if (file[i].isDirectory()) {
                    String dir1 = sourceDir + "/" + file[i].getName();
                    String dir2 = targetDir + "/" + file[i].getName();
                    copyDirMethod(dirLevel, dir1, dir2, call);
                }
            }
            dirLevel--;//该层已经循环遍历完毕，返回上一层 层级-1
            //层级小于等于0，说明已经计算完毕，递归回到最顶层
            if (dirLevel <= 0 && null != call) {
                if (null != progressDialog) {
                    progressDialog.setMessage("文件迁移完成");
                    call.onSuccess();
                }
            }
        }

        /**
         * 复制单个文件，用于上面的复制文件夹方法
         *
         * @param sourcefile 源文件路径
         * @param targetFile 目标路径
         */
        private synchronized void copyFileMethod(final File sourcefile, final File targetFile, CopyPasteListener call) {
            try {
                fileInputStream = new FileInputStream(sourcefile);
                inbuff = new BufferedInputStream(fileInputStream);
                fileOutputStream = new FileOutputStream(targetFile);// 新建文件输出流并对它进行缓冲
                outbuff = new BufferedOutputStream(fileOutputStream);
                int fileVolume = (int) (dirSize / (1024 * 1024));
                fileChannelOutput = fileOutputStream.getChannel();
                fileChannelInput = fileInputStream.getChannel();
                ByteBuffer buffer = ByteBuffer.allocate(4096);
                long transferSize = 0;
                int tempP = 0;
                int progress = 0;
                if (null != progressDialog) {
                    progressDialog.setMax(fileVolume * 1024 * 1024);
                }
                while (fileChannelInput.read(buffer) != -1) {
                    buffer.flip();
                    transferSize += fileChannelOutput.write(buffer);
                    progress = (int) (transferSize + hasReadSize) / (1024 * 1024);
                    if (progress > tempP) {
                        tempP = progress;
                        if (null != progressDialog) {
                            progressDialog.setProgress(progress * 1024 * 1024);
                        }
                        if (null != call) { //此处重点在于传递大小
                            call.onProgress(dirFileCount, hasReadCount, dirSize, transferSize + hasReadSize);
                        }
                    }
                    buffer.clear();
                }
                hasReadCount++;
                hasReadSize += sourcefile.length();
                if (null != call) { //此处重点在于传递文件个数
                    call.onProgress(dirFileCount, hasReadCount, dirSize, hasReadSize);
                }
                outbuff.flush();
                fileOutputStream.flush();
                inbuff.close();
                outbuff.close();
                fileOutputStream.close();
                fileInputStream.close();
                fileChannelOutput.close();
                fileChannelInput.close();
//                if (hasReadSize >= dirSize && null != call) {
//                    call.onSuccess();
//                }
            } catch (FileNotFoundException e) {
                if (null != call) {
                    call.onFail(e.getMessage());
                }
            } catch (IOException e) {
                if (null != call) {
                    call.onFail(e.getMessage());
                }
            }
        }


        /**
         * 删除整个文件夹
         * FileCopeTool.deleteFolder(URL.HtmlPath + "/" + identify);
         *
         * @param path 路径，无需文件名
         */
        public void deleteFolder(String path) {
            File f = new File(path);
            if (f.exists()) {
                // 在判断它是不是一个目录
                if (f.isDirectory()) {
                    // 列出该文件夹下的所有内容
                    String[] fileList = f.list();
                    if (fileList == null) {
                        return;
                    }
                    for (int i = 0; i < fileList.length; i++) {
                        // 对每个文件名进行判断
                        // 如果是文件夹 那么就循环deleteFolder
                        // 如果不是，直接删除文件
                        String name = path + File.separator + fileList[i];
                        File ff = new File(name);
                        if (ff.isDirectory()) {
                            deleteFolder(name);
                        } else {
                            ff.delete();
                        }
                    }
                    // 最后删除文件夹
                    f.delete();

                } else {
                    // 该文件夹不是一个目录
                }
            } else {
                //不存在该文件夹
            }
        }

        /**
         * 获取文件夹大小
         *
         * @param dirLevel 计算文件夹的层级，用于判断递归遍历是否完成,初始调用应该设置为0
         * @param file
         * @param call     完成回调
         */
        private void getDirSize(int dirLevel, File file, InitListener call) {
            if (file.isFile()) {
                // 如果是文件，获取文件大小累加
                dirSize += file.length();
                dirFileCount++;
            } else if (file.isDirectory()) {
                dirLevel++; //进入下一层 层级+1
                File[] f1 = file.listFiles();
                for (int i = 0; i < f1.length; i++) {
                    // 调用递归遍历f1数组中的每一个对象
                    getDirSize(dirLevel, f1[i], call);
                }
                dirLevel--;//该层已经循环遍历完毕，返回上一层 层级-1
            }
            //层级小于等于0，说明已经计算完毕，递归回到最顶层
            if (dirLevel <= 0 && null != call) {
                call.onNext(dirFileCount, dirSize, this);
            }
        }

        /**
         * 初始化全局变量
         */
        private void initDirSize() {
            dirSize = 0;
            hasReadSize = 0;
            dirFileCount = 0;
            hasReadCount = 0;
        }

        /**
         * 复制文件夹前，初始化四个个变量
         */
        public void initValueAndGetDirSize(Context context, File file, InitListener call) {
            if (isNeesDefaulProgressDialog) {
                progressDialog = new CommonProgressDialog(context);
                progressDialog.setMessage("准备...");
                progressDialog.show();
            }
            new Thread(new Runnable() {
                @Override
                public void run() {
                    initDirSize();
                    getDirSize(0, file, call);
                }
            }).start();
        }

        /**
         * 默认为true
         */
        public CopyPasteImp setIsNeesDefaulProgressDialog(boolean isNeed) {
            isNeesDefaulProgressDialog = isNeed;
            return this;
        }
    }
}

进度条工具类：CommonProgressDialog.java


import android.app.AlertDialog;
import android.content.Context;
import android.os.Bundle;
import android.os.Handler;
import android.text.Spannable;
import android.text.SpannableString;
import android.text.style.StyleSpan;
import android.widget.ProgressBar;
import android.widget.TextView;

import com.csair.mmpmobile.R;

import java.text.NumberFormat;

public class CommonProgressDialog extends AlertDialog {
    private ProgressBar mProgress;
    private TextView mProgressNumber;
    private TextView mProgressPercent;
    private TextView mProgressMessage;
    private Handler mViewUpdateHandler;
    private Runnable mViewUpdateRunnable;
    private int mMax;
    private CharSequence mMessage;
    private boolean mHasStarted;
    private int mProgressVal;
    private String TAG = "CommonProgressDialog";
    private String mProgressNumberFormat;
    private NumberFormat mProgressPercentFormat;

    public CommonProgressDialog(Context context) {
        super(context);
// TODO Auto-generated constructor stub
        initFormats();
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
// TODO Auto-generated method stub
        super.onCreate(savedInstanceState);
        setContentView(R.layout.common_progress_dialog);
        mProgress = (ProgressBar) findViewById(R.id.progress);
        mProgressNumber = (TextView) findViewById(R.id.progress_number);
        mProgressPercent = (TextView) findViewById(R.id.progress_percent);
        mProgressMessage = (TextView) findViewById(R.id.progress_message);
        mViewUpdateRunnable = new Runnable() {
            @Override
            public void run() {
                int progress = mProgress.getProgress();
                int max = mProgress.getMax();
                double dProgress = (double) progress / (double) (1024 * 1024);
                double dMax = (double) max / (double) (1024 * 1024);
                if (mProgressNumberFormat != null) {
                    String format = mProgressNumberFormat;
                    mProgressNumber.setText(String.format(format, dProgress, dMax));
                } else {
                    mProgressNumber.setText("");
                }
                if (mProgressPercentFormat != null) {
                    double percent = (double) progress / (double) max;
                    SpannableString tmp = new SpannableString(mProgressPercentFormat.format(percent));
                    tmp.setSpan(new StyleSpan(android.graphics.Typeface.BOLD),
                            0, tmp.length(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
                    mProgressPercent.setText(tmp);
                } else {
                    mProgressPercent.setText("");
                }
            }
        };
        mViewUpdateHandler = new ViewUpdateHandler();
        onProgressChanged();
        if (mMessage != null) {
            setMessage(mMessage);
        }
        if (mMax > 0) {
            setMax(mMax);
        }
        if (mProgressVal > 0) {
            setProgress(mProgressVal);
        }
    }

    private void initFormats() {
        mProgressNumberFormat = "%1.2fM/%2.2fM";
        mProgressPercentFormat = NumberFormat.getPercentInstance();
        mProgressPercentFormat.setMaximumFractionDigits(0);
    }

    private void onProgressChanged() {
        mViewUpdateHandler.post(mViewUpdateRunnable);
    }

    public void setProgressStyle(int style) {
//mProgressStyle = style;
    }

    public int getMax() {
        if (mProgress != null) {
            return mProgress.getMax();
        }
        return mMax;
    }

    public void setMax(int max) {
        if (mProgress != null) {
            mProgress.setMax(max);
            onProgressChanged();
        } else {
            mMax = max;
        }
    }

    public void setIndeterminate(boolean indeterminate) {
        if (mProgress != null) {
            mProgress.setIndeterminate(indeterminate);
        }
// else {
// mIndeterminate = indeterminate;
// }
    }

    public void setProgress(int value) {
        if (mHasStarted) {
            mProgress.setProgress(value);
            onProgressChanged();
        } else {
            mProgressVal = value;
        }
    }

    @Override
    public void setMessage(CharSequence message) {
// TODO Auto-generated method stub
//super.setMessage(message);
        if (mProgressMessage != null) {
            mViewUpdateHandler.post(new Runnable() {
                @Override
                public void run() {
                    mProgressMessage.setText(message);
                }
            });
        } else {
            mMessage = message;
        }

    }

    @Override
    protected void onStart() {
// TODO Auto-generated method stub
        super.onStart();
        mHasStarted = true;
    }

    @Override
    protected void onStop() {
// TODO Auto-generated method stub
        super.onStop();
        mHasStarted = false;
    }

    static class ViewUpdateHandler extends Handler {
    }
}

进度条布局文件：common_progress_dialog.xml

进度条背景资源：

主要使用方式

1，启用默认进度条，初始化或得总体文件大小和总个数，进入下载流程

CopyPasteUtil.build()
                .setIsNeesDefaulProgressDialog(true)
                .initValueAndGetDirSize(mActivity, new File(MMPUrl.SD_PATH), new CopyPasteUtil.InitListener() {
                    @Override
                    public void onNext(long dirFileCount, long dirSize, CopyPasteUtil.CopyPasteImp imp) {
                        int fileVolume = (int) (dirSize / (1024 * 1024));
                        UiThread.run(new Runnable() {
                            @Override
                            public void run() {
                                Toast.makeText(mActivity, "onNext->dirFileCount:" + dirFileCount + "==onNext->dirSize:" + fileVolume + "M", Toast.LENGTH_LONG).show();
                            }
                        });

                        imp.copyDirectiory(mActivity, MMPUrl.SD_PATH, MMPUrl.SD_PATH_COPY, new CopyPasteUtil.CopyPasteListener() {
                            @Override
                            public void onSuccess() {
                                UiThread.run(new Runnable() {
                                    @Override
                                    public void run() {
                                        Toast.makeText(mActivity, "onSuccess:" + i++, Toast.LENGTH_LONG).show();
                                    }
                                });
                            }

                            @Override
                            public void onProgress(long dirFileCount, long hasReadCount, long dirSize, long hasReadSize) {
                                UiThread.run(new Runnable() {
                                    @Override
                                    public void run() {
                                        mVersion.setText(dirFileCount + "-" + hasReadCount + "==" + dirSize + "-" + hasReadSize);
                                    }
                                });
                            }

                            @Override
                            public void onFail(String errorMsg) {
                                UiThread.run(new Runnable() {
                                    @Override
                                    public void run() {
                                        Toast.makeText(mActivity, "onFail", Toast.LENGTH_LONG).show();
                                    }
                                });
                            }

                            @Override
                            public void onCancle() {
                                UiThread.run(new Runnable() {
                                    @Override
                                    public void run() {
                                        Toast.makeText(mActivity, "onCancle", Toast.LENGTH_LONG).show();
                                    }
                                });
                            }
                        });
                    }
                });

2，关闭默认进度条，直接进入下载流程，但是没有总体文件大小和总个数

CopyPasteUtil.build()
                .setIsNeesDefaulProgressDialog(false)
                .copyDirectiory(mActivity, MMPUrl.SD_PATH, MMPUrl.SD_PATH_COPY, new CopyPasteUtil.CopyPasteListener() {
                    @Override
                    public void onSuccess() {
                        UiThread.run(new Runnable() {
                            @Override
                            public void run() {
                                Toast.makeText(mActivity, "onSuccess:" + i++, Toast.LENGTH_LONG).show();
                            }
                        });
                    }

                    @Override
                    public void onProgress(long dirFileCount, long hasReadCount, long dirSize, long hasReadSize) {
                        UiThread.run(new Runnable() {
                            @Override
                            public void run() {
                                mVersion.setText(dirFileCount + "-" + hasReadCount + "==" + dirSize + "-" + hasReadSize);
                            }
                        });
                    }

                    @Override
                    public void onFail(String errorMsg) {
                        UiThread.run(new Runnable() {
                            @Override
                            public void run() {
                                Toast.makeText(mActivity, "onFail", Toast.LENGTH_LONG).show();
                            }
                        });
                    }

                    @Override
                    public void onCancle() {
                        UiThread.run(new Runnable() {
                            @Override
                            public void run() {
                                Toast.makeText(mActivity, "onCancle", Toast.LENGTH_LONG).show();
                            }
                        });
                    }
                });

感谢：
android复制文件、文件夹，使用FileChannel带进度条
实例详解Android自定义ProgressDialog进度条对话框的实现
给progressbar设置drawable和自定义progressbar
FileCopeUtil 文件操作

你可能感兴趣的:(CopyPasteUtil文件复制黏贴工具类)

  • HarmonyOS Next鸿蒙扫一扫功能实现 JohnLiu_ HarmonyOSNextharmonyos华为扫一扫鸿蒙
    直接使用的是华为官方提供的api，封装成一个工具类方便调用。import{common}from'@kit.AbilityKit';import{scanBarcode,scanCore}from'@kit.ScanKit';exportnamespaceScanUtil{exportasyncfunctionstartScan(context:common.Context):Promise{if
  • word转html制作操作手册,Word文档转换为HTML帮助文档操作手册范本.pdf 想吃草莓干 word转html制作操作手册
    Word文档转换为HTML帮助文档操作手册一、使用到的软件DOC2CHMDreamweaverCS3Helpandmanual4二、操作步骤1.先建立一个工作目录。如hhwork。2.将需要转换的文件复制到此工作目录下。如果是中文文件名，最好将其改为英文文件名。例：现在要将《小神探点检定修信息管理系统使用手册0.3.6.doc》转换为Html格式的帮助文档，首先将此文档复制到hhwork目录下并将
  • 上传文件到钉盘流程详解 jspyth 开发场景案例分析开发语言java后端
    文章目录前言准备工作实现过程Maven依赖封装一个工具类获取文件上传信息unionId获取钉盘目录spaceId创建上传到钉盘前言  本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。准备工作1、在钉钉开发者后台创建一个钉钉企业内部应用；2、创建并保存好应用的appKey和appSecret，后面用于获取调用API的请求token；3、应用中配置好所需权限：企业存储文件上传
  • SpringBoot 获取 ApplicationContext loveLifeLoveCoding springbootspringbootjavaspring
    1.概念ApplicationContext是什么？简单来说就是Spring中的容器，可以用来获取容器中的各种bean组件，注册监听事件，加载资源文件等功能2.获取ApplicationContext的方式2.1.创建工具类通过此工具类，可以方便的获取bean组件,获取配置信息等importorg.springframework.beans.BeansException;importorg.spr
  • PCL 点云视窗类CloudViewer LeonDL168 PCL算法计算机视觉人工智能视觉检测图像处理
    点云视窗类CloudViewer是简单显示点云的可视化工具类，可以让用户用尽可能少的代码查看点云。注意：点云视窗类不能应用于多线程应用程序中。简单点云可视化如果用户想用几行代码可视化程序中所对应的地物，可以使用下面的代码：#include//...voidfoo(){pcl::PointCloud::Ptrcloud;//...为cloud添加对应的场景pcl::visualization::Cl
  • 麻雀虽小，五脏俱全 - Java工具类库 - Hutool waiter_chen
    Hutool官网：https://www.hutool.cn官方参考文档：https://www.hutool.cn/docsAsetoftoolsthatkeepJavasweet.——Htool特点通过静态方法封装，类函数式语言般，降低学习成本，提高工作效率整合多方用户需求，减少代码搜索成本，避免网络上参差不齐的代码出现导致的bugutil包提供多方公用类和公用工具方法，节省开发封装时间，减少
  • Java：数学相关类 昭关969 java开发语言
    Math类Math类是数学工具类，用于数学计算，构造方法是私有的，方法都是静态的，因此直接类名调用staticintabs(inta)求参数绝对值staticdoubleceil(doublea)向上取整staticdoublefloor(doublea)向下取整staticlonground(doublea)四舍五入staticintmax(inta,intb)求较大值staticintmin(
  • python打包whl文件 梦中学逆向 pythonpython
    简介当我们自己开发完一个项目时，如果想在别的电脑上使用，将所有文件复制比较麻烦，这时将所有项目打包成一个whl文件，再到别的电脑安装就很简单了准备一个新的虚拟环境：避免版本冲突安装wheel，后面打包要用pipinstallwheel将所有项目放在同一个文件夹下，新建一个setup.py文件importosimportreimportsysfromsetuptoolsimportsetupimpo
  • 文件大小自动转换工具类 小卡车555 java
    根据传入的文件大小，自动转换为B、KB、MB、GB、TBimportjava.text.DecimalFormat;publicclassFileSizeUtil{/***文件单位*/privatestaticfinalString[]units=newString[]{"B","KB","MB","GB","TB"};/***文件大小自动转换*@paramsize*@return*/public
  • 网页隐藏版之一行小说阅读器 流落的小鬼 css前端javascript摸鱼神器最佳隐藏
    网页隐藏版之一行小说阅读器显示效果：懒人操作：页面鼠标右键，新建文本文档，复制黏贴以下代码，点击左上角【文件】，点击【另存为】，如下设置，后缀为.html，这样一个本地网页就完成啦~https://baidu.combody{margin:0;padding:0;}p{font-size:15px;margin:0;padding:0;}/*设置文件输入框的样式*/#fileInput{font-
  • JS 获取时间 买买买买菜
    /**针对Ext的工具类*/exportvarMrYangUtil=function(){/****获得当前时间*/this.getCurrentDate=function(){returnnewDate();};/****获得本周起止时间*/this.getCurrentWeek=function(){//起止日期数组varstartStop=newArray();//获取当前时间varcurr
  • java基础-线程间通信方式 问道飞鱼 Java开发技术java开发语言
    文章目录1.wait()和notify()2.volatile关键字3.Java.util.concurrent包提供的工具类Semaphore（信号量）BlockingQueue（阻塞队列）4.Atomic类在Java中，线程间的通信是非常重要的，尤其是在多线程编程中，它有助于协调线程的行为，确保资源的正确访问和更新。Java提供了多种方式来实现线程间的通信，主要包括以下几种方法：1.wait(
  • 幼儿园观察日 秀珍ginger
    今早，应儿子学校要求，来园里进行为期半日的观察活动。首先是室内活动，不同的活动区里，小朋友各显身手。耐心者，剪纸，折纸，黏贴，一气呵成，主题刚好应着端午节赛龙舟！图片发自App黏土，太空泥爱好者坐在对面，正包着粽子。老师边巡查边指导，整个教室内没有一丝杂乱的动静。图片发自App过了很久，突然响起了乐曲声。一瞧，小朋友们装扮上了，粉墨登场！咿咿呀呀的稚嫩声线，尖尖着兰花指，还要舞起鲜艳的扇子，家长们
  • JavaSE之static关键字 麦芒疯狂生长！ JavaSEjava开发语言
    不积跬步无以至千里，不积小流无已成江海一、认识static我们在学习一个关键字时，首先要关注这个关键字有什么用？我们为什么要学习它？这里给大家先介绍一下static都会出现在我们日常项目的哪些位置。static主要会出现在工具类和测试类当中，这里讲一下什么是JavaBean类、工具类和测试类。1、JavaBean类：用来描述一类事物的类，比如Student类、Teacher类、Dog类、Cat类等
  • Cookie & Session & JWT认证 & Filter & Interceptor aDreamerOutOfTheSky javaspringspringboot
    文章目录前言一、Cookie和Session二、JWT1.三部分2.使用3.另外一种使用3.1引入依赖3.1定义工具类三、Filter过滤器3.1实现Filter接口，并且增加@WebFilter注解3.2启动类上增加注解3.3Filter过滤实现登陆校验3.4拦截器实现登陆校验总结前言本文介绍了Cookie，Session，JWT，过滤器，拦截器的相关知识一、Cookie和Session浏览器请
  • 数仓开发之DWD层完整使用 (第五章) 小坏讲微服务 数据仓库hadoopscalakafka
    数仓开发之DWD层完整使用一、流量域未精加工的事务事实表1、主要任务1）数据清洗（ETL）2）新老访客状态标记修复3）分流2、思路1）数据清洗（ETL）2）新老访客状态标记修复（1）前端埋点新老访客状态标记设置规则（2）新老访客状态标记修复思路3）利用侧输出流实现数据拆分（1）埋点日志结构分析（2）分流日志分类（3）分流思路3、图解4、代码1）在KafkaUtil工具类中补充getKafkaPro
  • OkHttp搞定Http请求 头秃到底
    文章目录OkHttp依赖包创建OkHttpClient构造UrlHeader头设定Get请求同步Get异步GetPost请求Json内容Form表单文件上传Put请求Json内容参数方式Delete请求OkHttp工具类OkHttp官方文档仓库OkHttp是一款高效的HTTP客户端框架:HTTP/2支持允许对同一主机的所有请求共享一个套接字。连接池可以减少请求延迟(如果HTTP/2不可用)。透明G
  • Java数组和字符串 bala_jiang Javajava开发语言
    前言介绍Java数组和字符串的定义和使用。目录前言一、数组（一）、数组概述（二）、数组的使用1.数组的声明和初始化（1）、静态初始化（2）、动态初始化（3）、数组默认初始化值2.数组的长度3.数组元素访问和遍历数组4.数组的扩容与拷贝（三）、二维数组（四）、数组工具类1.booleanequals(数组1，数组2）2.StringtoString(数组）3.voidfill(数组，值）4.void
  • S08 我懂个P|图表篇（二）-我懂个P【设计大神阿文带你飞】（学习笔记） 努力奋斗的durian
    文章原创,最近更新：2018-06-02课程内容:逆袭图表大神第一招：脱掉课程原链接:我懂个P【设计大神阿文带你飞】在上一节课，我们掌握了好图表的三个标准。前提：选对图表设计：简洁大方内容：一针见血从这一节开始，教大家三招超实用的神技，先从第一招开始~脱掉复制黏贴islide智能图表第一招：脱掉所谓脱掉，其实就是把【简洁大方】这个标准贯彻到底，把图表中多余的设计元素通通剥光删掉！怎么脱？脱掉背景纹
  • 2023-07-05 是柒柒吖1
    大概我还真的没睡醒，两点多就醒了，一看错过了时间，真的累啊，一开始00.09的闹钟，昨天晚上我还检查了下，确定没有错，结果却没有被闹钟吵醒，真的无语了对自己。两点多的闹钟结果把自己闹醒了，醒了就做事吧！电脑没地方放，那就放床上，结果发现电脑放床上，鼠标不好使了，每次需要黏贴复制的东西，它却失灵，本来很快能排好的文章，两篇愣是花了我一个半小时，还是没有完善好的。原本想法挺好，想着两个娃睡了，安心的做
  • 配置QT程序的命令行参数 码农飞飞 QT+QMLqtui开发语言json
    在开发一些非UI程序的时候，我们习惯通过命令行参数给程序传递一些配置项和参数。这时候在程序里面解析这些配置项和参数就成了一个让人头疼的问题。其实针对QT命令行参数的解析，QT提供了现成的工具类QCommandLineParser，通过使用工具类可以极大的简化我们解析命令行参数的工作量。这里介绍一下命令行参数解析类的使用方法。获取程序的版本信息对于一些通用产品，比如git或者electron等等我们
  • 使用jackson将xml和对象、List相互转换 齐 飞 xmllistjavaspringboot后端
    文章目录JacksonXml常用注解常用的配置属性相关依赖jackson工具类xml和对象相互转换xml数据实体类xml转为对象对象转为xmlxml和List相互转换xml数据实体类List转xmlxml转List方法1方法2@JacksonXmlElementWrapper的useWrapping参数区别总结JacksonXmlJackson是一个广泛使用的JSON处理库，但在处理XML数据时，
  • linux下文件的复制、移动与删除 搬砖中年人
    一、文件复制命令cp命令格式：cp[-adfilprsu]源文件(source)目标文件(destination)cp[option]source1source2source3...directory参数说明：-a:是指archive的意思，也说是指复制所有的目录-d:若源文件为连接文件(linkfile)，则复制连接文件属性而非文件本身-f:强制(force)，若有重复或其它疑问时，不会询问用户
  • docker快速部署Redis、MySQL、Nginx ChanChan__ Linuxdockerredismysqlnginxlinux服务器微服务
    文章目录docker部署redisdocker部署mysqldocker部署nginxdocker部署redis拉取镜像dockerpullredis:7.0.10拷贝一份redis.conf文件复制到/home/ubuntu/redis文件夹下，修改redis.conf配置文件vimredis.conf-----------------------------------------------
  • 日志工具类-RiZhiHelp taozi_5188 asp.net常用功能和代码
    usingSystem;usingSystem.Collections.Generic;usingSystem.Linq;usingSystem.Text;usingSystem.IO;namespaceRiZhi{publicclassRiZhiHelp{privateconststringPath=@"E:\自己学习\RiZhi\Log\";publicstaticvoidWriteLog(s
  • Linux操作命令学习笔记 Erii要早睡 linux学习
    Linux操作命令学习笔记常用操作命令（以下均严格区分大小写）查看文件以及文件夹：ls命令ls-a（显示隐含文件，如以.开头的文件)ls-l(长格式输出，和ll命令效果近似)ls-R（递归显示）查看当前路径：pwd命令新建目录：mkdir命令mkdir-p（创建多级目录）切换工作目录：cd命令创建文件：touch命令（重复创建可以更新修改时间）文件复制：cp命令cp-R（递归复制）文件移动：mv命
  • Java集合 golove666 后端java集合框架Java集合线程安全
    Java集合一、什么是Java集合？主要组成部分：二、Collections工具类1.**排序相关方法**：2.**查找和替换相关方法**：3.**同步和不可变集合相关方法**：4.**打乱顺序相关方法**：5.**集合频率与填充相关方法**：6.**集合比较相关方法**：7.**集合旋转相关方法**：8.**集合交换相关方法**：9.**集合填充相关方法**：10.**空集合相关方法**：三、集
  • Java 获取中文拼音和首字母 颇有几分姿色 java基础java
    需求：获取中文首字母当做用户登录名。获取用户姓名拼音做其他逻辑。不需要定制化使用hutool封装的PinyinUtil即可，我这里需要自己定制，所以写了个工具类。实现基于搜狐的Pinyin4j库。依赖：cn.hutoolhutool-all5.4.2com.belerwebpinyin4j2.5.1PinyinUtils代码示例PinyinUtils提供了以下主要方法：toHanYuPinyinS
  • Java 入门指南：Java 并发编程 —— 同步工具类 Semephore（信号量） ZachOn1y Javajava开发语言intellij-idea个人开发团队开发java-ee
    文章目录同步工具类Semephore核心功能限制并发访问量公平与非公平策略灵活性与适应性常用方法使用示例同步工具类JUC（Java.util.concurrent）是Java提供的用于并发编程的工具类库，其中包含了一些通信工具类，用于在多个线程之间进行协调和通信，特别是在多线程和网络通信方面。这些工具类提供了丰富的功能，帮助开发者高效地实现复杂的并发控制和网络通信需求。SemephoreSemap
  • Java 入门指南：Java 并发编程 —— 同步工具类 CountDownLatch（倒计时门闩） ZachOn1y Javajava后端个人开发java-ee团队开发
    文章目录同步工具类CountDownLatch常用方法使用步骤适用场景使用示例同步工具类JUC（Java.util.concurrent）是Java提供的用于并发编程的工具类库，其中包含了一些通信工具类，用于在多个线程之间进行协调和通信，特别是在多线程和网络通信方面。这些工具类提供了丰富的功能，帮助开发者高效地实现复杂的并发控制和网络通信需求。CountDownLatchCountDownLatc
  • ztree异步加载 3213213333332132 JavaScriptAjaxjsonWebztree
    相信新手用ztree的时候,对异步加载会有些困惑，我开始的时候也是看了API花了些时间才搞定了异步加载，在这里分享给大家。 我后台代码生成的是json格式的数据，数据大家按各自的需求生成，这里只给出前端的代码。 设置setting，这里只关注async属性的配置 var setting = { //异步加载配置
  • thirft rpc 具体调用流程 BlueSkator 中间件rpcthrift
    Thrift调用过程中，Thrift客户端和服务器之间主要用到传输层类、协议层类和处理类三个主要的核心类，这三个类的相互协作共同完成rpc的整个调用过程。在调用过程中将按照以下顺序进行协同工作：         （1）     将客户端程序调用的函数名和参数传递给协议层（TProtocol），协议
  • 异或运算推导, 交换数据 dcj3sjt126com PHP异或^
    /* * 5 0101 * 9 1010 * * 5 ^ 5 * 0101 * 0101 * ----- * 0000 * 得出第一个规律: 相同的数进行异或, 结果是0 * * 9 ^ 5 ^ 6 * 1010 * 0101 * ---- * 1111 * * 1111 * 0110 * ---- * 1001
  • 事件源对象 周华华 JavaScript
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml&q
  • MySql配置及相关命令 g21121 mysql
            MySQL安装完毕后我们需要对它进行一些设置及性能优化，主要包括字符集设置，启动设置，连接优化，表优化，分区优化等等。           一 修改MySQL密码及用户      
  • [简单]poi删除excel 2007超链接 53873039oycg Excel
          采用解析sheet.xml方式删除超链接，缺点是要打开文件2次,代码如下:      public void removeExcel2007AllHyperLink(String filePath) throws Exception { OPCPackage ocPkg = OPCPac
  • Struts2添加 open flash chart 云端月影
    准备以下开源项目： 1. Struts 2.1.6 2. Open Flash Chart 2 Version 2 Lug Wyrm Charmer (28th, July 2009) 3. jofc2，这东西不知道是没做好还是什么意思，好像和ofc2不怎么匹配，最好下源码，有什么问题直接改。 4. log4j 用eclipse新建动态网站，取名OFC2Demo，将Struts2 l
  • spring包详解 aijuans spring
    下载的spring包中文件及各种包众多，在项目中往往只有部分是我们必须的，如果不清楚什么时候需要什么包的话，看看下面就知道了。 aspectj目录下是在Spring框架下使用aspectj的源代码和测试程序文件。Aspectj是java最早的提供AOP的应用框架。 dist 目录下是Spring 的发布包，关于发布包下面会详细进行说明。 docs&nb
  • 网站推广之seo概念 antonyup_2006 算法Web应用服务器搜索引擎Google
       持续开发一年多的b2c网站终于在08年10月23日上线了。作为开发人员的我在修改bug的同时，准备了解下网站的推广分析策略。     所谓网站推广，目的在于让尽可能多的潜在用户了解并访问网站，通过网站获得有关产品和服务等信息，为最终形成购买决策提供支持。     网站推广策略有很多，seo，email，adv
  • 单例模式,sql注入,序列 百合不是茶 单例模式序列sql注入预编译
      序列在前面写过有关的博客,也有过总结,但是今天在做一个JDBC操作数据库的相关内容时 需要使用序列创建一个自增长的字段  居然不会了,所以将序列写在本篇的前面    1,序列是一个保存数据连续的增长的一种方式; 序列的创建; CREATE SEQUENCE seq_pro 2 INCREMENT BY 1 -- 每次加几个 3
  • Mockito单元测试实例 bijian1013 单元测试mockito
    Mockito单元测试实例： public class SettingServiceTest { private List<PersonDTO> personList = new ArrayList<PersonDTO>(); @InjectMocks private SettingPojoService settin
  • 精通Oracle10编程SQL(9)使用游标 bijian1013 oracle数据库plsql
    /* *使用游标 */ --显示游标 --在显式游标中使用FETCH...INTO语句 DECLARE CURSOR emp_cursor is select ename,sal from emp where deptno=1; v_ename emp.ename%TYPE; v_sal emp.sal%TYPE; begin ope
  • 【Java语言】动态代理 bit1129 java语言
      JDK接口动态代理 JDK自带的动态代理通过动态的根据接口生成字节码(实现接口的一个具体类)的方式，为接口的实现类提供代理。被代理的对象和代理对象通过InvocationHandler建立关联   package com.tom; import com.tom.model.User; import com.tom.service.IUserService;
  • Java通信之URL通信基础 白糖_ javajdkwebservice网络协议ITeye
    java对网络通信以及提供了比较全面的jdk支持，java.net包能让程序员直接在程序中实现网络通信。 在技术日新月异的现在，我们能通过很多方式实现数据通信，比如webservice、url通信、socket通信等等，今天简单介绍下URL通信。 学习准备：建议首先学习java的IO基础知识   URL是统一资源定位器的简写，URL可以访问Internet和www，可以通过url
  • 博弈Java讲义 - Java线程同步 (1) boyitech java多线程同步锁
      在并发编程中经常会碰到多个执行线程共享资源的问题。例如多个线程同时读写文件，共用数据库连接，全局的计数器等。如果不处理好多线程之间的同步问题很容易引起状态不一致或者其他的错误。    同步不仅可以阻止一个线程看到对象处于不一致的状态，它还可以保证进入同步方法或者块的每个线程，都看到由同一锁保护的之前所有的修改结果。处理同步的关键就是要正确的识别临界条件（cri
  • java-给定字符串，删除开始和结尾处的空格，并将中间的多个连续的空格合并成一个。 bylijinnan java
    public class DeleteExtraSpace { /** * 题目：给定字符串，删除开始和结尾处的空格，并将中间的多个连续的空格合并成一个。 * 方法1.用已有的String类的trim和replaceAll方法 * 方法2.全部用正则表达式，这个我不熟 * 方法3.“重新发明轮子”，从头遍历一次 */ public static v
  • An error has occurred.See the log file错误解决！ Kai_Ge MyEclipse
    今天早上打开MyEclipse时，自动关闭！弹出An error has occurred.See the log file错误提示！ 很郁闷昨天启动和关闭还好着！！！打开几次依然报此错误，确定不是眼花了！ 打开日志文件！找到当日错误文件内容： --------------------------------------------------------------------------
  • [矿业与工业]修建一个空间矿床开采站要多少钱? comsci
           地球上的钛金属矿藏已经接近枯竭...........        我们在冥王星的一颗卫星上面发现一些具有开采价值的矿床.....        那么,现在要编制一个预算,提交给财政部门..
  • 解析Google Map Routes dai_lm google api
    为了获得从A点到B点的路劲，经常会使用Google提供的API，例如 [url] http://maps.googleapis.com/maps/api/directions/json?origin=40.7144,-74.0060&destination=47.6063,-122.3204&sensor=false [/url] 从返回的结果上，大致可以了解应该怎么走，但
  • SQL还有多少“理所应当”？ datamachine sql
    转贴存档，原帖地址：http://blog.chinaunix.net/uid-29242841-id-3968998.html、http://blog.chinaunix.net/uid-29242841-id-3971046.html！ ------------------------------------华丽的分割线--------------------------------
  • Yii使用Ajax验证时，如何设置某些字段不需要验证 dcj3sjt126com Ajaxyii
    经常像你注册页面,你可能非常希望只需要Ajax去验证用户名和Email,而不需要使用Ajax再去验证密码,默认如果你使用Yii 内置的ajax验证Form,例如: $form=$this->beginWidget('CActiveForm', array(        'id'=>'usuario-form',&
  • 使用git同步网站代码 dcj3sjt126com crontabgit
    转自:http://ued.ctrip.com/blog/?p=3646?tn=gongxinjun.com   管理一网站，最开始使用的虚拟空间，采用提供商支持的ftp上传网站文件，后换用vps，vps可以自己搭建ftp的，但是懒得搞，直接使用scp传输文件到服务器，现在需要更新文件到服务器，使用scp真的很烦。发现本人就职的公司，采用的git+rsync的方式来管理、同步代码，遂
  • sql基本操作 蕃薯耀 sqlsql基本操作sql常用操作
    sql基本操作 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年6月1日 17:30:33 星期一     &
  • Spring4+Hibernate4+Atomikos3.3多数据源事务管理 hanqunfeng Hibernate4
    Spring3+后不再对JTOM提供支持，所以可以改用Atomikos管理多数据源事务。Spring2.5+Hibernate3+JTOM参考：http://hanqunfeng.iteye.com/blog/1554251Atomikos官网网站：http://www.atomikos.com/   一.pom.xml <dependency> <
  • jquery中两个值得注意的方法one()和trigger()方法 jackyrong trigger
      在jquery中，有两个值得注意但容易忽视的方法，分别是one()方法和trigger()方法,这是从国内作者<<jquery权威指南》一书中看到不错的介绍 1） one方法     one方法的功能是让所选定的元素绑定一个仅触发一次的处理函数，格式为    one(type,${data},fn) &nb
  • 拿工资不仅仅是让你写代码的 lampcy 工作面试咨询
    这是我对团队每个新进员工说的第一件事情。这句话的意思是，我并不关心你是如何快速完成任务的，哪怕代码很差，只要它像救生艇通气门一样管用就行。这句话也是我最喜欢的座右铭之一。 这个说法其实很合理：我们的工作是思考客户提出的问题，然后制定解决方案。思考第一，代码第二，公司请我们的最终目的不是写代码，而是想出解决方案。 话粗理不粗。 付你薪水不是让你来思考的，也不是让你来写代码的，你的目的是交付产品
  • 架构师之对象操作----------对象的效率复制和判断是否全为空 nannan408 架构师
    1.前言。   如题。 2.代码。 (1)对象的复制，比spring的beanCopier在大并发下效率要高，利用net.sf.cglib.beans.BeanCopier Src src=new Src(); BeanCopier beanCopier = BeanCopier.create(Src.class, Des.class, false);
  • ajax 被缓存的解决方案 Rainbow702 JavaScriptjqueryAjaxcache缓存
    使用jquery的ajax来发送请求进行局部刷新画面，各位可能都做过。 今天碰到一个奇怪的现象，就是，同一个ajax请求，在chrome中，不论发送多少次，都可以发送至服务器端，而不会被缓存。但是，换成在IE下的时候，发现，同一个ajax请求，会发生被缓存的情况，只有第一次才会被发送至服务器端，之后的不会再被发送。郁闷。 解决方法如下： ① 直接使用 JQuery提供的 “cache”参数，
  • 修改date.toLocaleString()的警告 tntxia String
      我们在写程序的时候，经常要查看时间，所以我们经常会用到date.toLocaleString()，但是date.toLocaleString()是一个过时 的API，代替的方法如下：   package com.tntxia.htmlmaker.util; import java.text.SimpleDateFormat; import java.util.
  • 项目完成后的小总结 xiaomiya js总结项目
    项目完成了，突然想做个总结但是有点无从下手了。 做之前对于客户端给的接口很模式。然而定义好了格式要求就如此的愉快了。 先说说项目主要实现的功能吧 1，按键精灵 2，获取行情数据 3，各种input输入条件判断 4，发送数据（有json格式和string格式） 5，获取预警条件列表和预警结果列表， 6，排序， 7，预警结果分页获取 8，导出文件（excel，text等） 9，修
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他