常用类库

最新推荐文章于 2022-11-30 16:42:04 发布

小方f

最新推荐文章于 2022-11-30 16:42:04 发布

阅读量255

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_43511745/article/details/107570249

版权

7. java中的常用类库

7.1String,StringBuffer,StringBuilder如何创建对象？有哪些常用方法？相互转换【String与基本数据类型 / String与字节数组/字符数组】？

字符串是程序中使用最广泛，处理最多的数据，因此java就提供了专门针对字符串处理的java类。
在学习这个java类之前我们需要先认识一些java的帮助文件【jdk_api】

API–应用程序接口。【提供java中常用的类和接口的使用规范】帮助文件。

Java中的字符串java提供的一个java类。

java.lang.String由于String类是属于java.lang包，因此在使用的时候不需要导包。

2.String类的定义

public final class String

extends Object

implements Serializable, ComparableString, CharSequence

使用了final 修饰符，说明String类没有子类，不可被继承。
实现了implements Serializable, ComparableString, CharSequence

3.String类的使用

1.可以像基本数据类型使用方式一样创建对象。

int a=100;
String s=”hello”;  ”hello”--字符串常量

2.可以通过String类提供的构造方法创建对象

String常用构造方法:

String() 创建一个空字符串对象。

String(String original) 通过指定的字符串常量，创建一个字符串对象。

String(byte[] bytes, int offset, int length)通过字节数组创建一个字符串对象。【字节数组转换成字符串】。

String(char[] value, int offset, intcount) 通过字符数组创建一个字符串对象。【字符数组转换成字符串】。

例如：

package com.click369.test1;
public class StringTest1 {
     public static void main(String[] args) {
         //String的对象创建
         //1.可以像基本数据类型使用方式一样创建对象。
         String s1="hello";
         //2.可以通过String类提供的构造方法创建对象
    /*
     \* 常用构造方法:
         String() 创建一个空字符串对象。
         String(String original) 通过指定的字符串常量，创建一个字符串对象。
         String(byte[] bytes, int offset, int length)通过字节数组创建一个字符串对象。【字节数组转换成字符串】。
         //byte[] bytes---被转换的字节数组
         //int offset---字节数组转换数据的起始位置

         //int length---被转换的个数

         //将字节数组中的数字值转换成了字符串

         String(char[] value, int offset, int count) 通过字符数组创建一个字符串对象。【字符数组转换成字符串】。

    //char[] value---被转换的字符数组

        //int offset---字符数组转换数据的起始位置

         //int count---被转换的个数
     */
         String s2=new String();
         String s3=new String("hello");
         byte bytes[]={97,98,99,100};
         String s4=new String(bytes,0,4);
         System.out.println("s4=="+s4);
         char value[]={'h','e','l','l','o'};
         String s5=new String(value,0,value.length);
         System.out.println("s5=="+s5);
  }
}

String类中常用方法的使用：

1.public char charAt(int index)得到原始字符串的指定位置[从0开始]的字符
2.public byte[] getBytes(String charsetName)
public byte[] getBytes()
3.public boolean equals(Object anObject)
4.public boolean equalsIgnoreCase(String anotherString)不考虑大小写
5.public boolean startsWith(String prefix)
6.public boolean endsWith(String suffix)
7.public int indexOf(String str)
8.public int lastIndexOf(String str)
9.public String substring(int beginIndex)
public String substring(int beginIndex,int endIndex)
10.public String concat(String str)
11.public String replace(String oldChar,String newChar)
12.public boolean matches(String regex) 匹配正则表达式
13.public boolean contains(String s)
14.public String[] split(String regex)
15.public String toLowerCase()转换为小写
16.public String toUpperCase()
17.public String trim()
18.public char[] toCharArray()

例如：

package com.click369.test1;
public class StringTest2 {
     public static void main(String[] args) {
         String s1=new String("hello,world");
         //public char charAt(int index)得到原始字符串的指定位置[从0开始]的字符
         char ch=s1.charAt(5);
         System.out.println("ch=="+ch); //,
         //public byte[] getBytes(String charsetName)将原始字符按照指定字符编码转换成字节数组。
         //charsetName--字符编码【utf-8,GBK,GB2312...】
         //public byte[] getBytes()将原始字符换成字节数组。
         byte bytes[]=s1.getBytes();
         for(byte b:bytes){
             System.out.println("b=="+b);
         }
         //?????????
         //public boolean equals(Object anObject)比较两个字符串是否相等。
         boolean b=s1.equals("hello,world");
         System.out.println("b=="+b);
         //public boolean equalsIgnoreCase(String anotherString)比较两个字符串是否相等,不考虑大小写
         boolean b1=s1.equalsIgnoreCase("HELLO,world");
         System.out.println("b1=="+b1);
         //public boolean startsWith(String prefix)前缀匹配【从一组用户名中得到所有姓李的用户名】
         String names[]={"李三","张三","李四","张四"};
         for(String name:names){
             if(name.startsWith("李")){
                  System.out.println("name=="+name);
             }
         }
         //public boolean endsWith(String suffix)后缀匹配【从一组用户名中得到所有用“四”结尾的用户】
         for(String name:names){
             if(name.endsWith("四")){
                  System.out.println("name=="+name);
             }
         }
         //public int indexOf(String str)得到指定字符串在原始字符串中第一次出现的位置。[没有就-1]
         int in=s1.indexOf("a");
         System.out.println("in=="+in);
         //public int lastIndexOf(String str)得到指定字符串在原始字符串中最后一次出现的位置。[没有就-1]
         int ind=s1.lastIndexOf("o");
         System.out.println("ind=="+ind);
         //public String substring(int beginIndex)截取字符串
         //public String substring(int beginIndex,int endIndex)【包前不包后】
         String sub1=s1.substring(2, 9);
         System.out.println("sub1=="+sub1);
      //http://e.hiphotos.baidu.com/image/pic/item/4610b912c8fcc3cef70d70409845d688d53f20f7.jpg
         String imgurl="http://e.hiphotos.baidu.com/image/pic/item/4610b912c8fcc3cef70d70409845d688d53f20f7.jpg";
         String imgname=imgurl.substring(imgurl.lastIndexOf("/")+1);
         System.out.println("imgname=="+imgname);
         //public String concat(String str) 类似与“+”，字符串链接符
         String newstr=s1.concat(",网星软件");
         System.out.println("newstr=="+newstr);
         //public String replace(String oldChar,String newChar)替换字符串
         String info="name=zhangsan,age=23";
         String newinfo=info.replace("zhangsan","lisi");
         System.out.println("newinfo=="+newinfo);
         //public boolean matches(String regex) 匹配正则表达式
         //public boolean contains(String s)判断指定的字符串是否在原始字符串中存在
         boolean b2=s1.contains("Hello");
         System.out.println("b2=="+b2);
         //public String[] split(String regex)把原始字符串按照指定的分隔符拆分成String数组
         String info1="name=zhangsan,age=23";
         String infoArray[]=info1.split("=");
        for(String stri:infoArray){
             System.out.println("stri:"+stri);
         }
         //public String toLowerCase()转换为小写
         //public String toUpperCase()转换为大写
         //public String trim()//去除两端空格
         String s2="  zhang san  ";
         System.out.println("s2:"+s2.length());
        String zhangsanstring=s2.trim();

        System.out.println("zhangsanstring:"+zhangsanstring.length());
         //public char[] toCharArray()将字符串转换成字符数组
         char charray[]=s1.toCharArray();
         for(char c:charray){
             System.out.println("c=="+c);
   		 }
    }
}

字节数组与String的转换

字节数组---->String [String的构造方法【[String]】
String—>字节数组[String的public byte[] ()]

字符数组与String的转换

字符数组—>String[String的构造方法String(char[] value, int offset, int count)]
String---->字符数组[String的public char[] toCharArray()]

基本数据类型与String的转换。

基本数据类型---->String

valueOf的静态方法

static [String]	valueOf(boolean b)返回 boolean 参数的字符串表示形式。
static String	valueOf(char c) 返回 char 参数的字符串表示形式。
static String	valueOf(double d) 返回 double 参数的字符串表示形式。
static String	valueOf(float f) 返回 float 参数的字符串表示形式。
static String	valueOf(int i) 返回 int 参数的字符串表示形式。
static String	valueOf(long l) 返回 long 参数的字符串表示形式。

3.2 String----->基本数据类型[基本类型的封装类]

封装类—基本类型的封装类[只有基本类型具有封装类]

基本数据类型对应的复合数据类型【java类】

基本数据类型	封装类类型java类
byte[字节型]	Byte[java类]
short[短整型]	Short[java类]
int[整型]	Integer[java类]
long[长整型]	Long[java类]
float[单精度浮点型]	Float[java类]
double[双精度浮点型]	Double[java类]
char[字符型]	Character[java类]
boolean【布尔型】	Boolean[java类]

基本数据类型与对应的封装类的转换

基本数据类型----->对应的封装类[装箱操作]将基本类型的数据值/变量赋值给对应的封装类

1.将基本类型的数据值/变量赋值给对应的封装类

2.通过封装类的构造方法

例如：

//int num=100; //num是基本类型变量，没有可供调用的变量和方法
//Integer number=num; //装箱操作 //number对应的封装类对象，提供一系列可供调用的变量和方法。
//System.out.println("number=="+number);
//Integer number=100;
Integer number1=new Integer(100);
int num=100;
Integer number2=new Integer(num);
Integer number3=new Integer("100"); //String---》int型封装类对象

对应的封装类----->基本数据类型[拆箱操作]将封装类对象转换基本数据类型

Integer number21=new Integer(200);
int num1=number21; //拆箱操作

String----->基本数据类型[通过基本类型的封装类提供的parseXXX(String value)]

例如：

String dou="12.5";
double d=Double.parseDouble(dou);

String类final修饰的不可变字符串类

java.lang.StringBuilder类—一个inal修饰的可变的字符序列

不可变字符串与可变的字符序列？？？？

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4rwoPvdh-1595598040798)(C:\Users\18373\Desktop\Java基础\java基础第七节常用类库\img\Stringbuffer.png)]

我们在需要很多的字符串相连接的时候，最好使用StringBuilder类，不要使用String类，因为使用String类会造成存储空间的浪费。

定义：

public final class StringBuilder
extends [Object]
implements [Serializable]

构造方法摘要
StringBuilder() 构造一个不带任何字符的字符串生成器，其初始容量为 16 个字符。
StringBuilder(int capacity) 构造一个不带任何字符的字符串生成器，其初始容量由 capacity 参数指定。
StringBuilder(String str) 构造一个字符串生成器，并初始化为指定的字符串内容。

例如：

//StringBuilder()创建一个初始容量为16个字符的空的可变的字符串
         StringBuilder sbui1=new StringBuilder();
         //StringBuilder(int capacity) 创建一个指定初始容量的空的可变的字符串
         StringBuilder sbui2=new StringBuilder(30);
         //StringBuilder(String str)通过String对象创建一个可变的字符串【String转换成StringBuilder】
         StringBuilder sbui3=new StringBuilder("hello");        
         //String
         String s1="hello"; // 字符串常量池中创建一个"hello"
         String s2="world"; // 字符串常量池中创建一个"world"
         String s3="hello"+"world"; //字符串常量池中创建一个"helloworld";    
         StringBuilder sbui=new StringBuilder();//创建一个初始容量为16个字符的存储空间
         sbui.append("hello"); //在16个字符的存储空间---》hello
         sbui.append("world"); //在16个字符的存储空间---》helloworld

常用方法

StringBuilder append(Object o)向StringBuilder中追加任何类型的数据。
int capacity()返回当前容量。
char charAt(int index) 得到指定位置的字符数据
deleteCharAt(int index)移除此序列指定位置上的 char。
int indexOf(String str)得到指定的字符串在StringBuilder中第一次出现的位置。
lastIndexOf(String str)得到指定的字符串在StringBuilder中最后一次出现的位置。
insert(int offset,Object o)向StringBuilder中的指定位置插入指定数据。
replace(int start, int end, String str)替换
reverse()将此字符序列用其反转形式取代。
String substring(int start)/substring(int start, int end)截取字符串，注意用String变量收取结果。
toString()将StringBuilder转换成String

例如：

StringBuilder sbui=new StringBuilder();//创建一个初始容量为16个字符的存储空间
         sbui.append("hello"); //在16个字符的存储空间---》hello
         sbui.append("world"); //在16个字符的存储空间---》helloworld
         sbui.append(1234);
         sbui.append(true);
         sbui.append(12.34);
         System.out.println(sbui);
         //int capacity()返回当前容量。
         System.out.println(sbui.capacity());
         //char charAt(int index) 得到指定位置的字符数据
         System.out.println(sbui.charAt(1));//e
         //4.deleteCharAt(int index)移除此序列指定位置上的 char。
         //["zhangsan","lisi","wangwu"]
         String names[]={"zhangsan","lisi","wangwu"};
         StringBuilder sbui11=new StringBuilder();
         sbui11.append("[");
         for(String name:names){
             sbui11.append("\""+name+"\",");
         }
         sbui11.deleteCharAt(sbui11.length()-1);
         sbui11.append("]");
         System.out.println(sbui11);
         //5.int indexOf(String str)得到指定的字符串在StringBuilder中第一次出现的位置。
         //6.lastIndexOf(String str)得到指定的字符串在StringBuilder中最后一次出现的位置。
         //7.insert(int offset,Object o)向StringBuilder中的指定位置插入指定数据。
         System.out.println(sbui);
         sbui.insert(5, "##");
         System.out.println(sbui);
         //8.replace(int start, int end, String str)替换
         sbui.replace(5, 7, "@@");
         System.out.println(sbui);
         //reverse()将此字符序列用其反转形式取代。
         sbui.reverse();
         System.out.println(sbui);

10.String substring(int start)/substring(int start, int end)截取字符串，注意用String变量收取结果。

StringBuilder与String的转换

StringBuilder—>String

1.1通过StringBuilder的toString方法

1.2通过String的构造方法String(StringBuilder builder)
String-----》StringBuilder

2.1通过StringBuilder的构造方法StringBuilder(String str)

2.2通过StringBuilder的append方法

**java.lang.StringBuffer–**线程安全的可变字符序列

public final class StringBuffer
extends [Object]
implements [Serializable][CharSequence]

构造方法摘要
StringBuffer()构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。
StringBuffer(int capacity)构造一个不带字符，但具有指定初始容量的字符串缓冲区。
StringBuffer(String str)构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。

StringBuffer append(Object o)向StringBuffer中追加任何类型的数据。
int capacity()返回当前容量。
char charAt(int index) 得到指定位置的字符数据
deleteCharAt(int index)移除此序列指定位置上的 char。
int indexOf(String str)得到指定的字符串在StringBuffer中第一次出现的位置。
lastIndexOf(String str)得到指定的字符串在StringBuffer中最后一次出现的位置。
insert(int offset,Object o)向StringBuffer中的指定位置插入指定数据。
replace(int start, int end, String str)替换
reverse()将此字符序列用其反转形式取代。
String substring(int start)/substring(int start, int end)截取字符串，注意用String变量收取结果。
toString()将StringBuffer转换成String

7.2 Date/SimpleDataFormat如何创建对象？有哪些常用方法？

时间日期处理类

java.util.Date 类 Date 表示特定的瞬间，精确到毫秒。

构造方法

Date() 得到当前系统的日期时间

Date(long date)分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。

例如：

//Date() 得到当前系统的日期时间
         Date d1=new Date();
         //Thu Sep 05 10:45:10 GMT+08:00 2019
         System.out.println(d1);
         //Date(long date)分配 Date 对象并初始化此对象，
         //以表示自从标准基准时间（称为“历元（epoch）”，
      //即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。
         Date d2=new Date(5000);
         //Thu Jan 01 08:00:05 GMT+08:00 1970
         System.out.println(d2);

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tI8g71sn-1595598040804)(C:\Users\18373\Desktop\Java基础\java基础第七节常用类库\img\data.png)]$

实例方法

after(Date when)测试此日期是否在指定日期之后。
before(Date when)测试此日期是否在指定日期之前。
toString() 将Date转换String.

通过Date(long date)得到当前系统时间

得到1970 年 1 月 1 日 00:00:00 GMT到当前时间的毫秒数。

System类中 static long currentTimeMillis()返回以毫秒为单位的当前时间。
通过Date(long date)构造方法得到当前系统时间

例如：

/*
          \* 通过Date(long date)得到当前系统时间
             1.得到1970 年 1 月 1 日 00:00:00 GMT到当前时间的毫秒数。
             System类中 static long currentTimeMillis()返回以毫秒为单位的当前时间。
             2.通过Date(long date)构造方法得到当前系统时间
          */
         long haomiaoshu=System.currentTimeMillis();
         Date d3=new Date(haomiaoshu);
         //Thu Sep 05 10:55:28 GMT+08:00 2019
         System.out.println(d3);

注意：我们通过Date类得到的时间日期格式都不符合我们的使用习惯

【Fri Nov 08 10:28:37 GMT+08:00 2019】
【2019年11月8日 10:28:37 星期五】
【2019/11/8 10:28:37 星期五】
【2019-11-8 10:28:37 星期五】

时间日期格式转换

**java.text.SimpleDateFormat—**时间日期的格式化类

构造方法

SimpleDateFormat(String pattern) 通过指定的格式创建SimpleDateFormat对象

String pattern—时间日期格式。

日期和时间格式由日期和时间格式字符串指定规范：

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lTEsFfL6-1595598040807)(C:\Users\18373\Desktop\Java基础\java基础第七节常用类库\img\data2.png)]$

yyyy-MM-dd HH:mm:ss E [2019-09-05 11:05:30 星期四]
yyyy/MM/dd HH-mm-ss E [2019/09/05 11-05-30 星期四]
yyyy年MM月dd日 HH时mm分ss秒 E [2019年09月05日 11时05分30秒星期四]

实例方法

String format(Date date) 将一个 Date 格式化为日期/时间字符串
Date parse(String source) 从给定字符串的开始解析文本，以生成一个Date。

例如：

//Date----时间日期格式----String
         //得到当前系统时间
         Date d=new Date();
         //设置时间日期格式
         String geshi="yyyy-MM-dd HH:mm:ss E";
         //创建时间日期格式化对象
         SimpleDateFormat sdf=new impleDateFormat(geshi);
         //通过format()方法格式时间日期
         String newdate=sdf.format(d);
         //2019-09-05 11:28:07 星期四
         System.out.println(newdate);
         
         try{
         //String----时间日期格式----Date
         String datetime="2019-09-05 11:28:07 星期四";
         String geshi1="yyyy-MM-dd HH:mm:ss E";
         //创建时间日期格式化对象
         SimpleDateFormat sdf1=new SimpleDateFormat(geshi1);
        Date dd=sdf1.parse(datetime);
         //Thu Sep 05 11:28:07 GMT+08:00 2019
         System.out.println(dd);
         }catch(Exception e){
             e.printStackTrace();
         }

7.3Math类有哪些常用方法？

java.lang.Math

Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

成员变量

static double E 自然常数
static double PI 圆周率

静态方法

random() 得到0.0-1.0之间的随机数
round(float a)返回最接近参数的 int。

例如：

//static double E 自然常数
//static double PI 圆周率
         System.out.println("E=="+Math.E);
         System.out.println("PI=="+Math.PI);
         //静态方法
         //random() 得到0.0-1.0之间的随机数
         //System.out.println("random=="+Math.random());
         //得到1--100之间的随机数
  int d1=(int)(Math.random()*100);
  System.out.println("d1=="+d1);
  //round(float a)返回最接近参数的 int。
    System.out.println("round=="+Math.round(11.5)); //12
    System.out.println("round=="+Math.round(-11.5)); //-11

7.4 正则表达式？

正则表达式，又称规则表达式。正则表达式通常被用来检索、替换那些符合某个模式(规则)的文本。正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。通常都是用来验证输入的字符串数据是否复合正则表达式定义的规范，常被用来做验证操作。
元字符和限定字符
元字符

x\|y	匹配x或y。例如，“z\|food”能匹配“z”或“food”(此处请谨慎)。“[z\|f]ood”则匹配“zood”或“food”。
[xyz]	字符集合。匹配所包含的任意一个字符。例如，“[abc]”可以匹配“plain”中的“a”。
[^xyz]	负值字符集合。匹配未包含的任意字符。例如，“[^abc]”可以匹配“plain”中的“plin”任一字符。
[a-z]	字符范围。匹配指定范围内的任意字符。例如，“[a-z]”可以匹配“a”到“z”范围内的任意小写字母字符。注意:只有连字符在字符组内部时,并且出现在两个字符之间时,才能表示字符的范围; 如果出字符组的开头,则只能表示连字符本身.
[^a-z]	负值字符范围。匹配任何不在指定范围内的任意字符。例如，“[^a-z]”可以匹配任何不在“a”到“z”范围内的任意字符。
\b	匹配一个单词的边界，也就是指单词和空格间的位置（即正则表达式的“匹配”有两种概念，一种是匹配字符，一种是匹配位置，这里的\b就是匹配位置的）。例如，“er\b”可以匹配“never”中的“er”，但不能匹配“verb”中的“er”；“\b1_”可以匹配“1_23”中的“1_”，但不能匹配“21_3”中的“1_”。
\B	匹配非单词边界。“er\B”能匹配“verb”中的“er”，但不能匹配“never”中的“er”。
\cx	匹配由x指明的控制字符。例如，\cM匹配一个Control-M或回车符。x的值必须为A-Z或a-z之一。否则，将c视为一个原义的“c”字符。
\d	匹配一个数字字符。等价于[0-9]。grep 要加上-P，perl正则支持
\D	匹配一个非数字字符。等价于[^0-9]。grep要加上-P，perl正则支持
\f	匹配一个换页符。等价于\x0c和\cL。
\n	匹配一个换行符。等价于\x0a和\cJ。
\r	匹配一个回车符。等价于\x0d和\cM。
\s	匹配任何不可见字符，包括空格、制表符、换页符等等。等价于[ \f\n\r\t\v]。
\S	匹配任何可见字符。等价于[^ \f\n\r\t\v]。
\t	匹配一个制表符。等价于\x09和\cI。
\v	匹配一个垂直制表符。等价于\x0b和\cK。
\w	匹配包括下划线的任何单词字符。类似但不等价于“[A-Za-z0-9_]”，这里的"单词"字符使用Unicode字符集。
\W	匹配任何非单词字符。等价于“[^A-Za-z0-9_]”。

限定字符

^	匹配输入字行首。如果设置了RegExp对象的Multiline属性，^也匹配“\n”或“\r”之后的位置。
$	匹配输入行尾。如果设置了RegExp对象的Multiline属性，$也匹配“\n”或“\r”之前的位置。
*	匹配前面的子表达式任意次。例如，zo能匹配“z”，也能匹配“zo”以及“zoo”。等价于{0,}。
+	匹配前面的子表达式一次或多次(大于等于1次）。例如，“zo+”能匹配“zo”以及“zoo”，但不能匹配“z”。+等价于{1,}。
?	匹配前面的子表达式零次或一次。例如，“do(es)?”可以匹配“do”或“does”。?等价于{0,1}。
{n}	n是一个非负整数。匹配确定的n次。例如，“o{2}”不能匹配“Bob”中的“o”，但是能匹配“food”中的两个o。
{n,}	n是一个非负整数。至少匹配n次。例如，“o{2,}”不能匹配“Bob”中的“o”，但能匹配“foooood”中的所有o。“o{1,}”等价于“o+”。“o{0,}”则等价于“o*”。
{n,m}	m和n均为非负整数，其中n<=m。最少匹配n次且最多匹配m次。例如，“o{1,3}”将匹配“fooooood”中的前三个o为一组，后三个o为一组。“o{0,1}”等价于“o?”。请注意在逗号和两个数之间不能有空格。

常用的正则表达式：

Email地址：^\w+([-+.]\w+)@\w+([-.]\w+).\w+([-.]\w+)*$
域名：a-zA-Z0-9{0,62}(/.a-zA-Z0-9{0,62})+/.?
InternetURL：[a-zA-z]+://[^\s]* 或 ^http://([\w-]+.)+[\w-]+(/[\w-./?%&=]*)?$
手机号码（可根据目前国内收集号扩展前两位开头号码）：^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$
电话号码(“XXX-XXXXXXX”、“XXXX-XXXXXXXX”、“XXX-XXXXXXX”、“XXX-XXXXXXXX”、"XXXXXXX"和"XXXXXXXX)：^((\d{3,4}-)|\d{3.4}-)?\d{7,8}$
国内电话号码(0511-4405222、021-87888822)：\d{3}-\d{8}|\d{4}-\d{7}
15位身份证号：¹\d{5}\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\d{2}$
18位身份证号：²\d{5}(18|19|([23]\d))\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\d{3}[0-9Xx]$
帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：³[a-zA-Z0-9_]{4,15}$
密码(以字母开头，长度在6~18之间，只能包含字母、数字和下划线)：⁴\w{5,17}$
强密码(必须包含大小写字母和数字的组合，不能使用特殊字符，长度在8-10之间)：^(?=.\d)(?=.[a-z])(?=.*[A-Z]).{8,10}$
日期格式：^\d{4}-\d{1,2}-\d{1,2}

中文字符的正则表达式：[\u4e00-\u9fa5]

腾讯QQ号：1-9{4,} (腾讯QQ号从10000开始)

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

IP地址：((?: (?:25[0-5]|2[0-4]\d|[01]?\d?\d)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d?\d)

例如：

package com.click369.test1;

import java.util.Scanner;

public class ZhengZeTest1 {
     public static void main(String[] args) {
         /*
         String regex="^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\\d{8}$";
         Scanner input=new Scanner(System.in);
         System.out.println("请输入手机号码");
         String phoneNum=input.nextLine();
         boolean b=phoneNum.matches(regex);
         if(b){
             System.out.println("合法手机号码");
         }else{
             System.out.println("非法手机号码");
         }
         */      
         String regex="[\u4e00-\u9fa5]{2,4}";
         Scanner input=new Scanner(System.in);
         System.out.println("请输中文:");
         String zhongwen=input.nextLine();
         boolean b=zhongwen.matches(regex);
        if(b){
             System.out.println("中文");
        }else{
             System.out.println("非中文");
         }
     }
}

(System.in);
         System.out.println("请输入手机号码");
         String phoneNum=input.nextLine();
         boolean b=phoneNum.matches(regex);
         if(b){
             System.out.println("合法手机号码");
         }else{
             System.out.println("非法手机号码");
         }
         */      
         String regex="[\u4e00-\u9fa5]{2,4}";
         Scanner input=new Scanner(System.in);
         System.out.println("请输中文:");
         String zhongwen=input.nextLine();
         boolean b=zhongwen.matches(regex);
        if(b){
             System.out.println("中文");
        }else{
             System.out.println("非中文");
         }
     }
}