15、Java常用类（数组工具类Arrays）、基本类型包装类（Integer类）、正则表达式、String的split(String regex)和replaceAll(String regex, String replacement)

Arrays类

Arrays类概述

• 针对数组进行操作的工具类
• 提供了排序，查找等功能

Arrays类常用方法

toString()方法

package org.westos.demo1;

import java.util.Arrays;

/**
 * @author lwj
 * @date 2020/5/1 14:39
 */
public class MyTest {
    public static void main(String[] args) {
        byte[] arr1 = {1, 2, 3, 4, 5};
        short[] arr2 = {1, 2, 3, 4, 5};
        int[] arr3 = {1, 2, 3, 4, 5};
        long[] arr4 = {2L, 3L, 4L, 5L};
        char[] arr5 = {‘A‘, ‘B‘, ‘C‘, ‘D‘};
        boolean[] arr6 = {true, false};
        float[] arr7 = {0.7f, 1.9f};
        double[] arr8 = {0.2, 0.3};
        Object[] arr9 = {new Object(), new Object()};
        System.out.println(Arrays.toString(arr1));
        System.out.println(Arrays.toString(arr2));
        System.out.println(Arrays.toString(arr3));
        System.out.println(Arrays.toString(arr4));
        System.out.println(Arrays.toString(arr5));
        System.out.println(Arrays.toString(arr6));
        System.out.println(Arrays.toString(arr7));
        System.out.println(Arrays.toString(arr8));
        System.out.println(Arrays.toString(arr9));
    }
}

toString()方法的源码

public static String toString(int[] a) {
    if (a == null)
        return "null";
    int iMax = a.length - 1;
    if (iMax == -1)
        return "[]";

    StringBuilder b = new StringBuilder();
    b.append(‘[‘);
    for (int i = 0; ; i++) {
        b.append(a[i]);
        if (i == iMax)
            return b.append(‘]‘).toString();
        b.append(", ");
    }
}

sort()方法（七种基本数据类型（除了boolean） + 引用类型）

package org.westos.demo1;

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

/**
 * @author lwj
 * @date 2020/5/1 14:47
 */
public class MyDemo {
    public static void main(String[] args) {
        int[] arr = {13, 12, 23, 15, 47};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        //[12, 13, 15, 23, 47]

        double[] arr1 = {12.3, 11.9, 13.7, 22.1, 0.9};
        Arrays.sort(arr1);
        System.out.println(Arrays.toString(arr1));
        //[0.9, 11.9, 12.3, 13.7, 22.1]

        short[] arr2 = {12, 13, 1, 34, 11, 22};
        Arrays.sort(arr2, 2, 6);
        System.out.println(Arrays.toString(arr2));
        //[12, 13, 1, 11, 22, 34]

        //默认是从小到大排列，如果想要从大到小排列，必须是引用类型 + 比较器
        Integer[] arr3 = {13, 12, 23, 15, 47};
        Arrays.sort(arr3, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });
        System.out.println(Arrays.toString(arr3));
        //[12, 13, 15, 23, 47]

        Double[] arr4 = {12.3, 11.9, 13.7, 22.1, 0.9};
        Arrays.sort(arr4, (o1, o2) -> (int)(o2 - o1));
        System.out.println(Arrays.toString(arr4));
        //[22.1, 13.7, 12.3, 11.9, 0.9]
        //从大到小排序
    }
}

内部是使用快速排序，默认从小到大。

binarySearch()方法

package org.westos.demo1;

import java.util.Arrays;

/**
 * @author lwj
 * @date 2020/5/1 14:51
 */
public class Test {
    public static void main(String[] args) {
        int[] arr = {12, 13, 14, 15, 16};
        int key = 12;
        int index = Arrays.binarySearch(arr, key);
        System.out.println("key的在数组中的索引为" + index);
        //key的在数组中的索引为0
    }
}

binarySearch()方法的源码

public static int binarySearch(int[] a, int key) {
    return binarySearch0(a, 0, a.length, key);
}

private static int binarySearch0(int[] a, int fromIndex, int toIndex,
                                 int key) {
    int low = fromIndex;
    int high = toIndex - 1;

    while (low <= high) {
        int mid = (low + high) >>> 1;
        int midVal = a[mid];

        if (midVal < key)
            low = mid + 1;
        else if (midVal > key)
            high = mid - 1;
        else
            return mid; // key found
    }
    return -(low + 1);  // key not found.
}

equals()方法 和 toString()方法参数一致（8种基本数据类型 + 引用数据类型）

package org.westos.demo1;

import java.util.Arrays;

/**
 * @author lwj
 * @date 2020/5/1 14:53
 */
public class Demo {
    public static void main(String[] args) {
        int[] arr1 = {12, 13, 11, 23};
        int[] arr2 = {12, 11, 13, 23};
        boolean equals = Arrays.equals(arr1, arr2);
        System.out.println(equals);
        //false
        //Arrays.equals()方法，两个数组的对应索引的元素相等，两个数组才可以说相等
    }
}

equals()方法的源码

public static boolean equals(int[] a, int[] a2) {
    if (a==a2)
        return true;
    if (a==null || a2==null)
        return false;

    int length = a.length;
    if (a2.length != length)
        return false;

    for (int i=0; i<length; i++)
        if (a[i] != a2[i])
            return false;

    return true;
}

copyOf()方法

package org.westos.demo1;

import java.util.Arrays;

/**
 * @author lwj
 * @date 2020/5/1 16:50
 */
public class MyTest2 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        int[] value = Arrays.copyOf(arr, 10);
        System.out.println(value.length);
        //10
        System.out.println(Arrays.toString(value));
        //[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]
		
        
        int[] copy = Arrays.copyOf(arr, 3);
        System.out.println(copy.length);
        //3
        System.out.println(Arrays.toString(copy));
        //[1, 2, 3]
    }
}

源码

public static int[] copyOf(int[] original, int newLength) {
    int[] copy = new int[newLength];
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}

static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 
// 将指定源数组从指定位置复制到目标数组的指定位置。  

package org.westos.demo1;

import java.util.Arrays;

/**
 * @author lwj
 * @date 2020/5/2 9:39
 */
public class MyDemo2 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8};
        int[] array = new int[10];
        System.arraycopy(arr, 0, array, 0, arr.length);
        System.out.println(Arrays.toString(array));
        //[1, 2, 3, 4, 5, 6, 7, 8, 0, 0]
    }
}

copyOfRange()方法

package org.westos.demo1;

import java.util.Arrays;

/**
 * @author lwj
 * @date 2020/5/2 9:42
 */
public class Test2 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6};
        int[] copy = Arrays.copyOfRange(arr, 1, 4);
        //[1, 4)
        System.out.println(Arrays.toString(copy));
        //[2, 3, 4]
    }
}

基本类型的包装类

概述

Integer的基本用法

三个基本方法和两个基本属性

Integer.toBinaryString()
Integer.toOctalString()
Integer.toHexString()
Integer.MIN_VALUE
Integer.MAX_VALUE

package org.westos.demo;

/**
 * @author lwj
 * @date 2020/5/2 12:05
 */
public class MyDemo {
    public static void main(String[] args) {
        int num = 100;
        //将整数转为二进制、八进制、十六进制
        String s = Integer.toBinaryString(num);
        String s1 = Integer.toOctalString(num);
        String s2 = Integer.toHexString(num);
        System.out.println(s);
        //1100100
        System.out.println(s1);
        //144 = 64 + 32 + 4 = 100
        System.out.println(s2);
        //64 = 16 * 6 + 4 = 100

        Object o = new Object();
        System.out.println(o.toString());
        /*public String toString() {
            return getClass().getName() + "@" + Integer.toHexString(hashCode());
        }*/

        //判断一个数是否在int的范围内
        //Integer.MIN_VALUE Integer.MAX_VALUE
        if (num >= Integer.MIN_VALUE && num <= Integer.MAX_VALUE) {
            System.out.println("num在int类型的范围");
            //num在int类型的范围
        }
     }
}

构造方法

public Integer(int i)
public Integer(String s)

package org.westos.demo;

/**
 * @author lwj
 * @date 2020/5/2 12:13
 */
public class Test {
    public static void main(String[] args) {
        Integer integer = new Integer(123);
        Integer integer1 = new Integer("123");
        System.out.println(integer);
        //123
        System.out.println(integer1);
        //123

        Integer abc = new Integer("abc");
        //Exception in thread "main" java.lang.NumberFormatException: For input string: "abc"
        //数字格式异常，不能将非数字字符串转换为Integer类型
        System.out.println(abc);
    }
}

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

String ---> int
	int i = new Integer(String s).intValue()
	int i = Integer.parseInt(String s)

int ---> String
	拼接空串：100 + ""
	String.valueOf(int i)
	new Integer(int i).toString() //调用对象的方法

package org.westos.demo;

/**
 * @author lwj
 * @date 2020/5/2 12:18
 */
public class Demo {
    public static void main(String[] args) {
        //String ---> int
        //方式一
        int i = new Integer("123").intValue();
        //intValue()相当于手动拆箱
        System.out.println(i);
        //方式二
        int i1 = Integer.parseInt("123");
        System.out.println(i1);


        //int ---> String
        //方式一
        String s = 100 + "";
        //方式二
        String s1 = String.valueOf(100);
        System.out.println(s1);
        //方式三
        Integer integer = new Integer(100);
        String s2 = integer.toString();
        System.out.println(s2);
    }
}

Integer的自动装箱、自动拆箱

自动拆装箱：JDK1.5之后引入的一个新特性。

• 自动装箱：将一个基本数据类型自动转换为它所对应的包装类型
• 自动拆箱：将一个包装类型自动转换成它所对应的基本数据类型

package org.westos.demo2;

/**
 * @author lwj
 * @date 2020/5/2 12:23
 */
public class MyTest {
    public static void main(String[] args) {
        Integer integer = 100;
        //自动装箱

        Integer integer1 = 200;
        //自动装箱
        int i = integer1;
        //自动拆箱
    }
}

Integer valueOf(int i)
//手动装箱

int intValue(Integer integer)
//手动拆箱

package org.westos.demo2;

/**
 * @author lwj
 * @date 2020/5/2 12:29
 */
public class MyDemo {
    public static void main(String[] args) {
        //手动装箱
        int num = 100;
        Integer integer = Integer.valueOf(num);

        //一步（自动装箱）
        Integer integer1 = 100;

        //手动拆箱
        Integer integer2 = 200;
        int i = integer2.intValue();
        
        //一步（自动拆箱）
        int j = integer2;
    }
}

Integer integer = 200;
integer += 100;
//首先自动拆箱，从Integer类型拆箱int类型，计算完毕后，从int类型自动装箱为Integer类型

package org.westos.demo2;

/**
 * @author lwj
 * @date 2020/5/2 12:36
 */
public class Test {
    public static void main(String[] args) {
        Integer[] arr = {10, 20, 30, Integer.valueOf(40), new Integer(50)};
        //自动装箱

        int sum = 0;
        for (Integer integer : arr) {
            sum += integer;
            //自动拆箱
        }
        System.out.println(sum);
        //150
    }
}

Integer的面试题

package org.westos.demo;

/**
 * @author lwj
 * @date 2020/5/2 11:04
 */
public class MyTest {
    public static void main(String[] args) {
        Integer integer = new Integer(127);
        Integer integer1 = new Integer(127);
        System.out.println(integer == integer1);
        //false
        //警告：包装类型间的相等判断应该用equals，而不是‘==‘
        System.out.println(integer.equals(integer1));
        //true

        Integer integer2 = new Integer(128);
        Integer integer3 = new Integer(128);
        System.out.println(integer2 == integer3);
        //false
        System.out.println(integer2.equals(integer3));
        //true

        Integer integer4 = 127;
        Integer integer5 = 127;
        System.out.println(integer4 == integer5);
        //true
        System.out.println(integer4.equals(integer5));
        //true

        Integer integer6 = 128;
        Integer integer7 = 128;
        System.out.println(integer6 == integer7);
        //false
        System.out.println(integer6.equals(integer7));
        //true
    }
}

Integer类内部有一个私有静态内部类IntegerCache。

private static class IntegerCache {
    static final int low = -128;
    static final int high;
    static final Integer cache[];

    static {
        int h = 127;
        String integerCacheHighPropValue =
            sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
        if (integerCacheHighPropValue != null) {
            try {
                int i = parseInt(integerCacheHighPropValue);
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            } catch( NumberFormatException nfe) {
                // If the property cannot be parsed into an int, ignore it.
            }
        }
        high = h;
		//cache数组，length = (127+128) + 1 = 256
        cache = new Integer[(high - low) + 1];
        int j = low;
        for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);
        //为cache数组的每个元素赋值，cache[0] = -128,cache[1] = -127,cache[255] = 128

        // range [-128, 127] must be interned (JLS7 5.1.7)
        assert IntegerCache.high >= 127;
    }

    private IntegerCache() {}
}

所以使用

Integer i = 127;
Integer j = 127;

这种方式时，默认调用的是自动装箱方法，

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

所以，i和j指向同一个地址，用==比较时返回false。

[-128, 127]。

正则表达式

校验QQ号

package org.westos.demo;

import java.util.Scanner;

/**
 * @author lwj
 * @date 2020/5/2 13:49
 */
public class MyTest {
    public static void main(String[] args) {
        /*
        校验qq号
           1、5-15位数字
           2、0不能开头
         */
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你的qq号：");
        String qq = sc.nextLine();
        boolean b = checkQqNumber2(qq);
        if (b) {
            System.out.println("规则正确");
        } else {
            System.out.println("规则不正确");
        }
    }

    /**
     * 采用正则表达式校验
     * @param qq
     * @return
     */
    private static boolean checkQqNumber2(String qq) {
        String regex = "[1-9][0-9]{4,14}";
        //0不能开头,其余4-14位必须是数字
        return qq.matches(regex);
    }

    /**
     * 利用以前的知识
     * @param qq
     * @return
     */
    public static boolean checkQqNumber(String qq) {
        int length = qq.length();
        if (length >= 5 && length <= 15 && !qq.startsWith("0")) {
            for (int i = 0; i < qq.length(); i++) {
                char c = qq.charAt(i);
                //Character.isDigit(char c) 返回c是否是数字字符
                if (!(Character.isDigit(c))) {
                    return false;
                }
            }
        } else {
            return false;
        }
        return true;
    }
}

校验手机号

package org.westos.demo;

import java.util.Scanner;

/**
 * @author lwj
 * @date 2020/5/2 14:07
 */
public class MyDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个手机号");
        String phone = sc.nextLine();
        boolean b = checkPhoneNumber2(phone);
        if (b) {
            System.out.println("手机号规则正确");
        } else {
            System.out.println("手机号规则错误");
        }
    }

    private static boolean checkPhoneNumber2(String phone) {
        String regex = "[1][^012][0-9]{9}";
        //手机号以1开头,第二位不能是012,其余9位必须是数字
        return phone.matches(regex);
    }

    public static boolean checkPhoneNumber(String phoneNumber) {
        //以1开头，并且是11位
        //第二位是3 4 5 6 7 8 9
        if (phoneNumber.startsWith("1") && phoneNumber.length() == 11) {
            char c = phoneNumber.charAt(1);
            if (c == ‘0‘ || c == ‘1‘ || c == ‘2‘) {
                return false;
            }
            for (int i = 2; i < phoneNumber.length(); i++) {
                char ch = phoneNumber.charAt(i);
                if (!(Character.isDigit(ch))) {
                    return false;
                }
            }
        } else {
            return false;
        }
        return true;
    }
}

正则表达式的规则

匹配单个字符

package org.westos.demo;


/**
 * @author lwj
 * @date 2020/5/2 14:32
 */
public class Test {
    public static void main(String[] args) {
        //定义正则表达式
        String regex = "a";
        //只能匹配单个字符a,相当于[a]
        boolean b = "aaa".matches(regex);
        System.out.println(b);
        //false



        regex = "[abc]";
        //匹配列表中的任意一个单个字符
        boolean matches = "a".matches(regex);
        System.out.println(matches);
        //true

        regex = "[abcdefgABCDEFG123456]";
        boolean matches1 = "1".matches(regex);
        System.out.println(matches1);
        //true
        boolean matches2 = "8".matches(regex);
        System.out.println(matches2);
        //false

        regex = "[a-z]";
        //匹配所有的小写字母
        boolean matches3 = "b".matches(regex);
        System.out.println(matches3);
        //true


        regex = "[a-zA-Z0-9]";
        boolean matches4 = "Q".matches(regex);
        System.out.println(matches4);
        //true

        //上面的所有正则表达式都是只能匹配一个单个字符，因为只有一个[]
    }
}

package org.westos.demo;

/**
 * @author lwj
 * @date 2020/5/2 15:10
 */
public class Demo {
    public static void main(String[] args) {
        String regex = "[^5-9]";
        //取反，不是5-9
        boolean matches = "1".matches(regex);
        System.out.println(matches);
        //true

        regex = "[^a-z]";
        //不是小写字母
        boolean matches1 = "A".matches(regex);
        System.out.println(matches1);
        //true

        regex = ".";
        //匹配单个任意字符
        boolean matches2 = "a".matches(regex);
        System.out.println(matches2);
        //true


        regex = "...";
        //匹配三个任意字符
        boolean matches3 = "abc".matches(regex);
        System.out.println(matches3);
        //true

        regex = "\\.";
        //只匹配.本身
        boolean matches4 = ".".matches(regex);
        System.out.println(matches4);
        //true

        // | 或者 \\|代表|（进行转义）

        regex = "\\d";
        //匹配单个数字
        boolean matches5 = "0".matches(regex);
        System.out.println(matches5);
        //true


        regex = "\\D";
        //匹配非数字 [^\d]
        boolean matches8 = "a".matches(regex);
        System.out.println(matches8);
        //true

        regex = "\\w";
        //匹配[a-zA-Z_0-9],包括下划线
        boolean matches6 = "b".matches(regex);
        System.out.println(matches6);
        boolean matches10 = "_".matches(regex);
        System.out.println(matches10);
        //true

        regex = "\\W";
        //匹配非单词字符 [^\w]
        boolean matches7 = "中".matches(regex);
        System.out.println(matches7);
        //true

        regex = "\\s";
        //匹配空格
        boolean matches9 = " ".matches(regex);
        System.out.println(matches9);
        //true
    }
}

匹配多个字符

package org.westos.demo;

/**
 * @author lwj
 * @date 2020/5/2 15:51
 */
public class MyTest2 {
    public static void main(String[] args) {
        //匹配多个


        String regex = "[a-z]?";
        //?代表一次或一次也没有 [0, 1]
        boolean matches = "".matches(regex);
        System.out.println(matches);
        //true

        regex = "[a-z]*";
        //*代表零次或多次 [0, )
        boolean matches1 = "".matches(regex);
        System.out.println(matches1);
        //true

        regex = "[a-z]+";
        //+代表一次或多次 [1, )
        boolean matches2 = "abc".matches(regex);
        System.out.println(matches2);
        //true

        regex = "[a-z]{3}";
        //{3}代表恰好三次
        boolean matches3 = "bcd".matches(regex);
        System.out.println(matches3);
        //true

        regex = "[a-z]{4,}";
        //{4,}代表至少4次
        boolean matches4 = "afgjs".matches(regex);
        System.out.println(matches4);
        //true

        regex = "[0-9]{2,6}";
        //{2,6}代表至少2次不超过6次
        boolean matches5 = "12345".matches(regex);
        System.out.println(matches5);
        //true

        regex = "\\w{6}";
        //[a-zA-Z_0-9]恰好6次
        boolean matches6 = "aA_123".matches(regex);
        System.out.println(matches6);
        //true
    }
}

验证网易邮箱格式

package org.westos.demo;

/**
 * @author lwj
 * @date 2020/5/2 16:12
 */
public class MyDemo2 {
    public static void main(String[] args) {
        //检验邮箱格式
        //6-18位字符,字母开头,字母、数字、下划线组成
        String regex = "[a-zA-Z]\\w{5,17}@163\\.com";
        boolean matches = "westos@163.com".matches(regex);
        System.out.println(matches);
        //true
    }
}

正则表达式的分割功能

String类的功能：public String[] split(String regex)

package org.westos.demo;

import java.util.Arrays;

/**
 * @author lwj
 * @date 2020/5/2 16:35
 */
public class Test2 {
    public static void main(String[] args) {
        String regex = "[=]\\w*";
        //*代表零个或多个[a-zA-Z_0-9]
        String name = "张三=asdas李四=asd12王五=asdas12刘六";
        String[] split = name.split(regex);
        System.out.println(Arrays.toString(split));
        //[张三, 李四, 王五, 刘六]
    }
}

正则表达式的替换功能

String类的功能：public String replaceAll(String regex,String replacement)

package org.westos.demo;

import java.util.NavigableMap;

/**
 * @author lwj
 * @date 2020/5/2 16:44
 */
public class Demo2 {
    public static void main(String[] args) {
        String regex = "特朗普|奥巴马";
        String str = "特朗普和奥巴马是美国总统。";
        String s = str.replaceAll(regex, "*");
        System.out.println(s);
        //*和*是美国总统。


        regex = "[特朗普奥巴马]";
        //任意一个字符
        String s2 = str.replaceAll(regex, "*");
        System.out.println(s2);
        //***和***是美国总统。


        String name = "张三=asdas李四=asd12王五=asdas12刘六";
        regex = "[=a-zA-Z_0-9]+";
        //+代表一个或多个[=a-zA-Z_0-9]
        String s1 = name.replaceAll(regex, "=");
        System.out.println(s1);
        //张三=李四=王五=刘六
    }
}

练习

package org.westos.demo1;

import java.util.Arrays;

/**
 * @author lwj
 * @date 2020/5/2 16:54
 */
public class MyTest {
    public static void main(String[] args) {
        //字符串:”91   27  46    38         50”，请写代码实现最终输出结果是：”27 38 46 50 91”
        String source = "91   27  46    38         50";
        String regex = "\\s+";
        //匹配多个空格，至少一个
        String[] split = source.split(regex);
        int[] dest = new int[split.length];
        int index = 0;
        for (String str : split) {
            //Integer.parseInt(String s) 数字字符串转为int
            dest[index++] = Integer.parseInt(str);
        }
        //对int类型的数组进行排序
        Arrays.sort(dest);
        StringBuffer sb = new StringBuffer();
        //拼接数组元素
        for (int i = 0; i < dest.length; i++) {
            if (i == dest.length - 1) {
                sb.append(dest[i]);
            } else {
                sb.append(dest[i]).append(" ");
            }
        }
        String s = sb.toString();
        System.out.println(s);
        //27 38 46 50 91
    }
}

15、Java常用类（数组工具类Arrays）、基本类型包装类（Integer类）、正则表达式、String的split(String regex)和replaceAll(String regex, String replacement)

原文：https://www.cnblogs.com/shawnyue-08/p/12819332.html