Question

让我说我有

class Dummy {
    String a, b;
    public Dummy(String a, String b) {
        this.a = a;
        this.b = b;
    }
    public String toString(){
        return a+b;
    }
    public String getA() {
        return a;
    }
    public String getB() {
        return b;
    }

}

我想

List<Dummy> myList = new ArrayList<Dummy>() {{
     add(new Dummy("test", ""));
     add(new Dummy("boo", "o"));
}};

System.out.println( myList.toString());
System.out.println( myList.getAs());  //should return ["test", "boo"]
System.out.println( myList.getBs());//should return ["", "o"]

如果你明白我的意思

可能要创建扩展ArrayList<Dummy>的类？

修改

好像那样

class Dummy {
    String a, b;
//...
    public static String toAString(List<Dummy> l){
       String s="";
       for (Dummy d : l){
           s+=d.a;
       }
       return s;
    }
}

edit2：

我只会在Dummy中使用2个字符串，它更适合做ArrayList<String []>吗？在内存方面

Answer 1

定义与getA和getB对应的第一类函数。我正在使用Guava中的Function。

class Dummy {
    String a, b;
    public Dummy(String a, String b) {
        this.a = a;
        this.b = b;
    }
    public String toString(){
        return a+b;
    }
    public String getA() {
        return a;
    }
    public String getB() {
        return b;
    }
    public static Function<Dummy, String> getA = new Function<Dummy, String>() {
      public String apply(Dummy d) {
        return d.a;
      }
    }
    public static Function<Dummy, String> getB = new Function<Dummy, String>() {
      public String apply(Dummy d) {
        return d.b;
      }
    }
}

这是你如何使用它:(下面的Iterables也是来自Guava）。

List<Dummy> myList = new ArrayList<Dummy>() {{
     add(new Dummy("test", ""));
     add(new Dummy("boo", "o"));
}};

System.out.println( myList.toString());
System.out.println( Iterables.transform(myList, Dummy.getA)); // returns ["test", "boo"]
System.out.println( Iterables.transform(myList, Dummy.getB)); // returns ["", "o"]

Answer 2

在Java 8之前，您可以使用像Guava这样的功能习惯API之一：

Function<Dummy, String> getAFunc = new Function<Dummy, String> {
    @Override
    public String apply(Dummy dummy) {
        return dummy.getA();
    }
}

Function<Dummy, String> getBFunc = new Function<Dummy, String> {
    @Override
    public String apply(Dummy dummy) {
        return dummy.getB();
    }
}

System.out.println( Lists.transform(myList, getAFunc) );
System.out.println( Lists.transform(myList, getBFunc) );

同意这是非常丑陋和冗长的，以及番石榴团队在说misuse of functional idioms makes them weep时所指的一些内容。

但是等等，有希望，并且使用the open source Funcito library（免责声明：这是一种方法，使这个代码更优雅，更短，更通用于任何情况）主要作者）

现在你可以简单地写

Function<Dummy, AType> getAFunc = functionFor( callsTo(Dummy.class).getA() );
Function<Dummy, BType> getBFunc = functionFor( callsTo(Dummy.class).getB() );

System.out.println( Lists.transform(myList, getAFunc) );
System.out.println( Lists.transform(myList, getBFunc) );

简洁的关键是使用Funcito来构建你的函数。即使假设A＆amp; B不是字符串，正如我在示例中所示。现在你可以将它用于除Dummy之外的任何类型，并且对于任何具有getter方法的字段，通过使用Funcito快速生成包装适当方法的Function。如果您愿意，Funcito还可以使用除番石榴之外的一些替代功能API。

请注意，上面的内容是使用Guava的导入和Funcito的静态导入。

Answer 3

是的，你是对的，你需要扩展ArrayList才能做到这一点。

Answer 4

      List<Dummy> myList = new ArrayList<Dummy>() 
      myList.add(new Dummy("test", ""));     
      myList.add(new Dummy("boo", "o")); 


                     for(Dummy dumdum : myList) {
                     System.out.println(dumdum.getA() + " " + dumdum.getB());
                      }

这是您正在寻找的，还是我误解了您的问题？

Answer 5

使用Composition而不是继承..............

考虑同一个包中的所有类。

Dummy Class:

class Dummy {
    String a, b;
    public Dummy(String a, String b) {
        this.a = a;
        this.b = b;
    }
    public String toString(){
        return a+b;
    }
    public String getA() {
        return a;
    }
    public String getB() {
        return b;
    }

}

Test Class: 已编辑

public class Test{
 Test t = new Test();                   
 List<Dummy> myList = new ArrayList<Dummy>();
 public static void main(String[] args){
 t.myList.add(new Dummy("test", ""));
 t.myList.add(new Dummy("boo", "o"));
for (Dummy d : t.myList)
{
  System.out.println(d.toString());
  System.out.println(d.getA());  
  System.out.println(d.getB()); 
  }
 } 
}

Answer 6

快速扩展ArrayList变得站不住脚，因为你最终需要一个MoronArrayList，一个GeniusArrayList，一个DummyHashMap，一个DummyQueue等......

@missingfaktor建议的番石榴的东西是一种选择。另一个选择，如果经常需要它，它将实用程序方法放在 Dummy 类中。 e.g。

public static String toAStrings(Collection<Dummy> collection) {
   StringBuilder sb = new StringBuilder;
   boolean firstTime = true;
   for (Dummy dummy : collection) {
      if (!firstTime )
         sb.append(",");
      firstTime = false;
      sb.append(dummy.getA());
   }

   return sb.toString();
}

Java Extend ArrayList <dummy> functions </dummy>

6 个答案: