第一：String类：字符串常量
1.String是一个类，String是引用数据类型。 String str="abc";这里str可以换成别的，但是“abc”的值不能改变(也就是说该对象的地址可以换，但是该对象的值只有一个不能被改变)，String类的对象表示字符串常量，可以被共享，string对象是最终的。
2.object中的equals方法是比较两个对象的内存地址是否相等，但是这String里为什么是比较两个对象的具体内容是否相等呢？答：因为String类是object类的子类，String类重写了object类的equals方法。object的equals方法和tostring都被下面的子类重写了。equals现在比较的是对象的内容是否相等（不在比较地址了），tostring是输出对象的内容（不在输出地址了）
3.获得字符串类的实例的方式：
---1.String str="hello";这个hello对象被保存到了堆内存中的常量池中。
---2.String str2=new String("hello");其中hello本身是个字符串对象，然后new又是个对象，因此在这里有两个对象。new出来的东西在堆内存中放着，而这个new出来的对象是hello对象的副本。
4.两种创建String类对象的表示方式：
第一种：String str="abc";：将常量保存到常量池（先查看常量池中是否有这个对象，如果没有就保存，如果有就直接调用常量池中的）
解释：这种是声明一个str对象，然后把这个对象里面的值放在常量池中。常量池中的数据是不能改变的，
1).如果想把abc变成abcd，只能是在常量池中在创建一个内存空间，然后放abcd。原来多大abc还在那。这也
就是说string类创建的对象是不能改变的，是最终的，是个常量。
2).若果现在在创建一个对象，string str2="abc"，这时候将不会在常量池中创建abc这个字符串对象，而是直接去常量池中找abc（因为abc已经被str创建了，str2直接用就行了）。
他们的地址是一样的，因为第一次str往常量池中放入了abc,然后abc在常量池中共享了，当执行str2=abc的时候不会在在常量池中创建重新创建一个abc对象了，而是直接用共享的abc。
第二种：String str=new String("abc");：先查看常量池中是否有hello，如果没有hello，将hello这个字符串对象保存在常量池，然后创建hello的副本（也就是在给new开辟一个空间，在创建一个对象）
解释：这种创建方式其实是创建了两次string对象，当中new的时候创建了一次对象，在“abc”的时候又创建
了一次对象（双引号引起来的这个字符串就是一个字符串对象）。（也就是说abc是个对象，而new出来的这个对象只是abc对象的一个副本）。在内存当中，
先在常量池当中创建这个字符串对象，然后这个常量池中的对象在拷贝到堆内存当中。变量str指向堆内存，然后堆内存在指向常量池。
1. String str=new String("wugui");str="wangba"；这是先创建了一个字符串对象，然后 str="wangba"。这时候首先是在常量池中看有没有wugui，如果没有就把wugui放进常量池，然后
将这个值拷贝到堆内存中的对象（现在出现了对象的副本），最后，用str去堆内存中找，堆内存在去常量池中找，最终找到wugui。当执行str="wangba"的时候，
因为常量池中已经存在了str变量的值（也就是wugui），此时会在常量池中在开辟一个空间放wangba。
5.String对象的方法
public static void main(String[] args) {
//String str="hello";//hello是字符串对象,hello是字符串常量不能被改变，但是str可以去引用其他字符串。常量可以被共享。，str是对象的引用。
//str="test";//给str重新赋值了。但是hello对象还在，只是hello对象的引用现在给了test
String str=new String("wugui");
//1.charAt():给定参数（参数是个索引），返回值是这个索引所对应的字符
char ch=str.charAt(0);
System.out.println(ch);//结果：w
//2.concat():连接两个字符串，但是要记住又产生了一个新对象
String str2=str.concat("wangba");
System.out.println(str2);//结果：wuiguiwangba,这是个新的字符串。原来的wuigui这个字符串还在
//3.equals():比较两个字符串的内容是否相等
boolean falg=str.equals(str2);
System.out.println(falg);//结果：两个字符串的内容不相等，返回false
//4.indexof():返回指定字符的位置（索引）（第一次出现时候的索引）
int index=str2.indexOf('g');//这个参数是int值,也就是这个字符的ASTT值
System.out.println(index);//返回值是2
//4.indexof:找g这个字符，从索引为6的位置开始找，如果找不到返回值是-1
int index0=str2.indexOf('g',6);
System.out.println(index0);
//5.lastIndexOf():从后往前找，参数是字符，返回值是int（也就是索引）
int index2=str2.lastIndexOf('g');//这里传入的字符，因此单引号
System.out.println(index2);//返回值是2
//6.length():返回字符串的长度
int len=str2.length();
System.out.println(len);
//7.replace():替换字符，返回值是字符串，有两个参数，第一个参数原来字符，第二个参数是新字符
String str3="你的女朋友是女的";
String str4=str3.replace('女', '男');
System.out.println(str4);//输出结果：你的男朋友是男的
//7.replace():替换字符串
String str5=str3.replace("你的", "他的");
System.out.println(str5);//结果是：他的女朋友是女的
//8.split():分割，按照某种规则分割字符串。返回值是个字符串数组
String str6="create or replace function maxNum(v_num1 in number,v_num2 in number,v_r out number)";
String str7[]=str6.split(" ");//表示用空格来分割，也就是说现在的规则是空格
for(String s: str7){
System.out.println(s);//结果是每个单词组成的数组
}
//9.substring():提取子串。返回一个新字符串，这个新字符串是原来字符串的子字符串
String str8=str3.substring(2, 4);//两个参数是起始位置和结束位置,但是不包含右边。半开半闭的
System.out.println(str8);
//9.
String str08=str3.substring(2);
System.out.println(str08);//这个是从索引为2开始到结束
//10.toCharArray():将字符串转化成字符数组
char[] chs=str3.toCharArray();
for(char c:chs){
System.out.println(c);//结果是该字符串中的每个字符
}
//11.getBytes():将字符串转化成字节数组
String str9="admin";
byte[] bs=str9.getBytes();
for(byte b:bs){
int x=b;//可以先将每个字节转化成int，这样可以获得汉字的编码
System.out.println(x);//将字符串转化成字节数组的时候，其实是转化成了字节的编码
}
//12.注意：toString:转化成字符串。这个是继承了objeect，返回值是个字符串
//13.toUpperCase：将字符串转化成大写.str9.toLowerCase()是转化成小写
String str10=str9.toUpperCase();
System.out.println(str10);
//14trim().去掉收尾空格
String str11=" 小青 ";
String str12=str11.trim();
System.out.println(str12);
//注意：15.valueof：返回值是字符串，参数是任意类型，因此这个方法是把任意类型的数据转化成字符串。注意这个是个静态方法，不用对象调用，用类调用
String str13=String.valueOf(1111);//String表示是字符串类，而str1,str2等都是字符串对象
System.out.println(str13+222);//把整数转化成了字符串，因此这里的结果是1111222
//15.endWith():判断某个字符串是否以指定字符串结尾
String str14="你的性别是女";
boolean flag3=str14.endsWith("女");
System.out.println(flag3);
//16.contains:是否包含
boolean a = str14.contains("你的");
System.out.println(a);
}
第二：StringBuffer字符串变量
StringBuffer是一个长度可变的字符串，能改变内容和长度。因此在StingBuffer中包含好多修改长度的方法。
1.只有一个创建对象的方法：StringBuffer sb=new StringBuffer();
2.当创建对象的时候，创建了一个无参的对象，这时候内存将构造一个不带字符的字符串缓冲区，初始容量为16个字符
3.StringBuffer里面有个char类型的数组（char数组其实就是个字符串），这个数组的默认长度是16，这是初始容量。StringBuffer封装一个字符串对象，这个字符串对象的内容最终封装到这个char类型的数组中了。
4.每个StringBuffer对象都有一个字符数组的属性，这个属性就是StringBuffer的缓冲区，以后的值都放在这个缓冲区里，缓冲区默认大小为16字符
5.StringBuffer改变的是原来的这个对象，而不会在创建一个新的，这是StringBuffer与string的不同
6.StringBuffer类型的数据通过.tostring方法转化成string类型的数据
/**
1. StringBuffer是改变原来字符串对象，因此有append和insert方法
2。StringBuffer有缓冲区，他的内容在这个缓冲区里放着呢，这个缓冲区是个char类型的数组。因此内容最终是保存到char类型的数组中
3.StringBuffer是个可变的字符串变量，记住是个变量，而string是字符串常量
4.StringBuffer能够改变内容和长度。
5.StringBuffer对象都有个字符数组的属性，这个属性就是StringBuffer的缓冲区。
**/
7.StringBuffer的方法
public static void main(String[] args) {
StringBuffer sb=new StringBuffer("create or replace function maxNum");
//1.求出这个对象的长度
int count=sb.length();//初始长度是16，当保存不下的时候就自动伸缩。
System.out.println(count);//输出40
/*//2.给原来的sb对象追加新内容。长度和内容都将发生变化
StringBuffer sb2= sb.append(1111);//追加。追加任何类型的值
System.out.println(sb2);//结果是create or replace function maxNum1111，此时长度变成44*/
//2.1根本不需要创建新对象
sb.append(1111);
System.out.println(sb);//结果是create or replace function maxNum1111*/
//2.2也可以直接追加一个stringbuffer对象
StringBuffer sb2=new StringBuffer("这是sb字符串");
sb.append(sb2);
//3.insert插入，第一个参数表示从哪插入，第二个参数表示要插入的值。记住索引从0开始
sb2.insert(4, "sbsbsbs");
System.out.println(sb2);
//4.replace:替换
sb2.replace(3, 5, "*");//把起始位置是3，结束位置是5，把这里面的内容替换成*
//5.反转
sb2.reverse();
System.out.println(sb2);
//6,去掉空格的尺寸trimToSize
sb2.append(" ");//先给这个对象追加空格
sb2.trimToSize();
sb2.append(1111);
System.out.println(sb2);
//删除.注意都是半包含
sb2.delete(1, 7);//从索引为1开始，到7结束，删除1到7之间的内容
String str=sb.toString();//将StringBuffer转化成string
}
第三：Date
public static void main(String[] args) {
//1.获取系统当前的日期
Date date =new Date();//1.创建日期对象
System.out.println(date);//本类输出的是地址，可是子类从写了object，因此现在输出的是内容
//System.out.println(date.toString());两个等价
SimpleDateFormat sdf=new SimpleDateFormat("YYYY-MM-dd:HH:mm:ss:SS");//2，创建格式化对象，这个参数是parrent类型的，也就是模式的意思
String str=sdf.format(date);//把日期格式化，使用的是format方法，返回string
//2.after。注意date是表示距离1970年1月1日
long l=11100000000000L;//某一个日期从1970年1月1日起经过了这么多毫秒
long l2=date.getTime();//表示当前日期距离1970年1月1日经过了多少毫秒。其中date表示当前日期。gettime表示毫秒
System.out.println(l2);
boolean flag=date.after(new Date(l));//把这个毫秒当做参数，结果是返回这个毫秒所对应的日期
System.out.println(flag);//这里相当于比较l和l2的大小了
//3.befer在...之前，跟上面的一样
//4.Calendar也表示日期，这个是个静态类
//Calendar c=new Calendar();//这个类是受保护的，protected，因此不能创建，直接类名调用
}