Java基础04

Regex：

package Chapter14;

import java.util.regex.Pattern;

public class CustomRegex {
    public static void main(String[] args) {
        /*
        java.util.regex 包主要包括以下三个类：
        Pattern 类：
        pattern 对象是一个正则表达式的编译表示。Pattern 类没有公共构造方法。要创建一个 Pattern 对象，你必须首先调用其公共静态编译方法，它返回一个 Pattern 对象。该方法接受一个正则表达式作为它的第一个参数。
        Matcher 类：
        Matcher 对象是对输入字符串进行解释和匹配操作的引擎。与Pattern 类一样，Matcher 也没有公共构造方法。你需要调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象。
        PatternSyntaxException：
        PatternSyntaxException 是一个非强制异常类，它表示一个正则表达式模式中的语法错误。
        */

        String content = "I am noob " +
                "from runoob.com.";

        String pattern = ".*runoob.*";

        boolean isMatch = Pattern.matches(pattern, content);
        System.out.println("字符串中是否包含了 'runoob' 子字符串? " + isMatch);


    }
}

Method

package Chapter15;

public class CustomMethod {

    public static void main(String[] args) {

        // 调用可变参数的方法
        printMax(34, 3, 3, 2, 56.5);
        printMax(new double[]{1, 2, 3});
    }

    public static void printMax( double... numbers) {
        if (numbers.length == 0) {
            System.out.println("No argument passed");
            return;
        }

        double result = numbers[0];

        for (int i = 1; i <  numbers.length; i++){
            if (numbers[i] >  result) {
                result = numbers[i];
            }
        }
        System.out.println("The max value is " + result);
    }

    protected void finalize() {

    }

    // java 方法 和 iOS 大同小异
}

Stream

package Chapter16;

import java.io.*;

public class CustomStream {

    public static void main(String args[]) throws IOException
    {
//        char c;
//        // 使用 System.in 创建 BufferedReader
//        BufferedReader br = new BufferedReader(new
//                InputStreamReader(System.in));
//        System.out.println("输入字符, 按下 'q' 键退出。");
//        // 读取字符
//        do {
//            c = (char) br.read();
//            System.out.println(c);
//        } while(c != 'q');
//        // 使用 System.in 创建 BufferedReader
//        BufferedReader br = new BufferedReader(new
//                InputStreamReader(System.in));
//        String str;
//        System.out.println("Enter lines of text.");
//        System.out.println("Enter 'end' to quit.");
//        do {
//            str = br.readLine();
//            System.out.println(str);
//        } while(!str.equals("end"));
//
//        int b;
//        b = 'A';
//        System.out.write(b);
//        System.out.write('\n');
        File f = new File("a.txt");
        FileOutputStream fop = new FileOutputStream(f);
        // 构建FileOutputStream对象,文件不存在会自动新建

        OutputStreamWriter writer = new OutputStreamWriter(fop, "UTF-8");
        // 构建OutputStreamWriter对象,参数可以指定编码,默认为操作系统默认编码,windows上是gbk

        writer.append("中文输入");
        // 写入到缓冲区

        writer.append("\r\n");
        //换行

        writer.append("English");
        // 刷新缓存冲,写入到文件,如果下面已经没有写入的内容了,直接close也会写入

        writer.close();
        //关闭写入流,同时会把缓冲区内容写入文件,所以上面的注释掉

        fop.close();
        // 关闭输出流,释放系统资源

        FileInputStream fip = new FileInputStream(f);
        // 构建FileInputStream对象

        InputStreamReader reader = new InputStreamReader(fip, "UTF-8");
        // 构建InputStreamReader对象,编码与写入相同

        StringBuffer sb = new StringBuffer();
        while (reader.ready()) {
            sb.append((char) reader.read());
            // 转成char加到StringBuffer对象中
        }
        System.out.println(sb.toString());
        reader.close();
        // 关闭读取流

        fip.close();
        // 关闭输入流,释放系统资源

        /*
        File类中有两个方法可以用来创建文件夹：

        mkdir( )方法创建一个文件夹，成功则返回true，失败则返回false。失败表明File对象指定的路径已经存在，或者由于整个路径还不存在，该文件夹不能被创建。

        mkdirs()方法创建一个文件夹和它的所有父文件夹。
*/
    }
}

Scanner

package Chapter17;

import java.util.Scanner;

public class CustomScanner {

    public static void main(String[] args) {

        Scanner scan = new Scanner(System.in);
        // 从键盘接收数据

        //next方式接收字符串
        System.out.println("next方式接收：");
        // 判断是否还有输入
        if(scan.hasNext()){
            String str1 = scan.next();
            System.out.println("输入的数据为："+str1);
        }

        /*
        next() 与 nextLine() 区别
        next():
        1、一定要读取到有效字符后才可以结束输入。
        2、对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
        3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
        next() 不能得到带有空格的字符串。

        nextLine()：
        1、以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
        2、可以获得空白。*/

        int i = 0 ;
        float f = 0.0f ;
        System.out.print("输入整数：");
        if(scan.hasNextInt()){
            // 判断输入的是否是整数
            i = scan.nextInt() ;
            // 接收整数
            System.out.println("整数数据：" + i) ;
        }else{
            // 输入错误的信息
            System.out.println("输入的不是整数！") ;
        }
        System.out.print("输入小数：");
        if(scan.hasNextFloat()){
            // 判断输入的是否是小数
            f = scan.nextFloat() ;
            // 接收小数
            System.out.println("小数数据：" + f) ;
        }else{
            // 输入错误的信息
            System.out.println("输入的不是小数！") ;
        }


        double sum = 0;
        int m = 0;

        while(scan.hasNextDouble())
        {
            double x = scan.nextDouble();
            m = m + 1;
            sum = sum + x;
        }

        System.out.println(m+"个数的和为"+sum);
        System.out.println(m+"个数的平均值是"+(sum/m));
    }
}

Error

package Chapter18;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class CustomError {

    public static void main(String[] args) {

        /*
        用户输入了非法数据。

        要打开的文件不存在。

        网络通信时连接中断，或者JVM内存溢出。

        try
        {
            // 程序代码
        }catch(ExceptionName e1)
        {
            //Catch 块
        }
        */

        /*
        检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。

        运行时异常： 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。

        错误： 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。*/


        try{
            int a[] = new int[2];
            System.out.println("Access element three :" + a[3]);
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println("Exception thrown  :" + e);
        }
        System.out.println("Out of the block");

        int a[] = new int[2];
        try{
            System.out.println("Access element three :" + a[3]);
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println("Exception thrown  :" + e);
        }
        finally{
            a[0] = 6;
            System.out.println("First element value: " +a[0]);
            System.out.println("The finally statement is executed");
        }
    }
}