全排序、首字母大小、字符串去重。。。方法的实现

1、全排序方法

将一个String类型数据排列生成没有任何两个相同元素的字符串（每个字符串长度和输入的字符串长度相同/每个元素都要使用到）

    //算法思路是二叉树（减枝）
    public ArrayList<String> parmute(String str){
        char[] chars = str.toCharArray();
        if(chars.length == 0) return list;
        StringBuilder path =new StringBuilder();//在单线程中，StringBuilder类运算速度更快
        boolean[] used = new boolean[chars.length];//定义字符串元素的使用情况
        dfs(chars,path,used);
        return list;
    }

    //迭代
    private void dfs(char[] chars, StringBuilder path, boolean[] used) {
        if(path.length() == chars.length){//判断是否到达二叉树最底层
            list.add(new String(path));
            return ;
        }
        for (int i = 0; i < chars.length; i++) {
            if(used[i] == true)//判断该元素是否使用过
                continue;
            used[i] = true;//将该元素标记为使用
            path.append(chars[i]);//进入到下一级（添加一个元素）
            dfs(chars,path,used);//递归
            path.deleteCharAt(path.length() - 1);//回溯
            used[i] = false;//释放该元素，让其在其他分枝可以被使用
        }
    }

2、字符串首字母大小写转换

输入一串字符串，将每个单词的首字母转换成大写其余还是小写字母
方法一： 

public static String tialetterturn(String str){
        String[] str1 = str.split(" ");
        System.out.println(Arrays.toString(str1));
        StringBuilder str3 = new StringBuilder();
        for (String s : str1) {
            char[] chars = s.toCharArray();
            for (int i = 0; i < chars.length; i++) {
                if (i ==0 && chars[0] >= 'a' && chars[0] <= 'z'){
                    chars[0] -= 32;
                }
                if (i>= 1 && chars[i] >= 'A' && chars[i] <= 'Z'){
                    chars[i] += 32;
                }
            }
            String str2 = ArrayTurnString(chars);
            str3.append(str2);
            str3.append(" ");
        }
        return new String(str3);
    }

    private static String ArrayTurnString(char[] arr) {
        String temp = Arrays.toString(arr);
        String str02 = temp.substring(1,temp.length()-1);
        return str02.replace(", ","");
    }

将字符数组中的所有大写字母变成小写字母(不能使用 toLowerCase()方法)

public static char[] toLowerCase(char[] chars){
        for (int i = 0; i < chars.length; i++) {
            if (chars[i] >= 'A' && chars[i] <= 'Z'){
                chars[i] += 32;
            }
        }
        return chars;
    }

3、字符串去重处理

去除给定的参数字符串中的重符字符

public static String getSingleString(String str){
        StringBuffer str2 = new StringBuffer();
        for (int i = 0; i < str.length(); i++) {
            if (str.indexOf(str.charAt(i)) == i){
                str2.append(str.charAt(i));
            }
        }
        return new String(str2);
    }

创建一个一维数组arr(String类型)，里面元素有{“a”,”s”,”d”,”f”,”a”,”a”,”d”,”2”,”3”,”8”}，
根据里面的元素随机生成一个长度为5的字符串，将该字符串中相同的元素去重然后再反序输出到控制台上

public static void main(String[] args) {
        String[] arr = {"a","s","d","f","a","a","d","2","3","8"};
        Random random = new Random();
        StringBuilder str = new StringBuilder();
        StringBuilder str2 = new StringBuilder();
        for (int i=0;i<5;i++){
            str.append(arr[random.nextInt(arr.length)]);
        }
        System.out.println("去重前：" + str.toString());
        Map<Character,Object> map = new LinkedHashMap<>();
        for (int i = 0; i < str.length(); i++) {
            map.put(str.charAt(i),i);//去重
        }

        //获取迭代器
        Iterator<Character> iterator = map.keySet().iterator();
        while (iterator.hasNext()) {//没有指针下移操作，只是判断是否存在下一个元素
            Character string = iterator.next();
//            System.out.println(iterator.next());
            str2.append(string);
        }
        System.out.println("去重反转后：" + str2.reverse().toString());

    }

    private static void method01() {//方法一
        String[] arr = {"a","s","d","f","a","a","d","2","3","8"};
        Random random = new Random();
        StringBuilder str = new StringBuilder();
        StringBuilder str2 = new StringBuilder();
        for (int i=0;i<5;i++){
            str.append(arr[random.nextInt(arr.length)]);
        }
        System.out.println("去重前：" + str.toString());
        for (int i = 0; i < str.length(); i++) {
            if (str.indexOf(String.valueOf(str.charAt(i))) == i) {
                str2.append(str.charAt(i));
            }
        }
        System.out.println("去重反转后：" + str2.reverse().toString());
    }