Java_08 快速入门 Java常用类库
目录
第一章：Java常用类库
1.1 StringBuffer类
范例1-1：观察StringBuffer基本使用。
范例1-2：取得CharSequence接口实例化对象。
范例1-3：String与StringBuffer比较。
范例1-4：字符串反转。
范例1-5：在指定的索引位置增加数据。
范例1-6：删除部分数据。
正在上传…重新上传取消1.2 Runtime类
范例1-7：观察内存大小。
范例1-8：启动时设置内存大小。
范例1-9：观察gc()使用前后的内存占用率问题。
范例1-10：创建“mspaint.exe”（Windows的画板）进程
1.3 System类
范例1-11：请统计出某项操作的执行时间。
范例1-12：对象回收操作。
1.4 对象克隆
范例1-13：实现克隆操作。
1.5 数字操作类
范例1-14：观察四舍五入。
范例1-15：实现指定位数的四舍五入操作。
范例1-16：产生10个不大于100的正整数（0～99）。
范例1-17：实现36选7程序。
范例1-18：超过double数据范围的计算。
范例1-19：进行BigInteger的演示。
范例1-20：完成准确位的四舍五入操作。
1.6 日期处理类
范例1-21：取得当前的日期时间。
范例1-22：Date与long间的转换。
范例1-23：将日期格式化显示（Date型数据变为String型数据）。
范例1-24：将字符串转换为日期。
范例1-25：观察SimpleDateFormat的自动纠正。
范例1-26：取得当前的日期时间。
范例1-27：取得五天之后的日期。
1.7 比较器
范例1-28：实现二分查找。
范例1-29：数组相等比较。
范例1-30：数组填充。
范例1-31：实现对象数组排序。
范例1-32：利用Comparator接口实现对象数组排序。
范例1-33：修改测试程序。
1.8 正则表达式
范例1-34：实现字符串的判断。
范例1-35：利用正则表达式实现同样的验证。
范例1-36：实现字符串替换。
范例1-37：字符串拆分。
范例1-38：验证一个字符串是否是数字，如果是则将其变为double型。
范例1-39：判断给定的字符串是否是一个IP地址（IPV4）。
范例1-41：判断电话号码，一般要编写电话号码满足以下3种格式。
范例1-42：验证email地址，对于此验证假设有如下两种不同的格式要求。
范例1-43：利用Pattern类实现字符串拆分。
范例1-44：实现字符串验证操作。
1.9 反射机制
范例1-45：反射初步操作。
范例1-46：利用反射实例化对象。
范例1-47：利用反射实现工厂设计模式
范例1-48：错误的反射实例化操作。
范例1-49：明确调用类中的有参构造。
范例1-50：使用反射操作简单Java类的属性。
范例1-51：利用反射直接操作私有成员
1.10 国际化
范例1-52：输出Locale类对象。
范例1-53：直接使用Locale定义的常量对象。
范例1-54：定义com.yootk.demo.Messages.properties文件。
范例1-55：读取资源文件。
范例1-56：修改com.yootk.demo.Messages.properties定义。
范例1-57：读取数据并且动态设置内容。
范例1-58：定义中文资源文件——com.yootk.demo.Messages_zh_CN.properties。
范例1-59：定义英文（英语-美国）资源文件——com.yootk.demo.Messages_en_US.properties
范例1-60：读取资源文件。
第一章：Java常用类库
1.1 StringBuffer类
范例1-1：观察StringBuffer基本使用。
|
package com.yootk.demo; public class TestDemo { public static void main(String[] args) throws Exception { // String类可以直接赋值实例化，但是StringBuffer类不行 StringBuffer buf = new StringBuffer(); // 实例化StringBuffer类对象 buf.append("Hello ").append("MLDN ").append("!!"); change(buf); // 引用传递 System.out.println(buf); } public static void change(StringBuffer temp) { // 接收StringBuffer引用 temp.append("\n").append("www.yootk.com"); // 修改内容 } } |
范例1-2：取得CharSequence接口实例化对象。
|
package com.yootk.demo; public class TestDemo { public static void main(String[] args) throws Exception { CharSequence seq = "www.yootk.com"; // 向上转型 System.out.println(seq); // String类覆写的toString() } } |
范例1-3：String与StringBuffer比较。
|
package com.yootk.demo; public class TestDemo { public static void main(String[] args) throws Exception { StringBuffer buf = new StringBuffer("yootk"); System.out.println("yootk".contentEquals(buf)); } } |
范例1-4：字符串反转。
|
package com.yootk.demo; public class TestDemo { public static void main(String[] args) throws Exception { StringBuffer buf = new StringBuffer("www.yootk.com"); System.out.println(buf.reverse()); } } |
范例1-5：在指定的索引位置增加数据。
|
package com.yootk.demo; public class TestDemo { public static void main(String[] args) throws Exception { StringBuffer buf = new StringBuffer("yootk"); // 首先在最前面追加一个字符串，然后在指定位置追加字符串 buf.insert(0, "www.").insert(9, ".com"); System.out.println(buf); } } |
范例1-6：删除部分数据。
|
package com.yootk.demo; public class TestDemo { public static void main(String[] args) throws Exception { StringBuffer buf = new StringBuffer("Hello World MLDN"); System.out.println(buf.delete(5, 11)); } } |
1.2 Runtime类
范例1-7：观察内存大小。
|
package com.yootk.demo; public class TestDemo { public static void main(String[] args) throws Exception { Runtime run = Runtime.getRuntime(); // 取得Runtime类的实例化对象 System.out.println("MAX = " + run.maxMemory()); // 取得最大可用内存 System.out.println("TOTAL = " + run.totalMemory());// 取得全部可用内存 System.out.println("FREE = " + run.freeMemory()); // 取得空闲内存 } } |
范例1-8：启动时设置内存大小。
|
java -Xms1024M -Xmx1024M -Xmn512M com.yootk.demo.Test Demo |
范例1-9：观察gc()使用前后的内存占用率问题。
|
package com.yootk.demo; public class TestDemo { public static void main(String[] args) throws Exception { Runtime run = Runtime.getRuntime(); // 取得Runtime类的实例化对象 String str = ""; for (int x = 0; x < 2000; x++) { str += x; // 产生大量垃圾 } System.out.println("【垃圾处理前内存量】MAX = " + run.maxMemory()); System.out.println("【垃圾处理前内存量】TOTAL = " + run.totalMemory()); System.out.println("【垃圾处理前内存量】FREE = " + run.freeMemory()); run.gc(); // 释放垃圾空间 System.out.println("〖垃圾处理后内存量〗MAX = " + run.maxMemory()); System.out.println("〖垃圾处理后内存量〗TOTAL = " + run.totalMemory()); System.out.println("〖垃圾处理后内存量〗FREE = " + run.freeMemory()); } } |
范例1-10：创建“mspaint.exe”（Windows的画板）进程
|
package com.yootk.demo; public class TestDemo { public static void main(String[] args) throws Exception { Runtime run = Runtime.getRuntime(); // 取得Runtime类的实例化对象 Process pro = run.exec("mspaint.exe"); // 调用本机可执行程序 Thread.sleep(2000); // 运行2s后自动关闭 pro.destroy(); // 销毁进程 } } |
1.3 System类
范例1-11：请统计出某项操作的执行时间。
|
package com.yootk.demo; public class TestDemo { public static void main(String[] args) throws Exception { long start = System.currentTimeMillis(); // 取得开始时间 String str = ""; for (int x = 0; x < 30000; x++) { str += x; } long end = System.currentTimeMillis(); // 取得结束时间 System.out.println("本次操作所花费的时间：" + (end - start)); } } |
范例1-12：对象回收操作。
|
package com.yootk.demo; class Human { public Human() { System.out.println("欢天喜地，一个健康的孩子诞生了。"); } @Override protected void finalize() throws Throwable { // 覆写Object类方法 System.out.println("活了250年，到时候了！"); throw new Exception("此处即使抛出异常对象也不会产生任何影响！"); } } public class TestDemo { public static void main(String[] args) { Human mem = new Human(); // 实例化新的对象 mem = null; // 产生垃圾 System.gc(); // 手工处理垃圾收集 } } |
1.4 对象克隆
范例1-13：实现克隆操作。
|
package com.yootk.demo; class Book implements Cloneable { // 此类的对象可以被克隆 private String title; private double price; public Book(String title, double price) { this.title = title; this.price = price; } public void setTitle(String title) { this.title = title; } @Override public String toString() { return "书名：" + this.title + "，价格：" + this.price; } // 由于此类需要对象克隆操作，所以才需要进行方法的覆写 @Override public Object clone() throws CloneNotSupportedException { return super.clone(); // 调用父类的克隆方法 } } public class TestDemo { public static void main(String[] args) throws Exception { Book bookA = new Book("Java开发", 79.8); // 实例化新对象 Book bookB = (Book) bookA.clone(); // 克隆对象，开辟新的堆内存空间 bookB.setTitle("JSP开发"); // 修改克隆对象属性，不影响其他对象 System.out.println(bookA); System.out.println(bookB); } } |
1.5 数字操作类
范例1-14：观察四舍五入。
|
package com.yootk.demo; public class TestDemo { public static void main(String[] args) throws Exception { System.out.println(Math.round(15.5)); // 16 System.out.println(Math.round(-15.5)); // -15 System.out.println(Math.round(-15.51)); // -16 } } |
范例1-15：实现指定位数的四舍五入操作。
|
package com.yootk.demo; public class TestDemo { public static void main(String[] args) throws Exception { System.out.println(round(-15.678139,2)); // -15.68 } /** * 四舍五入操作，可以保留指定长度的小数位数 * @param num 要进行四舍五入操作的数字 * @param scale 保留的小数位 * @return 四舍五入之后的数据 */ public static double round(double num , int scale) { // Math.pow()的方法作用是进行10的N次方的计算 return Math.round(num * Math.pow(1.0, scale)) / Math.pow(1.0, scale); } } |
范例1-16：产生10个不大于100的正整数（0～99）。
|
package com.yootk.demo; import java.util.Random; public class TestDemo { public static void main(String[] args) throws Exception { Random rand = new Random() ; for (int x = 0 ; x < 10 ; x ++) { System.out.print(rand.nextInt(100) + "、"); } } } |
范例1-17：实现36选7程序。
|
package com.yootk.demo; import java.util.Random; public class TestDemo { public static void main(String[] args) throws Exception { Random rand = new Random(); int data[] = new int[7]; // 开辟一个7个元素的数组，保存生成数字 int foot = 0; // 此为数组操作脚标 while (foot < 7) { // 不确定循环次数，所以使用while循环 int t = rand.nextInt(37); // 生成一个不大于37的随机数 if (!isRepeat(data, t)) { // 重复 data[foot++] = t; // 保存数据 } } java.util.Arrays.sort(data); // 排序 for (int x = 0; x < data.length; x++) { System.out.print(data[x] + "、"); } } /** * 此方法主要是判断是否存在重复的内容，但是不允许保存0 * @param temp 指的是已经保存的数据 * @param num 新生成的数据 * @return 如果存在返回true，否则返回false */ public static boolean isRepeat(int temp[], int num) { if (num == 0) { // 没有必要判断了 return true; // 直接返回，随后的代码都不再执行 } for (int x = 0; x < temp.length; x++) { if (temp[x] == num) { return true; // 表示后面的数据不再进行判断 } } return false; } } |
范例1-18：超过double数据范围的计算。
|
package com.yootk.demo; public class TestDemo { public static void main(String[] args) throws Exception { System.out.println(Double.MAX_VALUE * Double.MAX_VALUE);// Infinity } } |
范例1-19：进行BigInteger的演示。
|
package cn.mldn.demo; import java.math.BigInteger; public class TestDemo { public static void main(String[] args) throws Exception { BigInteger bigA = new BigInteger("234809234801"); // 大数字A BigInteger bigB = new BigInteger("8939834789"); // 大数字B System.out.println("加法结果：" + bigA.add(bigB)); System.out.println("减法结果：" + bigA.subtract(bigB)); System.out.println("乘法结果：" + bigA.multiply(bigB)); System.out.println("除法结果：" + bigA.divide(bigB)); BigInteger result[] = bigA.divideAndRemainder(bigB); System.out.println("商：" + result[0] + "，余数：" + result[1]); } } |
范例1-20：完成准确位的四舍五入操作。
|
package cn.mldn.demo; import java.math.BigDecimal; class MyMath { public static double round(double num, int scale) { BigDecimal big = new BigDecimal(num); // 将数据封装在BigDecimal类中 BigDecimal result = big.divide(new BigDecimal(1), scale, BigDecimal.ROUND_HALF_UP); // 除法计算 return result.doubleValue(); // Number类的方法 } } public class TestDemo { public static void main(String[] args) throws Exception { System.out.println(MyMath.round(15.5, 0)); // 计算结果：16 System.out.println(MyMath.round(-15.5, 0)); // 计算结果：-15 System.out.println(MyMath.round(168.98765, 2)); // 计算结果：168.99 } } |
1.6 日期处理类
范例1-21：取得当前的日期时间。
|
package com.yootk.demo; import java.util.Date; public class TestDemo { public static void main(String[] args) throws Exception { Date date = new Date(); System.out.println(date); // 输出对象信息 } } |
范例1-22：Date与long间的转换。
|
package com.yootk.demo; import java.util.Date; public class TestDemo { public static void main(String[] args) throws Exception { long cur = System.currentTimeMillis(); // 取得当前的日期时间以long型返回 Date date = new Date(cur); // 将long转换为Date System.out.println(date); // 输出对象信息 System.out.println(date.getTime()); // 输出对象信息 } } |
范例1-23：将日期格式化显示（Date型数据变为String型数据）。
|
package com.yootk.demo; import java.text.SimpleDateFormat; import java.util.Date; public class TestDemo { public static void main(String[] args) throws Exception { Date date = new Date(); // 实例化Date类对象 // 实例化SimpleDateFormat类对象，同时定义好要转换的目标字符串格式 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS"); String str = sdf.format(date); // 将Date型变为String型 System.out.println(str); } } |
范例1-24：将字符串转换为日期。
|
package com.yootk.demo; import java.text.SimpleDateFormat; import java.util.Date; public class TestDemo { public static void main(String[] args) throws Exception { String str = "2005-07-27 07:15:22.111" ; // 字符串由日期时间组成 // 实例化SimpleDateFormat类对象，同时定义好要转换的目标字符串格式 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS") ; Date date = sdf.parse(str) ; // 将字符串变为日期型数据 System.out.println(date); } } |
范例1-25：观察SimpleDateFormat的自动纠正。
|
package com.yootk.demo; import java.text.SimpleDateFormat; import java.util.Date; public class TestDemo { public static void main(String[] args) throws Exception { String str = "2005-15-57 77:95:22.111" ; // 字符串由日期时间组成 // 实例化SimpleDateFormat类对象，同时定义好要转换的目标字符串格式 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS") ; Date date = sdf.parse(str) ; // 将字符串变为日期型数据 System.out.println(date); } } |
范例1-26：取得当前的日期时间。
|
package com.yootk.demo; import java.util.Calendar; public class TestDemo { public static void main(String[] args) throws Exception { Calendar cal = Calendar.getInstance(); // 取得本类对象 StringBuffer buf = new StringBuffer(); // 保存日期时间数据 buf.append(cal.get(Calendar.YEAR)).append("-"); // 取得年数据 buf.append(cal.get(Calendar.MONTH) + 1).append("-"); // 取得月数据，从0开始 buf.append(cal.get(Calendar.DAY_OF_MONTH)).append(" "); // 取得天数据 buf.append(cal.get(Calendar.HOUR_OF_DAY)).append(":"); // 取得小时数据 buf.append(cal.get(Calendar.MINUTE)).append(":"); // 取得分钟数据 buf.append(cal.get(Calendar.SECOND)); // 取得秒数据 System.out.println(buf); } } |
范例1-27：取得五天之后的日期。
|
package com.yootk.demo; import java.util.Calendar; public class TestDemo { public static void main(String[] args) throws Exception { Calendar cal = Calendar.getInstance(); // 取得本类对象 StringBuffer buf = new StringBuffer(); // 保存日期时间数据 buf.append(cal.get(Calendar.YEAR)).append("-"); // 取得年数据 buf.append(cal.get(Calendar.MONTH) + 1).append("-"); // 取得月数据，从0开始 buf.append(cal.get(Calendar.DAY_OF_MONTH) + 5).append(" "); // 取得5天后数据 buf.append(cal.get(Calendar.HOUR_OF_DAY)).append(":"); // 取得小时数据 buf.append(cal.get(Calendar.MINUTE)).append(":"); // 取得分钟数据 buf.append(cal.get(Calendar.SECOND)); // 取得秒数据 System.out.println(buf); } } |
1.7 比较器
范例1-28：实现二分查找。
|
package com.yootk.demo; import java.util.Arrays; public class TestDemo { public static void main(String[] args) throws Exception { int data[] = new int[] { 1, 5, 6, 2, 3, 4, 9, 8, 7, 10 }; java.util.Arrays.sort(data); // 数组必须排序才可以查找 System.out.println(Arrays.binarySearch(data, 9)); } } |
范例1-29：数组相等比较。
|
package com.yootk.demo; import java.util.Arrays; public class TestDemo { public static void main(String[] args) throws Exception { int dataA[] = new int[] { 1, 2, 3 }; // 定义A数组 int dataB[] = new int[] { 1, 2, 3 }; // 定义B数组 System.out.println(Arrays.equals(dataA, dataB)); // 比较是否相等 } } |
范例1-30：数组填充。
|
package com.yootk.demo; import java.util.Arrays; public class TestDemo { public static void main(String[] args) throws Exception { int data[] = new int[10]; // 动态开辟数组 Arrays.fill(data, 3); // 填充数组数据 System.out.println(Arrays.toString(data)); // 将数组变为字符串输出 } } |
范例1-31：实现对象数组排序。
|
package com.yootk.demo; import java.util.Arrays; class Book implements Comparable<Book> { // 实现比较器 private String title ; private double price ; public Book(String title,double price) { this.title = title ; this.price = price ; } @Override public String toString() { return "书名：" + this.title + "，价格：" + this.price + "\n" ; } @Override public int compareTo(Book o) { // Arrays.sort()会自动调用此方法比较 if (this.price > o.price) { return 1 ; } else if (this.price < o.price) { return -1 ; } else { return 0; } } } public class TestDemo { public static void main(String[] args) throws Exception { Book books [] = new Book [] { new Book("Java开发实战经典",79.8) , new Book("JavaWEB开发实战经典",69.8) , new Book("Oracle开发实战经典",99.8) , new Book("Android开发实战经典",89.8) } ; Arrays.sort(books); // 对象数组排序 System.out.println(Arrays.toString(books)); } } |
范例1-32：利用Comparator接口实现对象数组排序。
（1）定义一个类，此类不实现比较器接口。
|
package com.yootk.demo; class Book { private String title ; private double price ; public Book() {} public Book(String title,double price) { this.title = title ; this.price = price ; } @Override public String toString() { return "书名：" + this.title + "，价格：" + this.price + "\n" ; } public void setPrice(double price) { this.price = price; } public void setTitle(String title) { this.title = title; } public double getPrice() { return price; } public String getTitle() { return title; } } |
范例1-33：修改测试程序。
|
public class TestDemo { public static void main(String[] args) throws Exception { Book books [] = new Book [] { new Book("Java开发实战经典",79.8) , new Book("JavaWEB开发实战经典",69.8) , new Book("Oracle开发实战经典",99.8) , new Book("Android开发实战经典",89.8) } ; java.util.Arrays.sort(books,(o1,o2)->{ if (o1.getPrice() > o2.getPrice()) { return 1; } else if (o1.getPrice() < o2.getPrice()) { return -1; } else { return 0; } }); System.out.println(java.util.Arrays.toString(books)); } } |
1.8 正则表达式
范例1-34：实现字符串的判断。
|
package com.yootk.demo; public class TestDemo { public static void main(String[] args) throws Exception { String str = "123yootk"; System.out.println(isNumber(str)); } /** * 判断字符串是否由数字所组成，在本操作中首先将字符串转换为字符数组，然后循环判断每一位字符 * @param temp 要判断的字符串数据 * @return 如果字符串有非数字、为null、没有数据则返回false，正确返回true */ public static boolean isNumber(String temp) { if (temp == null || "".equals(temp)) { // 字符串数据为空 return false ; } char data[] = temp.toCharArray(); // 字符串变为字符数组 for (int x = 0; x < data.length; x++) { if (data[x] > '9' || data[x] < '0') { // 有一位字符不是数字 return false; // 有则返回false，结束判断 } } return true; } } |
范例1-35：利用正则表达式实现同样的验证。
|
package com.yootk.demo; public class TestDemo { public static void main(String[] args) throws Exception { String str = "123yootk"; System.out.println(str.matches("\\d+")); } } |
范例1-36：实现字符串替换。
|
package com.yootk.demo; public class TestDemo { public static void main(String[] args) throws Exception { String str = "hello*)(*()yootk(*#mldn*"; String regex = "[^a-z]"; // 此处编写正则 System.out.println(str.replaceAll(regex, "")); // 字符串替换 } } |
范例1-37：字符串拆分。
|
package com.yootk.demo; public class TestDemo { public static void main(String[] args) throws Exception { String str = "yootk9mldnyo8798o5555tk"; String regex = "\\d+"; // [0-9]一位以上 String result[] = str.split(regex); for (int x = 0; x < result.length; x++) { System.out.println(result[x]); } } } |
范例1-38：验证一个字符串是否是数字，如果是则将其变为double型。
提示：要转换的数字可能是整数（10）也可能是小数（1.2），但是绝对不允许出现非数字，并且小数点出现时应该有对应的小数位，正则规则分析分析如图1-6所示。
图1-6 正则规则分析
|
|
||
|
回答：转义字符操作。 本书第2章为读者讲解过转义字符的概念，其中“\\”描述的是“\”，所以如果要在字符串中定义“\”则必须使用“\\”，这也就是使用“\\d”（本质是“\d”）的原因了。 另外由于“.”可以描述所有的任务，所以也需要为其转义，而“\\.”描述的是“\.”的字符，实际上也属于转义操作。 |
在图1-6描述的正则规则中，整数位使用“\\d+”描述，表示一位以上的整数位。但是在设计小数位时由于存在小数点（“.”在正则中表示任意字符，所以必须使用“\\”转义）的问题，而且小数点与小数位应该作为整体出现，所以使用了“()”进行声明，而整个小数部分应该出现0次或1次，则使用“?”量词修饰。
|
package com.yootk.demo; public class TestDemo { public static void main(String[] args) throws Exception { String str = "1.10"; String regex = "\\d+(\\.\\d+)?"; if (str.matches(regex)) { // 转型之前要进行验证 System.out.println(Double.parseDouble(str)); } } } |
范例1-39：判断给定的字符串是否是一个IP地址（IPV4）。
提示：以“192.168.1.1”IP地址为例，每一个段可以包含的数字长度为1~3位。
|
package com.yootk.demo; public class TestDemo { public static void main(String[] args) throws Exception { String str = "192.168.1.1"; String regex = "\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}"; System.out.println(str.matches(regex)); } } |
范例1-40：给定一个字符串，要求判断其是否是日期格式，如果是则将其转换为Date型数据。本次只验证“年-月-日”的日期格式，其中年包含4位数字，月与日分别包含2位数字。
|
package com.yootk.demo; import java.text.SimpleDateFormat; import java.util.Date; public class TestDemo { public static void main(String[] args) throws Exception { String str = "2013-08-15"; String regex = "\\d{4}-\\d{2}-\\d{2}"; // 定义验证规则 if (str.matches(regex)) { // 符合规则 Date date = new SimpleDateFormat("yyyy-MM-dd").parse(str); System.out.println(date); } } } |
范例1-41：判断电话号码，一般要编写电话号码满足以下3种格式。
· 格式一：51283346，一般长度是7 ~ 8位的数字是电话号码（正则格式为：“\\d{7,8}”）；
· 格式二：01-51283346，区号一般是3 ~ 4位，而且区号和电话之间的“-”只有在出现区号时才出现，正则格式：“\\d{3,4}-)?\\d{7,8}”；
· 格式三：(010)-51283346，其中在区号前的括号必须成对出现，这样就需要将括号与区号一起显示，正则格式：“((\\d{3,4}-)|(\\(\\d{3,4}\\)-))?\\d{7,8}”）。
|
package com.yootk.demo; public class TestDemo { public static void main(String[] args) throws Exception { String str = "(010)-51283346"; String regex = "((\\d{3,4}-)|(\\(\\d{3,4}\\)-))?\\d{7,8}"; System.out.println(str.matches(regex)); } } |
范例1-42：验证email地址，对于此验证假设有如下两种不同的格式要求。
· 要求格式一：email由字母、数字、“_”（下划线）组成。简单email正则分析如图1-7所示。
图1-7 简单email正则分析
|
package com.yootk.demo; public class TestDemo { public static void main(String[] args) throws Exception { String str = "mldn_lixinghua100@yootk.com"; String regex = "\\w+@\\w+\\.\\w+"; System.out.println(str.matches(regex)); } } |
范例1-43：利用Pattern类实现字符串拆分。
|
package com.yootk.demo; import java.util.Arrays; import java.util.regex.Pattern; public class TestDemo { public static void main(String[] args) throws Exception { String str = "hello1yootk22mldn333lixinghua"; String regex = "\\d+"; Pattern pattern = Pattern.compile(regex); // 编译正则 String result[] = pattern.split(str); // 拆分字符串 System.out.println(Arrays.toString(result)); } } |
范例1-44：实现字符串验证操作。
|
package com.yootk.demo; import java.util.regex.Matcher; import java.util.regex.Pattern; public class TestDemo { public static void main(String[] args) throws Exception { String str = "100"; String regex = "\\d+"; Pattern pattern = Pattern.compile(regex); // 编译正则 Matcher mat = pattern.matcher(str); // 进行正则匹配 System.out.println(mat.matches()); // 匹配结果 } } |
1.9 反射机制
范例1-45：反射初步操作。
|
package com.yootk.demo; import java.util.Date; // 导入所需要的类 public class TestDemo { public static void main(String[] args) throws Exception { Date date = new Date(); // 产生实例化对象 System.out.println(date.getClass()); // 直接反射输出 } } |
范例1-46：利用反射实例化对象。
|
package com.yootk.demo; class Book { public Book() { System.out.println("********** Book类的无参构造方法 ***********"); } @Override public String toString() { return "《名师讲坛——Java开发实战经典》"; } } public class TestDemo { public static void main(String[] args) throws Exception { Class<?> cls = Class.forName("com.yootk.demo.Book"); // 设置要操作对象的类名称 // 反射实例化后的对象返回的结果都是Object类型 Object obj = cls.newInstance(); // 相当于使用new调用无参构造 Book book = (Book) obj; // 向下转型 System.out.println(book); } } |
范例1-47：利用反射实现工厂设计模式
|
package com.yootk.test; interface Fruit { public void eat() ; } class Apple implements Fruit { @Override public void eat() { System.out.println("** 吃苹果！"); } } class Orange implements Fruit { @Override public void eat() { System.out.println("** 吃橘子！"); } } class Factory { public static Fruit getInstance(String className) { Fruit f = null; try { // 反射实例化，子类对象可以使用Fruit接收 f = (Fruit) Class.forName(className).newInstance(); } catch (Exception e) {} // 此处为了方便不处理异常 return f; } } public class TestFactory { public static void main(String[] args) { // 直接传递类名称 Fruit fa = Factory.getInstance("com.yootk.test.Apple") ; Fruit fb = Factory.getInstance("com.yootk.test.Orange") ; fa.eat(); fb.eat(); } } |
范例1-48：错误的反射实例化操作。
|
package com.yootk.demo; class Book { private String title ; private double price ; public Book(String title, double price) { this.title = title ; this.price = price ; } @Override public String toString() { return "图书名称：" + this.title + "，价格：" + this.price ; } } public class TestDemo { public static void main(String[] args) throws Exception { Class<?> cls = Class.forName("com.yootk.demo.Book") ; Object obj = cls.newInstance() ; // 相当于使用new调用无参构造实例化 System.out.println(obj); } } |
范例1-49：明确调用类中的有参构造。
|
package com.yootk.demo; import java.lang.reflect.Constructor; class Book { private String title ; private double price ; public Book(String title, double price) { this.title = title ; this.price = price ; } @Override public String toString() { return "图书名称：" + this.title + "，价格：" + this.price ; } } public class TestDemo { public static void main(String[] args) throws Exception { Class<?> cls = Class.forName("com.yootk.demo.Book") ; // 明确地找到Book类中两个参数的构造，第一个参数类型是String，第二个是double Constructor<?> con = cls.getConstructor(String.class,double.class) ; Object obj = con.newInstance("Java开发实战经典",79.8) ; // 实例化对象，传递参数内容 System.out.println(obj); } } |
范例1-50：使用反射操作简单Java类的属性。
|
package com.yootk.demo; import java.lang.reflect.Method; class Book { private String title ; public void setTitle(String title) { this.title = title; } public String getTitle() { return title; } } public class TestDemo { public static void main(String[] args) throws Exception { String fieldName = "title" ; // 要操作的成员名称 Class<?> cls = Class.forName("com.yootk.demo.Book") ; // 取得要操作类的反射对象 Object obj = cls.newInstance() ; // 必须实例化对象 // 取得类中的setTitle()方法，由于title需要首字母大写，所以调用init()处理，参数类型为String Method setMet = cls.getMethod("set" + initcap(fieldName), String.class) ; // 取得类中的getTitle()方法，本方法不接收参数并且没有返回值类型声明 Method getMet = cls.getMethod("get" + initcap(fieldName)) ; setMet.invoke(obj, "Java开发实战经典") ; // 等价于：Book类对象.setTitle("Java开发实战经典") System.out.println(getMet.invoke(obj)); // 等价于：Book类对象.getTitle() } public static String initcap(String str) { // 首字母大写操作 return str.substring(0, 1).toUpperCase() + str.substring(1) ; } } |
范例1-51：利用反射直接操作私有成员
|
package com.yootk.demo; import java.lang.reflect.Field; class Book { // 为了演示，所以使用非标准简单Java类 private String title ; // 私有属性，并没有定义setter、getter方法 } public class TestDemo { public static void main(String[] args) throws Exception { Class<?> cls = Class.forName("com.yootk.demo.Book"); // 取得反射对象 Object obj = cls.newInstance(); // 必须给出实例化对象 Field titleField = cls.getDeclaredField("title"); // 取得类中的title属性 titleField.setAccessible(true); // 取消封装 titleField.set(obj, "Java开发实战经典"); // 相当于：Book类对象.title = "数据" System.out.println(titleField.get(obj)); // 相当于：Book类对象.title } } |
1.10 国际化
范例1-52：输出Locale类对象。
|
package com.yootk.demo; import java.util.Locale; public class TestDemo { public static void main(String[] args) throws Exception { Locale loc = Locale.getDefault() ; // 取得本地默认的Local对象 System.out.println(loc); // 直接输出loc对象 } } |
范例1-53：直接使用Locale定义的常量对象。
|
package com.yootk.demo; import java.util.Locale; public class TestDemo { public static void main(String[] args) throws Exception { Locale loc = Locale.CHINA ; // 中文语言环境 System.out.println(loc); } } |
范例1-54：定义com.yootk.demo.Messages.properties文件。
|
# （注释内容）yootk.info = 更多课程请访问：www.yootk.com yootk.info = \u66F4\u591A\u8BFE\u7A0B\u8BF7\u8BBF\u95EE\uFF1Awww.yootk.com |
范例1-55：读取资源文件。
|
package com.yootk.demo; import java.util.ResourceBundle; public class TestDemo { public static void main(String[] args) throws Exception { // 访问的时候一定不要加上后缀，因为默认找到的后缀就是“*.properties” // 此时的Messages.properties文件一定要放在CLASSPATH路径下 ResourceBundle rb = ResourceBundle.getBundle("com.yootk.demo.Messages"); System.out.println(rb.getString("yootk.info")); } } |
范例1-56：修改com.yootk.demo.Messages.properties定义。
|
# （注释内容）yootk.info = 更多课程请访问：{0}，讲师：{1} yootk.info = \u66F4\u591A\u8BFE\u7A0B\u8BF7\u8BBF\u95EE\uFF1A{0}\uFF0C\u8BB2\u5E08\uFF1A{1} |
范例1-57：读取数据并且动态设置内容。
|
package com.yootk.demo; import java.text.MessageFormat; import java.util.ResourceBundle; public class TestDemo { public static void main(String[] args) throws Exception { // 访问的时候一定不要加上后缀，因为默认找到的后缀就是“*.properties” // 此时的Messages.properties文件一定要放在CLASSPATH路径下 ResourceBundle rb = ResourceBundle.getBundle("com.yootk.demo.Messages"); System.out.println(MessageFormat.format(rb.getString("yootk.info"), "www.yootk.com", "李兴华")); // 设置两个占位符的内容 } } |
范例1-58：定义中文资源文件——com.yootk.demo.Messages_zh_CN.properties。
|
# （注释内容）yootk.info = 更多课程请访问：{0} yootk.info = \u66F4\u591A\u8BFE\u7A0B\u8BF7\u8BBF\u95EE\uFF1A{0} |
范例1-59：定义英文（英语-美国）资源文件——com.yootk.demo.Messages_en_US.properties
|
yootk.info = More courses, please click: {0} |
范例1-60：读取资源文件。
|
package com.yootk.demo; import java.text.MessageFormat; import java.util.Locale; import java.util.ResourceBundle; public class TestDemo { public static void main(String[] args) throws Exception { Locale zhLoc = new Locale("zh","CN") ; // 中国—中文 Locale enLoc = new Locale("en","US") ; // 英语—美国 ResourceBundle zhRB = ResourceBundle.getBundle( "com.yootk.demo.Messages", zhLoc); // 读取中文资源文件 ResourceBundle enRB = ResourceBundle.getBundle( "com.yootk.demo.Messages", enLoc); // 读取英文资源文件 // 读取资源内容，由于资源本身存在有一个占位符，所以需要设置相应的显示数据 System.out.println(MessageFormat.format(zhRB.getString("yootk.info"), "www.yootk.com")); System.out.println(MessageFormat.format(enRB.getString("yootk.info"), "www.yootk.com")); } } |
Java_08 快速入门 Java常用类库相关推荐
- Java常用类库以及简介，具体使用细节进行百度（爬虫爬取的数据）
来至于互联网 Office文档的Java处理包 POI [推荐] Apache POI是一个开源的Java读写Excel.WORD等微软OLE2组件文档的项目.目前POI已经有了Ruby版本. 结构: ...
- java 常用类库_JAVA（三）JAVA常用类库/JAVA IO
成鹏致远 |lcw.cnblog.com|2014-02-01 JAVA常用类库 1.StringBuffer StringBuffer是使用缓冲区的,本身也是操作字符串的,但是与String类不同, ...
- 视频教程-Spring boot快速入门-Java
Spring boot快速入门 十年项目开发经验,主要从事java相关的开发,熟悉各种mvc开发框架. 王振伟 ¥12.00 立即订阅 扫码下载「CSDN程序员学院APP」,1000+技术好课免费看 ...
- java学习_Java编程学习难不难 怎样才能快速入门Java
Java编程学习难不难?怎样才能快速入门Java?对于想要加入IT行业的人来说,Java是一个不错的选择,不仅人才需求大,就业薪资也非常不错.许多人都非常看好Java发展前景,接下来千锋小编就给大家介 ...
- Java好学吗？Java能做什么？如何快速入门Java?
Java是一门面向对象编程语言,不仅吸收了C++语言的各种优点,还摒弃了C++里难以理解的多继承.指针等概念,Java具有简单性.面向对象.分布式.健壮性.安全性.平台独立与可移植性.多线程.动态性等 ...
- 好程序员Java培训分享如何快速入门Java编程
好程序员Java培训分享如何快速入门Java编程,作为老牌编程语言,Java拥有广阔的市场应用,企业对Java人才的需求一直居高不下.有很多非专业.零基础的人想要学习Java却不知道怎么快速入门,接下 ...
- Java常用类库之String
Java常用类库之String学习与积累 概述 在学习Java时,我们知道Java的基本数据类型有整型的int,byte,short,long,字符型的char,布尔型的Boolean和浮点型的flo ...
- Java常用类库API
Java常用类库API 字符串操作 String类 String两种赋值方式 String类中的构造函数 String()方法 String(byte[] bytes)方法 String(byte[] ...
- 大数据技术之_20_Elasticsearch学习_01_概述 + 快速入门 + Java API 操作 + 创建、删除索引 + 新建、搜索、更新删除文档 + 条件查询 + 映射操作
大数据技术之_20_Elasticsearch学习_01 一 概述 1.1 什么是搜索? 1.2 如果用数据库做搜索会怎么样? 1.3 什么是全文检索和 Lucene? 1.4 什么是 Elastic ...
最新文章
- IsWow64的真实用途
- mysql 多表查询or_MySQL 多表查询
- Nhibernate 3.0 cookbook学习笔记 一对多与多对多映射
- pthread-win32 semaphore信号量总结
- MySQL高级 - 锁 - InnoDB行锁 - 类型
- SandyMandy ，绝世好BABY http://angel.mingox.com
- 华为就5G网络设备禁令起诉瑞典邮政和电信管理局
- python exec函数和eval函数_Python exec()和eval()的使用注意事项
- 编程中、遇到问题、bug多思考
- Markdown语法 (中文版)
- HP 打印机驱动安装报错Return code: 1603解决办法
- Python笔记五（写excel,加密模块，字典排序，常用的标准模块，操作mysql,时间模块）...
- Empty suite
- 2022·创新峰会回顾 | 擎创科技荣获CCID双料优秀成果奖
- 华大460 GPIO 例程赏析_20220911
- DNS（域名解析协议）详解
- 7-3 打印学生选课清单 (25分)
- jQuery——常用方法
- 互联网产品经理能力矩阵：基本能力之文档能力
- yolo cfg文件解析
热门文章
- 《领导沟通艺术与真实影响力》感想一
- 世界药王再遭“无间道”，药企如何保护自己的数据
- 相机平面与工作平面带夹角下的坐标换算
- 建筑师杰克帮你理解框架与模式
- 阿诺德·施瓦辛格的演讲（拼命才会优秀，自律才会自由~）
- 论文写作---word单独设置页眉页脚
- html给页面整体添加左右边距_DIV CSS padding内补白(内边距)left right top bottom案例教程...
- 我的世界斗罗封神服务器怎么注册,我的世界斗罗封神服务器-我的世界斗罗封神mod手机版v1.17.2.01-游戏宝手游网...
- docker命令介绍，镜像制作，容器启动，进入容器操作等
- 把C盘的用户Users文件移动到D盘最简单的方法【转】