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	-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 
    }    
}