Question

我是一名java初学者，虽然我在这里和谷歌上都找到了这个主题，但我还没有找到它。我确定它必须在某处，但是我不知道如何搜索。无论如何，这是：

如何编写从string / int / etc转换的方法。到一个班级，反之亦然？我绝对喜欢我的班级转换是自动的，但我可以生活在不完美的类型转换中。我不习惯的是调用类（“some string”）或class.toString（）来从字符串到类之间来回转换。我希望它尽可能无缝。这是一个例子：

我有一个 IsFound 类，其行为类似于布尔值，我将其用作方法中的返回类型;在方法体中，我返回一个像“found”这样的字符串（而不是 true ）。你可能会因为没有使用布尔而嘲笑我，但我想用自定义类/类型玩一点。这是一些代码

public class IsFound{

    public boolean found; // field

    public IsFound(String isFound_){
         if(isFound_.equals("FOUND")){
              found = true;
         else found = false;
         }
    }

    public String toString(){
    if(found)   return "found";
    else    return "not found";
    }    
}

这是我能得到的最远的。我需要转换器方法来自/来自字符串以及将来的引用我想知道转换器是否适用于int，char甚至其他类。

扩展布尔值的解决方案只是作为最后的手段，因为我不知道我带着什么膨胀 - 我想自己从0创建类。编辑：我希望能够使用类似的东西：

public IsFound parse(String substring_){
    if(search(substring_, string) == true){
        return FOUND; // or return "FOUND";
    {
    return NOTFOUND; // or return "NOT FOUND";
{

目前它提供了无法从String转换为IsFound的错误。我想填补这个空白。

Answer 1

你的问题闻起来像是经典的XY Problem，因为你似乎正在咆哮错误的树来找到你可能需要更好理解的问题的解决方案。尝试使用Strings作为类型的替代品是一种反模式，所以你最好不要这样做。对于这样的事情，考虑使用两状态类型的布尔值或多状态类型的枚举。

如，

public enum IsFound{
  FOUND, NOT_FOUND, UNKNOWN
}

...或

public enum IsFound {
   FOUND("Found"), NOT_FOUND("Not Found"), UNKNOWN("Unknown");

   private String name;

   private IsFound(String name) {
      this.name = name;
   }

   public String getName() {
      return name;
   }

   @Override
   public String toString() {
      return name;
   }

}

在其他课程中。

private Map<Luggage, IsFound> lostLuggageMap = new HashMap<>();

枚举添加了一个编译时类型安全，而Strings只是没有。
枚举可以具有非常有用的属性和行为（方法）。

Answer 2

我还会使用枚举，这是一个可以为您提供课堂上所有功能的内容。

  public enum IsFound{
    // each of these definitions are like calls to the IsFound constructor below
    FOUND("found"),
    NOT_FOUND("not found");

    // string representation
    private final String toString;

    private IsFound(String isFound){
      this.toString = isFound;
    }

    /**
     * @Override
     */
    public String toString(){
      return toString;
    }    


    // I think this is what you want. I'm not sure why you need this, but
    // am including it as I think it gives you what you want. see example below
    public static IsFound convert( String foundString ){
      if( FOUND.toString.equals(foundString) ){
        return FOUND;
      }
      else if( NOT_FOUND.toString.equals(foundString) ){
        return NOT_FOUND;
      }
      else{
        return null;
      }
    }
  }

您可以通过以下方式使用此功能：

private IsFound myFoundValue;

myFoundValue = IsFound.FOUND;

System.out.println(myFoundValue.toString()); // "found"

myFoundValue = IsFound.NOT_FOUND;

System.out.println(myFoundValue.toString()); // "not found"

switch( myFoundValue ){
  case FOUND:
    System.out.println("the value is FOUND");
  break;
  case NOT_FOUND:
    System.out.println("the value is NOT_FOUND");
  break;
  default:
    System.out.println("this should never happen");
  break;
}

myFoundValue = IsFound.convert("found"); // IsFound.FOUND

System.out.println( myFoundValue.toString() ); // "found"

Answer 3

对于“字符串”表示和POJO（普通旧java对象）之间的转换，您可能希望使用与已知文本格式（如JSON（或XML））之间的序列化。

public class Search {

 private boolean found;

 // getters, setters, constructor

}

使用Google的GSON库进行序列化/反序列化：

Search search = new Search();
search.setFound(true);

Gson gson = new Gson();
String json = gson.toJson(search);
// should output : { "found" : "true" } 

// The opposite way , if json is a string equal to { "found" : "true" } 
Gson gson = new Gson();
Search s = gson.fromJson(json, Search.class);
// s has found = true

Java：如何从类型A转换为类型B？

3 个答案: