Java常用类

目录

1、String类

字符串，“”

String声明为final，不可被继承的

String实现Serializeable接口，支持序列化

String内定义了final char【】  value用于存储 字符串数据，不可被修改，即是不可变的字符序列。

String：代表不可变的字符序列，简称：不可变性

应用

                7.内存解析

  8 .拼接         

9.常用方法

10.String 与char[]的转换

11.String 与字节数组byte[]的转换              

12、类似的类：StringBuffer，StringBuilder

2、日期类

system类中的currentTimemillis（）

java.util.Date类|java.sql.Date

Calendar日历类（抽象类）

jdk8之后的日期时间

3、类的比较

1. 1、String类

   1. 字符串，“”

   2. String声明为final，不可被继承的

   3. String实现Serializeable接口，支持序列化

      1. 实现comparable接口，表示支持比较，可比较的

   4. String内定义了final char【】  value用于存储 字符串数据，不可被修改，即是不可变的字符序列。

   5. String：代表不可变的字符序列，简称：不可变性

      1. 当对字符串重新赋值时，需要重写指定区域赋值，不能在原有的value进行赋值。

      2. 当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能在原本的value赋值

      3. 当调用String的replace（）方法修改字符或字符串时，也必须重新指定内存区域，不可在原有的地方赋值。

   6. 应用

      1. 字面量定义

             String str = " 人间大炮 ";

      2. new 构造器

         String str = new String（）;

                7.内存解析

                        

  8 .拼接         

当调用intern（）方法时，结果在常量池中。只要有一个拼接是变量，则结果就在对堆空间中常量与常量的拼接，结果在常量池之中

9.常用方法

• nt length（）:返回字符串的长度
• char charAt（int index）返回某索引处的字符
• boolean isEmpty（）：判断是否是空字符串
• String toLowerCase（）：将String中的所有字符转换为小写
• String toUpperCase（）：将String中的所有字符转换为大写
• String trim（）：返回字符串的副本，忽略前导空白和尾部空白
• boolean equals(Object obj):比较字符串的内容是否相同
• boolean equalslgnoreCase（String anotherString）：与equals方法类似，忽略大小写。
• String concat（String str）：将指定字符串连接到此字符串的结尾，等价于“+”
• int compareTo（String anotherString）：比较两个字符串的大小
• String substring（int beginindex）：返回一个新的字符，它是此字符串的从beginindex开始截取到最后的一个子字符串
• String substring（int beginIndex ，int endIndex）：截取，从begin到end的字符串，不包含end这个字符，左闭右开。
• boolean endsWith(String suffix) ： 测试此字符串是否以指定的后缀结束
• boolean startsWith(String prefix) ：测试此字符串是否以指定的前缀开始
•  boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的子字符串是否以指定前缀开始
• boolean contains(CharSequence s)：当且仅当此字符串包含指定的 char 值序列时，返回 true
• int indexOf(String str)：返回指定子字符串在此字符串中第一次出现处的索引
•  int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
• int lastIndexOf(String str)：返回指定子字符串在此字符串中最右边出现处的索引
•  int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索，注：indexOf和lastIndexOf方法如果未找到都是返回-1
• String replace(char oldChar, char newChar)：返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
• String replace(CharSequence target, CharSequence replacement)：使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
• String replaceAll(String regex, String replacement) ： 使 用 给 定 的replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
• String replaceFirst(String regex, String replacement) ： 使 用 给 定 的replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
• boolean matches(String regex)：告知此字符串是否匹配给定的正则表达式。
•  String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串。
• String[] split(String regex, int limit)：根据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个素中

10.String 与char[]的转换

• String ==》 char【】调用str.tocharArray()

• char【】 ==》 String 调用String构造器

11.String 与字节数组byte[]的转换              

1. 编码S--》b  ：调用String的getBytes（）。

2. 解码：b  ==》S：调用String构造器，new String（byte【】）

12、类似的类：StringBuffer，StringBuilder

        

2、日期类

• system类中的currentTimemillis（）

• java.util.Date类|java.sql.Date

  • 两个构造器的使用

    • Date（）：创建了一个对应当前时间的Date的对象

  • 构造器二

    • Date（long time（毫秒数））：创建指定毫秒数的Date对象

  • 两个方法的使用

    • toString（）：显示当前的年。月。日。时。分、秒

    • getTime（）；获取当前Date对象对应的毫秒数（时间戳）

  • java.sql.Date,数据库中的日期类型

    • 如何实例化

      • new java.sql.Date()

    • util.Date--》java.sql.Date对象.

      • 使用相同的时间戳进行转换。

• SimpleDataFormat：对日期进行格式化与解析。

  • 操作

    • 格式化 ：日期 ---》字符串

    • 解析：格式化的逆过程，字符串——》日期

  • 步骤

    • 使用默认的构造器SimpleDateFormat实例化

    • 调用有参构造器，在API中找、

Calendar日历类（抽象类）

• 创建子类的对象GregorianCalendar的对象
• 调用其静态方法getInstance（）

• @Test
      public void test(){
          Calendar calendar = new GregorianCalendar();
          System.out.println(calendar.getTimeInMillis());
          Calendar instance = Calendar.getInstance();
          System.out.println(instance.getTimeInMillis());
  
  
      }

  时间戳

• 常用方法
  • get（）
    • calender.get（Calender.xxx）
  • set（Calender.xxx,xxx）
  • add（Calender.xxx,xxx）
  • getTime（）
  • setTime（）

jdk8之后的日期时间

• java.time

• LocalDate,localTime

  • __.now:获得当前的日期、时间、日期+时间

• LocalDateTime

  • of（）：设定指定的年。月。日。时。分。秒。没有偏移量

• getXxx（）

  • 获得某某

• withXxx（）

  • 相当于设置相关的属性

  • 设置某某，但不能改原本的，只能获得一个新的返回值，

• 三者都体现了不可变性

• plusXxx()加操作

• Xxx（）减操作

• Instant

  • 类似于java，util，Date

  • .now（）：获取当前0时区的时间

  • atOffset：添加时间的偏移量

  • .toEpochMilli()获取距离1970年1月1日0时0分0秒（UTC）开始的毫秒数

  • .OfEpochNilli():通过给定的毫秒数，获取Instant实例

• DateTimeFormatter

  • 格式化或解析日期、时间，类似于SimpleDateFormat

3、类的比较

1.     java中的对象，只能进行比较操作：==，！=，不能使用大于小于的我，但是在开发的场景中，我们又需要对多个对象进行排序，需要比较对象的大小，需要使用两个接口中的任何一个。

1. Comparable接口的使用

   1. 自然排序：

   2. 像String、包装类等实现类了Comparable接口，重写了compareTo方法,给出比较两个对象大小。

   3. 重写compareTo（Obj）的规则

   4. 像String、包装类重写compareTO方法后，进行从小到大的排序

   5. 当我们自定义类时，想要去排序，我们可以让自定义类实现Comparable接口，重写compareTo（）方法，在conpareTo(obj)方法中指明如何排序

2. Comparator

   1. 定制排序

   2. 重写compare（obj1，obj2）

3. 两者对比

   1. Comparable接口的方式一旦定下，保证Coparable接口实现类的对象任何位置都可以使用

   2. 而Comparator则是临时使用

4. 代码案例

5. Comparable接口

6. Grade 类：

   package compareTest;
   
   
   public class Grade implements Comparable {
       private String name;//姓名
       private int age;//年龄
       private double english;//英语成绩
       private double math;//数学成绩
       private double chinese;//中文
   
       public Grade(){
   
       }
   
       public Grade(String name, int age, double english, double math, double chinese) {
           this.name = name;
           this.age = age;
           this.english = english;
           this.math = math;
           this.chinese = chinese;
       }
   
       public String getName() {
           return name;
       }
   
       public void setName(String name) {
           this.name = name;
       }
   
       public int getAge() {
           return age;
       }
   
       public void setAge(int age) {
           this.age = age;
       }
   
       public double getEnglish() {
           return english;
       }
   
       public void setEnglish(double english) {
           this.english = english;
       }
   
       public double getMath() {
           return math;
       }
   
       public void setMath(double math) {
           this.math = math;
       }
   
       public double getChinese() {
           return chinese;
       }
   
       public void setChinese(double chinese) {
           this.chinese = chinese;
       }
   
       @Override
       public String toString() {
           return "Grade{" +
                   "名字='" + name + ''' +
                   ", 年龄=" + age +
                   ", 英语=" + english +
                   ", 数学=" + math +
                   ", 语文=" + chinese +
                   '}';
       }
   
       @Override
       public int compareTo(Object o) {
           if(o instanceof Grade){
               if(this.english >((Grade) o).english){
                   return 1;
   
               }else if (this.english <(( Grade)o).english){
                   return -1;
               }else {
                   if(this.math >= ((Grade)o).math){
                       return -1;
                   }else {
                       return 1;
                   }
               }
           }else {
               throw new RuntimeException("输入的类型不一致");
           }
   
       }
   
   
   }
   

   测试类：

   public class GradeTest {
       public static void main(String[] args) {
           Grade[] grades = new Grade[]{new Grade("张三", 22, 99, 87, 77),
                   new Grade("李四", 28, 89, 77, 67),
                   new Grade("张三", 21, 94, 84, 87),
                   new Grade("逻辑", 28, 94, 144, 97),
                   new Grade("王二", 30, 100, 100, 100)};
           //实现Comparable接口
           Arrays.sort(grades);
           for (Grade g : grades) {
               System.out.println(g);
           }
       }
   }

Comparator接口：

public class GradeTest {
    public static void main(String[] args) {
        Grade[] grades = new Grade[]{new Grade("张三", 22, 99, 87, 77),
                new Grade("李四", 28, 89, 77, 67),
                new Grade("张三", 21, 94, 84, 87),
                new Grade("逻辑", 28, 94, 144, 97),
                new Grade("王二", 30, 100, 100, 100)};
//        //实现Comparable接口
//        Arrays.sort(grades);
//        for (Grade g : grades) {
//            System.out.println(g);
//        }
        //实现Comparator接口
        Arrays.sort(grades, new Comparator() {
            @Override
            public int compare(Grade o1, Grade o2) {
                if (o1 != null && o2 != null) {
                    if (o1.getChinese() > o2.getChinese()) {
                        return -1;
                    } else if (o1.getChinese() < o2.getChinese()) {
                        return 1;
                    } else {
                        return 0;
                    }
                }
                throw new RuntimeException("类型不一致");
            }
        });
        for (Grade g : grades) {
            System.out.println(g);
        }
    }
}