Java сравнивает строки, которые имеют символы и цифры

Question

В Java я хочу сравнивать и сортировать строки, содержащие символ и число.Например:

A15, D35, A17, C45, B27, C30 должны быть отсортированы

A15 A17 B27 C30 C45 C45 D35.Я не совсем уверен, как сравнить два из этих элементов, потому что они содержат строку и число.Кто-нибудь может мне помочь, пожалуйста?

Answer 1

Если ваши числа всегда состоят из двух цифр, просто сравните все как строки . Числа в десятичном формате тоже являются строками.

Другая история, если вам нужно отсортировать A9, A54 и A123456 и хотите, чтобы числа сортировались по их числовому значению . В этом случае вам может понадобиться написать собственную функцию сравнения, которая разбивает строку на части.

Answer 2

Пример упомянутой функции сравнения:

import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import com.google.common.collect.Lists;

class Scratch {

    public static void main(String[] args) {
        final List<String> in = Lists.newArrayList("D35", "A1", "C7", "A25", "A131");

        Collections.sort(in, new Comparator<String>() {
            @Override
            public int compare(String left, String right) {
                int letter = Character.compare(left.charAt(0), right.charAt(0));
                if (0 != letter)
                    return letter;

                return Long.compare(Long.parseLong(left.substring(1)), Long.parseLong(right.substring(1)));
            }
        });

        System.out.println(in);
    }
}

Answer 3

Обычно, если вам нужно отсортировать список строк, вы можете использовать потоки:

     List<String> yourSortedListOfStrings = yourListOfStrings.stream()
        .sorted()
        .collect(Collectors.toList());

Answer 4

public class StringComparator implements Comparator<String>{

    String string_char[]= {"a","s","d","f","g","h","j","k","l","z","x","c","v","b","n","m","q","w","e","r","t","y","u","i","o","p"};
    public enum DataType{
        STRING,INTEGER,SPECIAL_CHAR;
    }

    public Integer getDataTypePriority(DataType type){
        try{
            switch (type) {
                case SPECIAL_CHAR:
                    return 1;
                case INTEGER:
                    return 2;
                case STRING:
                    return 3;
                default:
                    break;
            }
        }catch(Exception e){
            e.printStackTrace();
        }
        return null;
    }

    public boolean isStringType(String val){
        for(String temp: string_char)
            if(temp.equalsIgnoreCase(val))
                return true;
        return false;   
    }
    public DataType getDataType(Character val){
        DataType type = null;
        try{
            Integer.parseInt(val.toString());
            type = DataType.INTEGER;
        }catch(Exception e){
            if(isStringType(val.toString()))
                type = DataType.STRING;
            else
                type = DataType.SPECIAL_CHAR;
        }
        return type;
    }
    @Override
    public int compare(String new_val, String old_val) {
        int result = 0;
        try{
            if(new_val == null)
                return -1;
            else if(old_val == null)
                return 1;
            StringBuilder old_Int = new StringBuilder();
            StringBuilder new_Int = new StringBuilder();
            DataType oldDataType = null;
            DataType newDataType = null;

            int old_length = old_val.length();
            int new_length = new_val.length();
            int max = old_length;
            if(new_length < old_length)//equals
                max = new_val.length();

            StringBuilder old_Char = new StringBuilder();
            StringBuilder new_Char = new StringBuilder();
            for(int i=0;i<max;i++){
                old_Char.setLength(0);
                new_Char.setLength(0);
                old_Char.append(old_val.charAt(i));
                new_Char.append(new_val.charAt(i));
                oldDataType = getDataType(old_val.charAt(i));
                newDataType = getDataType(new_val.charAt(i));
                if(oldDataType != newDataType){
                    if(getDataTypePriority(newDataType) > getDataTypePriority(oldDataType))
                        return 1;
                    else
                        return -1;
                }else{//same
                    if(newDataType.equals(DataType.STRING)){
                        if(old_Int.length() >0){//clearing string builder
                            old_Int.setLength(0);
                            new_Int.setLength(0);
                        }
                        if(new_Char.toString().compareTo(old_Char.toString()) >0)
                            return 1;
                        else if(new_Char.toString().compareTo(old_Char.toString()) < 0)
                            return -1;                              
                    }else if(newDataType.equals(DataType.INTEGER)){
                        old_Int.append(old_val.charAt(i));
                        new_Int.append(new_val.charAt(i));
                        while(i+1<max){
                            i+=1;
                            oldDataType = getDataType(old_val.charAt(i));
                            newDataType = getDataType(new_val.charAt(i));
                            if(oldDataType.equals(DataType.INTEGER))
                                old_Int.append(old_val.charAt(i));
                            if(newDataType.equals(DataType.INTEGER))
                                new_Int.append(new_val.charAt(i));
                            if(oldDataType != newDataType)
                                break;
                        }
                        if(new_length > max){
                            while(i+1 < new_length){
                                i+=1;
                                newDataType = getDataType(new_val.charAt(i));
                                if(newDataType.equals(DataType.INTEGER))
                                    new_Int.append(new_val.charAt(i));
                                else 
                                    break;
                            }
                        }else if(old_length >max){
                            while(i+1<old_length){
                                i+=1;
                                oldDataType = getDataType(old_val.charAt(i));
                                if(oldDataType.equals(DataType.INTEGER))
                                    old_Int.append(old_val.charAt(i));
                                else 
                                    break;
                            }
                        }
                        Integer n = Integer.parseInt(new_Int.toString());
                        Integer o = Integer.parseInt(old_Int.toString());
                        if(n > o)
                            return 1;
                        else if(n < o) 
                            return -1;
                    }else{//special char
                        if(old_Int.length() >0){//clearing string builder
                            old_Int.setLength(0);
                            new_Int.setLength(0);
                        }
                        if(new_Char.toString().compareTo(old_Char.toString()) >0)
                            return 1;
                        else if(new_Char.toString().compareTo(old_Char.toString()) < 0)
                            return -1;              
                    }
                }
            }
            return new_val.compareTo(old_val);

        }catch(Exception e){
            e.printStackTrace();
        }
        return result;
    }

}