java之旅 （第九天） String类型 String工具类 stringBuffer类 Integer包装类 bigDecimal类 data_DateFormat类 正则表达式

String类：
    1.public final class String  字符串不可改变
    2.字符串如果是变量进行相加，是先开辟，然后进行拼接
      字符串如果是常量进行相加，是先相加，然后去字符串自      己常量池去查找，如果有就返回，如果没有就创建
    注：
    1.每个字符串创建时就会被分配空间
    2.字符串一旦赋值，其值不能改变，如果进行字符串的追    加，则代表一个新的空间产生
    3.字符串变量相加产生的地址是垃圾地址，用一次过后，由    于没有引用，会被回收。因此就算常量相加后，也在常量池    不找这个垃圾地址
    4.常量相加：先拼接，再找，有就返回，无就创建
      变量相加：先开个房，再拼接（每次都会创建一个空间）
      最好不要进行字符串拼接，很容易挤爆内存！！（对象）

 

    3.String s = new String("hello")  String s = "hello";
      String s = new String("hello")会创建两个对象
      String s = "hello";只会创建一个对象
    注：
     String(String original) 
      初始化一个新创建的 String 对象，使其表示一个与参数相     同的字符序列；
      换句话说，新创建的字符串是该参数字符串的副本。
    

 

String工具类:
    1.public boolean equals(Object anObject) 区分大小写
      public boolean equalsIgnoreCase(String s）不大小写 
    
    2.public boolean contains(CharSequence s):判断该字符      串当中是否包含指定字符串
    举例：
        System.out.println(s1.contains("hello"));
        System.out.println(s1.contains("hw"));
        
    3.public boolean startsWith(String prefix):判断该字符      串是否以指定字符串开头    
      public boolean endsWith(String prefix):判断该字符      串是否以指定字符串结尾                       
    举例：
        System.out.println(s1.startsWith("s"));

    4.  isEmpty()：判断字符串是否为空
    举例：
        System.out.println(s1.isEmpty());
    
    5.public char charAt(int index)：返回指定索引的           char，指数范围从 0 到 length() - 1
    举例：
    需求:统计一个字符串当中的大写字母数量，小写字母数量,    数字的数量。
    取出字符串当中每一个字符
    把一个字符串当中的首字母转换大写，其余小写(只考虑英文)
 
public class StringDemo05 {
    public static void main(String[] args) {
        String s = "asd151sdAFSA2D1Fsddffor";
        //定义三个统计变量
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;

        char ch ；
        for(int x = 0;x < s.length();x++) {
            ch= s.charAt(x);
            if(ch >= 'a' && ch <='z') {
                smallCount++;
            }else if (ch >= 'A' && ch <='Z') {
                bigCount++;
            }else if (ch >= '0' && ch <='9') {
                numberCount++;    
            }
        }
    }
    注：
    1.String内部用来存储的结果是一个char字符数组。
    private final char value[];//这是string中用来存储值    的结构。

    6.public String substring(int beginIndex)：返回一个字      符串。子字符串从指定索引处的字符和延伸到这个字符串      的末尾。 
      public String substring(int beginIndex， int             endIndex)：返回一个字符串，子字符串从指定的           beginIndex延伸在指数 endIndex - 1特征（切记很多都是      到到所给长度-1，并且，字符串在底层就是数组形式，可      以通过索引来操作）
      举例：
      String s = "hjadjkasd";
      String s1 = s.substring(0, 1);

    7.public String toUpperCase()：转换为大写
      public String toLowerCase()：转换为小写
      举例：
      String s2 = s1.toUpperCase();
      String s4 = s3.toLowerCase();
    
    8.public String concat(String str)：将指定的字符串，      添加到字符串的末尾。 如果参数字符串的长度是0，那么      返回拼接的String对象。

 

Integer:
    1.为了对基本数据类型提供更多的操作，Java为一种基本数      据类型都提供了对应的包装类(包装类类型)

         byte         Btye      float     Float
         short      Short      double      Double
        int        Integer     char    Character
        long      Long        boolean   Boolean
         
    举例：
            Integer.MAX_VALUE    int类型的最大值
        Integer.MIN_VALUE     int类型的最小值     
        public static final int  (静态final)  写好的

    2.Integer(int value) 
    构造一个新分配的 Integer 对象，它表示指定的 int 值。 

    Integer(String s) 
    构造一个新分配的 Integer 对象，它表示 String 参数所指    示的 int 值。
    注意:这里的内容必须是整数数字，而不能是字符串类型
    举例：    
        int i = 100;
        Integer i1 = new Integer(i);
        
        String s = "100";
        Integer i2 = new  Integer(s);
    
    3.整数变String类型：
    int number = 100;
        //方式1
        String s = ""+number;
        System.out.println(s);
        //方式2
        String s1 = String.valueOf(number);
        System.out.println(s1);
        注：valueOf是把很多类型转化为String类型
        //方式3
        Integer i = new Integer(number);
        String s2 = i.toString();
        System.out.println(s2);
        注：toString是把Integer类型转化为String类型
        //方式4
        String s3 = Integer.toString(number);
        System.out.println(s3);
    
    4.String类型转化为整数类型:
        String str2 = "30";
        Integer i2 = new Integer(str2);
        int x = i2;
        注：Integer类型就像是int过渡，但是Intege类型必        须得由Intege类型接收再赋值给Int类型
        
    5.JDK5的新特性:
     自动装箱:把基本数据类型转换为包装数据类型
     自动拆箱:把包装数据类型自动转换为基本数据类型

     举例：Integer i = new Integer(100)
          Integer i = 500;Integer i =                         Integer.valueOf(500); //自动装箱
          int x = i + 200; //int x = i.intValue() +               200;//自动拆箱
    
    6.   Integer i1 = new Integer(127);
        Integer i2 = new Integer(127);
        System.out.println(i1 == i2); //false
        System.out.println(i1.equals(i2));//true

        Integer i7 = Integer.valueOf(12);
        Integer i8 = 12;
        System.out.println(i7 == i8);//装箱 拆箱
        System.out.println(i7.equals(i8));//true
        //通过源码我们发现，如果你的数据在-128~127的数据        范围，这些数据存放在缓冲区（同一个位置），否则创        建新的空间

 

stringBuffer:
    字符串的内容一旦被创建也就意味着无法进行改变，如果我    们将它进行改变则会创建一个新的字符串对象
     如果需要对字符串进行频繁的改变，我们就应该使用字符串    缓冲区类
    StringBuffer(字符串缓冲区类):线程安全的可变字符序列。
    
    StringBuffer方法:
         public int capacity():返回的是总容量
         public int length():返回的是已用容量
     
    举例：
        StringBuffer sb = new StringBuffer("toobug");
        System.out.println(sb);
        System.out.println(sb.capacity()); //22
        System.out.println(sb.length());//6
                                    
        StringBuffer sb1 = new StringBuffer();
        System.out.println(sb1);//（输出一个占位符)
        System.out.println(sb1.capacity());//16
        System.out.println(sb1.length());//0
    注：
        1.StringBuffer默认开16个长度的空间（底层也是数        组），只有在初始化时会根据给的字符串加长度，其他        时候不变（若超出长度，就成倍增加）

    增:
        StringBuffer("toobug");
        sb.append("好啊");      //在字符串后面加
        sb.insert(1, "笨笨的");//从指定位置插入

    删:
        sb.delete(1,4); 从指定位置开始到指定位置结束的删        除 结束长度为end-1  //截取都是最终长度-1
        sb.deleteCharAt(5);根据索引位置删除指定字符

    改:
        sb.replace(0, 5, "JAVA好");从指定索引开始，到指        定索引-1结束，替换指定内容(替换范围也是end-1)
        sb.setCharAt(1, '好');根据指定索引，替换字符内容

    查:
        sb.toString():打印出sb的字符串内容（转为String）
        sb.indexOf("t"):查找该字符在字符中首次的索引位置
        sb.substring(0, 3):从指定索引开始到指定索引结            束，结束对应的字符串内容（end-1）

    注：StringBuffer是在缓冲区，速度快很多
        //算时间
        long startTime = System.currentTimeMillis();
        /*String s = "你好";
        for (int i = 0; i < 100000; i++) {
            s+="你好"+i;
        }*/
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < 100000; i++) {
            sb.append("你好"+i);
        }
        //算时间
        long endTime = System.currentTimeMillis();
        System.out.println("共耗时:"+(endTime-                startTime));
        //共耗时:614
        //共耗时:20（单位毫秒）

    补充：
    1.String/StringBuffer/StringBuilder三个的区别?
       a.String是一个不可变的字符序列，而                      StringBuffer/StringBuilder是可变的字符序列
       b.StringBuffer是同步，所以效率低，但是数据安全
       而StringBuilder不是同步的，所以他的效率更快，但是数      据是不安全的
             
     2.StringBuffer底层还是来维护一个数组，那么他和数组的    区别是什么？
       StringBuffer,是不是只能存储一个字符序列的内容？
      而数组是可以存储多个类型的容器，但是必须是同一种数据       类型

 

bigDecimal:
    我们在进行浮点数计算的时候，发现你们的答案都算错了，
    为什么呢？因为我们的CPU对浮点数运算无法进行精确，容易    丢失精度，数据越广 精度丢失越大
    这种问题不是语言的问题，而是CPU本身就没有高精度计算的    能力(太湖神光除外、神威)中国的超级计算机

    System.out.println(0.090.01);//0.0999999999999999
    System.out.println(1.0 -0.32);//0.679999999999999
    System.out.println(1.015  *     100);//101.49999999999999
    System.out.println(1.301 /     100);//0.013009999999999999
    注：如果是浮点类型，其默认是double类型，需加F或类转
    float a=0.02；//报错
    float a=(float)0.02; //double转float    
    float a= 0.02f;   //定义的时候就是float类型    
    
        //加
        BigDecimal bd1 = new BigDecimal("0.09");
        BigDecimal bd2 = new BigDecimal("0.01");
        System.out.println(bd1.add(bd2));

        //减
        BigDecimal bd3 = new BigDecimal("1.0");
        BigDecimal bd4 = new BigDecimal("0.32");
        System.out.println(bd3.subtract(bd4));

        //乘
        BigDecimal bd5 = new BigDecimal("1.015");
        BigDecimal bd6 = new BigDecimal("100");
        System.out.println(bd5.multiply(bd6));

        //除
        BigDecimal bd7 = new BigDecimal("1.301");
        BigDecimal bd8 = new BigDecimal("100");
        System.out.println(bd7.divide(bd8));
        注：虽然这种精确度高的用得少，但是一旦用了就得会
    

 

data_DateFormat：
     Date:表示特定的瞬时时间,精确到毫秒 
    
    构造方法：（默认为 1970-1-1 8:00）
     Date():根据当前默认的时间格式返回当前时间
     Date(long date):根据给定的毫秒值来创建时间对象

    getTime():获取时间以毫秒为单位    （与默认相减）
    getTime 方法返回一个整数值，这个整数代表了从 1970 年     1 月 1 日开始计算到 Date 对象中的时间之间的毫秒数。
    Date date = new Date();
    long time  = date.getTime();
    System.out.println(time);//返回当前时间的毫秒值 17:05

    SimpleDateFormat：对时间和日期进行解析和格式化，根据                   不同模板返回对应的格式
    
 

举例：
    1.把Date转化为我们想要的格式：

        //创建时间对象
        Date d = new Date();
        获取到当前时间的系统默认格式

        //创建时间格式化对象，并且设定日期格式
      SimpleDateFormat sdf = new  SimpleDateFormat                              ("yyyy-MM-dd HH:mm:ss");      

        y:年   M：月  H：小时（24） h：小时（12） 
        a：上午   p:下午
        格式：yy：年的最后两位
             MM：不超两位数显示0
             M：不超两位数不显示0，超了原样输出
       控制符：   小 大 小 大 小    
                格式一定创建，

        //将指定的Date的对象进行模板格式化
        String s = sdf.format(d);
        System.out.println(s);

    2.把时间转化为Date格式（计算用）
      String string = "1970-7-30 17:13:48";
      SimpleDateFormat sdf1 = new         SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
      Date d1 = sdf1.parse(string);//解析
      System.out.println(d1);

    3.计算时间差（两种）
        //获取毫秒差
      Date date3 =new Date(); //Date的getTime方法
      System.out.println(date3.getTime());
        
     //系统自带的获取毫秒差的方法（与1970相减）
    System.out.println(System.currentTimeMillis())
    
        //时间转化
    String mydate="1998-03-13";
    SimpleDateFormat sdf2=new                                       SimpleDateFormat("yyyy-MM-dd");
    Date d2=sdf2.parse(mydate);    
    long m=d2.getTime();
    long now=System.currentTimeMillis();
    long time=now-m;
    long days=time/1000/60/60/24;
    System.out.println("天数："+days);
    
        注：
        1.Date类型返回系统默认的格式
        2.SimpleDateFormat就是定义格式（正向翻译，反向          翻译都要用）
        3.format():正向翻译，把Date类型转化为String
    （解析）parse（）：反向翻译，把String类型转化为Date
        4.SimpleDateFormat像个翻译规则，其只有规定翻译        规则的功能，而Date类型的.getTime（）能返回毫            秒，这个计算时间差很有用
        5.Date的getTime()方法与系统的                                System.currentTimeMillis()方法都能获取毫秒差
          建议使用系统的，不用创建对象
        6.把两个时间段的时间进行转化（天 分钟），但是原          始数据以毫秒为结果，（1秒=1000毫秒）
        7.计算程序运行时间方法：
        long starTime=System.currentTimeMillis();
        long ebdTime=System.currentTimeMillis();
        计算两个差值，便可得执行时间

     

正则表达式：（字符串）
    public boolean matches(String regex)
    正则表达式:符合一定规则的字符串
    regex：regulation expression
    举例：
    String regex = "[1-9][0-9]{4,14}";
    //String regex="[1-9]\\d{4,14}"
    boolean b = qq.matches(regex);
    注：[1-9]：第一位是1-9的数字
        [0-9]{4,14}:因为第一位已经被固定，至少还需4位数
        在正则表达式里除了转义字符，其他都需要双斜杠

    matches("[1][3578]\\d{9}"）    
    注：[1]表示第一位必须是1（最好把括号写上）
        [3578]表示3 或 5 或 7 或 8
        \\ d{9}:表示还需9位数字