`
苗振忠
  • 浏览: 59640 次
  • 性别: Icon_minigender_1
  • 来自: 北京
文章分类
社区版块
存档分类
最新评论

项目经验分享——Java常用工具类集合

 
阅读更多 
写在前面

 

本文涉及的工具类部分是自己编写，另一部分是在项目里收集的。工具类涉及数据库连接、格式转换、文件操作、发送邮件等等。提高开发效率，欢迎收藏与转载。

 
数据库连接工具类

 
数据库连接工具类——仅仅获得连接对象 ConnDB.java
[java] view plain copy

    package com.util;  
      
    import java.sql.Connection;  
    import java.sql.DriverManager;  
      
    /** 
     * 数据库连接工具类——仅仅获得连接对象 
     * 
     */  
    public class ConnDB {  
          
        private static Connection conn = null;  
          
        private static final String DRIVER_NAME = "com.mysql.jdbc.Driver";  
      
        private static final String URL = "jdbc:mysql://localhost:3306/axt?useUnicode=true&characterEncoding=UTF-8";  
      
        private static final String USER_NAME = "root";  
      
        private static final String PASSWORD = "root";  
          
        public static Connection getConn(){  
            try {  
                Class.forName(DRIVER_NAME);  
                conn = DriverManager.getConnection(URL, USER_NAME, PASSWORD);  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
            return conn;  
        }  
    }  

数据库连接工具类——包含取得连接和关闭资源 ConnUtil.java

 
[java] view plain copy

    package com.util;  
      
    import java.sql.Connection;  
    import java.sql.DriverManager;  
    import java.sql.PreparedStatement;  
    import java.sql.ResultSet;  
    import java.sql.SQLException;  
      
      
    /**  
     * @className: ConnUtil.java 
     * @classDescription: 数据库连接工具类——包含取得连接和关闭资源  
     * @function:  
     * @author: Wentasy 
     * @createTime: 2012-9-24 上午11:51:15 
     * @modifyTime:  
     * @modifyReason:  
     * @since: JDK 1.6 
     */  
    public class ConnUtil {  
        public static final String url = "jdbc:mysql://XXX.XXX.XXX.XXX:3306/dbadapter";  
        public static final String user = "root";  
        public static final String password = "XXXXXX";  
          
        /** 
         * 得到连接 
         * @return 
         * @throws SQLException 
         * @throws ClassNotFoundException 
         */  
        public static Connection establishConn() throws SQLException,ClassNotFoundException{  
            Class.forName("com.mysql.jdbc.Driver");  
            return DriverManager.getConnection(url, user, password);  
        }  
          
        /** 
         * 关闭连接 
         * @param conn 
         * @throws SQLException 
         */  
        public static void close(Connection conn) throws SQLException{  
            if(conn != null){  
                conn.close();  
                conn = null;  
            }  
        }  
          
        /** 
         * 关闭PreparedStatement 
         * @param pstmt 
         * @throws SQLException 
         */  
        public static void close(PreparedStatement pstmt) throws SQLException{  
            if(pstmt != null){  
                pstmt.close();  
                pstmt = null;  
            }  
        }  
          
        /** 
         * 关闭结果集 
         * @param rs 
         * @throws SQLException 
         */  
        public static void close(ResultSet rs) throws SQLException{  
            if(rs != null){  
                rs.close();  
                rs = null;  
            }  
        }  
    }  


 
格式转换工具类

 
日期转换工具类 CommUtil.java
[java] view plain copy

    package com.util;  
      
    import java.text.ParseException;  
    import java.text.SimpleDateFormat;  
    import java.util.Date;  
      
    /** 
     * 日期转换工具类 
     */  
    public class CommUtil {  
      
        /** 
         * 将日期格式转换成yyyy-MM-dd的字符串格式 
         * 返回值如：2010-10-06 
         * @param time 要转换的日期 
         * @return 
         */  
        public static  String dateToString(Date time)  {  
              
            SimpleDateFormat formatter = new  SimpleDateFormat ("yyyy-MM-dd"); //定义将日期格式要换成的格式  
            String stringTime  =  formatter.format(time);  
          
            return  stringTime;  
              
          }  
        /** 
         * 将日期格式转换成yyyyMMdd的字符串格式 
         * 返回值如：2010-10-06 
         * @param time 要转换的日期 
         * @return 
         */  
        public static  String dateTimeToString(Date time)  {  
              
            SimpleDateFormat formatter = new  SimpleDateFormat ("yyyyMMdd"); //定义将日期格式要换成的格式  
            String stringTime  =  formatter.format(time);  
          
            return  stringTime;  
              
          }  
          
           
        /** 
         * 将日期格式转换成yyyy-MM-dd的字符串格式 
         * 返回值如：2010-10-06 
         * @param time 要转换的日期 
         * @return 
         */  
        public static  Date dateToDate(Date time)  {  
              
            SimpleDateFormat formatter = new  SimpleDateFormat ("yyyy-MM-dd"); //定义将日期格式要换成的格式  
            String stringTime  =  formatter.format(time);  
         Date date = null;  
        try {  
            date = formatter.parse(stringTime);  
        } catch (ParseException e) {  
            e.printStackTrace();  
        }  
            return  date;  
              
        }  
          
        /** 
         * 得到当前时间，以字符串表示 
         * @return 
         */  
        public static String getDate(){  
            Date date = new Date();  
            return CommUtil.dateToString(date);  
        }  
    }  

日期转换类  DateConverter.java
[java] view plain copy

    package com.util;  
      
    import java.text.DateFormat;  
    import java.text.SimpleDateFormat;  
    import java.util.Date;  
    import java.util.Map;  
      
    import com.opensymphony.xwork2.conversion.impl.DefaultTypeConverter;  
      
    /** 
     * 日期转换类 
     * 
     */  
    public class DateConverter extends DefaultTypeConverter {  
        private static final DateFormat[] ACCEPT_DATE_FORMATS = {  
                new SimpleDateFormat("dd/MM/yyyy"),  
                new SimpleDateFormat("yyyy-MM-dd"),  
                new SimpleDateFormat("yyyy/MM/dd") }; //支持转换的日期格式   
      
        @Override   
        public Object convertValue(Map context, Object value, Class toType) {   
            if (toType == Date.class) {  //浏览器向服务器提交时，进行String to Date的转换   
                Date date = null;   
                String dateString = null;   
                String[] params = (String[])value;   
                dateString = params[0];//获取日期的字符串   
                for (DateFormat format : ACCEPT_DATE_FORMATS) {   
                    try {   
                        return format.parse(dateString);//遍历日期支持格式，进行转换   
                    } catch(Exception e) {   
                        continue;   
                    }   
                }   
                return null;   
            }   
            else if (toType == String.class) {   //服务器向浏览器输出时，进行Date to String的类型转换   
                Date date = (Date)value;   
                return new SimpleDateFormat("yyyy-MM-dd").format(date);//输出的格式是yyyy-MM-dd   
            }   
              
            return null;   
        }  
    }  

功能更强大的格式化工具类 FormatUtils.java

 
[java] view plain copy

    package com.util;  
      
    import java.text.DecimalFormat;  
    import java.text.ParseException;  
    import java.text.SimpleDateFormat;  
    import java.util.Date;  
      
    /** 
     * 功能更强大的格式化工具类 
     */  
    public class FormatUtils {  
        private static SimpleDateFormat second = new SimpleDateFormat(  
                "yy-MM-dd hh:mm:ss");  
      
        private static SimpleDateFormat day = new SimpleDateFormat("yyyy-MM-dd");  
        private static SimpleDateFormat detailDay = new SimpleDateFormat("yyyy年MM月dd日");  
        private static SimpleDateFormat fileName = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss");  
        private static SimpleDateFormat tempTime = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
        private static SimpleDateFormat excelDate = new SimpleDateFormat("yyyy/MM/dd");  
          
        /** 
         * 格式化excel中的时间 
         * @param date 
         * @return 
         */  
        public static String formatDateForExcelDate(Date date) {  
            return excelDate.format(date);  
        }  
          
        /** 
         * 将日期格式化作为文件名 
         * @param date 
         * @return 
         */  
        public static String formatDateForFileName(Date date) {  
            return fileName.format(date);  
        }  
      
        /** 
         * 格式化日期(精确到秒) 
         *  
         * @param date 
         * @return 
         */  
        public static String formatDateSecond(Date date) {  
            return second.format(date);  
        }  
          
        /** 
         * 格式化日期(精确到秒) 
         *  
         * @param date 
         * @return 
         */  
        public static String tempDateSecond(Date date) {  
            return tempTime.format(date);  
        }  
      
        public static Date tempDateSecond(String str) {  
            try {  
                return tempTime.parse(str);  
            } catch (ParseException e) {  
                e.printStackTrace();  
            }  
            return new Date();  
        }  
        /** 
         * 格式化日期(精确到天) 
         *  
         * @param date 
         * @return 
         */  
        public static String formatDateDay(Date date) {  
            return day.format(date);  
        }  
          
        /** 
         * 格式化日期(精确到天) 
         *  
         * @param date 
         * @return 
         */  
        public static String formatDateDetailDay(Date date) {  
            return detailDay.format(date);  
        }  
      
        /** 
         * 将double类型的数字保留两位小数（四舍五入） 
         *  
         * @param number 
         * @return 
         */  
        public static String formatNumber(double number) {  
            DecimalFormat df = new DecimalFormat();  
            df.applyPattern("#0.00");  
            return df.format(number);  
        }  
      
        /** 
         * 将字符串转换成日期 
         *  
         * @param date 
         * @return 
         * @throws Exception 
         */  
        public static Date formateDate(String date) throws Exception {  
            return day.parse(date);  
        }  
          
        /** 
         * 将字符日期转换成Date 
         * @param date 
         * @return 
         * @throws Exception 
         */  
        public static Date parseStringToDate(String date) throws Exception {  
            return day.parse(date);  
        }  
          
        public static String formatDoubleNumber(double number) {  
            DecimalFormat df = new DecimalFormat("#");  
            return df.format(number);  
        }  
    }  


 

 
文件操作工具类

 
目录操作工具类 CopyDir.java
[java] view plain copy

    package com.util;  
      
    import java.io.*;  
      
    /** 
     * 1,建立目的目录。 2，遍历源目录。 3，遍历过程中，创建文件或者文件夹。 原理：其实就是改变了源文件或者目录的目录头。 
     * @datetime  Dsc  24 
     */  
    public class CopyDir {  
        private File sDir, dDir, newDir;  
      
        public CopyDir(String s, String d) {  
            this(new File(s), new File(d));  
        }  
      
        CopyDir(File sDir, File dDir)// c:\\Test d:\\abc  
        {  
            this.sDir = sDir;  
            this.dDir = dDir;  
        }  
      
        public void copyDir() throws IOException {  
            // 是创建目的目录。也就是创建要拷贝的源文件夹。Test  
            // 获取源文件夹名称。  
            String name = sDir.getName();  
            // 通过该名称在目的目录创建该文件夹，为了存放源文件夹中的文件或者文件夹。  
            // 将目的目录和源文件夹名称，封装成File对象。  
            newDir = dDir;  
            // new File(dDir,name);  
            // 调用该对象的mkdir方法。在目的目录创建该文件夹。d:\\abc\\Test  
            newDir.mkdir();//  
      
            // 遍历源文件夹。  
            listAll(sDir);  
        }  
      
        /* 
         * 将遍历目录封装成方法。 在遍历过程中，遇到文件创建文件。 遇到目录创建目录。 
         */  
        private void listAll(File dir) throws IOException {  
            File[] files = dir.listFiles();  
            for (int x = 0; x < files.length; x++) {  
                if (files[x].isDirectory()) {  
                    createDir(files[x]);// 调用创建目录的方法。  
                    listAll(files[x]);// 在继续进行递归。进入子级目录。  
                } else {  
                    createFile(files[x]);// 调用创建文件的方法。  
                }  
            }  
        }  
      
        /* 
         * copy目录。通过源目录在目的目录创建新目录。 
         */  
        private void createDir(File dir) {  
            File d = replaceFile(dir);  
            d.mkdir();  
        }  
      
        /* 
         * copy文件。 
         */  
        private void createFile(File file) throws IOException {  
            File newFile = replaceFile(file);  
            // copy文件是一个数据数据传输的过程。需要通过流来完成。  
            FileInputStream fis = new FileInputStream(file);  
            FileOutputStream fos = new FileOutputStream(newFile);  
            byte[] buf = new byte[1024 * 2];  
            int num = 0;  
            while ((num = fis.read(buf)) != -1) {  
                fos.write(buf, 0, num);  
            }  
            fos.close();  
            fis.close();  
        }  
      
        /* 
         * 替换路径。 
         */  
        private File replaceFile(File f) {  
            // 原理是：将源目录的父目录(C:\\Tset)，替换成目的父目录。（d:\\abc\\Test）  
            String path = f.getAbsolutePath();// 获取源文件或者文件夹的决定路径。  
            // 将源文件或者文件夹的绝对路径替换成目的路径。  
            String newPath = path.replace(sDir.getAbsolutePath(), newDir  
                    .getAbsolutePath());  
            // 将新的目的路径封装成File对象  
            File newFile = new File(newPath);  
            return newFile;  
        }  
    }  

文件/目录部分处理工具类 DealDir.java
[java] view plain copy

    package com.util;  
      
    import java.io.File;  
    import java.util.StringTokenizer;  
      
    /** 
     * 文件/目录 部分处理 
     * @createTime Dec 25, 2010 7:06:58 AM 
     * @version 1.0 
     */  
    public class DealDir {  
        /** 
         * 获取文件的后缀名并转化成大写 
         *  
         * @param fileName 
         *            文件名 
         * @return 
         */  
        public String getFileSuffix(String fileName) throws Exception {  
            return fileName.substring(fileName.lastIndexOf(".") + 1,  
                    fileName.length()).toUpperCase();  
        }  
      
        /** 
         * 创建多级目录 
         *  
         * @param path 
         *            目录的绝对路径 
         */  
        public void createMultilevelDir(String path) {  
            try {  
                StringTokenizer st = new StringTokenizer(path, "/");  
                String path1 = st.nextToken() + "/";  
                String path2 = path1;  
                while (st.hasMoreTokens()) {  
      
                    path1 = st.nextToken() + "/";  
                    path2 += path1;  
                    File inbox = new File(path2);  
                    if (!inbox.exists())  
                        inbox.mkdir();  
      
                }  
            } catch (Exception e) {  
                System.out.println("目录创建失败" + e);  
                e.printStackTrace();  
            }  
      
        }  
      
        /** 
         * 删除文件/目录(递归删除文件/目录) 
         *  
         * @param path 
         *            文件或文件夹的绝对路径 
         */  
        public void deleteAll(String dirpath) {  
            if (dirpath == null) {  
                System.out.println("目录为空");  
            } else {  
                File path = new File(dirpath);  
                try {  
                    if (!path.exists())  
                        return;// 目录不存在退出  
                    if (path.isFile()) // 如果是文件删除  
                    {  
                        path.delete();  
                        return;  
                    }  
                    File[] files = path.listFiles();// 如果目录中有文件递归删除文件  
                    for (int i = 0; i < files.length; i++) {  
                        deleteAll(files[i].getAbsolutePath());  
                    }  
                    path.delete();  
      
                } catch (Exception e) {  
                    System.out.println("文件/目录 删除失败" + e);  
                    e.printStackTrace();  
                }  
            }  
        }  
      
        /** 
         * 文件/目录 重命名 
         *  
         * @param oldPath 
         *            原有路径（绝对路径） 
         * @param newPath 
         *            更新路径 
         * @author lyf 注：不能修改上层次的目录 
         */  
        public void renameDir(String oldPath, String newPath) {  
            File oldFile = new File(oldPath);// 文件或目录  
            File newFile = new File(newPath);// 文件或目录  
            try {  
                boolean success = oldFile.renameTo(newFile);// 重命名  
                if (!success) {  
                    System.out.println("重命名失败");  
                } else {  
                    System.out.println("重命名成功");  
                }  
            } catch (RuntimeException e) {  
                e.printStackTrace();  
            }  
      
        }  
      
    }  


目录处理工具类 DealWithDir.java
[java] view plain copy

    package com.util;  
      
    import java.io.File;  
      
    /** 
     * 目录处理工具类 
     * 
     */  
    public class DealWithDir {  
        /** 
         * 新建目录 
         */  
        public static boolean newDir(String path) throws Exception {  
            File file = new File(path);  
            return file.mkdirs();//创建目录  
        }  
          
        /** 
         * 删除目录 
         */  
        public static boolean deleteDir(String path) throws Exception {  
            File file = new File(path);  
            if (!file.exists())  
                return false;// 目录不存在退出  
            if (file.isFile()) // 如果是文件删除  
            {  
                file.delete();  
                return false;  
            }  
            File[] files = file.listFiles();// 如果目录中有文件递归删除文件  
            for (int i = 0; i < files.length; i++) {  
                deleteDir(files[i].getAbsolutePath());  
            }  
            file.delete();  
              
            return file.delete();//删除目录  
        }  
      
        /** 
         * 更新目录 
         */  
        public static boolean updateDir(String path, String newPath) throws Exception {  
            File file = new File(path);  
            File newFile = new File(newPath);  
            return file.renameTo(newFile);  
        }  
          
        public static void main(String d[]) throws Exception{  
            //deleteDir("d:/ff/dddf");  
            updateDir("D:\\TOOLS\\Tomcat 6.0\\webapps\\BCCCSM\\nationalExperiment/22222", "D:\\TOOLS\\Tomcat 6.0\\webapps\\BCCCSM\\nationalExperiment/224222");  
        }  
          
          
    }  


删除文件夹工具类 DeleteFolder.java

 
[java] view plain copy

    package com.util;  
      
    import java.io.File;  
      
    /** 
     * 删除文件夹 
     * @createTime DSC 20, 2010 15:38 
     * @version 2.0 
     */  
    public class DeleteFolder {  
        // 删除文件夹  
        // param folderPath 文件夹完整绝对路径  
        public static void delFolder(String folderPath) {  
            try {  
                delAllFile(folderPath); // 删除完里面所有内容  
                String filePath = folderPath;  
                filePath = filePath.toString();  
                java.io.File myFilePath = new java.io.File(filePath);  
                myFilePath.delete(); // 删除空文件夹  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
        }  
      
        // 删除指定文件夹下所有文件  
        // param path 文件夹完整绝对路径  
        public static boolean delAllFile(String path) {  
            boolean flag = false;  
            File file = new File(path);  
            if (!file.exists()) {  
                return flag;  
            }  
            if (!file.isDirectory()) {  
                return flag;  
            }  
            String[] tempList = file.list();  
            File temp = null;  
            for (int i = 0; i < tempList.length; i++) {  
                if (path.endsWith(File.separator)) {  
                    temp = new File(path + tempList[i]);  
                } else {  
                    temp = new File(path + File.separator + tempList[i]);  
                }  
                if (temp.isFile()) {  
                    temp.delete();  
                }  
                if (temp.isDirectory()) {  
                    delAllFile(path + "/" + tempList[i]);// 先删除文件夹里面的文件  
                    delFolder(path + "/" + tempList[i]);// 再删除空文件夹  
                    flag = true;  
                }  
            }  
            return flag;  
        }  
      
    }  


 
文件上传工具类 UploadUtil.java
[java] view plain copy

    package com.util;  
      
    import java.io.BufferedInputStream;  
    import java.io.BufferedOutputStream;  
    import java.io.File;  
    import java.io.FileInputStream;  
    import java.io.FileOutputStream;  
    import java.io.InputStream;  
    import java.io.OutputStream;  
    import java.util.Calendar;  
      
    /** 
     * 文件上传工具类 
     * 
     */  
    public class UploadUtil {  
        private static final int BUFFER_SIZE = 16 * 1024;  
        //保存图片  
        public static synchronized void copy(File src, File newFile) {  
              
            try {  
                InputStream is = null;  
                OutputStream os = null;  
                try {  
                    is = new BufferedInputStream(new FileInputStream(src),  
                            BUFFER_SIZE);  
                    os = new BufferedOutputStream(new FileOutputStream(newFile),  
                            BUFFER_SIZE);  
                    byte[] buffer = new byte[BUFFER_SIZE];  
                    while (is.read(buffer) > 0) {  
                        os.write(buffer);  
                    }  
                } finally {  
                    if (null != is) {  
                        is.close();  
                    }  
                    if (null != os) {  
                        os.close();  
                    }  
                }  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
        }  
      
        /** 
         * 返回 年号+月号+天+时+分+秒+随机码 
         * @return 
         */  
        @SuppressWarnings("static-access")  
        public static synchronized String getTime() {  
            Calendar calendar = Calendar.getInstance();  
            String year = calendar.get(calendar.YEAR) + "";  
            String month = (calendar.get(calendar.MONTH) + 1) + "";  
            String day = calendar.get(calendar.DAY_OF_MONTH) + "";  
            String hour = calendar.get(calendar.HOUR_OF_DAY) + "";  
            String minute = calendar.get(calendar.MINUTE) + "";  
            String second = calendar.get(calendar.SECOND) + "";  
            String milliSecond = calendar.get(calendar.MILLISECOND) + "";  
            int r = (int)(Math.random()*100000);  
            String random = String.valueOf(r);  
            return year + month + day + hour + minute + second + milliSecond + random+"a";  
        }  
      
    }  


 
其他工具类
MD5编码工具类 MD5Code.java
[java] view plain copy

    package com.util;  
    /** 
     * MD5编码工具类 
     * 
     */  
    public class MD5Code {  
        static final int S11 = 7;  
      
        static final int S12 = 12;  
      
        static final int S13 = 17;  
      
        static final int S14 = 22;  
      
        static final int S21 = 5;  
      
        static final int S22 = 9;  
      
        static final int S23 = 14;  
      
        static final int S24 = 20;  
      
        static final int S31 = 4;  
      
        static final int S32 = 11;  
      
        static final int S33 = 16;  
      
        static final int S34 = 23;  
      
        static final int S41 = 6;  
      
        static final int S42 = 10;  
      
        static final int S43 = 15;  
      
        static final int S44 = 21;  
      
        static final byte[] PADDING = { -128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  
                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  
                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  
                0, 0, 0, 0, 0, 0, 0 };  
      
        private long[] state = new long[4];// state (ABCD)  
      
        private long[] count = new long[2];// number of bits, modulo 2^64 (lsb  
      
        // first)  
      
        private byte[] buffer = new byte[64]; // input buffer  
      
      
        public String digestHexStr;  
          
        private byte[] digest = new byte[16];  
      
        public String getMD5ofStr(String inbuf) {  
            md5Init();  
            md5Update(inbuf.getBytes(), inbuf.length());  
            md5Final();  
            digestHexStr = "";  
            for (int i = 0; i < 16; i++) {  
                digestHexStr += byteHEX(digest[i]);  
            }  
            return digestHexStr;  
        }  
      
        public MD5Code() {  
            md5Init();  
            return;  
        }  
      
        private void md5Init() {  
            count[0] = 0L;  
            count[1] = 0L;  
            // /* Load magic initialization constants.  
            state[0] = 0x67452301L;  
            state[1] = 0xefcdab89L;  
            state[2] = 0x98badcfeL;  
            state[3] = 0x10325476L;  
            return;  
        }  
      
        private long F(long x, long y, long z) {  
            return (x & y) | ((~x) & z);  
        }  
      
        private long G(long x, long y, long z) {  
            return (x & z) | (y & (~z));  
        }  
      
        private long H(long x, long y, long z) {  
            return x ^ y ^ z;  
        }  
      
        private long I(long x, long y, long z) {  
            return y ^ (x | (~z));  
        }  
      
        private long FF(long a, long b, long c, long d, long x, long s, long ac) {  
            a += F(b, c, d) + x + ac;  
            a = ((int) a << s) | ((int) a >>> (32 - s));  
            a += b;  
            return a;  
        }  
      
        private long GG(long a, long b, long c, long d, long x, long s, long ac) {  
            a += G(b, c, d) + x + ac;  
            a = ((int) a << s) | ((int) a >>> (32 - s));  
            a += b;  
            return a;  
        }  
      
        private long HH(long a, long b, long c, long d, long x, long s, long ac) {  
            a += H(b, c, d) + x + ac;  
            a = ((int) a << s) | ((int) a >>> (32 - s));  
            a += b;  
            return a;  
        }  
      
        private long II(long a, long b, long c, long d, long x, long s, long ac) {  
            a += I(b, c, d) + x + ac;  
            a = ((int) a << s) | ((int) a >>> (32 - s));  
            a += b;  
            return a;  
        }  
      
        private void md5Update(byte[] inbuf, int inputLen) {  
            int i, index, partLen;  
            byte[] block = new byte[64];  
            index = (int) (count[0] >>> 3) & 0x3F;  
            // /* Update number of bits */  
            if ((count[0] += (inputLen << 3)) < (inputLen << 3))  
                count[1]++;  
            count[1] += (inputLen >>> 29);  
            partLen = 64 - index;  
            // Transform as many times as possible.  
            if (inputLen >= partLen) {  
                md5Memcpy(buffer, inbuf, index, 0, partLen);  
                md5Transform(buffer);  
                for (i = partLen; i + 63 < inputLen; i += 64) {  
                    md5Memcpy(block, inbuf, 0, i, 64);  
                    md5Transform(block);  
                }  
                index = 0;  
            } else  
                i = 0;  
            // /* Buffer remaining input */  
            md5Memcpy(buffer, inbuf, index, i, inputLen - i);  
        }  
      
        private void md5Final() {  
            byte[] bits = new byte[8];  
            int index, padLen;  
            // /* Save number of bits */  
            Encode(bits, count, 8);  
            // /* Pad out to 56 mod 64.  
            index = (int) (count[0] >>> 3) & 0x3f;  
            padLen = (index < 56) ? (56 - index) : (120 - index);  
            md5Update(PADDING, padLen);  
            // /* Append length (before padding) */  
            md5Update(bits, 8);  
            // /* Store state in digest */  
            Encode(digest, state, 16);  
        }  
      
        private void md5Memcpy(byte[] output, byte[] input, int outpos, int inpos,  
                int len) {  
            int i;  
            for (i = 0; i < len; i++)  
                output[outpos + i] = input[inpos + i];  
        }  
      
        private void md5Transform(byte block[]) {  
            long a = state[0], b = state[1], c = state[2], d = state[3];  
            long[] x = new long[16];  
            Decode(x, block, 64);  
            /* Round 1 */  
            a = FF(a, b, c, d, x[0], S11, 0xd76aa478L); /* 1 */  
            d = FF(d, a, b, c, x[1], S12, 0xe8c7b756L); /* 2 */  
            c = FF(c, d, a, b, x[2], S13, 0x242070dbL); /* 3 */  
            b = FF(b, c, d, a, x[3], S14, 0xc1bdceeeL); /* 4 */  
            a = FF(a, b, c, d, x[4], S11, 0xf57c0fafL); /* 5 */  
            d = FF(d, a, b, c, x[5], S12, 0x4787c62aL); /* 6 */  
            c = FF(c, d, a, b, x[6], S13, 0xa8304613L); /* 7 */  
            b = FF(b, c, d, a, x[7], S14, 0xfd469501L); /* 8 */  
            a = FF(a, b, c, d, x[8], S11, 0x698098d8L); /* 9 */  
            d = FF(d, a, b, c, x[9], S12, 0x8b44f7afL); /* 10 */  
            c = FF(c, d, a, b, x[10], S13, 0xffff5bb1L); /* 11 */  
            b = FF(b, c, d, a, x[11], S14, 0x895cd7beL); /* 12 */  
            a = FF(a, b, c, d, x[12], S11, 0x6b901122L); /* 13 */  
            d = FF(d, a, b, c, x[13], S12, 0xfd987193L); /* 14 */  
            c = FF(c, d, a, b, x[14], S13, 0xa679438eL); /* 15 */  
            b = FF(b, c, d, a, x[15], S14, 0x49b40821L); /* 16 */  
            /* Round 2 */  
            a = GG(a, b, c, d, x[1], S21, 0xf61e2562L); /* 17 */  
            d = GG(d, a, b, c, x[6], S22, 0xc040b340L); /* 18 */  
            c = GG(c, d, a, b, x[11], S23, 0x265e5a51L); /* 19 */  
            b = GG(b, c, d, a, x[0], S24, 0xe9b6c7aaL); /* 20 */  
            a = GG(a, b, c, d, x[5], S21, 0xd62f105dL); /* 21 */  
            d = GG(d, a, b, c, x[10], S22, 0x2441453L); /* 22 */  
            c = GG(c, d, a, b, x[15], S23, 0xd8a1e681L); /* 23 */  
            b = GG(b, c, d, a, x[4], S24, 0xe7d3fbc8L); /* 24 */  
            a = GG(a, b, c, d, x[9], S21, 0x21e1cde6L); /* 25 */  
            d = GG(d, a, b, c, x[14], S22, 0xc33707d6L); /* 26 */  
            c = GG(c, d, a, b, x[3], S23, 0xf4d50d87L); /* 27 */  
            b = GG(b, c, d, a, x[8], S24, 0x455a14edL); /* 28 */  
            a = GG(a, b, c, d, x[13], S21, 0xa9e3e905L); /* 29 */  
            d = GG(d, a, b, c, x[2], S22, 0xfcefa3f8L); /* 30 */  
            c = GG(c, d, a, b, x[7], S23, 0x676f02d9L); /* 31 */  
            b = GG(b, c, d, a, x[12], S24, 0x8d2a4c8aL); /* 32 */  
            /* Round 3 */  
            a = HH(a, b, c, d, x[5], S31, 0xfffa3942L); /* 33 */  
            d = HH(d, a, b, c, x[8], S32, 0x8771f681L); /* 34 */  
            c = HH(c, d, a, b, x[11], S33, 0x6d9d6122L); /* 35 */  
            b = HH(b, c, d, a, x[14], S34, 0xfde5380cL); /* 36 */  
            a = HH(a, b, c, d, x[1], S31, 0xa4beea44L); /* 37 */  
            d = HH(d, a, b, c, x[4], S32, 0x4bdecfa9L); /* 38 */  
            c = HH(c, d, a, b, x[7], S33, 0xf6bb4b60L); /* 39 */  
            b = HH(b, c, d, a, x[10], S34, 0xbebfbc70L); /* 40 */  
            a = HH(a, b, c, d, x[13], S31, 0x289b7ec6L); /* 41 */  
            d = HH(d, a, b, c, x[0], S32, 0xeaa127faL); /* 42 */  
            c = HH(c, d, a, b, x[3], S33, 0xd4ef3085L); /* 43 */  
            b = HH(b, c, d, a, x[6], S34, 0x4881d05L); /* 44 */  
            a = HH(a, b, c, d, x[9], S31, 0xd9d4d039L); /* 45 */  
            d = HH(d, a, b, c, x[12], S32, 0xe6db99e5L); /* 46 */  
            c = HH(c, d, a, b, x[15], S33, 0x1fa27cf8L); /* 47 */  
            b = HH(b, c, d, a, x[2], S34, 0xc4ac5665L); /* 48 */  
            /* Round 4 */  
            a = II(a, b, c, d, x[0], S41, 0xf4292244L); /* 49 */  
            d = II(d, a, b, c, x[7], S42, 0x432aff97L); /* 50 */  
            c = II(c, d, a, b, x[14], S43, 0xab9423a7L); /* 51 */  
            b = II(b, c, d, a, x[5], S44, 0xfc93a039L); /* 52 */  
            a = II(a, b, c, d, x[12], S41, 0x655b59c3L); /* 53 */  
            d = II(d, a, b, c, x[3], S42, 0x8f0ccc92L); /* 54 */  
            c = II(c, d, a, b, x[10], S43, 0xffeff47dL); /* 55 */  
            b = II(b, c, d, a, x[1], S44, 0x85845dd1L); /* 56 */  
            a = II(a, b, c, d, x[8], S41, 0x6fa87e4fL); /* 57 */  
            d = II(d, a, b, c, x[15], S42, 0xfe2ce6e0L); /* 58 */  
            c = II(c, d, a, b, x[6], S43, 0xa3014314L); /* 59 */  
            b = II(b, c, d, a, x[13], S44, 0x4e0811a1L); /* 60 */  
            a = II(a, b, c, d, x[4], S41, 0xf7537e82L); /* 61 */  
            d = II(d, a, b, c, x[11], S42, 0xbd3af235L); /* 62 */  
            c = II(c, d, a, b, x[2], S43, 0x2ad7d2bbL); /* 63 */  
            b = II(b, c, d, a, x[9], S44, 0xeb86d391L); /* 64 */  
            state[0] += a;  
            state[1] += b;  
            state[2] += c;  
            state[3] += d;  
        }  
      
        private void Encode(byte[] output, long[] input, int len) {  
            int i, j;  
            for (i = 0, j = 0; j < len; i++, j += 4) {  
                output[j] = (byte) (input[i] & 0xffL);  
                output[j + 1] = (byte) ((input[i] >>> 8) & 0xffL);  
                output[j + 2] = (byte) ((input[i] >>> 16) & 0xffL);  
                output[j + 3] = (byte) ((input[i] >>> 24) & 0xffL);  
            }  
        }  
      
        private void Decode(long[] output, byte[] input, int len) {  
            int i, j;  
            for (i = 0, j = 0; j < len; i++, j += 4)  
                output[i] = b2iu(input[j]) | (b2iu(input[j + 1]) << 8)  
                        | (b2iu(input[j + 2]) << 16) | (b2iu(input[j + 3]) << 24);  
            return;  
        }  
      
        public static long b2iu(byte b) {  
            return b < 0 ? b & 0x7F + 128 : b;  
        }  
          
        public static String byteHEX(byte ib) {  
            char[] Digit = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A',  
                    'B', 'C', 'D', 'E', 'F' };  
            char[] ob = new char[2];  
            ob[0] = Digit[(ib >>> 4) & 0X0F];  
            ob[1] = Digit[ib & 0X0F];  
            String s = new String(ob);  
            return s;  
        }  
    }  


 
读取Config文件工具类 PropertiesConfig.java
[java] view plain copy

    package com.util;  
      
    import java.io.BufferedInputStream;  
    import java.io.FileInputStream;  
    import java.io.InputStream;  
    import java.util.Properties;  
    /** 
     * 读取Config文件工具类 
     * @version 1.0 
     * @since JDK 1.6 
     */  
    public class PropertiesConfig {    
            
        /**  
         * 获取整个配置文件中的属性 
         * @param filePath 文件路径，即文件所在包的路径，例如：java/util/config.properties  
         */    
        public static Properties readData(String filePath) {    
            filePath = getRealPath(filePath);  
            Properties props = new Properties();    
            try {    
                InputStream in = new BufferedInputStream(new FileInputStream(filePath));    
                props.load(in);    
                in.close();    
                return props;    
            } catch (Exception e) {    
                e.printStackTrace();    
                return null;    
            }    
        }    
          
        private static String getRealPath(String filePath) {  
            //获取绝对路径 并截掉路径的”file:/“前缀    
            return PropertiesConfig.class.getResource("/" + filePath).toString().substring(6);  
        }  
    }    


自动扫描FTP文件工具类 ScanFtp.java
[java] view plain copy

    package com.util;  
      
    import java.io.BufferedInputStream;  
    import java.io.BufferedOutputStream;  
    import java.io.File;  
    import java.io.FileInputStream;  
    import java.io.FileOutputStream;  
    import java.io.IOException;  
      
    /** 
     * 自动扫描FTP文件工具类 
     * 需要定时执行 
     */  
    public class ScanFtp {  
        //服务器图片路径文件夹  
        private String serverLocal = "D:/TOOLS/Tomcat 6.0/webapps/BCCCSM/modelforcast/";  
        //图片上传文件夹存放路径,文件夹内应包含AGCM CSM ZS 3个子文件夹分别存放需要扫描到tomcat中的图片  
        private String saveLocal = "D:/modelForcast/";  
        /** 
         * 获得远程权限 
         * @return 
         */  
        private void getFTPAdress(){  
            //登陆成功  
        }  
          
        /** 
         * 开始扫描 
         * @throws IOException  
         */  
        private void scan() throws IOException {  
            this.getFTPAdress();  
            File file = new File(saveLocal + "AGCM");  //打开AGCM  
            File[] array = file.listFiles();  
            String fileName;  
            File fileTemp;  
            for(int i = 0; i < array.length; i++){  
                if(array[i].isFile()) {  
                    fileTemp = array[i];  
                    fileName = fileTemp.getName();//取出文件名  
                    if (!fileName.equals("humbs.db")) {  
                        this.saveFile(fileTemp, 1);//分析每一个文件名字并存储  
                        System.out.println(fileName + " saved");  
                    }  
                }     
            }  
              
            file = new File(saveLocal + "CSM");  //打开CSM  
            array = file.listFiles();  
            for(int i = 0; i < array.length; i++){  
                if(array[i].isFile()) {  
                    fileTemp = array[i];  
                    fileName = fileTemp.getName();//取出文件名  
                    if (!fileName.equals("humbs.db")) {  
                        this.saveFile(fileTemp, 2);//分析每一个文件名字并存储  
                        System.out.println(fileName + " saved");  
                    }  
                }     
            }  
              
            file = new File(saveLocal + "ZS");  //打开ZS  
            array = file.listFiles();  
            for(int i = 0; i < array.length; i++){  
                if(array[i].isFile()) {  
                    fileTemp = array[i];  
                    fileName = fileTemp.getName();//取出文件名  
                    if (!fileName.equals("humbs.db")) {  
                        this.saveFile(fileTemp, 3);//分析每一个文件名字并存储  
                        System.out.println(fileName + " saved");  
                    }  
                }     
            }  
              
      
        }  
          
        /** 
         * 开始执行 
         * @throws IOException  
         */  
        public void execute() throws IOException{  
            scan();//开始扫描  
        }  
          
        /** 
         * 按类型存储 
         * @param file 
         * @param type 
         * @throws IOException  
         */  
        private void saveFile(File file, int type) throws IOException {  
            String fileName = file.getName();  
            //类型A C 和 指数3种  
            String year = fileName.substring(1, 5);//获得发布年份  
            String date = fileName.substring(5, 9);//获得发布日期包含月日  
            String var = null;//获得变量名字  
            String dir = serverLocal;//存储目录名字  
            if (type == 1 ) {  
                var = fileName.substring(11, 15);  
                dir = dir + "AGCM/" + var + "/" + year + "/" + date;  
            } else if(type == 2) {  
                var = fileName.substring(11, 15);  
                dir = dir + "CSM/" + var + "/" + year + "/" + date;  
            } else {  
                var = fileName.substring(11, 15);//指数的暂时没处理  
                dir = dir + "ZS/" + var + "/" + year + "/" + date;  
            }  
            //判断是否存在这样的目录没有就自动创建  
            File savePath = new File(dir);  
            if(!savePath.exists()) {  
                savePath.mkdirs();  
            }  
            File saveFile = new File(dir + "/" + fileName);  
            if(!saveFile.exists()){//如果不存在,就存文件  
                FileInputStream fis = null;//这里用本地复制暂时代替FTP  
                FileOutputStream fos =null;  
                BufferedInputStream bis =null;  
                BufferedOutputStream bos =null;    
                int c;  
                fis = new FileInputStream(file);  
                bis = new BufferedInputStream(fis);  
                fos = new FileOutputStream(dir + "/" + fileName);  
                bos = new BufferedOutputStream(fos);  
                while((c = bis.read())!= -1)  
                    bos.write(c);  
                bos.flush();  
                if(bos != null) bos.close();  
                if(bis != null) bis.close();  
                if(fos != null) fos.close();  
                if(fis != null) fos.close();  
            } else {  
                System.out.println("文件已经存在,不进行存储,可清理当前文件.");  
            }  
        }  
          
          
        /** 
         * 测试方法 
         * @param argv 
         * @throws IOException  
         */  
        public static void main(String argv[])  {  
            ScanFtp s = new ScanFtp();  
            try {  
                s.scan();  
            } catch (IOException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }  
        }  
    }  


邮件发送工具类 SendMail.java
[java] view plain copy

    package com.util;  
      
    import org.apache.commons.mail.EmailException;  
    import org.apache.commons.mail.SimpleEmail;  
      
    /** 
     * 邮件发送工具类 
     */  
    public class SendMail {  
        private String hostName;//设置smtp服务器  
        private String sendMailAddress;//设置发送地址  
        private String mailPassword;//设置密码  
        private boolean TLS = false;//设置是否需要TLS登录  
        private String[] getMailAddress;//设置接收地址s  
        private String mailTitle;//设置标题  
        private String mailContent;//设置邮件内容  
      
        public  void  send(){  
            SimpleEmail email = new SimpleEmail();  
            email.setTLS(TLS); //是否TLS校验，，某些邮箱需要TLS安全校验，同理有SSL校验    
            email.setHostName(hostName);  
            try {  
                email.setFrom(sendMailAddress, sendMailAddress);  
                email.setAuthentication(sendMailAddress, mailPassword);  
                email.setCharset("utf-8");//解决中文乱码问题  
                email.setSubject(mailTitle); //标题         
                email.setMsg(mailContent);//内容    
                for(int i = 0; i < getMailAddress.length; ++i){  
                    email.addTo(getMailAddress[i]); //接收方  
                    email.send();  
                }  
                      
                  
            } catch (EmailException e) {  
            //  e.printStackTrace();  
            }  
        }  
      
        public String getHostName() {  
            return hostName;  
        }  
      
        public void setHostName(String hostName) {  
            this.hostName = hostName;  
        }  
      
        public String getSendMailAddress() {  
            return sendMailAddress;  
        }  
      
        public void setSendMailAddress(String sendMailAddress) {  
            this.sendMailAddress = sendMailAddress;  
        }  
      
        public String getMailPassword() {  
            return mailPassword;  
        }  
      
        public void setMailPassword(String mailPassword) {  
            this.mailPassword = mailPassword;  
        }  
      
        public boolean isTLS() {  
            return TLS;  
        }  
      
        public void setTLS(boolean tls) {  
            TLS = tls;  
        }  
      
        public String[] getGetMailAddress() {  
            return getMailAddress;  
        }  
      
        public void setGetMailAddress(String[] getMailAddress) {  
            this.getMailAddress = getMailAddress;  
        }  
      
        public String getMailTitle() {  
            return mailTitle;  
        }  
      
        public void setMailTitle(String mailTitle) {  
            this.mailTitle = mailTitle;  
        }  
      
        public String getMailContent() {  
            return mailContent;  
        }  
      
        public void setMailContent(String mailContent) {  
            this.mailContent = mailContent;  
        }  
    }  


分页工具类 SharePager.java
[java] view plain copy

    package com.util;  
      
      
    /** 
     * 分页工具类 
     * 
     */  
    public class SharePager {  
        private int totalRows; //总行数  
        private int pageSize = 20; //每页显示的行数    
        private int currentPage; //当前页号  
        private int totalPages; //总页数   
        private int startRow; //当前页在数据库中的起始行    
         
      
        /** 
         * 默认构造函数 
         */  
        public SharePager()   
        {    
              
        }    
            
        /**默认每页10行 
         * @param totalRows  
         */    
        public SharePager(int totalRows)   
        {    
            this.totalRows = totalRows;    
      
            totalPages =(int) Math.ceil((double)totalRows / (double)pageSize);    
            startRow = 0;    
        }    
            
            
        /**可自定义每页显示多少页 
         * @param totalRows  
         * @param pageSize  
         */    
        public SharePager(int totalRows, int pageSize)   
        {    
            this.totalRows = totalRows;    
            this.pageSize = pageSize;   
            if(this.pageSize<1)                 
                this.pageSize=1;  
            else if(pageSize>20)  
                this.pageSize=20;  
      
    //        if(this.pageSize>totalRows){  
    //          this.pageSize=(int)totalRows;  
    //        }  
              
          
      
            totalPages =(int) Math.ceil((double)totalRows / (double)this.pageSize);     
            currentPage = 1;    
            startRow = 0;    
        }    
            
        /** 
         * 跳转到首页 
         */  
        public void first()   
        {    
            this.currentPage = 1;    
            this.startRow = 0;   
        }    
          
        /** 
         * 跳转到上一页 
         */  
        public void previous()   
        {    
            if (currentPage == 1)   
            {    
                return;    
            }    
            currentPage--;    
            startRow = (currentPage-1) * pageSize;    
       }    
          
        /** 
         * 跳转到下一页 
         */  
        public void next()   
        {    
            if (currentPage < totalPages)  
            {    
                currentPage++;    
            }    
            startRow = (currentPage-1) * pageSize;    
        }    
          
        /** 
         *  跳转到尾页 
         */  
        public void last()   
        {    
            this.currentPage = totalPages;    
            if(currentPage<1){  
                currentPage = 1;  
            }  
            this.startRow = (currentPage-1) * this.pageSize;  
            totalPages =(int) Math.ceil((double)totalRows / (double)this.pageSize);     
              
        }    
          
        /** 
         * 跳转到指定页 
         * @param currentPage   指定的页 
         */  
        public void refresh(int currentPage)   
        {    
              
            if(currentPage < 0)  
            {  
                first();  
            }  
            if (currentPage > totalPages)   
            {    
                last();    
            }else{  
                this.currentPage = currentPage;  
                this.startRow = (currentPage-1) * this.pageSize;  
              }  
       
        }    
           
            
        public int getStartRow()  
        {    
            return startRow;    
        }    
          
        public int getTotalPages()  
        {    
            return totalPages;    
        }    
          
        public int getCurrentPage()  
        {    
            return currentPage;    
        }    
          
        public int getPageSize()   
        {    
            return pageSize;    
        }    
          
        public void setTotalRows(int totalRows)   
        {    
            this.totalRows = totalRows;    
        }    
          
        public void setStartRow(int startRow)  
        {    
            this.startRow = startRow;    
        }    
          
        public void setTotalPages(int totalPages)   
        {    
            this.totalPages = totalPages;    
        }    
          
        public void setCurrentPage(int currentPage)   
        {    
            this.currentPage = currentPage;    
        }   
          
        public void setPageSize(int pageSize)   
        {    
            this.pageSize = pageSize;    
        }    
          
        public int getTotalRows()   
        {    
            return totalRows;    
        }    
    }


分享到：
| android项目源码大全
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    COMSOL焊接热源模型详解：双椭球、高斯旋转体与柱状体热源的应用与优化

    内容概要：本文详细介绍了COMSOL软件中三种常用的焊接热源模型：双椭球热源、高斯旋转体热源和柱状体热源。双椭球热源适用于电弧焊，通过将热源分为前后两个半椭球，能够更好地模拟熔池的温度梯度变化；高斯旋转体热源适合激光焊，采用旋转对称的高斯函数描述热流密度分布；柱状体热源则用于电阻焊等均匀加热场景，尽管物理上不够精确，但计算速度快。文中还提供了具体的MATLAB代码实现，并分享了参数调试的经验和注意事项。 适合人群：从事焊接仿真研究的技术人员、研究生以及相关领域的研究人员。 使用场景及目标：帮助用户选择合适的热源模型进行焊接仿真，确保仿真结果的准确性。同时，提供实用的参数调试技巧，避免常见错误，提高仿真的效率和可靠性。 其他说明：强调了不同热源模型的特点及其适用场景，提醒用户根据实际情况灵活调整参数，并结合实验数据进行验证。

    带你去认识RFID技术

    带你去认识RFID技术

    开关磁阻电机(SRM)的Matlab与Maxwell仿真建模及控制策略研究

    内容概要：本文深入探讨了开关磁阻电机（SRM）的仿真方法和技术细节，涵盖了从Matlab仿真模型搭建到Maxwell有限元仿真的全过程。首先介绍了SRM的基本参数设置及其在Simulink中的电磁关系建模，接着详细讲解了两种常见的控制策略：电流斩波控制（CCC）和角度位置控制（APC）。随后讨论了Maxwell中SRM几何结构的精确建模、材料属性设置及网格划分技巧，并阐述了转矩分配函数（TSF）和直接转矩控制（DTC）的具体实现。最后分享了一些实用的仿真优化建议，如响应面法和遗传算法的应用。 适合人群：从事电机控制系统设计的研发工程师、高校师生及相关领域的研究人员。 使用场景及目标：适用于希望深入了解SRM工作原理并掌握其仿真技能的专业人士；旨在帮助读者构建高效的SRM仿真平台，提高电机性能，降低开发成本。 其他说明：文中提供了大量MATLAB代码片段和Maxwell建模指导，便于读者理解和实践。此外，还提到了许多实际操作中的注意事项和常见错误，有助于避免不必要的弯路。

    Windows 10 Enterprise G 麦克风摄像头开关工具

    一键打开或关闭Windows 10 Enterprise G 麦克风或摄像头

    LightCNN-29Layer预训练模型

    https://github.com/AlfredXiangWu/LightCNN 预训练模型

    电-气-热综合能源系统节点能价计算方法及其碳排放成本优化

    内容概要：本文深入探讨了电-气-热综合能源系统的节点能价计算方法，重点介绍了如何将碳排放成本纳入系统优化中。作者通过复现论文中的模型，展示了电、气、热潮流的耦合实现，并提出了以综合能源系统总运行成本和碳排放成本最小为目标函数的优化调度模型。文中详细解释了模型的关键组成部分，如目标函数的设计、多能流优化以及节点能价的计算方法。通过多个实例验证，证明了该模型的有效性和通用性。 适合人群：对综合能源系统建模感兴趣的科研人员和技术开发者，尤其是希望深入了解电-气-热耦合系统及碳排放成本优化的人群。 使用场景及目标：适用于需要进行综合能源系统优化的研究和工程项目，旨在降低碳排放并优化能源系统的总成本。具体应用场景包括但不限于电力系统、天然气系统和热力系统的联合优化调度。 其他说明：文章不仅提供了详细的代码实现和模型解析，还讨论了模型的实际应用效果和潜在改进方向。通过具体的案例分析，展示了模型在不同规模和类型的能源系统中的表现，为后续研究提供了宝贵的参考。

    前端分析-2023071100789s+12

    前端分析-2023071100789s+12

    基于MATLAB的CNN-LSTM结合SE注意力机制的时序数据分析与分类

    内容概要：本文详细介绍了如何在MATLAB环境中构建一个结合卷积神经网络(CNN)、长短时记忆网络(LSTM)以及SE注意力机制的混合模型用于时序数据分类。首先进行数据预处理，确保输入数据符合模型要求。接着，通过CNN提取空间特征，再由SE模块评估特征的重要性，最后交给LSTM处理时间序列信息。文中提供了完整的代码实现步骤，并针对可能出现的问题给出了优化建议。实验结果显示，在EEG信号分类和其他工业应用场景中，该模型相较于传统方法能够提高分类精度。 适合人群：有一定机器学习基础并对深度学习感兴趣的科研工作者和技术开发者。 使用场景及目标：适用于需要处理带有时间和空间相关性的多维时序数据的任务，如医疗健康监测、金融趋势预测、机械故障预警等领域。目的是为了获得更高的分类准确性，同时增强模型的可解释性和鲁棒性。 其他说明：作者强调了在实际应用过程中应注意的一些细节，例如正确设置输入数据的维度、选择合适的超参数（如学习率、批大小）、以及考虑是否添加正则化项来避免过拟合等问题。此外，还提到了一些实用的小贴士，像使用动态学习率调度器加快收敛速度等。

    基于Matlab/Simulink的风电调频与风储联合频域模型仿真及应用

    内容概要：本文介绍了利用Matlab/Simulink进行风电调频与风储联合仿真的方法。针对传统时域仿真耗时的问题，提出了一种基于频域模型的方法，实现了快速高效的仿真。文中详细描述了虚拟惯性控制和储能下垂控制的具体实现方式及其对系统频率稳定性的影响。通过频域模型，将复杂的微分方程转化为简单的矩阵运算，显著提高了仿真速度。同时，加入了SOC（荷电状态）管理和滑动平均滤波，确保了储能系统的安全可靠运行。实验结果显示，在相同的硬件条件下，频域模型的仿真速度比传统时域模型快了近十倍，且频率偏差明显减小。 适合人群：从事电力系统仿真、风电调频研究的专业人士和技术爱好者。 使用场景及目标：适用于需要快速验证风电调频控制策略的研究人员和工程师。主要目标是在保证仿真精度的同时大幅提高仿真速度，为风电并网提供技术支持。 其他说明：本文提供的模型专注于调频性能分析，不涉及风机内部动态细节。对于更详细的风机模型，作者提供了进一步的参考资料。

    【人工智能领域】小模型性能直追千亿大模型：AI行业轻量化时代的发展趋势与应用前景分析

    内容概要：本文探讨了小模型在AI行业中逐渐展现出与大模型相媲美性能的现象，分析了大模型和小模型各自的优劣势。大模型虽然在准确性、通用性上有优势，但也面临高成本、低效性、隐私保护等问题；小模型则以高效性、低成本、强隐私保护和高可解释性等优点崭露头角。文中列举了微软Phi-3系列、Google Gemma、Anthropic Claude 3 Haiku和Meta Llama 3等小模型的成功案例，展示了小模型在不同领域的应用潜力。随着技术进步、应用需求增长及政策推动，AI行业正逐步向轻量化转型，但仍需面对性能瓶颈、数据获取等挑战。文章最后展望了小模型与大模型结合的发展趋势，并强调了AI技术发展中伦理和法律问题的重要性。; 适合人群：对AI技术发展趋势感兴趣的从业者、研究人员、企业决策者以及相关领域的学生。; 使用场景及目标：①了解AI行业中大模型与小模型的特点和发展现状；②掌握小模型在各个领域的具体应用场景及其优势；③思考AI技术轻量化转型对企业和社会的影响。; 其他说明：文章指出AI行业的轻量化时代已经悄然来临，小模型凭借其独特的优势将在更多领域发挥作用。同时提醒读者关注AI技术发展中的伦理和法律问题，鼓励大家积极参与到这一变革中来。

    西门子S7-1200 PLC物料分拣系统仿真实现与WinCC动画集成

    内容概要：本文详细介绍了基于西门子S7-1200 PLC的物料分拣系统的设计与仿真。系统采用三个光电传感器进行物料检测和颜色识别，两个推料气缸用于分拣，以及一个传送带电机驱动物料传输。核心逻辑由梯形图和SCL语言编写，涵盖初始化、传感器处理、气缸动作控制和WinCC动画同步等功能。文中强调了急停连锁、颜色传感器信号保持时间和气缸动作延迟等关键细节，并提供了详细的代码片段和调试建议。此外，还介绍了WinCC动画的实现方法，确保仿真效果逼真。 适合人群：初学者和有一定经验的PLC程序员，尤其是希望深入了解PLC控制系统设计和仿真的技术人员。 使用场景及目标：①帮助读者掌握PLC编程的基本技能，特别是S7-1200系列PLC的应用；②提供完整的物料分拣系统仿真案例，便于理解和实践；③通过WinCC动画展示，增强对工业自动化系统的直观认识。 其他说明：本文提供的程序包可在GitHub上获取，建议使用TIA Portal V17打开。仿真过程中应注意变量绑定和时间参数的调整，以确保系统稳定性和动画同步。

    基于邻域粗糙集、引力搜索算法和支持向量机的DGA变压器故障诊断技术研究

    内容概要：本文详细介绍了基于邻域粗糙集（NRS）、引力搜索算法（GSA）和支持向量机（SVM）的变压器故障诊断方法。首先，邻域粗糙集用于特征约简，减少数据维度并提高后续算法的效率。其次，引力搜索算法用于优化SVM的参数，找到最优的惩罚因子C和核函数参数gamma。最后，使用优化后的SVM对变压器故障进行分类诊断。这种方法显著提升了变压器故障诊断的准确性和效率，为电力系统的稳定运行提供了有力保障。 适合人群：从事电力系统维护、数据分析以及机器学习领域的研究人员和技术人员。 使用场景及目标：适用于需要高精度变压器故障诊断的电力系统，旨在提高故障检测的准确性，减少误报率，确保电力系统的安全稳定运行。 其他说明：文中提供了具体的Python代码示例，帮助读者更好地理解和应用这些技术。同时强调了特征工程和参数优化的重要性，指出不同的数据分布可能需要调整相关参数以获得最佳效果。

    MATLAB 2019b中双馈风机MPPT、变速恒频及稳压控制的仿真与优化

    内容概要：本文详细介绍了使用MATLAB 2019b进行双馈风机的最大功率追踪(MPPT)、变速恒频以及直流母线稳压控制仿真的方法和技巧。首先，文章展示了双馈电机通过背靠背变流器连接电网的整体模型架构，分别阐述了转子侧和网侧变流器的功能及其核心控制算法。对于MPPT部分，采用了经典爬山法，并讨论了功率变化方向判断周期和步长参数的影响。接着，深入探讨了变速恒频控制中转子侧变流器的作用，强调了PI参数的选择和解耦补偿的重要性。最后，针对直流母线稳压控制，提出了梯形积分法和前馈补偿的应用，确保电压波动最小化。此外，文中还提供了多个调试技巧和注意事项，如仿真步长、PWM生成、锁相环参数调整等。 适合人群：从事风电领域研究的技术人员、研究生及以上学历的学生，尤其是那些希望深入了解双馈风机控制原理和MATLAB仿真应用的人群。 使用场景及目标：适用于风电系统的开发与优化项目，旨在提高双馈风机的效率和稳定性。具体目标包括实现高效的MPPT算法、稳定的变速恒频控制以及可靠的直流母线稳压机制。 其他说明：文中不仅包含了详细的数学公式和代码片段，还有丰富的实践经验分享，帮助读者更好地理解和解决实际工程中的问题。同时，作者提醒了一些常见的仿真错误，如变流器开关频率设置不当、PWM模块配置失误等，有助于初学者避免类似的问题。

    基于Matlab/Simulink的300kW直驱永磁同步电机风电并网仿真模型构建与优化

    内容概要：本文详细介绍了如何使用Matlab/Simulink构建300kW直驱永磁同步电机的风电并网仿真模型。首先，文章讲解了永磁同步电机的关键参数配置，如定子电阻、d轴和q轴电感、磁链强度以及极对数等。接着，深入探讨了逆变器控制部分的设计，包括锁相环（PLL）的参数设置、双闭环控制结构中的电流环PI参数调整方法。此外，还讨论了并网瞬间的波形处理技巧，如软启动逻辑和直流母线电压的平稳爬升。文中提供了多个调试秘诀，如直流母线电容的选择、坐标变换模块的正确使用等。最后，强调了仿真过程中需要重点关注的三个信号：发电机转矩脉动、网侧电流谐波含量和直流母线电压纹波。 适合人群：具有一定电力电子和控制系统基础知识的研究人员、工程师和技术爱好者。 使用场景及目标：适用于希望深入了解风电并网系统的原理和实现方式的技术人员。通过构建和优化仿真模型，可以更好地掌握永磁同步电机的工作机制及其在风电领域的应用。 阅读建议：读者可以在阅读过程中跟随作者逐步搭建仿真模型，同时关注各个模块的具体参数设置和调试技巧，以便更好地理解和掌握相关知识点。

    药店管理系统（Java + SpringBoot + Mybatis/Mybatis-plus + Mysql)

    项目功能说明 促销管理：零售出库、零售退货 采购管理：采购订单、采购入库、采购退货 销售管理：销售订单、物流信息、销售退货 仓库管理：其它入库、其它出库、调拨出库、组装单、拆卸单 成本核算：收入单、支出单、收款单、付款单、转账单、收预付款 药品溯源：库存状况、账户统计、进货统计、销售统计、入库明细、出库明细、入库汇总、出库汇总、客户对账、供应商对账、库存预警 药品管理：药品类别、药品信息、计量单位、序列号 基本资料：供应商信息、客户信息、会员信息、仓库信息、收支项目、结算账户、经手人管理 系统管理：角色管理、功能管理、机构管理、用户管理、日志管理、系统配置、商品属性、插件管理

    基于梯度下降的改进自适应短时傅里叶变换方法及其在Jupyter Notebook中的应用

    内容概要：本文介绍了基于梯度下降的改进自适应短时傅里叶变换（STFT）方法，并展示了其在Jupyter Notebook中的具体实现。传统的STFT由于固定窗口长度，在处理非平稳信号时存在局限性。改进的方法通过梯度下降策略自适应调整窗口参数，从而提高时频分辨率。文中详细解释了算法的工作原理，包括信号生成、窗函数设计、损失函数选择等方面，并给出了具体的Python代码示例。此外，文章还讨论了该方法在多个领域的广泛应用，如金融时间序列、地震信号、机械振动信号、声发射信号、电压电流信号、语音信号、声信号和生理信号等。 适合人群：从事信号处理、数据分析及相关领域研究的专业人士，尤其是对时频分析感兴趣的科研人员和技术开发者。 使用场景及目标：适用于需要处理非平稳信号的研究和应用场景，旨在提高信号处理的精度和效率。具体目标包括但不限于：改善金融市场的预测能力、提升地震监测系统的准确性、增强机械设备故障诊断的效果、优化语音识别和合成的质量等。 其他说明：该方法不仅限于特定类型的信号，而是可以通过调整参数灵活应用于不同的信号类型。文中提供的代码可以在Jupyter Notebook环境中直接运行，便于实验和验证。

    VMD+NGO最优变分模态优化算法在信号处理与数据预测中的应用及实现

    内容概要：本文详细介绍了VMD（变分模态分解）与NGO（北方苍鹰优化算法）结合形成的最优变分模态优化算法。该算法通过嵌套多种损失函数，尤其是包络熵，实现了对复合信号在频域上的最优拆分。文中不仅解释了算法的工作原理，还提供了具体的Python代码示例，展示了如何通过调整参数来优化信号拆分过程。此外，文章强调了该算法在特征工程领域的巨大价值，特别是在提高数据预测准确性方面的作用。通过实例演示，证明了VMD+NGO算法在处理非平稳信号、音频处理、图像处理等领域中的优越性能。 适合人群：从事信号处理、数据分析、机器学习等相关领域的研究人员和技术人员，尤其是那些希望深入了解并应用先进信号处理技术的人。 使用场景及目标：适用于需要从复杂复合信号中提取有用信息的各种应用场景，如工业设备状态监测、故障诊断、时间序列预测等。主要目标是提高信号处理的精度和效率，进而改善基于这些信号的预测模型的表现。 其他说明：文章提供了详细的代码片段和理论背景，有助于读者更好地理解和实施该算法。同时提醒读者注意某些实现细节，如参数的选择和优化策略的应用。

    基于51单片机protues仿真的鱼缸环境监测系统（仿真图、源代码，AD原理图、流程图）

    基于51单片机protues仿真的鱼缸环境监测系统（仿真图、源代码，AD原理图、流程图） 1、测量鱼缸水温、PH值、有害物质等，并显示 2、可以通过串口遥控控制制氧机和加热器的启停【没有自动控制功能】； 3、仿真图、源代码，AD原理图、流程图

    kotlin从入门到精通.pdf

    内容概要：本文档《kotlin从入门到精通.pdf》详细介绍了Kotlin编程语言的核心概念和特性，内容涵盖了基本语法、类型系统、类与对象、继承、接口、泛型、扩展函数、委托属性、控制流、异常处理、注解、反射、动态类型等多个方面。文档不仅讲解了Kotlin的基本语法和特性，还深入探讨了其与Java和Scala的互操作性和对比。此外，文档还提供了关于如何在不同构建工具（如Maven、Ant、Gradle）中使用Kotlin的具体指导。 适合人群：适合有一定编程基础，特别是熟悉Java的开发人员，尤其是工作1-3年的研发人员。 使用场景及目标： 1. 学习Kotlin的基础语法和特性，了解其与Java的互操作性； 2. 理解Kotlin的高级特性，如扩展函数、委托属性、内联函数等； 3. 掌握Kotlin在不同构建工具中的配置和使用方法； 4. 比较Kotlin与其他语言（如Java、Scala）的优缺点，帮助开发者做出合适的技术选型。 阅读建议：由于Kotlin与Java有着良好的互操作性，且文档内容详尽，建议读者结合实际项目需求逐步学习。对于初学者，可以从基本语法和类型系统入手，逐步深入到高级特性和构建工具的使用。对于有经验的开发者，可以直接跳转到感兴趣的章节，如扩展函数、委托属性等，以提高学习效率。

    F5应用交付之BIG-IP+LTM篇-Beta版

    应用交付之BIG-IP+LTM篇-Beta版

Magicbox
Global site tag (gtag.js) - Google Analytics