工具类,包装类,系统类,时间类,正则表达式

黑马程序员

---------------------- <a href="http://edu.csdn.net/heima" target="blank">android培训</a>、<a href="http://edu.csdn.net/heima" target="blank">java培训</a>、期待与您交流！ ----------------------

1. 工具类

1.Arrays 对数组的常用操作

binarySearch 二分法查找

copyOfRange 拷贝数组的一部分生成新数组

equals 判断数组中所有元素是否equals相等

fill 用一个指定元素填满数组

sort 对数组排序

toString 将数组转为字符串表示形式

import java.util.Arrays;

import java.util.Comparator;

import java.util.List;

import java.util.Random;

import cn.itcast.day18.domain.Person;

public class ArraysDemo {

public static void main(String[] args) {

// test1();

// test2();

// test3();

// test4();

// test5();

// test6();

// test7();

// test8();

}

private static void test8() {

Person[] arr = { new Person("ssb", 25), new Person("ycl", 23), new Person("gx", 24) };

System.out.println(Arrays.toString(arr)); // 打印数组中所有元素

Arrays.sort(arr, new Comparator<Person>() { // 排序

public int compare(Person o1, Person o2) {

int nameGap = o1.getName().compareTo(o2.getName());

return nameGap != 0 ? nameGap : o1.getAge() - o2.getAge();

}

});

System.out.println(Arrays.toString(arr));

}

private static void test7() {

int[] arr = new int[10];

for (int i = 0; i < arr.length; i++)

arr[i] = new Random().nextInt(100) + 1; // 生成1到100的随机数

System.out.println(Arrays.toString(arr)); // 打印数组中所有元素

Arrays.sort(arr); // 排序

System.out.println(Arrays.toString(arr));

}

private static void test6() {

int[] arr = new int[10]; // 0

Arrays.fill(arr, -1); // 用-1填满arr

System.out.println(Arrays.toString(arr));

}

private static void test5() {

Person[] arr1 = { new Person("沙 ", 22), new Person(" 成龙", 23), new Person("高 ", 24) };

Person[] arr2 = { new Person("沙 ", 22), new Person(" 成龙", 23), new Person("高 ", 24) };

System.out.println(equals(arr1, arr2));

}

private static boolean equals(Object[] arr1, Object[] arr2){

if (arr1 == arr2)

return true;

if (arr1 == null && arr2 != null)

return false;

if (arr2 == null && arr1 != null)

return false;

if (arr1.length != arr2.length)

return false;

for(int i = 0; i < arr1.length; i++)

if(!arr1[i].equals(arr2[i]))

return false;

return true;

}

private static void test4() {

int[] arr1 = { 1, 2, 3 };

int[] arr2 = { 1, 2, 3 };

System.out.println(arr1 == arr2); // false

System.out.println(arr1.equals(arr2)); // false

System.out.println(Arrays.equals(arr1, arr2)); // true, 比较两个数组中所有元素是否相同

}

private static int[] copyOfRange(int[] src, int from, int to){

if(from < 0 || from > src.length - 1 || to < from || to > src.length)

throw new IllegalArgumentException("索引越界");

int[] arr = new int[to - from]; // 按照需要的大小创建数组

int index = 0; // 定义一个变量, 代表数组的索引

for(int i = from; i < to; i++) // 从from循环到to

arr[index++] = src[i]; // 拷贝数据

return arr;

}

private static void test3() {

int[] arr = {100, 200, 300, 500, 800};

int[] newArr = copyOfRange(arr, 1, 4); // 从arr中拷贝, 1(包括)到4(不包括), 创建新数组

for (int i : newArr)

System.out.println(i);

}

private static void test2() {

int[] arr = {100, 200, 300, 500, 800};

System.out.println(Arrays.binarySearch(arr, 200));

System.out.println(Arrays.binarySearch(arr, 800));

System.out.println(Arrays.binarySearch(arr, 1000)); // -6, 负数代表没有, 6代表如果有, 应该在第6个

System.out.println(Arrays.binarySearch(arr, 400)); // -4, 代表没有, 有的话在第4个

}

private static void test1() {

Person[] arr = { new Person("沙 ", 22), new Person("闫成龙", 23), new Person("高旭", 24) };

List<Person> list = Arrays.asList(arr); // 将数组转为List

for (Person p : list)

System.out.println(p);

}

}

2.Collections 对集合的常用操作

addAll 向集合中添加多个元素

binarySearch 二分法查找

sort 对数组排序

fill 用一个指定元素填满数组

enumeration 从Collection中获取Enumeration

max 在Collection中查找最大元素

min 在Collection中查找最小元素

replaceAll 用指定元素替换原有元素

reverse 反转集合

swap 交换集合中两个元素

import java.util.ArrayList;

import java.util.Collections;

import java.util.Enumeration;

import cn.itcast.day18.domain.Person;

public class CollectionsDemo {

public static void main(String[] args) {

// test1();

// test2();

// test3();

// test4();

// test5();

// test6();

// test7();

// test8();

// test9();

// test10();

// test11();

// test12();

// test13();

}

private static void test13() {

ArrayList<Person> list = new ArrayList<Person>();

Collections.addAll(list, new Person("ycl", 23), new Person("gx", 24), new Person("ssb", 25), new Person("xsq", 21));

System.out.println(list);

Collections.swap(list, 0, 1);

System.out.println(list);

}

private static void test12() {

ArrayList<Person> list = new ArrayList<Person>();

Collections.addAll(list, new Person("ycl", 23), new Person("gx", 24), new Person("ssb", 25), new Person("xsq", 21));

Collections.sort(list); // 按照自然顺序排序

System.out.println(list);

}

private static void test11() {

ArrayList<Person> list = new ArrayList<Person>();

Collections.addAll(list, new Person("ycl", 23), new Person("gx", 24), new Person("ssb", 25), new Person("xsq", 21));

Collections.reverse(list); // 反转所有元素

System.out.println(list);

}

private static void test10() {

ArrayList<Person> list = new ArrayList<Person>();

Collections.addAll(list, new Person("ycl", 23), new Person("gx", 24), new Person("gx", 24));

Collections.replaceAll(list, new Person("gx", 24), new Person("ssb", 25)); // 替换

System.out.println(list);

}

private static void test9() {

ArrayList<Person> list = new ArrayList<Person>();

Collections.addAll(list, new Person("ycl", 23), new Person("gx", 24), new Person("ssb", 25), new Person("xsq", 21));

System.out.println(Collections.max(list)); // 找到最大的, 自然顺序

System.out.println(Collections.min(list)); // 最小的

}

private static void test8() {

ArrayList<Person> list1 = new ArrayList<Person>();

Collections.addAll(list1, new Person("ycl", 23), new Person("gx", 24), new Person("ssb", 25), new Person("xsq", 21));

ArrayList<Person> list2 = new ArrayList<Person>();

Collections.addAll(list2, new Person("gx", 24), new Person("ssb", 25));

System.out.println(Collections.indexOfSubList(list1, list2)); // 查找list2在list1中第一次出现的位置

}

private static void test7() {

ArrayList<Person> list = new ArrayList<Person>();

Collections.addAll(list, new Person("ycl", 23), new Person("gx", 24), new Person("gx", 24));

System.out.println(Collections.frequency(list, new Person("gx", 24))); // 判断指定对象的个数

System.out.println(Collections.frequency(list, new Person("ycl", 23)));

}

private static void test6() {

ArrayList<Person> list = new ArrayList<Person>();

Collections.addAll(list, new Person("ycl", 23), new Person("gx", 24), new Person("ssb", 25), new Person("xsq", 21));

Collections.fill(list, new Person(" 成龙", 23)); // 用指定对象替换集合中原有对象, 原来有几个就替换几个

System.out.println(list);

}

private static void test5() {

ArrayList<Person> list1 = new ArrayList<Person>();

Collections.addAll(list1, new Person("ycl", 23), new Person("gx", 24), new Person("ssb", 25), new Person("xsq", 21));

Enumeration<Person> e = Collections.enumeration(list1); // 从list1获取Enumeration

while(e.hasMoreElements())

System.out.println(e.nextElement());

}

private static void test4() {

ArrayList<Person> list1 = new ArrayList<Person>();

Collections.addAll(list1, new Person("ycl", 23), new Person("gx", 24), new Person("ssb", 25), new Person("xsq", 21));

ArrayList<Person> list2 = new ArrayList<Person>();

Collections.addAll(list2, new Person("沙 ", 22), new Person(" 成龙", 23), new Person("高 ", 24));

System.out.println(Collections.disjoint(list1, list2)); // 判断是否没有相同元素, equals()

}

private static void test3() {

ArrayList<Person> list1 = new ArrayList<Person>();

Collections.addAll(list1, new Person("ycl", 23), new Person("gx", 24), new Person("ssb", 25), new Person("xsq", 21));

ArrayList<Person> list2 = new ArrayList<Person>();

Collections.addAll(list2, new Person("沙 ", 22), new Person(" 成龙", 23), new Person("高 ", 24));

Collections.copy(list1, list2); // 用list2中的元素覆盖list1中的元素

System.out.println(list1);

}

private static void test2() {

ArrayList<Person> list = new ArrayList<Person>();

Collections.addAll(list, new Person("ycl", 23), new Person("gx", 24), new Person("ssb", 25));

System.out.println(Collections.binarySearch(list, new Person("ycl", 23)));

}

private static void test1() {

ArrayList<Person> list = new ArrayList<Person>();

Collections.addAll(list, new Person("ssb", 25), new Person("ycl", 23), new Person("gx", 24));

System.out.println(list);

}

}

2. 包装类

JDK提供了对所有数据类型的包装类

byte >>> Byte

short >>> Short

int >>> Integer

long >>> Long

double >>> Double

float >>> Float

char >>> Character

boolean >>> Boolean

包装类的常用方法

toString方法

parseInt方法：Integer.parseInt(String s)

valueOf方法：Double.valueOf(String s)

/*

* 基本数据类型和其对应的包装类可以混用

*

* Integer的缓冲区

* 由于程序中的Integer类型非常常见, 所以也提供了缓冲区

* 这个缓冲区是有大小的, 保存了-128到127之内的Integer

*

*/

public class ArithmeticDemo {

public static void main(String[] args) {

// test1();

// test2();

}

private static void test2() {

Integer i1 = -129;

Integer i2 = -129;

System.out.println(i1 == i2);

}

private static void test1() {

int i = 1 + 1;

System.out.println(i); // int --> Integer, Integer.toString()

Integer integer = new Integer(1) + new Integer(1); // 自动拆箱, Integer --> int

System.out.println(integer);

}

}

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Map;

/*

* 集合中只能存储对象, 不能存基本数据类型

* JDK5之后有了自动装箱和自动拆箱的机制, 可以将基本数据类型自动装换为其对应的包装类

* int可以当做Integer用, Integer也可以当做int用

*/

public class GenericDemo {

public static void main(String[] args) {

ArrayList<Integer> list = new ArrayList<Integer>();

list.add(1); // int --> Integer, JDK5之后自动装箱. list.add(new Integer(1));

list.add(2);

list.add(3);

Map<Character, Integer> map = new HashMap<Character, Integer>();

map.put('a', 1);

map.put('b', 3);

}

}

3. 系统类

System类

静态属性in为标准输入流，属于InputStream类型，read方法返回一个字节，默认指向键盘输入

静态属性out为标准打印流，属于PrintStream类型，print方法打印字符，默认打印到屏幕

可以用set方法修改属性in和out

System.exit()方法退出Java虚拟机

System.gc()垃圾回收，Java中的对象成为垃圾之后不会马上回收掉，如果想立即回收可以调用System.gc()

System.getProperties()方法获得系统属性

Runtime类

表示系统运行时状态

exec方法执行命令

import java.util.Enumeration;

import java.util.Properties;

public class SystemDemo {

public static void main(String[] args) {

// test1();

// test2();

// test3();

}

private static void test3() {

Properties prop = System.getProperties();

Enumeration<String> e = (Enumeration<String>) prop.propertyNames();

while(e.hasMoreElements()){

String name = e.nextElement();

System.out.println(name + " = " + prop.getProperty(name));

}

}

private static void test2() {

try{

System.out.println("try");

System.exit(0); // 退出程序, 即使finally也不会运行了

throw new RuntimeException();

}finally{

System.out.println("finally");

}

}

private static void test1() {

long start = System.nanoTime(); // 1毫秒 = 1/1000秒, 1纳秒 = 1/1000毫秒

for (int i = 0; i < 100; i++) {

}

long end = System.nanoTime();

System.out.println(end - start);

}

}

import java.io.IOException;

public class RuntimeDemo {

public static void main(String[] args) throws IOException {

// Runtime.getRuntime().exec("cmd /c F:/Itcast/20111015/day5-video/2.选择排序.avi");

// Runtime.getRuntime().exec("C:/Program Files/Tencent/QQ/Bin/QQ.exe");

// Runtime.getRuntime().exec("shutdown -s -t 300");

Runtime.getRuntime().exec("shutdown -a");

}

}

4. 时间类

Date类

使用new Date()创建时间对象代表当前系统时间

需要使用DateFormat类来进行格式化，才能显示想符合习惯的格式

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

public class DateDemo {

public static void main(String[] args) throws Exception {

// test1();

// test2();

// test3();

// test4();

// test5();

// test6();

}

private static void test6() {

Date date = new Date(2012, 12, 21); // 创建一个指定的时间

System.out.println(new SimpleDateFormat("E").format(date)); // 获取星期几

}

private static void test5() throws ParseException {

String s = "2012-12-21 00:00:00";

SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

Date date = format.parse(s); // 从字符串转为Date对象

System.out.println(date);

}

private static void test4() {

Date date = new Date(); // 创建Date对象

SimpleDateFormat format = new SimpleDateFormat("当前时间是: yyyy年MM月dd日 a hh时mm分ss秒SSS毫秒 E"); // 格式化工具

System.out.println(format.format(date)); // 将Date格式化成字符串

}

private static void test3() {

Date date = new Date();

System.out.println(date);

System.out.println(date.toLocaleString()); // 本地格式

System.out.println(date.toGMTString()); // 格林尼治时间

}

private static void test2() {

long time = 1320731579390L; // 毫秒值

long year = time / 1000 / 60 / 60 / 24 / 365; // 计算出经历了多少年

System.out.println(1970 + year); // 加上1970就是现在的年份

}

private static void test1() {

Date date = new Date(); // 创建了一个Date对象, 代表当前的瞬间

System.out.println(System.currentTimeMillis());

System.out.println(date.getTime()); // 1970年1月1日0时到这个Date对象代表的时间经历了多少毫秒

}

}

Calendar类

使用该类对时间进行操作比较方便

通过常量来表示时间的各种值，如一年中的某一天，一个月的某一天等

将对应的常量作为形参来调用相应的get、add、set方法来操作对象

练习

设计一个方法，计算某年是否是闰年？

设计一个方法可以计算工作时间，接收一个参数（工作日），方法打印出哪天完工。

import java.util.Calendar;

public class CalendarDemo {

public static void main(String[] args) {

countWorkDay(5); // 2011-11-15

countWorkDay(9); // 2011-11-21

}

/*

* 计算指定工作日之后的时间, 并打印

* 获取Calendar对象

* 循环n次, 每次将日历向后翻1天

* 判断当前是星期几, 如果是周六或周日, 就多加一天

*/

private static void countWorkDay(int n){

Calendar c = Calendar.getInstance();

for (int i = 0; i < n; i++) {

c.add(Calendar.DATE, 1);

if (c.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY || c.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY)

n++;

}

show(c);

}

/*

* 该方法判断指定的年份是否是闰年

* 获取Calendar对象, 将日历调整到指定年份的3月1日

* 将日历向前翻1天, 获取当前是几号

*/

private static boolean isLeapYear(int year){

Calendar c = Calendar.getInstance(); // 获取日历

c.set(year, 2, 1); // 设置到指定年3月1日

c.add(Calendar.DATE, -1); // 向前翻1天

return c.get(Calendar.DATE) == 29; // 判断这天是否是29号

}

private static void test1() {

Calendar c = Calendar.getInstance(); // 获取日历对象, 当前时间

show(c);

}

private static void add(Calendar c) {

c.add(Calendar.YEAR, -1); // 2010

c.add(Calendar.MONTH, 1); // 12

c.add(Calendar.DATE, -1); // 7

}

private static void set(Calendar c) {

c.set(Calendar.YEAR, 2012);

c.set(Calendar.MONTH, 11);

c.set(Calendar.DATE, 21);

}

private static void show(Calendar c) {

int year = c.get(Calendar.YEAR);

int month = c.get(Calendar.MONTH) + 1;

int date = c.get(Calendar.DATE);

int hour = c.get(Calendar.HOUR_OF_DAY);

int minute = c.get(Calendar.MINUTE);

int second = c.get(Calendar.SECOND);

int day = c.get(Calendar.DAY_OF_WEEK) - 1; // 星期日是0, 星期六时6

String[] arr = { "日", "一", "二", "三", "四", "五", "六" };

System.out.println( //

year + "年" + month + "月" + date + "日 " + hour + "时" + minute + "分" + second + "秒 星期" + arr[day]);

}

}

5. 正则表达式

基本说来，正则表达式是一种用来描述一定数量文本的模式。Regex代表Regular Express。本文将用<<regex>>来表示一段具体的正则表达式。

一段文本就是最基本的模式，简单的匹配相同的文本。

正则表达式:

用于字符串的操作。

正则的好处：

1，简化书写。

2，可以对字符进行复杂操作。

弊端：

当规则写的较多阅读性较差。

正则表达式其实就是用一些符号代替代码。

正则表达式对字符串的常见操作。

1，匹配。String matches方法。

2，切割。String split();

3，替换。String replaceAll();

4，获取。

通过Pattern对象来完成。

1，先要将规则编译成正则表达式对象。

通过Pattern对象的compile方法。

2，让正则和字符串相关联。获取对应的匹配器。

通过Pattern对象中的matcher方法。完成。该方法会返回一个匹配器对象。Matcher

3，通过Matcher对象的find方法，将正则作用到字符串上，进行扫描。

group可以获取符合规则的内容。

import java.util.*;

class RegexTest

{

public static void main(String[] args)

{

mailtest();

}

/*

我我......我我我....我要.要要....要要要....要学学...学学...编编...编编编...编程...程...程...程程

要求变成：我要学编程

1,去掉 . 替换。

2,将叠词一个字符 替换。

*/

public static void test1()

{

String str = "我我......我我我....我要.要要....要要要....要学学...学学...编编...编编编...编程...程...程...程程";

str = str.replaceAll("\\.+","");

System.out.println(str);

str = str.replaceAll("(.)\\1+","$1");

System.out.println(str);

}

/*

0010.10.10.10 00192.168.105.254 002.2.2.2 35.109.18.34 134.30.201.100

要求按照ip地址段的顺序对这些ip地址排序。

1,给ip的每一段补0，按照最大需求补。将每一个段都补两个0.

2，在保留每一段后三位。

*/

public static void iptest()

{

String ip = "10.10.10.10 192.168.105.254 2.20.0.2 35.109.18.34 134.30.201.100";

ip = ip.replaceAll("(\\d+)","00$1");

System.out.println(ip);

ip = ip.replaceAll("0*(\\d{3})","$1");

System.out.println(ip);

String[] ips = ip.split(" +");

TreeSet<String> ts = new TreeSet<String>();

for(String s : ips)

{

ts.add(s);

}

for(String s : ts)

{

System.out.println(s.replaceAll("0*(\\d+)","$1"));

}

}

/*

自定义email地址的匹配规则。abc@sina.com

*/

public static void mailtest()

{

String mail = "abc@sina.com.cn";

String mailreg = "[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[a-zA-Z]+)+";

mailreg = "\\w+@\\w+(\\.\\w+)+";//1@1.1

//mail.indexOf("@")!=-1// @

System.out.println("mail:"+mail.matches(mailreg));

}

}

import java.util.regex.*;

class RegexDemo

{

public static void main(String[] args)

{

getStr();

}

public static void getStr()

{

String str = "da jia hao , ming tian bu fang jia!";

System.out.println(str);

//获取该字符串中,由三个字母组成的单词。

String reg = "{3}\\b]\\b[a-z]{3}\\b";

Pattern p = Pattern.compile(reg);

//正则和字符串关联。获取匹配器。

Matcher m = p.matcher(str);

while(m.find())

{

String s = m.group();

System.out.println(s);

//System.out.println(m.start()+"..."+m.end());

}

}

public static void replaceStr()

{

String str = "zhsan######lisi---wna****gwu";

str = str.replaceAll("(.)\\1+","$1");

System.out.println(str);

}

public static void splitStr()

{

String str = "zhsan######lisi---wna****gwu";

String reg = "(.)\\1+";

String[] arr = str.split(reg);

for(String s :arr)

{

System.out.println("s="+s);

}

}

public static void checkTel()

{

String tel = "17800002222";

String reg = "1[35]\\d{9}";

System.out.println(tel.matches(reg));

}

public static void checkQQ()

{

String qq = "12345";

String reg = "[1-9]\\d{4,14}";

System.out.println(qq.matches(reg));

}

//需求对QQ号码进行校验：要去，必须是数字，5~15位。 0不可以开头。

public static void checkQQ_2(String qq)

{

int len = qq.length();

if(len>=5 && len<=15)

{

if(!qq.startsWith("0"))

{

try

{

long num = Long.parseLong(qq);

System.out.println("QQ号是："+num);

}

catch (NumberFormatException e)

{

System.out.println("非法");

}

/*

char[] arr = qq.toCharArray();

boolean b = true;

for(int x=0;x<arr.length; x++)

{

if(!(arr[x]>='0' && arr[x]<='9'))

{

b = false;

break;

}

}

if(b)

{

System.out.println("QQ号是："+qq);

}

else

{

System.out.println("出现非法字符");

}

*/

}

else

{

System.out.println("0不可以开头");

}

}

else

{

System.out.println("qq号码长度错误");

}

}

}

------------ <a href="http://edu.csdn.net/heima" target="blank">android培训</a>、<a href="http://edu.csdn.net/heima" target="blank">java培训</a>、期待与您交流！ -----------