`
入云涛
  • 浏览: 155977 次
  • 性别: Icon_minigender_1
  • 来自: 成都
社区版块
存档分类
最新评论

java常用函数收集

    博客分类：
  • java
Java正则表达式CC++C# 
阅读更多 
/**
 * 根据传入的格式获取日期
 * 
 * @param format
 *            如:YYYYMMDD || MM/dd/yyyy, hh:mm:ss
 * @return 字符串的日期
 */
public String getSysDate(String format) {
	String dateStr = "";
	try {
		Format formatter;
		Date date = new Date();
		formatter = new SimpleDateFormat(format);
		dateStr = formatter.format(date);
	} catch (Exception e) {
		System.out.println(e);
	}
	return dateStr;
}
/**
 * 根据传入的格式获取日期
 * 
 * @param format
 *            如:YYYYMMDD || MM/dd/yyyy, hh:mm:ss
 * @return 字符串的日期
 */
public String getFormatDate(Date date, String format) {
	String dateStr = "";
	try {
		Format formatter;
		formatter = new SimpleDateFormat(format);
		dateStr = formatter.format(date);
	} catch (Exception e) {
		System.out.println(e);
	}
	return dateStr;
}
/**
 * 获取分割后的字符串数组信息
 * 
 * @param Str
 * @param Split
 * @return 字符串数组
 */
public String[] getSplit(String Str, String Split) {
	return Str.split(Split);
}
/**
 * 把字符串转换成指定的日期格式
 * 
 * @param str
 * @param format
 * @return
 */
public Date Convert(String str, String format) {
	java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat(format);
	try {
		java.util.Date d = sdf.parse(str);
		return d;
	} catch (Exception ex) {
		ex.printStackTrace();
		return null;
	}
}
/**
 * 获取月的天数
 * 
 * @param year
 * @param month
 * @return
 */
public static int getdays(String year, String month) {
	int yearInt = Integer.parseInt(year);
	int monthInt = Integer.parseInt(month);
	int monthdays = 31;
	switch (monthInt) {
	case 1:
	case 3:
	case 5:
	case 7:
	case 8:
	case 10:
	case 12: {
		monthdays = 31;
		break;
	}
	case 2: {
		if (isLeapyear(yearInt)) {
			monthdays = 29;
		} else {
			monthdays = 28;
		}
		break;
	}
	case 4:
	case 6:
	case 9:
	case 11: {
		monthdays = 30;
		break;
	}
	}
	return monthdays;
}

/**
 * 判断闰年
 * 
 * @param year
 * @return
 */
public static boolean isLeapyear(int year) {
	if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) {
		return true;
	} else {
		return false;
	}
}

/**
 * 判断某天是星期几
 * 
 * @param strDate
 * @return 0 表示是星期天
 */
public static int getWeekByDate(String strDate) {
	int dayOfWeek = 0;
	try {

		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		Calendar calendar = Calendar.getInstance();
		Date date = new Date();
		date = sdf.parse(strDate);
		calendar.setTime(date);
		dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);
	} catch (Exception e) {
		e.printStackTrace();
	}
	return dayOfWeek - 1;
}
/**
 * 判断字符串是不是数字
 * 
 * @param str
 * @return
 */
public static boolean isNumeric(String str) {
	Pattern pattern = Pattern.compile("[0-9]*");
	Matcher isNum = pattern.matcher(str);
	if (!isNum.matches()) {
		return false;
	}
	return true;
}
/**
 * 获得距给定日期countday的字符串格式
 * 
 * @param date
 * @param countday
 * @param flag
 *            为true表示日期前，为false表示日期后
 * @return YYYY-MM-DD
 */
public String getDateString(Date date, int countday, boolean flag) {
	String datestr = "";
	if (flag) {
		datestr = getFormatDate(new Date((new Date()).getTime() - countday
				* 24 * 60 * 60 * 1000l), "yyyy-MM-dd");
	} else {
		datestr = getFormatDate(new Date((new Date()).getTime() + countday
				* 24 * 60 * 60 * 1000l), "yyyy-MM-dd");
	}
	return datestr;
}
/***************************************************************************
 * 根据两个时间判断时间差
 * @throws ParseException 
 * @throws ParseException 
 **************************************************************************/
public Long getDateDifference(Date date1,Date date2) throws ParseException {
//		Date date1 = new SimpleDateFormat("yyyy-mm-dd").parse("2008-3-31");
//		Date date2 = new SimpleDateFormat("yyyy-mm-dd").parse("2008-3-30");
	// 日期相减得到相差的日期
	long day = (date1.getTime() - date2.getTime()) / (24 * 60 * 60 * 1000) > 0 ? (date1
			.getTime() - date2.getTime())
			/ (24 * 60 * 60 * 1000)
			: (date2.getTime() - date1.getTime()) / (24 * 60 * 60 * 1000);
	return day;

}
/***************************************************************************
 * 根据两个时间来判断时间的差值
 * @param days
 * @return
 */
public Long getDateDifference1(Date date1,Date date2) throws ParseException {
	// 日期相减得到相差的日期
	long day = (date1.getTime() - date2.getTime())/ (24 * 60 * 60 * 1000);
	return day;
}
/***************************************************************************
 * 返回当前时间的一个时间差时间
 * @param days
 * @return
 */
public static String Ds(int days) {
	SimpleDateFormat form = new SimpleDateFormat("yyyy-MM-dd");
	Calendar calendar = Calendar.getInstance();
	int day = calendar.get(Calendar.DAY_OF_YEAR);
	calendar.set(Calendar.DAY_OF_YEAR, day - days);
	Date cc = calendar.getTime();
	return form.format(cc);
}
/*************************************************************************
 * 获取系统当前时间
 */
public static Date getSystemDate(){
	SimpleDateFormat   sf   =   new   SimpleDateFormat("yyyy-MM-dd");   
	Date   date   =   new   Date();                                                                 
	try {
		return new SimpleDateFormat("yyyy-mm-dd").parse(sf.format(date));
	} catch (ParseException e) {
	}
	return null;
}
 /**
   * 判断是否为整数
   * 
   * @param str 传入的字符串
   * @return 是整数返回true,否则返回false
   */
  public static boolean isInteger(String str) {
    Pattern pattern = Pattern.compile("^[-\\+]?[\\d]*$");
    return pattern.matcher(str).matches();
 }
/**
   * 判断是否为浮点数，包括double和float
   * 
   * @param str 传入的字符串
   * @return 是浮点数返回true,否则返回false
   */
  public static boolean isDouble(String str) {
    Pattern pattern = Pattern.compile("^[-\\+]?[.\\d]*$");
    return pattern.matcher(str).matches();
  }
/**
   * 判断输入的字符串是否符合Email样式.
   * 
   * @param str 传入的字符串
   * @return 是Email样式返回true,否则返回false
   */
  public static boolean isEmail(String str) {
    Pattern pattern = Pattern.compile("^\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*$");
    return pattern.matcher(str).matches();
  }
/**
   * 判断输入的字符串是否为纯汉字
   * 
   * @param str 传入的字符窜
   * @return 如果是纯汉字返回true,否则返回false
   */
  public static boolean isChinese(String str) {
    Pattern pattern = Pattern.compile("[\u0391-\uFFE5]+$");
    return pattern.matcher(str).matches();
  }

/**
   * 是否为空白,包括null和""
   * 
   * @param str
   * @return
   */
  public static boolean isBlank(String str) {
    return str == null || str.trim().length() == 0;
  }
/**
   * 判断是否为质数
   * 
   * @param x
   * @return
   */
  public static boolean isPrime(int x) {
    if (x <= 7) {
      if (x == 2 || x == 3 || x == 5 || x == 7)
        return true;
    }
    int c = 7;
    if (x % 2 == 0)
      return false;
    if (x % 3 == 0)
      return false;
    if (x % 5 == 0)
      return false;
    int end = (int) Math.sqrt(x);
    while (c <= end) {
      if (x % c == 0) {
        return false;
      }
      c += 4;
      if (x % c == 0) {
        return false;
      }
      c += 2;
      if (x % c == 0) {
        return false;
      }
      c += 4;
      if (x % c == 0) {
        return false;
      }
      c += 2;
      if (x % c == 0) {
        return false;
      }
      c += 4;
      if (x % c == 0) {
        return false;
      }
      c += 6;
      if (x % c == 0) {
        return false;
      }
      c += 2;
      if (x % c == 0) {
        return false;
      }
      c += 6;
    }
    return true;
  }
/**
     * 人民币转成大写
     * 
     * @param value
     * @return String
     */
    public static String hangeToBig(double value)
    {
        char[] hunit = { '拾', '佰', '仟' }; // 段内位置表示
        char[] vunit = { '万', '亿' }; // 段名表示
        char[] digit = { '零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖' }; // 数字表示
        long midVal = (long) (value * 100); // 转化成整形
        String valStr = String.valueOf(midVal); // 转化成字符串

        String head = valStr.substring(0, valStr.length() - 2); // 取整数部分
        String rail = valStr.substring(valStr.length() - 2); // 取小数部分

        String prefix = ""; // 整数部分转化的结果
        String suffix = ""; // 小数部分转化的结果
        // 处理小数点后面的数
        if (rail.equals("00"))
        { // 如果小数部分为0
            suffix = "整";
        }
        else
        {
            suffix = digit[rail.charAt(0) - '0'] + "角" + digit[rail.charAt(1) - '0'] + "分"; // 否则把角分转化出来
        }
        // 处理小数点前面的数
        char[] chDig = head.toCharArray(); // 把整数部分转化成字符数组
        char zero = '0'; // 标志'0'表示出现过0
        byte zeroSerNum = 0; // 连续出现0的次数
        for (int i = 0; i < chDig.length; i++)
        { // 循环处理每个数字
            int idx = (chDig.length - i - 1) % 4; // 取段内位置
            int vidx = (chDig.length - i - 1) / 4; // 取段位置
            if (chDig[i] == '0')
            { // 如果当前字符是0
                zeroSerNum++; // 连续0次数递增
                if (zero == '0')
                { // 标志
                    zero = digit[0];
                }
                else if (idx == 0 && vidx > 0 && zeroSerNum < 4)
                {
                    prefix += vunit[vidx - 1];
                    zero = '0';
                }
                continue;
            }
            zeroSerNum = 0; // 连续0次数清零
            if (zero != '0')
            { // 如果标志不为0,则加上,例如万,亿什么的
                prefix += zero;
                zero = '0';
            }
            prefix += digit[chDig[i] - '0']; // 转化该数字表示
            if (idx > 0)
                prefix += hunit[idx - 1];
            if (idx == 0 && vidx > 0)
            {
                prefix += vunit[vidx - 1]; // 段结束位置应该加上段名如万,亿
            }
        }

        if (prefix.length() > 0)
            prefix += '圆'; // 如果整数部分存在,则有圆的字样
        return prefix + suffix; // 返回正确表示
    }
/**
     * 全角字符转半角字符
     * 
     * @param QJStr
     * @return String
     */
    public static final String QJToBJChange(String QJStr)
    {
        char[] chr = QJStr.toCharArray();
        String str = "";
        for (int i = 0; i < chr.length; i++)
        {
            chr[i] = (char) ((int) chr[i] - 65248);
            str += chr[i];
        }
        return str;
    }
/**
     * 去掉字符串中重复的子字符串
     * 
     * @param str
     * @return String
     */
    private static String removeSameString(String str)
    {
        Set<String> mLinkedSet = new LinkedHashSet<String>();
        String[] strArray = str.split(" ");
        StringBuffer sb = new StringBuffer();

        for (int i = 0; i < strArray.length; i++)
        {
            if (!mLinkedSet.contains(strArray[i]))
            {
                mLinkedSet.add(strArray[i]);
                sb.append(strArray[i] + " ");
            }
        }
        System.out.println(mLinkedSet);
        return sb.toString().substring(0, sb.toString().length() - 1);
    }
/**   
     * 根据指定方法的参数去构造一个新的对象的拷贝并将他返回
     * @param obj 原始对象
     * @return 新对象
     * @throws NoSuchMethodException    
     * @throws InvocationTargetException    
     * @throws IllegalAccessException    
     * @throws InstantiationException    
     * @throws SecurityException    
     * @throws IllegalArgumentException    
     */
    @SuppressWarnings("unchecked")
    public static Object copy(Object obj) throws IllegalArgumentException, SecurityException, InstantiationException, IllegalAccessException,
                    InvocationTargetException, NoSuchMethodException
    {
        //获得对象的类型    
        Class classType = obj.getClass();

        //通过默认构造方法去创建一个新的对象，getConstructor的视其参数决定调用哪个构造方法    
        Object objectCopy = classType.getConstructor(new Class[]{}).newInstance(new Object[]{});

        //获得对象的所有属性    
        Field[] fields = classType.getDeclaredFields();

        for(int i = 0; i < fields.length; i++)
        {
            //获取数组中对应的属性    
            Field field = fields[i];

            String fieldName = field.getName();
            String stringLetter = fieldName.substring(0, 1).toUpperCase();

            //获得相应属性的getXXX和setXXX方法名称    
            String getName = "get" + stringLetter + fieldName.substring(1);
            String setName = "set" + stringLetter + fieldName.substring(1);

            //获取相应的方法    
            Method getMethod = classType.getMethod(getName, new Class[]{});
            Method setMethod = classType.getMethod(setName, new Class[]{field.getType()});

            //调用源对象的getXXX（）方法    
            Object value = getMethod.invoke(obj, new Object[]{});

            //调用拷贝对象的setXXX（）方法    
            setMethod.invoke(objectCopy, new Object[]{value});
        }

        return objectCopy;
    }

//过滤特殊字符
public static String encoding(String src){
        if (src==null)
            return "";
        StringBuilder result=new StringBuilder();
        if (src!=null){
            src=src.trim();
            for (int pos=0;pos<src.length();pos++){
                switch(src.charAt(pos)){
                    case '\"':result.append("&quot;");break;
                    case '<':result.append("&lt;");break;
                    case '>':result.append("&gt;");break;
                    case '\'':result.append("&apos;");break;
                    case '&':result.append("&amp;");break;
                    case '%':result.append("&pc;");break;
                    case '_':result.append("&ul;");break;
                    case '#':result.append("&shap;");break;
                    case '?':result.append("&ques;");break;
                    default:result.append(src.charAt(pos));break;
                }
            }
        }
        return result.toString();
    }
//反过滤特殊字符
    public static String decoding(String src){
        if (src==null)
            return "";
        String result=src;
        result=result.replace("&quot;", "\"").replace("&apos;", "\'");
        result=result.replace("&lt;", "<").replace("&gt;", ">");
        result=result.replace("&amp;", "&");
        result=result.replace("&pc;", "%").replace("&ul", "_");
        result=result.replace("&shap;", "#").replace("&ques", "?");
        return result;
    }
// toUtf8String将文件名转成GBK后再附到ContentDisposition
public static String toUtf8String(String s) {
	StringBuffer sb = new StringBuffer();
	for (int i = 0; i < s.length(); i++) {
		char c = s.charAt(i);
		if (c >= 0 && c <= 255) {
			sb.append(c);
		} else {
			byte[] b;
			try {
				b = Character.toString(c).getBytes("utf-8");
			} catch (Exception ex) {
				System.out.println(ex);
				b = new byte[0];
			}
			for (int j = 0; j < b.length; j++) {
				int k = b[j];
				if (k < 0)
					k += 256;
				sb.append("%" + Integer.toHexString(k).toUpperCase());
			}
		}
	}
	return sb.toString();
}
/**
     * 对字节流进行GBK解码
     * 
     * @param byteBuffer
     * @return
     */
    public static String decode(ByteBuffer byteBuffer) {
        Charset charset = Charset.forName("ISO-8859-1");
        CharsetDecoder decoder = charset.newDecoder();
        try {
            CharBuffer charBuffer = decoder.decode(byteBuffer);
            return new String(charBuffer.toString().getBytes("ISO8859_1"),
                    "GBK").trim();
        } catch (Exception e) {
            return null;
        }
    }
//实现百分比
public String myPercent(int y, int z) {
		String baifenbi = "";// 接受百分比的值
		double baiy = y * 1.0;
		double baiz = z * 1.0;
		double fen = baiy / baiz;
		// NumberFormat nf = NumberFormat.getPercentInstance(); 注释掉的也是一种方法
		// nf.setMinimumFractionDigits( 2 ); 保留到小数点后几位
		DecimalFormat df1 = new DecimalFormat("##.00%"); // ##.00%
															// 百分比格式，后面不足2位的用0补齐
		// baifenbi=nf.format(fen);
		baifenbi = df1.format(fen);
		return baifenbi;
	}
正则表达式用于字符串处理、表单验证等场合，实用高效。现将一些常用的表达式收集于此，以备不时之需。 

匹配中文字符的正则表达式： [\u4e00-\u9fa5] 
评注：匹配中文还真是个头疼的事，有了这个表达式就好办了 

匹配双字节字符(包括汉字在内)：[^\x00-\xff] 
评注：可以用来计算字符串的长度（一个双字节字符长度计2，ASCII字符计1） 

匹配空白行的正则表达式：\n\s*\r 
评注：可以用来删除空白行 

匹配HTML标记的正则表达式： <(\S*?)[^>]*>.*? </\1> ¦ <.*? /> 
评注：网上流传的版本太糟糕，上面这个也仅仅能匹配部分，对于复杂的嵌套标记依旧无能为力 

匹配首尾空白字符的正则表达式：^\s* ¦\s*$ 
评注：可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式 

匹配Email地址的正则表达式：\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)* 
评注：表单验证时很实用 

匹配网址URL的正则表达式：[a-zA-z]+://[^\s]* 
评注：网上流传的版本功能很有限，上面这个基本可以满足需求 

匹配帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$ 
评注：表单验证时很实用 

匹配国内电话号码：\d{3}-\d{8} ¦\d{4}-\d{7} 
评注：匹配形式如 0511-4405222 或 021-87888822 

匹配腾讯QQ号：[1-9][0-9]{4,} 
评注：腾讯QQ号从10000开始 

匹配中国邮政编码：[1-9]\d{5}(?!\d) 
评注：中国邮政编码为6位数字 

匹配身份证：\d{15} ¦\d{18} 
评注：中国的身份证为15位或18位 

匹配ip地址：\d+\.\d+\.\d+\.\d+ 
评注：提取ip地址时有用 

匹配特定数字： 
^[1-9]\d*$　 　 //匹配正整数 
^-[1-9]\d*$ 　 //匹配负整数 
^-?[1-9]\d*$　　 //匹配整数 
^[1-9]\d* ¦0$　 //匹配非负整数（正整数 + 0） 
^-[1-9]\d* ¦0$　　 //匹配非正整数（负整数 + 0） 
^[1-9]\d*\.\d* ¦0\.\d*[1-9]\d*$　　 //匹配正浮点数 
^-([1-9]\d*\.\d* ¦0\.\d*[1-9]\d*)$　 //匹配负浮点数 
^-?([1-9]\d*\.\d* ¦0\.\d*[1-9]\d* ¦0?\.0+ ¦0)$　 //匹配浮点数 
^[1-9]\d*\.\d* ¦0\.\d*[1-9]\d* ¦0?\.0+ ¦0$　　 //匹配非负浮点数（正浮点数 + 0） 
^(-([1-9]\d*\.\d* ¦0\.\d*[1-9]\d*)) ¦0?\.0+ ¦0$　　//匹配非正浮点数（负浮点数 + 0） 
评注：处理大量数据时有用，具体应用时注意修正 

匹配特定字符串： 
^[A-Za-z]+$　　//匹配由26个英文字母组成的字符串 
^[A-Z]+$　　//匹配由26个英文字母的大写组成的字符串 
^[a-z]+$　　//匹配由26个英文字母的小写组成的字符串 
^[A-Za-z0-9]+$　　//匹配由数字和26个英文字母组成的字符串 
^\w+$　　//匹配由数字、26个英文字母或者下划线组成的字符串 
评注：最基本也是最常用的一些表达式 

String.split()方法中，有时需要特殊字符，见下：
/**
* 点的转义：.  ==> \\u002E
 美元符号的转义：$  ==> \\u0024
 乘方符号的转义：^  ==> \\u005E
 左大括号的转义：{  ==> \\u007B
 左方括号的转义：[  ==> \\u005B
 左圆括号的转义：(  ==> \\u0028
 竖线的转义：| ==> \\u007C
 右圆括号的转义：) ==> \\u0029
 星号的转义：*  ==> \\u002A
 加号的转义：+  ==> \\u002B
 问号的转义：?  ==> \\u003F
 反斜杠的转义：\ ==> \\u005C
 竖线:	| ==>\\u007C
* */
分享到：
| js写文件
评论
发表评论

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

相关推荐

    Java多线程机制（讲述java里面与多线程有关的函数）

    9.1 Java中的线程： Java程序中的线程是在操作系统级别的线程基础上进行抽象的。每个Java程序都有一个主线程，即由JVM启动并执行main方法的线程。线程代表了程序中的执行流，可以在不同的线程之间切换以共享CPU时间...

    JAVA中常用的jar包

    "JAVA中常用的jar包"这个主题涵盖了一系列广泛使用的库，这些库不仅包括标准的标签库，还可能包含数据库驱动程序。下面我们将深入探讨这些关键知识点。 首先，标准标签库（Standard Taglib Library，通常称为JSTL）...

    java常用工具类集合（也有转自他人的）

    "java常用工具类集合"是一个综合性的资源，它包含了从不同来源收集的实用工具类，旨在帮助开发者提高效率，减少代码重复。下面，我们将深入探讨这个主题，分析其中可能包含的知识点。 首先，`opslabJutil-master....

    Java一些常用验证整理

    这里的【标题】"Java一些常用验证整理"和【描述】"Java一些常用验证整理，附有有关代码"指的是收集并整理了一些常见的Java验证方法。这些方法主要用于检查用户输入、数据交换等场景中的字符串格式，以确保其合法性。...

    几百个常用的 API 函数的简介

    在编程世界中，API（应用程序接口）是一组预先定义的函数、类、对象和常量，它们为开发者提供了与操作系统、库或服务交互的能力。API 函数是这些接口中的核心部分，它们允许程序员通过调用特定函数来实现特定功能，...

    Java常用代码全集.7z

    此外，文件可能还会包含异常处理（try-catch-finally语句）、接口和抽象类的使用示例，这些都是Java中重要的错误管理和设计模式的基础。 在集合框架方面，文件可能涵盖了ArrayList、LinkedList、HashMap、HashSet等...

    java常用字符串方法网络收集txt版

    1. **字符串类(String)**：Java中的字符串是不可变的，这意味着一旦创建了一个字符串对象，就不能改变其内容。字符串对象是通过`String`类创建的，例如`String str = "Hello, World!";`。 2. **创建字符串**：除了...

    java常用技术整理.rar

    4. **集合框架**：ArrayList、LinkedList、HashSet、HashMap等是Java中最常用的集合类，理解它们的特性、操作和适用场景非常重要。 5. **多线程**：Java提供了内置的多线程支持，包括Thread类和Runnable接口，线程...

    java常用字符串方法，网络收集，txt版

    本资源"java常用字符串方法，网络收集，txt版"主要整理了Java中常用的字符串处理方法，这对于Java程序员来说是一份宝贵的参考资料。下面，我们将详细探讨这些方法，并结合实例进行讲解。 1. **创建字符串** - `...

    java常用单词java常用单词.doc

    6. **system** - 在Java中，System类提供了系统级的函数，如标准输入、输出流。 7. **out** - System类的一个静态字段，通常与`println()`方法一起使用，用于输出信息到控制台。 8. **print** - 输出数据到指定的...

    JAVA 常用的jar包(全)

    在Java开发中，`jar`（Java Archive）文件是一种打包格式，用于收集多个类文件、相关的元数据和资源文件，以便作为一个单元分发。这里提到的"JAVA 常用的jar包(全)"可能是一个包含多种常用Java库的集合，方便开发者...

    java学习中收集的有用资料

    3. **异常处理**：Java中的异常处理机制允许程序优雅地处理错误情况，通过try-catch-finally块捕获和处理异常，可以防止程序意外终止。 4. **集合框架**：Java集合框架包括List、Set、Map接口和它们的实现类，如...

    java常用英语

    - **Print**: 打印，Java中常用的输出方式之一。 - **Import**: 导入，用于在Java程序中引入其他类或包。 - **Graphics**: 图形，Java中的图形处理类，用于绘图。 - **Extend**: 扩展，Java中的继承关键字，用于创建...

    JAVA基础加强 --学习心得一(JAVA中常用英文单词简写释义).pdf

    在学习JAVA基础的过程中，了解并掌握一些常用的英文缩写是非常重要的。这些缩写不仅代表着JAVA技术的核心概念，也是深入理解JAVA平台和应用开发的关键。以下是一些重要术语的详细解释： 1. **API (Application ...

    Java常用代码大全.7z

    "Java常用代码大全.7z"这个压缩包很可能是为了帮助开发者收集和整理了一系列常见的Java编程代码片段，以便在开发过程中快速参考和使用。文档中的内容可能涵盖了各种Java编程的基础到进阶知识点。 在Java编程中，...

    Spark常用的算子以及Scala函数总结.pdf

    16. collect(): 将分布式数据集中的元素收集到驱动程序中，返回一个数组。 除了上述的算子外，Scala 本身还提供许多强大的函数式编程特性，比如高阶函数、集合操作、模式匹配等，这些特性在 Spark 编程中也能得到...

    常用JAVA面试题库

    以下是一些基于"常用JAVA面试题库"的详细知识点解析： 1. **Java基础** - **数据类型**：Java有8种基本数据类型，分为整型、浮点型、字符型和布尔型。面试中可能会询问它们的范围和表示方式。 - **变量与常量**：...

    近几年JAVA面试常用知识点.docx

    这是Java中基本的面向对象编程示例。 1.1.2 继承 继承允许一个类（子类）继承另一个类（父类）的属性和方法。在`Animal`和`Cat`的例子中，`Cat`类继承自`Animal`，并重写了`eat()`方法，表现出多态性。这样，`Cat`...

    收集的java小程式

    Java中的多态主要体现在方法的重载（overloading）和重写（overriding）。 6. **异常处理**：Java提供了强大的异常处理机制，通过try-catch-finally语句块来捕获和处理运行时错误，保证程序的健壮性。 7. **集合...

    Java面试题大全.pdf

    - Java中构造函数（Constructor）的使用，包括构造函数重载。 - Java类中的方法重写（Override）和方法重载（Overload）的区别。 - Java中String类的不可变性以及String、StringBuffer和StringBuilder的区别和...

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