java性能调优02

1、字符串优化处理

　　1.1 常量池的优化：当String对象拥有相同的值时，他们只引用常量池的同一个拷贝.

String a="123";

String b="123";

System.out.println(a.intern()==b.intern()); //true

　　1.2 字符串截取导致内存泄露问题优化（包装类都有此问题）

　　　　在使用substring方法时，在其外面使用new String()进行处理即可解决此问题（触发垃圾回收）

new String("要被截取的字符串".substring(0,3));

　　1.3 对于字符串的拆分，尽量使用indexOf效率更高

//将字符串arrayStr通过split拆分后放入strings集合中
public static List<String> toList(String arrayStr,String split,List<String> strings) {

    int index=arrayStr.indexOf(split);

    while (index!=-1) {

        strings.add(new String(arrayStr.substring(0,index)));

        arrayStr=new String(arrayStr.substring(index+1));

        index=arrayStr.indexOf(split);

    }

    //判断最后一个是否是空

    if (!arrayStr.trim().equals("")) {

         strings.add(arrayStr);

     }

     return strings;

}

2、集合优化

　　2.1 主要用于在尾部添加的处理时，使用ArrayList的效率较高；

　　　　在头部和中间插入数据时，使用LinkedList的效率较高；

　　　　删除操作较多时，使用LinkedListde效率较高

　　2.2 对于集合的迭代和遍历使用原始的for(int i=0;i<10;i++)的效率会更高

　　2.3 使用集合是给定初始化大小，效率更高

　　2.4 如果需要对集合中数据尽量使用treeSet,treeMap来实现

3、常用技巧

　　3.1 对于工具类使用静态方法

　　3.2 使用clone方法代替new新的对象

　　3.3 对于io操作要使用带缓存的buffer包装类

　　3.4 对用数组的拷贝使用Arrays.copyOf()方法

　　3.5 使用布尔运算&&代替位运算&

　　3.6 对用大量的循环使用展开循环更好

　　3.7 对于多次使用的表达式进行提取为一个临时变量

　　3.8 尽量少用switch语句，使用ifelse替代

　　3.9 能使用位运算的尽量使用位运算（如*2，/4等操作）

　　3.10 能使用局部变量的就不用使用全局变量，效率更高

　　3.11 能不使用异常的尽量不用进行异常处理

　　3.12 不要使用二维数组，效率很低，使用一维数组代替即可

4、bio，aio ,nio的比较

　　java bio：同步并阻塞，一个连接一个线程，即客户端有连接请求时就启动一个线程进行处理，使用与连接数目小且固定的框架，对服务器的资源要求不较高，并发环境中jdk1.4之前的唯一选择

　　java nio：同步非阻塞，一个请求一个线程，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理，适用于连接数目多但连接时间短的架构，jdk1.4开始支持

　　java nio：异步非阻塞，一个有效请求一个线程，即客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理，适用于连接数目多且连接时间长的架构，jdk1.7开始支持

//通过nio进行文件复制

public void copyFileByNio(String sourceFile,String targetFile) throws Exception {

        FileInputStream inputStream=new FileInputStream(new File(sourceFile));

        FileOutputStream outputStream=new FileOutputStream(new File(targetFile));

        //获取nio通道

        FileChannel readChannel=inputStream.getChannel();

        FileChannel writeChannel=outputStream.getChannel();

        ByteBuffer readBuffer=ByteBuffer.allocate(1024*8);

        //通过nio通道进行读写操作

        while (true) {

            readBuffer.clear();

            int read=readChannel.read(readBuffer);

            if (read==-1) {

                break;

            }

            readBuffer.flip();

            writeChannel.write(readBuffer);

        }

        //关闭通道

        readChannel.close();

        writeChannel.close();

}

//通过aio复制文件

public void copyFileByAio(String sourceFile,String targetFile) throws Exception {

        //获取aio异步通道

        AsynchronousFileChannel readChannel = AsynchronousFileChannel.open(Paths.get(sourceFile));

        OpenOption openOption=StandardOpenOption.WRITE;

        //获取aio异步通道

        AsynchronousFileChannel writeChannel=AsynchronousFileChannel.open(Paths.get(targetFile),openOption);

        ByteBuffer readBuffer=ByteBuffer.allocate(1024*8);

        //通过aio通道进行读写操作

        Future<Integer> result=readChannel.read(readBuffer, 0);

        while (!result.isDone()) {

            Thread.sleep(1);

        }

        readBuffer.flip();

        writeChannel.write(readBuffer, 0);

        //关闭通道

        readChannel.close();

        writeChannel.close();

}

5、ByteBuffer的常用操作

　　rewind()://它使限制保持不变，将位置设置为 0。

　　reset()://将此缓冲区的位置重置为最近标记的位置。

　　flip();//它将限制设置为当前位置，然后将位置设置为 0。

　　clear();//它将限制设置为容量大小，将位置设置为 0。

　　slice();//创建一个从当前位置到上限的子缓存区

　　　　 ByteBuffer buffer=ByteBuffer.allocate(15);

        System.out.println("上限："+buffer.limit()+",容量："+buffer.capacity()+",位置："+buffer.position());

        for(int i=0;i<10;i++){

            buffer.put((byte)i);

        }

        System.out.println("上限："+buffer.limit()+",容量："+buffer.capacity()+",位置："+buffer.position());

        //使缓冲区为重新读取已包含的数据做好准备：它使限制保持不变，将位置设置为 0。

        buffer.rewind();

        System.out.println("上限："+buffer.limit()+",容量："+buffer.capacity()+",位置："+buffer.position());

        for(int i=0;i<10;i++){

            if (i==4) {

                //在此缓冲区的位置设置标记。

                buffer.mark();

            }else if (i==6) {

                buffer.mark();

            }

            buffer.put((byte)i);

        }

        //将此缓冲区的位置重置为最近标记的位置。

        buffer.reset();

        System.out.println("上限："+buffer.limit()+",容量："+buffer.capacity()+",位置："+buffer.position());

        //使缓冲区为一系列新的通道写入或相对获取 操作做好准备：它将限制设置为当前位置，然后将位置设置为 0。

        buffer.flip();

        System.out.println("上限："+buffer.limit()+",容量："+buffer.capacity()+",位置："+buffer.position());

        //使缓冲区为一系列新的通道读取或相对放置 操作做好准备：它将限制设置为容量大小，将位置设置为 0。

        buffer.clear();

        System.out.println("上限："+buffer.limit()+",容量："+buffer.capacity()+",位置："+buffer.position());

　　　　　//创建一个从当前位置到上限的子缓存区
        ByteBuffer subBuffer=buffer.slice();
        System.out.println("上限："+subBuffer.limit()+",容量："+subBuffer.capacity()+",位置："+subBuffer.position());

6、将文件内容映射到ByteBuffer缓存中

public void loadFile(String fileName) throws Exception {

        RandomAccessFile file=new RandomAccessFile(fileName, "rw");

        long length=file.length();

        FileChannel channel=file.getChannel();

        //将文件内容映射到ByteBuffer缓存中

        MappedByteBuffer buffer=channel.map(MapMode.READ_WRITE, 0, file.length());

        //从缓存中读取文件的内容

        byte[] content=new byte[(int)length];

        buffer.get(content, 0, (int)length);

        System.out.println(new String(buffer.array(),"gb2312"));

        channel.close();

        file.close();

}

//聚集写

public void gatherWrite(String filename) throws Exception {

        ByteBuffer courseBuffer=ByteBuffer.wrap("buffer 聚集写操作".getBytes("gb2312"));

        ByteBuffer authBuffer=ByteBuffer.wrap("special 讲师".getBytes("gb2312"));

        ByteBuffer[] buffers=new ByteBuffer[]{courseBuffer,authBuffer};

        FileOutputStream outputStream=new FileOutputStream(new File(filename));

        FileChannel channel=outputStream.getChannel();

        channel.write(buffers);

        channel.close();

        outputStream.close();

}

//映射读

public void mapRead(String filename) throws Exception {

        FileInputStream inputStream=new FileInputStream(new File(filename));

        FileChannel channel=inputStream.getChannel();

        ByteBuffer b1=ByteBuffer.allocate(13);

        ByteBuffer b2=ByteBuffer.allocate(100);

        channel.read(new ByteBuffer[]{b1,b2});

        System.out.println(new String(b1.array(),"gb2312"));

        System.out.println(new String(b2.array(),"gb2312"));

        channel.close();

        inputStream.close();

}

巴特西

java性能调优02

最新文章

热门文章