效率问题

Question

这段代码可以优化吗，就是迭代一个list，把当中的对象的属性设到另外一个对象的属性上，再把另外的对象add到另外一个list中。上代码：A.javapublic class A {    private String abc;
    private int a;
    private float ab;
    
    public String getAbc() {
        return abc;
    }
    public void setAbc(String abc) {
        this.abc = abc;
    }
    public int getA() {
        return a;
    }
    public void setA(int a) {
        this.a = a;
    }
    public float getAb() {
        return ab;
    }
    public void setAb(float ab) {
        this.ab = ab;
    }
}
B.javaprivate String abc;
    private int a;
    private float ab;
    
    public String getAbc() {
        return abc;
    }
    public void setAbc(String abc) {
        this.abc = abc;
    }
    public int getA() {
        return a;
    }
    public void setA(int a) {
        this.a = a;
    }
    public float getAb() {
        return ab;
    }
    public void setAb(float ab) {
        this.ab = ab;
    }
C.javapublic class C {    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub        List<A> alist = new ArrayList<A>();
        List<B> blist = new ArrayList<B>();
        
        A a1 = new A();
        a1.setA(1);
        a1.setAb(1.1f);
        a1.setAbc("111");
        
        A a2 = new A();
        a2.setA(2);
        a2.setAb(1.2f);
        a2.setAbc("222");
        
        A a3 = new A();
        a3.setA(3);
        a3.setAb(1.3f);
        a3.setAbc("333");
        
        alist.add(a1);
        alist.add(a2);
        alist.add(a3);
        
        for(A a:alist){ // 此处是否可以优化，或者其他方法。其中A.java 和B.java属性方法都一样的，就类名不一样。
            B b = new B();
            b.setA(a.getA());
            b.setAb(a.getAb());
            b.setAbc(a.getAbc());
            blist.add(b);
        }
        
        for(B b:blist){
            System.out.println(b.getA());
            System.out.println(b.getAb());
            System.out.println(b.getAbc());
        }
        
    }}

Answer 1

B.java贴错了。。
public class B {
    
    private String abc;
    private int a;
    private float ab;
    
    public String getAbc() {
        return abc;
    }
    public void setAbc(String abc) {
        this.abc = abc;
    }
    public int getA() {
        return a;
    }
    public void setA(int a) {
        this.a = a;
    }
    public float getAb() {
        return ab;
    }
    public void setAb(float ab) {
        this.ab = ab;
    }
}

Answer 2

我觉得没什么可优化的了
get
set在效率貌似没什么值得优化的

Answer 3

没什么好优化的，java不纠结效率问题，

Answer 4

拷贝属性可以用BeanUtils(工具类  网上找一下)BeanUtils.copyProperties(A, B);

Answer 5

for(A a:alist){ // 此处是否可以优化，或者其他方法。其中A.java 和B.java属性方法都一样的，就类名不一样。
            B b = new B();//这个对象创建了好多次了啊。。难道真没什么优化的吗。
            b.setA(a.getA());
            b.setAb(a.getAb());
            b.setAbc(a.getAbc());
            blist.add(b);
        }

Answer 6

package com.codetest.test.abc;import java.util.ArrayList;
import java.util.List;public class A {
private String abc;
private int a;
private float ab; public String getAbc() {
return abc;
} public void setAbc(String abc) {
this.abc = abc;
} public int getA() {
return a;
} public void setA(int a) {
this.a = a;
} public float getAb() {
return ab;
} public void setAb(float ab) {
this.ab = ab;
} public A() {
} public A(String abc, int a, float ab) {
this.abc = abc;
this.a = a;
this.ab = ab;
}
}class B {
private String abc;
private int a;
private float ab; public String getAbc() {
return abc;
} public void setAbc(String abc) {
this.abc = abc;
} public int getA() {
return a;
} public void setA(int a) {
this.a = a;
} public float getAb() {
return ab;
} public void setAb(float ab) {
this.ab = ab;
} public B() {
} public B(String abc, int a, float ab) {
this.abc = abc;
this.a = a;
this.ab = ab;
}
}class C {
public static void main(String[] args) {
List<A> alist = new ArrayList<A>();
List<B> blist = new ArrayList<B>(); alist.add(new A("111", 1, 1.1f));
alist.add(new A("222", 2, 1.2f));
alist.add(new A("333", 3, 1.3f)); for (A a : alist) { // 此处是否可以优化，或者其他方法。其中A.java 和B.java属性方法都一样的，就类名不一样。
blist.add(new B(a.getAbc(), a.getA(), a.getAb()));
} for (B b : blist) {
System.out.println(b.getA());
System.out.println(b.getAb());
System.out.println(b.getAbc());
}
}
}

Answer 7

能解释下，为什么用构造方法吗，同样是new 一个对象，有什么区别吗？谢谢拉

Answer 8

优化是为了提高效率，代码整洁，java代码说真的，差不多就行,//应用6L
for(A a:alist){ // 此处是否可以优化，或者其他方法。其中A.java 和B.java属性方法都一样的，就类名不一样。
            B b = new B();//这个对象创建了好多次了啊。。难道真没什么优化的吗。
            b.setA(a.getA());
            b.setAb(a.getAb());
            b.setAbc(a.getAbc());
            blist.add(b);
        }第一个//，可以给这2个类用接口，父类，
第一个//，new B()必须是多次的，因为blist.add(b);是放b的地址到blist里面，必须多次new生成多个地址，最多把声明写在循环外//应用6L
B b = null;
for(A a:alist){ 
   b = new B();
   b.setA(a.getA());
   b.setAb(a.getAb());
   b.setAbc(a.getAbc());
   blist.add(b);
}有些地方改只能叫做java的多种写法，没有太大的优劣，不能叫代码优化

Answer 9

就是效率上的区别呗。调用对象的成员变量与成员函数在实质上是不同的：
调用成员变量实质是一次寻址操作；调用成员函数实质上是一次寻址+一次跳转。
以常见的PC机CPU计算：寻址操作的时间与加法运算的时间相当；跳转操作的时间通常相当于一次加法运算的5-10倍。通常情况上这些系统级的效率差别并不是程序效率上的瓶颈。但是，“不积跬步，无以致千里；不积小流，无以成江海。”的道理大家都应该明白，平时养成高效编码的习惯还是好些的。PS：用带参构造函数也不会影响可读性哈。

Answer 10

最近好像在论坛上看到有不少人提出这种不负责任的观点。(PS：啊咧，幻觉么？怎么感觉在下在论坛里也写过类似的话？该打)
如果您的职业定位不是一辈子做下级代码工的话就给我把这个观点扔掉！不管是哪行哪业，只要是企业，追求的都是效益。而效率是与效益密切相关的。对于同一个功能，作为客户的话，您愿意要半分钟得结果的程序还是几秒钟得到结果的？我们通常说，Java程序员并“不太关心效率的问题”这句话其实是省略了部分内容的。由于Java程序员很多时候都会拿别人的开源控件来直接用，这里他们不会去注意这些控件运行的效率问题，因为效率不好的话可以换一个满足要求的。换言之，他们不是不注意效率问题，而是把效率问题留给控件的开发者去解决了。而一个程序不可能全部用别人的控件做成，总得有自己的代码。虽然Java程序员可以不去注意系统级别、控件级别的效率问题，但自己代码的逻辑算法上的效率问题还是要注意的。

Answer 11

10楼的数字很给力！
但是，对于 构造函数 或者 set方法这种 极低的开销上，编码清晰的价值远远大于你所谓的那5倍速 的价值
效率不是在set、get方法这些所谓的寻址上考虑的吧。。
比如 socket编成我们会用NIO ， 应该他就是比IO快N倍，而IO的开销是非常大的，这个东西上考虑效率才有价值，效率都是在大开销的操作上重点考虑的，难道还考虑 我这个代码用了10次set，我能不能用8次把事情做完，如果我直接用构造函数+8个参数会快N倍哦？还有带参构造函数，可读性明显比set要差太多，对于一个方法参数越多，可读性越低所以你所说的构造效率高于 set什么的， 我个人直接无视

Answer 12

在下上面的回复中似乎已经提到了像这种系统级的效率差异通常并不是程序的效率瓶颈所在。在下始终认为世上没什么事是绝对的，“可读性”什么的也是因人而异。就像“众口难调”一样，有人认为先new出一个对象，再用set组对其初始化(就像是先说明有一个个体，再逐步描述其特征)这样比较直观；也有些人会认为直接用带参构造函数初始化(就像是直接让观众看到一个完整的个体)这样比较容易接受。这种各人感觉上的差异很平常。
但这两种方案中效率上的差异也是确实存在的。另外，关于构造函数参数数量的问题在下与12楼看法基本一致。过多的参数不仅读起来困难，而且可能会导致程序栈段过大反而会影响效率。但这里可以采用像构造中间类、同类参数用数组传递等手段来减少参数数量。要知道：方法是死的，而使用方法的人是活的。