Java常用类（Integer类、正则表达式、Pattern和Matcher类）

最新推荐文章于 2023-09-15 20:30:00 发布

DuDuDu.

最新推荐文章于 2023-09-15 20:30:00 发布

阅读量2.4k

点赞数

本文链接：https://blog.csdn.net/weixin_44807446/article/details/96040517

版权

一、基本类型包装类

为什么会有基本类型包装类
为了对基本数据类型进行更多的操作,更方便的操作,java就针对每一种基本数据类型提供了对应的类类型.。
常用操作：常用的操作之一：用于基本数据类型与字符串之间的转换。
基本类型和包装类的对应
byte——Byte
short——Short
int——Integer
long——Long
float——Float
double——Double
char——Character
boolean——Boolean

二、Integer类

1.Integer类概述

Integer 类在对象中包装了一个基本类型 int 的值,
该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，
还提供了处理 int 类型时非常有用的其他一些常量和方法

2.构造方法

public Integer(int value)
public Integer(String s)

3.String和int类型的相互转换

//int --String
            int num = 100;
            String str = num + "";//方式1
            
            String.valueOf(num);//方式2

            String s = new Integer(num).toString();//方式3

 //String -----int
            String str2 = "50";
            Integer integer = new Integer(str2);
            int i = integer.intValue();//方式1,将包装类型，转换成他所对应的基本类型
            System.out.println(i + 1);
            
            int i1 = Integer.parseInt(str2);//方式2
            System.out.println(i1);

4.自动装箱和拆箱

JDK5的新特性
自动装箱：把基本类型转换为包装类类型
自动拆箱：把包装类类型转换为基本类型

        Integer ii = 100;//自动装箱
        ii += 200;//自动拆箱、自动装箱

注意事项
在使用时，Integer x = null;代码就会出现NullPointerException。
建议先判断是否为null，然后再使用。

        Integer integer = new Integer(1000);
        int i = integer.intValue(); //手动拆箱

        Integer integer1 = Integer.valueOf(100);//手动装箱
        Integer integer2 = Integer.valueOf("10000");

5.Integer的常用方法

        //String toString ()
        //返回一个表示该 Integer 值的 String 对象。
        //static String toString ( int i)
        //返回一个表示指定整数的 String 对象。

        //int intValue ()
        //以 int 类型返回该 Integer 的值。
        //static int parseInt (String s)
        //将字符串参数作为有符号的十进制整数进行解析。

        //static Integer valueOf ( int i)
        //返回一个表示指定的 int 值的 Integer 实例。
        //static Integer valueOf (String s)
        //返回保存指定的 String 的值的 Integer 对象。

        Integer i1 = new Integer(127);
        Integer i2 = new Integer(127);
        System.out.println(i1 == i2);//false
        //Integer重写了父类的equals方法，比较的是值是否相等
        System.out.println(i1.equals(i2));//true

        Integer i7 = 127;
        Integer i8 = 127;
        //没有超过一个字节 会从缓存里面取出一个对象
        System.out.println(i7 == i8);//true
        System.out.println(i7.equals(i8));//true

        Integer i5 = 128;
        Integer i6 = 128;
        //这个值，超过了一个字节的范围，回去重新new一个Integer对象
        System.out.println(i5 == i6);//false
        System.out.println(i5.equals(i6));//true

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

//需求：我有如下一个字符串:”91 27 46 38 50”，请写代码实现最终输出结果是：”27 38 46 50 91”
public class Demo {
    public static void main(String[] args) {
        String str="91 27 46 38 50";  
        String[] s = str.split(" ");
        //定义一个int数组
        int[] arr=new int[s.length];
        //遍历字符串数组，取出每一个元素，放到int数组里面
        for (int i = 0; i < s.length; i++) {
            arr[i]=Integer.parseInt(s[i]);
        }
        //排序
        Arrays.sort(arr);

        //遍历int数组拼串
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < arr.length; i++) {
            sb.append(arr[i]).append(" ");

        }
        String string = sb.toString().trim();
        System.out.println(string);
    }
}

三、正则表达式

1.正则表达式的概述

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

2.正则表达式的案例演示

检验校验qq号码.
要求必须是5 - 15 位数字，0 不能开头

public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的QQ号码");
        String qqNum = scanner.nextLine();
        boolean b = checkQQNum(qqNum);
        if (b) {
            System.out.println("QQ号码规则正确");
        } else {
            System.out.println("QQ号码规则有误");
        }
    }

    private static boolean checkQQNum(String qqNum) {
        //定义一个正则表达式
        String regx="[1-9][0-9]{4,14}";
        boolean matches = qqNum.matches(regx);
        return matches;
    }

检验手机号码
要求长度11位以 1开头，手机号码每一位都是数字，第二位 3 5 6 7 8 9

public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的手机号码");
        String phoneNum = scanner.nextLine();
        boolean b = checkPhoneNum(phoneNum);
        if (b) {
            System.out.println("规则正确");
        } else {
            System.out.println("规则不正确");
        }
    }
    private static boolean checkPhoneNum(String phoneNum) {
        String phoneRegx="[1][3,5,6,7,8,9][0-9]{9}";
        return phoneNum.matches(phoneRegx);

    }

3.正则表达式的组成规则

String regx = "a";
        regx = "[abcdef]"; //运行出现列表中的某一个字符
        regx = "[a-z]";//允许出现26个小写字母的任意一个
        regx = "[A-Za-z]";
        regx = "[0-9]";
        regx = "[a-zA-Z0-9]";
        regx = "[^0-9]"; //把不允许出现我列表中的任意一个
        regx = ".";//通配单个任意字符
        regx = "\\.";// \\ 转意字符 \\. 这个意思就是匹配点本身
        regx = "\\|";
        regx = "\\d";//"跟"[0-9]意思一样
        regx = "\\w";//跟 [a-zA-Z_0-9] 意思一样
        regx = "[a-z]+"; //+ 可以出现一个或多个
        regx = "a?"; //一次或一次也没有 比如 "" 空串 就是没有
        regx = "[a-z]*";//零次或多次  大于等于1次 都算多次
        regx = "[a-z]{6}";//正好6次
        regx = "[0-9]{6,}";//至少6个
        regx = "[0-9]{6,16}";//大于等于 6 小于等于16

4.正则表达式的分割功能

public static void main(String[] args) {
        String str = "张三=男=23";
        String[] strings = str.split("=");
        System.out.println(strings[0]);
        System.out.println(strings[1]);
        System.out.println(strings[2]);
        //根据正则切割字符
        String str1 = "张三=aaBBB&7dfefe男=SASDfdfedfefdfd23";
        String[] strings1 = str1.split("[=a-zA-Z]+");
        System.out.println(strings1[0]);
        System.out.println(strings1[1]);
        System.out.println(strings1[2]);
        
    }

5.正则表达式的替换功能

public class MyTest {
    public static void main(String[] args) {
  System.out.println("奥巴马是美国总统".replace("奥巴马", "*"));

   String str="a12133b2323233222cewrere1243434aadfd888";
   System.out.println(str.replaceAll("[0-9]+", ""));
    }
}

四、Pattern类和Matcher类

1.Pattern类和Matcher类的概述

pattern模式器：用来封装一个正则表达式
matcher匹配器：可以封装一个待匹配的数据
可以通过匹配器中的方法进行匹配

public static void main(String[] args) {
        //获取一个模式器
        Pattern p = Pattern.compile("a*b");
        //通过模式器获取一个匹配器
        Matcher m = p.matcher("aaaab");
        //进行匹配
        boolean b = m.matches();
        System.out.println(b);

        //如果说你只是想看一个字符串，符不符合一个正则表达式的规则，那么你就使用字符串类中的matches()方法
        boolean matches = "aaaaab".matches("a*b");
        System.out.println(matches);
    }

2.正则表达式的获取功能

Pattern和Matcher的结合使用
使用的是 find()方法和 group()方法

public static void main(String[] args) {
         // da jia ting wo shuo, jin tian yao xia yu, bu shang wan zi xi, gao xing bu?
        //把下面这个字符串中是三个字母组成的单词，获取出来
        String str="da jia ting wo shuo, jin tian yao xia yu, bu shang wan zi xi, gao xing bu?";
        //   \\b单词边界
        String strRgex="\\b[a-z]{3}";
        //把正则表达式封装到，模式器中
        Pattern p = Pattern.compile(strRgex);
        //获取匹配器，把待匹配的字符串传进去
        Matcher m = p.matcher(str);

        // boolean find () 尝试查找与该模式匹配的输入序列的下一个子序列。
        // String group () 返回由以前匹配操作所匹配的输入子序列。
        while (m.find()){
            String s = m.group();
            System.out.println(s);
        }
    }

DuDuDu.

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
Java常用类（Integer类、正则表达式、Pattern和Matcher类）

一、基本类型包装类为什么会有基本类型包装类为了对基本数据类型进行更多的操作,更方便的操作,java就针对每一种基本数据类型提供了对应的类类型.。常用操作：常用的操作之一：用于基本数据类型与字符串之间的转换。基本类型和包装类的对应byte——Byteshort——Shortint——Integerlong——Longfloat——Floatdouble——Doublechar...
复制链接

扫一扫