1.题目

2.知识点
注1：
indexOf() 是 Java 中 String 类的方法之一，它用于查找指定字符或字符串在字符串中第一次出现的位置。如果找到了该字符或字符串，则返回它在字符串中的索引位置（从0开始），如果没有找到，则返回-1。
注2：
1）indexOf(int ch)：用于查找指定字符（Unicode码）在字符串中第一次出现的位置。如果找到了该字符，则返回它在字符串中的索引位置（从0开始），如果没有找到，则返回-1。

示例：

String str = "hello";
int index = str.indexOf('e');
System.out.println(index); // 输出：1

2）indexOf(String str)：用于查找指定字符串在当前字符串中第一次出现的位置。如果找到了该字符串，则返回它在字符串中的索引位置（从0开始），如果没有找到，则返回-1。

示例：

String str = "hello";
int index = str.indexOf("lo");
System.out.println(index); // 输出：3

区别1：
valueOf() 是 Java 中许多类的静态方法，用于将其他类型的数据转换为字符串表示形式。

在 String 类中，valueOf() 方法有多个重载形式：

valueOf(boolean b)：将布尔值转换为字符串。

valueOf(char c)：将字符转换为字符串。

valueOf(char[] data)：将字符数组转换为字符串。

valueOf(char[] data, int offset, int count)：将字符数组的一部分转换为字符串。

valueOf(int i)：将整数转换为字符串。

valueOf(long l)：将长整型数转换为字符串。

valueOf(float f)：将浮点数转换为字符串。

valueOf(double d)：将双精度浮点数转换为字符串。

valueOf(Object obj)：将对象转换为字符串，调用该对象的 toString() 方法。

int num = 42;
String str = String.valueOf(num);
//将整数 42 转换为字符串 "42"。

3.思路和例子
（1）字符串反转就是类似交换 先定义左右指针，当左指针小于右指针的时候，两数就进行交换
（2）
StringBuilder 是 Java 中用于构建字符串的可变对象。它允许你有效地构建和修改字符串，而无需每次修改都创建一个新的字符串对象，这样可以节省内存并提高性能。

在代码中，StringBuilder sb = new StringBuilder(); 创建了一个空的 StringBuilder 对象，你可以使用它来构建最终的字符串结果。通过 StringBuilder 的 append() 方法，你可以向其中追加字符、字符串或其他数据类型的值，然后通过 toString() 方法将 StringBuilder 对象转换为最终的字符串。

在这个具体的例子中，你可以看到 StringBuilder 用于构建反转后的字符串结果。你可以通过 sb.append(…) 方法来将反转后的字符逐个追加到 StringBuilder 中，最后通过 sb.toString() 方法获取构建好的字符串。
例子1：
当我们使用 StringBuilder 时，通常会追加字符、字符串或其他数据类型的值，并最终获取构建好的字符串。以下是一个示例，演示了如何使用 StringBuilder 构建一个字符串，将一组数字以逗号分隔开：
在这个例子中，我们首先创建了一个空的 StringBuilder 对象 sb。然后，我们遍历整数数组 numbers，将每个数字逐个追加到 StringBuilder 中。在追加数字时，我们检查当前数字是否是数组的最后一个元素，如果不是，就在数字后面追加逗号分隔符。最后，我们使用 sb.toString() 获取构建好的字符串，并将其输出。

import java.util.*;

public class Example {
    public static void main(String[] args) {
        // 假设有一个整数数组
        int[] numbers = {1, 2, 3, 4, 5};

        // 创建一个 StringBuilder 对象
        StringBuilder sb = new StringBuilder();

        // 遍历整数数组，将每个数字追加到 StringBuilder 中
        for (int i = 0; i < numbers.length; i++) {
            // 追加当前数字
            sb.append(numbers[i]);
            
            // 如果不是最后一个数字，追加逗号分隔符
            if (i < numbers.length - 1) {
                sb.append(", ");
            }
        }

        // 获取构建好的字符串
        String result = sb.toString();
        
        // 输出结果
        System.out.println(result);
    }
}

（3）
在Java中，StringBuilder 类的构造函数可以接受多种类型的参数来初始化 StringBuilder 对象。其中一个重要的构造函数接受一个字符串作为参数，这个字符串会被复制到新的 StringBuilder 对象中。

所以，当我们使用 StringBuilder sb = new StringBuilder(s); 这种形式时，我们是在构造一个新的 StringBuilder 对象，该对象的初始内容是字符串 s 的内容。这意味着我们在构造 StringBuilder 对象的同时，会将字符串 s 的内容复制到新的 StringBuilder 对象中。

使用 StringBuilder sb = new StringBuilder(); 这种形式时，我们是在构造一个空的 StringBuilder 对象，没有传入任何初始内容。这种情况下，StringBuilder 对象会初始化为空，我们可以后续通过 append() 方法来逐步添加内容。

所以，根据需要选择使用不同的构造函数形式来初始化 StringBuilder 对象。

（4）将字符数组中的字符逐个追加到 StringBuilder 中，然后返回 StringBuilder 对象转换成的字符串。

这段代码的目的是将字符数组中的字符逐个追加到 StringBuilder 中，然后返回 StringBuilder 对象转换成的字符串。下面是一个例子来说明这个过程：

假设有一个字符数组 charArray，内容为 {‘a’, ‘b’, ‘c’, ‘d’}。

char[] charArray = {'a', 'b', 'c', 'd'};

// 构建一个 StringBuilder 对象
StringBuilder sb = new StringBuilder();

// 遍历字符数组，将每个字符追加到 StringBuilder 中
for (char c : charArray) {
    sb.append(c);
}

// 将 StringBuilder 对象转换为字符串并返回
String result = sb.toString();
System.out.println(result); // 输出：abcd

//在这个例子中，我们首先创建了一个空的 StringBuilder 对象 sb。然后，我们遍历字符数组 charArray，将数组中的每个字符逐个追加到 StringBuilder 中。最后，我们使用 sb.toString() 将 StringBuilder 对象转换为字符串，并将其存储在 result 变量中。最终输出的结果是字符串 “abcd”。

(5)toCharArray() 是 Java 中 String 类的一个方法，用于将字符串转换为字符数组。它将字符串中的每个字符复制到一个新的字符数组中，并返回该字符数组。

String str = "hello";
char[] charArray = str.toCharArray();

我们首先声明了一个字符串 str，内容为 “hello”。然后，我们调用 toCharArray() 方法将字符串转换为字符数组，并将结果存储在 charArray 变量中。最终，charArray 中存储的内容是 {‘h’, ‘e’, ‘l’, ‘l’, ‘o’}。
(6)charAt() 是 Java 中 String 类的一个方法，用于获取字符串中指定索引位置的字符。它接受一个整数参数，表示要获取的字符在字符串中的位置，然后返回该位置的字符。

public char charAt(int index)

String str = "hello";
char ch = str.charAt(1);
System.out.println(ch); // 输出：e

4.代码实现

class Solution {
    public String reverseVowels(String s) {
        int left=0;
        int right=s.length()-1;
        String yuanyin="AEIOUaeiou";
        char[] mm=s.toCharArray();//将字符串变成字符数组，字符数组有利于单个处理字符
      
        while(left<right)
        {//字符串左半部分没含有元音字母
           while(left<right&&yuanyin.indexOf(s.charAt(left))==-1)
           {
            left++;
           }
           //字符串右半部分没含有元音字母
           while(left<right&&yuanyin.indexOf(s.charAt(right))==-1)
           {
            right--;
           }
           if(left<right)
           {
            char temp=mm[left];
            mm[left]=mm[right];
            mm[right]=temp;
            left++;
            right--;
           }
           }
           StringBuilder sb=new StringBuilder();
           for(char c:mm)
           {
             sb.append(c);
           }
           return sb.toString();
        }
      
       

    }

方法2：没有什么变动 ，只是把构造StringBuilder直接换成了 ,将数组字符 返回到一个新的字符串 return new string(mm).

class Solution {
    public String reverseVowels(String s) {
        int left=0;
        int right=s.length()-1;
        String yuanyin="AEIOUaeiou";
        char[] mm=s.toCharArray();//将字符串变成字符数组，字符数组有利于单个处理字符
      
        while(left<right)
        {//字符串左半部分没含有元音字母
           while(left<right&&yuanyin.indexOf(s.charAt(left))==-1)
           {
            left++;
           }
           //字符串右半部分没含有元音字母
           while(left<right&&yuanyin.indexOf(s.charAt(right))==-1)
           {
            right--;
           }
           if(left<right)
           {
            char temp=mm[left];
            mm[left]=mm[right];
            mm[right]=temp;
            left++;
            right--;
           }
           }
        //   StringBuilder sb=new StringBuilder();
          // for(char c:mm)
          // {
          //   sb.append(c);
          // }
          // return sb.toString();
           // 将字符数组转换为字符串
        return new String(mm);
        }
      
       

    }

方法三：思想没有什么变动，就是如果不用加强for循环 ，用数组的普通循环

class Solution {
    public String reverseVowels(String s) {
        int left=0;
        int right=s.length()-1;
        String yuanyin="AEIOUaeiou";
        char[] mm=s.toCharArray();//将字符串变成字符数组，字符数组有利于单个处理字符
      
        while(left<right)
        {//字符串左半部分没含有元音字母
           while(left<right&&yuanyin.indexOf(s.charAt(left))==-1)
           {
            left++;
           }
           //字符串右半部分没含有元音字母
           while(left<right&&yuanyin.indexOf(s.charAt(right))==-1)
           {
            right--;
           }
           if(left<right)
           {
            char temp=mm[left];
            mm[left]=mm[right];
            mm[right]=temp;
            left++;
            right--;
           }
           }
           StringBuilder sb=new StringBuilder();
          for(int i=0;i<mm.length;i++)
           {
             sb.append(mm[i]);
           }
          return sb.toString();
           // 将字符数组转换为字符串
       //第二种方法 return new String(mm);
       
        }
    
    }