JavaSE常用类1

常用类

object类

1. toString

• 功能：返回对象的字符串形式

• object类是所有类的父类，所有类都有toString方法

• 使用sout打印对象的引用时，会自动调用toString()

• 返回值：全类名@hash值

• 如果object中的toString不能满足要求，就要重写toString()

1. ==

   1）判断基本数据类型的值是否相同

   2）判断两个对象是否是同一个对象/判断两个引用是否指向同一个对象

2. equals

   boolean equals(Object obj)

• 作用：在object类中和==的第二个作用相同，判断两个对象是否是同一个对象/判断两个引用是否指向同一个对象

• 不能满足要求要重写

包装类

问题：8种数据类型的数据不能被当做对象使用

解决：设计类的属性时，如果是基本数据类型，要用对应的包装类

byte Byte

short Short

int Integer

long Long

float Float

double Double

char Character

boolean Boolean

装箱和拆箱

1. 装箱：将基本数据类型转换成对应的包装类

• 手动装箱

• 自动装箱

拆箱：将包装类转换成对应的基本数据类型

• 手动拆箱

• 自动拆箱

 //手动装箱
 int a = 20;
 Integer i = Integer.valueOf(a);
 ​
 //手动拆箱
 int b = i.intValue();
 ​
 //自动装箱
 Integer i1 = a;
 ​
 //自动拆箱
 int x = i1;
 System.out.println((x + "") instanceof String);
 ​
 String str = "999";
 int a1 = Integer.parseInt(str);
 ​
 str = "99.99";
 double d = Double.parseDouble(str);
 ​
 str = "true";
 boolean b1 = Boolean.parseBoolean(str);

基本数据类型和字符串的相互转换

1）基本数据类型 --> 字符串

• 拼接" "：x+""

• 验证：instanceof String

2)字符串 --> 基本数据类型

包装类的常量池

1. 自动装箱的本质：底层调用了手动装箱的代码Integer.valueOf()

2. 常量池：

   1）Integer在类加载时会创建一个数组，数组中保存了-128~127范围内的所有的Integer类型的对象，这个数组就是Integer的常量池

2）如果使用自动装箱，首先从常量池中获取对象，如果不在常量池中就创建新的Integer对象

1. 优势

   不用频繁的创建Integer类型的对象，可以一定程度上提升系统性能

2. 包装类判断值是否相等要用equals()判断

3. 小数没有常量池

 a = new Integer(100);
 b = new Integer(100);
 System.out.println(a == b);//false
 a = 100;
 b = 100;
 System.out.println(a == b);//true
 ​
 a = new Integer(128);
 b = new Integer(128);
 System.out.println(a == b);//false
 a = 128;
 b = 128;
 System.out.println(a == b);//false

String类

1. 字符串是不可变的。一个字符串对象一旦被配置，其内容是不可变的。

    String str1 = "hello world";
    String str2 = new String("hello world");

2. 判断字符串内容是否相同

    str1.equals(str2)

3. 忽略大小写判断字符串是否相同

    str1.equalsIgnoreCase(str3)

4. 判断是否包含

    str1.contains("hello")

5. 判断是否以特定字符串开始

    str1.startsWith("hello")

6. 判断字符串长度是否为0

    str1.isEmpty()
    //不是null

7. 返回特定位置的字符(下标： 0 - 长度 - 1)

    str1.charAt(0)

8. 返回特定字符首次出现的索引

    str1.indexOf('l')

9. 返回特定字符从特定位置开始查找的索引

    str1.indexOf('l',5)

10. 获取子字符串

     str1.substring(6)
     str1.substring(6,7)//[,)

11. 转换成大写

     str1.toUpperCase()

12. 转换成小写

     str3.toLowerCase()

13. 字符串拼接

     str1.concat("hugyh")

14. 替换

     str1.replace('l','L')

15. 去空格

     String str4 = "      hello         ";
     System.out.println(str4.trim());

java比较器

1. 目前存在的问题：

   1）Arrays.sort()默认从小到大排序，实现从大到小排序需要 -- 排序的定制

   2）Arrays.sort()如何实现自定义类型的排序

2. 如何实现自定义对象的排序

   1）自然排序 - Comparable

   2） 定制排序 - Comparator

3. 自然排序

• 步骤：

  1）自定义类实现Comparable接口

2）重写Comparable接口的compareTo方法，在这个方法中定义排序规则

this -- 当前对象 obj -- 被比较对象

this > obj,返回一个正数

this = obj, 返回0

this < obj,返回一个负数

3）注意

• Arrays.sort()默认使用了自然排序的规则金总排序，要求自定义类必须实现自然排序的规则

• String类java官方已经实现了自然排序

1. 定制排序

1）什么时候使用定制排序：已经定义好的类无法修改代码的时候

2）如何实现定制排序

• 自定义类实现Comparator接口

• 重写Comparator接口中的Compara方法

  o1 -- 前面的参数 o2 -- 第二个参数

  o1 > o2,返回一个正数

  o1 = o2,返回0

  o1 < o2,返回一个负数

3）最佳实践 -- 使用匿名内部类 -- 这个匿名内部类是Comparator接口的实现类

 public int comparaTo(Student o){
     if(this.age = o.age){
         return -(this.height - o.height);
     }else{
         return Integer.compare(this.age, o.age);//Integer的方法
     }
 }
 Student[] arr = new Student[]{s1, s2, s3, s4, s5};
 Arrays.sort(arr, new Comparator<String>(){
     @Override
     public int comparaTo(String o1, String o2){
     if(o1.length(0 == o2.length()){
         return -o1.compareTo(o2);
     }
        
        return Integer.compare(o1.length(), o2.length());
 }
 });

StringBuffer和StringBuilder

• 可以对字符串进行修改

• 长度可变

• 有缓冲区，用于存储可变字符序列的容器。

不用频繁的new对象,!!!可以拼接

 StringBuffer sbf = new StringBuffer("hello");
 ​
 sbf.append("world");
 sbf.append(", hello java");
 sbf.append(", my sql");
 ​
 String s = sbf.toString();
 sout(s);

StringBuilder线程不同步，通常用于单线程

StringBuffer是线程同步的，通常用于多线程