day14【基础API与常见算法】

最新推荐文章于 2024-10-11 17:30:36 发布

张哈哈i

最新推荐文章于 2024-10-11 17:30:36 发布

阅读量200

点赞数

分类专栏：零基础 Java 初学者文章标签：字符串 java 正则表达式

本文链接：https://blog.csdn.net/m0_48852181/article/details/107967230

版权

Java 同时被 3 个专栏收录

11 篇文章 0 订阅

订阅专栏

初学者

11 篇文章 0 订阅

订阅专栏

零基础

10 篇文章 0 订阅

订阅专栏

day14【基础API与常见算法】

和数学相关的类

java.lang.Math

java.lang.Math` 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的工具类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单。

public static double abs(double a) ` ：返回 double 值的绝对值。
public static double ceil(double a)` ：返回大于等于参数的最小的整数。
public static double floor(double a) ` ：返回小于等于参数最大的整数。
public static long round(double a)` ：返回最接近参数的 long。(相当于四舍五入方法)
public static double pow(double a,double b)：返回a的b幂次方法
public static double sqrt(double a)：返回a的平方根
public static double random()：返回[0,1)的随机值
public static final double PI：返回圆周率
public static double max(double x, double y)：返回x,y中的最大值
public static double min(double x, double y)：返回x,y中的最小值

java.util.Random

用于产生随机数

@Test
	public void test03(){
		Random r = new Random();
		System.out.println("随机整数：" + r.nextInt());
		System.out.println("随机小数：" + r.nextDouble());
		System.out.println("随机布尔值：" + r.nextBoolean());
	}

数组的算法升华

反转

// 本类用于演示数组的反转，方式为借助新数组反转
public class OneTest {
    public static void main(String[] args) {
        int[] nums = {55,23,98,100,27,58};

        int[] newNums = new int[nums.length];// 创建新数组，借助这个数组反转原数组

        for(int i=0;i<nums.length;i++){
            newNums[newNums.length-1-i] = nums[i];// 依次将原数组正向位置的元素插入到新数组反向的位置。
        }
        nums = newNums;

        for (int num : nums) {
            System.out.println(num);
        }

    }
}

/ 本类演示数组反转，首尾交换元素的方式
public class TwoTest {
    public static void main(String[] args) {
        int[] nums = {55,23,98,100,27,58,79};

        for(int i = 0;i < nums.length / 2;i++){
            // 首尾元素交换
            int temp = nums[i];
            nums[i] = nums[nums.length-1-i];
            nums[nums.length-1-i] = temp;
        }

        for (int num : nums) {
            System.out.println(num);
        }
    }
}

数组工具类

public class SixTest {
    public static void main(String[] args) {
        int[] nums = {34,67,100,98,77,50};
        Arrays.sort(nums);
        //将数组变为字符串
        String s = Arrays.toString(nums);
        System.out.println(s);
/*        for (int num :nums){
            System.out.println(num);
        }*/
        //使用二分查找法搜索数组,需要先进行排序
        int index = Arrays.binarySearch(nums,50);
        System.out.println(index);
        //按照长度复制原数组的元素进入新的数组，可以扩容数组
        int[] newNums = Arrays.copyOf(nums,3);
        System.out.println(Arrays.toString(newNums));
        //from是从这个位置开始截取原数组，to是截取到这个位置的前一位。
        int[] newNumsTWo = Arrays.copyOfRange(nums,2,5);
        System.out.println(Arrays.toString(newNumsTWo));
    }
}

截取字符串

public class TwoTest {
    public static void main(String[] args) {
        // 截取字符串
        String one = "One World,One Dream!";

        String two = one.substring(5);// 从参数的索引位置开始截取到字符串末尾。
        System.out.println(two);

        String three = one.substring(5,10);// 从第一个参数索引位置开始，截取到第二个参数索引位置的前一位。
        System.out.println(three);

        String four = one.substring(5,one.length());// length()将返回字符串的长度。这个长度代表字符数，包含两端和中间的空格。
        System.out.println(one.length());
        String five = one.trim();// 去掉两端的空格。
        System.out.println(five.length());

正则匹配

boolean matchs(正则表达式)：判断当前字符串是否匹配某个正则表达式

常用正则表达式：

字符类

[abc]：a、b 或 c（简单类）

[^abc]：任何字符，除了 a、b 或 c（否定）

[a-zA-Z]：a 到 z 或 A 到 Z，两头的字母包括在内（范围）

预定义字符类

.：任何字符（与行结束符可能匹配也可能不匹配）

\d：数字：[0-9]

\D：非数字： [^0-9]

\s：空白字符：[ \t\n\x0B\f\r]

\S：非空白字符：[^\s]

\w：单词字符：[a-zA-Z_0-9]

\W：非单词字符：[^\w]

POSIX 字符类（仅 US-ASCII）

\p{Lower}小写字母字符：[a-z]

\p{Upper}大写字母字符：[A-Z]

\p{ASCII}所有 ASCII：[\x00-\x7F]

\p{Alpha}字母字符：[\p{Lower}\p{Upper}]

\p{Digit}十进制数字：[0-9]

\p{Alnum}字母数字字符：[\p{Alpha}\p{Digit}]

\p{Punct}标点符号：!"#$%&’()*+,-./:;<=>?@[]^_`{|}~

\p{Blank}空格或制表符：[ \t]

边界匹配器

^：行的开头

$：行的结尾

Greedy 数量词

X?：X，一次或一次也没有

X*：X，零次或多次

X+：X，一次或多次

X{n}：X，恰好 n 次

X{n,}：X，至少 n 次

X{n,m}：X，至少 n 次，但是不超过 m 次

Logical 运算符

XY：X 后跟 Y

X|Y：X 或 Y

(X)：X，作为捕获组

特殊构造（非捕获）

(?:X) X，作为非捕获组

(?=X) X，通过零宽度的正 lookahead

(?!X) X，通过零宽度的负 lookahead

(?<=X) X，通过零宽度的正 lookbehind

(?<!X) X，通过零宽度的负 lookbehind

(?>X) X，作为独立的非捕获组

常用类型

1.验证用户名和密码，要求第一个字必须为字母，一共6~16位字母数字下划线组成：（¹\w{5,15}$）

2.验证电话号码：xxx/xxxx-xxxxxxx/xxxxxxxx：（^(\d{3,4}-)\d{7,8}$）

3.验证手机号码：( ^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$ )

4.验证身份证号： (^{\d{15}$)|(^\d{18}$)|(}\d{17}(\d|X|x)$)

5.验证Email地址：(^\w+([-+.]\w+)@\w+([-.]\w+).\w+([-.]\w+)*$)

6.只能输入由数字和26个英文字母组成的字符串：(²+$)

7.整数或者小数：(³+(.[0-9]+){0,1}$)

8.中文字符的正则表达式：([\u4e00-\u9fa5])

9.金额校验(非零开头的最多带两位小数的数字)：(^([1-9][0-9]*)+(.[0-9]{1,2})?$)

10.IPV4地址：(((\d{1,2})|(1\d{1,2})|(2[0-4]\d)|(25[0-5]))\.){3}((\d{1,2})|(1\d{1,2})|(2[0-4]\d)|(25[0-5]))

String类和它的常用方法

1、String的创建对象的方法：

String s1 = "Tom";// 直接将常量池中的String对象地址赋值给引用
String s2 = new String("Tom");// 首先在常量池中有String对象，然后在堆中也会new对象，然后引用指向堆中对象，堆中的对象有个属性叫value指向常量池中的String对象。

2、String的不可变性：一个字符串对象一旦在声明的时候确定了串值，那么这个值将不再改变。由于字符串不可变，那么在拼接字符串的时候就会产生大量的对象。

3、String的常用方法：

String s1 = "nihao,";
s1 = s1.concat("chilema");//concat方法是拼接不是追加，所以拼接后会产生新的字符串，需要给引用重新赋值。

int index = s1.indexOf("ha");// 在调用方法的字符串中，从索引0开始查找第一次出现参数字符串的索引位置，找不到返回-1.
int index = s1.indexOf("ha"，3);// 在调用方法的字符串中，从第二个参数所以位置开始向后查找第一次出现参数字符串的索引位置，找不到返回-1.
int index = s1.indexOf(97);// 参数还可以是int型字符的编码值。
int index = s1.indexOf('a');// 参数还可以是int型字符的编码值。

int index = s1.lastIndexOf("ha");// 在调用方法字符串中，从下标0开始查找最后一次出现参数字符串的索引位置，找不到返回-1.
int index = s1.length();// 返回字符串中的字符数，包含中间和两端的空格。
boolean flag = s1.equals("Hello");// 比较两个字符串的字符值是否相等，区分大小写。
boolean flag = s1.equalsIgnoreCase("Hello");// 比较两个字符串值是否相等，不区分大小写。
String s = s1.toLowerCase();// 将调用方法的字符串全部转成小写字母。
String s = s1.toUpperCase();// 将调动方法的字符串全部转成大写字母。
String s = s1.substring(int beginIndex);// 从参数索引位置开始截取到字符串末尾。
String s = s1.substring(int beginIndex,int endIndex);// 从第一个参数索引位置开始截取到第二个参数位置的前一位。
char[] chars = s1.toCharArray();// 将字符串转成一个char型数组。
byte[] bytes = s1.getBytes();// 将字符串转成一个字节数组。
String[] strs = s1.spilt("");// 将一个String按照参数的正则表达式要求转成String的数组。
String s = s1.replace("","");// 将调用方法的String按照第一个参数的正则表达式全部转成第二个参数的正则表达式内容。

数索引位置开始截取到第二个参数位置的前一位。
char[] chars = s1.toCharArray();// 将字符串转成一个char型数组。
byte[] bytes = s1.getBytes();// 将字符串转成一个字节数组。
String[] strs = s1.spilt("");// 将一个String按照参数的正则表达式要求转成String的数组。
String s = s1.replace("","");// 将调用方法的String按照第一个参数的正则表达式全部转成第二个参数的正则表达式内容。