java基础学习（二）

时间：2021-04-03 19:46:09 收藏：0 阅读：10

java基础学习（二）

九、java字符串处理

九、java字符串处理

在 Java 中定义一个字符串最简单的方法是用双引号把它包围起来。这种用双引号括起来的一串字符实际上都是 String 对象，如字符串“Hello”在编译后即成为 String 对象。因此也可以通过创建 String 类的实例来定义字符串。

不论使用哪种形式创建字符串，字符串对象一旦被创建，其值是不能改变的，但可以使用其他变量重新赋值的方式进行更改。

1. String有多种构造方法：

1. String()

初始化一个新创建的 String 对象，表示一个空字符序列。

2. String(String original)

初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列。换句话说，新创建的字符串是该参数字符串的副本。例如：

String str1 = new String("Hello Java");
String str2 = new String(str1);

这里 str1 和 str2 的值是相等的。

3. String(char[ ]value)

分配一个新的字符串，将参数中的字符数组元素全部变为字符串。该字符数组的内容已被复制，后续对字符数组的修改不会影响新创建的字符串。例如：

char a[] = {‘H‘,‘e‘,‘l‘,‘l‘,‘0‘};
String sChar = new String(a);
a[1] = ‘s‘;

上述 sChar 变量的值是字符串“Hello”。即使在创建字符串之后，对 a 数组中的第 2 个元素进行了修改，但未影响 sChar 的值。

分配一个新的 String，它包含来自该字符数组参数一个子数组的字符。offset 参数是子数组第一个字符的索引，count 参数指定子数组的长度。该子数组的内容已被赋值，后续对字符数组的修改不会影响新创建的字符串。例如：

char a[]={‘H‘,‘e‘,‘l‘,‘l‘,‘o‘};
String sChar=new String(a,1,4);
a[1]=‘s‘;

上述 sChar 变量的值是字符串“ello”。该构造方法使用字符数组中的部分连续元素来创建字符串对象。offset 参数指定起始索引值，count 指定截取元素的个数。创建字符串对象后，即使在后面修改了 a 数组中第 2 个元素的值，对 sChar 的值也没有任何影响。

2. String和int类型相互转换

1.String 转 int

Integer.parseInt(str)
Integer.valueOf(str).intValue()
- 例如下面代码所示：

public static void main(String[] args) {
       String str = "123";
       int n = 0;
   
       // 第一种转换方法：Integer.parseInt(str)
       n = Integer.parseInt(str);
       System.out.println("Integer.parseInt(str) : " + n);
   
       // 第二种转换方法：Integer.valueOf(str).intValue()
       n = 0;
       n = Integer.valueOf(str).intValue();
       System.out.println("Integer.parseInt(str) : " + n);
   }

输出结果为：

Integer.parseInt(str) : 123
Integer.parseInt(str) : 123

在 String 转换 int 时，String 的值一定是整数，否则会报数字转换异常（java.lang.NumberFormatException）。

2.int 转 String ：

String s = String.valueOf(i);
String s = Integer.toString(i);
String s = "" + i;

例如下面代码所示：

	public static void main(String[] args) {
		// 第一种方法：String.valueOf(i);
         num = 10;
         String str = String.valueOf(num);
         System.out.println("str:" + str);
     
        // 第二种方法：Integer.toString(i);
         num = 10;
         String str2 = Integer.toString(num);
         System.out.println("str2:" + str2);
     
         // 第三种方法："" + i;
         String str3 = num + "";
         System.out.println("str3:" + str3);
     }

输出结果为：

str:10
str2:10
str3:10

使用第三种方法相对第一第二种耗时比较大。在使用第一种 valueOf() 方法时，注意 valueOf 括号中的值不能为空，否则会报空指针异常（NullPointerException）。

3.valueOf()

valueOf() 方法将数据的内部格式转换为可读的形式。它是一种静态方法，对于所有 Java 内置的类型，在字符串内被重载，以便每一种类型都能被转换成字符串。valueOf() 方法还被类型 Object 重载，所以创建的任何形式类的对象也可被用作一个参数。这里是它的几种形式：

static String valueOf(double num)
static String valueOf(long num)
static String valueOf(Object ob)
static String valueOf(char chars[])

与前面的讨论一样，调用 valueOf() 方法可以得到其他类型数据的字符串形式——例如在进行连接操作时。对各种数据类型，可以直接调用这种方法得到合理的字符串形式。所有的简单类型数据转换成相应于它们的普通字符串形式。任何传递给 valueOf() 方法的对象都将返回对象的 toString() 方法调用的结果。事实上，也可以通过直接调用 toString() 方法而得到相同的结果。

对大多数数组，valueOf() 方法返回一个相当晦涩的字符串，这说明它是一个某种类型的数组。然而对于字符数组，它创建一个包含了字符数组中的字符的字符串对象。valueOf() 方法有一种特定形式允许指定字符数组的一个子集。

它具有如下的一般形式：

static String valueOf(char chars[ ], int startIndex, int numChars)

这里 chars 是存放字符的数组，startIndex 是字符数组中期望得到的子字符串的首字符下标，numChars 指定子字符串的长度。

4.parse()

parseXxx(String) 这种形式，是指把字符串转换为数值型，其中 Xxx 对应不同的数据类型，然后转换为 Xxx 指定的类型，如 int 型和 float 型。

5.toString()

toString() 可以把一个引用类型转换为 String 字符串类型，是 sun 公司开发 Java 的时候为了方便所有类的字符串操作而特意加入的一个方法。

6.字符串拼接

运算符“+”
concat() 方法

7.length()

获取字符串长度（length()）

字符串名.length();

8.toLowerCase()和toUpperCase()

toLowerCase() 方法可以将字符串中的所有字符全部转换成小写，而非字母的字符不受影响。语法格式如下：

字符串名.toLowerCase()    // 将字符串中的字母全部转换为小写，非字母不受影响

toUpperCase() 则将字符串中的所有字符全部转换成大写，而非字母的字符不受影响。语法格式如下：

字符串名.toUpperCase()    // 将字符串中的字母全部转换为大写，非字母不受影响

9.trim()

去首尾空格

10.substring()

1. substring(int beginIndex)

此方式用于提取从索引位置开始至结尾处的字符串部分。

2. substring(int beginIndex，int endIndex)

开始位置 beginIndex， Java 是基于字符串的首字符索引为 0 处理的，但是对于结束位置 endIndex，Java 是基于字符串的首字符索引为 1 来处理的

public static void main(String[] args) {
    String day = "Today is Monday";    //原始字符串
    System.out.println("substring(0)结果："+day.substring(0));
    System.out.println("substring(2)结果："+day.substring(2));
    System.out.println("substring(10)结果："+day.substring(10));
    System.out.println("substring(2,10)结果："+day.substring(2,10));
    System.out.println("substring(0,5)结果："+day.substring(0,5));
}

输出结果如下所示：

substring(0)结果：Today is Monday
substring(2)结果：day is Monday
substring(10)结果：onday
substring(2,10)结果：day is M
substring(0,5)结果：Today

11.split()

str.split(String sign)
str.split(String sign,int limit)
- 其中它们的含义如下：
  - str 为需要分割的目标字符串。
  - sign 为指定的分割符，可以是任意字符串。
  - limit 表示分割后生成的字符串的限制个数，如果不指定，则表示不限制，直到将整个目标字符串完全分割为止。
  使用分隔符注意如下：
  
  1）“.”和“|”都是转义字符，必须得加“\”。
  - 如果用“.”作为分隔的话，必须写成String.split("\\.")，这样才能正确的分隔开，不能用String.split(".")。
  - 如果用“|”作为分隔的话，必须写成String.split("\\|")，这样才能正确的分隔开，不能用String.split("|")。
  2）如果在一个字符串中有多个分隔符，可以用“|”作为连字符，比如：“acount=? and uu =? or n=?”，把三个都分隔出来，可以用String.split("and|or")。

12.replace()、replaceFirst()和replaceAll()

1.replace()

replace() 方法用于将目标字符串中的指定字符（串）替换成新的字符（串），其语法格式如下：
```
字符串.replace(String oldChar, String newChar)
```
其中，oldChar 表示被替换的字符串；newChar 表示用于替换的字符串。replace() 方法会将字符串中所有 oldChar 替换成 newChar。

2.replaceFirst()

replaceFirst() 方法用于将目标字符串中匹配某正则表达式的第一个子字符串替换成新的字符串，其语法形式如下：
```
字符串.replaceFirst(String regex, String replacement)
```
其中，regex 表示正则表达式；replacement 表示用于替换的字符串

3.replaceAll()

replaceAll() 方法用于将目标字符串中匹配某正则表达式的所有子字符串替换成新的字符串，其语法形式如下：
```
字符串.replaceAll(String regex, String replacement)
```
其中，regex 表示正则表达式，replacement 表示用于替换的字符串

13.equals() 方法、equalsIgnoreCase() 方法、 compareTo() 方法

1.equals() 方法

equals() 方法将逐个地比较两个字符串的每个字符是否相同

2.equalsIgnoreCase() 方法

equalsIgnoreCase() 方法的作用和语法与 equals() 方法完全相同，唯一不同的是 equalsIgnoreCase() 比较时不区分大小写。

3.compareTo() 方法

compareTo() 方法用于按字典顺序比较两个字符串的大小（一个字符串小于另一个指的是它在字典中先出现），该比较是基于字符串各个字符的 Unicode 值。compareTo() 方法的语法格式如下：

str.compareTo(String otherstr);

它会按字典顺序将 str 表示的字符序列与 otherstr 参数表示的字符序列进行比较。如果按字典顺序 str 位于 otherster 参数之前，比较结果为一个负整数；如果 str 位于 otherstr 之后，比较结果为一个正整数；如果两个字符串相等，则结果为 0。

提示：如果两个字符串调用 equals() 方法返回 true，那么调用 compareTo() 方法会返回 0。

14.字符串查找

1. indexOf()

indexOf() 方法用于返回字符（串）在指定字符串中首次出现的索引位置，如果能找到，则返回索引值，否则返回 -1。
- str.indexOf(value)
- str.indexOf(value,int fromIndex)
  
  其中，str 表示指定字符串；value 表示待查找的字符（串）；fromIndex 表示查找时的起始索引，如果不指定 fromIndex，则默认从指定字符串中的开始位置（即 fromIndex 默认为 0）开始查找。
  
  查找方向是向右的

2.lastlndexOf()

lastIndexOf() 方法用于返回字符（串）在指定字符串中最后一次出现的索引位置，如果能找到则返回索引值，否则返回 -1。
- str.lastIndexOf(value)
- str.lastlndexOf(value, int fromIndex)
  
  注意：lastIndexOf() 方法的查找策略是从右往左查找，如果不指定起始索引，则默认从字符串的末尾开始查找。
  
  查找方向是向左的

3.charAt()

charAt() 方法可以在字符串内根据指定的索引查找字符

该方法的语法形式如下：
```
字符串名.charAt(索引值)
```
提示：字符串本质上是字符数组，因此它也有索引，索引从零开始。

15.StringBuffer()

StringBuffer 类是可变字符串类，创建 StringBuffer 类的对象后可以随意修改字符串的内容。每个 StringBuffer 类的对象都能够存储指定容量的字符串，如果字符串的长度超过了 StringBuffer 类对象的容量，则该对象的容量会自动扩大。
- StringBuffer() 构造一个空的字符串缓冲区，并且初始化为 16 个字符的容量。
- StringBuffer(int length) 创建一个空的字符串缓冲区，并且初始化为指定长度 length 的容量。
- StringBuffer(String str) 创建一个字符串缓冲区，并将其内容初始化为指定的字符串内容 str，字符串缓冲区的初始容量为 16 加上字符串 str 的长度。

1.append()

追加字符串

StringBuffer 对象.append(String str)

2. setCharAt()

在字符串的指定索引位置替换一个字符

StringBuffer 对象.setCharAt(int index, char ch);

3.reverse()

将字符串序列用其反转的形式取代

StringBuffer 对象.reverse();

4.deleteCharAt()

deleteCharAt() 方法用于移除序列中指定位置的字符

StringBuffer 对象.deleteCharAt(int index);

5.delete()

delete() 方法用于移除序列中子字符串的字符

StringBuffer 对象.delete(int start,int end);

其中，start 表示要删除字符的起始索引值（包括索引值所对应的字符），end 表示要删除字符串的结束索引值（不包括索引值所对应的字符）

16.String、StringBuffer和StringBuilder类的区别

String 是 Java 中基础且重要的类，被声明为 final class，是不可变字符串。因为它的不可变性，所以拼接字符串时候会产生很多无用的中间对象，如果频繁的进行这样的操作对性能有所影响。

StringBuffer 就是为了解决大量拼接字符串时产生很多中间对象问题而提供的一个类。它提供了 append 和 add 方法，可以将字符串添加到已有序列的末尾或指定位置，它的本质是一个线程安全的可修改的字符序列。

在很多情况下我们的字符串拼接操作不需要线程安全，所以 StringBuilder 登场了。StringBuilder 是 JDK1.5 发布的，它和 StringBuffer 本质上没什么区别，就是去掉了保证线程安全的那部分，减少了开销。

线程安全：

StringBuffer：线程安全
StringBuilder：线程不安全

速度：

一般情况下，速度从快到慢为 StringBuilder > StringBuffer > String，当然这是相对的，不是绝对的。

使用环境：

操作少量的数据使用 String。
单线程操作大量数据使用 StringBuilder。
多线程操作大量数据使用 StringBuffer。

接下来看java基础学习（三）

原文：https://www.cnblogs.com/namusangga/p/14613649.html