JavaSE笔记_day11_StringBuilder、基本数据类型包装类、正则表达式

       返回值类型 int 

• StringBuilder(int space): 创建一个StringBuilder对象,开辟了指定大小的字符数组空间.
• StringBuilder(String s): 创建一个StringBuilder对象,开辟s字符串+16大小的字符数组空间
  

public class StringBuilderTest {
    public static void main(String[] args) {
        //1.创建一个StringBuilder对象，开辟一个16大小的字符数组空间。
        StringBuilder s1 = new StringBuilder();
        int space = s1.capacity();
        System.out.println(space);//16
        System.out.println("s1:"+s1);//s1:	

        //2.创建了一个 StringBuilder对象,开辟了一个指定大小的字符数组空间.
        StringBuilder s2 = new StringBuilder(23);
        System.out.println(s2.capacity());//23
        System.out.println("s2:"+s2);//s2:	

        //3.创建了一个 StringBuilder对象,开辟s字符串+16大小的字符数组空间
        StringBuilder s3 = new StringBuilder("abc123");
        System.out.println(s3.capacity());//22
        System.out.println("s3:"+s3);//s3:abc123
    }
}

3.StringBuilder的添加功能

    将任意的数据类型，转换成字符序列，添加到StringBuilder缓冲区中

• append(Object obj):将参数以字符串的形式，在末尾追加到StringBuilder所表示的字符串缓冲区中。

      返回值类型StringBuilder类型

public class StringBuilderTest {
    public static void main(String[] args) {
        //1.创建一个StringBuilder对象，开辟一个16大小的字符数组空间。
        StringBuilder s1 = new StringBuilder();
        System.out.println(s1.capacity());//16
        s1.append(true);
        s1.append(3.14);
        s1.append("123456ABC");
        s1.append(5);
        System.out.println(s1);//StringBuider重写了toString()方法，打印的是结果：true3.14123456ABC5
	
        //当字符序列数量超过StringBuilder缓冲区大小，那么StringBuilder底层默认开辟更大的存储空间
        System.out.println(s1.capacity());//34底层自动扩容

        //2.append因为返回值类型是StringBuilder，因此方法可以链式调用
        s1.append(false).append("11").append(55);
        System.out.println(s1);//true3.14123456ABC5false1155
    }
}

• insert(int i , Object obj):将参数obj添加到StringBuilder所表示的字符序列索引位置i上

      返回值类型 StringBuilder类型

public class StringBuilderTest {
    public static void main(String[] args) {
        //1.创建一个StringBuilder对象，开辟一个16大小的字符数组空间。
        StringBuilder s1 = new StringBuilder();
        s1.append(true).insert(0,3.14);
        System.out.println(s1);//3.14true
        s1.insert(1,"hello");
        System.out.println(s1);//3hello.14true
        System.out.println(s1.length());//13,索引位置0 - 12
        s1.insert(12,'b');
        System.out.println(s1);//3hello.14trube,
        //大索引位置上+1位置上添加数据,相当于末尾追加，与append方法结果一致
        s1.insert(14,"abc");//长度14，索引0-13
        System.out.println(s1);//3hello.14trubeabc
        //s1.inset(16,"a");//越界异常,报错
    }
}

• 注意：

    1.append方法末尾追加，在当前最大索引位置下一位添加
    2.insert方法，最大索引位置上+1位置上添加数据，相当于append的末尾追加                    

s1.append(x) 和 s1.insert(s1.length(), x) 具有相同的效果

4.StringBuilder的删除方法 (索引值不可超过其length-1)

• 1.delete(int start,int end): 将StringBuilder所表示的字符序列中，删除索引[start,end)全部 

     返回值类型 stringBuilder 

• 2.deleteCharAt(int i): 将指定索引位置i上的字符，从StringBuilder字符序列中删除掉

     返回值类型 StringBuilder

public class StringBuilderTest {
    public static void main(String[] args) {
        //1.创建一个StringBuilder对象，开辟一个16大小的字符数组空间。
        StringBuilder s1 = new StringBuilder("truetest");
        s1.delete(1,4);//删除1-3索引的数据
        System.out.println(s1);//ttest
        s1.deleteCharAt(4);
        System.out.println(s1);//ttes
    }
}

5.StringBuilder的替换和反转功能

• 1.replace(int start , int end String s): 将StringBuilder所表示的字符序列，从start索引开始，到end结束，之间的字符使用s字符串进行替换。 

       返回值类型 StringBuilder 

• 2.reverse(): 将此字符序列用其反转形式取代

public class StringBuilderTest {
    public static void main(String[] args) {
        //1.创建一个StringBuilder对象，开辟一个16大小的字符数组空间。
        StringBuilder s1 = new StringBuilder();
        s1.append("falsehello123");
        s1.replace(1,5,"哈哈");//1-4索引范围的字符
        System.out.println(s1);//f哈哈hello123
        System.out.println(s1.reverse());//321olleh哈哈f
    }
}

6.String和StringBuilder的区别

• 1.String是一个不可变的字符序列。 StringBuilder是一个可变的字符序列。 
• 2.实际开发中，字符串拼接的需求 

 举例：提供数组 int[] arr = {1,2,45,67,8,-9};将数组中的所有内容拼接成一个字符串进行返回。

1)String字符串进行拼接
    String s = "["
    arr.length.fori
        s = s + arr[i] + ",";//整个过程，在常量池中频繁的创建字符串常量空间
2)StringBuilder
    StringBuffer s = new StringBuider("[");
    arr.length.fori
        s.append(arr[i]);//整个过程，只有StringBuilder对象

7.StringBuilder和StringBuffer的区别

StringBuffer、StringBuilder都是一个字符序列的缓冲区

• 1.StringBuffer类，开始于JDK1.0版本，线程安全的类。

         StringBuilder类，开始于JDK1.5版本，线程不安全。

• 单线程下，建议使用StringBuilder(main()方法是一个单线程) 
• 2.StringBuilder比StringBuffer运行速度快。 真实开发场景，StringBuilder使用率高一些

8.String和StringBuilder作为参数传递案例

public class StringBuilderTest {
    public static void main(String[] args) {
        String ss = "QQ";
        getString(ss);
        System.out.println(ss);//2.QQ
        System.out.println("=========================");
        StringBuilder sss = new StringBuilder("12");
        getStringBuilder(sss);
        System.out.println(sss);//4.12true
    }
    public static void getString(String s1){
        s1 = "123";
	System.out.println(s1);//1.123
    }
    public static void getStringBuilder(StringBuilder s2 ){
        s2.append("true");
        System.out.println(s2);//3.12true
    }
}

二.基本数据类型包装类

1.基本数据类型包装类的概述

4类8种基本数据类型，只能表示一些比较简单直接的数据
需要对这些基本数据类型的数据，进行一些操作，于是将这些基本数据类型封装起来，封装到一个类中，
将这个类称为基本数据类型的包装类。
使用场景：
    1.前端(数据的输入) ---> 后台系统(接收前台传递的数据，进行数据的处理)
        前端界面：输入项，用户注册界面
        用户名 --> String 
        密码 --> String 
        年龄 --> int 
        出生年月 --> 日期类型
    但是数据在系统之间进行传递的时候，全部都是以String类型字符串传递
    问题：需要将String类型，转换成int类型和对应的日期类型
    解决：创建了一个int类型的对应的引用数据类型，可以作为String和int之间的桥梁
    2.集合 
        集合中存储的所有数据，必须是引用数据类型

2.基本数据类型对应的包装类

byte   -->  Byte
short  -->  Short
int    -->  Integer
long   -->  Long
			
float   --> Float
double  --> Double
			
char    --> Character
boolean --> Boolean

3.Integer类型

• Integer 类在对象中包装了一个基本类型 int 的值，以后integer就表示这个int类型的数据

1.Integer构造方法
    1.Integer(int value): 将一个int类型数据，转换成一个Integer类型对象
    2.Integer(String s): 将String类型数据，转换成Integer类型的对象

public class IntegerDemo {
    public static void main(String[] args) {
        Integer it1 = new Integer(5);
        System.out.println(it1);//5
        Integer it2 = new Integer("123");//不是所有的字符串都能转，否则报错。
        System.out.println(it2);//123

        //Integer it3 = new Integer( "abc"); //java.lang.NumberFormatException:
        System.out.println(it3);
    }
}

2.Integer转换方法
    1.intValue():非静态方法，创建对象使用，将一个integer类型的数据，转换成一个int类型的数据。
        返回值类型 int
    2.parseInt(String s): 静态方法，可以直接类名.调用。将一个字符串s 直接转换成int类型数据。
        返回值类型 int 
    不常用：3.toHexString(int i): 静态方法，将一个int类型的数据，转换成一个16进制的字符串
           4.toOctalString(int i) :静态方法，将一个int类型的数据，转换成一个8进制的字符串
	   5.toBinaryString(int i) :静态方法，将一个int类型的数据，转换成一个2进制的字符串
    6.valueOf(int i 、String s) : 静态方法，将一个int类型或者String类型转换成Integer类型

public class IntegerDemo {
    public static void main(String[] args) {
        //1.intValue()，integer -> int
        Integer i = new Integer("12");
        int age = i.intValue();
        System.out.println(age+1);//13
					
        //2.parseInt(String s),静态方法，String ->int
        int result = Integer.parseInt("345");
        System.out.println(result+1);//346

        //3.toHexString(int i),静态方法,int->16进制String 返回值类型String
        System.out.println(Integer.toHexString(15));//f

        //4.toOctalString(int i),静态方法,int->8进制String 返回值类型String
        System.out.println(Integer.toOctalString(15));//17

        //5.toBinaryString(int i),静态方法,int->2进制String 返回值类型String
        System.out.println(Integer.toBinaryString(15));//1111

        //6.valueOf(int i 、 String s),静态方法,int、String -> Integer
        System.out.println(Integer.valueOf(12));
    }
}

3.Integer的常量(了解)

public class IntegerDemo {
    public static void main(String[] args) {
        //1.Integer中的静态常量
        System.out.println(Integer.MAX_VALUE);//2147483647
        System.out.println(Integer.MIN_VALUE);//-2147483648
        //一个int类型的数据，占有4字节大小，每个字节对应8bit大小
        System.out.println(Integer.SIZE);//32
        //返回值类型 Class类型
        System.out.println(Integer.TYPE);//int
    }
}

4.自动装箱和自动拆箱
    自动装箱：表示将一个基本数据类型，封装成一个引用数据类型。
    自动拆箱：表示将一个引用数据类型，转换成一个基本数据类型。			
    自动装箱的体现：基本数据类型可以直接给引用数据类型赋值
        Integer i = 18;//将一个int类型的8，直接赋值为Integer类型变量i
    自动拆箱的体现: 引用数据类型可以直接和基本数据类型进行运算
        i = i + 5;
			
public class IntegerDemo {
    public static void main(String[] args) {
        //1.自动装箱
        Integer i1 = new Integer(18);
        Integer i2 = 18;
        //2.自动拆箱
        //(1)自动拆箱：将i的值进行自动拆箱，变成基本数据类型int 18，将18和5相加 = 23
        //(2)自动装箱：int类型 23又变为Integer类型
        i2 = i2+5;
        System.out.println(i2);//23
    }
}

三.正则表达式

1.正则表达式的概念

• 正则表达式本身就是一个字符串，能够表示一些规则。 
•  作用：进行数据的合法性验证

要求：客户注册一个QQ号码
    (1)全部都是数字
    (2)数字，0不能开头
    (3)整个QQ号码长度5-15位
    String qq = "QQ号码"；
    做一个正则表达式：
        [1-9][0-9]{4,14}  ->[1-9]:表示匹配1-9的数字
                          ->[0-9]:表示匹配0-9的数字
			  ->{4,14}:表示第二个中括号[0-9]数字出现的次数4-14次
优点：验证数据比较简单。
弊端：正则表达式写正确比较困难。

2.正则表达式的写作规则

• API中搜索pattern。 
• matches(String regex): 来自于String类中，表示字符串是否符合regex的正则表达式的规则 

       返回值类型 boolean

1.字符类，表示匹配一个字符
    [abc] :匹配一个字符，只能是abc中的其中一个
    [^abc] :匹配除了abc中的任意一个字符
    [0-9] :匹配0-9的任意一个数字
    [a-zA-Z] :匹配任何一个字母
public class RegexDemo {
    public static void main(String[] args) {
        regexMethod();
    }
    //正则表达式的字符匹配
    public static void regexMethod(){
        String regex1 = "[abc]";
        String regex2 = "[^abc]";
        String s1 = "1";
        if(s1.matches(regex1)){
            System.out.println("匹配！");
        }else{
            System.out.println("不匹配！");
        }
        System.out.println(s1.matches(regex2));
    }
}
2.预定义字符类
    . ：匹配任意一个字符
    \d：匹配0-9任意一个数字，单独出现表示转义的含义。单独出现时，必须写成\\d。
    \D: 匹配不是0-9中的任意一个字符
    \s: 匹配空格[ \t\n\x0B\f\r]
    \S: 匹配非空格字符
    \w: 匹配单个密码字符：[a-zA-Z_0-9]
    \W: 匹配与\W相反字符
public class RegexDemo {
    public static void main(String[] args) {
        regexMethod2();
    }
    public static void regexMethod2(){
        String regex = ".";
        String s = "0";
        System.out.println(s.matches(regex));
        System.out.println(s.matches("\\d"));//单独出现必须为\\d
    }
}
3.数量词
    regex{}: 表示regex出现的次数
    {n,}: 至少出现n次
    {n,m}: 出现的次数为n-m次
    {n}: 正好出现n次
public class RegexDemo {
    public static void main(String[] args) {
        qqMatch();
    }
    public static void qqMatch(){
        /*  要求：客户注册一个QQ号码
        (1)全部都是数字
        (2)数字，0不能开头
        (3)整个QQ号码长度5-15位*/
        String regex = "[1-9][0-9]{4,14}";//[0-9] == \\d
        String qq = "1234";
        System.out.println(qq.matches(regex));//false
    }
}

    键盘录入一个正整数n，创建一个大小为n的数组
    键盘录入m(m<=n)个整数，存入上述数组，
    当录入字符串"end"或者录入个数达到n时，结束录入
    并且将数组内容、数组最大值按照指定格式进行输出
    例如：
        请输入数组大小：
        10
        请输入若干整数
        2
        4
        5
        6
        7
        end 
    最终结果为：[2,4,5,6,7,0,0,0,0,0],最大值为7
import java.util.Arrays;
import java.util.Scanner;
public class HomeWork1 {
    public static void main(String[] args) {
        //1.创建一个键盘录入的Scanner对象
        Scanner sc = new Scanner(System.in);
        //2.键盘录入一个整数n，作为数组的长度
        System.out.println("请输入数组长度：");
        int count = sc.nextInt();
        while(count<=0){
            System.out.println("数组长度输入有误,请重新输入：");
            count = sc.nextInt();
        }
        //3.创建一个count大小的int类型的数组
        int[] arr = new int[count];
        //4.向arr数组中添加数据
        for (int i = 0; i < arr.length; i++) {
            String s = sc.next();
            if("end".equals(s)){//5.输入的数据以end结束
                break;
	    }else if(s.matches("[-]{0,1}[0-9]{1,}")){//输入的数据应该都是数字,-应该出现0次或1次，0-9至少出现一次
	        arr[i] = Integer.parseInt(s);//6.Integer的parseInt方法，可以将String类型转换为int类型
	    }else{
		System.out.println("输入有误，请重新输入！");
		i--;
	    }
	}
	//数组打印是地址，Arrays的toString(),打印的是数组内容
	System.out.println("最终的结果为： "+Arrays.toString(arr)+"最大值为："+maxInt(arr));//最终的结果为： [2, 4, 5, 6, 7, 0, 0, 0, 0, 0]最大值为：7
    }
    public static int maxInt(int[] arr){
        int maxi = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(maxi < arr[i]){
                int temp = arr[i];
                arr[i] = maxi;
                maxi = temp;
            }
        }
        return maxi;
    }
}

    有如下字符串"If you want to change your fate I think you need to learn java"
    每个单词之间都有空格分割，求出这个字符串中，包含多少单词
public class HomeWork2 {
    public static void main(String[] args) {
        String s = "If   you   want to change your fate I think you need to learn java";
        //String 类型中，有一个方法，split(String regex)根据给定正则表达式的匹配拆分此字符串。
        //将字符串以regex进行切割，方法的返回值类型string[]
        //1.将上述的字符串，需要通过空格进行拆分
        String[] ss = s.split(" {1,}");//空格的次数至少出现一次
        System.out.println(Arrays.toString(ss) );//[If, you, want, to, change, your, fate, I, think, you, need, to, learn, java]
        System.out.println("单词个数为："+ss.length);  //单词个数为：14
    }
}