Java基础 -- 字符串(格式化输出、正则表达式)

public class Immutable {
	public static String upcase(String s) {
		return s.toUpperCase();
	}
	
	public static void main(String[] args) {
		String q = "howdy";
		System.out.println(q);
		String qq = upcase(q);
		System.out.println(qq);
		System.out.println(q);
	}
}　

howdy
HOWDY
howdy　

String s = "asdf";
String x = Immutable.upcase(s);　　

String str="abc";
System.out.println(str);
str=str+"de";
System.out.println(str);

String str="abc"+"de";
StringBuilder stringBuilder=new StringBuilder().append("abc").append("de");
System.out.println(str);
System.out.println(stringBuilder.toString());

String str1="abc";
String str2="de";
String str=str1+str2;

public class SimpleFormat {
	public static void main(String[] args) {
		int x = 5;
		double y = 5.332542;
		System.out.println("Row 1: [" + x + " " + y + "]");    //原来方式
		
		//格式化输出方式
		System.out.format("Row 1: [%d %f]\n", x,y);
		System.out.printf("Row 1: [%d %f]\n", x,y);
	}
}

Row 1: [5 5.332542]
Row 1: [5 5.332542]
Row 1: [5 5.332542]

import java.io.*;
import java.util.*;

public class Turtle {
	
	private String name;
	private Formatter f;
	
	public Turtle(String name,Formatter f) {
		this.name = name;
		this.f = f;
		
	}
	
	
	public void move(int x,int y) {
		f.format("%s The Turtle is at (%d,%d)\n",name,x,y);
	}
	
	public static void main(String[] args) {
			PrintStream outAlias = System.out;
			Turtle tommy = new Turtle("Tommy",new Formatter(System.out));
			Turtle terry = new Turtle("Terry",new Formatter(outAlias));
			
			tommy.move(0, 0);
			terry.move(4, 8);
			tommy.move(3, 4);
			terry.move(2, 5);
			tommy.move(3, 3);
			terry.move(3, 3);
	}
		
}

Tommy The Turtle is at (0,0)
Terry The Turtle is at (4,8)
Tommy The Turtle is at (3,4)
Terry The Turtle is at (2,5)
Tommy The Turtle is at (3,3)
Terry The Turtle is at (3,3)

%[argument_index$][flags][width][.precision]conversion

import java.util.*;

public class Receipt {
	private double total = 0;
	private Formatter f = new Formatter(System.out);
	
	public void printTitle() {
		f.format("%-15s %5s %10s\n","Item","Qty","Price");
		f.format("%-15s %5s %10s\n","---","---","-----");
	}
	
	
	public void print(String name,int qty,double price) {		
		//%-15.15s：字符串左对齐，最小长度为15，最大长度也为15
		//%10.2f：最小长度为10,其中小数占两位
		f.format("%-15.15s %5d %10.2f\n",name,qty,price);
		total += price;
	}
	
	public void printTotal() {
		f.format("%-15s %5s %10.2f\n","Tax","",total*0.06);
		f.format("%-15s %5s %10s\n","","","-----");
		f.format("%-15s %5s %10.2f\n","Total","",total*1.06);
	}
	
	public static void main(String[] args) {
		Receipt receipt = new Receipt();
		receipt.printTitle();
		receipt.print("Jack‘s Magic Beans",4, 4.25);
		receipt.print("Princess Peas",3, 5.1);
		receipt.print("Three Bears Porridge",1,14.29);
		receipt.printTotal();
	}
	
}

Item              Qty      Price
---               ---      -----
Jack‘s Magic Be     4       4.25
Princess Peas       3       5.10
Three Bears Por     1      14.29
Tax                         1.42
                           -----
Total                      25.06

public class DatabaseException extends Exception{
	public DatabaseException(int transactionID,int queryID,String message) {
		//调用基类构造函数
		super(String.format("(t%d,q%d) %s", transactionID,queryID,message));
	}
	
	public static void main(String[] args) {
		try {
			throw new DatabaseException(3,7,"Write filed!");
		}catch(Exception e) {
			System.out.println(e.getMessage());
		}
	}
}

(t3,q7) Write filed!

import java.util.regex.*;
 
class RegexExample1{
   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);
   }
}

字符串中是否包含了 ‘runoob‘ 子字符串? true

import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
public class RegexMatches
{
    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");
      }
   }
}

Found value: This order was placed for QT3000! OK?
Found value: This order was placed for QT
Found value: 3000
Found value: ! OK?

import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
public class RegexMatches
{
    private static final String REGEX = "\\bcat\\b";
    private static final String INPUT =
                                    "cat cat cat cattie cat";
 
    public static void main( String args[] ){
       Pattern p = Pattern.compile(REGEX);
       Matcher m = p.matcher(INPUT); // 获取 matcher 对象
       int count = 0;
 
       while(m.find()) {
         count++;
         System.out.println("Match number "+count);
         System.out.println("start(): "+m.start());
         System.out.println("end(): "+m.end());
      }
   }
}

Match number 1
start(): 0
end(): 3
Match number 2
start(): 4
end(): 7
Match number 3
start(): 8
end(): 11
Match number 4
start(): 19
end(): 22

import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
public class RegexMatches
{
    private static final String REGEX = "foo";
    private static final String INPUT = "fooooooooooooooooo";
    private static final String INPUT2 = "ooooofoooooooooooo";
    private static Pattern pattern;
    private static Matcher matcher;
    private static Matcher matcher2;
 
    public static void main( String args[] ){
       pattern = Pattern.compile(REGEX);
       matcher = pattern.matcher(INPUT);
       matcher2 = pattern.matcher(INPUT2);
 
       System.out.println("Current REGEX is: "+REGEX);
       System.out.println("Current INPUT is: "+INPUT);
       System.out.println("Current INPUT2 is: "+INPUT2);
 
 
       System.out.println("lookingAt(): "+matcher.lookingAt());
       System.out.println("matches(): "+matcher.matches());
       System.out.println("lookingAt(): "+matcher2.lookingAt());
   }
}

Current REGEX is: foo
Current INPUT is: fooooooooooooooooo
Current INPUT2 is: ooooofoooooooooooo
lookingAt(): true
matches(): false
lookingAt(): false

import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
public class RegexMatches
{
   private static String REGEX = "a*b";
   private static String INPUT = "aabfooaabfooabfoobkkk";
   private static String REPLACE = "-";
   public static void main(String[] args) {
      Pattern p = Pattern.compile(REGEX);
      // 获取 matcher 对象
      Matcher m = p.matcher(INPUT);
      StringBuffer sb = new StringBuffer();
      while(m.find()){
         m.appendReplacement(sb,REPLACE);
      }
      m.appendTail(sb);
      System.out.println(sb.toString());
   }
}

-foo-foo-foo-kkk

import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
public class RegexMatches
{
    private static String REGEX = "dog";
    private static String INPUT = "The dog says meow. " +
                                    "All dogs say meow.";
    private static String REPLACE = "cat";
 
    public static void main(String[] args) {
       Pattern p = Pattern.compile(REGEX);
       // get a matcher object
       Matcher m = p.matcher(INPUT); 
       INPUT = m.replaceAll(REPLACE);
       System.out.println(INPUT);
   }
}

The cat says meow. All cats say meow.