Java中常见的类（二）

字符串拼接

拼接方法：

1. +号拼接：左右两边操作数是字面值时，直接拼接再在常量池中开空间

   ​ 如果左右两边操作数是变量则通过 常量池重新分配空间，存储变量地址

2. StringBuilder.append()

3. concat

性能比较:append>concat>+号（如果+号两边是字面值则效率最高）

public class Test{  
    public static void main(String[] args) {  
        test01();  
        test02();  
        test03();  
    }  
    public static void test01() {  
        long start=System.currentTimeMillis();  
        StringBuffer s=new StringBuffer("a");  
        for(int i=0;i<100000;i++) {  
            s.append("c");  
        }  
        long end=System.currentTimeMillis();  
        System.out.println("append时间："+(end-start));      
    }  
    public static void test02() {  
        long start=System.currentTimeMillis();  
        String s=new String("a");  
        for(int i=0;i<100000;i++) {  
            s.concat("c");  
        }  
        long end=System.currentTimeMillis();  
        System.out.println("concat时间："+(end-start));  
    }  
    public static void test03() {  
        long start=System.currentTimeMillis();  
        String s=new String("a");  
        for(int i=0;i<100000;i++) {  
            s=s+"c";  
        }  
        long end=System.currentTimeMillis();  
        System.out.println("+号时间："+(end-start));  
    }   
}  

SimpleDateFormat

public class Test01 {  
    public static void main(String[] args) {  
        //创建时间对象  
        Date date =new Date();  
        //创建SimpleDateFormat对象  
        SimpleDateFormat s=new SimpleDateFormat();  
        //设置输出内容格式  
        s.applyPattern("yyyy年MM月dd日  HH时mm分ss秒  是一年中的第D天");  
        //调用格式化方法格式化日期  
        String str=s.format(date);  
        System.out.println(str);  
        //创建对象并且指定格式化内容  
        SimpleDateFormat S1=new SimpleDateFormat("yy/MM/dd hh:mm:ss");  
        System.out.println(S1.format(date));  
    }  
}  

Calendar

public class Test01 {  
    public static void main(String[] args) {  
        //创建对象  
        Calendar c1=Calendar.getInstance();  
        //add()方法，累加不会增位  
        c1.add(Calendar.DAY_OF_MONTH, 13);  
        System.out.println(c1.get(Calendar.DAY_OF_MONTH));  
        System.out.println(c1.get(Calendar.MONTH));  
          
        c1=Calendar.getInstance();  
        //roll方法，累加不会增位  
        c1.roll(Calendar.DAY_OF_MONTH, 13);  
        System.out.println(c1.get(Calendar.DAY_OF_MONTH));  
        System.out.println(c1.get(Calendar.MONTH));  
        System.out.println("===");  
        c1 = Calendar.getInstance();  
        //传入参数如果是当前月份之内的天数 则设置为指定的日期 如果传入的是超过了字段值的数 则会增位  
        c1.setLenient(true);  
        c1.set(Calendar.DAY_OF_MONTH, 32);  
        System.out.println(c1.get(Calendar.DAY_OF_MONTH));  
        System.out.println(c1.get(Calendar.MONTH));  
    }  
}  

File

常见的方法

File s=new File)("路径")：创建文件对象
canExecute():查看是否可执行
canWrite():查看是否可写
canRead():查看是否可读
compareTo(path):比较路径
getPath（）：获取路径
creatNewFile():创建新文件
isAbsolute():是否是绝对路径
getAbsolutePath()：获取绝对路径
getName（）：获取文件名称
getParent():获取父级目录
getFreeSpace（）：获取剩余空间
getTotalSpace():获取总共空间大小
getUseableSpace():获取可用大小
lastModified():最后修改时间

public class Test02 {  
    public static void main(String[] args) {  
        File f=new File("D:\\md\\c.text");  
        System.out.println("查看是否可执行："+f.canExecute());  
        System.out.println("查看是否可写:"+f.canWrite());  
        System.out.println("查看是否可读:"+f.canRead());  
          
        File ff=new File("D:\\md\\d.text");  
        //比较path  
        System.out.println(ff.compareTo(f));  
        //获取路径  
        System.out.println(f.getPath());  
        try {  
            System.out.println("创建文件是否成功："+f.createNewFile());  
        } catch (IOException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
          
        System.out.println("是否是绝对路径："+f.isAbsolute());  
        //获取绝对路径  
        System.out.println("获取文件名称："+f.getName());  
        System.out.println("获取父级目录："+f.getParent());  
        System.out.println("获取相对路径："+f.getPath());  
        f=new File("D:\\md\\c.text");  
        System.out.println(new SimpleDateFormat("yyyy/MM/dd hh:mm:ss").format(new Date(f.lastModified())));  
    }  
}  

IO

IO流的分类：

​ 1.按照数据的输出类型不同：

			字节流：输入输出时，按照字节输入输出

			字符流：输入输出时，按照字符输入输出

​ 2.按照流的方向：输入流和输出流

​ 3.按照处理功能：

			节点流：连接在管道两端的流

			处理流：没有连在两端的流

数据读取：

​ InputStream:所有字节流的父类

​ FileIputStream:文件字节输入流

public class Test03 {  
    public static void main(String[] args) {  
        //创建对象  
        InputStream in=null;  
        try {  
            in = new FileInputStream("D:\\md\\b.text");  
            byte[] buf=new byte[1024];  
            int len=in.read(buf);  
            String msg=new String(buf,0,len);  
            System.out.println(msg);  
        } catch (FileNotFoundException e) {  
            e.printStackTrace();  
        }catch (Exception e) {  
            e.printStackTrace();  
        }finally {  
            try {  
                in.close();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
}  

数据输出：

​ OutputStream:所有字节输出流的父类

​ FileOutputStream：输出文件，如果文件不存在会创建该文件

public class Test04 {  
    public static void main(String[] args) throws IOException{  
        //创建数据输出流对象  
        OutputStream os=new FileOutputStream("ab.text");  
        //声明写出数据  
        int num=97;  
        os.write(num);  
        os.close();  
          
    }  
}

简单的复制粘贴

public class Test06 {  
    public static void main(String[] args) throws IOException{  
        CV();  
    }  
    public static void CV()throws IOException{  
        String srcFile="C:\\Users\\xmt15\\Pictures\\Saved Pictures\\1.jpg";  
        String destFile="2.jpg";  
        InputStream is=new FileInputStream(srcFile);  
        OutputStream os=new FileOutputStream(destFile);  
        //读取文件  
        int len=0;  
        while((len=is.read())!=-1) {  
            os.write(len);  
        }  
        os.close();  
        is.close();  
    }  
}