Java 基础类库

与用户互动

1. 运行java程序的参数

　　public static void main(Stirng[] args)

　　这个方法是有JVM调用，因此用public static修饰，并且没有返回值，同时形参args由JVM负责赋值。

　　如果传进去的参数是多个，用空格隔开，用Java命令行运行程序，如下： 

　　java javaclasssName  arg1 arg2 ...  

　　如果参数本身含有空格，该参数用双引号“”括起来，否则JVM会把该空格当成参数分隔符

　　Java javaclassName "arg1 arg1.1"  arg2 ...

2. 使用Scanner获取键盘输入

　　Scanner是一个基于正则表达式的文本扫描器，它可以从文本、输入流、字符串中解析出基本类型值和字符串值。Scanner提供了多个构造器，不同的构造器可以接受文本、输入流、字符串作为数据源，用于从中解析数据。

　　主要提供了两个方法来扫描输入：

　　hasNextXxx： 是否还有下一个输入项，其中Xxx可以是Int，Long等代表基本类型的字符串。如果只是判断是否包含下一个字符串，则直接使用hasNext()

　　nextXxx: 获取下一个输入项，Xxx与上面相同。

　　在默认情况下，Scanner使用空白（包括空格、Tab空白、回车）作为多个输入项之间的分隔符。

public static void main(String[] args) {
        // System.in 代表标准输入，就是键盘输入
        Scanner sc = new Scanner(System.in);
        // 只把回车作为换行符
        sc.useDelimiter("
");
        // 判断是否还有下一个输入项
        while (sc.hasNext()) {
            // 输出输入项
            System.out.println("The input value is： " + sc.next());
        }
    }

 　　还有另外两个简单方法来逐行读取：

　　boolean hasNextLine():  返回输入源中是否还有下一行。

　　String nextLine()： 返回输入源中下一行的字符串。

系统相关

1. System类

　　System类代表当前java程序的运行平台，程序不能创建System类的对象，System类提供了一些类变量和类方法，允许直接调用。

　　System类提供了代表标准输入、标准输出和错误输出的类变量，并提供了一些静态方法用于访问环境变量、系统属性的方法，还提供了加载文件和动态链接库的方法。

public static void main(String[] args) throws Exception, IOException {
        Map<String, String> env = System.getenv();
        for (String name : env.keySet()) {
            System.out.println(name + "--->" + env.get(name));
        }
        // 获取指定环境变量的值
        System.out.println(System.getenv("JAVA_HOME"));
        // 获取所有的系统属性
        Properties props = System.getProperties();
        // 将所有的系统属性保存到文件中
        props.store(new FileOutputStream("props.txt"), "System Properties");
        // 输出特定的系统属性
        System.out.println(System.getProperty("os.name"));
    }

 2. Runtime类

　　Runtime类代表Java程序的运行时环境，每个Java程序都有一个与之对应的Runtime实例，应用程序通过该对象与其运行时环境相连。0

public static void main(String[] args) throws Exception{
        // 获取Java程序关联的运行时环境
        Runtime rt = Runtime.getRuntime();

        System.out.println("处理器数量：" + rt.availableProcessors());
        System.out.println("空闲内存数：" + rt.freeMemory());
        System.out.println("总内存数：" + rt.totalMemory());
        System.out.println("最大内存数：" + rt.maxMemory());

        // 直接单独起一个进程来运行操作系统的命令
        rt.exec("notepad.exe");
    }

常用类

1. Object类

　　它是所有类、数组、枚举类的父类。Java允许把任何类型的对象赋给Object类型的变量。

　　当定义一个类时，没有使用extends关键字为它显示指定父类，则该类默认继承Object类。

2. Objects类

　　它是工具类。

　　Java为工具类的命名习惯是添加一个字母s。

3. String、StringBuffer和StringBuilder类

　　String是不可变类，一旦String对象被创建，这个对象包含的字符串序列就不可改变，直到该对象被销毁。

　　StringBuffer对象则代表一个字符序列可变的字符串，可通过一系列方法改变字符串，如append(), insert(), remove(), 最后在通过toString()方法将其转换为String对象。

　　从JDK1.5新增 StringBuilder类。它和StringBuffer基本相似。不同的是，StringBuffer是线程安全的；StringBuilder没有实现线程安全功能，所以性能略高。（因此需要创建一个内容可变的字符串对象，优先考虑StringBuilder）

　　以上三者，都实现了CharSequence接口，因此CharSequence可以认为是字符串协议接口。

public static void main(String[] args) {
        String s = new String("abcdefghijk");
        // 字符串的序列从0开始到length()-1
        System.out.println(s.charAt(5)); // f

        String s1 = new String("abcdefghijk");
        String s2 = new String("abcdefghijklmn");
        String s3 = new String("abcdefghijkabcde");
        // 比较两个字符串的大小。
        // 如果两个字符串的字符序列相等，则返回0；不相等时，从两个字符串第0个字符开始比较，返回第一个不相等的字符差
        // 另一个情况，较长的字符串的前面部分恰巧是较短的字符串，则返回它们的长度差。
        System.out.println(s.compareTo(s1)); // 0
        System.out.println(s2.compareTo(s3)); // 返回'l'-'a'的差
        System.out.println(s1.compareTo(s2)); // 返回长度差

        
        StringBuilder sb = new StringBuilder();
        sb.append("java"); // java
        sb.insert(0, "Hello "); //Hello java
        sb.replace(5, 6, ","); //Hello,java
        sb.delete(5, 6); //Hellojava
        // 反转
        sb.reverse(); //avajolleH
        System.out.println(sb.toString());

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

        // 只保留指定长度
        sb.setLength(6);
        System.out.println(sb.toString()); // avajol
    }

4. Math类

　　是一个工具类。构造器被定义成private的，因此不能创建Math类的对象。Math类中的所有方法都是类方法。还有类变量：PI和E。

5. Random 与 Java7的ThreaLocalRandom

　　Random专门用来生成伪随机数。它有两个构造器：一个构造器使用默认的种子（以当前时间为种子）；另一构造器需要显示传入一个long型整数的种子。

public static void main(String[] args) {
        Random rand = new Random(System.currentTimeMillis());
        
        System.out.println(rand.nextBoolean());
        
        byte[] buffer = new byte[16];
        rand.nextBytes(buffer);
        System.out.println(Arrays.toString(buffer));
        
        // 生成0.0~1.0之间的随机double数
        System.out.println(rand.nextDouble());
        // 生成0.0~1.0之间的随机float数
        System.out.println(rand.nextFloat());
        // 生成int范围内的随机数
        System.out.println(rand.nextInt());
        // 生成0~20范围内的随机数
        System.out.println(rand.nextInt(20));
    }

　　ThreadLocalRandom是Java7新增的类，是Random的增强版。在并发环境下，可以减少多线程资源竞争，最终保证系统具有更好的线程安全性。它提供了一个静态的current() 方法来获取ThreadLocalRandom对象。

　　ThreadLocalRandom random = ThreadLocalRandom.current();

　　测试发现：

　　当两个Random对象的种子相同，而且方法的调用顺序也相同，它们就会产生相同的数字序列。所以说是是伪随机数。

　　为了避免上面这种情况，通常使用当前时间作为Random对象的种子。 

　　Random rand = new Random(System.currentTimeMillis())

6. BigDecimal类

　　解决float和double浮点数，容易引起精度丢失的问题。它能精确表示、计算浮点数。

　　它有很多构造器，但是，推荐使用基于String的构造器，因为该构造器的结果是可预知的。

　　如果程序需要对double浮点数进行加减乘除基本运算，则需要先将double类型数字包装成BigDecimal对象，调用BigDecimal对象的方法执行运算后再将结果转换成double型变量。

public class BigDecimalUtils {

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

    // 私有构造器，不能实例化
    private BigDecimalUtils() {

    }

    // 加
    public static double add(double d1, double d2) {
        BigDecimal b1 = BigDecimal.valueOf(d1);
        BigDecimal b2 = BigDecimal.valueOf(d2);
        return b1.add(b2).doubleValue();
    }

    // 减
    public static double sub(double d1, double d2) {
        BigDecimal b1 = BigDecimal.valueOf(d1);
        BigDecimal b2 = BigDecimal.valueOf(d2);
        return b1.subtract(b2).doubleValue();
    }

    // 乘
    public static double mul(double d1, double d2) {
        BigDecimal b1 = BigDecimal.valueOf(d1);
        BigDecimal b2 = BigDecimal.valueOf(d2);
        return b1.multiply(b2).doubleValue();
    }

    // 除
    // 当发生除不尽的时候，精确到小数点以后10位的数字四舍五入
    public static double div(double d1, double d2) {
        BigDecimal b1 = BigDecimal.valueOf(d1);
        BigDecimal b2 = BigDecimal.valueOf(d2);
        return b1.divide(b2, DEF_DIV_SCALE, BigDecimal.ROUND_HALF_UP)
                .doubleValue();
    }

    public static void main(String[] args) {
        System.out.println(add(0.05, 0.01));
        System.out.println(mul(0.005, 0.123));
        System.out.println(div(10, 3));
    }

}

日期、时间类

 1. Date类

 　　从JDK1.0就存在，它的大部分构造器和方法都已经过时了，所以不再推荐使用了。

2. Calendar类

 　　它是一个抽象类（不能使用构造器来创建对象，根据几个静态getInstance()方法来获取Calender对象），它用于表示日历。

　　Calendar和Date都是表示日期的工具类，因此可以直接进行转换。

public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date);
        System.out.println(date.getTime());

        Calendar calendar = Calendar.getInstance();
        Date date1 = calendar.getTime();

        Calendar calendar2 = Calendar.getInstance();
        calendar2.setTime(date1);
    }

　　

　　使用DateFormat格式化日期、时间 

　　DateFormat是一个抽象类，它提供了几个类方法用于获取DateFormat对象。

　　它的parse()方法可以把一个字符串解析成Date对象，但它要求被解析的字符串必须符合日期字符串的要求。

　　使用SimpleDateFormat格式化日期

　　它是DateFormat的子类。可以灵活地格式化Date，也可以用于解析各种格式的日期字符串。

　　创建SimpleDateFormat对象时需要传入一个pattern字符串，它不是正则，而是一个日期模板字符串。

　　例如：

　　String dateString = "2011-11-11";　　

　　SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

　　Date date = sdf.parse(dateString);   // String --> Date

　　String dateStr = sdf.format(date);   // Date --> String

正则表达式

　　是一个强大的字符串处理工具。可以对字符串进行查找、提取、分割、替换等操作。

　　在程序中：

　　Pattern对象是正则表达式编译后在内存中的表示形式，因此，正则表达式必须先编译成Pattern对象，然后再利用Pattern对象创建对应的Matcher对象。

　　执行匹配所涉及的状态保留在Matcher对象中，多个Matcher对象可共享同一个Pattern对象。

　　Pattern是不可变类，可供多个并发线程安全使用。 Matcher类提供了几个常用方法。具体方法可以查阅API。

public static void main(String[] args) {
        Pattern pattern = Pattern.compile("a*b");
        Matcher matcher = pattern.matcher("aaaaaaab");
        boolean b = matcher.matches();
        System.out.println(b);// true
    }

 国际化和格式化

1. 国际化的思路

　　通过在资源文件中设置key-value的形式。资源文件的命名可以有以下三种形式：

　　baseName_language_country.properties

　　baseName_language.properties

　　baseName.properties

　　其中baseName是资源文件的基本名，用户可随意而定；而language和country都不可以随意变化，必须是java所支持的语言和国家。

2. Java支持的国家和语言

　　通过如下形式可以得到：

public static void main(String[] args) {
        // 返回java所支持的全部国家和语言的数组
        Locale[] localeList = Locale.getAvailableLocales();

        for (int i = 0; i < localeList.length; i++) {
            System.out.println(localeList[i].getDisplayCountry() + "="
                    + localeList[i].getCountry() + " "
                    + localeList[i].getDisplayLanguage() + "="
                    + localeList[i].getLanguage());
        }
    }

3. 完成国际化