从java中的方法返回不同类型的数据?
从java中的方法返回不同类型的数据?,java,return,return-type,Java,Return,Return Type,myMethod()将返回字符串和int值。因此,从main()中获取这些返回值,我提出了以下解决方案 创建类调用ReturningValues public static ? myMethod(){ // ? = what should be the return type return value;// is String return index;// is int } 并更改myMethod(),如下所示 public class ReturningValues { p
myMethod()
将返回字符串和int值。因此,从main()
中获取这些返回值,我提出了以下解决方案
创建类调用ReturningValues
public static ? myMethod(){ // ? = what should be the return type
return value;// is String
return index;// is int
}
并更改myMethod()
,如下所示
public class ReturningValues {
private String value;
private int index;
// getters and setters here
}
现在我的问题是,有没有更简单的方法来实现这一点 否。Java方法只能返回一个结果(
void
、一个原语或一个对象),而创建这样的struct
类型的类正是这样做的
需要注意的是,像您的ReturningValues
这样的类通常是不可变的:
public static ReturningValues myMethod() {
ReturningValues rv = new ReturningValues();
rv.setValue("value");
rv.setIndex(12);
return rv;
}
这样做的好处是可以传递
返回值
,例如在线程之间传递,而不必担心意外地使事情失去同步。这可能是解决方案之一。但你现在的解决方案已经足够好了。您还可以添加新变量并保持其干净,这是当前代码无法做到的
public class ReturningValues {
public final String value;
public final int index;
public ReturningValues(String value, int index) {
this.value = value;
this.index = index;
}
}
一般来说,如果您不确定最终返回的值是什么,则应该考虑使用返回类型作为所有返回值的超级类。在这种情况下,需要返回字符串或int,考虑返回对象类(它是java中定义的所有类的基类)。 但是要小心,在调用此方法的地方要有instanceof checks。否则,您可能会得到ClassCastException
private static final int INDEX_OF_STRING_PARAM = 0;
private static final int INDEX_OF_INT_PARAM = 1;
public static Object[] myMethod() {
Object[] values = new Object[2];
values[INDEX_OF_STRING_PARAM] = "value";
values[INDEX_OF_INT_PARAM] = 12;
return values;
}
public static void main(String args[]) {
Object obj = myMethod(); // i am calling static method from main() which return Object
if(obj instanceof String){
// Do something
}else(obj instance of Integer) {
//do something else
}
你采取的方法很好。 只是实施可能需要更好。 例如,ReturningValues应该定义得很好,并且 如果您可以将ReturningValues设置为不可变就更好了
private static final int INDEX_OF_STRING_PARAM = 0;
private static final int INDEX_OF_INT_PARAM = 1;
public static Object[] myMethod() {
Object[] values = new Object[2];
values[INDEX_OF_STRING_PARAM] = "value";
values[INDEX_OF_INT_PARAM] = 12;
return values;
}
public static void main(String args[]) {
Object obj = myMethod(); // i am calling static method from main() which return Object
if(obj instanceof String){
// Do something
}else(obj instance of Integer) {
//do something else
}
或者,如果有很多键值对,那么可以使用HashMap
// this approach is better
public static ReturningValues myMethod() {
ReturningValues rv = new ReturningValues("value", 12);
return rv;
}
public final class ReturningValues {
private final String value;
private final int index;
public ReturningValues(String value, int index) {
this.value = value;
this.index = index;
}
}
公共静态映射myMethod(){
Map Map=newhashmap();
map.put(VALUE,“VALUE”);
地图出售(索引,12);
返回集合。不可修改映射(map);//尝试使用此
}
@ruchira-ur解决方案本身就是最好的。但我认为,如果它只涉及整数和字符串,我们可以用非常简单的方法来实现
public static Map<String,Object> myMethod() {
Map<String,Object> map = new HashMap<String,Object>();
map.put(VALUE, "value");
map.put(INDEX, 12);
return Collections.unmodifiableMap(map); // try to use this
}
我希望它有用……) 最后,我认为我的方法更好,因为当返回类型的数量增加时,这种实现会以最好的方式实现
class B {
public String myfun() {
int a=2; //Integer .. you could use scanner or pass parameters ..i have simply assigned
String b="hi"; //String
return Integer.toString(a)+","+b; //returnig string and int with "," in middle
}
}
class A {
public static void main(String args[]){
B obj=new B(); // obj of class B with myfun() method
String returned[]=obj.myfun().split(",");
//splitting integer and string values with "," and storing them in array
int b1=Integer.parseInt(returned[0]); //converting first value in array to integer.
System.out.println(returned[0]); //printing integer
System.out.println(returned[1]); //printing String
}
}
我使用enum创建各种返回类型。它不是自动定义的。该实现看起来像工厂模式
public static ReturningValues myMethod() {
ReturningValues rv = new ReturningValues();
rv.setValue("value");
rv.setIndex(12);
return rv;
}
方法重载可以在这里派上用场 比如:
您要查找的类已存在:
公共静态条目myMethod(){
返回新的SimpleEntry(12,“值”);
}
后来:
public static Entry<Integer,String> myMethod(){
return new SimpleEntry<>(12, "value");
}
输入值和索引=myMethod();
int index=valueAndIndex.getKey();
字符串值=valueAndIndex.getValue();
它只是一个简单的两字段数据结构,存储一个键和一个值。如果您需要进行任何特殊处理,存储两个以上的字段,或者有任何其他附带的案例,您应该创建自己的类,但除此之外,
Map.Entry
是利用率较低的Java类之一,非常适合这种情况。我知道这已经很晚了,但我认为它会对来寻找答案的人有所帮助。您可以使用捆绑包
返回多个数据类型值,而无需创建其他方法。我试过了,效果很好
在调用方法的MainActivity中:
方法:
附言:我不确定实现这样的捆绑包是否合适,但对我来说,它运行得非常完美。您可以将返回作为一个对象。您可以在您的应用程序中“动态”创建该对象
public Bundle method() {
mBundle = new Bundle();
String typicalString = "This is String";
Int typicalInt = 1;
mBundle.putString("myS", typicalString);
mBundle.putInt("myI", typicalInt);
return mBundle;
}
字符串也一样。但我担心这是一个昂贵的解决方案…我只想提出我的观点 因此,您需要创建一个通用返回类型,并由不同类型的具体返回类型实现。 服务类可以创建不同类型的对象,并作为泛型类型返回
function: if(int)
return new object(){
int nr=..
}
Java不会强制您声明在函数声明中返回的ArrayList的类型,因此您可以返回任何类型的ArrayList 一种解决方案可以如下所示。 该函数可定义如下(输入的数量/类型可套利)
静态列表多类型输入输出(int a、double b、字符串c、列表d)
{
List multiTypes=new ArrayList();
多类型。添加(a);
多类型。添加(b);
多类型。添加(c);
多类型。添加(d);
返回多类型;
}
调用此类方法/函数时,示例如下(只需记住并正确设置返回类型的顺序):
List HelloWorldStrList=newarraylist(Arrays.asList(“Welcome”、“Hello”、“World”);
List multiType=multiTypeInputOut(1,2.1,“HelloWorld”,HelloWorldStrList);
int entry1=(int)multiType.get(0);
double entry2=(double)multi-type.get(1);
String entry3=(String)multiType.get(2);
List entry4=(List)multiType.get(3);
您可以使用属性
或哈希映射
甚至列表
,但我认为您的返回值
更合适,因为它对于方法返回的内容是明确的。索引和值如何相关?这会起作用,但它的类型安全性要低得多,而且更难阅读。@chrylis是的,我完全同意。我已经提到,当前代码只限于两个或三个返回值是可管理的。但更好的是OP提供的,因为它是类型安全的,更容易理解。正如所建议的,返回类型也可以是接口。在这种情况下,返回的对象/类必须实现此接口。如果索引
和值
字段是私有的,则需要添加getter来访问它们。我个人认为,使用类似枚举的方法看起来有点奇怪。更像是黑客。
Entry<Integer,String> valueAndIndex = myMethod();
int index = valueAndIndex.getKey();
String value = valueAndIndex.getValue();
Bundle myBundle = method();
String myString = myBundle.getString("myS");
String myInt = myBundle.getInt("myI");
public Bundle method() {
mBundle = new Bundle();
String typicalString = "This is String";
Int typicalInt = 1;
mBundle.putString("myS", typicalString);
mBundle.putInt("myI", typicalInt);
return mBundle;
}
function: if(int)
return new object(){
int nr=..
}
public interface GenericReturnType{
public static RETURN_TYPE enum{
MACHINE, PERSON;
}
public RETURN_TYPE getReturnType();
}
public class PersonReturnType implements GenericReturnType{
// CONSTRUCTORS //
// GETTRE AND SETTER //
public RETURN_TYPE getReturnType(){
return PERSON;
}
public String getAddress(){
return something;
}
}
public class MachineReturnType implements GenericReturnType{
// CONSTRUCTORS //
// GETTRE AND SETTER //
public RETURN_TYPE getReturnType(){
return MACHINE;
}
public String getManufatureName(){
return something;
}
}
public class TestService{
public GenericReturnType getObject(// some input //){
GenericReturnType obj ;
if(// some code //){
obj = new PersonReturnType();
// some code //
}
if(// some code //){
obj = new MachineReturnType();
// some code //
}
return obj;
}
}
public class TestDriver{
TestService service = new TestService();
GenericReturnType genObj = TestService.getObject(// some input //);
if(genObj.getReturnType() == RETURN_TYPE.MACHINE){
// SOME CODE //
}
if(genObj.getReturnType() == RETURN_TYPE.PERSON){
// SOME CODE //
}
}
public ArrayList divineCast(String object) {
try
{
Integer result = Integer.parseInt(object);
ArrayList<Integer> generic = new ArrayList<Integer>();
generic.add(result);
return generic;
}
catch(Exception e)
{
//not a Integer
}
try
{
Float result = Float.parseFloat(object);
ArrayList<Float> generic = new ArrayList<Float>();
generic.add(result);
return generic;
}
catch(Exception e)
{
//not a Float
}
try
{
Double result = Double.parseDouble(object);
ArrayList<Double> generic = new ArrayList<Double>();
generic.add(result);
return generic;
}
catch(Exception e)
{
//not a double
}
try
{
Boolean result = Boolean.parseBoolean(object);
ArrayList<Boolean> generic = new ArrayList<Boolean>();
generic.add(result);
return generic;
}
catch(Exception e)
{
//not a Boolean
}
try
{
String result = String.valueOf(object);
ArrayList<String> generic = new ArrayList<String>();
generic.add(result);
return generic;
}
catch(Exception e)
{
//not a String
}
return null;
}
String test1 = "0.90854938";
String test2 = "true";
System.out.println(divineCast(test1).get(0));
System.out.println(divineCast(test1).get(0).getClass());
System.out.println(divineCast(test2).get(0));
System.out.println(divineCast(test2).get(0).getClass());
static List<Object> multiTypeInputOut (int a, double b, String c, List<Object> d)
{
List<Object> multiTypes = new ArrayList<>();
multiTypes.add(a);
multiTypes.add(b);
multiTypes.add(c);
multiTypes.add(d);
return multiTypes;
}
List<Object> HelloWorldStrList = new ArrayList<Object>(Arrays.asList("Welcome", "Hello", "World"));
List<Object> multiType = multiTypeInputOut (1, 2.1, "HelloWorld", HelloWorldStrList);
int entry1 = (int) multiType.get(0);
double entry2 = (double) multiType.get(1);
String entry3 = (String) multiType.get(2);
List<Object> entry4 = (List<Object>) multiType.get(3);