Java学习第七篇:与运行环境交互

目录

一.与用户互动

　　1.main方法形参

　　2.使用Scanner类获取输入

　　3.使用BufferedReader类获取输入

二.常用类

　　1.System类和Runtime类

　　2.String, StringBuilder和StringBuffer类

　　3.Math类

　　4.Random和ThreadLocalRandom类

　　5.BigDecimal类

　　6.Calendar类

三.正则表达式

　　1.正则表达式使用查询表

　　2.使用正则表达式

　　3.程序实例

正文

一.与用户互动

1.main方法的形参

main方法中包括一个字符串数组形参，根据方法调用的规则：谁调用方法，谁负责为形参赋值。也就是说，main方法由JVM调用，即args形参应该由JVM负责赋值。

public class ArgsTest {
    public static void main(String[] args) {
        System.out.println(args.length);
        for(String arg : args) {
            System.out.println(arg);
        }
    }
}

因程序放在本地的E:\myJavaCode下，所以运行命令和运行结果如下:

2.使用Scanner类获取输入

import java.util.*;
public class ScannerKeyBoardTest {
    public static void main(String[] args) {
        //System.in代表标准输入
        Scanner sc=new Scanner(System.in);
        //以回车作为分隔符
        sc.useDelimiter("\n");

        //判断是否还有下个输入项
        while(sc.hasNext()) {
            //输出
            System.out.println("键盘输入的内容是: "+sc.next());
        }
    }
}

运行结果:

Java
键盘输入的内容是: Java

C++
键盘输入的内容是: C++

PHP
键盘输入的内容是: PHP

注：如果将sc.useDelimiter("\n")这行注释，则默认以空格、Tab空白等作为分隔符。

Scanner不仅能读取用户键盘输入，还可以读取文件输入。

import java.io.*;
import java.util.*;
public class ScannerFileTest{
    public static void main(String[] args) throws Exception{
        //将一个File对象作为Scanner的构造参数,Scanner读取文件内容
        Scanner sc=new Scanner(new File("ScannerFileTest.java"));
        System.out.println("ScannerFileTest.java的文件内容为：");

        //判断是否还有下一行
        while(sc.hasNextLine()) {
            //输出下一行
            System.out.println(sc.nextLine());
        }
    }
}

运行结果:

3.使用BufferedReader类获取输入

import java.io.*;
public class KeyboardInTest {
    public static void main(String[] args) throws Exception {
        //创建BufferedReader对象
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

        //输出
        String line=null;
        while( (line=br.readLine()) !=null ) {
            System.out.println("用户从键盘输入的是: "+line);
        }
    }
}

运行结果:

Java
用户从键盘输入的是: Java
C++
用户从键盘输入的是: C++
PHP
用户从键盘输入的是: PHP

二.常用类

1.System类和Runtime类

Java程序在不同操作系统上运行时，可能需要取得平台相关的属性，或者调用平台命令来完成特定的功能。Java提供了System类和Runtime类来与程序的运行平台进行交互。

(1).System类

import java.io.*;
import java.util.*;
public class SystemTest {
    public static void main(String[] args) throws Exception{
        //获取系统所有的环境变量
        Map<String, String> env=System.getenv();
        for(String key : env.keySet() ) {
            System.out.println(key + "------>" + env.get(key));
        }

        //获取指定的环境变量
        System.out.println(env.get("JAVA_HOME"));

        //获取系统的所有属性,并将属性保存到文件props.txt文件中
        Properties props=System.getProperties();
        props.store(new FileOutputStream("props.txt"), "System Properties");

        //输出系统指定属性
        System.out.println(System.getProperty("os.name"));
    }
}

System类还提供了identityHashCode(Object x)方法，来判断两个对象是不是同一个对象。

public class IdentityHashCodeTest {
    public static void main(String[] args) {
        String s1=new String("Hello");
        String s2=new String("Hello");
        //String重写了hashCode()方法——改为根据字符序列计算hashCode值
        //因为s1和s2的字符序列相同,所以它们的hashCode()方法返回值相同
        System.out.println(s1.hashCode() + "---" + s2.hashCode());

        //s1和s2是不同的字符串对象,所以它们的identityHashCode值不同
        System.out.println(System.identityHashCode(s1)+"---"+
                           System.identityHashCode(s2)
                           );

        String s3="Java";
        String s4="Java";
        //s3和s4是相同的字符串对象,所以它们的hashCode()方法返回值和identityHashCode值相同
        System.out.println(s3.hashCode() + "---" + s4.hashCode());
        System.out.println(System.identityHashCode(s3)+"---"+
                System.identityHashCode(s4)
                );
    }
}

运行结果:

69609650---69609650
12258573---5629279
2301506---2301506
21350489---21350489

(2).Runtime类

每个Java程序都有一个与之对应的Runtime实例，应用程序通过该对象与其运行时环境相连。应用程序不能创建自己的Runtime实例，但可以通过getRuntime()方法获取与之关联的Runtime对象。

Runtime类代表Java程序的运行时环境，可以访问JVM的相关信息，如处理器数量、内存信息等。另外，Runtime类还可以直接单独启动一个进程来运行操作系统的命令。

public class RuntimeTest {
    public static void main(String[] args) throws Exception {
        //获取Java程序关联的运行时对象
        Runtime rt=Runtime.getRuntime();
        //访问JVM的相关信息
        System.out.println("处理器数量: "+rt.availableProcessors());
        System.out.println("空闲内存数: "+rt.freeMemory());
        System.out.println("可用最大内存数: "+rt.maxMemory());

        //运行记事本程序
        rt.exec("notepad.exe");
    }
}

2.String, StringBuilder和StringBuffer类

String, StringBuilder和StringBuffer类的具体方法见Java API文档。

public class StringBuilderTest {
    public static void main(String[] args) {
        StringBuilder sb=new StringBuilder();
        //追加字符串
        sb.append("java");
        System.out.println(sb);

        //插入
        sb.insert(0, "hello ");
        System.out.println(sb);

        //替换
        sb.replace(5, 6, ",");
        System.out.println(sb);

        //删除
        sb.delete(5, 6);
        System.out.println(sb);

        //反转
        sb.reverse();
        System.out.println(sb);

        //length
        System.out.println(sb.length());
        //capacity
        System.out.println(sb.capacity());

        //改变StringBuilder的长度
        sb.setLength(5);
        System.out.println(sb);
    }
}

运行结果:

java
hello java
hello,java
hellojava
avajolleh
9
16
avajo

3.Math类

Math类的具体方法见Java API文档。

public class MathTest {
    public static void main(String[] args) {
        /*----------下面是三角运算----------*/
        //将弧度转换成角度
        System.out.println("Math.toDegrees(1.57): "+Math.toDegrees(1.57));
        //将角度转换为弧度
        System.out.println("Math.toRadians(90): "+Math.toRadians(90));

        /*----------下面是取整运算----------*/
        //向下取整
        System.out.println("Math.floor(1.2): "+Math.floor(1.2));
        //向上取整
        System.out.println("Math.ceil(1.2): "+Math.ceil(1.2));
        //四舍五入
        System.out.println("Math.round(2.3): "+Math.round(2.3));

        /*----------下面是乘方、开方、指数运算----------*/
        //计算平方根
        System.out.println("Math.sqrt(2.3): "+Math.sqrt(2.3));
        //计算立方根
        System.out.println("Math.cbrt(9): "+Math.cbrt(9));
        //返回欧拉数e的n次幂
        System.out.println("Math.exp(2): "+Math.exp(2));
        //计算乘方
        System.out.println("Math.pow(3,2): "+Math.pow(3,2));
    }
}

运行结果:

Math.toDegrees(1.57): 89.95437383553926
Math.toRadians(90): 1.5707963267948966
Math.floor(1.2): 1.0
Math.ceil(1.2): 2.0
Math.round(2.3): 2
Math.sqrt(2.3): 1.51657508881031
Math.cbrt(9): 2.080083823051904
Math.exp(2): 7.38905609893065
Math.pow(3,2): 9.0

4.Random和ThreadLocalRandom类

ThreadLocalRandom类的用法与Random基本一致，只是ThreadLocalRandom用于并发访问的环境。

import java.util.Arrays;
import java.util.Random;

public class RandomTest {
    public static void main(String[] args) {
        Random rand=new Random();

        //生成随机布尔值
        System.out.println("rand.nextBoolean(): "+rand.nextBoolean());

        //生成随机byte
        byte[] buffer=new byte[16];
        rand.nextBytes(buffer);
        System.out.println(Arrays.toString(buffer));

        //生成0.0~1.0之间的伪随机double数
        System.out.println("rand.nextDouble(): "+rand.nextDouble());

        //生成平均值是0.0，标准差是1.0的伪高斯数
        System.out.println("rand.nextGaussian(): "+rand.nextGaussian());

        //生成一个处于int整数取值范围的伪随机数
        System.out.println("rand.nextInt(): "+rand.nextInt());

        //生成0~26之间的伪随机整数(包含0,但不包含26)
        System.out.println("rand.nextInt(26): "+rand.nextInt(26));

        //生成指定区间的随机数[min,max]
        //int rand=rand.nextInt(max-min+1)+min;
        //生成[120,230]之间的随机数
        System.out.println("[120,230]之间的随机数: "+(rand.nextInt(230-120+1)+120));

        //生成一个处于long整数值范围的伪随机数
        System.out.println("rand.nextLong(): "+rand.nextLong());
    }
}

运行结果:

rand.nextBoolean(): true
[47, -75, -97, -94, 63, 93, -22, -40, -79, -91, -4, -41, -90, 116, -73, 121]
rand.nextDouble(): 0.1644444197510042
rand.nextGaussian(): 0.8657605571241994
rand.nextInt(): -488956561
rand.nextInt(26): 13
[120,230]之间的随机数: 199
rand.nextLong(): 7184787237768710562

5.BigDecimal类

float,double两种基本类型容易引起精度的丢失，为此Java提供了BigDecimal类。

import java.math.BigDecimal;

public class BigDecimalTest {
    public static void main(String[] args) {
        BigDecimal f1=new BigDecimal("0.05");
        BigDecimal f2=BigDecimal.valueOf(0.01);
        BigDecimal f3=new BigDecimal(0.05);

        System.out.println("使用String作为BigDecimal构造器参数: ");
        System.out.println("0.05+0.01="+f1.add(f2));
        System.out.println("0.05-0.01="+f1.subtract(f2));
        System.out.println("0.05*0.01="+f1.multiply(f2));
        System.out.println("0.05/0.01="+f1.divide(f2));

        System.out.println("使用double作为BigDecimal构造器参数: ");
        System.out.println("0.05+0.01="+f3.add(f2));
        System.out.println("0.05-0.01="+f3.subtract(f2));
        System.out.println("0.05*0.01="+f3.multiply(f2));
        System.out.println("0.05/0.01="+f3.divide(f2));
    }
}

运行结果:

使用String作为BigDecimal构造器参数:
0.05+0.01=0.06
0.05-0.01=0.04
0.05*0.01=0.0005
0.05/0.01=5
使用double作为BigDecimal构造器参数:
0.05+0.01=0.06000000000000000277555756156289135105907917022705078125
0.05-0.01=0.04000000000000000277555756156289135105907917022705078125
0.05*0.01=0.0005000000000000000277555756156289135105907917022705078125
0.05/0.01=5.000000000000000277555756156289135105907917022705078125

注：从程序运行结果我们可以看出，创建BigDecimal对象时，不要直接使用double浮点数作为参数调用BigDecimal构造器，否则同样会发生精度丢失的问题。

如果程序中要求对double浮点数进行加、减、乘、除基本运算，则需要先将double类型数值包装成BigDecimal对象，调用BigDecimal对象的方法执行运算后再将结果转换成double类型变量。这是比较烦琐的过程，可以考虑以BigDecimal为基础定义一个Arith工具类。

import java.math.BigDecimal;

/**
 * Created by Administrator on 13-12-26.
 * Description: 如果程序中要求对double浮点数进行加、减、乘、除基本运算，则需要先将double类型数值
 *              包装成BigDecimal对象，调用BigDecimal对象的方法执行运算后再将结果转换成double类型
 *              变量。这是比较烦琐的过程，可以考虑以BigDecimal为基础定义一个Arith工具类.
 */
public class Arith {

    //默认除法运算精度
    private static final int DEF_DIV_SCALE=10;

    //构造器私有，让这个类不能实例化
    private Arith() {}

    /**
     * 提供精确的加法运算
     * @param v1 被加数
     * @param v2 加数
     * @return 两个参数的和
     */
    public static double add(double v1, double v2) {
        BigDecimal b1=BigDecimal.valueOf(v1);
        BigDecimal b2=BigDecimal.valueOf(v2);
        return b1.add(b2).doubleValue();
    }

    /**
     * 提供精确的减法运算
     * @param v1 被减数
     * @param v2 减数
     * @return 两个参数的差
     */
    public static double sub(double v1, double v2) {
        BigDecimal b1=BigDecimal.valueOf(v1);
        BigDecimal b2=BigDecimal.valueOf(v2);
        return b1.subtract(b2).doubleValue();
    }

    /**
     * 提供精确的乘法运算
     * @param v1 被乘数
     * @param v2 乘数
     * @return 两个参数的积
     */
    public static double mul(double v1, double v2) {
        BigDecimal b1=BigDecimal.valueOf(v1);
        BigDecimal b2=BigDecimal.valueOf(v2);
        return b1.multiply(b2).doubleValue();
    }

    /**
     * 提供相对精确的除法运算，当发生除不尽的情况时，精确到小数点以后10位的数字四舍五入
     * @param v1 被除数
     * @param v2 除数
     * @return 两个参数的商
     */
    public static double div(double v1, double v2) {
        BigDecimal b1=BigDecimal.valueOf(v1);
        BigDecimal b2=BigDecimal.valueOf(v2);
        return b1.divide(b2, DEF_DIV_SCALE, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    //主函数,测试
    public static void main(String[] args) {
        System.out.println("0.05+0.01=" +Arith.add(0.05, 0.01));
        System.out.println("1.0-0.42=" +Arith.sub(1.0, 0.42));
        System.out.println("4.05*1.03=" +Arith.mul(4.05, 1.03));
        System.out.println("12.0/7.0=" +Arith.div(12.0, 7.0));
    }
}

6.Calendar类

import java.util.Calendar;

public class CalendarTest {
    public static void main(String[] args) {
        Calendar c=Calendar.getInstance();
        //取出年
        System.out.println(c.get(Calendar.YEAR));
        //取出月(月份的起始值是0)
        System.out.println(c.get(Calendar.MONTH));
        //取出日
        System.out.println(c.get(Calendar.DATE));
        //分别设置年月日时分秒
        c.set(2003, 10, 23, 12, 32, 33);
        System.out.println(c.getTime());
        //将Calendar的年推前一年
        c.add(Calendar.YEAR, -1);
        System.out.println(c.getTime());
        //将Calendar的月推前8个月
        c.roll(Calendar.MONTH, -8);
        System.out.println(c.getTime());
    }
}

运行结果:

2013
11
27
Sun Nov 23 12:32:33 CST 2003
Sat Nov 23 12:32:33 CST 2002
Sat Mar 23 12:32:33 CST 2002

7.TimeZone类

import java.util.Arrays;
import java.util.TimeZone;

public class TimeZoneTest {
    public static void main(String[] args) {
        //取得Java所支持的所有时区ID
        String[] ids= TimeZone.getAvailableIDs();
        System.out.println(Arrays.toString(ids));
        TimeZone my=TimeZone.getDefault();
        //获取系统默认时区的ID
        System.out.println(my.getID());            //Asia/Shanghai
        //获取系统默认时区的名称
        System.out.println(my.getDisplayName());   //中国标准时间
        //获取指定ID的时区名称
        System.out.println(TimeZone.getTimeZone("CNT").getDisplayName()); //纽芬兰标准时间
    }
}

三.正则表达式

1.正则表达式使用查询表

贪婪模式：数量表示符默认采用贪婪模式，除非另有表示。贪婪模式的表达式会一直匹配下去，直到无法匹配为止。

勉强模式：它只会匹配最少的字符，也称为最小匹配模式。

占有模式：目前只有Java支持，很少用。

2.使用正则表达式

①String类提供的操作正则表达式的方法

②Pattern和Matcher类

Matcher类提供了如下几个常用方法

Pattern和Matcher类使用正则表达式的典型调用顺序如下

3.程序实例

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class FindGroup {
    public static void main(String[] args) {
        Matcher m= Pattern.compile("\\w+").matcher("Java is very easy!");
        while(m.find()) {
            System.out.println(m.group()+ "子串的起始位置: "+m.start()
                                        + "子串的结束位置: "+m.end());
        }
    }
}

运行结果:

Java子串的起始位置: 0子串的结束位置: 4
is子串的起始位置: 5子串的结束位置: 7
very子串的起始位置: 8子串的结束位置: 12
easy子串的起始位置: 13子串的结束位置: 17

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class ReplaceTest {
    public static void main(String[] args) {
        String[] msgs={
                "Java has regular expressions in 1.4",
                "regular expressions now expressing in Java",
                "Java represses oracular expressions"
        };
        Pattern p=Pattern.compile("re\\w*");
        Matcher matcher=null;
        for(String msg : msgs) {
            if(matcher==null) {
                matcher=p.matcher(msg);
            }else {
                matcher.reset(msg);
            }
            System.out.println(matcher.replaceAll("哈哈:)"));
        }
    }
}

运行结果:

Java has 哈哈:) exp哈哈:) in 1.4
哈哈:) exp哈哈:) now exp哈哈:) in Java
Java 哈哈:) oracular exp哈哈:)

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class MatchesTest {
    public static void main(String[] args) {
        String[] mails={
                "kongyeeku@163.com",
                "kongyeeku@gmail.com",
                "ligang@crazyit.org",
                "wawa@abc.xx"
        };
        String mailRegEx="\\w{3,20}@\\w+\\.(com|org|cn|net|gov)";
        Pattern mailPattern=Pattern.compile(mailRegEx);
        Matcher matcher=null;
        for(String mail : mails) {
            if(matcher==null) {
                matcher=mailPattern.matcher(mail);
            }
            else {
                matcher.reset(mail);
            }
            String result=mail + (matcher.matches() ? "是" : "不是")
                               + "一个有效的邮件地址!";
            System.out.println(result);
        }
    }
}

运行结果:

kongyeeku@163.com是一个有效的邮件地址!
kongyeeku@gmail.com是一个有效的邮件地址!
ligang@crazyit.org是一个有效的邮件地址!
wawa@abc.xx不是一个有效的邮件地址!