java 常用工具类

最新推荐文章于 2021-02-27 15:52:34 发布
最新推荐文章于 2021-02-27 15:52:34 发布
阅读量489 收藏
点赞数
文章标签： java date byte string list null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fpqshine/article/details/5203024
版权

DateTimeHelper 时间组件

 

/**
 *
 */
package com.ibm08001.bbs.utils;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 *
 */
public class DateTimeHelper {

        private static SimpleDateFormat FULL_SDF = new SimpleDateFormat(
                "yyyy-MM-dd HH:mm:ss");

        private static SimpleDateFormat DFULL_SDF = new SimpleDateFormat(
                "yyyy-MM-dd");

        private static SimpleDateFormat DFULL_SDF_SLASH = new SimpleDateFormat(
                "yyyy/MM/dd HH:mm");

        private static SimpleDateFormat FULL_SDF_NOSP = new SimpleDateFormat(
                "yyyyMMddHHmm");

        private static SimpleDateFormat DFULL_SDF_CN = new SimpleDateFormat(
                "yyyy年MM月dd日");

        private static SimpleDateFormat ONLY_TIME = new SimpleDateFormat("HH:mm");

        private static SimpleDateFormat MD_TIME = new SimpleDateFormat("MM-dd");

        public static String getMDTime(Date date) {
            if (date != null) {
                return MD_TIME.format(date);
            } else {
                return "";
            }

        }

        public static String getOnlyTime(Date date) {
            if (date != null) {
                return ONLY_TIME.format(date);
            } else {
                return "";
            }

        }

        public static String getFullTimeNoSP(Date date) {
            if (date != null) {
                return FULL_SDF_NOSP.format(date);
            } else {
                return "";
            }

        }

        public static String getFullTimeTwo(Date date) {
            if (date != null) {
                String dateStr = FULL_SDF.format(date);
                return dateStr.substring(2, 10);
            } else {
                return "";
            }

        }

        public static String getFullTime(Date date) {
            if (date != null) {
                return FULL_SDF.format(date);
            } else {
                return "";
            }
        }

        public static String getDFullTime(Date date) {
            if (date != null) {
                return DFULL_SDF.format(date);
            } else {
                return "";
            }
        }

        public static String getDFullTimeSlash(Date date) {
            if (date != null) {
                return DFULL_SDF_SLASH.format(date);
            } else {
                return "";
            }
        }

        public static String getDFullTimeCN(Date date) {
            if (date != null) {
                return DFULL_SDF_CN.format(date);
            } else {
                return "";
            }
        }

}

 

 

md5加密

 

/**
 * Created on 2005-9-11
 * 参考：互联网
 * 功能：密码加密，返回加密后的编码，但不能解密
 */
package com.ibm08001.bbs.utils;
public class MD5{
    public MD5(){
        state = new long[4];
        count = new long[2];
        buffer = new byte[64];
        digest = new byte[16];
        md5Init();
    }
   
    private void Decode(long al[], byte abyte0[], int i){
        int j = 0;
        for(int k = 0; k < i; k += 4){
            al[j] = b2iu(abyte0[k]) | b2iu(abyte0[k + 1]) << 8 |
            b2iu(abyte0[k + 2]) << 16 | b2iu(abyte0[k + 3]) << 24;
            j++;
        }
    }

    private void Encode(byte abyte0[], long al[], int i){
        int j = 0;
        for(int k = 0; k < i; k += 4){
            abyte0[k] = (byte)(int)(al[j] & 255L);
            abyte0[k + 1] = (byte)(int)(al[j] >>> 8 & 255L);
            abyte0[k + 2] = (byte)(int)(al[j] >>> 16 & 255L);
            abyte0[k + 3] = (byte)(int)(al[j] >>> 24 & 255L);
            j++;
        }
    }

    private long F(long l, long l1, long l2){
        return l & l1 | ~l & l2;
    }

    private long FF(long l, long l1, long l2, long l3,
            long l4, long l5, long l6){
        l += F(l1, l2, l3) + l4 + l6;
        l = (int)l << (int)l5 | (int)l >>> (int)(32L - l5);
        l += l1;
        return l;
    }

    private long G(long l, long l1, long l2){
        return l & l2 | l1 & ~l2;
    }

    private long GG(long l, long l1, long l2, long l3,
            long l4, long l5, long l6){
        l += G(l1, l2, l3) + l4 + l6;
        l = (int)l << (int)l5 | (int)l >>> (int)(32L - l5);
        l += l1;
        return l;
    }

    private long H(long l, long l1, long l2){
        return l ^ l1 ^ l2;
    }

    private long HH(long l, long l1, long l2, long l3,
            long l4, long l5, long l6){
        l += H(l1, l2, l3) + l4 + l6;
        l = (int)l << (int)l5 | (int)l >>> (int)(32L - l5);
        l += l1;
        return l;
    }

    private long I(long l, long l1, long l2){
        return l1 ^ (l | ~l2);
    }

    private long II(long l, long l1, long l2, long l3,
            long l4, long l5, long l6){
        l += I(l1, l2, l3) + l4 + l6;
        l = (int)l << (int)l5 | (int)l >>> (int)(32L - l5);
        l += l1;
        return l;
    }

    public static long b2iu(byte byte0){
        return (long)(byte0 >= 0 ? byte0 : byte0 & 0xff);
    }

    public static String byteHEX(byte byte0){
        char ac[] = {'0', '1', '2', '3', '4', '5', '6',
                '7', '8', '9','A', 'B', 'C', 'D', 'E', 'F'};
        char ac1[] = new char[2];
        ac1[0] = ac[byte0 >>> 4 & 0xf];
        ac1[1] = ac[byte0 & 0xf];
        String s = new String(ac1);
        return s;
    }

    public String getMD5ofStr(String s){
        md5Init();
        md5Update(s.getBytes(), s.length());
        md5Final();
        digestHexStr = "";
        for(int i = 0; i < 16; i++){
            digestHexStr += byteHEX(digest[i]);
        }
        return digestHexStr;
    }

    private void md5Final(){
        byte abyte0[] = new byte[8];
        Encode(abyte0, count, 8);
        int i = (int)(count[0] >>> 3) & 0x3f;
        int j = i >= 56 ? 120 - i : 56 - i;
        md5Update(PADDING, j);
        md5Update(abyte0, 8);
        Encode(digest, state, 16);
    }

    private void md5Init(){
        count[0] = 0L;
        count[1] = 0L;
        state[0] = 0x67452301L;
        state[1] = 0xefcdab89L;
        state[2] = 0x98badcfeL;
        state[3] = 0x10325476L;
    }

    private void md5Memcpy(byte abyte0[],
            byte abyte1[], int i, int j, int k){
        for(int l = 0; l < k; l++){
            abyte0[i + l] = abyte1[j + l];
        }
    }

    private void md5Transform(byte abyte0[]){
        long l = state[0];
        long l1 = state[1];
        long l2 = state[2];
        long l3 = state[3];
        long al[] = new long[16];
        Decode(al, abyte0, 64);
        l = FF(l, l1, l2, l3, al[0], 7L, 0xd76aa478L);
        l3 = FF(l3, l, l1, l2, al[1], 12L, 0xe8c7b756L);
        l2 = FF(l2, l3, l, l1, al[2], 17L, 0x242070dbL);
        l1 = FF(l1, l2, l3, l, al[3], 22L, 0xc1bdceeeL);
        l = FF(l, l1, l2, l3, al[4], 7L, 0xf57c0fafL);
        l3 = FF(l3, l, l1, l2, al[5], 12L, 0x4787c62aL);
        l2 = FF(l2, l3, l, l1, al[6], 17L, 0xa8304613L);
        l1 = FF(l1, l2, l3, l, al[7], 22L, 0xfd469501L);
        l = FF(l, l1, l2, l3, al[8], 7L, 0x698098d8L);
        l3 = FF(l3, l, l1, l2, al[9], 12L, 0x8b44f7afL);
        l2 = FF(l2, l3, l, l1, al[10], 17L, 0xffff5bb1L);
        l1 = FF(l1, l2, l3, l, al[11], 22L, 0x895cd7beL);
        l = FF(l, l1, l2, l3, al[12], 7L, 0x6b901122L);
        l3 = FF(l3, l, l1, l2, al[13], 12L, 0xfd987193L);
        l2 = FF(l2, l3, l, l1, al[14], 17L, 0xa679438eL);
        l1 = FF(l1, l2, l3, l, al[15], 22L, 0x49b40821L);
        l = GG(l, l1, l2, l3, al[1], 5L, 0xf61e2562L);
        l3 = GG(l3, l, l1, l2, al[6], 9L, 0xc040b340L);
        l2 = GG(l2, l3, l, l1, al[11], 14L, 0x265e5a51L);
        l1 = GG(l1, l2, l3, l, al[0], 20L, 0xe9b6c7aaL);
        l = GG(l, l1, l2, l3, al[5], 5L, 0xd62f105dL);
        l3 = GG(l3, l, l1, l2, al[10], 9L, 0x2441453L);
        l2 = GG(l2, l3, l, l1, al[15], 14L, 0xd8a1e681L);
        l1 = GG(l1, l2, l3, l, al[4], 20L, 0xe7d3fbc8L);
        l = GG(l, l1, l2, l3, al[9], 5L, 0x21e1cde6L);
        l3 = GG(l3, l, l1, l2, al[14], 9L, 0xc33707d6L);
        l2 = GG(l2, l3, l, l1, al[3], 14L, 0xf4d50d87L);
        l1 = GG(l1, l2, l3, l, al[8], 20L, 0x455a14edL);
        l = GG(l, l1, l2, l3, al[13], 5L, 0xa9e3e905L);
        l3 = GG(l3, l, l1, l2, al[2], 9L, 0xfcefa3f8L);
        l2 = GG(l2, l3, l, l1, al[7], 14L, 0x676f02d9L);
        l1 = GG(l1, l2, l3, l, al[12], 20L, 0x8d2a4c8aL);
        l = HH(l, l1, l2, l3, al[5], 4L, 0xfffa3942L);
        l3 = HH(l3, l, l1, l2, al[8], 11L, 0x8771f681L);
        l2 = HH(l2, l3, l, l1, al[11], 16L, 0x6d9d6122L);
        l1 = HH(l1, l2, l3, l, al[14], 23L, 0xfde5380cL);
        l = HH(l, l1, l2, l3, al[1], 4L, 0xa4beea44L);
        l3 = HH(l3, l, l1, l2, al[4], 11L, 0x4bdecfa9L);
        l2 = HH(l2, l3, l, l1, al[7], 16L, 0xf6bb4b60L);
        l1 = HH(l1, l2, l3, l, al[10], 23L, 0xbebfbc70L);
        l = HH(l, l1, l2, l3, al[13], 4L, 0x289b7ec6L);
        l3 = HH(l3, l, l1, l2, al[0], 11L, 0xeaa127faL);
        l2 = HH(l2, l3, l, l1, al[3], 16L, 0xd4ef3085L);
        l1 = HH(l1, l2, l3, l, al[6], 23L, 0x4881d05L);
        l = HH(l, l1, l2, l3, al[9], 4L, 0xd9d4d039L);
        l3 = HH(l3, l, l1, l2, al[12], 11L, 0xe6db99e5L);
        l2 = HH(l2, l3, l, l1, al[15], 16L, 0x1fa27cf8L);
        l1 = HH(l1, l2, l3, l, al[2], 23L, 0xc4ac5665L);
        l = II(l, l1, l2, l3, al[0], 6L, 0xf4292244L);
        l3 = II(l3, l, l1, l2, al[7], 10L, 0x432aff97L);
        l2 = II(l2, l3, l, l1, al[14], 15L, 0xab9423a7L);
        l1 = II(l1, l2, l3, l, al[5], 21L, 0xfc93a039L);
        l = II(l, l1, l2, l3, al[12], 6L, 0x655b59c3L);
        l3 = II(l3, l, l1, l2, al[3], 10L, 0x8f0ccc92L);
        l2 = II(l2, l3, l, l1, al[10], 15L, 0xffeff47dL);
        l1 = II(l1, l2, l3, l, al[1], 21L, 0x85845dd1L);
        l = II(l, l1, l2, l3, al[8], 6L, 0x6fa87e4fL);
        l3 = II(l3, l, l1, l2, al[15], 10L, 0xfe2ce6e0L);
        l2 = II(l2, l3, l, l1, al[6], 15L, 0xa3014314L);
        l1 = II(l1, l2, l3, l, al[13], 21L, 0x4e0811a1L);
        l = II(l, l1, l2, l3, al[4], 6L, 0xf7537e82L);
        l3 = II(l3, l, l1, l2, al[11], 10L, 0xbd3af235L);
        l2 = II(l2, l3, l, l1, al[2], 15L, 0x2ad7d2bbL);
        l1 = II(l1, l2, l3, l, al[9], 21L, 0xeb86d391L);
        state[0] += l;
        state[1] += l1;
        state[2] += l2;
        state[3] += l3;
    }

    private void md5Update(byte abyte0[], int i){
        byte abyte1[] = new byte[64];
        int k = (int)(count[0] >>> 3) & 0x3f;
        if((count[0] += i << 3) < (long)(i << 3))
            count[1]++;
        count[1] += i >>> 29;
        int l = 64 - k;
        int j;
        if(i >= l){
            md5Memcpy(buffer, abyte0, k, 0, l);
            md5Transform(buffer);
            for(j = l; j + 63 < i; j += 64){
                md5Memcpy(abyte1, abyte0, 0, j, 64);
                md5Transform(abyte1);
            }
            k = 0;
        }
        else{
            j = 0;
        }
        md5Memcpy(buffer, abyte0, k, j, i - j);
    }

    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[];
    private long count[];
    private byte buffer[];
    public String digestHexStr;
    private byte digest[];

    public static void main(String[]args){
        MD5 md5=new MD5();
        System.out.println(md5.getMD5ofStr("123456"));
    }
}

 

 

 

 

 

 

 

jsp简单分页组件

 

package com.ibm08001.bbs.utils;

import java.util.HashMap;
import java.util.List;
import java.util.Map;


public class PageHelper {

    private int pageSize;
    private int currentPage;
    private int totalRecord;
    private int totalPage;
    private int nextPage;
    private int prevPage;
    private int firstRecord;
   
    private List list;
   
    private Map paras = new HashMap();

    public static PageHelper getInstance(String currentPage, int pageSize,
            int totalRecord) {

        return new PageHelper(currentPage, pageSize, totalRecord);

    }

    private PageHelper(String currentPage, int pageSize, int totalRecord) {
        this.totalRecord = totalRecord;
        this.pageSize = pageSize;
       
        if (totalRecord != 0) {
       
            /*
            if (totalRecord % pageSize == 0) {
                totalPage = totalRecord / pageSize;
            } else {
                totalPage = (totalRecord / pageSize) + 1;
            }
            */
            totalPage = (totalRecord - 1) / pageSize + 1;
            firstRecord = (Integer.parseInt(currentPage) - 1) * pageSize;
           
            if (currentPage == null || currentPage.equals("")
                    || currentPage.equals("0")) {
                this.currentPage = 1;
            } else {
                this.currentPage = Integer.parseInt(currentPage);
                if (this.currentPage - 1 <= 0) {
                    this.prevPage = 1;
                } else {
                    this.prevPage = this.currentPage - 1;
                }
                if (this.currentPage + 1 >= totalPage) {
                    this.nextPage = totalPage;
                } else {
                    this.nextPage = this.currentPage + 1;
                }
            }
        } else {
            this.currentPage = 0;
            this.totalRecord = 0;
            this.totalPage = 0;
            this.nextPage = 0;
            this.prevPage = 0;
        }

    }

    /**
     * @return the pageSize
     */
    public int getPageSize() {
        return pageSize;
    }

    /**
     * @param pageSize
     *            the pageSize to set
     */
    public void setPageSize(int pageSize) {
        this.pageSize = pageSize;
    }

    /**
     * @return the currentPage
     */
    public int getCurrentPage() {
        return currentPage;
    }

    /**
     * @param currentPage
     *            the currentPage to set
     */
    public void setCurrentPage(int currentPage) {
        this.currentPage = currentPage;
    }

    /**
     * @return the totalRecord
     */
    public int getTotalRecord() {
        return totalRecord;
    }

    /**
     * @param totalRecord
     *            the totalRecord to set
     */
    public void setTotalRecord(int totalRecord) {
        this.totalRecord = totalRecord;
    }

    /**
     * @return the totalPage
     */
    public int getTotalPage() {
        return totalPage;
    }

    /**
     * @param totalPage
     *            the totalPage to set
     */
    public void setTotalPage(int totalPage) {
        this.totalPage = totalPage;
    }

    /**
     * @return the nextPage
     */
    public int getNextPage() {
        return nextPage;
    }

    /**
     * @param nextPage
     *            the nextPage to set
     */
    public void setNextPage(int nextPage) {
        this.nextPage = nextPage;
    }

    /**
     * @return the prevPage
     */
    public int getPrevPage() {
        return prevPage;
    }

    /**
     * @param prevPage
     *            the prevPage to set
     */
    public void setPrevPage(int prevPage) {
        this.prevPage = prevPage;
    }

    /**
     * @return the list
     */
    public List getList() {
        return list;
    }

    /**
     * @param list
     *            the list to set
     */
    public void setList(List list) {
        this.list = list;
    }

    /**
     * @return the paras
     */
    public Object getParameter(String key) {

        return paras.get(key);
    }

    /**
     * @param paras
     *            the paras to set
     */
    public void addParameter(String key, Object value) {
        paras.put(key, value);
    }

    public int getFirstRecord() {
        return firstRecord;
    }

    public void setFirstRecord(int firstRecord) {
        this.firstRecord = firstRecord;
       
    }

   
}

 

 

 

 

 

 

 

榨菜大叔@
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java中的网络编程类（TCP/UDP)
JZ
06-11 1万+
Java中的网络编程类n Java.net包– TCP协议• URL• URLConnection• Socket• ServerSocket– UDP协议• DatagramPacket• DatagramSocket• MulticastSocketTCP Socket客户端package com.cauc.edu; import java.net.*; import java.io.*; ...
Java常用工具类整理一
逍遥飞鹤的专栏
07-10 1933
1.Java中计算两个时间的差
java工具类_Java常用工具类
weixin_35294082的博客
02-12 244
网上理论上的概念都大同小异，使用自己的方式来理解，把他"吃透"，这样才能变成你自己财富。包装类在Java中基本数据类型都存放在栈内存中，那我们如果想把基本数据类型存放在堆中，那该如何来进行处理呢？这时我们就可以使用包装类来实现。基本数据类型对应的包装类byteByteshortShortintIntegerlongLongfloatFloatdoubleDoublecharCharacter基本数...
25个Java机器学习工具&库
youzhouliu的博客
12-25 1610
摘要：本问总结了25个Java机器学习工具&库：Weka集成了数据挖掘工作的机器学习算法、面向数据流挖掘的流行开源框架（MOA）、新型的柔性工作流引擎ADAMS、基于Java的面向文本文件的机器学习工具包Mallet等。 本列表总结了25个Java机器学习工具&库： 1. Weka集成了数据挖掘工作的机器学习算法。这些算法可以直接应用于一个数据集上或者你可以自己编写代码来调用。We
jaava和jsp工具类
09-12
[工具类] 成各种密码随机串，加密解密，编码解码，执行url.java [工具类] 读取、打印输出、保存xml .java [工具类] 获得汉字拼音首字母的java工具类 .java [工具类] 获取绝对路径 .java [工具类] 记录log日志文件的工具类 .java [工具类] 连接数据库的工具类 .java [工具类] 使用Java程序来实现HTTP文件的队列下载 .java [工具类] 文件操作工具类 .java [工具类] 序列化保存为XML文件的工具类 .java [工具类] 一个压缩工具类 .java [工具类] 用java编写简单UDP网络通信程序 .ja
Java常用工具类
04-12
Java常用工具类是Java开发中不可或缺的一部分，它们提供了一系列便捷的方法，帮助开发者高效地处理各种常见任务。在Java中，最著名的工具类库是`java.util`包，它包含了大量实用类，如集合、日期时间、数学计算、...
java 常用工具类
06-23
Java工具类是Java编程中非常重要的组成部分，它们提供了一系列预定义的方法，可以帮助开发者高效地处理各种常见任务，而无需从头实现。在Java中，最知名的工具类库是`java.util`包，它包含了大量方便实用的类。下面...
java常用工具类
10-17
"java常用工具类"这个主题涵盖了Java开发中常用的类和方法，这些工具类可以帮助我们简化编程工作，提高代码的可读性和可维护性。在Java中，`java.util`包就是这样一个包含大量工具类的包，提供了很多实用的功能。 1...
28个java常用的工具类
09-04
java工具类，包含了字符串类型，数据类型，MD5,日期时间类型，文件上传工具类，正则表达式帮助类等28个java开发的常用工具。
Java网络编程之URLEncode和URLDecode工具类
wf_kingofring的专栏
03-15 7039
import java.io.UnsupportedEncodingException; import java.net.URLDecoder; import java.net.URLEncoder;public class EncodeTest { private StringBuilder query = new StringBuilder(); public synchronize
java socket工具类示例
04-17
java socket工具类示例,使用控制台实现简单收发,简单聊天系统.
jsp工具类应用
12-15
jsp工具函数应用的基本步骤，帮助你在jsp页面也可以完成调用方法进行查询的任务
Java高编，网络tcp工具类方法
Berlin56的博客
07-12 1637
tcp连接1.服务器创建ServerScoket并且监听本机端口（ServerScoket构造方法） 2.服务器ServerScoket开始在端口上等待客户端连接 accept（）； 3.客户端使用Scoket通过主机地址和端口号连接服务器。（scoket构造方法） 4.在服务器也会产生客户端对应的一个scoket，连接已经建立 5.通过Scoket的双向字节流来进行交互。getInput
Java网络编程总结
热门推荐
wenzhi的博客
09-22 2万+
本文主要对java网络编程Socket类的使用做总结，其中Socket对象可以进行数据的读取和写入是必须要知道的！
Mongodb数据统计分析：group by、count(distinct userId)
yown的专栏
12-30 2万+
最近在做mongodb数据统计查询，需求：统计一段时间内每天的分享次数和分享人数? 查了众多资料，居然未找到好的方案，最终还是自己写函数解决了，现分享出来（若有好的方法请指出）： 表t_share_log结构(习惯这么叫，虽mongodb中为collection): 字段名 类型 说明 id string 记录id gmtCreate date 创建时间 user
JSP分页工具类
幻世录
04-12 294
/** * 页面里的一页数据的对象 * @author BluceYoung * */ public class PageUtil<T> { private int pageNo;//当前第几页 private int pageCount;//共多少页 private int pageSize=5;//每页显示多少条 private int totalCount;/...
我在项目中用到的一些工具类
HeiMeiHXN的专栏
09-15 1521
         最近在做一个 bbs 项目,由于是项目实战,所以进度非常慢,很多东西都是头一次接触到.据说真正把 bbs 弄懂,就会得到很大提高,也真是这样呢,现在才刚刚开始,就已经接触了很多以前没有用到的好东西,并非自己写的,但是放在这里以防遗忘,也可以和大家共享.比如说下面的几个工具类:  1>. 一个关于取出各种格式的日期的类.如果你觉得这里面没有你想要的格式,那么可以在里面添加,
基于 JSP 的自动代码生成工具类，自动生成 JavaBean Dao Service Servlet Filter(请求响应编码过滤器)
cimo的博客
02-27 448
生成代码目录结构如下： 如何使用： 在项目目录下新建工具类包util，并 在util包中新建 数据库连接工具类DbCon（类名必须为 DbCon）和 代码生成工具类 Automatically 修改代码配置，运行Automatically工具类即可 代码如下： 数据库连接工具类： package com.util; import java.sql.Connection; import java.sql.DriverManager; /** * @author cimo * @create 20
java网络编程中常用的类
倩mys的博客
11-04 1850
java网络编程中常用的类 1、InetAddress 用于封装计算机的IP地址和DNS(Domain Name System域名系统)（没有端口信息） InetAddress没有构造器，要得到对象只能通过静态方法实现 /** * 使用getLocalHost的方法创建InetAddress对象 */ package com.InetAddress; import java.net.Inet...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值