JavaSE常用类1

标签：常用 String -- str1 字符串 Integer JavaSE 排序

常用类

object类

toString

功能：返回对象的字符串形式
object类是所有类的父类，所有类都有toString方法
使用sout打印对象的引用时，会自动调用toString()
返回值：全类名@hash值
如果object中的toString不能满足要求，就要重写toString()

==

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

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

boolean equals(Object obj)

作用：在object类中和==的第二个作用相同，判断两个对象是否是同一个对象/判断两个引用是否指向同一个对象
不能满足要求要重写

包装类

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

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

byte Byte

short Short

int Integer

long Long

float Float

double Double

char Character

boolean Boolean

装箱和拆箱

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

手动装箱
自动装箱

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

手动拆箱
自动拆箱

 //手动装箱
 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)字符串 --> 基本数据类型

包装类的常量池

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

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

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

优势

不用频繁的创建Integer类型的对象，可以一定程度上提升系统性能
包装类判断值是否相等要用equals()判断
小数没有常量池

 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类

字符串是不可变的。一个字符串对象一旦被配置，其内容是不可变的。
```
 String str1 = "hello world";
 String str2 = new String("hello world");
```
判断字符串内容是否相同
```
 str1.equals(str2)
```
忽略大小写判断字符串是否相同
```
 str1.equalsIgnoreCase(str3)
```
判断是否包含
```
 str1.contains("hello")
```
判断是否以特定字符串开始
```
 str1.startsWith("hello")
```
判断字符串长度是否为0
```
 str1.isEmpty()
 //不是null
```
返回特定位置的字符(下标： 0 - 长度 - 1)
```
 str1.charAt(0)
```
返回特定字符首次出现的索引
```
 str1.indexOf('l')
```
返回特定字符从特定位置开始查找的索引
```
 str1.indexOf('l',5)
```

获取子字符串

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

转换成大写
```
 str1.toUpperCase()
```
转换成小写
```
 str3.toLowerCase()
```
字符串拼接
```
 str1.concat("hugyh")
```
替换
```
 str1.replace('l','L')
```

去空格

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

java比较器

目前存在的问题：

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

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

1）自然排序 - Comparable

2）定制排序 - Comparator
自然排序

步骤：

1）自定义类实现Comparable接口

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

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

this > obj,返回一个正数

this = obj, 返回0

this < obj,返回一个负数

3）注意

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

定制排序

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是线程同步的，通常用于多线程

标签：常用,String,--,str1,字符串,Integer,JavaSE,排序
From： https://blog.csdn.net/lhlljk666/article/details/140737894

常用类