开发常见工具类

少年已不年少 少年已不年少 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 400+累计阅读 483平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄11年
关注
原创 最新推荐文章于 2026-09-18 12:22:25 发布 483 阅读 AI 写同款· GEO 优化 ›
【RS】哨兵系列数据下载（哨兵2号Sentinel-2波段介绍、下载） 以哨兵二号为示例，分享如何下载欧空局的哨兵系列数据 阅读详情

/**
* 日期操作
*/
public class DateUtil {
private static final String[] weekDayStrings = {“日”, “一”, “二”, “三”, “四”, “五”, “六”};

public static final String DATETIME_PATTERN_1_1 = "yyyy-MM-dd HH:mm:ss.SSS";
public static final String DATETIME_PATTERN_2_1 = "yyyy-MM-dd HH:mm";
public static final String DATETIME_PATTERN_2_2 = "yyyy/MM/dd HH:mm";
public static final String DATETIME_PATTERN_2_3 = "yyyy年MM月dd日 HH:mm";
public static final String DATETIME_PATTERN_3_1 = "yyyy-MM-dd";
public static final String DATETIME_PATTERN_3_2 = "yyyy/MM/dd";
public static final String DATETIME_PATTERN_3_3 = "yyyy年MM月dd日";
public static final String DATETIME_PATTERN_3_4 = "yyyyMMdd";
public static final String DATETIME_PATTERN_4_1 = "yyyy";
public static final String DATETIME_PATTERN_5_1 = "MM-dd";
public static final String DATETIME_PATTERN_6_1 = "yyyy-MM-dd HH:mm:ss";

/**
 * 获取任意一段时间内的简单日历,主要包含日期和星期对应关系
 *
 * @param startDay 起始日期
 * @param endDay   结束日期
 * @return 二维数组, <br>星期/日期
 */
public static String[][] getWeekDays(Calendar startDay, Calendar endDay) {

    ArrayList<String[]> weekDays = new ArrayList<>();

    Calendar tempStart = (Calendar) startDay.clone();
    while (endDay.compareTo(tempStart) == 1) {
        String[] arr = new String[2];
        arr[0] = weekDayStrings[tempStart.get(Calendar.DAY_OF_WEEK) - 1];
        arr[1] = String.valueOf(tempStart.get(Calendar.DAY_OF_MONTH));
        weekDays.add(arr);
        tempStart.add(Calendar.DAY_OF_YEAR, 1);
    }
    return (weekDays.toArray(new String[0][0]));


}

public static String getFormatTime(String datetime, String pattern, String pattern_new) {
    if (datetime != null && datetime.trim().length() > 0) {
        try {
            Date date = new SimpleDateFormat(pattern).parse(datetime);
            SimpleDateFormat dateFormat = new SimpleDateFormat(pattern_new);
            return dateFormat.format(date);
        } catch (ParseException e) {
            e.printStackTrace();
            return null;
        }
    } else {
        return null;
    }
}

/**
 * 获取星期几
 *
 * @return
 */
public static String getWeek() {
    Calendar cal = Calendar.getInstance();
    int i = cal.get(Calendar.DAY_OF_WEEK);
    switch (i) {
        case 1:
            return "星期日";
        case 2:
            return "星期一";
        case 3:
            return "星期二";
        case 4:
            return "星期三";
        case 5:
            return "星期四";
        case 6:
            return "星期五";
        case 7:
            return "星期六";
        default:
            return "";
    }
}

public static String getWeekOfDate(Date dt, Calendar calendar) {
    String[] weekDays = {"周日", "周一", "周二", "周三", "周四", "周五", "周六"};
    calendar.setTime(dt);
    int w = calendar.get(Calendar.DAY_OF_WEEK) - 1;
    if (w < 0)
        w = 0;
    return weekDays[w];
}

/**
 * 判断是白天还是晚上
 *
 * @return 白天返回 true ; 晚上 返回false
 */
public static boolean isDayOrNight(Context context) {
    //获得内容提供者

// ContentResolver mResolver = context.getContentResolver();
//获得系统时间制
// String timeFormat = android.provider.Settings.System.getString(mResolver, android.provider.Settings.System.TIME_12_24);
// if (timeFormat.equals(“24”)) {
boolean hourFormat = DateFormat.is24HourFormat(context);
//判断时间制
if (hourFormat) {
//24小时制
SimpleDateFormat df = new SimpleDateFormat(“HH:mm:ss”);//设置日期格式
String time = df.format(new Date());
int hour = Integer.parseInt(time.substring(0, 2));
if (hour >= 6 && hour < 18) { //白天
return true;
} else {
return false;
}
} else {
//12小时制
//获得日历
Calendar mCalendar = Calendar.getInstance();
if (mCalendar.get(Calendar.AM_PM) == Calendar.AM) {
//白天
if(mCalendar.get(Calendar.HOUR)>=6){
return true;
}else{
return false;
}
}else{
if(mCalendar.get(Calendar.HOUR)<6){
return true;
}else{
//晚
return false;
}

        }
    }
}


public static String getCurrentTime() {
    SimpleDateFormat formatter = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
    Date curDate = new Date(System.currentTimeMillis());//获取当前时间
    return formatter.format(curDate);
}

/**
 * 将字符串转为时间戳
 * @param user_time "2010年12月08日11时17分00秒"
 * @return
 */
public static String getTime(String user_time) {
    String re_time = null;
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日HH时mm分ss秒");
    Date d;
    try {
        d = sdf.parse(user_time);
        long l = d.getTime();
        String str = String.valueOf(l);
        re_time = str.substring(0, 10);
    } catch (ParseException e) {
        e.printStackTrace();
    }
    return re_time;
}

/**
 * 将yyyy年MM月dd日格式时间转换成毫秒值
 * @param time
 * @return
 */
public static long getLongTime(String time){
    long l = 0;
    SimpleDateFormat sdf = new SimpleDateFormat(DATETIME_PATTERN_3_1);
    Date d;
    try {
        d = sdf.parse(time);
        l =  d.getTime();
    } catch (ParseException e) {
        e.printStackTrace();
    }
    return l;
}

/**
 * 将毫秒值转换成yyyy年MM月dd日格式
 * @param ms
 * @return
 */
public static String getStringTime(long ms) {
    SimpleDateFormat formatter = new SimpleDateFormat(DATETIME_PATTERN_3_1);
    Date curDate = new Date(ms);//获取当前时间
    return formatter.format(curDate);
}

/**
 * 将yyyy-MM-dd hh:mm:ss 格式时间转换成毫秒值
 * @param time
 * @return
 */
public static long parseLongTime(String time){
    long l = 0;
    SimpleDateFormat sdf = new SimpleDateFormat(DATETIME_PATTERN_6_1);
    Date d;
    try {
        d = sdf.parse(time);
        l =  d.getTime();

    } catch (ParseException e) {
        e.printStackTrace();
    }
    return l;
}

/**
 * 将毫秒值转换成yyyy-MM-dd hh:mm:ss 格式
 * @param ms
 * @return
 */
public static String parseStrTime(long ms) {
    SimpleDateFormat formatter = new SimpleDateFormat(DATETIME_PATTERN_6_1);
    Date curDate = new Date(ms);//获取当前时间
    return formatter.format(curDate);
}

}

/**
* sp工具类
*/
public class SharePreferencesUtil {
public static final String DEFAULT_SHARE_NODE = “followup_sharepreference”;

public static void saveInt(String node, String key, int value) {
    SharedPreferences sp = BaseApplication.getAppContext().getSharedPreferences(node, Context.MODE_PRIVATE);
    SharedPreferences.Editor editor = sp.edit();
    editor.putInt(key, value);
    editor.commit();
}

public static void saveInt(String key, int value) {
    SharedPreferences sp = BaseApplication.getAppContext().getSharedPreferences(DEFAULT_SHARE_NODE, Context.MODE_PRIVATE);
    SharedPreferences.Editor editor = sp.edit();
    editor.putInt(key, value);
    editor.commit();
}

public static void saveBoolean(String node, String key, boolean value) {
    SharedPreferences sp = BaseApplication.getAppContext().getSharedPreferences(node, Context.MODE_PRIVATE);
    SharedPreferences.Editor editor = sp.edit();
    editor.putBoolean(key, value);
    editor.commit();
}

public static void saveBoolean(String key, boolean value) {
    SharedPreferences sp = BaseApplication.getAppContext().getSharedPreferences(DEFAULT_SHARE_NODE, Context.MODE_PRIVATE);
    SharedPreferences.Editor editor = sp.edit();
    editor.putBoolean(key, value);
    editor.commit();
}

public static void saveString(String node, String key, String value) {
    SharedPreferences sp = BaseApplication.getAppContext().getSharedPreferences(node, Context.MODE_PRIVATE);
    SharedPreferences.Editor editor = sp.edit();
    editor.putString(key, value);
    editor.commit();
}

public static void saveString(String key, String value) {
    SharedPreferences sp = BaseApplication.getAppContext().getSharedPreferences(DEFAULT_SHARE_NODE, Context.MODE_PRIVATE);
    SharedPreferences.Editor editor = sp.edit();
    editor.putString(key, value);
    editor.commit();
}

public static int getInt(String node, String key, int defaultvalue) {
    SharedPreferences sp = BaseApplication.getAppContext().getSharedPreferences(node, Context.MODE_PRIVATE);
    return sp.getInt(key, defaultvalue);
}

public static int getInt(String key, int defaultvalue) {
    SharedPreferences sp = BaseApplication.getAppContext().getSharedPreferences(DEFAULT_SHARE_NODE, Context.MODE_PRIVATE);
    return sp.getInt(key, defaultvalue);
}

public static boolean getBoolean(String node, String key, boolean defaultvalue) {
    SharedPreferences sp = BaseApplication.getAppContext().getSharedPreferences(node, Context.MODE_PRIVATE);
    return sp.getBoolean(key, defaultvalue);
}

public static boolean getBoolean(String key, boolean defaultvalue) {
    SharedPreferences sp = BaseApplication.getAppContext().getSharedPreferences(DEFAULT_SHARE_NODE, Context.MODE_PRIVATE);
    return sp.getBoolean(key, defaultvalue);
}

public static String getString(String node, String key, String defaultvalue) {
    SharedPreferences sp = BaseApplication.getAppContext().getSharedPreferences(node, Context.MODE_PRIVATE);
    return sp.getString(key, defaultvalue);
}

public static String getString(String key, String defaultvalue) {
    SharedPreferences sp = BaseApplication.getAppContext().getSharedPreferences(DEFAULT_SHARE_NODE, Context.MODE_PRIVATE);
    return sp.getString(key, defaultvalue);
}

}

/**
* @Description String 处理类
*/
public class StringUtil {
/**
* 金额转换为小数点后两位
* @param money
* @return
*/
public static String formatMoney(String money) {
if (TextUtils.isEmpty(money)) {
return “0.00”;
} else {
if(isNumber(money)) {
return String.format(“%.2f”, Double.valueOf(money));
}else {
return money;
}
}
}
/**
* 判断字符串是否是整数
*/
public static boolean isInteger(String value) {
try {
Integer.parseInt(value);
return true;
} catch (NumberFormatException e) {
return false;
}
}

/**
 * 判断字符串是否是浮点数
 */
public static boolean isDouble(String value) {
    try {
        Double.parseDouble(value);
        if (value.contains("."))
            return true;
        return false;
    } catch (NumberFormatException e) {
        return false;
    }
}

/**
 * 判断字符串是否是数字
 */
public static boolean isNumber(String value) {
    return isInteger(value) || isDouble(value);
}

}

/**
* dip转换px
*/
public class UIUtils
{

public static Context getContext()
{
    return BaseApplication.getInstance();
}

public static Thread getMainThread()
{
    return BaseApplication.getMainThread();
}

public static long getMainThreadId()
{
    return BaseApplication.getMainThreadId();
}
public static int getScreenHight()
{
    final float scale = getContext().getResources().getDisplayMetrics().heightPixels;
    return (int) scale;
}
/** dip转换px */
public static int dp2px(int dip)
{
    final float scale = getContext().getResources().getDisplayMetrics().density;
    return (int) (dip * scale + 0.5f);
}

/** pxz转换dip */
public static int px2dp(int px)
{
    final float scale = getContext().getResources().getDisplayMetrics().density;
    return (int) (px / scale + 0.5f);
}

/** 获取主线程的handler */
public static Handler getHandler()
{
    return BaseApplication.getMainThreadHandler();
}

/** 延时在主线程执行runnable */
public static boolean postDelayed(Runnable runnable, long delayMillis)
{
    return getHandler().postDelayed(runnable, delayMillis);
}

/** 在主线程执行runnable */
public static boolean post(Runnable runnable)
{
    return getHandler().post(runnable);
}

/** 从主线程looper里面移除runnable */
public static void removeCallbacks(Runnable runnable)
{
    getHandler().removeCallbacks(runnable);
}

public static View inflate(int resId)
{
    return LayoutInflater.from(getContext()).inflate(resId, null);
}

/** 获取资源 */
public static Resources getResources()
{
    return getContext().getResources();
}

/** 获取文字 */
public static String getString(int resId)
{
    return getResources().getString(resId);
}

/** 获取文字数组 */
public static String[] getStringArray(int resId)
{
    return getResources().getStringArray(resId);
}

/** 获取dimen */
public static int getDimens(int resId)
{
    return getResources().getDimensionPixelSize(resId);
}

/** 获取drawable */
public static Drawable getDrawable(int resId)
{
    return getResources().getDrawable(resId);
}

/** 获取颜色 */
public static int getColor(int resId)
{
    return getResources().getColor(resId);
}

/** 获取颜色选择器 */
public static ColorStateList getColorStateList(int resId)
{
    return getResources().getColorStateList(resId);
}

// 判断当前的线程是不是在主线程
public static boolean isRunInMainThread()
{
    return android.os.Process.myTid() == getMainThreadId();
}

public static void runInMainThread(Runnable runnable)
{
    if (isRunInMainThread())
    {
        runnable.run();
    } else
    {
        post(runnable);
    }
}

public static void startActivity(Intent intent)
{

// MainActivity activity = MainActivity.getForegroundActivity();
// if (activity != null)
// {
// activity.startActivity(intent);
// } else
// {
// intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
// getContext().startActivity(intent);
// }
}

/** 对toast的简易封装。线程安全，可以在非UI线程调用。 */
public static void showToastSafe(final int resId)
{
    showToastSafe(getString(resId));
}

/** 对toast的简易封装。线程安全，可以在非UI线程调用。 */
public static void showToastSafe(final String str)
{
    if (isRunInMainThread())
    {
        showToast(str);
    } else
    {
        post(new Runnable()
        {
            @Override
            public void run()
            {
                showToast(str);
            }
        });
    }
}

private static void showToast(String str)
{

// MainActivity frontActivity = MainActivity.getForegroundActivity();
// if (frontActivity != null)
// {
// Toast.makeText(frontActivity, str, Toast.LENGTH_SHORT).show();
// }
}

public static void showNormalToast(final int resId)
{
    showToast(getString(resId));
}

public static void showToast(final int resId)
{

// MainActivity frontActivity = MainActivity.getForegroundActivity();
// if (frontActivity != null)
// {
// Toast toast = Toast.makeText(getContext(), getString(resId),
// Toast.LENGTH_SHORT);
// toast.setGravity(Gravity.CENTER_HORIZONTAL | Gravity.TOP, 0, UIUtils.dp2px(200));
// toast.show();
// }
}

/**
 * 判断app是否存活
 * @param context
 * @return
 */
public static boolean isAppAlive(Context context){
    ActivityManager am = (ActivityManager)context.getSystemService(Context.ACTIVITY_SERVICE);
    List<ActivityManager.RunningTaskInfo> list = am.getRunningTasks(100);
    for (ActivityManager.RunningTaskInfo info : list) {
        if (info.topActivity.getPackageName().equals(context.getPackageName()) && info.baseActivity.getPackageName().equals(context.getPackageName())) {
            return true;
        }
    }
    return false;
}

}

/**
* 设备信息工具类,用以获取屏幕分辨率,设备识别号等硬件信息
*/
public class DeviceUtil {
private static int screenWidth = 0;
private static int screenHeight = 0;
private static int statusBarHeight = 0;

public static boolean isTablet = false;

/**
 * 根据手机的分辨率从 dp 的单位 转成为 px(像素)
 */
public static int dip2px(float dpValue) {
    final float scale = BaseApplication.getInstance().getResources().getDisplayMetrics().density;
    return (int) (dpValue * scale + 0.5f);
}

/**
 * 根据手机的分辨率从 px(像素) 的单位 转成为 dp
 */
public static int px2dip(Context context, float pxValue) {
    final float scale = context.getResources().getDisplayMetrics().density;
    return (int) (pxValue / scale + 0.5f);
}

public static int sp2px(Context context, float spValue) {
    final float fontScale = context.getResources().getDisplayMetrics().scaledDensity;
    return (int) (spValue * fontScale + 0.5f);
}

/**
 * 获得状态栏高度
 *
 * @return
 */
public static int getStatusBarHeight() {
    if (statusBarHeight == 0) {
        Class<?> c;
        Object obj;
        Field field;
        int x;
        try {
            c = Class.forName("com.android.internal.R$dimen");
            obj = c.newInstance();
            field = c.getField("status_bar_height");
            x = Integer.parseInt(field.get(obj).toString());
            statusBarHeight = BaseApplication.getInstance().getResources().getDimensionPixelSize(x);
        } catch (Exception e1) {
            e1.printStackTrace();
        }

//
// View view = activity.getWindow().getDecorView();
// Rect rect = new Rect();
// view.getWindowVisibleDisplayFrame(rect);
// statusBarHeight = rect.top;
}
return statusBarHeight;
}

public static int getScreenWidth() {
    if (screenWidth == 0) {
        screenWidth = BaseApplication.getInstance().getResources().getDisplayMetrics().widthPixels;
    }
    return screenWidth;
}

public static DisplayMetrics getDisplayMetrics() {
    return BaseApplication.getInstance().getResources().getDisplayMetrics();
}

public static int getScreenHeight() {
    if (screenHeight == 0) {
        screenHeight = BaseApplication.getInstance().getResources().getDisplayMetrics().heightPixels;
    }
    return screenHeight;
}

public static int getSDKVersion() {
    return Build.VERSION.SDK_INT;
}


/**
 * 判断是否平板
 *
 * @param context
 * @return
 */
public static boolean isTablet(Context context) {
    DisplayMetrics dm = context.getResources().getDisplayMetrics();
    double diagonalPixels = Math.sqrt(Math.pow(dm.widthPixels, 2) + Math.pow(dm.heightPixels, 2));
    double screenSize = diagonalPixels / (160 * dm.density);
    if (screenSize >= 6) {
        return true;
    } else {
        return false;
    }
}

/**
 * 判断sdk版本是否高于11.目前关系到属性动画的使用
 *
 * @return
 */
public static boolean isHigherThanSDK11() {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
        return true;
    }
    return false;
}

/**
 * 获取手机厂商
 *
 * @return
 */
public static String getDeviceManufacturers() {
    return Build.MANUFACTURER;
}

/**
 * 获取屏幕宽度和高度，单位为px
 * @param context
 * @return
 */
public static Point getScreenMetrics(Context context){
    DisplayMetrics dm =context.getResources().getDisplayMetrics();
    int w_screen = dm.widthPixels;
    int h_screen = dm.heightPixels;
    AbLogUtil.d( "Screen---Width = " + w_screen + " Height = " + h_screen + " densityDpi = " + dm.densityDpi);
    return new Point(w_screen, h_screen);

}
/**
 * 获取屏幕长宽比
 * @param context
 * @return
 */
public static float getScreenRate(Context context){
    Point P = getScreenMetrics(context);
    float H = P.y;
    float W = P.x;
    return (H/W);
}

}

/**
*软键盘管理类
/
public class RstInputMethodManager {
/**
* 隐藏输入框
*
* @param view
*/
public static void hideSoftInput(EditText view) {
hideSoftInput(view.getWindowToken());
}

/**
 * 隐藏输入框
 */
public static void hideSoftInput(IBinder windowToken) {
    final InputMethodManager imm = (InputMethodManager) BaseApplication.getAppContext().getSystemService(Context.INPUT_METHOD_SERVICE);
    final IMMResult result = new IMMResult();
    if (null != windowToken) {
        imm.hideSoftInputFromWindow(windowToken, 0, result);
    }
}

/**
 * 显示 输入框
 *
 * @param view
 */
public static void showSoftInput(EditText view) {
    final InputMethodManager imm = (InputMethodManager) BaseApplication.getAppContext().getSystemService(Context.INPUT_METHOD_SERVICE);
    final IMMResult result = new IMMResult();
    imm.showSoftInput(view, 0, result);
    view.postDelayed(new Runnable() {
        @Override
        public void run() {
            int res = result.getResult();
            if (res != InputMethodManager.RESULT_SHOWN && res != InputMethodManager.RESULT_UNCHANGED_HIDDEN) {
                imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
            }
        }
    }, 500);
    view.requestFocus();
}

public static class IMMResult extends ResultReceiver {
    public int result = -1;

    public IMMResult() {
        super(null);
    }

    @Override
    public void onReceiveResult(int r, Bundle data) {
        result = r;
    }

    public int getResult() {
        return result;
    }
}

}

收录于
android

当前文章被收录于：

android
3 篇文章 0 人学习
订阅专栏 查看详情
标签
#常见的工具类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
＜硬件设计＞ 阻抗设计(二) 使用Si9000计算阻抗 阻抗设计(二) 使用Si9000计算阻抗 阅读详情

相关推荐

告别CMake依赖！在Visual Studio 2022中直接配置VTK 9.4开发环境（附完整项目示例）

本文详细介绍了如何在Visual Studio 2022中直接配置VTK 9.4开发环境，无需依赖CMake。通过图文教程和完整项目示例，帮助C++开发者快速集成VTK库，简化开发流程，提升工作效率。特别适合科学可视化任务的开发者。

weixin_26804345的博客 416

java中string与date(日期)格式之间的转换

经常遇到string和date之间的转换，把相关的内容总结在这里吧： 1.string格式转化为Date对象： //把string转化为date DateFormat fmt =new SimpleDateFormat("yyyy-MM-dd"); Date date = fmt.parse(szBeginTime); test.setStartTime(date);

漂泊小柒的专栏 25万+

移相变压器Simulink建模与HVDC系统仿真实践

移相变压器是电力电子领域实现精确相位调节的核心设备，其通过特殊绕组设计改变输出电压相位角，在解决环网潮流不均、阻尼功率振荡等场景具有关键作用。本文基于MATLAB/Simulink环境，详细解析移相变压器的建模原理与技术实现，包括磁路耦合特性模拟、参数计算方法和控制策略设计。针对HVDC高压直流输电和FACTS柔性交流输电系统等典型应用，提供仿真模型搭建技巧与问题排查指南，特别涵盖新能源并网场景下的相位调节优化方案。通过实测数据验证，所建模型在稳态精度和动态响应方面均满足工程要求，为电力系统稳定性分析提供有

weixin_28278377的博客 272

项目开发中常见的工具类

1.获取随机数，四位或者六位,可用于验证码随机生成 package com.chang.commonutils; import java.text.DecimalFormat; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Random; /** * 获取随机数 * * @author qianyi * */ public class RandomUti

weixin_46258873的博客 317

工业视觉中HDR算法的动态范围优化与Debevec/Mertens方法实践

本文深入探讨了工业视觉中HDR（高动态范围）成像技术，重点解析了Debevec和Mertens两种核心算法。针对工业场景中因动态范围不足导致的过曝与欠曝问题，文章详细对比了两种方法的原理、实现步骤、参数调优及适用场景，为工程师在静态检测与高速产线等不同需求下，选择并实践HDR算法提供了清晰的指导。

weixin_29099217的博客 196

Windows上python的spark环境搭建

1.安装好JDK 下载并安装好jdk-12.0.1_windows-x64_bin.exe，配置环境变量： 新建系统变量JAVA_HOME，值为Java安装路径 新建系统变量CLASSPATH，值为 .;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;（注意最前面的圆点） 配置系统变量PATH，添加 %JAVA_HOME%bin;%JAVA_HOME%jrebin 在CMD中输入：java或者java -version，不显示不是内部命令等，说明安装成功。

weixin_43915303的博客 652

Android 開發 常見工具類收集

本文出自【张鸿洋的博客】：http://blog.csdn.net/lmj623565791/article/details/38965311， 打开大家手上的项目，基本都会有一大批的辅助类，今天特此整理出10个基本每个项目中都会使用的工具类，用于快速开发~~ 在此感谢群里给我发项目中工具类的兄弟/姐妹~ 1、日志工具类L.java [java] view plain

JLow 418

S32K144 ADC硬件触发实战：PDB与TRGMUX配置避坑指南

本文深入解析了S32K144微控制器中ADC硬件触发的两种核心方案：PDB与TRGMUX。通过对比其架构差异、详细配置流程及常见问题排查，提供了从寄存器操作到DMA联动的完整优化指南，旨在帮助开发者解决多通道采样时序不稳、CPU负载过高等实际难题，实现高效稳定的数据采集。

weixin_29168153的博客 444

java常用开发工具类大全,涵盖常见工作的问题（超赞）

原文：java常用开发工具类大全,涵盖常见工作的问题（超赞） 源代码下载地址：http://www.zuidaima.com/share/1845027886320640.htm /** *方法说明：实现service方法 *输入参数：HttpServletRequest req 客户请求对象 *输入参数：HttpServletResponse res 服务器应答对象

云淡风轻、仅此一抹 2745

FFmpeg 开发(01)：FFmpeg 编译和集成

尽管 FFmpeg 功能强大，但是由于其采用的是带有传染性的 LGPL/GPL 开源协议，所以一些大厂基本上都是自己独立开发类似的音视频处理库，甚至在接口和组织模块上模仿 FFmpeg 。

字节流动 1万+

第11节：GPU 线程层级：线程、线程块、网格

层级标识变量功能线程threadIdx执行单元，处理数据线程块blockIdx管理多个线程，提供共享内存网格管理多个 blockGPU 编程中，合理安排线程层级，是提升性能的关键。

yumeiguo的博客 212

业务开发常见问题-并发工具类

hello，大家好，本讲我们一起聊一下常见的几个并发工具类的使用和坑！在日常工作中，我们经常会遇到多线程并发问题，比如ThreadLocal、锁、ConcurrentHashMap、CopyOnWriteArrayList等。那么如何正常的使用呢？下面我们来一探究竟！

MichaelZ的博客 936

C# 上位机内存泄漏排查指南：3 个工具 + 4 个技巧，从 GC 频繁到稳定运行 720 小时

C# 上位机内存泄漏排查的核心是「先定位泄漏存在，再追溯引用根源，最后修复验证通过「Visual Studio 诊断工具（快速定位）+ dotMemory（深度分析）+ PerfView（生产监控）」三个工具的配合，结合「复现场景、排查静态成员+事件、检查非托管资源、GC 日志验证」四个技巧，可高效解决绝大多数泄漏问题。

这里只有干货：从 Modbus 通信到 MES 对接，从 YOLO 训练到工控机部署，带你搞定工业软件开发全流程。 739

JAVA开发常见工具类 ---- 日期工具类

import org.apache.commons.lang.StringUtils; import org.joda.time.DateTime; import org.joda.time.format.DateTimeFormat; import org.joda.time.format.DateTimeFormatter; import java.text.SimpleDateFormat...

xiaohui580 186

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目，保存在这里方便以后使用直接下载

假人有限元模型

假人模型，车辆碰撞假人有限元模型，适合做乘员安全的研究者利用

项目开发中DateUtils工具类常见方法

package com.chang.util; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; import java.util.GregorianCalendar; /** * * @ClassName: DateUtils * @Description: 日期工具类 默认使用 "yyyy-MM-dd HH:

weixin_46258873的博客 318

C# WinForm 基于DirectShow.dll编写的程序，可边预览边保存视频，音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择（默认选中第一个）2.可录制wmv和avi两种格式的视频并且都带有音频，avi可以录制的分辨率和帧数进行选择，wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照，也可边录制视频边拍照4.添加了视频和音频的压缩功能（酌情使用）这次二次开发发现C#对DirectShow的相关信息太少，这次做完也不敢藏私共享出来，还望大家指正

Java项目开发中常见的日期操作工具类封装

一、Java项目开发中常见的日期操作工具类封装 代码如下（示例）： import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.sql.Time; import java.text.SimpleDateFormat; import java.time.LocalDate; import java.time.LocalDateTime; import java.time.ZoneId; import java.time.form

boo程序员的博客 1419

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

四、实战——常见正则表达式书写\五、正则工具类开发

四、实战——常见症状表达式书写  1.实战应用 常见正则表达式书写：非空、手机号、Email地址…… 正则工具类开发及表单验证案例 仿smarty简易模板引擎 2.非空匹配 .+：匹配除了空格以外的原子一次或者无穷次 3.浮点数匹配 .前面的斜杠是转译符号 \d+\.\d{2}$，保留两位小数的正则表达式，如果有三位小数，则不符合规则 \d   匹配任意一个十进制数字，即[0-...

angryshan的博客 305

项目开发中StringUtil工具类常见方法

package com.chang.util; import java.io.ByteArrayOutputStream; import java.io.InputStream; import java.math.BigDecimal; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; import java.text.DecimalFormat; import java.util.Arra

weixin_46258873的博客 780

java开发中常见的工具类，方法等（持续更新）

/将item内容拷贝到新建的vo对象中。* 工具类向threadLocal存储诗句。//当前线程获取用户对象。//当前线程获取用户id。//先判断users集合是否为空。//获取当前用户手机号。//将用户对象，存入。

m0_73859807的博客 1976

Java的Collections工具类和Arrays工具类

详见 Collections 工具类和 Arrays 工具类常见方法总结

zengjyxxz的博客 203

Java 判空工具类

Java 判空工具类 import java.util.Collection; import java.util.Date; import java.util.Map; public class UtilValidate { private UtilValidate() { } public static boolean isEmpty(Object o) { return isEmptyUtil(o); } public static b

weixin_42116733的博客 568

MSP430常见问题之开发工具类

Q1：我自己做了一块MSP430F149的试验板，以前用下载线进行调试没有出现过问题，但是，最近我每次make后用下载线调试时，总是弹出一个窗口，给我提示：Could not find target status. 然后就死到那儿了，请问这是什么问题呢？A1：检查Jtag口线是否连接正常，如果JTAG口线连接正常，可能是供电不足，目标板加电再测试。 Q2：我用的430f22x学...

李肖遥的专栏 1671

项目中 常见工具类注入方式

项目中 常见工具类注入方式 一、构造器注入方式 public class TestUtils implements Runnable{ //添加所需service的私有成员 private IUserService iUserService; public TestUtils(IUserService iU...

三个小石头 1534

个人javaweb开发常见问题集锦<开发环境和开发工具类>[持续更新中……]

一、开发环境类： 二、开发工具类： 1：如何使用STS的svn插件。 如果：eclipse中svn插件,点项目右键team后,只显示Apply Patch,Share Project,Shar等，可以参照下面的文章进行解决。 https://zhidao.baidu.com/question/2120165300931985147.html

sanmubird的博客 246

Android快速开发不可或缺的11个工具类

Android快速开发不可或缺的11个工具类 ：http://www.devst ore.cn/code/info/363.html 转载于:https://www.cnblogs.com/zhjsll/p/4660549.html

weixin_30781107的博客 101

好用的Java工具类库大总结，提升开发效率必备

学习Java中有很多工具类库，业界标准类库，大公司内部也都在使用，简化代码量，提升效率，很多的初学者却不知道。

陈橘又青的博客 4415
上一篇： 我了解的开源网站和图片压缩网站
下一篇： nutz自定义sql查询
点赞 0
评论 0
书签 书签 0
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值