Java之StringBuffer，StringBuilder，Math，Date，SimpleDateFormat，UUID，File

 

java.lang 
类 StringBuffer

java.lang.Object

继承者 

java.lang.StringBuffer
所有已实现的接口：
Serializable, Appendable, CharSequence
public final class StringBufferextends Objectimplements Serializable, CharSequence


线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。


String创建的字符串对象是不可修改的，StringBuff类创建的是可修改的字符串序列，且实体容量会随着存放的字符串增加而自动增加。


可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。  




StringBuffer类的作用：


String虽然提供了很多API方法，但是始终是对字符串常量进行操作，不仅无法改变常量的值，还会占用大量内存空间。StringBuffer类则是一个非常灵活的工具，节约内存空间的同时还保障了线程安全。




java.lang 
类 StringBuilder


java.lang.Object
  


继承者 


java.lang.StringBuilder



所有已实现的接口：
Serializable, Appendable, CharSequence


public final class StringBuilderextends Objectimplements Serializable, CharSequence




一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。 




StringBuilder类即字符串生成器，新创建的StringBuilder对象初始容量是16个字符，可以自行指定初始长度，也可以动态地执行添加、删除和插入等字符串的编辑操作，大大提高了频繁增加字符串的效率。如果附加的字符超过可容纳的长度，则StringBuilder对象将自动增加长度以容纳被附加的字符。用一个简单的例子来看一下String类、StringBuffer类和StringBuilder类运行速度对比


String类、StringBuffer类和StringBuilder之间的关系：


让String类、StringBuffer类和StringBuilder类同时拼接100000次看他们运行的时间对比




public class StringBufferTest {
    public static void main(String[] args) {
        String s="";
        long start_s=System.currentTimeMillis();//String类开始拼接的时间
        for(int i=0;i<100000;i++){
            s+="aaaa";//String类拼接100000次
        }
        long end_s=System.currentTimeMillis();//String类结束拼接的时间
        System.out.println("String拼接100000次的时间："+(end_s-start_s)+"ms");//输出String拼接一万次用的毫秒数
        StringBuffer ss=new StringBuffer();
        long start_ss=System.currentTimeMillis();//StringBuffer类开始拼接的时间
        for(int i=0;i<100000;i++){
            ss.append("aaaa");
        }
        long end_ss=System.currentTimeMillis();//StringBuffer类结束拼接的时间
        System.out.println("StringBuffer拼接100000次的时间："+(end_ss-start_ss)+"ms");//输出StringBuffer拼接一万次用的毫秒数
        StringBuilder sd=new StringBuilder();
        long start_sd=System.currentTimeMillis();//StringBuilder类开始拼接的时间
        for(int i=0;i<100000;i++){
            sd.append("aaaa");//StringBuilder类拼接100000次
        }
        long end_sd=System.currentTimeMillis();//StringBuilder类结束拼接的时间
        System.out.println("StringBuilder拼接100000次的时间："+(end_sd-start_sd)+"ms");//输出StringBuilder拼接一万次用的毫秒数
    }
}




其运行结果如下：




在执行速度方面的比较：StringBuilder >  StringBuffer  >  String


三者的关系：




三者之间相互转换：




三者之间的不同之处：


String只能赋值1次，每一次改变内容都生成了一个新的对象，然后原有的对象引用了新的对象，所以说String本身是不可改变，每一次改变String的内容，都会在内存创建新的对象，而每一次生成新对象都会对系统性能产生影响，这会降低Java虚拟机的工作效率。如下图所示：




而StringBuilder和StringBuffer不同，每次操作都是对自身对象的操作，而不是生成新的对象，其所占空间会随着字幅内容增加而增加，做大量修改操作时，不会因生成大量匿名对象而影响系统性能。如下图所示：




StringBuffer类操作：


作用：String虽然提供了很多API方法，但是始终是对字符串常量进行操作，不仅无法改变常量的值，还会占用大量内存空间。StringBuffer类则是一个非常灵活的工具，节约内存空间的同时还保障了线程安全。


创建：




        //创建一个StringBuilder类对象必须用new方法，不能像String对象那样直接引用字符串常量
        StringBuffer sbf1=new StringBuffer();  //创建一个对象无初始值
        StringBuffer sbf2=new StringBuffer("abc");   //创建一个对象，初始值 “abc”
        StringBuffer sbf3=new StringBuffer(32);   //创建一个对象，初始容量为32个字符






追加字符串：


append()  方法




        StringBuffer sbf =new StringBuffer("谁将");
        sbf.append("新樽");   //追加字符串
        StringBuffer s1=new StringBuffer("辞旧月");  
        sbf.append(s1);  //追加新的字符串中的内容
        int a=2333;
        sbf.append(a);   //追加int型变量a
        System.out.println(sbf);






修改指定索引处的字符：


setChar() 方法




        StringBuffer sbf=new StringBuffer("谁将新樽辞旧月");
        sbf.setCharAt(6,'日');   //替换索引6的字符
        System.out.println(sbf);






插入字符串：


insert()  方法




        StringBuffer sbf=new StringBuffer("谁将新樽辞旧月");
        sbf.insert(2,"我的");  //在索引2插入
        System.out.println(sbf);






字符串的反序：


reverse()  方法




        StringBuffer sbf=new StringBuffer("谁将新樽辞旧月");
        sbf.reverse();
        System.out.println(sbf);






删除子字符串：


delete()  方法




        StringBuffer sbf=new StringBuffer("谁将新樽辞旧月");
        sbf.delete(4,6);
        System.out.println(sbf);






其他常用方法：




        StringBuffer sbf=new StringBuffer("谁将新樽辞旧月");
        System.out.println(sbf.length());   //获取字符串序列长度
        System.out.println(sbf.charAt(5));   //获取索引为5的内容
        System.out.println(sbf.indexOf("DEF"));   //获取DEF所在的索引位置，没有返回 -1
        System.out.println(sbf.substring(0,2));   //获取索引0-2的内容
        System.out.println(sbf.replace(2,5,"wode"));    //将索引2-5的内容替换




 




StringBuilder类和StringBuffer类具有兼容的API，所以两者使用方法也相同




        StringBuilder sbd=new StringBuilder();
        sbd.append("我是StringBuilder");  //追加字符
        sbd.length();   //长度
        sbd=sbd.insert(5,"///");   //插入
        sbd=sbd.delete(sbd.length()-1,sbd.length() );   //删除最后一个字符
        sbd=sbd.reverse();   //反序






java.lang 
类 Math


java.lang.Object
  


继承者 


java.lang.Math





public final class Mathextends Object




Math 类包含基本的数字操作，如指数、对数、平方根和三角函数。


与 StrictMath 类的某些数值方法不同，并不是 Math 类的所有等效函数的实现都定义为返回逐位相同的结果。这一宽限允许在不要求严格可重复性的地方实现更好的性能。


默认情况下，很多 Math 方法仅调用 StrictMath 中的等效方法来完成它们的实现。代码生成器鼓励使用特定于平台的本机库或者在可用的地方使用微处理器指令，来提供对 Math 方法的更高性能的实现。这种更高性能的实现仍然必须遵守 Math 的规范。 




 math类常用方法




        System.out.println(Math.E); //自然对数的底数
        System.out.println(Math.PI);  //圆周率
        System.out.println(Math.abs(-10)); //返回各种类型绝对值
        System.out.println(Math.cos(90));    //返回角的三角余弦。如果参数是 NaN 或无穷大，那么结果是 NaN。
        System.out.println(Math.sin(90));    //返回角的三角正弦。特殊情况是： 如果参数是 NaN 或无穷大，那么结果是 NaN。 如果参数是零，那么结果是零，符号与参数符号相同。
        System.out.println(Math.tan(90));  //返回角的三角正切。特殊情况是： 如果参数是 NaN 或无穷大，那么结果是 NaN。 如果参数是零，那么结果是零，符号与参数符号相同。
        System.out.println(Math.sqrt(5));  //返回正确舍入的 double 值的正平方根
        System.out.println(Math.cbrt(5));  //返回 double 值的立方根。
        System.out.println(Math.ceil(5.5));  //返回最小的（最接近负无穷大）double 值，该值大于或等于参数，并且等于某个整数。
        System.out.println(Math.floor(5.5));  //返回最大的（最接近正无穷大）double 值，该值小于或等于参数，并且等于某个整数。
        System.out.println(Math.rint(5.5));  //返回其值最接近参数并且是整数的 double 值。如果两个整数的 double 值都同样接近，那么结果取偶数。
        System.out.println(Math.round(5.5));  //返回最接近参数的 int。通过加上 1/2 将该结果舍入为整数，取结果的基数并将其强制转换为 int 类型。
        System.out.println(Math.random());  //返回带正号的 double 值，大于或等于 0.0，小于 1.0。返回值是一个伪随机 (pseudorandomly) 选择的数，在上述范围内（大致）均匀分布。 
        System.out.println(Math.max(5, 9));  //返回两个 值中较大的一个。
        System.out.println(Math.min(5, 9));  //返回两个 值中较小的一个。






 




java.util 
类 Random


java.lang.Object
  


继承者 


java.util.Random



所有已实现的接口：
Serializable
直接已知子类：
SecureRandom


public class Randomextends Objectimplements Serializable




此类的实例用于生成伪随机数流。此类使用 48 位的种子，使用线性同余公式对其进行修改（请参阅 Donald Knuth 的《The Art of Computer Programming, Volume 2》，第 3.2.1 节）。




 很多应用程序会发现 Math 类中的 random 方法更易于使用。


简单应用例子：




        System.out.println(r.nextBoolean());//生成一个随机的布尔值
        System.out.println(r.nextInt());//生成一个随机的整数
        System.out.println(r.nextInt(10));//生成一个随机10以内的整数
        System.out.println(r.nextInt(10)+5);//生成一个随机5~14的整数 






java.sql 
类 Date


java.lang.Object
  


继承者 


java.util.Date
      


继承者 


java.sql.Date



所有已实现的接口：
Serializable, Cloneable, Comparable<Date>


public class Dateextends Date




 


一个包装了毫秒值的瘦包装器 (thin wrapper)，它允许 JDBC 将毫秒值标识为 SQL DATE 值。毫秒值表示自 1970 年 1 月 1 日 00:00:00 GMT 以来经过的毫秒数。




 




java.text 
类 SimpleDateFormat


java.lang.Object
  


继承者 


java.text.Format
      


继承者 


java.text.DateFormat
          


继承者 


java.text.SimpleDateFormat



所有已实现的接口：
Serializable, Cloneable


public class SimpleDateFormatextends DateFormat




SimpleDateFormat 是一个以与语言环境相关的方式来格式化和分析日期的具体类。它允许进行格式化（日期 -> 文本）、分析（文本 -> 日期）和规范化。


SimpleDateFormat 使得可以选择任何用户定义的日期-时间格式的模式






import java.text.SimpleDateFormat;
import java.util.Date;

public class DateTest {
    public static void main(String[] args) {
        Date d=new Date();
        System.out.println(d);
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println(sdf.format(d));
    }
}








java.util 
类 UUID


java.lang.Object
  


继承者 


java.util.UUID



所有已实现的接口：
Serializable, Comparable<UUID>


public final class UUIDextends Objectimplements Serializable, Comparable<UUID>




表示通用惟一标识符 (UUID) 的类。 UUID 表示一个 128 位的值。


这些全局标识符具有不同的变体。此类的方法用于操作 Leach-Salz 变体，不过构造方法允许创建任何 UUID 变体。






import java.util.UUID;
public class UuidTest {
    public static void main(String[] args) {
                //静态，不能实例化    
        System.out.println(UUID.randomUUID());
    }
}








java.io 
类 File


java.lang.Object
  


继承者 


java.io.File



所有已实现的接口：
Serializable, Comparable<File>


public class Fileextends Objectimplements Serializable, Comparable<File>




文件和目录路径名的抽象表示形式。


用户界面和操作系统使用与系统相关的路径名字符串 来命名文件和目录。此类呈现分层路径名的一个抽象的、与系统无关的视图。抽象路径名 有两个组件：


    

  1. 一个可选的与系统有关的前缀 字符串，比如盘符，"/" 表示 UNIX 中的根目录，"\\\\" 表示 Microsoft Windows UNC 路径名，以及
    2. 

  2. 零个或更多字符串名称 的序列。
    3. 



除了最后一个，抽象路径名中的每个名称代表一个目录；最后一个名称既可以代表目录，也可以代表文件。空的 抽象路径名没有前缀和名称序列。 




File类常用方法




import java.io.File;

public class FileTest {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        File f=new File("C:\\Users\\Administrator\\Desktop\\Z1");
        System.out.println(f.exists());//测试路径或目录是否存在
        f.isDirectory();//测试此抽象路径名表示的文件是否是一个目录
        f.isFile();//测试此抽象路径名表示的文件是否是一个标准文件
        f.getAbsolutePath();//返回抽象路径名的绝对路径名字符串
        f.list();//返回由此抽象路径名所表示的目录中的文件和目录的名称所组成字符串数组
        f.lastModified();//返回此抽象路径名表示的文件最后一次被修改的时间
        f.toString();//返回此抽象路径名的路径名字符串
        f.isAbsolute();//测试此抽象路径名是否为绝对路径名
        f.getPath();//将此抽象路径名转换为一个路径名字符串
    }
}




 






            

            
posted @ 
2017-07-22 18:12 
谁将新樽辞旧月，今月曾经照古人 
阅读(400) 
评论(0) 
编辑 
收藏 
举报