Java我人生

Java文件读写IO/NIO及性能比较总结

干Java这么久，一直在做WEB相关的项目，一些基础类差不多都已经忘记。经常想得捡起，但总是因为一些原因，不能如愿。

其实不是没有时间，只是有些时候疲于总结，今得空，下定决心将丢掉的都给捡起来。

文件读写是一个在项目中经常遇到的工作，有些时候是因为维护，有些时候是新功能开发。我们的任务总是很重，工作节奏很快，快到我们不能停下脚步去总结。

文件读写有以下几种常用的方法

1、字节读写（InputStream/OutputStream）

2、字符读取（FileReader/FileWriter）

3、行读取（BufferedReader/BufferedWriter）

代码（以读取为例）：

[java] view plain copy print ?

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
/**
* 文件读取类
* 1、按字节读取文件内容
* 2、按字符读取文件内容
* 3、按行读取文件内容
* @author qin_xijuan
*
*/
public class FileOperate {
private static final String FILE_PATH = "d:/work/the List of Beautiful Music.txt";
/**
* 以字节为单位读取文件内容
* @param filePath：需要读取的文件路径
*/
public static void readFileByByte(String filePath) {
File file = new File(filePath);
// InputStream:此抽象类是表示字节输入流的所有类的超类。
InputStream ins = null ;
try{
// FileInputStream:从文件系统中的某个文件中获得输入字节。
ins = new FileInputStream(file);
int temp ;
// read():从输入流中读取数据的下一个字节。
while((temp = ins.read())!=-1){
System.out.write(temp);
}
}catch(Exception e){
e.getStackTrace();
}finally{
if (ins != null){
try{
ins.close();
}catch(IOException e){
e.getStackTrace();
}
}
}
}
/**
* 以字符为单位读取文件内容
* @param filePath
*/
public static void readFileByCharacter(String filePath){
File file = new File(filePath);
// FileReader:用来读取字符文件的便捷类。
FileReader reader = null;
try{
reader = new FileReader(file);
int temp ;
while((temp = reader.read()) != -1){
if (((char) temp) != '\r') {
System.out.print((char) temp);
}
}
}catch(IOException e){
e.getStackTrace();
}finally{
if (reader != null){
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
* 以行为单位读取文件内容
* @param filePath
*/
public static void readFileByLine(String filePath){
File file = new File(filePath);
// BufferedReader:从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
BufferedReader buf = null;
try{
// FileReader:用来读取字符文件的便捷类。
buf = new BufferedReader(new FileReader(file));
// buf = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
String temp = null ;
while ((temp = buf.readLine()) != null ){
System.out.println(temp);
}
}catch(Exception e){
e.getStackTrace();
}finally{
if(buf != null){
try{
buf.close();
} catch (IOException e) {
e.getStackTrace();
}
}
}
}
public static void main(String args[]) {
readFileByByte(FILE_PATH);
readFileByCharacter(FILE_PATH);
readFileByLine(FILE_PATH);
}
}

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
/**
 * 文件读取类

 * 1、按字节读取文件内容

 * 2、按字符读取文件内容

 * 3、按行读取文件内容

 * @author qin_xijuan
 *
 */
public class FileOperate {
    
    private static final String FILE_PATH = "d:/work/the List of Beautiful Music.txt";

    /**
     * 以字节为单位读取文件内容
     * @param filePath：需要读取的文件路径
     */
    public static void readFileByByte(String filePath) {
        File file = new File(filePath);
        // InputStream:此抽象类是表示字节输入流的所有类的超类。
        InputStream ins = null ;
        try{
            // FileInputStream:从文件系统中的某个文件中获得输入字节。
            ins = new FileInputStream(file);
            int temp ;
            // read():从输入流中读取数据的下一个字节。
            while((temp = ins.read())!=-1){
                System.out.write(temp);
            }
        }catch(Exception e){
            e.getStackTrace();
        }finally{
            if (ins != null){
                try{
                    ins.close();
                }catch(IOException e){
                    e.getStackTrace();
                }
            }
        }
    }
    
    /**
     * 以字符为单位读取文件内容
     * @param filePath
     */
    public static void readFileByCharacter(String filePath){
        File file = new File(filePath);
        // FileReader:用来读取字符文件的便捷类。
        FileReader reader = null;
        try{
            reader = new FileReader(file);
            int temp ;
            while((temp = reader.read()) != -1){
                if (((char) temp) != '\r') {
                    System.out.print((char) temp);
                }
            }
        }catch(IOException e){
            e.getStackTrace();
        }finally{
            if (reader != null){
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    /**
     * 以行为单位读取文件内容
     * @param filePath
     */
    public static void readFileByLine(String filePath){
        File file = new File(filePath);
        // BufferedReader:从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
        BufferedReader buf = null;
        try{
            // FileReader:用来读取字符文件的便捷类。
            buf = new BufferedReader(new FileReader(file));
            // buf = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
            String temp = null ;
            while ((temp = buf.readLine()) != null ){
                System.out.println(temp);
            }
        }catch(Exception e){
            e.getStackTrace();
        }finally{
            if(buf != null){
                try{
                    buf.close();
                } catch (IOException e) {
                    e.getStackTrace();
                }
            }
        }
    }

    public static void main(String args[]) {
        readFileByByte(FILE_PATH);
        readFileByCharacter(FILE_PATH);
        readFileByLine(FILE_PATH);
    }
}

// ----------------------------------------------------------------- 分割线 -----------------------------------------------------------------------------

再经过两位同行的提点下，我对之前写的文件做了点修改，并通过读写一个1.2M的文本文件来测试各方法的性能。从多次测试结果来看，行读写却是是Java.nio更有效率。

经过修改之后的代码如下：

[java] view plain copy print ?

package com.waddell.basic;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
/**
* 文件读取类
* 1、按字节读取文件内容
* 2、按字符读取文件内容
* 3、按行读取文件内容
*
* @author qin_xijuan
*
*/
public class FileOperate {
private static final String FILE_PATH = "d:/work/jipinwodi.txt";
/**
* 以字节为单位读写文件内容
*
* @param filePath
* ：需要读取的文件路径
*/
public static void readFileByByte(String filePath) {
File file = new File(filePath);
// InputStream:此抽象类是表示字节输入流的所有类的超类。
InputStream ins = null;
OutputStream outs = null;
try {
// FileInputStream:从文件系统中的某个文件中获得输入字节。
ins = new FileInputStream(file);
outs = new FileOutputStream("d:/work/readFileByByte.txt");
int temp;
// read():从输入流中读取数据的下一个字节。
while ((temp = ins.read()) != -1) {
outs.write(temp);
}
} catch (Exception e) {
e.getStackTrace();
} finally {
if (ins != null && outs != null) {
try {
outs.close();
ins.close();
} catch (IOException e) {
e.getStackTrace();
}
}
}
}
/**
* 以字符为单位读写文件内容
*
* @param filePath
*/
public static void readFileByCharacter(String filePath) {
File file = new File(filePath);
// FileReader:用来读取字符文件的便捷类。
FileReader reader = null;
FileWriter writer = null;
try {
reader = new FileReader(file);
writer = new FileWriter("d:/work/readFileByCharacter.txt");
int temp;
while ((temp = reader.read()) != -1) {
writer.write((char)temp);
}
} catch (IOException e) {
e.getStackTrace();
} finally {
if (reader != null && writer != null) {
try {
reader.close();
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
* 以行为单位读写文件内容
*
* @param filePath
*/
public static void readFileByLine(String filePath) {
File file = new File(filePath);
// BufferedReader:从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
BufferedReader bufReader = null;
BufferedWriter bufWriter = null;
try {
// FileReader:用来读取字符文件的便捷类。
bufReader = new BufferedReader(new FileReader(file));
bufWriter = new BufferedWriter(new FileWriter("d:/work/readFileByLine.txt"));
// buf = new BufferedReader(new InputStreamReader(new
// FileInputStream(file)));
String temp = null;
while ((temp = bufReader.readLine()) != null) {
bufWriter.write(temp+"\n");
}
} catch (Exception e) {
e.getStackTrace();
} finally {
if (bufReader != null && bufWriter != null) {
try {
bufReader.close();
bufWriter.close();
} catch (IOException e) {
e.getStackTrace();
}
}
}
}
/**
* 使用Java.nio ByteBuffer字节将一个文件输出至另一文件
*
* @param filePath
*/
public static void readFileByBybeBuffer(String filePath) {
FileInputStream in = null;
FileOutputStream out = null;
try {
// 获取源文件和目标文件的输入输出流
in = new FileInputStream(filePath);
out = new FileOutputStream("d:/work/readFileByBybeBuffer.txt");
// 获取输入输出通道
FileChannel fcIn = in.getChannel();
FileChannel fcOut = out.getChannel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
while (true) {
// clear方法重设缓冲区，使它可以接受读入的数据
buffer.clear();
// 从输入通道中将数据读到缓冲区
int r = fcIn.read(buffer);
if (r == -1) {
break;
}
// flip方法让缓冲区可以将新读入的数据写入另一个通道
buffer.flip();
fcOut.write(buffer);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (in != null && out != null) {
try {
in.close();
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
public static long getTime(){
return System.currentTimeMillis();
}
public static void main(String args[]) {
long time1 = getTime() ;
// readFileByByte(FILE_PATH);// 8734,8281,8000,7781,8047
// readFileByCharacter(FILE_PATH);// 734, 437, 437, 438, 422
// readFileByLine(FILE_PATH);// 110, 94, 94, 110, 93
readFileByBybeBuffer(FILE_PATH);// 125, 78, 62, 78, 62
long time2 = getTime() ;
System.out.println(time2-time1);
}
}

package com.waddell.basic;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

/**
 * 文件读取类

 * 1、按字节读取文件内容

 * 2、按字符读取文件内容

 * 3、按行读取文件内容

 * 
 * @author qin_xijuan
 * 
 */
public class FileOperate {

    private static final String FILE_PATH = "d:/work/jipinwodi.txt";

    /**
     * 以字节为单位读写文件内容
     * 
     * @param filePath
     *            ：需要读取的文件路径
     */
    public static void readFileByByte(String filePath) {
        File file = new File(filePath);
        // InputStream:此抽象类是表示字节输入流的所有类的超类。
        InputStream ins = null;
        OutputStream outs = null;
        try {
            // FileInputStream:从文件系统中的某个文件中获得输入字节。
            ins = new FileInputStream(file);
            outs = new FileOutputStream("d:/work/readFileByByte.txt");
            int temp;
            // read():从输入流中读取数据的下一个字节。
            while ((temp = ins.read()) != -1) {
                outs.write(temp);
            }
        } catch (Exception e) {
            e.getStackTrace();
        } finally {
            if (ins != null && outs != null) {
                try {
                    outs.close();
                    ins.close();
                } catch (IOException e) {
                    e.getStackTrace();
                }
            }
        }
    }

    /**
     * 以字符为单位读写文件内容
     * 
     * @param filePath
     */
    public static void readFileByCharacter(String filePath) {
        File file = new File(filePath);
        // FileReader:用来读取字符文件的便捷类。
        FileReader reader = null;
        FileWriter writer = null;
        try {
            reader = new FileReader(file);
            writer = new FileWriter("d:/work/readFileByCharacter.txt");
            int temp;
            while ((temp = reader.read()) != -1) {
                writer.write((char)temp);
            }
        } catch (IOException e) {
            e.getStackTrace();
        } finally {
            if (reader != null && writer != null) {
                try {
                    reader.close();
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 以行为单位读写文件内容
     * 
     * @param filePath
     */
    public static void readFileByLine(String filePath) {
        File file = new File(filePath);
        // BufferedReader:从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
        BufferedReader bufReader = null;
        BufferedWriter bufWriter = null;
        try {
            // FileReader:用来读取字符文件的便捷类。
            bufReader = new BufferedReader(new FileReader(file));
            bufWriter = new BufferedWriter(new FileWriter("d:/work/readFileByLine.txt"));
            // buf = new BufferedReader(new InputStreamReader(new
            // FileInputStream(file)));
            String temp = null;
            while ((temp = bufReader.readLine()) != null) {
                bufWriter.write(temp+"\n");
            }
        } catch (Exception e) {
            e.getStackTrace();
        } finally {
            if (bufReader != null && bufWriter != null) {
                try {
                    bufReader.close();
                    bufWriter.close();
                } catch (IOException e) {
                    e.getStackTrace();
                }
            }
        }
    }

    /**
     * 使用Java.nio ByteBuffer字节将一个文件输出至另一文件
     * 
     * @param filePath
     */
    public static void readFileByBybeBuffer(String filePath) {
        FileInputStream in = null;
        FileOutputStream out = null;
        try {
            // 获取源文件和目标文件的输入输出流  
            in = new FileInputStream(filePath);
            out = new FileOutputStream("d:/work/readFileByBybeBuffer.txt");
            // 获取输入输出通道
            FileChannel fcIn = in.getChannel();
            FileChannel fcOut = out.getChannel();
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            while (true) {
                // clear方法重设缓冲区，使它可以接受读入的数据
                buffer.clear();
                // 从输入通道中将数据读到缓冲区
                int r = fcIn.read(buffer);
                if (r == -1) {
                    break;
                }
                // flip方法让缓冲区可以将新读入的数据写入另一个通道  
                buffer.flip();
                fcOut.write(buffer);
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (in != null && out != null) {
                try {
                    in.close();
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    public static long getTime(){
        return System.currentTimeMillis();
    }

    public static void main(String args[]) {
        long time1 = getTime() ;
        // readFileByByte(FILE_PATH);// 8734,8281,8000,7781,8047
        // readFileByCharacter(FILE_PATH);// 734, 437, 437, 438, 422
        // readFileByLine(FILE_PATH);// 110, 94,  94,  110, 93
        readFileByBybeBuffer(FILE_PATH);// 125, 78,  62,  78, 62
        long time2 = getTime() ;
        System.out.println(time2-time1);
    }
}

在main方法中，调用各方法之后，有五组数据，分辨是我5次读写文件测试出来的时间（毫秒）。

关于Java.nio 请参考：http://www.iteye.com/topic/834447

付我个人测试：

[java] view plain copy print ?

public static void main(String args[]) {
long time1 = getTime() ;
// readFileByByte(FILE_PATH); //2338,2286
// readFileByCharacter(FILE_PATH);//160,162,158
// readFileByLine(FILE_PATH); //46,51,57
// readFileByBybeBuffer(FILE_PATH);//19,18,17
// readFileByBybeBuffer(FILE_PATH);//2048: 11,13
// readFileByBybeBuffer(FILE_PATH);//1024*100 100k,711k: 6,6
// readFileByBybeBuffer(FILE_PATH);//1024*100 100k,1422k: 7
// readFileByBybeBuffer(FILE_PATH);//1024*100 100k,9951k: 49,48
// readFileByBybeBuffer(FILE_PATH);//1024*1000 1M,711k: 7,7
// readFileByBybeBuffer(FILE_PATH);//1024*1000 1M,1422k: 7,8
// readFileByBybeBuffer(FILE_PATH);//1024*1000 1M,9951k: 48,49
// readFileByBybeBuffer(FILE_PATH);//1024*10000 10M,711k: 21,13,17
// readFileByBybeBuffer(FILE_PATH);//1024*10000 10M,1422k: 16,17,14,15
// readFileByBybeBuffer(FILE_PATH);//1024*10000 10M,9951k:64,60
long time2 = getTime() ;
System.out.println(time2-time1);
}

    public static void main(String args[]) {
        long time1 = getTime() ;
//         readFileByByte(FILE_PATH);     //2338,2286
//         readFileByCharacter(FILE_PATH);//160,162,158
//         readFileByLine(FILE_PATH);     //46,51,57
//        readFileByBybeBuffer(FILE_PATH);//19,18,17
//        readFileByBybeBuffer(FILE_PATH);//2048: 11,13
//        readFileByBybeBuffer(FILE_PATH);//1024*100 100k,711k: 6,6
//        readFileByBybeBuffer(FILE_PATH);//1024*100 100k,1422k: 7
//        readFileByBybeBuffer(FILE_PATH);//1024*100 100k,9951k: 49,48
//        readFileByBybeBuffer(FILE_PATH);//1024*1000 1M,711k: 7,7
//        readFileByBybeBuffer(FILE_PATH);//1024*1000 1M,1422k: 7,8
//        readFileByBybeBuffer(FILE_PATH);//1024*1000 1M,9951k: 48,49
//        readFileByBybeBuffer(FILE_PATH);//1024*10000 10M,711k: 21,13,17
//        readFileByBybeBuffer(FILE_PATH);//1024*10000 10M,1422k: 16,17,14,15
//        readFileByBybeBuffer(FILE_PATH);//1024*10000 10M,9951k:64,60
        
        long time2 = getTime() ;
        System.out.println(time2-time1);
    }

转自： http://www.cnblogs.com/waddell/archive/2013/01/24/2874104.html

Java性能优化传奇之旅--Java万亿级性能优化之电商平台高峰时段性能大作战：策略与趋势洞察青云交 Java Java虚拟机（JVM）专栏 JVM万亿性能密码 java 性能优化大型综合电商平台时尚电商平台生鲜电商平台母婴电商平台跨境电商平台
亲爱的朋友们，热烈欢迎你们来到青云交的博客！能与你们在此邂逅，我满心欢喜，深感无比荣幸。在这个瞬息万变的时代，我们每个人都在苦苦追寻一处能让心灵安然栖息的港湾。而我的博客，正是这样一个温暖美好的所在。在这里，你们不仅能够收获既富有趣味又极为实用的内容知识，还可以毫无拘束地畅所欲言，尽情分享自己独特的见解。我真诚地期待着你们的到来，愿我们能在这片小小的天地里共同成长，共同进步。本博客的精华专栏：Ja
Java性能优化传奇之旅--Java万亿级性能优化之Java 性能优化传奇：热门技术点亮高效之路青云交 JVM万亿性能密码 Java性能优化 Java java Java 性能优化热门技术多线程并发代码优化内存管理数据库访问
亲爱的朋友们，热烈欢迎你们来到青云交的博客！能与你们在此邂逅，我满心欢喜，深感无比荣幸。在这个瞬息万变的时代，我们每个人都在苦苦追寻一处能让心灵安然栖息的港湾。而我的博客，正是这样一个温暖美好的所在。在这里，你们不仅能够收获既富有趣味又极为实用的内容知识，还可以毫无拘束地畅所欲言，尽情分享自己独特的见解。我真诚地期待着你们的到来，愿我们能在这片小小的天地里共同成长，共同进步。本博客的精华专栏：Ja
Java性能优化传奇之旅--Java万亿级性能优化之电商平台高峰时段性能优化：多维度策略打造卓越体验青云交 Java Java技术栈 JVM万亿性能密码电商平台高峰时段性能优化技术架构系统设计业务策略用户体验
亲爱的朋友们，热烈欢迎你们来到青云交的博客！能与你们在此邂逅，我满心欢喜，深感无比荣幸。在这个瞬息万变的时代，我们每个人都在苦苦追寻一处能让心灵安然栖息的港湾。而我的博客，正是这样一个温暖美好的所在。在这里，你们不仅能够收获既富有趣味又极为实用的内容知识，还可以毫无拘束地畅所欲言，尽情分享自己独特的见解。我真诚地期待着你们的到来，愿我们能在这片小小的天地里共同成长，共同进步。本博客的精华专栏：Ja
Java面试题--JVM大厂篇之高并发Java应用的秘密武器：深入剖析GC优化实战案例青云交 Java大厂面试题 Java虚拟机（JVM）专栏 Java java jvm 不同场景中优化CMS GC 高并发Java应用的秘密武器 CMS GC电商实战优化案例 CMS GC大数据优化案例 CMS GC金融系统优化案例
引言：晚上好，Java开发者们！在高并发的现代应用中，垃圾回收器（GC）是Java性能优化的重要环节。尤其在CMS（ConcurrentMark-Sweep）GC曾经担任主角的日子里，适当的调优和优化措施至关重要。本篇文章将通过三个实际案例，探讨如何在不同场景中优化CMSGC，为你揭示Java性能调优的秘密。vQingYunJiao，无论你是新手还是资深工程师，希望这篇文章能为你提供实践中的宝贵经
Java性能优化：垃圾回收算法的神秘面纱揭开！青云交 Java性能优化 java 性能优化算法 Java性能优化标记-清除标记-整理 JVM算法
引言：在Java虚拟机（JVM）中，垃圾回收（GC）算法的精妙设计确保了高效内存管理，减轻了开发者手动管理内存的负担。下面描述的算法不仅提高了应用程序的性能，而且还能在不牺牲系统稳定性的前提下，支持大型、复杂的应用环境。正文：标记-清除（Mark-Sweep）算法：先通过精确标记出所有可达（活跃）对象，然后清扫掉所有未标记（非活跃）对象，释放其占用的内存。尽管简单高效，这一过程可能产生内存碎片，影
Java垃圾回收器的工作原理 java菜
上课，老师照本宣科，实在难以理解，干脆就看书里的Java书，正好看了Java的垃圾回收器是如何工作的，觉得有必要记录一下。参考于Java编程思想第四版（ThinkinginJava）1.垃圾回收器对于提高对象的创建速度，有明显的效果问题来了，垃圾回收是释放对象，而关创建对象什么事？首先了解一下Java是如何在堆上分配内存的，Java使用“堆指针”，每分配一个对象，指针就往后移一位，类似于堆栈，这样
Kotlin内联类、内部类、嵌套类维特or卡顿
Kotlin内联类、内部类、嵌套类在开始介绍Kotlin内联类、内部类、嵌套类之前，先简要回顾一下java中的内部类java中的内部类可以将一个类的定义放在另一个类的定义内部，这就是内部类——《Java编程思想》概述在java中，内部类有一中非常有用的特性，它允许将一些逻辑相关的类组织在一起，并控制位于内部的类的可见性。java内部类拥有其外围类所有元素的访问权，不需要特殊条件就可以访问外围类的所
Java学习资源 | Java编程好书分享，必读！ Java烂笔头
Java资源合集（书籍版）入门进阶高级样样俱全书籍《JAVA核心技术卷1》有一些编程基础的同学推荐阅读，可以学习一段时间回头再看看《JAVA编程思想》Java圣经，值得仔细品读，作者的功力十分深厚，即使很多内容还无法理解，但每次读完一定会有所收获《EffectiveJava》书并不厚但是干货十足，作者讲述Java的最佳实践和经验规则。它能帮助我们写出清晰、健壮、高效的代码，同时这本书涵盖了非常多的
Java编程思想——第一章：对象导论代夫阿普曼
1.抽象过程1.1Java语言的五个基本特性万物皆对象；程序是对象的集合，它们通过发送消息来告知彼此所要的做的；每个对象都有自己的由其他对象所构成的存储；每个对象都拥有其类型；某一特定类型的所有对象都可以接受同样的消息。对象具有状态、行为和标识。意味着每一个对象都可以拥有内部数据和方法，并且每一个对象都可以与其他对象区分开来（每一个对象在内存中都有一个唯一的地址）。2.每个对象都有一个接口因为类描
【Java万花筒】加速Java应用程序：探索性能优化的利器 friklogff java 性能优化开发语言
Java性能优化：提升应用程序效率与可靠性的关键前言在当今软件开发领域中，性能是一个至关重要的方面。对于Java应用程序而言，优化其性能可以带来更高的效率和更好的用户体验。本文将介绍一些常用的Java性能优化库和工具，帮助开发者了解如何识别和解决应用程序的性能瓶颈，以提升应用程序的效率和可靠性。欢迎订阅专栏：Java万花筒文章目录Java性能优化：提升应用程序效率与可靠性的关键前言1.JProfi
2024Java开发必读书籍推荐
作为一名Java工程师，持续学习和提升是非常重要的。阅读优秀的技术书籍可以帮助我们深入理解Java编程语言的核心概念和最佳实践。在本文中，我将向大家推荐一共10本Java工程师必读的经典书籍，旨在帮助大家扩展知识领域，提高编程技能和解决问题的能力。《Java编程思想》（ThinkinginJava）这是一本非常有名的经典书籍。它不仅介绍了Java编程的基础知识，还深入讨论了各种编程选择和判断，并涵
《JAVA编程思想》第七章多态读书笔记小芹菜_4d69
多态（后期绑定）JAVA中所有的函数，除了声明为final，皆使用后期绑定。（final函数存在的意义：防止子类重载）构造函数的调用顺序：1、调用baseclass函数；2、各个成员的声明顺序；3、本身构造函数本体。finalize()函数至少具有protected权限。构造函数中唯一可以安全调用的函数便是basecalss中的final函数（对private函数一样成立）。注：final和pri
Java性能优化(珍藏版) 羞涩的二黄
Java性能优化的50个细节（珍藏版）原文链接：https://www.toutiao.com/i6595499804082569742/在JAVA程序中，性能问题的大部分原因并不在于JAVA语言，而是程序本身。养成良好的编码习惯非常重要，能够显著地提升程序性能。1.尽量在合适的场合使用单例使用单例可以减轻加载的负担，缩短加载的时间，提高加载的效率，但并不是所有地方都适用于单例，简单来说，单例主要
你都是会点啥技术（四）--- Java 梦是做出来的 java java 后端总结学习
你都是会点啥技术（四）—Java写在前面的话：到2019年6月份为止，真正使用java有两年了，在大学期间老师教过一遍java（学的不好），看过两三个老师讲解的java视频，每次学习都会有新的体验和收获，也读过《java编程思想》和《深入理解Java虚拟机》，从我对我自己的审视来看，万万不敢说掌握了java这门语言，这次是把java从基础到高级梳理一遍，一方面是对java知识回顾，一方面补充工作中
Java编程思想（第四版）Thinking in Java 4th 读书笔记虾米记读书笔记 Java java 学习读书笔记
目录前言配书代码使用指南第1章对象导论1.2接口1.4被隐藏的具体实现1.5复用具体实现1.7多态1.8单根继承第2章一切都是对象object2.2必须由你创建所有对象2.2.1五个地方存储数据2.2.2特例：基本类型2.4类2.4.1字段和方法2.6构建一个Java程序2.6.1名字可见性2.7你的第一个Java程序2.8注释和嵌入式文档第3章操作符operators3.1更简单的打印语句3.4
2019-3-8晨间日记 Ay_先生
三月八日妇女节同时也是公司周年节日起床：8:27就寝：12点躺床，深夜2点开始深睡天气：阴有雨心情：中纪念日：无任务清单昨日完成的任务，最重要的三件事：改进：十一点半之前睡觉习惯养成：每天晚上学习Java编程思想或其他技术一个章节周目标·完成进度健身1次，目前尚未达成学习·信息·阅读阅读一篇文章健康·饮食·锻炼吃多点人际·家人·朋友维稳工作·思考上周五版本推荐，周一晚上八点才提单，周四晚上下班才搞
《JAVA编程思想》学习笔记：第19章（枚举）编程家园
第十九章、枚举类型概述：关键字enum：可以将一组具名的值的有限集合创建为一种新的类型（Class），而这些具名的值可以作为常规的程序组件使用。创建enum时，编译器会为你自动生成一个相关类，此类自动extendsjava.lang.Enum类。1.基本enum特性Enum类提供的功能如下：values()返回enum实例的数组，而且保持声明的顺序：ordinal()返回一个int值，这是每个en
大神的分享：Java程序员的学习生涯中各个阶段的建议 JAVA架构师的圈子
第一部分：对于参加工作一年以内的同学。恭喜你，这个时候，你已经拥有了一份Java的工作。这个阶段是你成长极快的阶段，而且你可能会经常加班。但是加班不代表你就可以松懈了，永远记的那句话，从你入行那一刻起，你就要不停的学习。在这一年里，你至少需要看完《Java编程思想》这本书。这本书的内容是帮助你对于Java有一个更加深入的了解，是Java基础的升级版。这本书很厚，正常速度的话，应该可以在半年左右看完
阿里大牛分享：Java性能优化宝典，678页PDF干货，助你成为技术大牛技术琐事 jvm 笔记 java-ee java 后端
前言：Java程序性能优化，这个话题虽然已经老生常谈，但真正将其讲解清楚却并非易事。目前市场上的相关图书，其内容深度与讲解方式参差不齐，有的甚至晦涩难懂。然而，这本书却与众不同，它让人眼前一亮，许多困扰Java程序员的难题都能在其中找到解答。这本书结合了作者多年的Java开发经验和对Java系统的深入理解，由浅入深地阐述了Java程序性能优化的方法、技巧和思想。它通过大量的实例，生动地展示了各种参
阿里技术专家力作：Java性能优化宝典，678页PDF精华，引领技术潮流手把手教你学Java java-ee java 后端深度优先 jvm
前言：Java程序性能优化，这个话题虽然已经老生常谈，但真正将其讲解清楚却并非易事。目前市场上的相关图书，其内容深度与讲解方式参差不齐，有的甚至晦涩难懂。然而，这本书却与众不同，它让人眼前一亮，许多困扰Java程序员的难题都能在其中找到解答。这本书结合了作者多年的Java开发经验和对Java系统的深入理解，由浅入深地阐述了Java程序性能优化的方法、技巧和思想。它通过大量的实例，生动地展示了各种参
java学习书籍推荐墨雨轩夏
一、Java编程入门类对于没有Java编程经验的程序员要入门，随便读什么入门书籍都一样，这个阶段需要你快速的掌握Java基础语法和基本用法，宗旨就是“囫囵吞枣不求甚解”，先对Java熟悉起来再说。用很短的时间快速过一遍Java语法，连懵带猜多写写代码，要“知其然”。1、《Java编程思想》在有了一定的Java编程经验之后，你需要“知其所以然”了。这个时候《Java编程思想》是一本让你知其所以然的好
后端开发工程师需要掌握的内容 Programmer boy 后端知识后端需要学习的知识学习方向
1.语言相关1.1Java核心知识点Java的类加载机制JVM相关：JVM内存模型和结构,GC原理,性能调优泛型集合体系异常体系IO体系多线程编程反射Servlet推荐数据《Java编程思想》《EffectiveJava》《深入理解Java虚拟机》1.2Shell、Python等脚本语言介绍此类脚本语言的意义在于辅助后端开发，包括系统运维，工具集成（借助管道、重定向），文本处理，数据计算等工作，提
怎么做好Java性能优化 superjava_ Java java 性能优化开发语言后端
0.开篇性能优化是一个很复杂的工作，且充满了不确定性。它不像Java业务代码，可以一次编写到处运行(writeonce,runanywhere)，往往一些我们可能并不能察觉的变化，就会带来惊喜/惊吓。能够全面的了解并评估我们所负责应用的性能，我认为是提升技术确定性和技术感知能力的非常有效的手段。本文尽可能简短的总结我自己在性能优化上面的一些体会和经验，从实践的角度出发尽量避免过于啰嗦和生硬，但相关
Java编程思想3 Be reborn Java编程思想 java 开发语言
文章目录一、访问权限控制1.目的2.访问权限修饰符：3.私有构造器二、复用类1.组合（Composition）：2.继承（Inheritance）：3.基类的初始化：4.在组合与继承之间选择：使用组合的情况：使用继承的情况：5.final关键字1.final修饰类：2.final修饰方法：3.final修饰变量（字段）：三、多态1.多态的基本概念：2.向上转型和向下转型：3.运行时多态性：4.抽象
那些年曾经看过的书——工作篇徐福记456 人生杂谈 android 音视频程序员的梦想
工作以后，主要是看一些与工作相关的书，比如Android相关：Android开发艺术探索、深入理解Android内核设计思想、Android系统源代码情景分析、精通Android多媒体开发、AndroidC++高级编程。音视频相关：FFmpeg从入门到精通、WebRTCNative开发实战、OpenGLES3.0编程指南、音视频开发进阶指南。语言相关：C++PrimerPlus、Java编程思想。
阿里Java性能优化实战手册：上线一小时，下载量破10W 技术琐事 spring boot spring java 后端性能优化
前言在阅读《Java程序性能优化实战》后，我深感这本书对Java的各个方面的讲解既全面又不失条理，每个知识点都阐述得清晰明了，让人阅读起来毫无障碍，收获颇丰。书中干货满满，国内如此优秀的作品实属罕见。我强烈推荐朋友们一读，相信你们定能从中获益匪浅核心内容把细节打磨的极其突出下面跟着小编来看下具体内容吧！第1章Java性能调优概述性能优化的一般步骤以及木桶原理与性能瓶颈第2章设计优化第3章Java程
书单 suddennessMan
持续添加1.MIT6.00.1x(计算机科学和Python编程导论)2019-1-2开始预计一个月2.HarvardCS50x(计算机科学)3.SICP(计算机程序的构造和解释)4.Java编程思想5.CSAPP(深入理解计算机系统)6.大话设计模式7.重构改善既有代码的设计8.effectivejava9.深入理解Java虚拟机10.tcp/ip详解卷一、二、三11.数据结构与算法12.Pyth
一文读懂java性能优化（最全干货篇）一只IT攻城狮《Java高并发编程》系列 java 性能优化后端
java性能优化篇-序一、概述二、技术优化之中间件优化三、技术优化之高并发优化四、技术优化之后端优化五、技术优化之架构优化一、概述性能优化：是指针对计算机系统或应用程序的性能进行改善的一系列技术和方法。性能优化的目标：是提高系统或应用程序的响应时间、吞吐量、效率和可伸缩性等方面的性能指标。性能优化需要有一些技巧：对于一个整个产品或项目而言，比如可以从前端优化、后端优化、架构优化、高并发优化、Lin
Java编程思想——第十一章：持有对象代夫阿普曼
容器提供完善的方法来保存对象，还拥有一些特性。Java容器类都可以自动地调整自己的尺寸。1.泛型和类型安全的容器通过使用泛型，可以在编译期防止将错误类型的对象放置到容器中。将元素从容器中拿出时，类型转换也不再是必需的了。因为容器直到它保存的是什么类型，因此它会在调用get()时替你执行转型。2.基本概念容器类类库的两个不同概念：Collection：一个独立元素的序列，这些元素都服从一条或多条规则
Java基础—方法—11方法结构和调用、重载和命令行传参（附：return语句、静态方法的介绍及命令行传参、GBK与Unicode编码问题解决）冻笠 JavaSE java 开发语言学习
1、科普：System.out.println();调用系统类的标准输出对象out中的方法println()2、Java中方法：类似其他语言的函数，是完成特定功能的代码片段，这也是设计方法的原则。3、方法结构：（其中参数像是一个占位符）1）return语句的作用：根据《java编程思想：第四版》4.5节中介绍：return语句作为一个无条件的分支，无需判断条件即可发生。return语句主要有两个用
基本数据类型和引用类型的初始值 3213213333332132 java基础
package com.array; /** * @Description 测试初始值 * @author FuJianyong * 2015-1-22上午10:31:53 */ public class ArrayTest { ArrayTest at; String str; byte bt; short s; int i; long
摘抄笔记--《编写高质量代码：改善Java程序的151个建议》白糖_ 高质量代码
记得3年前刚到公司，同桌同事见我无事可做就借我看《编写高质量代码：改善Java程序的151个建议》这本书，当时看了几页没上心就没研究了。到上个月在公司偶然看到，于是乎又找来看看，我的天，真是非常多的干货，对于我这种静不下心的人真是帮助莫大呀。看完整本书，也记了不少笔记
【备忘】Django 常用命令及最佳实践 dongwei_6688 django
注意：本文基于 Django 1.8.2 版本生成数据库迁移脚本（python 脚本） python manage.py makemigrations polls 说明：polls 是你的应用名字，运行该命令时需要根据你的应用名字进行调整查看该次迁移需要执行的 SQL 语句（只查看语句，并不应用到数据库上）： python manage.p
阶乘算法之一N! 末尾有多少个零周凡杨 java 算法阶乘面试效率
&n
spring注入servlet g21121 Spring注入
传统的配置方法是无法将bean或属性直接注入到servlet中的，配置代理servlet亦比较麻烦，这里其实有比较简单的方法，其实就是在servlet的init()方法中加入要注入的内容： ServletContext application = getServletContext(); WebApplicationContext wac = WebApplicationContextUtil
Jenkins 命令行操作说明文档 510888780 centos
假设Jenkins的URL为http://22.11.140.38:9080/jenkins/ 基本的格式为 java 基本的格式为 java -jar jenkins-cli.jar [-s JENKINS_URL] command [options][args] 下面具体介绍各个命令的作用及基本使用方法 1. &nb
UnicodeBlock检测中文用法布衣凌宇 UnicodeBlock
/** * 判断输入的是汉字 */ public static boolean isChinese(char c) { Character.UnicodeBlock ub = Character.UnicodeBlock.of(c);
java下实现调用oracle的存储过程和函数 aijuans java orale
1.创建表：STOCK_PRICES 2.插入测试数据： 3.建立一个返回游标： PKG_PUB_UTILS 4.创建和存储过程：P_GET_PRICE 5.创建函数： 6.JAVA调用存储过程返回结果集 JDBCoracle10G_INVO
Velocity Toolbox antlove 模板 tool box velocity
velocity.VelocityUtil package velocity; import org.apache.velocity.Template; import org.apache.velocity.app.Velocity; import org.apache.velocity.app.VelocityEngine; import org.apache.velocity.c
JAVA正则表达式匹配基础百合不是茶 java 正则表达式的匹配
正则表达式;提高程序的性能,简化代码,提高代码的可读性,简化对字符串的操作正则表达式的用途; 字符串的匹配字符串的分割字符串的查找字符串的替换正则表达式的验证语法 [a] //[]表示这个字符只出现一次 ,[a] 表示a只出现一
是否使用EL表达式的配置 bijian1013 jsp web.xml EL EasyTemplate
今天在开发过程中发现一个细节问题，由于前端采用EasyTemplate模板方法实现数据展示，但老是不能正常显示出来。后来发现竟是EL将我的EasyTemplate的${...}解释执行了，导致我的模板不能正常展示后台数据。网
精通Oracle10编程SQL(1-3)PLSQL基础 bijian1013 oracle 数据库 plsql
--只包含执行部分的PL/SQL块 --set serveroutput off begin dbms_output.put_line('Hello,everyone!'); end; select * from emp; --包含定义部分和执行部分的PL/SQL块 declare v_ename varchar2(5); begin select
【Nginx三】Nginx作为反向代理服务器 bit1129 nginx
Nginx一个常用的功能是作为代理服务器。代理服务器通常完成如下的功能：接受客户端请求将请求转发给被代理的服务器从被代理的服务器获得响应结果把响应结果返回给客户端实例本文把Nginx配置成一个简单的代理服务器对于静态的html和图片，直接从Nginx获取对于动态的页面，例如JSP或者Servlet，Nginx则将请求转发给Res
Plugin execution not covered by lifecycle configuration: org.apache.maven.plugin blackproof maven 报错
转：http://stackoverflow.com/questions/6352208/how-to-solve-plugin-execution-not-covered-by-lifecycle-configuration-for-sprin maven报错： Plugin execution not covered by lifecycle configuration:
发布docker程序到marathon ronin47 docker 发布应用
1 发布docker程序到marathon 1.1 搭建私有docker registry 1.1.1 安装docker regisry docker pull docker-registry docker run -t -p 5000:5000 docker-registry 下载docker镜像并发布到私有registry docker pull consol/tomcat-8.0
java-57-用两个栈实现队列&&用两个队列实现一个栈 bylijinnan java
import java.util.ArrayList; import java.util.List; import java.util.Stack; /* * Q 57 用两个栈实现队列 */ public class QueueImplementByTwoStacks { private Stack<Integer> stack1; pr
Nginx配置性能优化 cfyme nginx
转载地址：http://blog.csdn.net/xifeijian/article/details/20956605 大多数的Nginx安装指南告诉你如下基础知识——通过apt-get安装，修改这里或那里的几行配置，好了，你已经有了一个Web服务器了。而且，在大多数情况下，一个常规安装的nginx对你的网站来说已经能很好地工作了。然而，如果你真的想挤压出Nginx的性能，你必
[JAVA图形图像]JAVA体系需要稳扎稳打,逐步推进图像图形处理技术 comsci java
对图形图像进行精确处理，需要大量的数学工具，即使是从底层硬件模拟层开始设计，也离不开大量的数学工具包，因为我认为，JAVA语言体系在图形图像处理模块上面的研发工作，需要从开发一些基础的，类似实时数学函数构造器和解析器的软件包入手，而不是急于利用第三方代码工具来实现一个不严格的图形图像处理软件...... &nb
MonkeyRunner的使用 dai_lm android MonkeyRunner
要使用MonkeyRunner，就要学习使用Python，哎先抄一段官方doc里的代码作用是启动一个程序（应该是启动程序默认的Activity），然后按MENU键，并截屏 # Imports the monkeyrunner modules used by this program from com.android.monkeyrunner import MonkeyRun
Hadoop-- 海量文件的分布式计算处理方案 datamachine mapreduce hadoop 分布式计算
csdn的一个关于hadoop的分布式处理方案，存档。原帖：http://blog.csdn.net/calvinxiu/article/details/1506112。 Hadoop 是Google MapReduce的一个Java实现。MapReduce是一种简化的分布式编程模式，让程序自动分布到一个由普通机器组成的超大集群上并发执行。就如同ja
以資料庫驗證登入 dcj3sjt126com yii
以資料庫驗證登入由於 Yii 內定的原始框架程式, 採用綁定在UserIdentity.php 的 demo 與 admin 帳號密碼: public function authenticate() { $users=array( &nbs
github做webhooks：[2]php版本自动触发更新 dcj3sjt126com github git webhooks
上次已经说过了如何在github控制面板做查看url的返回信息了。这次就到了直接贴钩子代码的时候了。工具/原料 git github 方法/步骤在github的setting里面的webhooks里把我们的url地址填进去。钩子更新的代码如下： error_reportin
Eos开发常用表达式蕃薯耀 Eos开发 Eos入门 Eos开发常用表达式
Eos开发常用表达式 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2014年8月18日 15:03:35 星期一 &
SpringSecurity3.X--SpEL 表达式 hanqunfeng SpringSecurity
使用 Spring 表达式语言配置访问控制，要实现这一功能的直接方式是在<http>配置元素上添加 use-expressions 属性： <http auto-config="true" use-expressions="true"> 这样就会在投票器中自动增加一个投票器：org.springframework
Redis vs Memcache IXHONG redis
1. Redis中，并不是所有的数据都一直存储在内存中的，这是和Memcached相比一个最大的区别。 2. Redis不仅仅支持简单的k/v类型的数据，同时还提供list，set，hash等数据结构的存储。 3. Redis支持数据的备份，即master-slave模式的数据备份。 4. Redis支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用。 Red
Python - 装饰器使用过程中的误区解读 kvhur JavaScript jquery html5 css
大家都知道装饰器是一个很著名的设计模式，经常被用于AOP(面向切面编程)的场景，较为经典的有插入日志，性能测试，事务处理，Web权限校验， Cache等。原文链接：http://www.gbtags.com/gb/share/5563.htm Python语言本身提供了装饰器语法（@），典型的装饰器实现如下： @function_wrapper de
架构师之mybatis-----update 带case when 针对多种情况更新 nannan408 case when
1.前言. 如题. 2. 代码. <update id="batchUpdate" parameterType="java.util.List"> <foreach collection="list" item="list" index=&
Algorithm算法视频教程栏目记者 Algorithm 算法
课程：Algorithm算法视频教程百度网盘下载地址： http://pan.baidu.com/s/1qWFjjQW 密码: 2mji 程序写的好不好,还得看算法屌不屌！Algorithm算法博大精深。一、课程内容：课时1、算法的基本概念 + Sequential search 课时2、Binary search 课时3、Hash table 课时4、Algor
C语言算法之冒泡排序 qiufeihu c 算法
任意输入10个数字由小到大进行排序。代码： #include <stdio.h> int main() { int i,j,t,a[11]; /*定义变量及数组为基本类型*/ for(i = 1;i < 11;i++){ scanf("%d",&a[i]); /*从键盘中输入10个数*/ } for
JSP异常处理 wyzuomumu Web jsp
1.在可能发生异常的网页中通过指令将HTTP请求转发给另一个专门处理异常的网页中: <%@ page errorPage="errors.jsp"%> 2.在处理异常的网页中做如下声明： errors.jsp: <%@ page isErrorPage="true"%>，这样设置完后就可以在网页中直接访问exc

Java文件读写IO/NIO及性能比较总结

你可能感兴趣的:(java性能优化,java编程思想)