1、给定一个长度为n的字符 串，字符串中只包含大小写字母。 请你返回该字符串拥有那些字符。
并将它们按照出现的先后！顺序拼接成一个新的字符串。

这是我最开始写的，代码有点问题：

public String setString(String str) {
    char[] array = str.toCharArray();
    char[] arr = new char[52];
    char[] arrHelp = new char[52];

    for (int i = 0; i < array.length; i++) {
        if ((array[i] >= 'A' && array[i] <= 'Z') && arrHelp[array[i] - 'A'] == 0) {
            arr[i] = array[i];
            arrHelp[array[i] - 'A'] = '1';
        } else if ((array[i] >= 'a' && array[i] <= 'z') && arrHelp[array[i] - 'a' + 26] == 0) {
            arr[i] = array[i];
            arrHelp[array[i] - 'a' + 26] = '1';
        }
    }

    String result = new String(arr);
    return result;
}

自测输入“BAabB”,预期输出“BAab”,实际输出“BAab，怎么回事？

在之前的代码中，使用了错误的索引 i 来赋值 arr[i]，这会导致字符存储位置出现问题。通过引入 index 变量，我们确保只在正确的位置存储有效字符，并保持了字符出现的先后顺序。

在修正后的代码中，我们引入了一个名为 index 的额外变量来追踪有效字符的索引位置。初始值为0，每当遇到一个有效字符时，将其存储在 arr 数组中，并递增 index 的值。

最后，在创建新的字符串对象时，使用 new String(arr, 0, index) 来指定从 arr 数组的索引0开始，一直到有效字符的索引位置 index 结束。这样可以保证生成的字符串只包含有效字符，而不包含未赋值的部分。

通过以上修正，代码将按照预期的方式处理输入字符串，并返回正确的结果 "BAab"。

public String setString(String str) {
    char[] array = str.toCharArray();
    char[] arr = new char[52];
    char[] arrHelp = new char[52];

    int index = 0; // 追踪有效字符的索引

    for (int i = 0; i < array.length; i++) {
        if ((array[i] >= 'A' && array[i] <= 'Z') && arrHelp[array[i] - 'A'] == 0) {
            arr[index++] = array[i]; // 使用 index 来赋值有效字符，并递增索引
            arrHelp[array[i] - 'A'] = '1';
        } else if ((array[i] >= 'a' && array[i] <= 'z') && arrHelp[array[i] - 'a' + 26] == 0) {
            arr[index++] = array[i]; // 使用 index 来赋值有效字符，并递增索引
            arrHelp[array[i] - 'a' + 26] = '1';
        }
    }

    String result = new String(arr, 0, index); // 根据有效字符的索引创建新的字符串
    return result;
}

感觉这个方法笨笨的，有没有更聪明的做法？

我们需要先来了解字符串的一个方法contains（）：

contains方法用于检查一个字符串是否包含另一个字符串。

方法签名：

public boolean contains(CharSequence sequence)

 参数sequence是CharSequence类型，可以传递一个字符串或字符序列作为参数。contains方法返回一个布尔值，表示调用方法的字符串是否包含传递的字符串或字符序列。

String str = "Hello, World!";
boolean containsWorld = str.contains("World"); // 检查str是否包含"World"
System.out.println(containsWorld); // 输出: true

boolean containsGoodbye = str.contains("Goodbye"); // 检查str是否包含"Goodbye"
System.out.println(containsGoodbye); // 输出: false

需要注意的是，contains方法区分大小写。如果需要进行不区分大小写的比较，可以先将字符串转换为小写或大写形式，然后再使用contains方法进行判断。

好了，那么接下来这个问题就很好解决了： 

    public static String func1(String str){
        String s="";
        for(int i=0;i<str.length();i++){
            char ch =str.charAt(i);
            if(!s.contains(ch+"")){
                s+=ch;
            }
        }
        return s;
    }

    //效率太低了！用StringBuider

    public static String func2(String str){
        StringBuilder stringBuilder=new StringBuilder();
        for(int i=0;i<str.length();i++){
            char ch =str.charAt(i);
            if(stringBuilder.indexOf(ch+"")<0){
                stringBuilder.append(ch);
            }
        }
        return stringBuilder.toString();
    }

2、给出一个有序的整数数组A和有序的整数数组B，请将数组B合并到数组A中，变成一个有序的升序数组

数据范围:0≤n，m≤100， Ai<=100 Bi| <= 100

注意:

• 1.保证A数组有足够的空间存放B数组的元素，A和B中初始的元素数目分别为m和n，A的数组空间大小为m+n
• 2.不要返回合并的数组，将数组B的数据合并到A里面就好了，且后台会自动将合并后的数组A的内容打印出来，所以也不需要自己打印
• 3.A数组在[0，m-1]的范围也是有序的。

public void mergeArrays(int[] A, int m, int[] B, int n) {
    int indexA = m - 1; // A数组的末尾索引
    int indexB = n - 1; // B数组的末尾索引
    int mergeIndex = m + n - 1; // 合并后数组的末尾索引

    // 从后往前遍历，将较大的元素从后往前依次放入合并后的数组中
    while (indexA >= 0 && indexB >= 0) {
        if (A[indexA] >= B[indexB]) {
            A[mergeIndex] = A[indexA];
            indexA--;
        } else {
            A[mergeIndex] = B[indexB];
            indexB--;
        }
        mergeIndex--;
    }

    // 如果B数组还有剩余元素，将其依次放入合并后的数组中
    while (indexB >= 0) {
        A[mergeIndex] = B[indexB];
        indexB--;
        mergeIndex--;
    }
}

这里要注意！A[ ] 和 B[ ] 本来就已经按照升序排放好了。

当然，这里也可以选择 可以使用 java.util.Arrays 类中的sort方法。

以下是sort方法的签名：

public static void sort(int[] array)

该方法接受一个整数类型的数组作为参数，并按升序对数组进行排序。排序后，数组中的元素将按照从小到大的顺序排列。

举个例子：

import java.util.Arrays;

public class ArraySortExample {
    public static void main(String[] args) {
        int[] array = {5, 2, 8, 1, 9, 3};

        // 对数组进行排序
        Arrays.sort(array);

        // 输出排序后的数组
        for (int num : array) {
            System.out.print(num + " ");
        }
    }
}

运行以上代码将输出：1 2 3 5 8 9，表示数组中的元素已按升序排列。

需要注意的是，sort方法默认按升序对数组进行排序。如果需要按降序排序，可以使用Arrays.sort方法的重载版本，传递一个Comparator对象作为第二个参数，以指定自定义的排序顺序。

Comparator是一个函数式接口，用于定义比较两个对象的规则。

Comparator接口中有一个compare方法，用于比较两个对象的顺序。返回值为负数表示第一个对象应该排在前面，返回值为正数表示第二个对象应该排在前面，返回值为零表示两个对象相等。

import java.util.Arrays;
import java.util.Comparator;

public class CustomSortingExample {
    public static void main(String[] args) {
        String[] fruits = {"Apple", "Orange", "Banana", "Mango"};

        // 使用自定义的Comparator对象进行排序
        Arrays.sort(fruits, new LengthComparator());

        // 输出排序后的水果数组
        for (String fruit : fruits) {
            System.out.println(fruit);
        }
    }

    // 自定义的Comparator对象，根据字符串长度进行比较
    static class LengthComparator implements Comparator<String> {
        @Override
        public int compare(String s1, String s2) {
            return s1.length() - s2.length();
        }
    }
}

 在上述示例中，我们定义了一个字符串数组fruits，包含一些水果名称。然后，我们创建了一个名为 LengthComparator 的内部类，实现了Comparator<String>接口。在LengthComparator中，我们通过比较字符串长度来定义自定义的排序顺序。

在main方法中，我们使用 Arrays.sort 方法并传递 fruits 数组和 LengthComparator 对象作为参数进行排序。排序后，我们遍历输出排序后的水果数组。

运行以上代码将按照字符串长度进行升序排序输出水果数组。

通过实现自定义的Comparator对象，我们可以根据需要定义不同的排序规则来满足特定的排序需求。

3、关于以下程序代码的说明正确的是(  )

A.程序通过编译，输出结果为:x=102

B.程序通过编译，输出结果为:x=103

C.10行不能通过编译.因为x星私有静态变量

D.5行不能通过编译.因为引用了私有静态变量

 public class HasStatic {// 1
	private static int x = 100;// 2
	public static void main(String args[]) {// 3
		HasStatic hsl = new HasStatic();// 4
		hsl.x++;// 5
		HasStatic hs2 = new HasStatic();// 6
		hs2.x++;// 7
		hsl = new HasStatic();// 8
		hsl.x++;// 9
		HasStatic.x--;// 10
		System.out.println(" x=" + x);// 11
	}
}

1. 本题中的静态成员变量x，属于类变量，只有一份。所有对x的操作针对的都是同一份。
2. 静态成员变量的访问需要通过类名访问，这是正确的访问方式。本题中虽然使用了对象引用访问，但是不会报错，我们不建议这样访问，但不是错误，所以，不会编译报错。

综合以上2点，得出结论：本题可以正常通过编译和运行，输出结果是102。

答案：A