主要内容：

String类字符串构造器的用法String中的常用方法String类源代码String字符串各种拼接方式的效率比较包装类日期DateDate方法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(pareTo(str3));//在忽略大小写的情况下，执行compareTo方法System.out.println(pareToIgnoreCase(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 表示现在是5月17日11:57:49System.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 格式化后的输出: -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 = "/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 blocke.printStackTrace();}

需要注意的是：

在我们使用parse()这个方法的时候，需要注意的是String str = "/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 = pareTo(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;}