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

 

 

© 版权声明
THE END
喜欢就支持一下吧!
点赞0
分享