java细节

最新推荐文章于 2022-04-28 22:36:36 发布

月月鸟鸟月月

最新推荐文章于 2022-04-28 22:36:36 发布

阅读量153

点赞数

分类专栏： java基础文章标签： java基础

本文链接：https://blog.csdn.net/yzp3055506633/article/details/78068703

版权

java基础专栏收录该内容

0 篇文章 0 订阅

订阅专栏

public class Work {

private Listenerr listenerr;

public void setListener(Listenerr listenerr) {
    this.listenerr = listenerr;
}

public void banzhuo(String name, int num){

    if (listenerr!=null){
        listenerr.strat();
    }
     for (int i = 1; i <=num; i++) {

         String content = "我在搬第"+i+"砖";
         listenerr.progress(content);
    }

     if (listenerr!=null){
            listenerr.end();
    }
}

}

public class Manga {

public static void main(String[] args) {
    // TODO Auto-generated method stub
    Manga manga = new Manga();
    Work work = new Work();
    work.setListener(new Listenerr() {

        @Override
        public void strat() {
            // TODO Auto-generated method stub
            System.out.println("start");
        }

        @Override
        public void progress(String content) {
            // TODO Auto-generated method stub
            System.out.println(content);
        }

        @Override
        public void end() {
            // TODO Auto-generated method stub
            System.out.println("end");
        }
    });

    work.banzhuo("66", 10);
}

}

// 这个例子很好的阐述了关于时间监听的实现机制吧我感觉是
// java源于生活当想两个类中传递信息时可以去通过一个接口的来
// 这个例子也很好的体现了多态
~~~

易错的东西

~~~java
public class C extends Thread{

public static void main(String[] args){
    String bob = new String("练气期");
    String pop = "练气期";
    new C().change(bob);
    new C().change(pop);
    System.out.println("bob:-------"+bob);
    System.out.println("pop:-------"+pop);

}

private void change(String string) {
    // TODO Auto-generated method stub
    string = "你筑基了";
}

}

result：
bob:——-练气期
pop:——-练气期
~~~

~~~java
public class C extends Thread{

public static void main(String[] args){

    System.out.println(2f == 2.0);


    Integer a1 = 124;
    Integer b1 = 124;
    Integer a2 = 128;
    Integer b2 = 128;
    System.out.println(a1==b1);//true
    System.out.println(a2==b2);//false -128~~127


    Double i1 = 100.0;
    Double i2 = 100.0;
    Double i3 = 200.0;
    Double i4 = 200.0;

    System.out.println(i1==i2);//false
    System.out.println(i3==i4);//false

    Integer a = 1;
    Integer b = 2;
    Integer c = 3;
    Integer d = 3;
    Integer e = 321;
    Integer f = 321;
    Long g = 3L;
    Long h = 2L;

    System.out.println(c==d);//true
    System.out.println(e==f);//false
    System.out.println(c==(a+b));//true
    System.out.println(c.equals(a+b));//true
    System.out.println(g==(a+b)); //true
    System.out.println(g.equals(a+b)); //false
    System.out.println(g.equals(a+h)); //true

}

}
~~~

优化

尽量指定类、方法的final修饰符

带有final修饰符的类是不可派生的。在Java核心API中，有许多应用final的例子，例如java.lang.String，整个类都是final的。为类指定final修饰符可以让类不可以被继承，为方法指定final修饰符可以让方法不可以被重写。如果指定了一个类为final，则该类所有的方法都是final的。Java编译器会寻找机会内联所有的final方法，内联对于提升Java运行效率作用重大，具体参见Java运行期优化。此举能够使性能平均提高50%
尽量重用对象

特别是String对象的使用，出现字符串连接时应该使用StringBuilder/StringBuffer代替。由于Java虚拟机不仅要花时间生成对象，以后可能还需要花时间对这些对象进行垃圾回收和处理，因此，生成过多的对象将会给程序的性能带来很大的影响。
尽可能使用局部变量

调用方法时传递的参数以及在调用中创建的临时变量都保存在栈中速度较快，其他变量，如静态变量、实例变量等，都在堆中创建，速度较慢。另外，栈中创建的变量，随着方法的运行结束，这些内容就没了，不需要额外的垃圾回收。

~~~java

~~~
尽量减少对变量的重复计算

~~~java
//明确一个概念，对方法的调用，即使方法中只有一句语句，也是有消耗的，包括创建栈帧、调用方法时保护现场、调用方法完毕时恢复现场等。
for (int i = 0; i < list.size(); i++)
{…}

//下面这种更好
for (int i = 0, int length = list.size(); i < length; i++)
{…}
~~~
尽量采用懒加载的策略，即在需要的时候才创建

~~~java
String str = “aaa”;if (i == 1)
{

list.add(str);

}
//可以替换成下面的

if (i == 1)
{

String str = “aaa”;

list.add(str);

}
~~~
如果能估计到待添加的内容长度，为底层以数组方式实现的集合、工具类指定初始长度

比如ArrayList、LinkedLlist、StringBuilder、StringBuffer、HashMap、HashSet等等，以StringBuilder为例：

（1）StringBuilder() // 默认分配16个字符的空间

（2）StringBuilder(int size) // 默认分配size个字符的空间

（3）StringBuilder(String str) // 默认分配16个字符+str.length()个字符空间

可以通过类（这里指的不仅仅是上面的StringBuilder）的来设定它的初始化容量，这样可以明显地提升性能。比如StringBuilder吧，length表示当前的StringBuilder能保持的字符数量。因为当StringBuilder达到最大容量的时候，它会将自身容量增加到当前的2倍再加2，无论何时只要StringBuilder达到它的最大容量，它就不得不创建一个新的字符数组然后将旧的字符数组内容拷贝到新字符数组中—-这是十分耗费性能的一个操作。试想，如果能预估到字符数组中大概要存放5000个字符而不指定长度，最接近5000的2次幂是4096，每次扩容加的2不管，那么：

（1）在4096 的基础上，再申请8194个大小的字符数组，加起来相当于一次申请了12290个大小的字符数组，如果一开始能指定5000个大小的字符数组，就节省了一倍以上的空间；

（2）把原来的4096个字符拷贝到新的的字符数组中去。

这样，既浪费内存空间又降低代码运行效率。所以，给底层以数组实现的集合、工具类设置一个合理的初始化容量是错不了的，这会带来立竿见影的效果。但是，注意，像HashMap这种是以数组+链表实现的集合，别把初始大小和你估计的大小设置得一样，因为一个table上只连接一个对象的可能性几乎为0。初始大小建议设置为2的N次幂，如果能估计到有2000个元素，设置成new HashMap(128)、new HashMap(256)都可以
乘法和除法使用移位操作

~~~java
for (val = 0; val < 100000; val += 5)
{
a = val * 8;
b = val / 2;
}

//替换
for (val = 0; val < 100000; val += 5)
{
a = val << 3;
b = val >> 1;
}
~~~
尽量在合适的场合使用单例

使用单例可以减轻加载的负担、缩短加载的时间、提高加载的效率，但并不是所有地方都适用于单例，简单来说，单例主要适用于以下三个方面：

（1）控制资源的使用，通过线程同步来控制资源的并发访问

（2）控制实例的产生，以达到节约资源的目的

（3）控制数据的共享，在不建立直接关联的条件下，让多个不相关的进程或线程之间实现通信
集合的遍历问题

对于Arrsylist 来说 for foreach iterator 都可以

而对于link来说用itertor 就很快了因为他保存了上一个指针就不需要从头遍历过来了

但是iterator
使用同步代码块替代同步方法

这点在多线程模块中的synchronized锁方法块一文中已经讲得很清楚了，除非能确定一整个方法都是需要进行同步的，否则尽量使用同步代码块，避免对那些不需要进行同步的代码也进行了同步，影响了代码执行效率。
程序运行过程中避免使用反射

反射是Java提供给用户一个很强大的功能，功能强大往往意味着效率不高。不建议在程序运行过程中使用尤其是频繁使用反射机制，特别是Method的invoke方法，如果确实有必要，一种建议性的做法是将那些需要通过反射加载的类在项目启动的时候通过反射实例化出一个对象并放入内存—-用户只关心和对端交互的时候获取最快的响应速度，并不关心对端的项目启动花多久时间。
使用数据库连接池和线程池

这两个池都是用于重用对象的，前者可以避免频繁地打开和关闭连接，后者可以避免频繁地创建和销毁线程
字符串变量和字符串常量equals的时候将字符串常量写在前面

~java
String str = "123";
if (str.equals("123")) {...}
~

// 下面可以避免空指针异常
String str = "123";
if ("123".equals(str))
{
...
}
~~~

不要对数组使用toString()方法

打印的是地址
公用的集合类中不使用的数据一定要及时remove掉

如果一个集合类是公用的（也就是说不是方法里面的属性），那么这个集合里面的元素是不会自动释放的，因为始终有引用指向它们。所以，如果公用集合里面的某些数据不使用而不去remove掉它们，那么将会造成这个公用集合不断增大，使得系统有内存泄露的隐患。
把一个基本数据类型转为字符串，基本数据类型.toString()是最快的方式、String.valueOf(数据)次之、

数据+””最慢

~~i + “” 底层使用了StringBuilder实现，先用append方法拼接，再用toString()方法获取字符串

月月鸟鸟月月

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java细节

public class Work {private Listenerr listenerr;public void setListener(Listenerr listenerr) { this.listenerr = listenerr;}public void banzhuo(String name, int num){ if (listenerr!=null
复制链接

扫一扫