• Java 类类型之 String 类型


    类类型

    引用数据类型存的都是地址,通过地址指向对象;

    基本数据类型存的都是具体值;

    字符串 (String) 类型

    • 特点:

      1、字符创都是对象;

      2、一旦初始化,不能被更改,字符串缓冲区支持可变的字符串,因为 String 对象是不可变的,所以可以共享;

      3、共享;

      eg:

    public class Demo06 {

    public static void main(String[] args) {

    String str = "abcd";

    System.out.println("str = " + str);

    str = "wxyz";

    System.out.println("str = " + str);

    String str1 = "啵斯喵";
    String str2 = "啵斯喵";

    System.out.println(str1 == str2);
    /*重点:
    这里比较的是地址,第一次创建 "啵斯喵" 后创建地址,之后创建先查看缓冲区种有没有 "啵斯喵"
     创建规则:
    有则创建的变量指向此地址,没有则重新在缓冲区中创建该字符

    */
    }

    }

     

    若使用 new 关键字,则比较会出现不同情况

    public class Demo07 {

    public static void main(String[] args) {

    String str1 = "abcd";
    String str2 = new String("abcd");

    System.out.println(str1 == str2); //flase
        // == 比较的是两个字符串的地址,故结果为 false
    System.out.println(str1.equals(str2)); //true
        // equals 方法比较的是两个字符串的值,故结果为true
        // 由上可得:
        // 字符串 String 类中重写了 equals方法;

    }

    }

     

    字符串和 new 字符串的区别:

    package Demo;

    public class Demo08 {

    public static void main(String[] args) {

    String str1 = "abc";
    String str2 = new String("abd");

    System.out.println(str1.hashCode());
    System.out.println(str2.hashCode());

    }

    }
    • 字符串创建过程:

      • 字符串 str1 没有通过 new 关键字创建,则主方法压栈后,在方法区中的常量池中创建常量,主方法中的 String 变量 str1 指向常量池中的地址;

      • 字符串 str2 通过 new 关键字创建,则主方法压栈后,在方法区中的常量池中创建常量后,在堆中通过 new 关键字来创建 str2 ,并由 str2 指向常量池中的常量,在主方法中,则创建的字符串变量 str2 指向堆中开辟的空间的地址;

    • String 类的常用基本方法

    public class Demo09 {

    public static void main(String[] args) {
    /* 字符串类的方法:
    * 1.有多少个字符(长度)
    * 2.获取字符在字符串中第一次出现的位置
    * 3.获取所需位置上的字符
    * 4.获取部分字符串
    * 5.将指定字符串替换成另一个字符串
    * 6.将字符串转换成字节数组或字符数组
    * 7.字符大小写互相转换
    * 8.将字符串按照指定方式分割成多个字符串
    * 9.字符的比较
    */
    String str = "abcderfgabcdersholgpqweiop";

    //1.获取字符串长度
    int length;
    length = str.length();
    System.out.println("字符串的长度为:" + length);
    System.out.println("-----------------------------------------");

    //2.获取字符在字符串中第一次出现的位置
    int index;
    index = str.indexOf('e');
    System.out.println("字符串中字符 e 出现的位置为:" + index);


    //实例:遍历字符串,找到字符串中出现的指定字符的所有位置;
    /*注意:indexOf方法,寻找字符串中从 index+1 开始寻找下一次字符 ‘e’ 出现的位置,
      查找到最后一个位置后,再查找下一次返回的值就为 -1 ;*/
    while(index != -1){
    System.out.println(index);
    index = str.indexOf('e', index+1);
    }
    System.out.println("-----------------------------------------");

    //3.获取所需位置上的字符
    //注意:String 中字符的位置都是从零开始
    char i ;
    i = str.charAt(2);
    System.out.println("字符串中第 2 个字符是:" + i);
    System.out.println("-----------------------------------------");

    //4.获取部分字符串
    /*方法:substring(int start,int end);
     * 方法传入两个参数,字符串的开始下标和结束下标-1,包含头不包含尾
     *
     * 方法:substring(int start);
     * 方法传入一个参数,从字符串中的start中开始截取字符,直到字符串截取结束
     * */
    String temp1,temp2;
    temp1 = str.substring(3, 5);
    System.out.println(temp1);
    temp2 = str.substring(10);
    System.out.println(temp2);
    System.out.println("-----------------------------------------");

    boolean aa ;
    aa = str.contains("abc");
    System.out.println(aa);
    System.out.println("-----------------------------------------");

    //5.将指定字符串替换成另一个字符串
    String temp;
    temp = str.replace("abc", "xyz");
    System.out.println(temp);
    System.out.println("2-----------------------------------------");

    //6.1将字符串转为字符数组
    char []ch = str.toCharArray();
    //6.2将字符串转为字节数组
    byte []by = str.getBytes();
    for(int y = 0; y < ch.length; y++) {
    System.out.println(ch[y]);
    }
    System.out.println("-----------------------------------------");
    for(int y = 0; y < by.length; y++) {
    System.out.println(by[y]);
    }
    System.out.println("-----------------------------------------");


    //7.1将字符串中的所有字符转为大写
    String strtemp ;
    strtemp = str.toUpperCase();
    System.out.println(strtemp);
    System.out.println("-----------------------------------------");

    //7.2将字符串中的所有字符转为小写
    String strtem ;
    strtem = str.toLowerCase();
    System.out.println(strtem);
    System.out.println("-----------------------------------------");

    //8.将字符串按照指定方式分割成多个字符串
    String []st = str.split("a");
    for(int j = 0; j < st.length; j++) {
    System.out.println(st[j]);
    }
    System.out.println("-----------------------------------------");


    //9.字符的比较
    /*
     *方法:compare str1.compare(Str2);
     * 方法返回结果为 str1 中第一个位置上的字符减去 str2 中第一个位置上的字符;
     * 若第一个位置上的字符相同,则比较第二个位置上的字符,以此类推;若 str2 的字符包含 str1 则返回 -1
     */
    String a = "a";
    String b = "b";

    String c = "abc";
    String d = "vwx";
    String e = "qwertyu";
    String f = "mnbvcxz";
    System.out.println(a.compareTo(b));
    System.out.println(c.compareTo(d));
    System.out.println(e.compareTo(f));
    }

    }

     

    Stringbuffer 和StringBuilder

    • 特点:

      • 字符串缓冲区(容器)

      • 长度可变

      • 可存储任意数据类型,内部先将数据转成字符串再存储

    Stringbuffer

    • 常用基本方法

      • 构造方法

        public class Demo10 {

        public static void main(String[] args) {
        //创建Stringbuffer对象
        StringBuffer Strb1 = new StringBuffer();
        StringBuffer Strb2 = new StringBuffer(5);
        /* 使用构造函数方法重载
        * Strb1 使用无参构造方法,创建初始容量为 16 的对象;
        * Strb2 使用有参(int型)构造方法,创建初始容量为 5 的对象;
        * StringBuffer 若创建的字符串缓冲区长度不够,则自动增加原来一倍的长度
        * 详情转至 java-api 查询
        */
        Strb1.append("helloword");
        Strb1.append(true);
        Strb1.append(1314);

        Strb2.append("HELLO");

        System.out.println(Strb1);
        System.out.println(Strb2);

        }

        }
      • 基本方法

        public class Demo08 {

        public static void main(String[] args) {
        //创建Stringbuffer对象
        StringBuffer strb = new StringBuffer("啵斯喵hello");

        strb.insert(3,"小哥哥");

        System.out.println(strb); //啵斯喵小哥哥hello

        //删除数据
        strb.delete(3,6);
        System.out.println(strb); //啵斯喵hello

        //修改数据
        strb.replace(3, 8, "你好");
        System.out.println(strb);

        //总结:字符的添加删除,字符位置都是左闭右开

        }

        }

         

    Stringbuilder

    • 方法与 StringBeffer 相通

    StringBuffer 与 StringBuilder的异同

     StringBufferStringBuilder
    有无锁 有锁 无锁
    安全性 安全 不安全
    效率 效率低 效率高

     

    基本数据类型和类类型的转换

    • 八种基本数据类型与其对象类

    基本数据类型范围默认值包装类
    byte -27 ~ 27-1 0 Byte
    shot -215 ~ 215-1 0 Short
    float 1.4013E-45~3.4028E+38 0.0F Float
    boolean true 、false false Boolean
    char 0 ~ 216-1 'u0000' Character
    int -231 ~ 231-1 0 Integer
    double 4.9E-324~1.7977E+308 0.0D Double
    long -263 ~ 263-1 0 Long
    • 基本数据类型 与 类类型 的转换

     public class Demo11 {
      public static void main(String[] args) {
     // 定义基本数据类型
      char ch = 'a';
      float fo = 1;
      double bl = 520;
      int xt = 1314;
      boolean bb = true;
      byte bt = 10;
      short sh = 11;
      long ll = 5201314;
     
     // 基本数据类型 转为 类类型
      Character ca = Character.valueOf(ch);
      Float fa = Float.valueOf(fo);
      Double du = Double.valueOf(bl);
      Integer it = Integer.valueOf(xt);
      Boolean bo = Boolean.valueOf(bb);
      Byte be = Byte.valueOf(bt);
      Short so = Short.valueOf(sh);
      Long ln = Long.valueOf(ll);
     
      System.out.println(ca);
      System.out.println(fa);
      System.out.println(du);
      System.out.println(it);
      System.out.println(bo);
      System.out.println(be);
      System.out.println(so);
      System.out.println(ln);
     
     // 类类型 转为 基本数据类型
      char cr = ca.charValue();
      float ft = fa.floatValue();
      double dl = du.doubleValue();
      int ii = it.intValue();
      boolean bn = bo.booleanValue();
      byte bd = be.byteValue();
      short st = so.shortValue();
      long lg = ln.longValue();
     
      System.out.println(cr);
      System.out.println(ft);
      System.out.println(dl);
      System.out.println(ii);
      System.out.println(bn);
      System.out.println(bd);
      System.out.println(st);
      System.out.println(lg);
      /*虽然打印输出一样,但是类类型的对象可以进行类操作*/
      }
     
     }
    • String 字符串类型的转换

     import java.nio.charset.Charset;
     
     public class Demo11 {
      public static void main(String[] args) {
      //1. String 类型转成 int 类型
      System.out.println("99" + 1);
      int a = Integer.parseInt("99")+1;
      System.out.println(a);
      System.out.println("-------------------");
             
      //2. int 类型转成 String 类型
      System.out.println( 11 + 11 );
      System.out.println( 11 + "" + 11); //不推荐使用,非专业
      String str1 = String.valueOf(11); //1.转为 String 类型
      System.out.println(str1 + str1);
      String str2 = Integer.toString(11); //2.转为 String 类型
      System.out.println(str2 + str2);
      System.out.println();
     
      }
     
     }

     

    • 包装类 的装箱和拆箱

     //类包装
     public class Demo11 {
      public static void main(String[] args) {
      int a = 9;
      //包装对象
      Integer i = new Integer(a);
     
      // jdk1.1 之后,简化书写 把 int 类型数据转换为 integer 对象
      Integer j = a;
      //内部实现
      Integer value = Integer.valueOf(a);
     
     
      j = j + 1;
      //1.因为是做加法运算,所以第一步会将 对象 转为 数值 ----> 自动拆箱 int temp = j.parserint();
      //2.转为基本数值 j = 9 + 1 结果为 10;
      //3. j 是 Integer 类型,所以赋值之后要自动装箱
     // int b = j.intValue() + 1;
     // Integer.valueOf(b);
     
      System.out.println("================");
      //拓展 :
     // 在自动装箱的时候,如果给的数值在 byte 范围内(-128 到 127),不会创建新内存空间而是使用原来已有的空间
      Integer c = new Integer(8);
      Integer d = new Integer(8);
      System.out.println(c == d); //false
      System.out.println(c.equals(d)); //true
     
      Integer e = 127;
      Integer f = 127;
      System.out.println(e == f); //true
      System.out.println(e.equals(f)); //true
     
      Integer g = 128;
      Integer h = 128;
      System.out.println(g == h); //false
      System.out.println(g.equals(h)); //true
     
      }
     
     }
     

     

    日期时间类

    • 日期时间类

      • 从 jdk 1.1 开始,定义好的 Date 类便由需求的问题,拆分为日期类(Calendar)和时间类(Dateformat)

     

     import java.text.DateFormat;
     import java.text.ParseException;
     import java.text.SimpleDateFormat;
     import java.util.Calendar;
     import java.util.Date;
     
     /* 日期类
      * 1、日期转成字符串
      * 2、字符串转成日期
      * 3、SimpleDateFormat 什么时候用
      * 4、Calendar 什么时候用
      * */
     
     public class Demo12 {
      public static void main(String[] args) throws ParseException {
      //获取毫秒值(最小单位:毫秒) 从 1970 年 1 页 1 日开始
      long time = System.currentTimeMillis();
      System.out.println(time);
      //根据毫秒值获取对象
      Date d = new Date(time);
     
      System.out.println(d); //Sat Apr 25 10:46:53 CST 2020
      System.out.println(d.getYear()); //120
      System.out.println(d.getMonth()); //3
      System.out.println(d.getDay()); //6
      System.out.println(d.getDate()); //25
     
     
      //日期类对象转为字符串
     
     // 获取日期字符串拥有的风格:FULL、LONG、MEDIUM 和 SHORT
     // 如何使用对应的风格? 在getDateInstances 方法中传入对应的参数
     
      //获取日期
      DateFormat df1 = DateFormat.getDateInstance(DateFormat.SHORT);
      String format = df1.format(d);
      System.out.println(format);
      /* FULL : 2020年4月25日 星期六
      * LONG : 2020年4月25日
      * MEDIUM : 2020-4-25
      * SHORT : 20-4-25
      * */
     
      //获取时间
      DateFormat df2 = DateFormat.getTimeInstance();
      String format2 = df2.format(d);
      System.out.println(format2);System.out.println("---------------");
     
      //获取日期时间
      DateFormat df3 = DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.FULL);
      String format3 = df3.format(d);
      System.out.println(format3); //2020年4月25日 星期六 上午11时16分22秒 CST
     
     
      // 日期类
      Calendar c = Calendar.getInstance();
      System.out.println(c);
      /* java.util.GregorianCalendar[time=1587784918491,areFieldsSet=true,
      * areAllFieldsSet=true,lenient=true,
      * zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,
      * useDaylight=false,transitions=19,lastRule=null],firstDayOfWeek=1,
      * minimalDaysInFirstWeek=1,ERA=1,YEAR=2020,MONTH=3,WEEK_OF_YEAR=17,
      * WEEK_OF_MONTH=4,DAY_OF_MONTH=25,DAY_OF_YEAR=116,DAY_OF_WEEK=7,
      * DAY_OF_WEEK_IN_MONTH=4,AM_PM=0,HOUR=11,HOUR_OF_DAY=11,MINUTE=21,SECOND=58,
      * MILLISECOND=491,ZONE_OFFSET=28800000,DST_OFFSET=0]
      * */
     // 键值对
      System.out.println(c.get(Calendar.DATE));
      System.out.println(c.get(Calendar.YEAR));
      System.out.println(c.get(Calendar.DAY_OF_MONTH));
      System.out.println(c.get(Calendar.DAY_OF_WEEK));
     
      //字符串转日期类对象
      String time0 = "2020-04-25";
     
      //字符串的日期风格想要和 DateFormat 相对应才可以进行转换,否则抛出异常;
      //如果写的字符串和四种风格不对应,可以使用自定义风格来进行转换
      DateFormat df0 = DateFormat.getDateInstance();
      Date dt = df0.parse(time0);
      System.out.println("=========================");
      System.out.println(dt); //Sat Apr 25 00:00:00 CST 2020
     
      //自定义风格
      String dates = "2020-4-25 12:14:52";
      //给定自定义风格
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:Mm:ss");
      Date ddtt = sdf.parse(dates);
     System.out.println(ddtt);//Sat Apr 25 00:14:52 CST 2020 
    }  
    }

     

     

    每个NB的人物背后都有一段苦B的岁月,只要像SB一样坚持,就能变得NB
  • 相关阅读:
    python list间的并集、差集与交集
    kafka常用命令,启动/停止/查看主题列表/消费/生产
    python json
    lrzsz
    HashMap实现原理,源码分析
    Java中try catch finally语句中含有return语句的执行情况
    Maven
    我的面试题
    JSON数据格式
    springMVC2
  • 原文地址:https://www.cnblogs.com/liangls/p/12753688.html
Copyright © 2020-2023  润新知