笔记-java进阶之包装类、正则表达式、常见算法、Lambda表达式

​
​

活动地址：CSDN21天学习挑战赛

学习的最大理由是想摆脱平庸，早一天就多一份人生的精彩；迟一天就多一天平庸的困扰。各位小伙伴，如果您：
想系统/深入学习某技术知识点…
一个人摸索学习很难坚持，想组团高效学习…
想写博客但无从下手，急需写作干货注入能量…
热爱写作，愿意让自己成为更好的人…
…

包装类

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

为什么提供包装类?
1.java为了实现一切皆对象，为8种基本类型提供了对应的引用类型
2.后面的集合和泛型其实也只能支持包装类型，不支持基本数据类型

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

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

包装类特有的功能：

1.包装类的变量的默认值可以是null，容错率更高
2.可以把基本类型的数据转换成字符串类型
3.可以把字符串类型的数值转换成真实的数据类型

正则表达式

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

字符串对象提供了匹配正则表达式的方法：
public boolean matches(String regex);

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

System.out.println(“a”.matches(“[abc]”)); //true
System.out.println(“g”.matches(“[abc]”)); //false
System.out.println(“ab”.matches(“[abc]”)); //false
System.out.println(“ab”.matches(“[abc]+”)); //true

正则表达式在字符串方法中的应用：
public String replaceALL(String regex,String newStr)

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

正则表达式获取数据：

import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class test{
public static void main(String[] args) {
	String s = "java c++ python vb de ph ht cs js ";
	Pattern p = Pattern.compile("\\wh");
	Matcher m = p.matcher(s);
	while (m.find()) {
		String sub = s.substring(m.start(), m.end());
		System.out.println(sub); //th ph
		}
	}
}

常见算法

一、冒泡排序

public class BubbleSort {
	public void bubbleSort(int[] array) {
		int temp;
		boolean flag = true;
		for (int i = 0; i < array.length - 1 && flag == true; i++) {// 比较时为i
			flag = false;
			for (int j = 0; j < array.length - i - 1; j++) {
				if (array[j] > array[j + 1]) {// 如果要从大到小排序只需改变此处顺序即可
					temp = array[j + 1];
					array[j + 1] = array[j];
					array[j] = temp;
					flag = true;
				}
			}
			// 打印每趟排序结果
			for (int m = 0; m <= array.length - 1; m++) {// 输出时为i<=array.length-1
				System.out.print(array[m] + "t");
			}
			System.out.println();
		}
	}

	public static void main(String[] args) {
		BubbleSort bubbleSort = new BubbleSort();
		int[] array = { 5, 69, 12, 3, 56, 789, 2, 5648, 23 };
		bubbleSort.bubbleSort(array);
		System.out.println("排序后结果为：");
		for (int i = 0; i <= array.length - 1; i++) {// 输出时为i<=array.length-1
			System.out.print(array[i] + "t");
		}
	}

二、选择排序

public static void main(String[] args){
    int int[] arr = new int[]{1,6,8,9,2,3,5,4,7};
    for(int i=0;i<arr.length-1;i++){//每次循环都会找出最小的数
            int minIndex = i;//记录最小数的下标
            int minNum = arr[i];//记录最小数
            for(int j=i+1;j<arr.length;j++){//每次循环都会找出最小的数
                if(arr[j]<minNum){//如果当前数比最小数小，则更新最小数
                    minNum = arr[j];//更新最小数
                    minIndex = j;//更新最小数的下标
                }
            }
            arr[minIndex]=arr[i];//将最小数放到最前面
            arr[i]=minNum;//将标志位放到最小数原来所在的位置
        }
    
    for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]);
        }
}

三、二分查找

public static void main(String[] args) {
        //定义一个数组
        int[] arr = {10,14,16,25,28,30,35,88,100};
        int index =binarySearch(arr,100);
        System.out.println(index);
    }
    public  static int binarySearch(int[] arr,int data){
        int low = 0;
        int high = arr.length-1;
        while (low <= high){
            int mid = (low + high)/2;
            if (arr[mid] < data){
                low = mid+1;
            }else if (arr[mid] > data){
                high = mid -1;
            }else if (arr[mid] == data)
            return mid;
        }
        return -1;    
    }

Lambda表达式

Lambda表达式是JDK8开始后的一种新语法形式
作用：简化匿名内部类的代码写法
基本语法: (parameters) -> expression 或 (parameters) ->{ statements; }

1.paramaters：类似方法中的形参列表，这里的参数是函数式接口里的参数。这里的参数类型可以明确的声明也可不声明而由JVM隐含的推断。另外当只有一个推断类型时可以省略掉圆括号。

2.->：可理解为“被用于”的意思

3.方法体：可以是表达式也可以代码块，是函数式接口里方法的实现。代码块可返回一个值或者什么都不返回，这里的代码块等同于方法的方法体。如果是表达式，也可以返回一个值或者什么都不返回。

// 1. 不需要参数,返回值为 1
() -> 1
// 2. 接收一个参数(数字类型),返回其2倍的值
x -> 2 * x
// 3. 接受2个参数(数字),并返回他们的和
(x, y) -> x + y
// 4. 接收2个int型整数,返回他们的乘积
(int x, int y) -> x * y
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
(String s) -> System.out.print(s)