Java笔记17：JAVA常用函数

  1. **
  2. * 根据传入的格式获取日期
  3. *
  4. * @param format
  5. *            如:YYYYMMDD || MM/dd/yyyy, hh:mm:ss
  6. * @return 字符串的日期
  7. */
  8. public String getSysDate(String format) {
  9. String dateStr = "";
  10. try {
  11. Format formatter;
  12. Date date = new Date();
  13. formatter = new SimpleDateFormat(format);
  14. dateStr = formatter.format(date);
  15. } catch (Exception e) {
  16. System.out.println(e);
  17. }
  18. return dateStr;
  19. }
  20. /**
  21. * 根据传入的格式获取日期
  22. *
  23. * @param format
  24. *            如:YYYYMMDD || MM/dd/yyyy, hh:mm:ss
  25. * @return 字符串的日期
  26. */
  27. public String getFormatDate(Date date, String format) {
  28. String dateStr = "";
  29. try {
  30. Format formatter;
  31. formatter = new SimpleDateFormat(format);
  32. dateStr = formatter.format(date);
  33. } catch (Exception e) {
  34. System.out.println(e);
  35. }
  36. return dateStr;
  37. }
  38. /**
  39. * 获取分割后的字符串数组信息
  40. *
  41. * @param Str
  42. * @param Split
  43. * @return 字符串数组
  44. */
  45. public String[] getSplit(String Str, String Split) {
  46. return Str.split(Split);
  47. }
  48. /**
  49. * 把字符串转换成指定的日期格式
  50. *
  51. * @param str
  52. * @param format
  53. * @return
  54. */
  55. public Date Convert(String str, String format) {
  56. java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat(format);
  57. try {
  58. java.util.Date d = sdf.parse(str);
  59. return d;
  60. } catch (Exception ex) {
  61. ex.printStackTrace();
  62. return null;
  63. }
  64. }
  65. /**
  66. * 获取月的天数
  67. *
  68. * @param year
  69. * @param month
  70. * @return
  71. */
  72. public static int getdays(String year, String month) {
  73. int yearInt = Integer.parseInt(year);
  74. int monthInt = Integer.parseInt(month);
  75. int monthdays = 31;
  76. switch (monthInt) {
  77. case 1:
  78. case 3:
  79. case 5:
  80. case 7:
  81. case 8:
  82. case 10:
  83. case 12: {
  84. monthdays = 31;
  85. break;
  86. }
  87. case 2: {
  88. if (isLeapyear(yearInt)) {
  89. monthdays = 29;
  90. } else {
  91. monthdays = 28;
  92. }
  93. break;
  94. }
  95. case 4:
  96. case 6:
  97. case 9:
  98. case 11: {
  99. monthdays = 30;
  100. break;
  101. }
  102. }
  103. return monthdays;
  104. }
  105. /**
  106. * 判断闰年
  107. *
  108. * @param year
  109. * @return
  110. */
  111. public static boolean isLeapyear(int year) {
  112. if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) {
  113. return true;
  114. } else {
  115. return false;
  116. }
  117. }
  118. /**
  119. * 判断某天是星期几
  120. *
  121. * @param strDate
  122. * @return 0 表示是星期天
  123. */
  124. public static int getWeekByDate(String strDate) {
  125. int dayOfWeek = 0;
  126. try {
  127. SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
  128. Calendar calendar = Calendar.getInstance();
  129. Date date = new Date();
  130. date = sdf.parse(strDate);
  131. calendar.setTime(date);
  132. dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);
  133. } catch (Exception e) {
  134. e.printStackTrace();
  135. }
  136. return dayOfWeek - 1;
  137. }
  138. /**
  139. * 判断字符串是不是数字
  140. *
  141. * @param str
  142. * @return
  143. */
  144. public static boolean isNumeric(String str) {
  145. Pattern pattern = Pattern.compile("[0-9]*");
  146. Matcher isNum = pattern.matcher(str);
  147. if (!isNum.matches()) {
  148. return false;
  149. }
  150. return true;
  151. }
  152. /**
  153. * 获得距给定日期countday的字符串格式
  154. *
  155. * @param date
  156. * @param countday
  157. * @param flag
  158. *            为true表示日期前，为false表示日期后
  159. * @return YYYY-MM-DD
  160. */
  161. public String getDateString(Date date, int countday, boolean flag) {
  162. String datestr = "";
  163. if (flag) {
  164. datestr = getFormatDate(new Date((new Date()).getTime() - countday
  165. * 24 * 60 * 60 * 1000l), "yyyy-MM-dd");
  166. } else {
  167. datestr = getFormatDate(new Date((new Date()).getTime() + countday
  168. * 24 * 60 * 60 * 1000l), "yyyy-MM-dd");
  169. }
  170. return datestr;
  171. }
  172. /***************************************************************************
  173. * 根据两个时间判断时间差
  174. * @throws ParseException
  175. * @throws ParseException
  176. **************************************************************************/
  177. public Long getDateDifference(Date date1,Date date2) throws ParseException {
  178. //      Date date1 = new SimpleDateFormat("yyyy-mm-dd").parse("2008-3-31");
  179. //      Date date2 = new SimpleDateFormat("yyyy-mm-dd").parse("2008-3-30");
  180. // 日期相减得到相差的日期
  181. long day = (date1.getTime() - date2.getTime()) / (24 * 60 * 60 * 1000) > 0 ? (date1
  182. .getTime() - date2.getTime())
  183. / (24 * 60 * 60 * 1000)
  184. : (date2.getTime() - date1.getTime()) / (24 * 60 * 60 * 1000);
  185. return day;
  186. }
  187. /***************************************************************************
  188. * 根据两个时间来判断时间的差值
  189. * @param days
  190. * @return
  191. */
  192. public Long getDateDifference1(Date date1,Date date2) throws ParseException {
  193. // 日期相减得到相差的日期
  194. long day = (date1.getTime() - date2.getTime())/ (24 * 60 * 60 * 1000);
  195. return day;
  196. }
  197. /***************************************************************************
  198. * 返回当前时间的一个时间差时间
  199. * @param days
  200. * @return
  201. */
  202. public static String Ds(int days) {
  203. SimpleDateFormat form = new SimpleDateFormat("yyyy-MM-dd");
  204. Calendar calendar = Calendar.getInstance();
  205. int day = calendar.get(Calendar.DAY_OF_YEAR);
  206. calendar.set(Calendar.DAY_OF_YEAR, day - days);
  207. Date cc = calendar.getTime();
  208. return form.format(cc);
  209. }
  210. /*************************************************************************
  211. * 获取系统当前时间
  212. */
  213. public static Date getSystemDate(){
  214. SimpleDateFormat   sf   =   new   SimpleDateFormat("yyyy-MM-dd");
  215. Date   date   =   new   Date();
  216. try {
  217. return new SimpleDateFormat("yyyy-mm-dd").parse(sf.format(date));
  218. } catch (ParseException e) {
  219. }
  220. return null;
  221. }
  222. /**
  223. * 判断是否为整数
  224. *
  225. * @param str 传入的字符串
  226. * @return 是整数返回true,否则返回false
  227. */
  228. public static boolean isInteger(String str) {
  229. Pattern pattern = Pattern.compile("^[-//+]?[//d]*$");
  230. return pattern.matcher(str).matches();
  231. }
  232. /**
  233. * 判断是否为浮点数，包括double和float
  234. *
  235. * @param str 传入的字符串
  236. * @return 是浮点数返回true,否则返回false
  237. */
  238. public static boolean isDouble(String str) {
  239. Pattern pattern = Pattern.compile("^[-//+]?[.//d]*$");
  240. return pattern.matcher(str).matches();
  241. }
  242. /**
  243. * 判断输入的字符串是否符合Email样式.
  244. *
  245. * @param str 传入的字符串
  246. * @return 是Email样式返回true,否则返回false
  247. */
  248. public static boolean isEmail(String str) {
  249. Pattern pattern = Pattern.compile("^//w+([-+.]//w+)*@//w+([-.]//w+)*//.//w+([-.]//w+)*$");
  250. return pattern.matcher(str).matches();
  251. }
  252. /**
  253. * 判断输入的字符串是否为纯汉字
  254. *
  255. * @param str 传入的字符窜
  256. * @return 如果是纯汉字返回true,否则返回false
  257. */
  258. public static boolean isChinese(String str) {
  259. Pattern pattern = Pattern.compile("[/u0391-/uFFE5]+$");
  260. return pattern.matcher(str).matches();
  261. }
  262. /**
  263. * 是否为空白,包括null和""
  264. *
  265. * @param str
  266. * @return
  267. */
  268. public static boolean isBlank(String str) {
  269. return str == null || str.trim().length() == 0;
  270. }
  271. /**
  272. * 判断是否为质数
  273. *
  274. * @param x
  275. * @return
  276. */
  277. public static boolean isPrime(int x) {
  278. if (x <= 7) {
  279. if (x == 2 || x == 3 || x == 5 || x == 7)
  280. return true;
  281. }
  282. int c = 7;
  283. if (x % 2 == 0)
  284. return false;
  285. if (x % 3 == 0)
  286. return false;
  287. if (x % 5 == 0)
  288. return false;
  289. int end = (int) Math.sqrt(x);
  290. while (c <= end) {
  291. if (x % c == 0) {
  292. return false;
  293. }
  294. c += 4;
  295. if (x % c == 0) {
  296. return false;
  297. }
  298. c += 2;
  299. if (x % c == 0) {
  300. return false;
  301. }
  302. c += 4;
  303. if (x % c == 0) {
  304. return false;
  305. }
  306. c += 2;
  307. if (x % c == 0) {
  308. return false;
  309. }
  310. c += 4;
  311. if (x % c == 0) {
  312. return false;
  313. }
  314. c += 6;
  315. if (x % c == 0) {
  316. return false;
  317. }
  318. c += 2;
  319. if (x % c == 0) {
  320. return false;
  321. }
  322. c += 6;
  323. }
  324. return true;
  325. }
  326. /**
  327. * 人民币转成大写
  328. *
  329. * @param value
  330. * @return String
  331. */
  332. public static String hangeToBig(double value)
  333. {
  334. char[] hunit = { ‘拾‘, ‘佰‘, ‘仟‘ }; // 段内位置表示
  335. char[] vunit = { ‘万‘, ‘亿‘ }; // 段名表示
  336. char[] digit = { ‘零‘, ‘壹‘, ‘贰‘, ‘叁‘, ‘肆‘, ‘伍‘, ‘陆‘, ‘柒‘, ‘捌‘, ‘玖‘ }; // 数字表示
  337. long midVal = (long) (value * 100); // 转化成整形
  338. String valStr = String.valueOf(midVal); // 转化成字符串
  339. String head = valStr.substring(0, valStr.length() - 2); // 取整数部分
  340. String rail = valStr.substring(valStr.length() - 2); // 取小数部分
  341. String prefix = ""; // 整数部分转化的结果
  342. String suffix = ""; // 小数部分转化的结果
  343. // 处理小数点后面的数
  344. if (rail.equals("00"))
  345. { // 如果小数部分为0
  346. suffix = "整";
  347. }
  348. else
  349. {
  350. suffix = digit[rail.charAt(0) - ‘0‘] + "角" + digit[rail.charAt(1) - ‘0‘] + "分"; // 否则把角分转化出来
  351. }
  352. // 处理小数点前面的数
  353. char[] chDig = head.toCharArray(); // 把整数部分转化成字符数组
  354. char zero = ‘0‘; // 标志‘0‘表示出现过0
  355. byte zeroSerNum = 0; // 连续出现0的次数
  356. for (int i = 0; i < chDig.length; i++)
  357. { // 循环处理每个数字
  358. int idx = (chDig.length - i - 1) % 4; // 取段内位置
  359. int vidx = (chDig.length - i - 1) / 4; // 取段位置
  360. if (chDig[i] == ‘0‘)
  361. { // 如果当前字符是0
  362. zeroSerNum++; // 连续0次数递增
  363. if (zero == ‘0‘)
  364. { // 标志
  365. zero = digit[0];
  366. }
  367. else if (idx == 0 && vidx > 0 && zeroSerNum < 4)
  368. {
  369. prefix += vunit[vidx - 1];
  370. zero = ‘0‘;
  371. }
  372. continue;
  373. }
  374. zeroSerNum = 0; // 连续0次数清零
  375. if (zero != ‘0‘)
  376. { // 如果标志不为0,则加上,例如万,亿什么的
  377. prefix += zero;
  378. zero = ‘0‘;
  379. }
  380. prefix += digit[chDig[i] - ‘0‘]; // 转化该数字表示
  381. if (idx > 0)
  382. prefix += hunit[idx - 1];
  383. if (idx == 0 && vidx > 0)
  384. {
  385. prefix += vunit[vidx - 1]; // 段结束位置应该加上段名如万,亿
  386. }
  387. }
  388. if (prefix.length() > 0)
  389. prefix += ‘圆‘; // 如果整数部分存在,则有圆的字样
  390. return prefix + suffix; // 返回正确表示
  391. }
  392. /**
  393. * 全角字符转半角字符
  394. *
  395. * @param QJStr
  396. * @return String
  397. */
  398. public static final String QJToBJChange(String QJStr)
  399. {
  400. char[] chr = QJStr.toCharArray();
  401. String str = "";
  402. for (int i = 0; i < chr.length; i++)
  403. {
  404. chr[i] = (char) ((int) chr[i] - 65248);
  405. str += chr[i];
  406. }
  407. return str;
  408. }
  409. /**
  410. * 去掉字符串中重复的子字符串
  411. *
  412. * @param str
  413. * @return String
  414. */
  415. private static String removeSameString(String str)
  416. {
  417. Set<String> mLinkedSet = new LinkedHashSet<String>();
  418. String[] strArray = str.split(" ");
  419. StringBuffer sb = new StringBuffer();
  420. for (int i = 0; i < strArray.length; i++)
  421. {
  422. if (!mLinkedSet.contains(strArray[i]))
  423. {
  424. mLinkedSet.add(strArray[i]);
  425. sb.append(strArray[i] + " ");
  426. }
  427. }
  428. System.out.println(mLinkedSet);
  429. return sb.toString().substring(0, sb.toString().length() - 1);
  430. }
  431. /**
  432. * 根据指定方法的参数去构造一个新的对象的拷贝并将他返回
  433. * @param obj 原始对象
  434. * @return 新对象
  435. * @throws NoSuchMethodException
  436. * @throws InvocationTargetException
  437. * @throws IllegalAccessException
  438. * @throws InstantiationException
  439. * @throws SecurityException
  440. * @throws IllegalArgumentException
  441. */
  442. @SuppressWarnings("unchecked")
  443. public static Object copy(Object obj) throws IllegalArgumentException, SecurityException, InstantiationException, IllegalAccessException,
  444. InvocationTargetException, NoSuchMethodException
  445. {
  446. //获得对象的类型
  447. Class classType = obj.getClass();
  448. //通过默认构造方法去创建一个新的对象，getConstructor的视其参数决定调用哪个构造方法
  449. Object objectCopy = classType.getConstructor(new Class[]{}).newInstance(new Object[]{});
  450. //获得对象的所有属性
  451. Field[] fields = classType.getDeclaredFields();
  452. for(int i = 0; i < fields.length; i++)
  453. {
  454. //获取数组中对应的属性
  455. Field field = fields[i];
  456. String fieldName = field.getName();
  457. String stringLetter = fieldName.substring(0, 1).toUpperCase();
  458. //获得相应属性的getXXX和setXXX方法名称
  459. String getName = "get" + stringLetter + fieldName.substring(1);
  460. String setName = "set" + stringLetter + fieldName.substring(1);
  461. //获取相应的方法
  462. Method getMethod = classType.getMethod(getName, new Class[]{});
  463. Method setMethod = classType.getMethod(setName, new Class[]{field.getType()});
  464. //调用源对象的getXXX（）方法
  465. Object value = getMethod.invoke(obj, new Object[]{});
  466. //调用拷贝对象的setXXX（）方法
  467. setMethod.invoke(objectCopy, new Object[]{value});
  468. }
  469. return objectCopy;
  470. }
  471. //过滤特殊字符
  472. public static String encoding(String src){
  473. if (src==null)
  474. return "";
  475. StringBuilder result=new StringBuilder();
  476. if (src!=null){
  477. src=src.trim();
  478. for (int pos=0;pos<src.length();pos++){
  479. switch(src.charAt(pos)){
  480. case ‘/"‘:result.append("&quot;");break;
  481. case ‘<‘:result.append("&lt;");break;
  482. case ‘>‘:result.append("&gt;");break;
  483. case ‘/‘‘:result.append("&apos;");break;
  484. case ‘&‘:result.append("&amp;");break;
  485. case ‘%‘:result.append("&pc;");break;
  486. case ‘_‘:result.append("&ul;");break;
  487. case ‘#‘:result.append("&shap;");break;
  488. case ‘?‘:result.append("&ques;");break;
  489. default:result.append(src.charAt(pos));break;
  490. }
  491. }
  492. }
  493. return result.toString();
  494. }
  495. //反过滤特殊字符
  496. public static String decoding(String src){
  497. if (src==null)
  498. return "";
  499. String result=src;
  500. result=result.replace("&quot;", "/"").replace("&apos;", "/‘");
  501. result=result.replace("&lt;", "<").replace("&gt;", ">");
  502. result=result.replace("&amp;", "&");
  503. result=result.replace("&pc;", "%").replace("&ul", "_");
  504. result=result.replace("&shap;", "#").replace("&ques", "?");
  505. return result;
  506. }
  507. // toUtf8String将文件名转成GBK后再附到ContentDisposition
  508. public static String toUtf8String(String s) {
  509. StringBuffer sb = new StringBuffer();
  510. for (int i = 0; i < s.length(); i++) {
  511. char c = s.charAt(i);
  512. if (c >= 0 && c <= 255) {
  513. sb.append(c);
  514. } else {
  515. byte[] b;
  516. try {
  517. b = Character.toString(c).getBytes("utf-8");
  518. } catch (Exception ex) {
  519. System.out.println(ex);
  520. b = new byte[0];
  521. }
  522. for (int j = 0; j < b.length; j++) {
  523. int k = b[j];
  524. if (k < 0)
  525. k += 256;
  526. sb.append("%" + Integer.toHexString(k).toUpperCase());
  527. }
  528. }
  529. }
  530. return sb.toString();
  531. }
  532. /**
  533. * 对字节流进行GBK解码
  534. *
  535. * @param byteBuffer
  536. * @return
  537. */
  538. public static String decode(ByteBuffer byteBuffer) {
  539. Charset charset = Charset.forName("ISO-8859-1");
  540. CharsetDecoder decoder = charset.newDecoder();
  541. try {
  542. CharBuffer charBuffer = decoder.decode(byteBuffer);
  543. return new String(charBuffer.toString().getBytes("ISO8859_1"),
  544. "GBK").trim();
  545. } catch (Exception e) {
  546. return null;
  547. }
  548. }
  549. //实现百分比
  550. public String myPercent(int y, int z) {
  551. String baifenbi = "";// 接受百分比的值
  552. double baiy = y * 1.0;
  553. double baiz = z * 1.0;
  554. double fen = baiy / baiz;
  555. // NumberFormat nf = NumberFormat.getPercentInstance(); 注释掉的也是一种方法
  556. // nf.setMinimumFractionDigits( 2 ); 保留到小数点后几位
  557. DecimalFormat df1 = new DecimalFormat("##.00%"); // ##.00%
  558. // 百分比格式，后面不足2位的用0补齐
  559. // baifenbi=nf.format(fen);
  560. baifenbi = df1.format(fen);
  561. return baifenbi;
  562. }
  563. 正则表达式用于字符串处理、表单验证等场合，实用高效。现将一些常用的表达式收集于此，以备不时之需。
  564. 匹配中文字符的正则表达式： [/u4e00-/u9fa5]
  565. 评注：匹配中文还真是个头疼的事，有了这个表达式就好办了
  566. 匹配双字节字符(包括汉字在内)：[^/x00-/xff]
  567. 评注：可以用来计算字符串的长度（一个双字节字符长度计2，ASCII字符计1）
  568. 匹配空白行的正则表达式：/n/s*/r
  569. 评注：可以用来删除空白行
  570. 匹配HTML标记的正则表达式： <(/S*?)[^>]*>.*? <//1>  <.*? />
  571. 评注：网上流传的版本太糟糕，上面这个也仅仅能匹配部分，对于复杂的嵌套标记依旧无能为力
  572. 匹配首尾空白字符的正则表达式：^/s* /s*$
  573. 评注：可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式
  574. 匹配Email地址的正则表达式：/w+([-+.]/w+)*@/w+([-.]/w+)*/./w+([-.]/w+)*
  575. 评注：表单验证时很实用
  576. 匹配网址URL的正则表达式：[a-zA-z]+://[^/s]*
  577. 评注：网上流传的版本功能很有限，上面这个基本可以满足需求
  578. 匹配帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$
  579. 评注：表单验证时很实用
  580. 匹配国内电话号码：/d{3}-/d{8} /d{4}-/d{7}
  581. 评注：匹配形式如 0511-4405222 或 021-87888822
  582. 匹配腾讯QQ号：[1-9][0-9]{4,}
  583. 评注：腾讯QQ号从10000开始
  584. 匹配中国邮政编码：[1-9]/d{5}(?!/d)
  585. 评注：中国邮政编码为6位数字
  586. 匹配***：/d{15} /d{18}
  587. 评注：中国的***为15位或18位
  588. 匹配ip地址：/d+/./d+/./d+/./d+
  589. 评注：提取ip地址时有用
  590. 匹配特定数字：
  591. ^[1-9]/d*$　 　 //匹配正整数
  592. ^-[1-9]/d*$ 　 //匹配负整数
  593. ^-?[1-9]/d*$　　 //匹配整数
  594. ^[1-9]/d* 0$　 //匹配非负整数（正整数 + 0）
  595. ^-[1-9]/d* 0$　　 //匹配非正整数（负整数 + 0）
  596. ^[1-9]/d*/./d* 0/./d*[1-9]/d*$　　 //匹配正浮点数
  597. ^-([1-9]/d*/./d* 0/./d*[1-9]/d*)$　 //匹配负浮点数
  598. ^-?([1-9]/d*/./d* 0/./d*[1-9]/d* 0?/.0+ 0)$　 //匹配浮点数
  599. ^[1-9]/d*/./d* 0/./d*[1-9]/d* 0?/.0+ 0$　　 //匹配非负浮点数（正浮点数 + 0）
  600. ^(-([1-9]/d*/./d* 0/./d*[1-9]/d*)) 0?/.0+ 0$　　//匹配非正浮点数（负浮点数 + 0）
  601. 评注：处理大量数据时有用，具体应用时注意修正
  602. 匹配特定字符串：
  603. ^[A-Za-z]+$　　//匹配由26个英文字母组成的字符串
  604. ^[A-Z]+$　　//匹配由26个英文字母的大写组成的字符串
  605. ^[a-z]+$　　//匹配由26个英文字母的小写组成的字符串
  606. ^[A-Za-z0-9]+$　　//匹配由数字和26个英文字母组成的字符串
  607. ^/w+$　　//匹配由数字、26个英文字母或者下划线组成的字符串
  608. 评注：最基本也是最常用的一些表达式
  609. String.split()方法中，有时需要特殊字符，见下：
  610. /**
  611. * 点的转义：.  ==> //u002E
  612. 美元符号的转义：$  ==> //u0024
  613. 乘方符号的转义：^  ==> //u005E
  614. 左大括号的转义：{  ==> //u007B
  615. 左方括号的转义：[  ==> //u005B
  616. 左圆括号的转义：(  ==> //u0028
  617. 竖线的转义：| ==> //u007C
  618. 右圆括号的转义：) ==> //u0029
  619. 星号的转义：*  ==> //u002A
  620. 加号的转义：+  ==> //u002B
  621. 问号的转义：?  ==> //u003F
  622. 反斜杠的转义：/ ==> //u005C
  623. 竖线:    | ==>//u007C
  624. * */
时间： 2024-08-28 02:12:32

Java笔记17：JAVA常用函数的相关文章

java报表工具FineReport常用函数的用法总结（文本和日期函数）

FineReport是比较常用的java报表开发工具,本文总结了常用函数中的文本和日期函数 文本函数 CHAR CHAR(number):根据指定数字返回对应的字符.CHAR函数可将计算机其他类型的数字代码转换为字符. Number:用于指定字符的数字,介于1Number:用于指定字符的数字,介于165535之间(包括1和65535). 示例: CHAR(88)等于"X". CHAR(45)等于"-". CODE CODE(text):计算文本串中第一个字符的数字代

14.4-全栈Java笔记: javax.swing常用控件有哪些？怎么用？

常用基本控件 javax.swing.JButton 在图形界面程序中,按钮可能是使用量最大的控件之一,javax.swing包中JButton类就是用来创建按钮的.如表1所示,为JButton常用的构造方法.  javax.swing.JLabel JLabel控件是最简单的Swing组件之一,用于在窗体上显示标签, JLabel既可以显示文本,也可以显示图像.如表3所示,为JLabel常用的构造方法. 注意: JLabel只能用于显示文本和图标信息,用户不能对其进行修改. javax.swi

9.3-全栈Java笔记:List接口常用实现类的特点和底层实现

上节我们讲到「List接口的特点和常用方法」,本节接着上节的内容继续深入学习. 课前回顾:  List接口常用的实现类有3个:ArrayList.LinkedList.Vector. 那么它们的特点和底层实现有哪些呢? ArrayList特点和底层实现 ArrayList底层是用数组实现的存储. 特点:查询效率高,增删效率低,线程不安全.我们一般使用它. 查看源码,我们可以看出ArrayList底层使用Object数组来存储元素数据.所有的方法,都围绕这个核心的Object数组来开展. Arra

Java笔记十二.常用API-Hashtable类及其与HashMap、HashSet的区别

常用API-Hashtable类及其与HashMap.HashSet的区别 一.Hashtable<K,V>类 1.概述 Hashtable是一种高级数据结构,实现了一个Key-Value映射的哈希表,用以快速检索数据.Hashtable不仅可以像Vector一样动态存储一系列的对象,而且对存储的每一个值对象(值)都安排与另一个键对象(关键字)相关联,非null对象都可以被使用作为键对象或者值对象.为了能够成功从hashtable中存储和读取对象元素,实现键对象的类必须实现hashCode方法

15.1-全栈Java笔记：Java事件模型是什么？事件控制的过程有哪几步？？

应用前边两节上一章节的内容,大家可以完成一个简单的界面,但是没有任何的功能,界面完全是静态的,如果要实现具体功能的话,必须要学习事件模型. 事件模型简介及常见事件模型 对于采用了图形用户界面的程序来说,事件控制是非常重要的. 一个源(事件源)产生一个事件并把它(事件对象)送到一个或多个监听器那里,监听器只是简单地等待,直到它收到一个事件,一旦事件被接收,监听器将处理这些事件. 一个事件源必须注册监听器以便监听器可以接收关于一个特定事件的通知. 每种类型的事件都有其自己的注册方法,一般形式为: v

Java笔记：Java 流(Stream)、文件(File)和IO

更新时间:2018-1-7 12:27:21 更多请查看在线文集:http://android.52fhy.com/java/index.html java.io 包几乎包含了所有操作输入.输出需要的类.所有这些流类代表了输入源和输出目标. 输入输出流 简介 一个流被定义为一个数据序列.输入流用于从源读取数据,输出流用于向目标写数据. 下图是一个描述输入流和输出流的类层次图: 在java.io包中操作文件内容的主要有两大类:字节流.字符流,两类都分为输入和输出操作. 在字节流中输出数据主要是使用

Java中Math类常用函数总结

Java中比较常用的几个数学公式的总结: //取整,返回小于目标函数的最大整数,如下将会返回-2 Math.floor(-1.8): //取整,返回发育目标数的最小整数 Math.ceil() //四舍五入取整 Math.round() //计算平方根 Math.sqrt() //计算立方根 Math.cbrt() //返回欧拉数e的n次幂 Math.exp(3); //计算乘方,下面是计算3的2次方 Math.pow(3,2); //计算自然对数 Math.log(); //计算绝对值 Mat

java笔记-关于一些常用 且实用的开源包

作为一只从.net转java的程序猿..表示有些jdk原生的类很不习惯.. 1.时间处理 代替原生Calendar   joda-time 框架.地址https://github.com/JodaOrg/joda-time 2.Excel处理 原生没有  Apache POI 框架(强于jExcelAPI) 地址http://poi.apache.org/ 3.未完待续

java报表工具FineReport常用函数的用法总结（数学和三角函数）

ABS ABS(number):返回指定数字的绝对值.绝对值是指没有正负符号的数值. Number:需要求出绝对值的任意实数. 示例: ABS(-1.5)等于1.5. ABS(0)等于0. ABS(2.5)等于2.5. ACOS ACOS(number):返回指定数值的反余弦值.反余弦值为一个角度,返回角度以弧度形式表示. Number:需要返回角度的余弦值. 备注: 函数的参数必须在-1和1之间,包括-1和1. 返回的角度值在0和Pi之间. 如果要把返回的角度用度数来表示,用180/PI()乘