Java第一次面试题2020.5.16（对字符串进行操作）
你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。
题目要求
假定一个任意字符串N,N的长度在20-100之间(含20和100)，
- 首先对字符串进行过滤，只保留0-9,a-f, A-F之间到字符，
- 然后 每3位切分一次，最后一段不够3位的补0，纯数字的不用做进制转换，
- 含有字母的需要当成16进制数字 处理转换成10进制，
- 最后按奇数和偶数分别由小到大的顺序交叉排序输出，每输出10个数字换行，
- 如果 奇数不够补“-”,如果偶数不够补“*"，需统一格式化成最长数字的长度，不够位数的前面补0，
- 如有重复数 字，需要抛出异常，请用程序实现上述逻辑。
第一步-过滤字符串
private String s="544hua4owA326av8vneE4p56ce34bc93fkj00847fhffhj123ad349cd80ffe743f2f4f";
@Test
public void test02() {
StringBuilder sbu = Test02.filter(s);
System.out.println("过滤后="+sbu);
}
/**
* 过滤字符串
* @param s
* @return
*/
public static StringBuilder filter(String s){
//新建StringBuilder用来存储过滤后的字符串
StringBuilder sbu = new StringBuilder();
//判断长度在20-100
if(s.length()<20||s.length()>100){
System.out.println("输入的字符串格式有误");
}
//字符串转为字节数组进行筛选，只保留0-9,a-f, A-F之间到字符，添加到sbu中
char[] arr = s.toCharArray();
for (char c : arr) {
if (c>='0'&&c<='9') {
sbu.append(c);
}else if (c>='a'&&c<='f') {
sbu.append(c);
}else if (c>='A'&&c<='F') {
sbu.append(c);
}
}
return sbu;
}
输出结果：
过滤后=544a4A326a8eE456ce34bc93f00847fff123ad349cd80ffe743f2f4f
第二步-末尾加0
private String s="544hua4owA326av8vneE4p56ce34bc93fkj00847fhffhj123ad349cd80ffe743f2f4f";
/**
* @author wang
* 测试字符串末尾加0
*/
@Test
public void test03() {
//过滤字符串
StringBuilder sbu = Test02.filter(s);
//按三位末尾补0
StringBuilder s = Test02.addZero(sbu);
System.out.println("末尾加0="+s);
}
/**
* 末尾加0
* @param sb1
* @return
*/
public static StringBuilder addZero(StringBuilder sb1){
//字符串长度%3算出需要补0的个数，然后添加
for (int i = 0; i < sb1.length()%3; i++) {
sb1.append(0);
}
return sb1;
}
输出结果：
末尾加0=544a4A326a8eE456ce34bc93f00847fff123ad349cd80ffe743f2f4f0
第三步-三位切分字符串
private String s="544hua4owA326av8vneE4p56ce34bc93fkj00847fhffhj123ad349cd80ffe743f2f4f";
/**
* @author wang
* 测试按三位切分字符串
*/
@Test
public void test04() {
//过滤字符串
StringBuilder sbu = Test02.filter(s);
//按三位末尾补0
StringBuilder s = Test02.addZero(sbu);
//按三位切分字符串
ArrayList<String> list= Test02.cutThree(s);
System.out.println("按3切分后="+list);
}
/**
* 按三位截取字符串
* @param sb2
* @return
*/
public static ArrayList<String> cutThree(StringBuilder sb2){
//新建ArrayList存储切分后的字符串
ArrayList<String> arrayList = new ArrayList<String>();
int j = 0;
int k = 0;
//第一次截取substring(0, 3)，第二次substring(3, 6)...直到超出字符串长度跳出循环
for (int i = 0; i < sb2.length(); i++) {
k = k+3;
arrayList.add(sb2.substring(j, k));
//判断是否到达末尾处，到达跳出循环
if (k>=sb2.length()) {
break;
}
j = j+3;
}
return arrayList;
}
输出结果：
按3切分后=[544, a4A, 326, a8e, E45, 6ce, 34b, c93, f00, 847, fff, 123, ad3, 49c, d80, ffe, 743, f2f, 4f0]
第四步-转为10进制
private String s="544hua4owA326av8vneE4p56ce34bc93fkj00847fhffhj123ad349cd80ffe743f2f4f";
/**
* @author wang
* 测试转为10进制
*/
@Test
public void test05() {
//过滤字符串
StringBuilder sbu = Test02.filter(s);
//按三位末尾补0
StringBuilder s = Test02.addZero(sbu);
//按三位切分字符串
ArrayList<String> list= Test02.cutThree(s);
//转为10进制
ArrayList<String> list1 = Test02.to10(list);
System.out.println("转换10进制后="+list1);
}
/**
* 转为10进制
* @param list
* @return
*/
public static ArrayList<String> to10(ArrayList<String> list){
//遍历字符串集合，如果包含字母就转为10进制
for (int i = 0; i < list.size(); i++) {
String s11 = list.get(i);
//判断是否包含字母
if(s11.matches(".*[a-zA-z].*")){
//用转成10进制的数字替换掉原来位置的元素
list.set(i, new BigInteger(s11, 16).toString()) ;
}
}
return list;
}
输出结果：
转换10进制后=[544, 2634, 326, 2702, 3653, 1742, 843, 3219, 3840, 847, 4095, 123, 2771, 1180, 3456, 4094, 743, 3887, 1264]
第五步-升序排序
private String s="544hua4owA326av8vneE4p56ce34bc93fkj00847fhffhj123ad349cd80ffe743f2f4f";
/**
* @author wang
* 测试升序排序
*/
@Test
public void test06() {
//过滤字符串
StringBuilder sbu = Test02.filter(s);
//按三位末尾补0
StringBuilder s = Test02.addZero(sbu);
//按三位切分字符串
ArrayList<String> list= Test02.cutThree(s);
//转为10进制
ArrayList<String> list1 = Test02.to10(list);
//升序排序
ArrayList<Integer> list2 = Test02.sortList(list1);
System.out.println("排序后="+list2);
}
/**
* 升序排序
* @param stringlist
* @return
*/
public static ArrayList<Integer> sortList(ArrayList<String> stringlist){
//新建ArrayList<Integer>存放数字再进行排序
ArrayList<Integer> integerList = new ArrayList<Integer>();
//遍历字符串集合转为Integer后存入新集合中
for (int i = 0; i < stringlist.size(); i++) {
Integer s = Integer.valueOf(stringlist.get(i));
//System.out.println(Integer.valueOf(stringlist.get(i)));
integerList.add(s);
}
//利用Collections排序
Collections.sort(integerList);
return integerList;
}
输出结果：
排序后=[123, 326, 544, 743, 843, 847, 1180, 1264, 1742, 2634, 2702, 2771, 3219, 3456, 3653, 3840, 3887, 4094, 4095]
第六步-升序排序
private String s="544hua4owA326av8vneE4p56ce34bc93fkj00847fhffhj123ad349cd80ffe743f2f4f";
/**
* @author wang
* 测试分奇偶输出
*/
@Test
public void test07() {
//过滤字符串
StringBuilder sbu = Test02.filter(s);
//按三位末尾补0
StringBuilder s = Test02.addZero(sbu);
//按三位切分字符串
ArrayList<String> list= Test02.cutThree(s);
//转为10进制
ArrayList<String> list1 = Test02.to10(list);
//升序排序
ArrayList<Integer> list2 = Test02.sortList(list1);
//分奇偶输出
Test02.sortList2(list2);
}
/**
*
* 判断是否含有重复元素，分奇偶，单数不足补-，双数不足补*，交叉输出
*/
public static void sortList2(ArrayList<Integer> list){
//判断集合中是否有重复元素,有重复元素抛出异常
ArrayList<Integer> list3 = new ArrayList<Integer>();
//遍历集合存入新集合，存入时判断新集合中是否已经包含此元素
for (int i = 0; i < list.size(); i++) {
Integer s = list.get(i);
if (list3.contains(s)) {
throw new RuntimeException("集合中存在重复元素");
}else {
list3.add(s);
}
}
//新建字符串list1集合存放奇数
ArrayList<String> list1 = new ArrayList<String>();
//新增字符串集合list2存放偶数
ArrayList<String> list2 = new ArrayList<String>();
//遍历排序好的集合，判断奇偶，再分别存入奇数集合或者偶数集合
for (int i = 0; i < list.size(); i++) {
int a = list.get(i);
//如果是基数存入list1，偶数存入list2
if (a%2==1) {
list1.add(String.valueOf(a));
}else {
list2.add(String.valueOf(a));
}
}
//遍历奇数集合，求出奇数集合中每个元素的最大长度，存入j
int j = 0 ;
for (int i = 0; i < list1.size(); i++){
int k = list1.get(i).length();
if (j<k) {
j=k;
}
}
//根据最大长度j算出需要补0的个数（ 比如最大长度4，当前字符串长度3，则需要补一个0）
for (int i = 0; i < list1.size(); i++){
String s = list1.get(i);
int a = j-s.length();//算出需要补0的个数
for (int k = 0; k < a; k++) {
s = "0"+s;
}
//补0之后的新元素再替换掉旧元素
list1.set(i, s);
}
//遍历偶数集合，求出偶数集合中每个元素的最大长度，存入j1
int j1 = 0 ;
for (int i = 0; i < list2.size(); i++){
int k = list2.get(i).length();
if (j1<k) {
j1=k;
}
}
//根据最大长度j1得到需要补0的个数
for (int i = 0; i < list2.size(); i++){
String s = list2.get(i);
int a = j1-s.length();//算出需要补0的个数
for (int k = 0; k < a; k++) {
s = "0"+s;
}
//补0之后的新元素再替换掉旧元素
list2.set(i, s);
}
/*单数补-双数补*
* 算出奇数集合和偶数集合的大小差值
* 如果差值大于0,则奇数集合大,应该为偶数集合添加*,
* 根据之前算出的偶数集合中元素最大长度j1来决定一个元素需要拼接几个*,
* 再根据大小差值的数值得出需要添加几个元素。
* 如果差值小于0,则偶数集合大,应该为奇数集合添加-,
* 根据之前算出的偶数集合中元素最大长度j来决定一个元素需要拼接几个-,
* 再根据大小差值的数值得出需要添加几个元素。
* 最后分别输出奇数集合和偶数集合
*
* **/
int size= list1.size()-list2.size();//算出奇数集合和偶数集合的大小差值
//如果差值大于0，则奇数集合大，应该为偶数集合添加*，根据之前算出的偶数集合中元素最大长度j1来决定添加几个*
if (size>0) {
for (int i = 0; i < size; i++) {
StringBuilder s= new StringBuilder();
//根据之前算出的偶数集合中元素最大长度j1来决定添加几个*
for (int k = 0; k < j1; k++){
s.append("*");
}
list2.add(s.toString());
}
//如果差值小于0，则偶数集合大，应该为奇数集合添加-,根据之前算出的偶数集合中元素最大长度j来决定添加几个-
}else if(size<0) {
for (int i = 0; i < Math.abs(size); i++) {
StringBuilder s= new StringBuilder();
for (int k = 0; k < j; k++){
s.append("-");
}
list1.add(s.toString());
}
}
System.out.println("基数集合="+list1);
System.out.println("偶数集合="+list2);
//把奇数集合和偶数集合作为键值对存入map
LinkedHashMap<String, String> map = new LinkedHashMap<String, String>();
for (int i = 0; i < list1.size(); i++) {
map.put(list1.get(i), list2.get(i));
}
System.out.println("map集合="+map);
System.out.println("最终结果:");
Set<String> set = map.keySet();
int a = 0;
for (String s : set) {
System.out.print(s);
System.out.print(" ");
System.out.print(map.get(s));
System.out.print(" ");
a+=2;
//10个数字后换行
if (10==a) {
System.out.println();
}
}
}
输出结果：
基数集合=[0123, 0743, 0843, 0847, 2771, 3219, 3653, 3887, 4095, ----]
偶数集合=[0326, 0544, 1180, 1264, 1742, 2634, 2702, 3456, 3840, 4094]
map集合={0123=0326, 0743=0544, 0843=1180, 0847=1264, 2771=1742, 3219=2634, 3653=2702, 3887=3456, 4095=3840, ----=4094}
最终结果:
0123 0326 0743 0544 0843 1180 0847 1264 2771 1742
3219 2634 3653 2702 3887 3456 4095 3840 ---- 4094
扫一扫
1160
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
