转载

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的异同

StringBuffer StringBuilder
有无锁 有锁 无锁
安全性 安全 不安全
效率 效率低 效率高

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

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

基本数据类型 范围 默认值 包装类
byte -2 7 ~ 2 7 -1 0 Byte
shot -2 15 ~ 2 15 -1 0 Short
float 1.4013E-45~3.4028E+38 0.0F Float
boolean true 、false false Boolean
char 0 ~ 2 16 -1 '/u0000' Character
int -2 31 ~ 2 31 -1 0 Integer
double 4.9E-324~1.7977E+308 0.0D Double
long -2 63 ~ 2 63 -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 
    }    
}
原文  http://www.cnblogs.com/liangls/p/12753688.html
正文到此结束
所属分类： Java 编程技术

热门推荐

相关文章

阿里云首购8折
说给你听

本文目录
随机标签
书籍教程
Java入门教程 bootstrap3 CSS springboot-demo Apache基础教程 php ionic 教程 Python mysql教程 eclipse Ubuntu VPS系统配置 AngularJS 教程 Struts2教程 MongoDB教程 Redis教程 Spring教程 Git教程 Jenkins进阶系列 openfire参考指南 Java设计模式 HBase教程 Maven教程 hibernate教程 Docker 教程 memcached教程 Quartz指南 SpringCloud ANTLR教程 Hive教程 java实例教程 Ant教程 Hazelcast教程 Elastic-Job-Lite XStream教程 深入浅出MyBatis SVN教程 ibaties教程 rabittmq教程 WebService CXF学习 Hadoop教程 solr教程 JPA教程 ActiveMQ中文指南 Java内存模型 dubbo教程 Linux入门视频教程
近期评论
  1. 1 Spring Boot集成Spring Session快速入门Demo
  2. 2 Spring Boot集成RabbitMQ快速入门Demo
  3. 3 Spring Boot集成Quartz快速入门Demo
  4. 4 Spring Boot集成Mybatis Plus快速入门Demo
  5. 5 Spring Boot集成zipkin快速入门Demo
  6. 6 能用365块大洋去解决的事，千万不要用时间
  7. 7 Spring Boot集成atomikos快速入门Demo
  8. 8 Spring Boot集成fastdfs快速入门Demo
  9. 9 Spring Boot集成Https快速入门Demo
  10. 10 Spring Boot集成easypoi快速入门Demo
网站信息
  • 文章总数：155,463 篇
  • 文件总数：468,744 个
  • 标签总数：2,266 个
  • 分类总数：90 个
  • 留言数量：2,542 条
  • 在线人数：685 人
  • 运行天数：4,197天
  • 最后更新：2024年04月24日06点
Loading...

其他链接

关于本站

本站定位：个人技术类博客

本站作用：写博客、记日志、闲聊扯淡鼓捣技术。

问题交流

[HBLOG]公众号 HBLOG HBLOG