栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

15.包装类 正则表达式 Arrays类

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

15.包装类 正则表达式 Arrays类

包装类

        其实就是8种基本数据类型对应的引用类型

Java为了实现一切皆对象,为了8种基本类型提供了对应的引用类型

后面的集合和泛型其实也只是支持包装类型,不支持基本数据类型

自动装箱:基本类型的数据和变量可以直接赋值给包装类型的变量

自动拆箱:包装类型的变量可以直接赋值给基本数据类型的变量

包装类的特有功能:
包装类的变量的默认值可以是null,容错率更高。


可以把基本类型的数据转换成字符串类型(用处不大)
①调用toString()方法得到字符串结果。
②调用Integer.toString(基本类型的数据)。


可以把字符串类型的数值转换成真实的数据类型(真的很有用)
①Integer.parseInt(“字符串类型的整数”)
②Double.parseDouble(“字符串类型的小数”)

public class Test {
    public static void main(String[] args) {
        Integer it = 23;
        System.out.println(it);

        int age = 100;
        Integer it2 = age; // 自动装箱:可以把基本类型的变量直接赋值给包装类型的变量。
        System.out.println(it2);

        Integer it3 = 111;
        int age3 = it3;  // 自动拆箱:可以直接把包装类型的变量赋值给基本数据类型。
        System.out.println(age3);

        System.out.println("---------------------------");
        Integer it4 = 0;
        Integer it5 = null;

        // 包装类的特有功能2:把基本数据类型转换成字符串类型。
        Integer it6 = 23;
        String s1 = it6.toString(); // "23"
        System.out.println(s1 + 1); // 231

        Integer it7 = 23;
        String s2 =  Integer.toString(it7);
        System.out.println(s2 + 1); // 231

        String s3 = it7 + ""; // 字符串了!
        System.out.println(s3 + 1); // 231

        // 包装的特有功能3:把字符串类型的数值转换成对应的基本数据类型 (真的有用)
        String str = "23";
        // int a = Integer.parseInt(str); // 23
        int a = Integer.valueOf(str); // 23
        System.out.println(a + 1); // 24

        String str2 = "99.5";
//        double score = Double.parseDouble(str2);
        double score = Double.valueOf(str2);
        System.out.println(score + 0.5);
        
        ArrayList lists = new ArrayList<>();
    }
}

正则表达式

        正则表达式可以用一些规定的字符来制定规则,并用来校验数据格式的合法性

public class RegexDemo {
    public static void main(String[] args) {
        System.out.println(checkQQ("363921799"));
        System.out.println(checkQQ("363921799dazz"));

        System.out.println(checkQQ2("363921799"));
        System.out.println(checkQQ2("363921799dazz"));
    }

    public static boolean checkQQ2(String qq){
        return qq != null && !qq.startsWith("0") && qq.matches("\d{6,20}");
    }

    public static boolean checkQQ(String qq){
        // 1、判断qq是否为null,以及是否不满足6位以上。 不能以0开始。
        if(qq == null || qq.length() < 6 || qq.length() > 20 || qq.startsWith("0")) {
            return false;
        }
        
        // 2、必须全部是数字 遍历qq号码中的每个字符    323a242442
        for (int i = 0; i < qq.length(); i++) {
            char ch = qq.charAt(i);
            // 3、判断这个字符是否是非数字
            if(ch < '0' || ch > '9') {
                return false;
            }
        }
        
        // 4、返回正确
        return true;
    }
}

字符串对象提供了匹配正则表达式的方法:

public boolean matches​(String regex)

判断是否匹配正则表达式,匹配返回true,不匹配返回false

public class RegexDemo {
    public static void main(String[] args) {
        //public boolean matches(String regex):判断是否与正则表达式匹配,匹配返回true
        // 只能是 a  b  c
        System.out.println("a".matches("[abc]")); // true
        System.out.println("z".matches("[abc]")); // false

        // 不能出现a  b  c
        System.out.println("a".matches("[^abc]")); // false
        System.out.println("z".matches("[^abc]")); // true
        System.out.println("a".matches("\d")); // false
        System.out.println("3".matches("\d"));  // true
        System.out.println("333".matches("\d")); // false 每次只能匹配一个字符!

        System.out.println("z".matches("\w")); // true
        System.out.println("2".matches("\w"));// true
        System.out.println("21".matches("\w")); // false
        System.out.println("你".matches("\w")); // false
        System.out.println("你".matches("\W")); // true
        System.out.println("---------------------------------");
        //  以上正则匹配只能校验单个字符。

        // 校验密码
        // 必须是数字 字母 下划线 至少 6位
        System.out.println("242dxf_33".matches("\w{6,}"));
        System.out.println("243".matches("\w{6,}"));

        // 验证码 必须是数字和字符  必须是4位
        System.out.println("23dA".matches("[\w&&[^_]]{4}"));
        System.out.println("2_dA".matches("[\w&&[^_]]{4}"));
        System.out.println("24dA".matches("[a-zA-Z0-9]{4}"));
        System.out.println("2_dA".matches("[a-zA-Z0-9]{4}"));
    }
}

正则表达式在字符串方法中的使用:

public class RegexDemo {
    public static void main(String[] args) {
        String names = "小路dawd54845sdaw蓉儿516845wdaada小何";

        String[] nameArr = names.split("\w+");
        for (int i = 0; i < nameArr.length; i++) {
            System.out.println(nameArr[i]);
        }

        String result = names.replaceAll("\w+", ",");
        System.out.println(result);//小路,蓉儿,小何
    }
}

正则表达式支持爬取信息:

public class RegexDemo {
    public static void main(String[] args) {
        String rs = "学习Java,电话020-43422424,或者联系邮箱" +
                    "666666@qq.com,电话18432832633,0203232323" +
                    "邮箱dazz@qq.com,400-100-3233 ,4001003232";

        // 需求:从上面的内容中爬取出 电话号码和邮箱。
        // 1、设计爬取规则对象
        Pattern p = Pattern.compile("(0\d{2,7}-?\d{5,20})|(\w{2,30}@\w{2,20}(\.\w{2,10}){1,2})|(1[3-9]\d{9})");

        // 2、得到一个匹配器对象:集合爬取规则,内容。
        Matcher m = p.matcher(rs);

        // 3、开始爬取内容输出
        while (m.find()) {
            System.out.println(m.group());
        }
    }
}

Arrays类

        数组操作工具类,专门用于操作数组元素的

Arrays类常用API

public class ArraysDemo {
    public static void main(String[] args) {
        // 目标:学会使用Arrays类的常用API ,并理解其原理
        int[] arr = {10, 2, 55, 23, 24, 100};
        System.out.println(arr);

        // 1、返回数组内容的 toString(数组)
//        String rs = Arrays.toString(arr);
//        System.out.println(rs);

        System.out.println(Arrays.toString(arr));

        // 2、排序的API(默认自动对数组元素进行升序排序)
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));

        // 3、二分搜索技术(前提数组必须排好序才支持,否则出bug)
        int index = Arrays.binarySearch(arr, 55);
        System.out.println(index);

        // 返回不存在元素的规律: - (应该插入的位置索引 + 1)
        int index2 = Arrays.binarySearch(arr, 22);
        System.out.println(index2);

        // 注意:数组如果么有排好序,可能会找不到存在的元素,从而出现bug!!
        int[] arr2 = {12, 36, 34, 25 , 13,  24,  234, 100};
        System.out.println(Arrays.binarySearch(arr2 , 36));
    }
}

Arrays类的排序方法

自定义排序规则

        设置Comparator接口对应的比较器对象,来定制比较规则

                如果认为左边数据 大于 右边数据  返回正整数

                如果认为左边数据 小于 右边数据  返回负整数

                如果认为左边数据 等于 右边数据  返回0

import java.util.Arrays;
import java.util.Comparator;

public class ArraysDemo {
    public static void main(String[] args) {
        // 目标:自定义数组的排序规则:Comparator比较器对象。
        // 1、Arrays的sort方法对于有值特性的数组是默认升序排序
        int[] ages = {34, 12, 42, 23};
        Arrays.sort(ages);
        System.out.println(Arrays.toString(ages));

        // 2、需求:降序排序!(自定义比较器对象,只能支持引用类型的排序!!)
        Integer[] ages1 = {34, 12, 42, 23};
        
        Arrays.sort(ages1, new Comparator() {
            @Override
            public int compare(Integer o1, Integer o2) {
                // 指定比较规则。
//                if(o1 > o2){
//                    return 1;
//                }else if(o1 < o2){
//                    return -1;
//                }
//                return 0;
                // return o1 - o2; // 默认升序
                return o2 - o1; //  降序
            }
        });
        System.out.println(Arrays.toString(ages1));

        System.out.println("-------------------------");
        Student[] students = new Student[3];
        students[0] = new Student("大珍珠",23 , 175.5);
        students[1] = new Student("黑珍珠",18 , 185.5);
        students[2] = new Student("胖珍珠",20 , 195.5);
        System.out.println(Arrays.toString(students));

        // Arrays.sort(students);  // 直接运行奔溃
        Arrays.sort(students, new Comparator() {
            @Override
            public int compare(Student o1, Student o2) {
                // 自己指定比较规则
                // return o1.getAge() - o2.getAge(); // 按照年龄升序排序!
                // return o2.getAge() - o1.getAge(); // 按照年龄降序排序!!
                // return Double.compare(o1.getHeight(), o2.getHeight()); // 比较浮点型可以这样写 升序
                return Double.compare(o2.getHeight(), o1.getHeight()); // 比较浮点型可以这样写  降序
            }
        });
        System.out.println(Arrays.toString(students));
    }
}
public class Student {
    private String name;
    private int age;
    private double height;

    public Student() {
    }

    public Student(String name, int age, double height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + ''' +
                ", age=" + age +
                ", height=" + height +
                '}';
    }
}

常见算法 冒泡排序

        每次从数组中找出最大值放在数组的后面去

关键步骤:

        确定总共需要做几轮: 数组的长度-1

        每轮比较几次:

                i(轮数)       j(次数)      次数规律:  数组的长度 - i

                 1                3

                 2                2

                 3                1

        当前位置大于后一个位置则交换数据

选择排序

        每轮选择当前位置,开始找出后面的较小值与该位置交换

 关键步骤:

        确定总共需要选择几轮: 数组的长度-1

        控制每轮从以前位置为基准,与后面元素选择几次

二分查找

        二分查询性能好,二分查找的前提是必须是排好序的数据

二分查找相当于每次去掉一半的查找范围

二分查找正常的检索条件应该是开始位置min <= 结束位置max

数组的二分查找的实现步骤是什么样的?

        定义变量记录左边和右边位置。

        使用while循环控制查询(条件是左边位置<=右边位置)

        循环内部获取中间元素索引

        判断当前要找的元素如果大于中间元素,左边位置=中间索引+1

        判断当前要找的元素如果小于中间元素,右边位置=中间索引-1

        判断当前要找的元素如果等于中间元素,返回当前中间元素索引。

Lambda表达式

        Lambda表达式是JDK 8开始后的一种新语法形式,简化匿名内部类的代码写法

格式:

(匿名内部类被重写方法的形参列表) -> {
   被重写方法的方法体代码。
}

注:-> 是语法形式,无实际含义

注意:Lambda表达式只能简化函数式接口的匿名内部类的写法形式

函数式接口:首先必须是接口,其次接口中有且仅有一个抽象方法的形式

public class LambdaDemo {
    public static void main(String[] args) {

        goSwimming( new Swimming() {
            @Override
            public void swim() {
                System.out.println("去游泳吧~");
            }
        } );
    }

    public static void goSwimming(Swimming swimming) {
        swimming.swim();
    }
}
public class LambdaDemo {
    public static void main(String[] args) {
//简化
        goSwimming( () -> {
	            System.out.println("去游泳吧~") } );
            }

    public static void goSwimming(Swimming swimming) {
        swimming.swim();
    }
}

Lambda表达式简化Comparator接口的匿名形式

        注意:通常我们见到的函数式接口上都有一个@FunctionalInterface注解,标记该接口必须是满足函数式接口

public static void main(String[] args) {
    Integer[] ages = {66, 33, 22, 55, 88};

    Arrays.sort(ages, new Comparator(){
        @Override
        public int compare(Integer o1, Integer o2) {
            return o2 - o1;
        }
    });

    System.out.println("内容:" + Arrays.toString(ages));
}
public static void main(String[] args) {
    Integer[] ages = {66, 33, 22, 55, 88};
//简化
    Arrays.sort(ages, (Integer o1, Integer o2) -> {
            return o2 - o1;
    });


    System.out.println("内容:" + Arrays.toString(ages));
}

Lambda表达式的省略写法

        进一步在Lambda表达式的基础上继续简化

参数类型可以省略不写。

           如果只有一个参数,参数类型可以省略,同时()也可以省略。

           如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写,同时要省略分号!

           如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写。此时,如果这行代码是return语句,必须省略return不写,同时也必须省略";"不写

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/939044.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号