Java vs python 基础（5）

正则表达式

java.util.regex 包主要包括以下三个类：

• Pattern 类：

  pattern 对象是一个正则表达式的编译表示。Pattern 类没有公共构造方法。要创建一个 Pattern 对象，你必须首先调用其公共静态编译方法，它返回一个 Pattern 对象。该方法接受一个正则表达式作为它的第一个参数。

• Matcher 类：

  Matcher 对象是对输入字符串进行解释和匹配操作的引擎。与Pattern 类一样，Matcher 也没有公共构造方法。你需要调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象。

• PatternSyntaxException：

  PatternSyntaxException 是一个非强制异常类，它表示一个正则表达式模式中的语法错误。

package com.hoko;
import java.util.regex.Pattern;

public class Test {
	public static void main(String args[]){
	      String content = "I am noob " +
	        "from runoob.com.";
	 
	      String pattern = ".*runoob.*";
	 
	      boolean isMatch = Pattern.matches(pattern, content);
	      System.out.println("字符串中是否包含了 'runoob' 子字符串? " + isMatch);
	   }
}

 

import re

content = "I am noob " + "from runoob.com."
isMatch:str=''
pattern = ".*runoob.*"
if re.match(pattern, content):
    isMatch:str = 'true'
else:
    isMatch:str = 'false'
print("字符串中是否包含了 'runoob' 子字符串? " + isMatch)

捕获组

捕获组是把多个字符当一个单独单元进行处理的方法，它通过对括号内的字符分组来创建。

例如，正则表达式 (dog) 创建了单一分组，组里包含"d"，"o"，和"g"。

捕获组是通过从左至右计算其开括号来编号。例如，在表达式（（A）（B（C））），有四个这样的组：

• ((A)(B(C)))
• (A)
• (B(C))
• (C)

可以通过调用 matcher 对象的 groupCount 方法来查看表达式有多少个分组。groupCount 方法返回一个 int 值，表示matcher对象当前有多个捕获组。

还有一个特殊的组（group(0)），它总是代表整个表达式。该组不包括在 groupCount 的返回值中。

package com.hoko;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test {
	public static void main( String args[] ){
		 
	      // 按指定模式在字符串查找
	      String line = "This order was placed for QT3000! OK?";
	      String pattern = "(\\D*)(\\d+)(.*)";
	 
	      // 创建 Pattern 对象
	      Pattern r = Pattern.compile(pattern);
	 
	      // 现在创建 matcher 对象
	      Matcher m = r.matcher(line);
	      if (m.find( )) {
	         System.out.println("Found value: " + m.group(0) );
	         System.out.println("Found value: " + m.group(1) );
	         System.out.println("Found value: " + m.group(2) );
	         System.out.println("Found value: " + m.group(3) ); 
	      } else {
	         System.out.println("NO MATCH");
	      }
	   }
}

re.match与re.search的区别

re.match 只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回 None，而 re.search 匹配整个字符串，直到找到一个匹配。

import re
 
line = "Cats are smarter than dogs"
 
matchObj = re.match( r'dogs', line, re.M|re.I)
if matchObj:
   print ("match --> matchObj.group() : ", matchObj.group())
else:
   print ("No match!!")
 
matchObj = re.search( r'dogs', line, re.M|re.I)
if matchObj:
   print ("search --> matchObj.group() : ", matchObj.group())
else:
   print ("No match!!")

构造方法

当一个对象被创建时候，构造方法用来初始化该对象。构造方法和它所在类的名字相同，但构造方法没有返回值。

通常会使用构造方法给一个类的实例变量赋初值，或者执行其它必要的步骤来创建一个完整的对象。

不管你是否自定义构造方法，所有的类都有构造方法，因为Java自动提供了一个默认构造方法，默认构造方法的访问修改符和类的访问修改符相同(类为 public，构造函数也为 public；类改为 protected，构造函数也改为 protected)。

一旦你定义了自己的构造方法，默认构造方法就会失效。

package com.hoko;

public class Test {
	public static void main(String[] args) {
		MyClass t1 = new MyClass();
		MyClass t2 = new MyClass();
		System.out.println(t1.x+t2.x);
	}
}

class MyClass {
	  int x;
	 
	  // 以下是构造函数
	  MyClass() {
	    x = 10;
	  }
	}

class MyClass:
    def __init__(self):
        self.x = 10


if __name__ == '__main__':
    t1 = MyClass()
    t2 = MyClass()
    print(t1.x + t2.x)

package com.hoko;

public class Test {
	public static void main(String[] args) {
		MyClass t1 = new MyClass(20);
		MyClass t2 = new MyClass(30);
		System.out.println(t1.x+t2.x);
	}
}

class MyClass {
	  int x;
	 
	  // 以下是构造函数
	  MyClass(int i) {
	    x = i;
	  }
	}

class MyClass:
    def __init__(self,i):
        self.x = i


if __name__ == '__main__':
    t1 = MyClass(20)
    t2 = MyClass(30)
    print(t1.x + t2.x)

可变参数

package com.hoko;

public class Test {
	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);
    }
}

def printMax(*args):
    if len(args) == 0:
        print("No argument passed")
        return
    result = args[0]
    for i in range(1, len(args)):
        if args[i] > result:
            result = args[i]
    print("The max value is " + str(result))


printMax(34, 3, 3, 2, 56.5)
printMax(1.0, 2.0, 3.0)

流(Stream)、文件(File)和IO