String与StringBuffer、Date日期与SimpleDateFormat 简单的日期格式化

第一：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，因此不能创建，直接类名调用
 }