JavaSE基础进阶学习day07

包装类

一.包装类

1包装类是什么

(1)其实就是8中基本数据类型对应的引用类型

基本数据类型	引用数据类型
byte	Byte
short	Short
int	Integer
long	Long
char	Character
float	Float
double	Double
boolean	Boolean

2为什么提供包装类？

(1)Java为了实现一切皆对象，为8中基本类型提供了对应的引用类型

(2)后面的集合和泛型其实也只能支持包装类型，不支持基本类型

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

4自动拆箱：包装类的变量可以直接复制个自基本数据类型的变量。

5包装类的特有功能

(1)包装类的变量的默认值可以使null，容错率更高
(2)可以吧基本类型的数据转换成字符串类型（用处不大）
        ①调用toString()方法得到字符串结果
        ②调用Integer.toString(基本类型的数)。

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

6总结

(1)包装类是什么，目的是什么？
（I）基本数据类型对应的引用类型。
（II）实现了一切皆对象
（III）后期集合和泛型不支持基本类型，只能使用包装类。

(2)包装类有哪些特殊功能？
（I）可以把基本类型的数据转换成字符串类型（用处不大）
（II）可以把字符串类型的数值转换成真实的数据类型（很有用）

package com.itheima.d5_integer;

import java.sql.SQLOutput;

/**
 * 目标：明白包装类的概念，并使用
 */
public class Test {
    public static void main(String[] args) {
        int a = 10;
        Integer a1 = 11;
        Integer a2 = a;//自动装箱
        System.out.println(a);
        System.out.println(a1);

        Integer it = 100;
        int it1 = it;//自动拆箱
        System.out.println(it1);

        double db = 99.5;
        Double db2 = db;//自动装箱了
        double db3 = db2;//自动拆箱
        System.out.println(db3);

        //int age = null;//报错
        Integer age1 = null;
        Integer age2 = 0;

        System.out.println("-----------------------");
        //1包装类可以把基本类型的数据转换成字符串形式。
        Integer i3 = 23;
        String rs = i3.toString();
        System.out.println(rs + 1);

        String rs1 = Integer.toString(i3);
        System.out.println(rs1 + 1);

        //可以直接+字符串得到字符串类型
        String rs2 = i3 + "";
        System.out.println(rs2 + 1);

        System.out.println("----------------------");
        String number = "23";
        //转换成参数
        //int age = Integer.parseInt(number);
        int age = Integer.valueOf(number);
        System.out.println(age + 1);


        String number1 = "99.9";
        //转化成小数
        double score = Double.valueOf(number1);
        System.out.println(score + 0.1);
    }
}

正则表达式

一.正则表达式概述、初体验

1正则表示：

(1)正则表达式可以用一些规定的字符指定规则，并用来校验数据格式的合法性

2正则表达式初体验

(1)需求：假如现在要去检验一个qq号码是否正确，6位及20位之内，必须全部是数字

(2)先使用目前所学知识完成校验需求；然后体验一下正则表达式检验

二.正则表达式的匹配规则d

1API文档搜索Pattern

 

package com.itheima.d6_regex;

/**
 * 目标:全面，深入学习正则表达式的规则
 */
public class RegexDemo2 {
    public static void main(String[] args) {
        //public boolean matches(String regex):判断是否与正则表达式匹配，匹配返回true
        //只能是a  b  c
        System.out.println("a".matches("[abc]"));
        System.out.println("z".matches("[abc]"));

        //不能是abc
        System.out.println("a".matches("[^abc]"));
        System.out.println("z".matches("[^abc]"));

        System.out.println("a".matches("\\d"));
        System.out.println("3".matches("\\d"));
        System.out.println("333".matches("\\d"));
        System.out.println("z".matches("\\w"));
        System.out.println("2".matches("\\w"));
        System.out.println("21".matches("\\w"));
        System.out.println("您".matches("\\w"));
        System.out.println("-----------------");
        //以上正则表达式只能校验单个字符。

        //检验密码
        //必须是数字 字母 下划线 至少6位
        System.out.println("22312312asda".matches("\\w{6,}"));
        System.out.println("2232".matches("\\w{6,}"));

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

2总结：
(1)String类的哪个方法可以与正则表达式进行匹配

public boolean matches(String regex):
判断是否匹配正则表达式，匹配返回true，不匹配放回false

三.正则表达式的常见案例

需求：

①请编写程序模拟用户输入手机号码、验证格式正确，并给出提示，直到格式输入正确为止
②请编写程序模拟用户输入邮箱号码、验证格式正确，并给出提示，直到格式输入正确为止
③请编写程序模拟用户输入电话号码、验证格式正确，并给出提示，直到格式输入正确为止

package com.itheima.d6_regex;

import java.util.Scanner;

public class RegexTest3 {
    public static void main(String[] args) {
        //目标：校验手机号码 邮箱 电话号码
        checkPhone();
        checkEmail();
        checkTel();
    }


    public static void checkTel(){
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请您输入您的注册电话号:");
            String Tel = sc.next();
            //判断邮箱的格式是否正确
            if (Tel.matches("0\\d{2,7}-?\\d{5,20}")){
                System.out.println("格式正确，注册完成！");
                break;
            }else {
                System.out.println("格式错误！");
            }
        }

    }

    public static void checkEmail(){
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请您输入您的注册手机号:");
            String email = sc.next();
            //判断邮箱的格式是否正确
            if (email.matches("\\w{1,30}@[a-zA-Z0-9]{2,20}(\\.[a-zA-Z0-9]{2,20}){1,2}")){
                System.out.println("邮箱格式正确，注册完成！");
                break;
            }else {
                System.out.println("格式错误！");
            }
        }

    }


    public static void checkPhone(){
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请您输入您的注册手机号:");
            String phone = sc.next();
            //判断手机号码的格式是否正确
            if (phone.matches("1[3-9]\\d{9}")){
                System.out.println("手机号码格式正确，注册完成！");
                break;
            }else {
                System.out.println("格式错误！");
            }
        }

    }
}

四.正则表达式在方法中的应用

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

方法名	说明
public String replaceAll(String regex , String newStr)	按照正则表达式匹配的内容进行替换
public String[] split(String regex):	按照正则表达式匹配的内容进行分割字符串，返回一个字符串数组

package com.itheima.d6_regex;

/**
 * 目标：正则表达式在方法中的应用
 */
public class RegexDemo4 {
    public static void main(String[] args) {
        String names = "小路dsdada蓉儿dadadadawsa过儿";
        String[] arrs = names.split("\\w+");
        for (int i = 0; i < arrs.length; i++) {
            System.out.println(arrs[i]);
        }

        String names2 = names.replaceAll("\\w"," ");
        System.out.println(names2);
    }
}

五.正则表达式爬取信息

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

String rs = "来黑马程序学习Java,电话020- 43422424.或者联系邮箱"+"itcast@itcast.cn,电话18762832633. 0203232323" + "邮箱bozai@itcast.cn.400- 100- 3233，4001003232";
//需求:从上面的内容中爬取出电话号码和邮箱。
//需求:从上面的内容中爬取出电话号码和邮箱。
String regex - "(\\w{1, }@\\W{2,10}(11. \\w{2,10}){1,2})1" + "(1[3-9]\\d{9})|(0\\d{2,5}-?\d{5,15}) |400- ?\\d{3,8}-?\\d{3,8}";
// 2. 編译正则表达式成为-个匹配规则对象
Pattern pattern = Pattern. compile(regex);
// 3. 通过匹配规则对象得到一- 个匹配敬据内容的匹配器对象
Matcher matcher = pattern. matcher(rs);
// 4.酒过匹配器去内容中爬取出信息
while(matcher . find()){
        system.out. println(matcher .group());
}

Arrays类

一.Arrays类概述，常用功能演示

1Arrays类概述

(1)数组操作工具类，专门用于操作数组元素的

2Arrays类的常用API

方法名	说明
public static String toString(属性[] a)	对数组就西宁排序
public static void sort(类型[] a)	对数组进行默认升序排序
public static <T> void sort(类型[] a,Comparator<? super T> c)	使用比较器对象自定义排序
public static int binarySearch(int[] a,int key)	二分搜索数组中的数据，存在返回索引，不存在返回-1

package com.itheima.d7_arrays;

import java.util.ArrayList;
import java.util.Arrays;

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

        //1返回数组内容的toSring(数据)
        //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,50);
        System.out.println(index);

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

        //注意：数组如果没有排好序，可能会找不到存在的元素，从而出现bug
        int[] arr2 = {11 , 22 ,44 , 33 , 12};
        System.out.println(Arrays.binarySearch(arr2,33));
    }
}

二.Arrays类对于Comparator比较器的支持

1Arrays类的排序方法

方法名	说明
public static void sort(类型[] a)	对数组进行默认升序排序
public static <T> void sort{类型[] a,Comparator<? super T>C}	使用比较器对象自定义排序

2自定义排序规则
设置Comparator接口对应的比较器对象，来定制比较规则

如果认为左边数据 大于 右边数据 返回正整数
如果认为左边数据 小于 右边数据 返回负整数
如果认为左边数据 等于 右边数据 返回0

package com.itheima.d7_arrays;

public class Students {
    private String name;
    private int age;
    private double height;

    public Students() {
    }

    public Students(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 "Students{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", height=" + height +
                '}';
    }
}

package com.itheima.d7_arrays;

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

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

        //2需求：降序排序(自定义比较器对象，只能支持引用类型的排序！)
        Integer[] ages1 = {34 , 12 , 23 , 42};
        /**
         * 参数1：被排序的数组 必须引用类型的元素
         * 参数2：匿名内部类对象，代表一个比较器对象
         */
        Arrays.sort(ages1 , new Comparator<Integer>() {
            @Override
            public int compare(Integer o1 , Integer o2) {
               /* //指定比较规则
                if (o1 > 02){
                    return 1;
                }else if (o1 < o2){
                    return -1;
                }
                return 0;*/
                //return o1 - o2;//默认升序
                return -(o1 - o2);
            }
        });
        System.out.println(Arrays.toString(ages1));

        System.out.println("-----------------------");
        Students[] students = new Students[3];
        students[0] = new Students("吴磊" , 23 , 175.5);
        students[1] = new Students("协鑫" , 10 , 180.4);
        students[2] = new Students("鲁智深" , 99 , 110.0);
        System.out.println(Arrays.toString(students));

        //Arrays.sort(students);//直接运行崩溃
        Arrays.sort(students, new Comparator<Students>() {
            @Override
            public int compare(Students o1, Students 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));
    }
}

教学视频资源来自
Java入门基础视频教程，java零基础自学首选黑马程序员Java入门教程（含Java项目和Java真题）_哔哩哔哩_bilibili