Converting Between Numbers and Strings
Converting Strings to Numbers
Frequently, a program ends up with numeric data in a string object—a value entered by the user, for example.
The Number
subclasses that wrap primitive numeric types ( Byte
, Integer
, Double
, Float
, Long
, and Short
) each provide a class method named valueOf
that converts a string to an object of that type. Here is an example, ValueOfDemo
, that gets two strings from the command line, converts them to numbers, and performs arithmetic operations on the values:
public class ValueOfDemo { public static void main(String[] args) { // this program requires two // arguments on the command line if (args.length == 2) { // convert strings to numbers float a = (Float.valueOf(args[0])).floatValue(); float b = (Float.valueOf(args[1])).floatValue(); // do some arithmetic System.out.println("a + b = " + (a + b)); System.out.println("a - b = " + (a - b)); System.out.println("a * b = " + (a * b)); System.out.println("a / b = " + (a / b)); System.out.println("a % b = " + (a % b)); } else { System.out.println("This program " + "requires two command-line arguments."); } } }
The following is the output from the program when you use 4.5
and 87.2
for the command-line arguments:
a + b = 91.7 a - b = -82.7 a * b = 392.4 a / b = 0.0516055 a % b = 4.5
Note: Each of the Number
subclasses that wrap primitive numeric types also provides a parseXXXX()
method (for example, parseFloat()
) that can be used to convert strings to primitive numbers. Since a primitive type is returned instead of an object, the parseFloat()
method is more direct than the valueOf()
method. For example, in the ValueOfDemo
program, we could use:
float a = Float.parseFloat(args[0]); float b = Float.parseFloat(args[1]);
Converting Numbers to Strings
Sometimes you need to convert a number to a string because you need to operate on the value in its string form. There are several easy ways to convert a number to a string:
int i; // Concatenate "i" with an empty string; conversion is handled for you. String s1 = "" + i;
or
// The valueOf class method. String s2 = String.valueOf(i);
Each of the Number
subclasses includes a class method, toString()
, that will convert its primitive type to a string. For example:
int i; double d; String s3 = Integer.toString(i); String s4 = Double.toString(d);
The ToStringDemo
example uses the toString
method to convert a number to a string. The program then uses some string methods to compute the number of digits before and after the decimal point:
public class ToStringDemo { public static void main(String[] args) { double d = 858.48; String s = Double.toString(d); int dot = s.indexOf('.'); System.out.println(dot + " digits " + "before decimal point."); System.out.println( (s.length() - dot - 1) + " digits after decimal point."); } }
The output of this program is:
3 digits before decimal point. 2 digits after decimal point.
Manipulating Characters in a String(重点了解)
The String
class has a number of methods for examining the contents of strings, finding characters or substrings within a string, changing case, and other tasks.
Getting Characters and Substrings by Index
You can get the character at a particular index within a string by invoking the charAt()
accessor method. The index of the first character is 0, while the index of the last character is length()-1
. For example, the following code gets the character at index 9 in a string:
String anotherPalindrome = "Niagara. O roar again!"; char aChar = anotherPalindrome.charAt(9);
Indices begin at 0, so the character at index 9 is 'O', as illustrated in the following figure:
If you want to get more than one consecutive character from a string, you can use the substring
method. The substring
method has two versions, as shown in the following table:
Method | Description |
---|---|
String substring(int beginIndex, int endIndex) |
Returns a new string that is a substring of this string. The substring begins at the specified beginIndex and extends to the character at index endIndex - 1 . |
String substring(int beginIndex) |
Returns a new string that is a substring of this string. The integer argument specifies the index of the first character. Here, the returned substring extends to the end of the original string. |
The following code gets from the Niagara palindrome the substring that extends from index 11 up to, but not including, index 15, which is the word "roar":
String anotherPalindrome = "Niagara. O roar again!"; String roar = anotherPalindrome.substring(11, 15);
The StringBuilder Class(StringBuilder说明)
StringBuilder
objects are like String
objects, except that they can be modified. Internally, these objects are treated like variable-length arrays that contain a sequence of characters. At any point, the length and content of the sequence can be changed through method invocations.
Strings should always be used unless string builders offer an advantage in terms of simpler code (see the sample program at the end of this section) or better performance. For example, if you need to concatenate a large number of strings, appending to a StringBuilder
object is more efficient.
Length and Capacity
The StringBuilder
class, like the String
class, has a length()
method that returns the length of the character sequence in the builder.
Unlike strings, every string builder also has a capacity, the number of character spaces that have been allocated. The capacity, which is returned by the capacity()
method, is always greater than or equal to the length (usually greater than) and will automatically expand as necessary to accommodate additions to the string builder.
Constructor | Description |
---|---|
StringBuilder() |
Creates an empty string builder with a capacity of 16 (16 empty elements). |
StringBuilder(CharSequence cs) |
Constructs a string builder containing the same characters as the specified CharSequence , plus an extra 16 empty elements trailing the CharSequence . |
StringBuilder(int initCapacity) |
Creates an empty string builder with the specified initial capacity. |
StringBuilder(String s) |
Creates a string builder whose value is initialized by the specified string, plus an extra 16 empty elements trailing the string. |
For example, the following code
// creates empty builder, capacity 16 StringBuilder sb = new StringBuilder(); // adds 9 character string at beginning sb.append("Greetings");
will produce a string builder with a length of 9 and a capacity of 16:
装箱和拆箱(看看即可)
Autoboxing and unboxing lets developers write cleaner code, making it easier to read. The following table lists the primitive types and their corresponding wrapper classes, which are used by the Java compiler for autoboxing and unboxing:
Primitive type | Wrapper class |
---|---|
boolean | Boolean |
byte | Byte |
char | Character |
float | Float |
int | Integer |
long | Long |
short | Short |
double | Double |