Java实现输入一个字符串,去重后逆序输出

本文提供了一段Java代码,该代码可以接受用户输入的任意字符串,去除其中的重复字符并将其逆序输出。通过使用TreeSet来确保字符的唯一性和排序。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

问题描述:随机输入一个字符串,去掉重复后,逆序输出,直接上代码。

import java.util.Scanner;
import java.util.TreeSet;

public class TestString {
    private String str;
    private TreeSet<String> noReapted;//带有String类型的TreeSet泛型
    public TestString() {
        Scanner in = new Scanner(System.in);
        System.out.println ("输入一个字符串:");
        str = in.nextLine();
        noReapted = new TreeSet<String>();
    }
    //清楚重复的数据
    public void removeRepeated(){
        for (int i = 0; i < str.length();i++){
            noReapted.add(""+str.charAt(i));
            //str.charAt(i)返回的是char型  所以先加一个""空格 , 转换成String型
            //TreeSet泛型能保证重复的不加入 , 而且有序
        }         
        str = "";        
        for(String index:noReapted){
            str += index;
        }  
        StringBuilder sb = new StringBuilder();
        sb.append(str);
        //输出
        System.out.println (sb.reverse());
    }
    public static void main(String[] args) {
    	TestString ts = new TestString();         
        ts.removeRepeated();
    }
}
有什么不明白的,欢迎留言,建议先看看java SE API 

快乐学习,快乐编程!!






<think>嗯,用户让我写一个Java程序,输入一个整数,然后从右往左读取,复的数字,形成新的整数。比如输入9876673,输出应该是37689。首先,我需要理解这个问题。 那我应该怎么处理呢?首先,用户输入的整数可能很大,但Java的int范围是足够的,不过如果是特别大的数可能需要用long或者字符串处理,但题目说输入是int型,所以不用担心。接下来,我需要将这个整数转换成字符串或者字符数组来处理,方便逐个访问每一位数字。 然后,题目要求从右往左读取,也就是反转数字的顺序。比如输入9876673,反转后是3766789。不过要注意,反转后要。但是这里的需要保留最后出现的那个数字。比如原数字是9876673,反转后是3,7,6,6,7,8,9。这时候需要复的,所以应该是3,7,6,8,9。然后组合成37689,对吗?但样例的输出是37689,而反转后的顺序应该是3,7,6,8,9,组合成37689,所以原题中的输出是37689,所以中间可能有步骤是反转后的数字后的顺序。或者是不是应该反转之后,然后保持反转后的顺序? 或者再仔细看样例,输入是9876673,输出是37689。原数字从右往左的顺序是3,7,6,6,7,8,9。的话,每个数字保留最后一次出现的。比如,6出现了两次,保留最后一个出现的那个。例如,遍历的时候,后面的复数字会被保留吗?或者需要保留第一次出现的?比如,对于顺序3,7,6,6,7,8,9,的时候,应该保留每个数字第一次出现的位置,还是最后一次? 比如,原数字从右向左的顺序是3 7 6 6 7 8 9。这时候,如果遍历这个序列,保留第一次出现的数字,那么3会被保留,7第一次出现在第二个位置,之后出现的7就会被掉,而6第一次出现在第三位,后面的6会被掉,而之后的7已经被处理过了。所以这样后的序列是3,7,6,8,9。组合起来就是37689,与样例一致。所以正确的方式应该是从右往左遍历,保留每个数字第一次出现的那个,这样得到的顺序就是后的数字,并且按照从右往左的顺序排列。所以步骤应该是这样的: 1. 将整数转为字符串,然后反转,或者直接从右往左遍历每一位。 2. 遍历每一位数字,记录已经出现过的数字,如果遇到未出现的,就添加到结果中,并标记为已出现。 3. 最后将结果反转回来吗?或者不需要? 比如,输入9876673,从右到左的数字是3,7,6,6,7,8,9。我们需要处理这些数字,并保留每个数字的第一次出现。也就是3先出现,然后是7,然后是6,然后遇到复的6和7,就跳过。接着是8,然后是9。所以处理后的顺序是3,7,6,8,9。然后组合成37689,所以不需要反转,直接按顺序拼接即可。 所以正确的处理方法是:从右往左遍历每一位数字,保留首次出现的数字,并按遍历顺序组成结果。这样得到的顺序就是正确的。 那如何实现呢?可以用一个集合来记录已经出现的数字,比如使用LinkedHashSet来保持顺序,或者用普通的HashSet,但需要按遍历顺序添加。例如: 从右往左遍历每一位数字,如果该数字不在集合中,则添加到结果字符串中,并加入集合。否则跳过。例如: 输入9876673: 各位数字:9 8 7 6 6 7 3 (原数字是9876673,从右到左是3,7,6,6,7,8,9?或者原数字是9876673的各位是9、8、7、6、6、7、3?不,原数字是9876673,从左到右是9-8-7-6-6-7-3。所以从右到左是3-7-6-6-7-8-9。所以遍历的时候,第一位是3,然后是7,6,6,7,8,9。这时候,处理每一位: 3:未出现,加入结果,集合{3},结果"3" 7:未出现,加入,集合{3,7},结果"37" 6:未出现,加入,结果"376",集合+6 6:已存在,跳过 7:已存在,跳过 8:未存在,加入,结果"3768",集合+8 9:未存在,加入,结果"37689" 最终结果就是37689,符合样例。 那这样处理的话,可以用字符串构建的方式,从右往左遍历每一位,同时维护一个集合记录已出现的数字。如果该数字不在集合中,就添加到结果中,并加入集合。 那如何将输入的int转换为字符串,然后反转?或者,直接遍历原字符串逆序? 例如,输入整数是n,可以转为字符串s,然后从后往前遍历每个字符。或者,将s反转,然后从左到右遍历,遇到复的就跳过。两种方法都可以。 例如,s是输入字符串。比如输入9876673,s是"9876673"。反转后得到"3766789"。然后从左到右遍历每个字符,保留首次出现的。例如: 反转后的字符串是"3766789",遍历每个字符: 3 → 未出现 → 添加,结果"3" 7 → 未出现 → 添加 → "37" 6 → 未出现 → 添加 → "376" 6 → 已存在 → 跳过 7 → 已存在 → 跳过 8 → 未出现 → 添加 → "3768" 9 → 未出现 → 添加 → "37689" 最终结果就是37689,符合样例。所以这种方法可行。 那步骤可以是: 1. 将输入的整数转为字符串。如果输入的整数是负数?题目说是int型整数,可能包括负数吗?比如输入-9876673的话,如何处理?但题目中的样例是正数,可能假设输入的是正整数。或者需要处理负号的情况? 题目中的输入描述是输入一个int型整数,输出要求不含复数字的新整数。例如,输入-9876673的话,如何处理?原题样例没有给出这种情况,可能题目假设输入的是正整数,或者需要考虑负号的情况。但根据样例,输入是9876673,输出是37689,所以负号可能被忽略,或者需要考虑。 例如,假设输入的整数可能是负数,那么符号需要保留吗?比如输入-9876673,处理后的结果应该是-37689吗? 但原题中的输入输出样例中没有负号,可能题目中的输入是正整数,所以不需要考虑负数的情况。或者在代码中处理负数的情况,比如将符号单独处理,数字部分处理后再拼接回来。 但目前题目中的输入样例是正数,所以可能暂时不考虑负数的情况,或者在代码中处理。 那现在假设输入的整数是正数,那么步骤: 将输入的整数转为字符串,例如n=9876673 → s="9876673" 反转字符串得到"3766789" 遍历该反转后的字符串,从左到右,保留每个数字的第一次出现。 将这些数字收集起来,得到新的字符串,例如"37689" 然后,这个新字符串就是结果,直接转为整数即可。需要注意前导零的情况吗?比如,输入是100,反转后的数字是001,后得到0,所以输出应该是0。例如,输入100,输出0? 根据题目要求,输入样例的输出是37689,所以如果反转后的数字是001,那么处理后的结果是0,所以输出应该是0。那么代码中需要处理这种情况吗? 是的,例如输入为100,反转后的字符串是"001",后的结果是"0",所以输出0。这在Java中,用Integer.parseInt转换没有问题,会自动处理前导零。 那代码的大致步骤: 1. 读取输入的整数,转为字符串。如果是负数,可能需要处理符号位,但假设输入是正数,所以暂时不考虑。 2. 反转字符串,得到反转后的顺序。 3. 遍历反转后的字符串的每个字符,使用一个集合(例如HashSet)来记录已经出现的数字。如果当前字符不在集合中,就添加到结果字符串中,并将该字符加入集合。 4. 最后将结果字符串转为整数,输出。 这样就能得到正确的结果。 那现在需要考虑输入的整数可能为0的情况吗?比如输入是0,输出应该是0。 那么代码的处理是否正确? 例如,输入0 → 字符串是"0" → 反转后还是"0" → 遍历后得到"0" → 转为整数0。正确。 那现在如何实现Java代码的大致结构: import java.util.*; public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int num = sc.nextInt(); String s = String.valueOf(num); String reversed = new StringBuilder(s).reverse().toString(); Set<Character> seen = new HashSet<>(); StringBuilder result = new StringBuilder(); for (char c : reversed.toCharArray()) { if (!seen.contains(c)) { seen.add(c); result.append(c); } } // 处理结果可能为空的情况?例如输入是0的话,result是"0" System.out.println(Integer.parseInt(result.toString())); } } 但需要处理负数的情况吗?比如,输入为-9876673,反转后的字符串是-3766789?或者原数是负数的话,反转时符号如何处理? 例如,输入-9876673,字符串是"-9876673",反转后是"3766789-",这显然有问题。所以正确的处理方式应该是,当输入为负数时,符号位应该保留在结果的前面吗?例如,输入-9876673,反转后的数字是3766789,得到37689,然后符号放在前面,得到-37689?但原题中的样例没有这种情况,可能题目中的输入是正整数。或者题目不考虑负数的情况,或者用户需要处理负数的情况? 根据题目描述,输入是int整数,可能包含负数。比如,输入-9876673,输出应为-37689吗?或者如何处理? 例如,原题中的输入输出样例是正数,所以可能用户希望处理的是正整数的情况。或者,在处理时,需要将符号单独处理,数字部分处理后再拼接符号。 比如,输入为负数时,取出符号,处理剩余的数字部分,然后将符号加到结果前面。 例如,输入-9876673 → 符号是"-",数字部分是9876673 → 处理得到37689 → 结果-37689. 那如何处理这种情况? 在代码中,可以先判断是否为负数。如果是负数,则符号位保留,处理数字部分,然后将符号添加到结果前面。 例如: public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int num = sc.nextInt(); boolean isNegative = num < 0; num = Math.abs(num); String s = String.valueOf(num); String reversed = new StringBuilder(s).reverse().toString(); Set<Character> seen = new HashSet<>(); StringBuilder result = new StringBuilder(); for (char c : reversed.toCharArray()) { if (!seen.contains(c)) { seen.add(c); result.append(c); } } String res = result.toString(); if (isNegative) { res = "-" + res; } // 处理结果为空的情况? System.out.println(Integer.parseInt(res)); } } 但这样处理的话,当num是负数时,反转后的字符串是原数字绝对值反转后的字符串。例如,输入-9876673 → 绝对值是9876673 → 反转后是3766789 → 处理得到37689 → 加上符号得到-37689。但原数字反转后的处理是否应该包括符号? 比如,原数字是-9876673,原字符串是"-9876673",反转后的字符串是"3766789-"。这样处理的话,反转后的字符包括符号,那么处理后的符号可能出现在最后,导致处理结果错误。所以正确的做法应该是,在反转前,将符号掉,处理完数字部分后,再加上符号。 所以,在代码中,首先判断是否为负数,将符号保存,处理数字部分的反转、,然后将符号加在前面。 这样处理的话,当输入是负数时,输出结果是否正确? 例如,输入-9876673 → 数字部分是9876673 → 反转后得到3766789 → 处理得到37689 → 加上负号,输出-37689。是正确的。 那这样的话,代码需要处理负数的情况。比如: import java.util.*; public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int num = sc.nextInt(); boolean isNegative = false; if (num < 0) { isNegative = true; num = -num; // 这里需要注意当num是Integer.MIN_VALUE时,取反会导致溢出,但题目中是int类型,所以用户输入可能在合法范围内。 } String s = String.valueOf(num); String reversed = new StringBuilder(s).reverse().toString(); Set<Character> seen = new HashSet<>(); StringBuilder result = new StringBuilder(); for (char c : reversed.toCharArray()) { if (!seen.contains(c)) { seen.add(c); result.append(c); } } String resStr = result.toString(); // 处理前导零的情况?比如输入100,反转后的字符串是"001",处理后得到"0" // 当resStr为空时?比如输入0,反转后的字符串是"0",处理后是"0" // 所以不需要处理,直接转换即可 if (resStr.isEmpty()) { System.out.println(0); return; } if (isNegative) { resStr = "-" + resStr; } // 将字符串转换为整数,会自动处理前导零的情况,比如"0376"会被解析为376? // 但是当resStr是"37689",没问题;如果是"0376",转换为整数会变成376。但根据题意,是否需要保留前导零? // 题目中的样例输出是37689,没有前导零,所以正确的处理应该是将结果转为整数,这样前导零会被除。 // 例如,输入9876673的处理结果是"37689",转为整数37689,输出正确。 // 输入100的处理结果是"001"反转后的处理结果是"0",转为整数0。 System.out.println(Integer.parseInt(resStr)); } } 但是,当处理后的结果字符串是空的话,比如输入的num是0吗?比如输入num=0,反转后的字符串是"0",处理后结果是"0",正确。 那这样的话,代码应该可以处理各种情况。 测试样例输入9876673,输出37689。符合条件。 另一个测试输入是9876673 → 反转后的字符串是3766789 → 处理后的37689 → 正确。 输入是100 → 反转后的字符串是001 → 处理后的结果是0 → 正确。 输入是-9876673 → 处理后是-37689 → 正确。 那这个代码是否正确? 可能存在的问题: 当输入的num是0时,代码处理正确。 当输入的num是类似11111,反转后的字符串是11111,处理后是1,正确。 那这个时候,代码是正确的。</think>以下是解决该问题的Java代码实现: ```java import java.util.HashSet; import java.util.Scanner; import java.util.Set; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int num = scanner.nextInt(); boolean isNegative = num < 0; // 处理负数情况,取其绝对值处理 String s = String.valueOf(Math.abs(num)); // 反转字符串 String reversed = new StringBuilder(s).reverse().toString(); Set<Character> seen = new HashSet<>(); StringBuilder result = new StringBuilder(); for (char c : reversed.toCharArray()) { if (!seen.contains(c)) { seen.add(c); result.append(c); } } // 处理结果为空的情况(理论上不会出现) if (result.length() == 0) { System.out.println(0); return; } // 负数添加符号 String finalResult = isNegative ? "-" + result : result.toString(); // 转换为整数输出(自动处理前导零) System.out.println(Integer.parseInt(finalResult)); } } ``` --- ### **代码解析** 1. **输入处理** - 使用`Scanner`读取输入的整数 - 判断是否为负数,并记录符号状态 2. **字符串反转** ```java String reversed = new StringBuilder(s).reverse().toString(); ``` - 将整数转为字符串后反转,实现从右向左的阅读顺序 3. **处理** - 使用`HashSet`记录已出现的数字 - 遍历反转后的字符串,保留第一次出现的数字 4. **结果构建** - 若原数为负数,在结果前添加负号 - 直接通过`Integer.parseInt()`转换结果,自动处理前导零问题 --- ### **关键点说明** - **反转顺序**:通过`StringBuilder.reverse()`实现从右向左处理 - **策略**:使用`HashSet`记录已出现的字符,保证唯一性 - **符号处理**:单独处理负数符号,避免反转干扰 - **数值转换**:`Integer.parseInt()`自动除前导零(如输入`100`输出`0`) --- ### **测试案例** | 输入 | 输出 | 解释 | |-------------|----------|---------------------------| | 9876673 | 37689 | 样例输入,正常流程验证 | | 100 | 0 | 验证零逻辑 | | -123344556 | -654321 | 验证负数处理 | | 11111 | 1 | 全复数字场景 |
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值