13.String、StingBuffer、StringBudder、Date、

String的使用

package com.atguigu.java;

import org.junit.Test;

public class StringTest {
 /*
     String :字符串，使用一对""来表示
        1.声明为final的，不可被继承
        2.实现了Serializable接口（可序列化）：表示字符串是支持序列化的
           实现了Comparable接口：可以比较大小
        3.String定义了final char[] value 用于存储字符串数组
        4.String：代表不可变的字符序列，简称不可变性
           体现：1.当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有value进行赋值
                   当对现有字符串进行连接操作时，也需要进行重新指定内存区域赋值
                   当调用String的replace()方法修改指定字符或字符串时，也需要进行重新指定内存区域赋值
        5.通过字面量的方式（区别于new）给一个字符串赋值，此时字符串值声明在方法区的常量池中，
          字符串常量池中是不会存储相同的内容。
*/
    @Test
    public void test1(){
        String s1 = "abc";//字面量的定义方式
        String s2 = "abc";
        System.out.println(s1 == s2);//true：比较s1和s2的地址值
        s2 = "hello";
        System.out.println(s1 == s2);//false：

        System.out.println("**********");
        String s3 = "abc";
        s3 +="def";
        System.out.println(s3);//abcefg
        System.out.println(s1);//abc

        System.out.println("**********");
        String s4 = "abc";
        String s5 = s4.replace('a','b');
        System.out.println(s4);//abc
        System.out.println(s5);//bbc
    }
/*
    String的实例化方式：
     方式一：通过字面量定义的方式
     方式二：通过new + 构造器的方式
*/
    @Test
    public void test2(){
        //此时的s1 和s2的数据声明在方法区中的字符串常量池中
        String s1 = "java1";
        String s2 = "java1";
        //通过new + 构造器的方式：此时的s3 和s4保存的地址值，是数据在堆空间中开辟空间以后，对应的地址值
        String s3 = new String("java1");
        String s4 = new String("java1");

        System.out.println(s1 == s2);//true
        System.out.println(s1 == s3);//false
        System.out.println(s3 == s4);//false

    }
/*结论：
    常量与常量的拼接结果在常量池，且常量池中不会存在相同内容的常量
    只要其中有一个是变量，结果就在堆中
    如果拼接的结果调用intern()方法，返回值就在常量中
*/
    @Test
    public void test3(){
        String s1 = "abc";
        String s2 = "def";
        String s3 = "abc" + "def";
        String s4 = "abc"+s2;
        String s5 = s1+s2;
        String s6 = "abcdef";
        System.out.println(s3 == s6);//true
        System.out.println(s3 == s4);//false
        System.out.println(s3 == s5);//false

        String s7 = s5.intern();
        System.out.println(s7 == s3);//true
    }

}

String常用方法

package com.atguigu.java;

import org.junit.Test;

import java.util.Arrays;
/*String中常用方法
      length()：返回字符串的长度
      char charAt(int index): 返回某索引出的字符
      bool isEmpty(): 判断是否是空字符串
      String tolowerCase(): 将String中的所有字符转化为小写
      String toUpperCase(): 将String中的所有字符转化为大写
      String trim(): 返回字符串的副本，忽略前导空白和尾部空白
      boolean equals(Object obj) : 比较两个字符串的内容
      boolean equalsIgnoreCase(String anotherString): 与equals方法类似，忽略大小写
      String concat(String str)：将指定字符串连接到此字符串的尾部，等价于用“+”
      int compareTo(String anotherString): 比较两个字符串的的大小
      String substring(int beginIndex): 返回一个新的字符串，是此字符串的从beginIndex位置开始的子字符串
      String substring(int beginIndex, int endIndex):返回一个新的字符串，是此字符串的从beginIndex到endIndex之前位置开始的子字符串

    boolean endWith(String suffix):测试字符串是否以指定的后缀结束
    boolean startWith(String prefix):测试字符串是否以指定的前缀开始
    boolean startWhit(String prefix,int toffset):测试此字符串从指定索引开始的子字符串是否以指定字符开始

    boolean contains(charsequence s):当前字符串中是否包含指定字符串
    int indexOf(String str):出现str的第一次的位置
    int indexOf(String str,int fromIndex): 从指定位置开始，第一次出现str的位置
    int LastIndexOf(String str):从后往前找，第一次找到str的位置
    int LastIndexOf(String str,fromIndex):从指定位置开始，从后往前找，第一次找到dtr的位置
    注：indexOf和LastIndexOf方法如果为找到都是返回-1

    String replace(char oldchar,char newchar):将一个字符，换成另一个字符
    string replace(charsequance target,charSequence replace)：将一个字符串替换成另一个字符串
    String replaceAll(String regex,String replacement):使用给定的replacement替换此字符串所匹配给定的正则表达式的子字符串
    String replaceFirst(String regex,String replacement):使用给定的replacement替换此字符串所匹配给定的正则表达式的第一个子字符串

    boolean matchs(String regex):告知此字符串是否匹配给定的正则表达式

    String[] split(String regex):根据给定正则表达式的匹配拆分此字符串
    String[] split(string regex,int limit)：根据匹配给定的正则表达式，来拆分字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中
 */
public class StringMethodTest {
    @Test
    public void test1() {
        String s1 = "abcdefg";
        System.out.println(s1.length());//7
        System.out.println(s1.charAt(0));//a
        System.out.println(s1.isEmpty());//false
        //s1 = "";
        //System.out.println(s1.isEmpty());//true 判断数组长度
        String s2 = s1.toUpperCase();
        System.out.println(s1);//abcdefg s1不可变，仍然为原来的字符串
        System.out.println(s2);//ABCDEFG

    }
    @Test
/*
     String 与char[] 之间的转换
     String ----> char[] : 调用String的toCharArray()
     char() ----> String :嗲用String的构造器
*/
    public void test2(){
      String str1 = "abc123";
        char[] chararray = str1.toCharArray();
        for(int i = 0; i < chararray.length;i++){
            System.out.println(chararray[i]);
        }
        char[] arr = new char[] {'a','b','c'};
        String str2 = new String(arr);
        System.out.println(str2);
    }
    @Test
/*
    与字节数组byte[]的转换
    编码：String ----> byte[]: 调用 String的getByte()方法
    解码：byte[] ----> String : 仍然调用String的构造器
 */
    public void test3(){
        String str = "abc123";
        byte[] bytes = str.getBytes();
        System.out.println(Arrays.toString(bytes));//[97, 98, 99, 49, 50, 51]

        byte[] bytes1 = new byte[]{46,47,48,49};
        System.out.println(new String(bytes1));//./01
    }
}

关于StringBuffer和StringBuilder的使用

package com.atguigu.java;
/*
     关于StringBuffer和 StringBudder的使用

     String、StringBuffer和StringBudder三者的区别：
     String ：不可变的字符序列,使用char[]数组存储

     StringBuffer：可变的字符序列,未使用final修饰的char[]数组存储
                   线程安全，效率偏低

     StringBudder：可变的字符序列,未使用final修饰的char[]数组存储
                   线程不安全，效率较高

     源码分析：
     String str = new String()//new char[0];
     String str = new String(3)//new char[]{'a','b','c'};

     StringBuffer sb1 = new StringBuffer();//new char[16] 创建一个长度为16的数组
     sb.append('a')//value[0] = 'a';

     StringBuffer s1 = new StringBuffer("abc");//char[] value = new char[abc.length()+16]

    扩容问题：
         StringBuffer/StringudderB如果要添加的数据底层数组盛不下来，那就需要扩容，
     默认情况下，扩容为原来的 2倍+2，同时将原有的数值赋值到新的数组

    在开发中建议：StringBufffer(int capacity)或 StringBuddder（int capacity）构造器，（指定底层数组长度的构造器）
 */

import org.junit.Test;

public class StringBufferBudderTest {
    @Test
    public void test1(){
        StringBuffer sb1 = new StringBuffer("abc");
        sb1.setCharAt(0,'m');
        System.out.println(sb1);//mbc
    }
    @Test
/*
StringBuffer(StringBudder)常用方法:
    StringBuffer append(xxx):
    StringBuffer delete(int start,int end)
    StringBuffer replace(int start,int end,String str)
    Stringbuffer insert(int offset,xxx)
    StringBuffer reverse()

    public int indexOf(String str): 返回str在StringBuffer中首次出现的位置
    public String subString(int start,int end)：返回从Start到end的子字符串
    public int length()：返回长度
    public char charAt(int n)：返回某索引n处的字符
    public void setCharAt(int n,char ch)：将指定索引n处的字符修改成ch

   效率：StringBudder>StringBuffer>string
 */
    public void test2(){
        StringBuffer s1 = new StringBuffer();
        s1.append("abc");
        s1.append("123");
        System.out.println(s1);//abc123
        s1.delete(2,3);
        System.out.println(s1);//ab123
        s1.replace(2,3,"cd");
        System.out.println(s1);//abcd23
        s1.insert(3,"ab");
        System.out.println(s1);//abcabd23
        s1.reverse();
        System.out.println(s1);//32dbacba
    }
}

时间API

package com.atguigu.java;

import org.junit.Test;

import java.util.Date;

/*
  JDK8.0之前 日期和时间的API测试

 */
public class DateTimeTest {
    //1.System类中的currentTimeMillis():
        //时间戳：返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差
    @Test
    public void test1(){
        long time = System.currentTimeMillis();
        System.out.println(time);
    }
/*
    Java.util.Date类
         |----Java.sql.Date类：对应数据库中的日期

  Java.util.Date：
   1.两个构造器的使用
      构造器一：Date()：创建一个对应当前时间的Date对象
      构造器二：Date(long time):创建指定毫秒数的Date对象
   2.两个方法的使用
     toString():显示当前的年、月、日、时、分、秒
     getTime(): 获取当前对象的时间戳
     
sql下的Date：对应着数据库中的日期类型的变量
  >实例化：java.sql.Date date = new java.sql.Date(时间戳)
         >sql.Date--->util.Date 直接转（多态）
         >util.Date--->sql.Date
     Date date1 = new Date();
     java.sql.Date  date2 = new java.sql.Date(date1.getTime())
*/
    @Test
    public void test2(){
        //构造器一：Date()：创建一个对应当前时间的Date对象
        Date date1 = new Date();
        System.out.println(date1.toString());//Mon Apr 12 08:55:19 CST 2021
        System.out.println(date1.getTime());//1618189024338

        //构造器二：Date()
        Date date2 = new Date(1618189024338L);
        System.out.println(date2.toString());//Mon Apr 12 08:57:04 CST 2021
    }
}

SimpleDateFormat

package com.atguigu.java1;

import org.junit.Test;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

/*
    JDK 8 之前的时间的API测试
    1.System类中的currentTimeMillis()
    2 Java.Util.Date 和其子类 Java.sql.Date
    3.SimpleDateFormat
    4.Calender
 */
public class DateTimeTest {
 /*
    SimpleDateFormat的使用:SimpleDateFormat对日期Date类的格式化和解析
    1.两个操作：
      1.1  格式化： 日期--->字符串
      1.2   解析： 格式化的逆过程，字符串 --->日期

    2.实例化

  */
    @Test
    public void test1() throws ParseException {
        //实例化SimpleDateFormat:使用默认的构造器
        SimpleDateFormat sdf = new SimpleDateFormat();
        //格式化：日期 --> 字符串
        Date date = new Date();
        System.out.println(date);//Tue Apr 13 08:51:42 CST 2021

        String format = sdf.format(date);
        System.out.println(format);//2021/4/13 上午8:52

        //解析：字符串 --> 日期
        String str = "";
        String s = "2021/4/13 上午8:52";
        Date date1 = sdf.parse(s);
        System.out.println(date1);//Tue Apr 13 08:52:00 CST 2021
        //**********************************************
        //使用指定方式进行格式化：调用带参的构造器
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh.mm.ss");
        String format1 = sdf1.format(date);
        System.out.println(format1);//2021-04-13 09.05.29
        //解析: 要求字符串必须是符合SimpleDateFormat识别的格式（通过构造器的形参体现），否则会抛异常UnParseException
        Date date2 = sdf1.parse(format1);
        System.out.println(date2);//Tue Apr 13 09:08:14 CST 2021
    }
/*
        Calendar 日历类（抽象类）的使用
        1.实例化
        //方式一：创建其子类（GregorianCalendar）的对象
        //方式二：调用其静态方法getInstance() ：一般用方式二造对象


*/
    @Test
    public void test2(){
        //1.实例化
        Calendar calendar = Calendar.getInstance();
        //2.常用方法
        //get()
        int days = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(days);//18  当前月的第几天
        //set()
        calendar.set(Calendar.DAY_OF_MONTH,22);
        days = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(days);//22 将该对象内部结构改变
        //add()
       calendar.add(Calendar.DAY_OF_MONTH,3);
       days = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(days);//25

        //getTime():日历类 --->Date类
        Date date = calendar.getTime();
        System.out.println(date);//Sun Apr 25 16:41:06 CST 2021

        //setTime(): Date类 ---> 日历类
        Date date1 = new Date();
        calendar.setTime(date1);
        System.out.println(calendar.get(Calendar.DAY_OF_MONTH));//18
    }
}

package com.atguigu.java1;

import org.junit.Test;

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.time.temporal.TemporalAccessor;

public class JDK8DateTime {
/*
   LocalDate、LocalTime、LocalDateTime
   说明：LocalDateTime使用频率高

 */
    @Test
    public void Test1(){
        //实例化
        //方式一：now(): 获取当前的日期、时间、日期时间
        LocalDate localDate = LocalDate.now();
        System.out.println(localDate);//2021-04-18

        LocalTime localTime = LocalTime.now();
        System.out.println(localTime);//17:12:23.736841400

        LocalDateTime localDateTime = LocalDateTime.now();
        System.out.println(localDateTime);//2021-04-18T17:13:07.051375100

        //方式二：of():指定的年月日，没有偏移量
        LocalDateTime localDateTime1 = LocalDateTime.of(2021, 4, 18, 17, 18);
        System.out.println(localDateTime1);//2021-04-18T17:18

        //getXxx()
        //getDayOfMonth:当前月的第几天
        //getMonth():当前月
        //getMonthValue()：当前月对应的数值
        int dayOfMonth = localDateTime.getDayOfMonth();
        System.out.println(dayOfMonth);//18
        System.out.println(localDateTime.getDayOfWeek());//SUNDAY
        System.out.println(localDateTime.getDayOfYear());//108
        System.out.println(localDateTime.getMonth());//APRIL
        System.out.println(localDateTime.getMonthValue());//4

        //withXxx()
        LocalDateTime localDateTime2 = localDateTime.withDayOfMonth(22);
        System.out.println(localDateTime);//2021-04-18T17:34:20.206150900
        System.out.println(localDateTime2);//2021-04-22T17:34:20.206150900

        //plusXxx():加
        LocalDateTime localDateTime3 = localDateTime.plusMonths(3);
        System.out.println(localDateTime3);//2021-07-18T21:43:40.274083100

        //minusXxx():减
        LocalDateTime localDateTime4 = localDateTime.minusMonths(1);
        System.out.println(localDateTime4);//2021-03-18T21:45:31.148271800
    }
/*
     instant的使用
 */
    @Test
    public void DateTimeTest2(){
        //实例化：方法一:now
        Instant instant = Instant.now();
        System.out.println(instant);//2021-04-18T13:54:29.665579200Z  本初子午线上的时间
        //添加时间的偏移量
        OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
        System.out.println(offsetDateTime);//2021-04-18T21:57:26.462558500+08:00
        //获取自1970开始的毫秒数
        long epochMilli = instant.toEpochMilli();
        System.out.println(epochMilli);//1618754398902
    }

/*
    DateTimeFormatter:格式化或解析日期、时间
    类似于SimpleDateFormat
 */
    @Test
    public void test3(){
        /*实例化：
            方式1：预定义的标准格式：如ISO_LOCAL_DATE_TIME
            方式2：本地化相关的格式：ofLocalizedDateTime(FormatStyle long)
            常用方式3：自定义格式，：ofPattern("yyyy-MM-dd hh:mm:ss ")
         */
        DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
        //格式化:  日期 --> 字符串
        LocalDateTime localDateTime = LocalDateTime.now();
        String s1= formatter.format(localDateTime);
        System.out.println(localDateTime);//2021-04-19T09:02:24.640111500
        System.out.println(s1);//2021-04-19T09:02:24.6401115
        //解析 ： String ----》日期
        TemporalAccessor parse = formatter.parse("2021-04-19T09:02:24.6401115");
        System.out.println(parse);//{},ISO resolved to 2021-04-19T09:02:24.640111500


        //方式二
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT);
        String s2 = dateTimeFormatter.format(localDateTime);
        System.out.println(s2);//2021/4/20 下午11:52

        //方式三：自定义格式 常用该方式
        DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
        //格式化
        String format = dateTimeFormatter1.format(localDateTime.now());
        System.out.println(format);//2021-04-21 07:24:00
        //解析
        TemporalAccessor parse1 = dateTimeFormatter1.parse("2021-04-21 07:24:00");
        System.out.println(parse1);//{NanoOfSecond=0, MicroOfSecond=0, MinuteOfHour=24, SecondOfMinute=0, HourOfAmPm=7, MilliOfSecond=0},ISO resolved to 2021-04-21
    }
}

Comparable 和 Comparator

package com.atguigu.java1;
/*
  商品类
 */
public class Goods implements Comparable{
    private String name;
    private double price;

    public Goods(){

    }
    public Goods(String name,double price){
        this.name = name;
        this.price = price;
    }
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    public double getPrice(){
        return price;
    }
    public void setPrice(double price){
        this.price = price;
    }

    @Override
    public String toString() {
        return "Goods{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
//指明商品比较大小的方式：按照价格从低到高
    @Override
    public int compareTo(Object o) {
        if(o instanceof Goods){
            Goods goods = (Goods)o;
            if(this.price > goods.price){
                return 1;
            }else if(this.price < goods.price){
                return -1;
            }else{
                return 0;
            }
        }
        throw new RuntimeException("传入的数据类型不一致");
    }
}

package com.atguigu.java1;

import org.junit.Test;

import java.util.Arrays;
import java.util.Comparator;

/*
对多个对象进行比较大小、排序：使用两个接口comparable、comparator
一：comparable接口的使用： 自然排序
    1.像String、包装类等实现了comparable接口，重写了compareTo()方法，给出了比较两个对象大小的方法
    2.重写compareTo(obj)的规则：
       如果当前对象this大于形参对象obj，则返回正整数
       如果当前对象this小于形参对象obj，则返回负整数
       如果当前对象this等于形参对象obj，则返回零
3.对于自定义类来说，如果需要排序，可以让自定义类实现comparable接口，重写compareTo(),并指明如何排序
 */
public class CompareTest {
    @Test
    public void test1(){
        String[] str1 = new String[]{"gg","jj","dd","mm","aa"};
        Arrays.sort(str1);
        System.out.println(Arrays.toString(str1));//[aa, dd, gg, jj, mm]
    }

    @Test
    public void test2(){
        Goods[] arr = new Goods[4];
        arr[0] =new Goods("lenoveMouse",34);
        arr[1] =new Goods("dellMouse",43);
        arr[2] =new Goods("miMouse",12);
        arr[3] =new Goods("huaweiMouse",65);

        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        //[Goods{name='miMouse', price=12.0}, Goods{name='lenoveMouse', price=34.0}, Goods{name='dellMouse', price=43.0}, Goods{name='huaweiMouse', price=65.0}]
    }

/*
    Comparator接口的使用：定制排序
    1.使用背景 ：当元素类型没有实现Comparable接口而又不方便修改代码
              或者实现了Comparable接口的排序规则不适合当前的操作，可以考虑Comparator

    2.重写compare(Object obj1,Object obj2)方法
       如果返回正整数，obj1大
       如果返回负整数，obj1小
       如果返回0，obj1，obj2 大小相等
*/
    @Test
    public void test3(){
        String[] str1 = new String[]{"gg","jj","dd","mm","aa"};
        Arrays.sort(str1, new Comparator(){
            //按照字符串从大到小排序
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof String && o2 instanceof  String){
                    String o11 = (String) o1;
                    String o22 = (String) o2;
                    return -o22.compareTo(o11);
                }
                throw new RuntimeException("输入法的类型错误");
            }
        });
        System.out.println(Arrays.toString(str1));//[aa, dd, gg, jj, mm]
    }

/*
comparable与comparator比较
     comparable接口的方式一旦一定，保证comparable接口实现类的对象在任何位置都可以比较大小
     comparator接口属于临时性的比较（匿名对象）
*/
}