'Java代碼優化Java final 修飾類或者方法能提高性能？'
Java代碼優化 Java final 修飾類或者方法能提高性能？還50%？老鐵，你試了嗎？
Java代碼優化 Java final 修飾類或者方法能提高性能？還50%？老鐵，你試了嗎？
最近不是一直在搞優化嗎，為的就是提高項目的處理能力，提高吞吐量。然後就各種搜呀，各種JProfiler測試。看看代碼有啥可優化的。總能看到一個觀點。
final修飾類或者方法，能是性能提高50%。
不止一次，見到這個觀點。這個是真的嗎？
我來測試一下
1，先看下加final的方法和不加的差別
Java代碼優化 Java final 修飾類或者方法能提高性能？還50%？老鐵，你試了嗎？
最近不是一直在搞優化嗎，為的就是提高項目的處理能力，提高吞吐量。然後就各種搜呀，各種JProfiler測試。看看代碼有啥可優化的。總能看到一個觀點。
final修飾類或者方法，能是性能提高50%。
不止一次，見到這個觀點。這個是真的嗎？
我來測試一下
1，先看下加final的方法和不加的差別
看不出來50%在哪裡。
使用的測試代碼：
main方法
package com.lxk.fast;
import com.google.common.collect.Lists;
import com.lxk.model.Car;
import com.lxk.model.CarFinal;
import com.lxk.model.Dog;
/**
* 有人說給方法或者類加上final之後，效率會提升，我來試試。
*
* @author LiXuekai on 2019/6/20
*/
public class IsFinalFast {
public static void main(String[] args) {
methodTest();
//classTest();
}
private static void classTest() {
while (true) {
classFinal();
classNoFinal();
}
}
private static void classFinal() {
CarFinal car = new CarFinal("oooo", 100, Lists.newArrayList(new Dog("aaa", true, true)));
car.finalRun();
}
private static void classNoFinal() {
Car car = new Car("oooo", 100, Lists.newArrayList(new Dog("aaa", true, true)));
car.run();
}
private static void methodTest() {
Car car = new Car("oooo", 100, Lists.newArrayList(new Dog("aaa", true, true)));
while (true) {
noFinal(car);
isFinal(car);
}
}
private static void isFinal(Car car) {
car.finalRun();
}
private static void noFinal(Car car) {
car.run();
}
}
使用的2個model類
Car.java
package com.lxk.model;
import com.google.common.collect.Lists;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Car implements Cloneable, Comparable<Car> , Serializable {
private String sign;
private int price;
private List<Dog> myDog;
private List<String> boys;
public Car(String sign, int price) {
this.sign = sign;
this.price = price;
}
public Car(String sign, int price, List<Dog> myDog) {
this.sign = sign;
this.price = price;
this.myDog = myDog;
}
@Override
public int compareTo(Car o) {
//同理也可以根據sign屬性排序，就不舉例啦。
return this.getPrice() - o.getPrice();
}
@Override
public String toString() {
return "Car{" +
"sign='" + sign + '\\'' +
", price=" + price +
", myDog=" + myDog +
", boys=" + boys +
'}';
}
@Override
public Car clone() {
Car car = null;
try {
car = (Car) super.clone();
if (myDog != null) {
car.setMyDog(Lists.newArrayList(myDog));
}
if (boys != null) {
car.setBoys(Lists.newArrayList(boys));
}
} catch (CloneNotSupportedException ignored) {
System.out.println(ignored.getMessage());
}
return car;
}
public void run() {
for (int i = 0; i < 1000; i++) {
func();
}
}
public final void finalRun() {
for (int i = 0; i < 1000; i++) {
func1();
}
}
final void func1() {
String s = this.toString();
}
void func() {
String s = this.toString();
}
}
CarFinal.java
package com.lxk.model;
import com.google.common.collect.Lists;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
/**
* 使用final的Car類
*
* @author LiXuekai on 2019/6/20
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public final class CarFinal implements Cloneable, Comparable<Car>, Serializable {
private String sign;
private int price;
private List<Dog> myDog;
private List<String> boys;
public CarFinal(String sign, int price) {
this.sign = sign;
this.price = price;
}
public CarFinal(String sign, int price, List<Dog> myDog) {
this.sign = sign;
this.price = price;
this.myDog = myDog;
}
@Override
public int compareTo(Car o) {
//同理也可以根據sign屬性排序，就不舉例啦。
return this.getPrice() - o.getPrice();
}
@Override
public String toString() {
return "Car{" +
"sign='" + sign + '\\'' +
", price=" + price +
", myDog=" + myDog +
", boys=" + boys +
'}';
}
@Override
public Car clone() {
Car car = null;
try {
car = (Car) super.clone();
if (myDog != null) {
car.setMyDog(Lists.newArrayList(myDog));
}
if (boys != null) {
car.setBoys(Lists.newArrayList(boys));
}
} catch (CloneNotSupportedException ignored) {
System.out.println(ignored.getMessage());
}
return car;
}
public void run() {
for (int i = 0; i < 1000; i++) {
func();
}
}
public final void finalRun() {
for (int i = 0; i < 1000; i++) {
func1();
}
}
final void func1() {
String s = this.toString();
}
void func() {
String s = this.toString();
}
}
2，使用final 的類和沒final的類的差別。
Java代碼優化 Java final 修飾類或者方法能提高性能？還50%？老鐵，你試了嗎？
最近不是一直在搞優化嗎，為的就是提高項目的處理能力，提高吞吐量。然後就各種搜呀，各種JProfiler測試。看看代碼有啥可優化的。總能看到一個觀點。
final修飾類或者方法，能是性能提高50%。
不止一次，見到這個觀點。這個是真的嗎？
我來測試一下
1，先看下加final的方法和不加的差別
看不出來50%在哪裡。
使用的測試代碼：
main方法
package com.lxk.fast;
import com.google.common.collect.Lists;
import com.lxk.model.Car;
import com.lxk.model.CarFinal;
import com.lxk.model.Dog;
/**
* 有人說給方法或者類加上final之後，效率會提升，我來試試。
*
* @author LiXuekai on 2019/6/20
*/
public class IsFinalFast {
public static void main(String[] args) {
methodTest();
//classTest();
}
private static void classTest() {
while (true) {
classFinal();
classNoFinal();
}
}
private static void classFinal() {
CarFinal car = new CarFinal("oooo", 100, Lists.newArrayList(new Dog("aaa", true, true)));
car.finalRun();
}
private static void classNoFinal() {
Car car = new Car("oooo", 100, Lists.newArrayList(new Dog("aaa", true, true)));
car.run();
}
private static void methodTest() {
Car car = new Car("oooo", 100, Lists.newArrayList(new Dog("aaa", true, true)));
while (true) {
noFinal(car);
isFinal(car);
}
}
private static void isFinal(Car car) {
car.finalRun();
}
private static void noFinal(Car car) {
car.run();
}
}
使用的2個model類
Car.java
package com.lxk.model;
import com.google.common.collect.Lists;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Car implements Cloneable, Comparable<Car> , Serializable {
private String sign;
private int price;
private List<Dog> myDog;
private List<String> boys;
public Car(String sign, int price) {
this.sign = sign;
this.price = price;
}
public Car(String sign, int price, List<Dog> myDog) {
this.sign = sign;
this.price = price;
this.myDog = myDog;
}
@Override
public int compareTo(Car o) {
//同理也可以根據sign屬性排序，就不舉例啦。
return this.getPrice() - o.getPrice();
}
@Override
public String toString() {
return "Car{" +
"sign='" + sign + '\\'' +
", price=" + price +
", myDog=" + myDog +
", boys=" + boys +
'}';
}
@Override
public Car clone() {
Car car = null;
try {
car = (Car) super.clone();
if (myDog != null) {
car.setMyDog(Lists.newArrayList(myDog));
}
if (boys != null) {
car.setBoys(Lists.newArrayList(boys));
}
} catch (CloneNotSupportedException ignored) {
System.out.println(ignored.getMessage());
}
return car;
}
public void run() {
for (int i = 0; i < 1000; i++) {
func();
}
}
public final void finalRun() {
for (int i = 0; i < 1000; i++) {
func1();
}
}
final void func1() {
String s = this.toString();
}
void func() {
String s = this.toString();
}
}
CarFinal.java
package com.lxk.model;
import com.google.common.collect.Lists;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
/**
* 使用final的Car類
*
* @author LiXuekai on 2019/6/20
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public final class CarFinal implements Cloneable, Comparable<Car>, Serializable {
private String sign;
private int price;
private List<Dog> myDog;
private List<String> boys;
public CarFinal(String sign, int price) {
this.sign = sign;
this.price = price;
}
public CarFinal(String sign, int price, List<Dog> myDog) {
this.sign = sign;
this.price = price;
this.myDog = myDog;
}
@Override
public int compareTo(Car o) {
//同理也可以根據sign屬性排序，就不舉例啦。
return this.getPrice() - o.getPrice();
}
@Override
public String toString() {
return "Car{" +
"sign='" + sign + '\\'' +
", price=" + price +
", myDog=" + myDog +
", boys=" + boys +
'}';
}
@Override
public Car clone() {
Car car = null;
try {
car = (Car) super.clone();
if (myDog != null) {
car.setMyDog(Lists.newArrayList(myDog));
}
if (boys != null) {
car.setBoys(Lists.newArrayList(boys));
}
} catch (CloneNotSupportedException ignored) {
System.out.println(ignored.getMessage());
}
return car;
}
public void run() {
for (int i = 0; i < 1000; i++) {
func();
}
}
public final void finalRun() {
for (int i = 0; i < 1000; i++) {
func1();
}
}
final void func1() {
String s = this.toString();
}
void func() {
String s = this.toString();
}
}
2，使用final 的類和沒final的類的差別。
就是把上面的main方法換第二個執行。
也不是很大的差距呀。
沒有傳說中的50%的性能提升呀。
是我測試姿勢不對麼？代碼寫的哪裡有問題麼？
這個解釋怎麼樣？
就像人類的認知，很久之前，以為地球是中心，太陽圍著地球，那個時候，“太陽圍著地球轉”這個理論是對的。
但是，時間久了，新發現，新科技，新認知之後，“太陽圍著地球轉”的理論就out了。
這個理論適用這個“final”優化嗎？
---------------------
Java代碼優化 Java final 修飾類或者方法能提高性能？還50%？老鐵，你試了嗎？
最近不是一直在搞優化嗎，為的就是提高項目的處理能力，提高吞吐量。然後就各種搜呀，各種JProfiler測試。看看代碼有啥可優化的。總能看到一個觀點。
final修飾類或者方法，能是性能提高50%。
不止一次，見到這個觀點。這個是真的嗎？
我來測試一下
1，先看下加final的方法和不加的差別
看不出來50%在哪裡。
使用的測試代碼：
main方法
package com.lxk.fast;
import com.google.common.collect.Lists;
import com.lxk.model.Car;
import com.lxk.model.CarFinal;
import com.lxk.model.Dog;
/**
* 有人說給方法或者類加上final之後，效率會提升，我來試試。
*
* @author LiXuekai on 2019/6/20
*/
public class IsFinalFast {
public static void main(String[] args) {
methodTest();
//classTest();
}
private static void classTest() {
while (true) {
classFinal();
classNoFinal();
}
}
private static void classFinal() {
CarFinal car = new CarFinal("oooo", 100, Lists.newArrayList(new Dog("aaa", true, true)));
car.finalRun();
}
private static void classNoFinal() {
Car car = new Car("oooo", 100, Lists.newArrayList(new Dog("aaa", true, true)));
car.run();
}
private static void methodTest() {
Car car = new Car("oooo", 100, Lists.newArrayList(new Dog("aaa", true, true)));
while (true) {
noFinal(car);
isFinal(car);
}
}
private static void isFinal(Car car) {
car.finalRun();
}
private static void noFinal(Car car) {
car.run();
}
}
使用的2個model類
Car.java
package com.lxk.model;
import com.google.common.collect.Lists;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Car implements Cloneable, Comparable<Car> , Serializable {
private String sign;
private int price;
private List<Dog> myDog;
private List<String> boys;
public Car(String sign, int price) {
this.sign = sign;
this.price = price;
}
public Car(String sign, int price, List<Dog> myDog) {
this.sign = sign;
this.price = price;
this.myDog = myDog;
}
@Override
public int compareTo(Car o) {
//同理也可以根據sign屬性排序，就不舉例啦。
return this.getPrice() - o.getPrice();
}
@Override
public String toString() {
return "Car{" +
"sign='" + sign + '\\'' +
", price=" + price +
", myDog=" + myDog +
", boys=" + boys +
'}';
}
@Override
public Car clone() {
Car car = null;
try {
car = (Car) super.clone();
if (myDog != null) {
car.setMyDog(Lists.newArrayList(myDog));
}
if (boys != null) {
car.setBoys(Lists.newArrayList(boys));
}
} catch (CloneNotSupportedException ignored) {
System.out.println(ignored.getMessage());
}
return car;
}
public void run() {
for (int i = 0; i < 1000; i++) {
func();
}
}
public final void finalRun() {
for (int i = 0; i < 1000; i++) {
func1();
}
}
final void func1() {
String s = this.toString();
}
void func() {
String s = this.toString();
}
}
CarFinal.java
package com.lxk.model;
import com.google.common.collect.Lists;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
/**
* 使用final的Car類
*
* @author LiXuekai on 2019/6/20
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public final class CarFinal implements Cloneable, Comparable<Car>, Serializable {
private String sign;
private int price;
private List<Dog> myDog;
private List<String> boys;
public CarFinal(String sign, int price) {
this.sign = sign;
this.price = price;
}
public CarFinal(String sign, int price, List<Dog> myDog) {
this.sign = sign;
this.price = price;
this.myDog = myDog;
}
@Override
public int compareTo(Car o) {
//同理也可以根據sign屬性排序，就不舉例啦。
return this.getPrice() - o.getPrice();
}
@Override
public String toString() {
return "Car{" +
"sign='" + sign + '\\'' +
", price=" + price +
", myDog=" + myDog +
", boys=" + boys +
'}';
}
@Override
public Car clone() {
Car car = null;
try {
car = (Car) super.clone();
if (myDog != null) {
car.setMyDog(Lists.newArrayList(myDog));
}
if (boys != null) {
car.setBoys(Lists.newArrayList(boys));
}
} catch (CloneNotSupportedException ignored) {
System.out.println(ignored.getMessage());
}
return car;
}
public void run() {
for (int i = 0; i < 1000; i++) {
func();
}
}
public final void finalRun() {
for (int i = 0; i < 1000; i++) {
func1();
}
}
final void func1() {
String s = this.toString();
}
void func() {
String s = this.toString();
}
}
2，使用final 的類和沒final的類的差別。
就是把上面的main方法換第二個執行。
也不是很大的差距呀。
沒有傳說中的50%的性能提升呀。
是我測試姿勢不對麼？代碼寫的哪裡有問題麼？
這個解釋怎麼樣？
就像人類的認知，很久之前，以為地球是中心，太陽圍著地球，那個時候，“太陽圍著地球轉”這個理論是對的。
但是，時間久了，新發現，新科技，新認知之後，“太陽圍著地球轉”的理論就out了。
這個理論適用這個“final”優化嗎？
---------------------
Java代碼優化 Java final 修飾類或者方法能提高性能？還50%？老鐵，你試了嗎？
最近不是一直在搞優化嗎，為的就是提高項目的處理能力，提高吞吐量。然後就各種搜呀，各種JProfiler測試。看看代碼有啥可優化的。總能看到一個觀點。
final修飾類或者方法，能是性能提高50%。
不止一次，見到這個觀點。這個是真的嗎？
我來測試一下
1，先看下加final的方法和不加的差別
看不出來50%在哪裡。
使用的測試代碼：
main方法
package com.lxk.fast;
import com.google.common.collect.Lists;
import com.lxk.model.Car;
import com.lxk.model.CarFinal;
import com.lxk.model.Dog;
/**
* 有人說給方法或者類加上final之後，效率會提升，我來試試。
*
* @author LiXuekai on 2019/6/20
*/
public class IsFinalFast {
public static void main(String[] args) {
methodTest();
//classTest();
}
private static void classTest() {
while (true) {
classFinal();
classNoFinal();
}
}
private static void classFinal() {
CarFinal car = new CarFinal("oooo", 100, Lists.newArrayList(new Dog("aaa", true, true)));
car.finalRun();
}
private static void classNoFinal() {
Car car = new Car("oooo", 100, Lists.newArrayList(new Dog("aaa", true, true)));
car.run();
}
private static void methodTest() {
Car car = new Car("oooo", 100, Lists.newArrayList(new Dog("aaa", true, true)));
while (true) {
noFinal(car);
isFinal(car);
}
}
private static void isFinal(Car car) {
car.finalRun();
}
private static void noFinal(Car car) {
car.run();
}
}
使用的2個model類
Car.java
package com.lxk.model;
import com.google.common.collect.Lists;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Car implements Cloneable, Comparable<Car> , Serializable {
private String sign;
private int price;
private List<Dog> myDog;
private List<String> boys;
public Car(String sign, int price) {
this.sign = sign;
this.price = price;
}
public Car(String sign, int price, List<Dog> myDog) {
this.sign = sign;
this.price = price;
this.myDog = myDog;
}
@Override
public int compareTo(Car o) {
//同理也可以根據sign屬性排序，就不舉例啦。
return this.getPrice() - o.getPrice();
}
@Override
public String toString() {
return "Car{" +
"sign='" + sign + '\\'' +
", price=" + price +
", myDog=" + myDog +
", boys=" + boys +
'}';
}
@Override
public Car clone() {
Car car = null;
try {
car = (Car) super.clone();
if (myDog != null) {
car.setMyDog(Lists.newArrayList(myDog));
}
if (boys != null) {
car.setBoys(Lists.newArrayList(boys));
}
} catch (CloneNotSupportedException ignored) {
System.out.println(ignored.getMessage());
}
return car;
}
public void run() {
for (int i = 0; i < 1000; i++) {
func();
}
}
public final void finalRun() {
for (int i = 0; i < 1000; i++) {
func1();
}
}
final void func1() {
String s = this.toString();
}
void func() {
String s = this.toString();
}
}
CarFinal.java
package com.lxk.model;
import com.google.common.collect.Lists;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
/**
* 使用final的Car類
*
* @author LiXuekai on 2019/6/20
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public final class CarFinal implements Cloneable, Comparable<Car>, Serializable {
private String sign;
private int price;
private List<Dog> myDog;
private List<String> boys;
public CarFinal(String sign, int price) {
this.sign = sign;
this.price = price;
}
public CarFinal(String sign, int price, List<Dog> myDog) {
this.sign = sign;
this.price = price;
this.myDog = myDog;
}
@Override
public int compareTo(Car o) {
//同理也可以根據sign屬性排序，就不舉例啦。
return this.getPrice() - o.getPrice();
}
@Override
public String toString() {
return "Car{" +
"sign='" + sign + '\\'' +
", price=" + price +
", myDog=" + myDog +
", boys=" + boys +
'}';
}
@Override
public Car clone() {
Car car = null;
try {
car = (Car) super.clone();
if (myDog != null) {
car.setMyDog(Lists.newArrayList(myDog));
}
if (boys != null) {
car.setBoys(Lists.newArrayList(boys));
}
} catch (CloneNotSupportedException ignored) {
System.out.println(ignored.getMessage());
}
return car;
}
public void run() {
for (int i = 0; i < 1000; i++) {
func();
}
}
public final void finalRun() {
for (int i = 0; i < 1000; i++) {
func1();
}
}
final void func1() {
String s = this.toString();
}
void func() {
String s = this.toString();
}
}
2，使用final 的類和沒final的類的差別。
就是把上面的main方法換第二個執行。
也不是很大的差距呀。
沒有傳說中的50%的性能提升呀。
是我測試姿勢不對麼？代碼寫的哪裡有問題麼？
這個解釋怎麼樣？
就像人類的認知，很久之前，以為地球是中心，太陽圍著地球，那個時候，“太陽圍著地球轉”這個理論是對的。
但是，時間久了，新發現，新科技，新認知之後，“太陽圍著地球轉”的理論就out了。
這個理論適用這個“final”優化嗎？
---------------------
Java代碼優化 Java final 修飾類或者方法能提高性能？還50%？老鐵，你試了嗎？
最近不是一直在搞優化嗎，為的就是提高項目的處理能力，提高吞吐量。然後就各種搜呀，各種JProfiler測試。看看代碼有啥可優化的。總能看到一個觀點。
final修飾類或者方法，能是性能提高50%。
不止一次，見到這個觀點。這個是真的嗎？
我來測試一下
1，先看下加final的方法和不加的差別
看不出來50%在哪裡。
使用的測試代碼：
main方法
package com.lxk.fast;
import com.google.common.collect.Lists;
import com.lxk.model.Car;
import com.lxk.model.CarFinal;
import com.lxk.model.Dog;
/**
* 有人說給方法或者類加上final之後，效率會提升，我來試試。
*
* @author LiXuekai on 2019/6/20
*/
public class IsFinalFast {
public static void main(String[] args) {
methodTest();
//classTest();
}
private static void classTest() {
while (true) {
classFinal();
classNoFinal();
}
}
private static void classFinal() {
CarFinal car = new CarFinal("oooo", 100, Lists.newArrayList(new Dog("aaa", true, true)));
car.finalRun();
}
private static void classNoFinal() {
Car car = new Car("oooo", 100, Lists.newArrayList(new Dog("aaa", true, true)));
car.run();
}
private static void methodTest() {
Car car = new Car("oooo", 100, Lists.newArrayList(new Dog("aaa", true, true)));
while (true) {
noFinal(car);
isFinal(car);
}
}
private static void isFinal(Car car) {
car.finalRun();
}
private static void noFinal(Car car) {
car.run();
}
}
使用的2個model類
Car.java
package com.lxk.model;
import com.google.common.collect.Lists;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Car implements Cloneable, Comparable<Car> , Serializable {
private String sign;
private int price;
private List<Dog> myDog;
private List<String> boys;
public Car(String sign, int price) {
this.sign = sign;
this.price = price;
}
public Car(String sign, int price, List<Dog> myDog) {
this.sign = sign;
this.price = price;
this.myDog = myDog;
}
@Override
public int compareTo(Car o) {
//同理也可以根據sign屬性排序，就不舉例啦。
return this.getPrice() - o.getPrice();
}
@Override
public String toString() {
return "Car{" +
"sign='" + sign + '\\'' +
", price=" + price +
", myDog=" + myDog +
", boys=" + boys +
'}';
}
@Override
public Car clone() {
Car car = null;
try {
car = (Car) super.clone();
if (myDog != null) {
car.setMyDog(Lists.newArrayList(myDog));
}
if (boys != null) {
car.setBoys(Lists.newArrayList(boys));
}
} catch (CloneNotSupportedException ignored) {
System.out.println(ignored.getMessage());
}
return car;
}
public void run() {
for (int i = 0; i < 1000; i++) {
func();
}
}
public final void finalRun() {
for (int i = 0; i < 1000; i++) {
func1();
}
}
final void func1() {
String s = this.toString();
}
void func() {
String s = this.toString();
}
}
CarFinal.java
package com.lxk.model;
import com.google.common.collect.Lists;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
/**
* 使用final的Car類
*
* @author LiXuekai on 2019/6/20
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public final class CarFinal implements Cloneable, Comparable<Car>, Serializable {
private String sign;
private int price;
private List<Dog> myDog;
private List<String> boys;
public CarFinal(String sign, int price) {
this.sign = sign;
this.price = price;
}
public CarFinal(String sign, int price, List<Dog> myDog) {
this.sign = sign;
this.price = price;
this.myDog = myDog;
}
@Override
public int compareTo(Car o) {
//同理也可以根據sign屬性排序，就不舉例啦。
return this.getPrice() - o.getPrice();
}
@Override
public String toString() {
return "Car{" +
"sign='" + sign + '\\'' +
", price=" + price +
", myDog=" + myDog +
", boys=" + boys +
'}';
}
@Override
public Car clone() {
Car car = null;
try {
car = (Car) super.clone();
if (myDog != null) {
car.setMyDog(Lists.newArrayList(myDog));
}
if (boys != null) {
car.setBoys(Lists.newArrayList(boys));
}
} catch (CloneNotSupportedException ignored) {
System.out.println(ignored.getMessage());
}
return car;
}
public void run() {
for (int i = 0; i < 1000; i++) {
func();
}
}
public final void finalRun() {
for (int i = 0; i < 1000; i++) {
func1();
}
}
final void func1() {
String s = this.toString();
}
void func() {
String s = this.toString();
}
}
2，使用final 的類和沒final的類的差別。
就是把上面的main方法換第二個執行。
也不是很大的差距呀。
沒有傳說中的50%的性能提升呀。
是我測試姿勢不對麼？代碼寫的哪裡有問題麼？
這個解釋怎麼樣？
就像人類的認知，很久之前，以為地球是中心，太陽圍著地球，那個時候，“太陽圍著地球轉”這個理論是對的。
但是，時間久了，新發現，新科技，新認知之後，“太陽圍著地球轉”的理論就out了。
這個理論適用這個“final”優化嗎？
---------------------