《Java编程思想》第十三章 字符串

《Java编程思想》读书笔记

1、String作为方法的参数时，会复制一份引用，而该引用所指的对象其实一直待在单一的物理位置，从未动过。

2、显式地创建StringBuilder允许预先为他指定大小。如果知道字符串多长，可以预先指定StringBuilder的大小避免多次重新分配的冲突。

/** 
 * @author zlz099: 
 * @version 创建时间：2017年9月1日 下午4:03:59 
 */
public class UsingStringBuilder {
    
    public static Random random  = new Random(47);
    public String toString(){
        StringBuilder result = new StringBuilder("[");
        for(int i = 0; i < 25;i++){
            result.append(random.nextInt(100));
            result.append(". ");
        }
        result.delete(result.length()-2, result.length());
        result.append("]");
        return result.toString();
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        UsingStringBuilder usb = new UsingStringBuilder();
        System.out.println(usb);
    }

}

3、如果在toString中使用循环，则最好创建一个StringBuilder对象。

4、String上的操作：如果需要改变字符串的内容时，String类的方法会返回一个新的String对象。同时，如果没有改变内容，则String方法只是返回指向原对象的引用。

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

/** 
 * @author zlz099: 
 * @version 创建时间：2017年9月19日 下午3:50:23 
 */
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)
",name,x,y);
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        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);
        
    }

}

import java.util.Formatter;

/** 
 * @author zlz099: 
 * @version 创建时间：2017年9月19日 下午4:25:05 
 */
public class Recipe {
    private double total = 0;
    private Formatter formatter = new Formatter(System.out);
    public void printTitle(){
        formatter.format("%-15s %5s %10s
", "Item","Qty","Price");
        formatter.format("%-15s %5s %10s
", "----","---","-----");
    }
    public void print(String name,int qty,double price){
        formatter.format("%-15s %5s %10.2f
", name,qty,price);
        total += price;
    }
    public void printTotal(){
        formatter.format("%-15s %5s %10.2f
", "Tax","",total*0.06);
        formatter.format("%-15s %5s %10s
", "","","-----");
        formatter.format("%-15s %5s %10.2f
", "Total","",total*1.06);
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Recipe recipe = new Recipe();
        recipe.printTitle();
        recipe.print("Jack's Magic Beans", 4, 4.25);
        recipe.print("Princess peas", 3, 5.1);
        recipe.print("Three Bears Porridge", 1, 14.29);
        recipe.printTotal();    
    }
}

十六进制的转储工具：

import java.io.File;
import java.util.function.BinaryOperator;

/** 
 * @author zlz099: 
 * @version 创建时间：2017年9月19日 下午4:48:11 
 * 十六进制转储工具(dump)
 */
public class Hex {
    public static String format(byte[] data){
        StringBuilder result = new StringBuilder();
        int n = 0;
        for(byte b:data){
            if(n%16==0){
                result.append(String.format("%05X: ", n));
            }
            result.append(String.format("%02X ", b));
            n++;
            if(n%16 == 0) result.append("
");
        }
        result.append("
");
        return result.toString();
    }
    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        if(args.length == 0){
            System.out.println(format(BinaryFile.read("Hex.class")));
        }
        else {
            System.out.println(format(BinaryFile.read(new File(args[0]))));
        }
    }

}

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.BufferUnderflowException;

/** 
 * @author zlz099: 
 * @version 创建时间：2017年9月19日 下午4:56:17 
 */
public class BinaryFile {
    public static byte[] read(File bFile)throws IOException{
        BufferedInputStream bf = new BufferedInputStream(new FileInputStream(bFile));
        try {
            byte[] data = new byte[bf.available()];
            bf.read(data);
            return data;
        } finally {
            // TODO: handle exception
            bf.close();
        }
    }
    public static byte[] read(String bFile)throws IOException{
        return read(new File(bFile).getAbsoluteFile());
    }
}

5、正则表达式：插入一个数字：\d    插入一个反斜线：\\

import java.util.Arrays;

/** 
 * @author zlz099: 
 * @version 创建时间：2017年9月20日 上午9:53:58 
 */
public class Splitting {
    public static String knights = "Then, when you have found the shrubbery. you must "+
            "cut down the mightiest tree in the forest... "+
            "with... a herring!";
    public static void split(String regex){
        System.out.println(Arrays.toString(knights.split(regex)));
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        split(" ");
        split("\W+");
        split("n\W+");
    }

}

6、split（）方法：将字符串从正则表达式匹配的地方切开。在原始字符串中，与正则表达式匹配的部分，在最终结果中都不存在。重载版本允许限制字符串分割的次数。

/** 
 * @author zlz099: 
 * @version 创建时间：2017年9月20日 上午9:57:46 
 */
public class Replacing {
    static String s = Splitting.knights;
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println(s.replaceFirst("f\W+", "locaked"));//替换第一个f开头的单词
        System.out.println(s.replaceAll("shrubbery|tree|herring", "banana"));//替换所有匹配的，|表示或
    }
}

7、split(" "); 按空格划分   split("\W+");  非单词字符划分    split("n\W+");  n字符后跟一个或多个非单词字符。

8、replace( ); 可以替换字符，替换正则表达式第一个匹配的子串或者全部替换。

9、find（）可以在输入的任意位置定位正则表达式，lookingAt（）和match（）只能在正则表达式与输入的开始处就开始匹配时才能成功。match（）只有在整个输入匹配正则表达式时成功，lookingAt（）只要输入第一部分匹配就能成功。

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

/** 
 * @author zlz099: 
 * @version 创建时间：2017年9月20日 上午11:11:04 
 * 用来在CharSequence中查找多个匹配
 */
public class Finding {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Matcher m = Pattern.compile("\w+").matcher("Evening is full of the linnet's wings");
        while(m.find()){
            System.out.print(m.group()+" ");
        }
        System.out.println();
        int i = 0;
        while(m.find(i)){
            //接受一个整数作为参数，表示字符串中字符的位置，并以其作为搜索起点。以这个参数作为起点，不断重新设定搜索的起始位置。
            System.out.print(m.group()+" ");
            i++;
        }
    }

}

import java.util.Arrays;
import java.util.regex.Pattern;

/** 
 * @author zlz099: 
 * @version 创建时间：2017年9月20日 上午10:25:13 
 */
public class SplitDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String input = "This!!unusual use!!of exclamation!!points";
        System.out.println(Arrays.toString(Pattern.compile("!!").split(input)));
        //第二个split限制将输入分割成字符串的数量
        System.out.println(Arrays.toString(Pattern.compile("!!").split(input,3)));
    }
}

10、appendReplacement(StringBuffer sbuf,String replacement) :允许在执行替换的过程中操作用来替换的字符串。

11、Scanner构造器可以接受任何类型的输入对象，包括File对象。有了Scanner，所有的输入、分词以及翻译的操作都放在不同类型的next（）方法中。hasNext（）方法可以判断下一个输入分词是否所需的类型。

import java.io.BufferedReader;
import java.io.StringReader;

/** 
 * @author zlz099: 
 * @version 创建时间：2017年9月20日 上午10:39:32 
 */
public class SimpleRead {
    public static BufferedReader input = new BufferedReader(new StringReader("Sir Robin of Camelot
22 1.61803"));
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try {
            System.out.println("What is your name?");
            String name = input.readLine();
            System.out.println(name);
            System.out.println("How old are you? What is your favorite double?");
            System.out.println("(input: <age> <double>");
            String numbers = input.readLine();
            System.out.println(numbers);
            String[] numArray = numbers.split(" ");
            int age = Integer.parseInt(numArray[0]);
            double favorite = Double.parseDouble(numArray[1]);
            System.out.format("Hi %s.
",name);
            System.out.format("In 5 years you will be %d.
",age+5);
            System.out.format("My favorite double is  %f.
",favorite/2);
        } catch (Exception e) {
            // TODO: handle exception
            System.err.println("I/O exception");
        }
    }

}

12、Scanner有一个假设，在输入结束时会自动抛出IOException，所以Scanner将IOException吞掉了。

import java.util.Scanner;

/** 
 * @author zlz099: 
 * @version 创建时间：2017年9月20日 上午10:50:07 
 */
public class BetterRead {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner stdin = new Scanner(SimpleRead.input);
        System.out.println("What is your name?");
        String name = stdin.nextLine();
        System.out.println(name);
        System.out.println("How old are you? What is your favorite double?");
        System.out.println("(input: <age> <double>");
        int age = stdin.nextInt();
        double favorite = stdin.nextDouble();
        System.out.println(age);
        System.out.println(favorite);
        System.out.format("Hi %s.
",name);
        System.out.format("In 5 years you will be %d.
",age+5);
        System.out.format("My favorite double is  %f.
",favorite/2);

    }

}