主要内容：

String类
- 字符串构造器的用法
- String中的常用方法
- String类源代码
- String字符串各种拼接方式的效率比较
包装类
日期Date
- Date方法
- - getTime
- 日期格式化
- - 日期转字符串
  - 字符串转日期
枚举类（Enumeration）

String类

字符创的常见方式：
String常量池：
在JVM内存中，有这样一个结构：
在这个结构中可以保留程序之前用过的所有字符串（常量）
当需要再次使用内容相同的字符串的时候，JVM默认从这个结构中获取一个与其内容相同的String常量对象
这种结构称之为String（字符串）的常量池

字符串构造器的用法

public class TestStringCreate {public static void main(String[] args) throws UnsupportedEncodingException {//1.直接通过自动建包创建字符串对象String str1 = "abc";//2.new一个字符串：通过String类的构造器创建字符串对象String str2 = new String("abc");//3.String类的空构造：空字符串：""String str3 = new String();System.out.println(str3);//4.char(16) = 2byte(8)String str4 = "小哥哥真是帅";  //UTF-8byte[] b = str4.getBytes();  //UTF-8String str5 = new String(b, "ISO-8859-1");System.out.println(str5);  //IOS-8859-1 --> 乱码//5.将字符数组中的所有文字拼接为一个字符串char[] chArray = new char[] {'a', 'b', 'c', 'd', 'e'};String str6 = new String(chArray);System.out.println(str6);String str7 = new String(chArray, 3, 2);  //deSystem.out.println(str7);System.out.println((char)20013);System.out.println("bcd");//变个戏法String str8 = new String("abc123");String str9 = new String("abc123");System.out.println(str8 == str9);}
}

String中的常用方法

public class TestStringMethods {public static void main(String[] args) {String str1 = "abcdefghijklmn";String str2 = "ABC";String str3 = "abc";System.out.println(str1.charAt(6));  //制定一个下标位，返回这个下标对应的字符串中的字符/** 这个方法返回的是两个字符串“相减”的结果，* 相减：如果在两个字符串当中，存在不相同的字符，直接返回两个不相同字符的相减的值；* 如果两个字符串中，其中一个是另外一个字符串的子串，而且开头对齐，那么返回的就是两个字符串的长度相减*/System.out.println(str2.compareTo(str3));//在忽略大小写的情况下，执行compareTo方法System.out.println(str2.compareToIgnoreCase(str3));  String str4 = "fgh";//判断参数是否是调用者的子串System.out.println(str1.contains(str4)); //返回两个字符串是否内容相同System.out.println(str2.equals(str3));  //Vc1D ==> vc1d ==> true,  Vc1D ==> VC1D ==> true//在忽略大小写的前提下，比较两个字符串的内容System.out.println(str2.equalsIgnoreCase(str3)); String str5 = "老白XXX.avi";//判断字符串是否已特定后缀为结尾System.out.println(str5.endsWith(".rmvb")); //判断字符串是否以特定前缀为开头System.out.println(str5.startsWith("白")); String str6 = "abcaadsfaccdaaa";//返回当前字符串中，目标字符第一次出现的下标位System.out.println(str6.indexOf('a'));  //从指定的下标位开始进行检索，查找目标字符第一次出现的下标位System.out.println(str6.indexOf('c', 2));  //返回子串在目标字符串中，第一次出现的下标System.out.println(str6.indexOf("ar"));  //从指定下标位开始，向后检索子串第一次出现在目标串中的下标System.out.println(str6.indexOf("aa", 5));  //返回当前字符在目标字符串中最后一次出现的位置System.out.println(str6.lastIndexOf('a'));  //从指定的下标向前，检索目标字符出现的最后一个下标System.out.println(str6.lastIndexOf('c', 11));  //返回子串在目标串当中最后一次出现的下标System.out.println(str6.lastIndexOf("aa"));  //从指定下标开始向前检索，检索目标子串出现的最后一次的下标System.out.println(str6.lastIndexOf("aa", 10));  String str7 = "小姐姐XXX.avi.torrent";//获取这个文件的真正的文件类型System.out.println("文件类型：" + str7.substring(str7.lastIndexOf('.')));//从指定的beginIndex开始，向后截取子串，一致到原始串的结尾为止System.out.println(str1.substring(4));  //从指定的beginIndex（包含）开始，截取字符串到endIndex（不包含）System.out.println(str1.substring(7, 14));  //返回当前字符串的字符数量System.out.println(str1.length());  String str8 = "abc";System.out.println(str8.isEmpty());//一般判断一个字符串是否可以被使用的方式：if(str8 != null && !str8.isEmpty()) {System.out.println("str8是可以使用的");}//将一个字符串中所有的指定的原始字符，使用心得指定字符进行替换System.out.println(str6.replace('a', '_'));  String str9 = "abcghabcjkababc"//将指定的原始字符串用指定的新字符串进行替换System.out.println(str9.replace("abc", "xxx")); //将一个字符串转换为一个字符数组char[] chArray = str9.toCharArray();  for (char c : chArray) {System.out.print(c + ",");}System.out.println(); String str10 = "abc,bcde,g,hijkl,mnbvc";//按照指定的分隔符，将字符串切分成字符串数组String[] array = str10.split(",");  for (String string : array) {System.out.println(string);}String str11 = "  abc vbn  ";//删除字符串中的前后空格，但是中间空格将会被保留System.out.println(str11.trim());  String str12 = "aBcDeFg";//将当前字符串中所有大写字母转为小写字母System.out.println(str12.toLowerCase());  //将当前字符串中所有小写字母转为大写字母System.out.println(str12.toUpperCase());  int i = 300;System.out.println("" + i + 10)System.out.println(String.valueOf(300) + 20);}
}

String类源代码

String类的核心源代码：

private final char value[];

char[] value使用final修饰，而且没有被赋初值，这个value还是一个对象属性
所以：

String的构造方法比较复杂：
一个属性如果使用final修饰，就必须具有初值
如果没有初值的话，这个类中所有的构造方法就必须都带有为这个属性赋初值的过程
String内容不可变：
final修饰的引用变量，其中保存的内存地址是不能够改变的
数组这种结构，在内存中是定长且连续的，导致一个数组其长度是不能改变的，导致一个String对象被创建之后，其内容不可能被改变

上述各种原因，总和起来，可以得到如下结论：
在使用+进行字符串拼接的过程中，JVM一致在为我们重新new String类型的中间对象，new对象的过程时极其耗费时间和空间的。
所以，字符串通过+拼接，效率是极低的

String字符串各种拼接方式的效率比较

使用+进行字符串拼接：
因为在内存中，这种拼接方式要不断的开辟空间
所以浪费时间和空间
导致效率低下
concat拼接：
从源码角度来开，过程和+拼接一样
但是执行顺序有所不同：
+拼接是先new String，根据拼接结果改变这个String中数组的大小
concat：是先整理最终内容对应的字符数组，在根据这个数组去创建新的String对象
所以，concat效率稍微高一些
StringBuffer中的append()拼接：
StringBuffer的用法和String类似，但是结构和String完全不同：
1、StringBuffer中用来存储字符的char[]不使用final修饰，所以在拼接的过程中避免了重新new StringBuffer对象的过程
2、在进行append拼接的时候，StringBuffer中的char[]不是每一次都会被填满，没有填满char[]的拼接，是不会导致重新开辟char[]空间的，时间被节省了。
但是，StringBuffer是线程安全（Thread-safe）的，相较于线程不安全的就够，效率相对较低
StringBuilder中的append()拼接：
StringBuilder的用法和结构都是和StringBuffer相似的
但是StringBuilder线程不安全，所以效率相对较高

实验描述：
使用+拼接字符串：10W次
使用concat拼接字符串：10W次
使用StringBuffer拼接字符串：10000W次
使用StringBuilder拼接字符串：10000W次

包装类

Java中的数据类型：
基本数据类型分为：

数值型和整型：byte short int long char
浮点型：float double
布尔型：boolean

引用数据类型：
基本数据类型的作用和弊端：

作用：基本数据类型只能够用来存值
弊端：基本数据类型，没有属性和方法

Java中的包装类就是基本数据类型的升级版，在保存值的前提下，还提供了常用的属性和方法

包装类的应用：

//通过一个现有的整数值来创建一个Integer对象Integer i1 = new Integer(300);  System.out.println(i1);//通过一个符合数字结构的字符串，创建一个Integer类型的对象Integer i2 = new Integer("-300");  System.out.println(i2);//parseXXX方法，能够将字符串转换为相应类型的基本数据类型值int i3 = Integer.parseInt("123");  System.out.println(i3 + 10);//当传递给parseBoolean一个不是真值的字符串（"true"|"false"）的时候，我们统一返回falseboolean b1 = Boolean.parseBoolean("abc");  System.out.println(b1);System.out.println(Integer.MAX_VALUE);System.out.println(Integer.MIN_VALUE);//1 int = 4 byteSystem.out.println(Integer.BYTES);  //返回一个int有多少个2进制位System.out.println(Integer.SIZE);  //0000 0101System.out.println(Integer.toBinaryString(-5));  System.out.println(Integer.toHexString(15));System.out.println(Integer.toOctalString(16));

自动建包/拆包

自动建包：系统自动帮助程序完成new Integer这样的流程，而不是手动完成
自动拆包：系统会自动将包装类对象中存储的数字值当做一个int性的整数进行四则运算

日期Date

日期Date类有两构造方法可供使用：

Date object = new Date();
Date object = new Date(long date);

无参构造：

使用分配时间（到最近的毫秒）创建一个新的Date对象

有参构造：

创建一个新的Date对象，其时间设置为自“the epoch”（1970年1月1日00:00:00 GMT）以来的毫秒数

在内部，Java Date对象表示为long;它是自特定时间（称为纪元）以来的毫秒数。原始的Java Date类具有处理时区等的方法，但这些方法已被弃用，以支持当时新的Calendar类。
Date类要想使用首先要进行导包：

import java.util.Date;

导包的时候要注意：
Date包有两个，一个是util包下的，一个是sql包下的。

Date方法

getTime

getTime() ：获取一个时间的毫秒数，返回一个long型的整数。

ate d1 = new Date();  //代表当前时间
Long time = d1.getTime(); //当前时间毫秒数
System.out.println("当前时间：" + d1); //输出结果为Thu May 17 11:57:49 CST 2018 表示现在是2018年5月17日11:57:49
System.out.println("当前时间毫秒数：" + time); //输出结果为1526529469712 ，表示从1970年1月1日8点至现在经过了1526529469712毫秒

还有一个方法与getTime的作用是一样的 -> System.currentTimeMillis();

举例说明：
下面通过一个实例来理解上面的概念：
借助随机数，创建一个从1995.1.1 00:00:00 到 1995.12.31 23:59:59 之间的随机日期

//第一步，计算1995年的毫秒数
long second = 1000; //一秒为1000毫秒
long min = second * 60; //一分钟
long hour = min * 60;//一小時
long day = hour * 24;//一天
long year = day * 365;//一年
long leapday = (1995-1970)/4 * day; //每隔四年就有一個闰日
long eightHour = 8 * hour; //1997年8点才是真正开始时间，所以要算1995年1月1日0点得减去8个小時
long _1995Start = year * (1995-1970) + leapday - eightHour; //1995年的毫秒数（从1970年算起）
System.out.println("1995年的第一天：" + new Date(_1995Start));
System.out.println("1995年的最后一天：" + new Date(_1995Start+year-1));
//第二步，定义一个随机时间
long randomTime = (long)(Math.random() * (year-1) + _1995Start);
Date randomDate = new Date(randomTime);
System.out.println("1995年里的随机一天：" + randomDate);Date d1 = new Date();  //代表当前时间
Long time = d1.getTime(); //从1970年1月1日 早上8点0分0秒 开始经历了5000毫秒（也就是5秒）的时间
System.out.println("当前时间：" + d1);
System.out.println("当前时间毫秒数：" + time);

运行结果如下：

日期格式化

上面的例子直接打印对象，会看到 “Wed Sep 20 02:54:59 CST 1995” 这样的格式，可读性比较差，为了获得“1995/9/20 02:54:59”这样的格式，就要将日期进行格式化。

日期转字符串

SimpleDateFormat sdf =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS" );
Date d= new Date();
String str = sdf.format(d);
System.out.println("当前时间通过 yyyy-MM-dd HH:mm:ss SSS 格式化后的输出: "+str);

输出结果：当前时间通过 yyyy-MM-dd HH:mm:ss SSS 格式化后的输出: 2019-11-30 19:01:42 224

字符串转日期

模式（yyyy/MM/dd HH:mm:ss）需要和字符串格式保持一致，如果不一样就会抛出解析异常ParseException

SimpleDateFormat sdf =new SimpleDateFormat("yyyy/MM/dd HH:mm:ss" );
String str = "2019/11/30 19:01:42";try {Date d = sdf.parse(str);
System.out.printf("字符串 %s 通过格式  yyyy/MM/dd HH:mm:ss %n转换为日期对象: %s",str,d.toString());
} catch (ParseException e) {// TODO Auto-generated catch block
e.printStackTrace();
}

需要注意的是：
在我们使用parse()这个方法的时候，需要注意的是String str = "2019/11/30 19:01:42";的格式一定要是正确的，而且和SimpleDateFormat sdf =new SimpleDateFormat("yyyy/MM/dd HH:mm:ss" );一致，否则运行时会报异常，一个改，另一个也要去修改。

枚举类（Enumeration）

一般的类：

实例化对象的数量是没有上限要求的，通过new关键字可以随意实例化

枚举类：

枚举类的对象数量是一定的，不能随意new对象

枚举类的定义：

public enum Season {//枚举类的对象直接可以当做枚举类的常量类属性使用Spring("春雨惊春青谷天"), Summer("夏满芒夏暑相连"), Fall("秋处露秋寒霜降"), Winter("冬雪雪冬小大寒");private String desc;  //对季节的描述，一个对象属性private Season(String desc) {  //注意：枚举类的构造器，访问权限只能是privatethis.desc = desc;}
}

枚举类的应用：

//[1]枚举类的常见方法
//从枚举类当中获取枚举对象
Season s1 = Season.Spring;  //直接通过枚举类的类名，就能够获取枚举对象
System.out.println(s1);
Season s2 = Season.valueOf("Summer");  //通过枚举类对象的对象名字符串，获取枚举对象
System.out.println(s2);
Season[] values = Season.values();  //获取当前枚举类当中所有的枚举类对象for (Season season : values) {System.out.println(season);
}Season s3 = Season.Winter;int result = s3.compareTo(s2);  //比较两个枚举对象的定义顺序，返回的是两个枚举对象定义顺序的减法差，枚举对象的定义顺序从0开始
System.out.println(result);
System.out.println(s1.name());  //返回当前枚举对象名字的String字符串格式
System.out.println(s3.ordinal());  //返回当前枚举对象在枚举类当中的定义位置//[2]在switch中使用枚举对象
Season s4 = Season.Fall;
switch (s4) {  //判别的依然是枚举类对象的引用变量case Spring:  //case中对应的直接解释枚举类的对象System.out.println("春暖花开");break;case Summer:System.out.println("夏日炎炎");break;case Fall:System.out.println("秋高气爽");break;case Winter:System.out.println("冬天很冷");break;
}

JAVA的String、StringBuilder、StringBuffer、包装类、日期Date类、枚举类（Enumeration）相关推荐

Java 集合 --- String, StringBuilder, StringBuffer
Java 集合 --- String, StringBuilder, StringBuffer String String的声明方式 String的不可变性对比两个String StringBuil ...
String StringBuilder StringBuffer 包装类 Date 类枚举类
String,StringBuilder,StringBuffer直接的区别是: String 不可变长的字符序列 StringBuilder 可变长的字符序列,线程不安全的,效率较高 StringB ...
Java回顾-String/StringBuilder/StringBuffer
一.String的特点 1.String类代表字符串.Java 程序中的所有字符串字面值(如 "abc" )都作为此类的实例实现. 2.String是一个final类,代表不可变字 ...
Java中String、StringBuffer、StringBuilder的区别
Java中String.StringBuffer.StringBuilder是编程中经常使用的字符串类,他们之间的区别也是经常在面试中会问到的问题.现在总结一下,看看他们的不同与相同. 1.可变与不可 ...
Java基础知识（JAVA中String、StringBuffer、StringBuilder类的区别）
java中String.StringBuffer.StringBuilder是编程中经常使用的字符串类,他们之间的区别也是经常在面试中会问到的问题.现在总结一下,看看他们的不同与相同. 1.可变与不可 ...
String StringBuilder StringBuffer三者之间的区别~~~
String StringBuilder StringBuffer三者之间的区别~~~ String是字符串常量,它是典型的immutable类,被声明final class,所有的属性都是fina ...
String ,StringBuilder,StringBuffer的区分
String ,StringBuilder,StringBuffer的区分一.区别 String是字符串常量,而StringBuffer和StringBuilder是字符串变量.由String创建的 ...
String,Stringbuilder,Stringbuffer及正则表达式
掌握String StringBuilder StringBuffer类的区别一.String String是不可变类,一旦String对象被创建之后,包含对象中的字符串序列都是不可改变的,直到类被 ...
Java中String，StringBuffer都是final类
Java中String和StringBuffer同时final类,它们的区别在哪里 ? final 表示这个类不能再被继承.String不可变是说String中用一个final 的char数组priv ...
java中拼接和的区别_浅析Java中String与StringBuffer拼接的区别
学习笔记: 1.String拼接会创建一个新的String对象,存储拼接后的字符串: StringBuffer拼接是直接在本身拼接,会即时刷新. 2.String只能拼接String类型的字符串: S ...

JAVA的String、StringBuilder、StringBuffer、包装类、日期Date类、枚举类（Enumeration）