常用类与正则表达式

常用类

object类

object作为所有类的超类，无论是四类八种的基本类型还是引用类型或者是自定义类型都需要extends Object,所以其自然有着强大的功能，它的主要方法有
需要注意的几个方法：

   （1）、finalize:protected void finalize() throws Throwable:当垃圾回收器确定不存在对该对象的更过引用时，由对象的垃圾回收器调用会此方法，但是什么时候调用垃圾回收器不确定。在System类中的一个方法：   public void gc()垃圾回收器最终调用的就是这个方法。

   （2）、clone: Object类中的clone方法执行特定的复制操作，首先如果对象不能实现接口Cloneable，则会抛出 CloneNotSupportedException。

   （3）、toString：在平时编程中，我们都有这样的发现  System.out.println(oo)的输出与Systeml.out.println(oo.toString)输出结果一样， 为什么呢？

      这是因为System.out.println方法在打印引用时若引用不为空，则首先调用指向对象的toString方法获取字符串，然后打印字符串的内容，当然如果我们没有重写toString方法，就按Object类实现获取字符串，打印出来的内容就是this.getClass.getName + @ + Integer.toHexString(this.hashCode)，一般就比较难理解，所以好多大神都建议当自定义类时，最好重写toString方法,这样我们也就可以显示成员变量的值。

   （4）、equals：方法的重要意义 

      在一般初学者眼里，觉得自己能够辨识”equals“方法和”==“就很流弊了，前者比较其实例的值，后者比较实例的地址。很对，但是如果你不深入理解源码去看的话，很容易掉入各大公司的陷阱里面。其实equals的底层实现依然是”==“，

Scanner类

（1）类的功能： 该类的主要作用就是建立一个文本扫描器（键盘录入），存在于java.util包下。在键盘的录入过程中，Scanner sc = new Scammer(System.in),

System类中的静态字段为：

    public static final InputStream in:  标准输入流
    
 	InputStream :字节流    InputStream is = System.in ;  实质:抽象类多态
 	
	 public static final OutputStream out:  标准输出流 
	 
  （2）、判断功能：在录入数据之前添加逻辑判断，hasNextXXX()，判断是否由下一个可以录入的XXX类型的数据。nextXXX()，通过录入来获取这个int类型的数据，如果输入数据与判断数据不一致，则会抛出java.util.InputMismatchException(输入和想得到的数据不一致)
  （3）、注意事项：先录入int类型的数据再录入String类型的数据，String没有接收到，直接输出结果了，这是由于“回车”导致的，一回车。直接输出结果。
  解决方案有二：其一，使用next()方法，其二，再创建一个键盘输入对象录入String类型。

String类

类的功能代表字符串，Java程序中所有的字符串字面值（如“abc”）都作为此类的实例实现，字符串一旦被赋值，其值不能被改变。

String s = “hello”,与String s = new String(“hello”)两个有什么区别？分别创建了几个对象？

答：第一个创建了一个对象，第二个创建了两个对象（堆内存中有new String(),然后字符串常量池中也有这样一个字符串常量（开辟了地址空间））

String类常用的构造方法:

• String():表示一个空字符序列。
• public String(byte[] bytes,Charset ch):默认字符集(编码格式):GBK,如果是GBK格式,可以不写第二个参数
• public String(byte[] bytes,int index,int length):将部分字节数组构造成一个字符串
• public String(char[] value):将字符数组构造成一个字符串
• public String(char[] value,int index,int length):将部分的字符数组构造成一个字符串
• public String(String original):通过字符串常量构造一个字符串对象

注意事项：

其一、数组中没有length()方法，它有length属性。字符串中有length(),集合中没有length(),有size()获取集合中元素的数量。
其二、字符串变量相加，先开辟空间，再相加。字符串常量相加，首先在字符串常量池中找，判断有没有这个常量值，没有需要创建，有，则直接返回。

编码与解码格式一样（默认为GBK格式，一个中文对应两个字节。utf-8编码，一个汉字对应三个字节）。

String类中的判断功能：

boolean equals(Object obj):当前该对象是否obj这个对象是否相等;
boolean equalsIgnoreCase(String str):比较字符串是否相等,忽略大小写
boolean contains(String str):判断str这个字符串是否包含在当前字符串中
boolean startsWith(String str):是否以str子字符串开头
boolean endsWith(String str):判断是否以str子字符串结尾
boolean isEmpty():判断字符串是否为空

String类中转换功能：

String类的转换功能(重点)
byte[] getBytes():将字符串转换字节数组
char[] toCharArray():将字符串转换成 字符数组 (开发中经常使用)
static String valueOf(char[] chs):将字符数组转换成字符串
static String valueOf(int i):将一个int类型的数据转换成字符串

注意:

String类中的valueOf()可以将任何数据类型转换成字符串
String toLowerCase():将字符串全部转成小写
String toUpperCase():将字符串全部转换成大写
String concat(String str):字符串拼接方法

String类的其他功能：

替换功能:

• public String replace(char oldChar,char newChar):将字符串中某一个字符用新的字符替换
• public String replace(String oldStr,String newStr):将字符串中某一个子字符串用新 的字符串去替代
• 去除字符串两端空格: public String trim()两个字符串进行比较:
• public int compareTo(String anotherString) 是Comparable接口中的方法(该接口可以实现一个自然排序)
• Comparator接口可以比较器排序

插播递归：

自己调用自己的方法，称为方法递归，递归的三个条件：
A需要定义方法，B要有出口条件，C满足一定的规律

构造方法不能使用递归

StringBuffer类

StringBuffer:线程安全的可变字符序列。

StringBuffer的构造方法:

• public StringBuffer ()构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符
• public StringBuffer(int capacity)构造一个不带字符，但具有指定初始容量的字符串缓冲区
• public StringBuffer(String str)
• 构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。该字符串的初始容量为 16 加上字符串参数的长度。

获取长度和容量的方法：

• public int length():获取字符串长度数
• public int capacity():获取当前字符串缓冲区的容量

StringBuffer中的和添加有关的方法：

• public StringBuffer append(int/String/char/boolean/double/float…):当前这个方法追加,给缓冲中追加数据,返回字符串缓冲区本身(经常使用的)
• public StringBuffer insert(int offset,String str):在某一个位置处去插入str这个字符串,返回字符串缓冲区本身

StringBuffer的删除有关方法:

• public StringBuffer deleteCharAt(int index):删除指定位置处的字符,返回的是字符串缓冲区本身!
• public StringBuffer delete(int start,int end):删除从指定位置开始到指定位置结束的字符,返回的是字符串缓冲区本身!

StringBuffer的反转功能:

• public StringBuffer reverse():将此字符串中的字符序列直接反转

StringBuffer的替换功能:

• public StringBuffer replace(int start, int end,String str) 从指定位置开始到指定位置结束的字符用str子字符串去替代

StringBuffer的截取功能:

• public String substring(int start):从指定位置默认截取到末尾,返回值是一个新的字符串
• public String substring(int start,int end):从指定位置开始截取到指定位置结束,包前不包后,返回一个新的字符串

StringBuffer和String 的区别?

• StringBuffer会构造一个字符串缓冲区,从内存角度考虑,一般情况使用StringBuffer比较多(在单线程程序中使用StringBulider替代
• StringBuilder:线程不安全,单线程单纯为了提供执行效率!)
• String:普通的一个字符串,从内存角度考虑,耗费空间!

StringBuffer和数组的区别？

都属于容器类型的变量，数组只能存储一种类型的数据，并且长度是固定的，StringBuffer可以存储任意类型的元素。

静态代码块 ,构造代码块,构造方法的优先级问题:

• 静态代码块>构造代码块>构造方法…

Java中的包装类

对基本数据类型都非常熟悉，例如 int、float、double、boolean、char 等。基本数据类型是不具备对象的特性的，比如基本类型不能调用方法、功能简单。。。，为了让基本数据类型也具备对象的特性， Java 为每个基本数据类型都提供了一个包装类，这样我们就可以像操作对象那样来操作基本数据类型。

基本类型和包装类之间的对应关系：

• 包装类主要提供了两大类方法：

1. 将本类型和其他基本类型进行转换的方法

2. 将字符串和本类型及包装类互相转换的方法

• Integer 包装类的构造方法：
  
• Integer包装类的常用方法：
  
  基本类型和包装类之间的转换，即装箱和拆箱的操作。

      public class HelloWorld {
            public static void main(String[] args) {
            // 定义double类型变量
            double a = 91.5;
             
             // 手动装箱
            Double b =new Double(a);       
             
            // 自动装箱
            Double c = a;     
     
            System.out.println("装箱后的结果为：" + b + "和" + c);
             
            // 定义一个Double包装类对象，值为8
            Double d = new Double(87.0);
             
            // 手动拆箱
            double e =d.doubleValue()               ;
             
            // 自动拆箱
            double f = d               ;
             
             System.out.println("拆箱后的结果为：" + e + "和" + f);
         }
         }
   

在程序开发中，我们经常需要在基本数据类型和字符串之间进行转换。

其中，基本类型转换为字符串有三种方法：

1. 使用包装类的 toString() 方法

2. 使用String类的 valueOf() 方法

3. 用一个空字符串加上基本类型，得到的就是基本类型数据对应的字符串

使用 format() 方法将日期转换为指定格式的文本

import java.text.SimpleDateFormat;
import java.util.Date;
 
public class First {
    public static void main(String []args){
        //创建Date对象，表示当前时间
        Date d=new Date();
        //创建SimpleDateFormat对象，指定目标格式
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //调用format()方法，格式化时间，转换为指定格式字符串
        String today=sdf.format(d);
        //输出转换后的字符串
        System.out.println(today);
    }
}

使用 parse() 方法将文本转换为日期

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
 
public class First {
    public static void main(String []args){
        //创建SimpleDateFormat对象，指定字符串的日期格式
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String day="2016-12-30 14:52:30";  //创建日期格式的字符串
             
            try {
                //调用parse()方法，将字符串转换为日期
                Date date =(Date)df.parse(day);
                //输出转换后的时间
                System.out.println("当前时间；" + date);
            } catch (ParseException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }  
    }
}

注意：

1、 调用 SimpleDateFormat 对象的 parse() 方法时可能会出现转换异常，即 ParseException ，因此需要进行异常处理

2、 使用 Date 类时需要导入 java.util 包，使用 SimpleDateFormat 时需要导入 java.text 包

Calendar 类的应用

java.util.Calendar 类是一个抽象类，可以通过调用 getInstance() 静态方法获取一个 Calendar 对象，此对象已由当前日期时间初始化，即默认代表当前时间，

如 Calendar c = Calendar.getInstance();

import java.util.Calendar;
 
public class First {
    public static void main(String []args){
        //创建Calendar对象
        Calendar c=Calendar.getInstance();
        //获取年
        int year=c.get(Calendar.YEAR);
        //获取月份，0表示1月份
        int month=c.get(Calendar.MONTH)+1;
        //获取日期
        int day=c.get(Calendar.DAY_OF_MONTH);
        //获取小时
        int hours=c.get(Calendar.HOUR_OF_DAY);
        //获取分钟
        int minute=c.get(Calendar.MINUTE);
        //获取秒
        int scond=c.get(Calendar.SECOND);
        //输出结果
        System.out.println("当前时间为："+year+"-"+month+"-"+day+" "+hours+":"+minute+":"+scond);
         
    }
}

Calendar 类提供了 getTime() 方法，用来获取 Date 对象，完成 Calendar 和 Date 的转换，还可通过 getTimeInMillis() 方法，获取此 Calendar 的时间值，以毫秒为单位。

import java.util.Calendar;
import java.util.Date;
 
public class First {
    public static void main(String []args){
        //创建Calendar对象
        Calendar c=Calendar.getInstance();
        //将Calendar对象转换为Date对象
        Date date=c.getTime();
        //获取当前毫秒数
        Long time=c.getTimeInMillis();
        System.out.println("当前时间："+date);
        System.out.println("毫秒数："+time);       
         
    }  
}

使用 Math 类操作数据

Math 类位于 java.lang 包中，包含用于执行基本数学运算的方法， Math 类的所有方法都是静态方法，所以使用该类中的方法时，可以直接使用类名.方法名，

public class First {
    public static void main(String []args){
        //定义一个double类型的变量
        double a=12.08;
        //将double类型强制转换 int类型，去掉小数位
        int b=(int) a;
        System.out.println("强制转换为："+b);
        //调用round方法，进四舍五入
        Long c=Math.round(a);
        System.out.println("返回四舍五入的整数："+c);
        //调用floor方法，小于参数的最大
        double d=Math.floor(a);
        System.out.println("返回小于参数的最大整数："+d);
        //调用ceil方法，大于参数的最小
        double e=Math.ceil(a);
        System.out.println("返回大于参数的最小整数："+e);
        //调用random方法，随机数[0，1）之间的 随机浮点数
        double f=Math.random();
        System.out.println("随机数："+f);
        //调用random方法，随机[0，99）之间的整数
        int g=(int)(Math.random()*99);
        System.out.println("返回[0，99）之间的随机整数："+g);
    }  
}

正则表达式

正则表达式是指一个用来描述或者匹配一系列符合某个语法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用。

作用:比如注册邮箱,邮箱有用户名和密码,一般会对其限制长度,这个限制长度的事情就是正则表达式做的
js正则与java正则区别
JS转义字符用\表示
java转义字符用\表示

JAVA中的正则字符集

1） \w 匹配字母或者数字或者下划线 [a-zA-Z0-9_]
2） \s 匹配任意的空白符
3） \d 匹配数字 [0-9]
4） \W 匹配任意非字母、数字、下划线、汉字的字符
5） \S 匹配任意不是空白符的字符
6） \D 匹配任意非数字的字符
7） [\u4e00-\u9fa5]表示单个中文
8） * 重复任意次 {0,} \d*
9） + 至少重复一次{1,} \d+
10） ? 重复零次或一次=={0,1}
11） {n} 重复n次 \d{4}==\d\d\d\d 0000—9999
12） {n,} 重复n次或更多次\d{5,}
13） {n,m} 重复n到m次 \d{2,3}
注意：\f 匹配一个换页符 、\n 匹配一个换行符 、\r 匹配一个回车符

字符类

[abc]

a、b 或 c（简单类）

[^abc]

任何字符，除了 a、b 或 c（否定）

[a-zA-Z]

a到 z 或 A到 Z，两头的字母包括在内（范围）

[0-9]

0到9的字符都包括

[a-d[m-p]]

a 到 d 或 m 到 p：[a-dm-p]（并集）

[a-z&&[def]]

d、e 或 f（交集）

[a-z&&[^bc]]

a 到 z，除了 b 和 c：[ad-z]（减去）

[a-z&&[^m-p]]

a 到 z，而非 m 到 p：[a-lq-z]（减去）

预定义字符类

. 任何字符

\d 数字：[0-9]

\D 非数字： [^0-9]

\s 空白字符：[ \t\n\x0B\f\r]

(\t(Tab键)\n(换行)\x0B(垂直制表符)\f(翻页)\r(回车)）

\S 非空白字符：[^\s]

\w 单词字符：[a-zA-Z_0-9]

\W 非单词字符：[^\w]

数量词

X? X，一次或一次也没有

X* X，零次或多次

X+ X，一次或多次

X{n} X，恰好 n 次

X{n,} X，至少 n 次

X{n,m} X，至少 n 次，但是不超过 m 次

正则表达式的获取功能

Pattern 和 Matcher 的结合使用

从一个字符串中的把手机号码获取出来

public static void main(String[] args){

//从一个字符串中把手机号码获取出来
String s = "我有两张手机号是13855588866和13855661783"；
String regex = "1[357]\\d{9}";
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(s);
while(m.find()){
System.out.println(m.group());

}
 }

13855588866
13855661783