字符串（2）：String上的操作、格式化输出

╰+哭是因爲堅強的太久メ 2023-07-09 14:27 9阅读 0赞

### 一、String上的操作 ###

这里简单列举一些常用方法，更多请去查看api文档

**（1）String的构造方法**

1.  String(String original):把字符串数据封装成字符串对象
2.  String(char\[\] value):把字符数组的数据封装成字符串对象
3.  String(char\[\] value, int index, int count):把字符数组中的一部分数据封装成字符串对象

**（2）length()：获取字符串的长度，其实也就是字符个数**

String s = "123";
    int length = s.length();

**（3）charAt(int index):获取指定索引处的字符**

String s = "123";
    char charAt = s.charAt(2);

**（4）indexOf(String str):获取str在字符串对象中第一次出现的索引，lastIndexOf();**

String s = "123";
    int indexOf = s.indexOf("1");

**（5）substring(int start):从start开始截取字符串**

String s = "123";
    String substring = s.substring(1);

**（6）String substring(int start,int end):从start开始，到end结束截取字符串。包括start，不包括end**

String s = "123";
    String substring = s.substring(1,2);

**（7）equals(Object obj):比较字符串的内容是否相同**

String s = "123aBc";
    boolean equals = s.equals("123aBc");

**（8）equalsIgnoreCase(String anotherString):比较字符串的内容是否相同,忽略大小写**

String s = "123aBc";
    boolean equals = s.equalsIgnoreCase("123ABC");

**（9）startsWith(String prefix):判断字符串对象是否以指定的字符开头（区分大小写）**

String s = "123aBc";
    boolean equals = s.startsWith("123");

**（10）startsWith(String prefix,int toffset)：判断字符串对象是否以指定的字符开头，参数toffset为指定从哪个下标开始**

String s = "123aBc";
    boolean equals = s.startsWith("23a",1);

**（11）endsWith(String str):判断字符串对象是否以指定的字符结尾**

String s = "123aBc";
    boolean equals = s.endsWith("aBc");

**（12）isEmpty()：判断指定字符串是否为空**

String s = "";
    boolean equals = s.isEmpty();

**（13）toCharArray():把字符串转换为字符数组**

String s = "123aBc";
    char[] charArray = s.toCharArray();

**（14）toLowerCase():把字符串转换为小写字符串**

String s = "123aBc";
    String lowerCase = s.toLowerCase();

**（15）toUpperCase():把字符串转换为大写字符串**

String s = "123aBc";
    String upperCase = s.toUpperCase();

**（16）trim()：去除字符串两端空格**

String s = " 123 aBc ";
    String trim = s.trim();

**（17）split():去除字符串中指定的的字符，然后返回一个新的字符串**

String s = " 1 2 3 a B c ";
    String[] split = s.split(" ");

**（18）subSequence(int beginIndex,int endIndex )：返回一个字符序列，该字符序列是该序列的子序列。**

String s = " 1 2 3 a B c ";
    CharSequence subSequence = s.subSequence(2, 6);

**（19）replace(char oldChar, char newChar)：将指定字符替换成另一个指定的字符**

String s = "123aBc";
    String replace = s.replace("aB", "Ab");

**（20）replaceAll(String regex,String replasement)：用新的内容替换全部旧内容**

String s = "1 2 3 a B c";
    String replace = s.replaceAll(" ", ",");

**（21）contains(CharSequence s)：查看字符串中是都含有指定字符**

String s = "1 2 3 a B c";
    boolean contains = s.contains(" ");

**（22）concat(String str)：在原有的字符串的基础上加上指定字符串**

String s = "1 2 3 a B c";
    String concat = s.concat("++++");

当需要改变字符串的内容时，String类的方法都会返回一个新的String对象。同时，如果内容没有发生改变，String的方法只是返回指向原对象的引用而已。这可以节约存储空间以及避免额外的开销。

### 二、格式化输出 ###

在长久的等待之后，java SE5终于推出了C语言中printf()风格的格式化输出这一功能。这不仅使得控制输出的代码更加简单，同时也给与java开发者对于输出格式与排列更强大的控制能力。

**（1）printf()**

C语言中的printf()并不能像java那样连接字符串，它使用一个简单的格式化字符串，加上要插入其中的值，然后将其格式化输出。printf()并不使用重载的“+”操作符（C没有重载）来连接引号内的字符串或字符串变量，而是使用特殊的占位符来表示数据将来的位置，而且它还将插入格式化字符串的参数，以逗号分隔，排成一行。例如：

printf("Row 1: [%d %f]\n", x, y);

这一行代码在运行的时候，首先将x的值插入到%d的位置，然后将y的值插入到%f的位置。这些占位符称作格式修饰符，它们不但说明了插入数据的位置，同时还说明了将插入什么类型的变量，以及如何对其格式化。在这个例子中，%d表示x是一个整数，%f表示y是一个浮点数（float或者double）。

**（2）System.out.format()**

java SE5引入的format方法可用于PrintStream或PrintWriter对象，其中也包括System.out对象。format()方法模仿自C的printf()。如果你比较怀旧的话，也可以使用printf()。以下是一个简单的示例：

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);
    	}
    }

可以看到，format()与printf()是等价的，它们只需要一个简单的格式化字符串，加上一串参数即可，每个参数对应一个格式修饰符。

**（3）Formatter类**

在java中，所有新的格式化功能都由java.util.,Formatter类处理。可以将Formatter看作一个翻译器，它将你的格式化字符串与数据翻译成需要的结果。当你创建一个Formatter对象的时候，需要向其构造器传递一些信息，告诉它最终的结果将向哪里输出。

import java.io.PrintStream;
    import java.util.Formatter;
    
    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 out = System.out;
    		Turtle tommy = new Turtle("Tommy", new Formatter(System.out));
    		Turtle terry = new Turtle("Terry", new Formatter(out));
    		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都将输出到System.out，而所有的terry则都输出到System.out的一个别名中。Formatter的构造器经过重载可以接受多种输出的目的地，不过最常用的还是PrintStream()（如上例），OutputStream和File。

**（4）格式化说明符**

**   ** 在插入数据时，如果想要控制空格对齐，你需要更精细复杂的格式修饰符。以下是其抽象的语法：

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

最常见的应用是控制一个域的最小尺寸，这可以通过制定width来实现。Formatter对象通过在必要时添加空格，来确保一个域至少达到某个长度。在默认情况下数据是右对齐，不过可以通过使用“-”标识来改变对齐方向。

与width相对的是precision，它用来指明最大尺寸。width可以应用于各种类型的数据转换，并且其行为方式都一样。precision则不然，不是所有类型的数据都能使用precision，而且，应用于不同类型的数据转换时，precision的意义也不同。在将precision应用于String时，它表示打印String时输出字符的最大数量。而将在precision应用于浮点数时，它表示小数部分要显示出来的位数（默认是6位小数），如果小数位数过多则舍入，太少则在尾部补零。由于整数没有小数部分，所以precision无法应用于整数，如果你对整数应用precision，则会触发异常。

下面的程序应用格式修饰符来打印一个购物收据：

import java.util.Formatter;
    
    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) {
    		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();
    	}
    }

正如你所见，通过相当简洁的语法，Formatter提供了对空格与对齐的强大控制能力。在该程序中，为了恰当地控制间隔，格式化字符串被重复地利用了多遍。

**（5）Formatter转换**

**   ** 下面的表格包含了最常用的类型转换：

<table style="width:438px;"> 
 <tbody> 
  <tr> 
   <td colspan="2" style="text-align:center;width:435px;"><strong>类型转换字符</strong></td> 
  </tr> 
  <tr> 
   <td style="width:91px;">d</td> 
   <td style="width:344px;">整数型（十进制）</td> 
  </tr> 
  <tr> 
   <td style="width:91px;">c</td> 
   <td style="width:344px;">Unicode字符</td> 
  </tr> 
  <tr> 
   <td style="width:91px;">b</td> 
   <td style="width:344px;">Boolean值</td> 
  </tr> 
  <tr> 
   <td style="width:91px;">s</td> 
   <td style="width:344px;">String</td> 
  </tr> 
  <tr> 
   <td style="width:91px;">f</td> 
   <td style="width:344px;">浮点数（十进制）</td> 
  </tr> 
  <tr> 
   <td style="width:91px;">e</td> 
   <td style="width:344px;">浮点数（科学计数）</td> 
  </tr> 
  <tr> 
   <td style="width:91px;">x</td> 
   <td style="width:344px;">整数（十六进制）</td> 
  </tr> 
  <tr> 
   <td style="width:91px;">h</td> 
   <td style="width:344px;">散列码（十六进制）</td> 
  </tr> 
  <tr> 
   <td style="width:91px;">%</td> 
   <td style="width:344px;">字符“%”</td> 
  </tr> 
 </tbody> 
</table>

注意程序中的每个变量都可以用b转换。虽然它对各种类型都是合法的，但其行为却不一定与你想象的一致。对于Boolean基本类型或Boolean对象，其转换结果是对应的true和false。但是，对于其他类型的参数，只要该参数不为null，那转换的结果就永远都是true。即使是数字0，转换结果依然为true，而这在其他语言中（包括C），往往转换为false。所以，将b应用于非布尔类型的对象时请格外小心。

还有许多不常用的类型转换与格式修饰符选项，你可以在JDK文档中的Formatter类部分找到它们。

**（6）String.format()**

java SE5也参考了C中的sprintf()方法，以生成格式化的String对象。String.format()是一个static方法，它接受与Formatter的format()方法一样的参数，但返回一个String对象。当你只需要使用format()方法一次的时候String.format()用起来很方便。例如：

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 failed");
    		} catch (DatabaseException e) {
    			System.out.println(e);
    		}
    	}
    }

其实在String.format()内部，它也是创建一个Formatter对象，然后将你传入的参数转给该Formatter。不过，与其自己做这些事情，不如使用便捷的String.format()方法，何况这样的代码更清晰易读。

**如果本文对您有很大的帮助，还请点赞关注一下。**