转载

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折
说给你听

本文目录
随机标签
书籍教程
springboot-demo Java入门教程 bootstrap3 CSS Apache基础教程 php ionic 教程 Python mysql教程 eclipse Ubuntu VPS系统配置 AngularJS 教程 MongoDB教程 Struts2教程 Redis教程 Spring教程 Git教程 Jenkins进阶系列 openfire参考指南 Java设计模式 HBase教程 java-demo Maven教程 springcloud-demo hibernate教程 Docker 教程 memcached教程 Quartz指南 Hive教程 ANTLR教程 SpringCloud Ant教程 java实例教程 Hazelcast教程 XStream教程 Elastic-Job-Lite 深入浅出MyBatis ibaties教程 SVN教程 rabittmq教程 Hadoop教程 solr教程 WebService CXF学习 JPA教程 ActiveMQ中文指南 Java内存模型 dubbo教程 python3-demo Linux入门视频教程
近期评论
  1. 1 使用 Docker 打包和运行 Vue 应用
  2. 2 Dependency Check命令行方式扫描jar包的安全漏洞
  3. 3 maven使用Dependency-Check来扫描安全漏洞
  4. 4 使用sonarqube分析代码质量
  5. 5 使用screw来对比数据库表和字段差异
  6. 6 Spring Boot 实现防盗链功能
  7. 7 在Spring Boot中的实现国际化（i18n）
  8. 8 一个用于 SMB/CIFS 网络的 Java 库-JCIFS
  9. 9 Spring Boot 3.x嵌入MongoDB 进行测试
  10. 10 java如何解析和生成yaml文件？
网站信息
  • 文章总数：82,737 篇
  • 文件总数：284,312 个
  • 标签总数：2,416 个
  • 分类总数：85 个
  • 留言数量：2,559 条
  • 在线人数：685 人
  • 运行天数：4,439天
  • 最后更新：2024年12月22日17点
Loading...

其他链接

关于本站

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

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

问题交流

[HBLOG]公众号 HBLOG HBLOG