Java基础知识 16（Arrays工具类，包装类，Integer类，自动手动拆箱装箱，正则表达式）

最新推荐文章于 2023-01-04 16:42:30 发布

骑着蜗牛行天下

最新推荐文章于 2023-01-04 16:42:30 发布

阅读量226

点赞数

分类专栏： Java基础文章标签：正则表达式 java

本文链接：https://blog.csdn.net/weixin_45447369/article/details/105963927

版权

Java基础专栏收录该内容

42 篇文章 0 订阅

订阅专栏

Java基础知识 16

Arrarys工具类

详细程序运行：E:\Java project\20200502-Arrays工具类-练习
Java中针对数组的操作，提供了一个工具类，来简化我对数组的操作。.Arrays
（1）把数组中的元素，拼接成一个字符串：
String s=Arrays.toString(arr);
（2）排序数组：Arrays.sort(arr)----------->双枢轴快速排序
System.out.println(Arrays.toString(arr));
指定一个范围进行排序
Arrays.sort(arr,5,arr.length-1);
//从小到大排序（从大到小排序）
Arrays.sort(arr,new Comparator()){
@override
public int compare(Integer a,Integer b){
return a-b;//a-b,从小到大，b-a,从大到小
}
System.out.println(Arrays.toString(arr));
}
（3）二分查找：前提是数组元素有序
int index=Arrays.binarySearch(arr,90);
System.out.println(index);
（4）判断两个数组中的元素是否相同
boolean string = Arrays.equals(arr,arr2);
（5）复制旧数组中的元素带一个新数组中，新的数组长度为newLength，从0开始复制到旧数组
//复制到旧数组中的元素到新数组中，可以指定长度。
int[] ints = Arrays.copyOf(arr, 5);
//可以指定旧数组中的几个元素，指定索引，含头不含尾。
int[] ints1 = Arrays.copyOfRange(arr, 2, 6);

public class Mytest {
    public static void main(String[] args) {
        //Java中针对数组的操作，提供了一个工具类，来简化我对数组的操作，Arrays
        int[] arr={12,23,34,45,56,67,78,89,2,6};
        //把数组中的元素拼接成一个字符串
        String s = Arrays.toString(arr);
        System.out.println(s);
        System.out.println("-----------------");
        //排序数组：Arrays.sort(arr)----->双枢轴快速排序算法
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        //指定一个范围进行排序
        /*Arrays.sort(arr,5,arr.length-1);
        System.out.println(Arrays.toString(arr));*/
        System.out.println("------------------");
        //从小到大排序
        Integer[] arr2 = {6, 9, 20, 30, 50, 2, 6, 0, 1, 4};
        Arrays.sort(arr2, new Comparator<Integer>() {
            @Override
            public int compare(Integer a, Integer b) {
                return a-b;//b-a，从大到小
            }
        });
        System.out.println(Arrays.toString(arr2));
        System.out.println("------------------");
        //二分查找，前提是数组要有序。
        int index = Arrays.binarySearch(arr, 89);
        System.out.println(index);
        System.out.println("------------------");
        //判断两个数组中的元素是否相同
        int[] arr3 = {20, 25, 30, 70, 80, 90, 90, 100};
        int[] arr4 = {20, 25, 30, 70, 80, 90, 90,1000};
        boolean b = Arrays.equals(arr3, arr4);
        System.out.println(b);
        System.out.println("------------------");
        //复制旧数组中的元素到一个新的数组，新的数组长度为newLength，从0开始复制旧数组。
        //复制旧数组中的元素到新数组中，可以指定长度。复制的元素都是排序后的元素
        int[] ints = Arrays.copyOf(arr, 5);
        System.out.println(Arrays.toString(ints));
        //可以指定旧数组中的几个元素，指定索引，含头不含尾。指定的几个元素都是排序后的元素
        int[] ints1 = Arrays.copyOfRange(arr, 2, 6);
        System.out.println(Arrays.toString(ints1));
    }
}

包装类

详细程序运行：E:\Java project\20200502-包装类-练习
Java为了方便我们操作这些基本类型，针对这些基本类型，Java提供了它的包装类型。
基本类型------------------------包装类型（应用类型）
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Char
boolean Boolean

Integer类型

详细程序运行：E:\Java project\20200502-包装类-练习
Integer类型在对象中包装了一个基本类型的int值。
Integer类型的对象包含了一个int类型的字符
int num=10;
String s = Integer.toBinaryString(num);//转换成二进制
System.out.println(s);
String s1 = Integer.toHexString(num);//转换成十六进制
System.out.println(s1);
String s2 = Integer.toOctalString(num);//转换成八进制
System.out.println(s2);
MAX_VALUE，值为2^31-1的常量，表示int类型能够表示的最大值
MIN_VALUE，值为-2^31的常量，表示int类型能够表示的最小值
Integer这个类重写了toString()方法，会打印包装它的值。
Integer这个类重写了equals()方法，比较的是两个值是否相等。

public class Mytest4 {
    public static void main(String[] args) {
        //Integer 这个类重写toString() 会打印他包装的值
        Integer a=100;
        String s = a.toString();
        System.out.println(s);//100
        System.out.println("----------------------");
        //Integer 重写了equals()比较的是两个他包装的值是否相同
        Integer integer = new Integer(100);
        Integer integer1 = new Integer(100);
        boolean equals = integer.equals(integer1);
        System.out.println(equals);//true
    }
}

把一个基本类型构造成它对应的包装类型：
int num=100;
Integer integer=new Integer(num);
System.out.println(integer);
String str=“123”;
Integer integer1=new Integer(str);
System.out.println(integer1);
String的数字和int类型的相互转换：

public class Mytest {
    public static void main(String[] args) {
        //String和int类型的相互转换
        //int ------> String
        int num=100;
        //1.拼接一个空的字符串
        String s = num + "";
        System.out.println(s);
        //2.采用String类型的valueOf()方法(记住)
        String s1 = String.valueOf(num);
        System.out.println(s1);
        //3.先把int类型转换成integer类型，在转换成字符串类型，最后再输出
        Integer integer = new Integer(num);
        String s2 = integer.toString();
        System.out.println(s2);
        System.out.println("--------------");
        //String-------->int
        String str="123456";
        //1.利用integer进行转换
        Integer integer1 = new Integer(str);
        //intValue():以 int 类型返回该 Integer 的值。
        int i = integer1.intValue();
        System.out.println(i);
        //2.integer里面的静态方法parseInt,将字符串参数作为有符号的十进制整数进行解析。
        int i1 = integer1.parseInt("123456");
        System.out.println(i1);
    }
}

自动拆装箱

详细程序运行：E:\Java project\20200502-包装类-练习
JDK1.5之后，引入一个新的特性。
自动装箱：将一个基本数据类型自动转换成所对应的包装类型。
自动拆箱：将一个包装类型转换成它所对应的基本数据类型。

public class Mytest {
    public static void main(String[] args) {
        /*
         *自动拆装箱：JDK1.5之后，引入的一个新特性。
         * 自动装箱：将一个基本数据类型自动转换成所对应的包装类型
         * 自动拆箱：将一个包装类型转换成它所对应的基本类型
         */
        int num=100;
        //自动装箱：
        Integer integer=num;
        Integer integer1=200;
        //自动拆箱：
        Integer integer2 = new Integer(num);
        //将引用类型integer2自动拆箱成基本类型
        int a=integer2+2;
        System.out.println(a);
    }
}

手动装箱：调用了ValueOf()方法。
手动拆箱：调用了intValue()方法。

public class Mytest2 {
    public static void main(String[] args) {
        //手动拆箱,拆箱调用intValue()方法
        Integer a=20;
        int i = a.intValue();
        System.out.println(i);
        System.out.println("--------------");
        //手动装箱，装箱调用ValueOf()方法
        int num=100;
        Integer integer = Integer.valueOf(num);
        System.out.println(integer);
    }
}

自动装箱 在内部会调用 Integer.valueOf(128) 装箱
在Integer类里面有一个静态的内部类IntegerCache他有一个静态代码块，
当Integer类一加载，静态的的内部类IntegerCache也加载，IntegerCache他里面的静态代码块也得加载。
静态代码块里面会有一个Integer cache[];这个数组里面，放的就是一些提前创建好的Interge对象。
当我们采用 Integer i7 = 127;这种方式定义一个Integer对象时，如果值在 -128到127 之前，他会从cache[]数组中返回一个对象给你

public class Mytest {
    public static void main(String[] args) {
        Integer a = new Integer(127);
        Integer b = new Integer(127);
        System.out.println(a == b);//false
        //Integer这个类，重写了父类Object的equals()方法，比较的是两个值是否相同
        boolean equals = a.equals(b);
        System.out.println(equals);//true
        System.out.println("---------------");
        Integer c = new Integer(128);
        Integer d = new Integer(128);
        System.out.println(c == d);//false
        System.out.println(c.equals(d));//true
        System.out.println("---------------");
        //自动装箱
        Integer e=128;//new Integer(128)
        Integer f=128;//new Integer(128)
        System.out.println(e == f);//false
        System.out.println(e.equals(f));//true
        System.out.println("---------------");
        //自动装箱
        Integer g=127;
        Integer h=127;
        System.out.println(g == h);//true
        System.out.println(g.equals(h));//true
    }
}

正则表达式

详细程序运行：E:\Java project\20200502-正则表达式-练习
正则表达式是一种独立的语法，作用是定义一些规则，用来对数据进行规则的校验
定义正则表达式：
String regx="[a-z]";
String regx1="[A-Z]";
String regx2="[0-9]";
String regx3="[a-zA-Z0-9]";
（1）匹配：boolean b=“1”.matches(regx2);
（2）取反：String regx4="[^a-z]";是取反的意思。
（3）匹配单个任意字符：regx=".";
匹配两个任意字符：regx="…";
（4）只匹配点本身：regx="\\.";\\是转意字符
只匹配竖线： regx="\\|"；\\转意
（5）regx="\\w"和[a-zA-Z0-9]一样
\w---->单词字符 \W------->非单词字符，和[^\w]一样
（6）regx="\\d";跟[0–9]一样
regx="\\D",不是数字，跟[^0–9]一样
（7）regx="\\s",匹配空格字符。
（8）？表示一次或一次也没有，比如"“空串，就是没有
regx=“a?b?”;
regx=”[a-z]?";
（9）表示零次或多次，大于或等于1次，都算多次。
regx="a";
regx="[a-zA-Z0-9]*";
（10）+表示一次或多次
regx=“b+c+”;
regx="[a-zA-Z0-9]+";
regx=“a{3}”;{3}表示恰好3次
regx="\\w{6}",{6}表示恰好6次
regx="[0-9]{6,}",{6,}表示至少6次
regx="[a-zA-Z0-9]{6,12}",{6，12}表示小于等于12次，大于等于6次。

public class Mytest {
    public static void main(String[] args) {
        //定义正则表达式
        String regx="[a-z]";
        String regx1="[A-Z]";
        String regx2="[0-9]";
        String regx3="[a-zA-Z0-9]";
        System.out.println("------------------");
        //匹配大小写字母数字
        boolean s1 = "a".matches(regx);
        System.out.println(s1);
        boolean s4 = "a1".matches(regx);
        System.out.println(s4);
        boolean s2 = "A".matches(regx1);
        System.out.println(s2);
        boolean s5 = "A1".matches(regx1);
        System.out.println(s5);
        boolean s3 = "0".matches(regx2);
        System.out.println(s3);
        boolean s6 = "1a".matches(regx2);
        System.out.println(s6);
        boolean s0 = "a".matches(regx3);
        System.out.println(s0);
        System.out.println("------------------");
        //^ 取反 不是列表中的字母，
        String regx4="[^a-z]";
        boolean matches = "A".matches(regx4);
        System.out.println(matches);
        System.out.println("------------------");
        //匹配单个任意字符
        String s = ".";
        boolean matches1 = "1".matches(s);
        System.out.println(matches1);
        //匹配两个任意字符
        String s7 = "..";
        boolean matches2 = "12".matches(s7);
        System.out.println(matches2);
        System.out.println("------------------");
        //只匹配点本身 regx="\\.";\\是转义字符
        String s8 = "\\.";
        boolean matches3 = ".".matches(s8);
        System.out.println(matches3);
        //只匹配竖线|  regx="\\|";\\转义字符
        String s9 = "\\|";
        boolean matches4 = "|".matches(s9);
        System.out.println(matches4);
        System.out.println("------------------");
        //"\\w"和[a-zA-Z0-9]一样,包含下划线在内的所有数字和字母
        //[a-zA-Z0-9]==\w
        String s10 = "\\w";
        String s11 = "[a-zA-Z0-9]";
        //"\\w和[^\w]"意思一样
        String s12 = "\\W";
        String s13 = "[^\\w]";
        //"\\d"和[0-9]一样,[0-9]==\d
        regx="\\d";
        regx = "\\D";  // 跟 [^0 - 9] 意思一样
        regx="\\s"; //匹配空格字符
        //?表示一次或一次也没有，比如""空串，就是没有
        String s14 = "a?b?";
        boolean matches5 = "".matches(s14);
        System.out.println(matches5);
        String s15 = "[a-z]?";
        boolean matches6 = "a".matches(s15);
        System.out.println(matches6);
        System.out.println("------------------");
        //*表示零次或多次，大于等于一次，都算多次
        String a1 = "a*";
        boolean matches7 = "aaaaaaa".matches(a1);
        System.out.println(matches7);
        String a2 = "[a-zA-Z0-9]*";
        boolean matches8 = "123abcABC".matches(a2);
        System.out.println(matches8);
        System.out.println("------------------");
        //+表示一次或多次
        String a3 = "b+c+";//按顺序执行
        boolean matches9 = "bbbbcccc".matches(a3);
        System.out.println(matches9);//true
        String a4 = "b+c+";
        boolean matches10 = "bcbcbcbcbc".matches(a4);
        System.out.println(matches10);//false
        String a = "(bc)+";
        boolean matches00 = "bcbcbcbc".matches(a);
        System.out.println(matches00);//true
        String a5 = "[a-zA-Z0-9]+";
        System.out.println("asadadwefwef1535e".matches(a5));
        String a6 = "a{3}";//恰好3次a
        System.out.println("aaa".matches(a6));
        String a7 = "\\w{6}";//{6}恰好出现6次
        System.out.println("123abc".matches(a7));
        String a8 = "[0-9]{3,}";//{3，}最少出现3次
        System.out.println("456".matches(a8));
        String a9 = "[a-zA-Z0-9]{3,6}";//{3，6}最少3次，最多6次
        System.out.println("45f1aw".matches(a9));
    }
}

正则表达式的分割功能spilt()方法

import java.util.Arrays;

public class Mytest {
    public static void main(String[] args) {
        /*  A:
        正则表达式的分割功能 split () 方法
        String类的功能：public String[] split (String regex)
        B:
        案例演示
        年龄范围 "18-24"*/
        String name = "联想笔记本=华硕笔记本=戴尔笔记本";
        String s1 = name.substring(0, name.indexOf("="));
        System.out.println(s1);
        String s2 = name.substring(name.indexOf("=")+1, name.lastIndexOf("="));
        System.out.println(s2);
        String s3 = name.substring(name.lastIndexOf("=")+1);
        System.out.println(s3);
        System.out.println("----------------");
        //按照正则表达式来进行分割
        String[] split = name.split("=");
        String s = Arrays.toString(split);
        System.out.println(s);
        String name1 = "联想笔记本=1351ewfwef华硕笔记本=4563feww3e戴尔笔记本";
        String[] split1 = name1.split("[=0-9a-z]+");
        System.out.println(Arrays.toString(split1));
    }
}

正则表达式的代替功能

public class Mytest2 {
    public static void main(String[] args) {
        //正则表达式的代替功能replaceAll()方法
        String s1 = "熊猫喜欢吃竹子";
        String replace = s1.replace("熊猫", "**").replace("竹子", "**");
        System.out.println(replace);
        System.out.println("--------------");
        //replaceAll()方法
        String s2 = "熊猫喜欢吃竹子";
        String s3 = s2.replaceAll("熊猫|竹子", "**");
        System.out.println(s3);
    }
}

骑着蜗牛行天下

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础知识 16（Arrays工具类，包装类，Integer类，自动手动拆箱装箱，正则表达式）

Java基础知识 16Arrarys工具类详细程序运行：E:\Java project\20200502-Arrays工具类-练习Java中针对数组的操作，提供了一个工具类，来简化我对数组的操作。.Arrays（1）把数组中的元素，拼接成一个字符串：String s=Arrays.toString(arr);（2）排序数组：Arrays.sort(arr)-----------&gt...
复制链接

扫一扫