JAVASE(10)基本类型的包装类（Integer...）、自动拆装箱、正则表达式

Keyword:

• 基本类型的包装类
• 包装类Integer类的举例
• 自动拆装箱
• 正则表达式与举例说明
• Pattern和Matcher类

基本数据类型的包装类

概念：为了对基本数据类型进行更多的操作,更方便的操作,java就针对每一种基本数据类型提供了对应的类类型.
基本类型和包装类的对应：
byte<>Byte
short<>Short
int<>Integer
long<>Long
float <>Float
double <> Double
char <>Character
boolean<>Boolean

包装类Integer类(举例)

其他包装类与Integer类相似；
String和int类型的相互转换)：
int>>>>>String

• String类的valueof（）方法（主要）
• String类的Tostring方法
• Integer类的String方法

String>>>>int(条件：字符串必须为数字做成的字符串)

• Integer的静态方法parseint方法（主要）
• Integer的intvalue方法

Integer的面试题
		看程序写结果
		
		Integer i1 = new Integer(127);
		Integer i2 = new Integer(127);
		System.out.println(i1 == i2);//false
		System.out.println(i1.equals(i2));//ture
		System.out.println("-----------");
	
		Integer i3 = new Integer(128);
		Integer i4 = new Integer(128);
		System.out.println(i3 == i4);//false
		System.out.println(i3.equals(i4));//ture
		System.out.println("-----------");
	
		Integer i5 = 128;
		Integer i6 = 128;
		System.out.println(i5 == i6);//false
		System.out.println(i5.equals(i6));//ture
		System.out.println("-----------");
	
		Integer i7 = 127;
		Integer i8 = 127;
		System.out.println(i7 == i8);//ture
		System.out.println(i7.equals(i8));//ture

https://blog.csdn.net/gexin0517/article/details/95796480
当变量大于127时，比较方法和运算符比较的两个地址值时是从缓存中调用的，两个地址是一样的

自动装箱和拆箱

自动装箱：把基本类型转换为包装类类型
自动拆箱：把包装类类型转换为基本类型

public class MyTest {
    public static void main(String[] args) {
        int a=100;
        Integer integer = new Integer(a);
        Integer num = a; //自动装箱

        Integer integer1 = new Integer(10);

        Integer integer2 = new Integer(20);
         int r= integer1 + integer2;
       // 将一个包装类型，转化成他所对应的基本类型
        System.out.println(r);
       //都有哪些操作

        Integer ii = 100; //自动装箱

        ii += 200; //自动拆箱 自动装箱

        System.out.println(ii);

        //手动拆装箱
        Integer integer3 = new Integer(10);

        Integer integer4= new Integer(20);

        int num11 = integer3.intValue();//手动拆箱

        int num22 = integer4.intValue(); //手动拆箱

        int rr=num11+num22;

        Integer integer5 = Integer.valueOf(rr); //手动装箱
    }
}

正则表达式与举例说明

概念：是指一个用来描述或者匹配一系列符合某个句法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用。
正则表达式的规则
规则字符在java.util.regex Pattern类中

• A:字符

   x 字符 x。举例：'a'表示字符a
   \\ 反斜线字符。
   \n 新行（换行）符 ('\u000A') 
   \r 回车符 ('\u000D')
  

• B:字符类

   [abc] a、b 或 c（简单类） 
   [^abc] 任何字符，除了 a、b 或 c（否定） 
   [a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内（范围） 
   [0-9] 0到9的字符都包括
  

• C:预定义字符类

   . 任何字符。我的就是.字符本身，怎么表示呢? \.
   \d 数字：[0-9]
   \w 单词字符：[a-zA-Z_0-9]
   	在正则表达式里面组成单词的东西必须有这些东西组成
  

• D:边界匹配器

   ^ 行的开头 
   $ 行的结尾 
   \b 单词边界
   	就是不是单词字符的地方。
   	举例：hello world?haha;xixi
  

• E:Greedy 数量词

   X? X，一次或一次也没有 比如""空串 就是没有
   X* X，零次或多次  大于等于1次 都算多次
   X+ X，一次或多次
   X{n} X，恰好 n 次 
   X{n,} X，至少 n 次 
   X{n,m} X，至少 n 次，但是不超过 m 次 
  

正则表达式的判断功能

public boolean matches(String regex)

案例演示1：

//需求：校验qq号码.
			1:要求必须是5-15位数字
			2:0不能开头
//非正则表达式表示
		private static boolean checkQQ(String numQQ) {
		// 校验位数
		boolean b = false;
		// 判断长度
		if (numQQ.length() >= 5 && numQQ.length() <= 15) {
			// 判断开头不能为0
			if (!(numQQ.startsWith("0"))) {
				// 判断每一位是不是数字
				for (int i = 0; i < numQQ.length(); i++) {
					char ch = numQQ.charAt(i);
					if (ch >= '0' && ch <= '9') {
	
						b = true;
					} else {
						b = false;
						break; //一旦遇到不是数字的,就结束循环
					}
				}
			} else {
				b = false;
			}
		} else {
			b = false;
		}
		return b;
	}

//正则表达式
public class MyTest {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的qq号");
        String qqNumber = scanner.nextLine();
        //需要对用户输入的QQ号进行规则的校验
        String strRgex="[1-9][0-9]{4,14}";
        boolean b = qqNumber.matches(strRgex);
        if(b){
            System.out.println("qq号规则正确");
        }else{
            System.out.println("qq号规则不正确");
        }
    }

把给定字符串中的数字排序

//案例演示:
        //需求：我有如下一个字符串:”91 27 46 38 50”，请写代码实现最终输出结果是：”27 38 46 50 91”
        String str="91 27 46 38 50"; // ======>  "27 38 46 50 91"
        //-分析:
        //-a:定义目标字符串 "91 27 46 38 50"
        //        b:对这个字符串进行切割, 得到的就是一个字符串数组
        //        c:把b中的字符串数组转换成int类型的数组
        //        (1):定义一个int类型的数组, 数组的长度就是字符串数组长度
        //        (2):遍历字符串数组, 获取每一个元素.将其转换成int类型的数据
        //        (3):把int类型的数据添加到int类型的数组的指定位置
        //        d:排序
        //        e:创建一个StringBuilder对象, 用来记录拼接的结果
        //        f:遍历int类型的数组, 将其每一个元素添加到StringBuilder对象中
        //        g:就是把StringBuilder转换成String
        //        h:输出
public class MyTest {
    public static void main(String[] args) {
        String[] strs = str.split(" ");
        int[] arr=new int[strs.length];
        //遍历字符串数组，把元素存到，int数组里面去
        for (int i = 0; i < strs.length; i++) {
            arr[i]=Integer.parseInt(strs[i]);
        }
        //排序
        Arrays.sort(arr);
        //遍历int数组 转换成一个字符串
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < arr.length; i++) {
            sb.append(arr[i]).append(" ");
        }
        String s = sb.toString().trim();
        System.out.println(s);
    }
}

正则表达式的替换功能

public String replaceAll(String regex,String replacement)

Pattern和Matcher类

模式和匹配器
调用顺序是

Pattern p = Pattern.compile("a*b");
//输入固定的模式
Matcher m = p.matcher("aaaaab");
//匹配输入的字符串
boolean b = m.matches();