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

来源：互联网发布：青春帅哥新浪博客乐乎编辑：程序博客网时间：2024/06/06 06:31

黑马程序员

---------------------- <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 = "\\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>、期待与您交流！ -----------