（一）字符串

1.1String的特点

String类用final关键字修饰，表明该类不能被继承
String类中定义了一个char类型的数组，该数据用于接受保存的数据，该数据也用final修饰，无法被修改。
String实现了Serializable接口：表示字符串是支持序列化的。
实现了Comparable接口：表示String可以比较大小

（具体特点说明可以参考Java的打怪之路（二）—Java基础）
https://blog.csdn.net/weixin_44020747/article/details/109775757?spm=1001.2014.3001.5501

1.2String对象的创建

1.2.1String对象

两种方式：

String a="abc"
String b= new String（“abc”）

两种方式的区别在于：
直接赋值（String str=“hello”)：只会开辟一块堆内存空间，并且会保存在对象池中以便于下次使用。
构造方法(String str=new String(“hello”))：会开辟两块内存空间，（首先在堆内存中开辟空间保存hello，然后使用关键词new 开辟另一块堆空间。真正使用的是new开辟的空间，而之前开辟的空间会成为垃圾等待回收。）不会自动入池，但是可以通过intern()方法手工入池。

1.2.2字符串对象

Person p1 = new Person(“Tom”,12);
Person p2 = new Person(“Tom”,12);
在这里插入图片描述字符串对象还是按照字面量进行赋值，其地址值相同

1.2.3字符拼接

在这里插入图片描述

注意
1、常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
2、只要其中有一个是变量，结果就在堆中
3、如果拼接的结果调用intern()方法，返回值就在常量池中
4、如果有变量被final修饰，那么这个变量就变成了常量，其存放的还在常量池中。

1.2.3字符串中函数的值传递

public class p1 {
    
    
    String str=new String("good");
    public void change(String str){
    
    
        str="tets";
    }
    public static void main(String [] args){
    
    
        p1 x=new p1();
        x.change(x.str);
        System.out.println(x.str);
    }
}

这里结果是good
在传递参数时，基本数据类型传递的是真实值，引用数据类型传递的是地址值。
在基本数据类型中，传递的形参和实参是一样，在引用数据类型中吗，形参和实参是两个值，相当于又重新创建了一个变量。

在这里实参为str，其指向堆内存中的good。当传递实参到形参str时，这里传递的是地址，在堆内存中创建了一个test，该地址指向test。

在这里插入图片描述

1.3String与其他类型的转换

String转为基本数据类型、包装类：调用包装类的静态方法 parseXXX（）
基本数据类型、包装类转为String：调用String重载的方法 valueOf（）
String与char[]之间的转换：调用 toCharArray()方法
char[]转为String：调用String的构造器
String转为Byte[]：调用getBytes()
Byte[]转为String：调用String的构造器

package com.atguigu.java;

import org.junit.Test;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

/**
 * 涉及到String类与其他结构之间的转换
 *
 * @author shkstart
 * @create 2019 下午 2:39
 */
public class StringTest1 {
    
    


    /*
    String 与 byte[]之间的转换
    编码：String --> byte[]:调用String的getBytes()
    解码：byte[] --> String:调用String的构造器

    编码：字符串 -->字节  (看得懂 --->看不懂的二进制数据)
    解码：编码的逆过程，字节 --> 字符串 （看不懂的二进制数据 ---> 看得懂）

    说明：解码时，要求解码使用的字符集必须与编码时使用的字符集一致，否则会出现乱码。
     */
    @Test
    public void test3() throws UnsupportedEncodingException {
    
    
        String str1 = "abc123中国";
        byte[] bytes = str1.getBytes();//使用默认的字符集，进行编码。
        System.out.println(Arrays.toString(bytes));

        byte[] gbks = str1.getBytes("gbk");//使用gbk字符集进行编码。
        System.out.println(Arrays.toString(gbks));

        System.out.println("******************");

        String str2 = new String(bytes);//使用默认的字符集，进行解码。
        System.out.println(str2);

        String str3 = new String(gbks);
        System.out.println(str3);//出现乱码。原因：编码集和解码集不一致！


        String str4 = new String(gbks, "gbk");
        System.out.println(str4);//没有出现乱码。原因：编码集和解码集一致！


    }

    /*
    String 与 char[]之间的转换

    String --> char[]:调用String的toCharArray()
    char[] --> String:调用String的构造器
     */
    @Test
    public void test2(){
    
    
        String str1 = "abc123";  //题目： a21cb3

        char[] charArray = str1.toCharArray();
        for (int i = 0; i < charArray.length; i++) {
    
    
            System.out.println(charArray[i]);
        }

        char[] arr = new char[]{
    
    'h','e','l','l','o'};
        String str2 = new String(arr);
        System.out.println(str2);
    }

    /*
    复习：
    String 与基本数据类型、包装类之间的转换。

    String --> 基本数据类型、包装类：调用包装类的静态方法：parseXxx(str)
    基本数据类型、包装类 --> String:调用String重载的valueOf(xxx)

     */
    @Test
    public void test1(){
    
    
        String str1 = "123";
//        int num = (int)str1;//错误的
        int num = Integer.parseInt(str1);

        String str2 = String.valueOf(num);//"123"
        String str3 = num + "";

        System.out.println(str1 == str3);
    }
}

1.4StringBuffer与StringBulider

1.4.1异同

1、String、StringBuffer与StringBulider之间的异同：
String：是不可变的字符序列，底层使用char[]存储
StringBuffer：是可变的字符序列；线程安全，效率比较低；底层使用char[]存储
StringBulider：是可变的字符序列；线程不安全，效率高；底层使用char[]存储

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

StringBuffer sb1 = new StringBuffer();//char[] value = new char[16];底层创建了一个长度是16的数组。
System.out.println(sb1.length());//
sb1.append('a');//value[0] = 'a';
sb1.append('b');//value[1] = 'b';

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

//问题1. System.out.println(sb2.length());//3
//问题2. 扩容问题:如果要添加的数据底层数组盛不下了，那就需要扩容底层的数组。
         默认情况下，扩容为原来容量的2倍 + 2，同时将原有数组中的元素复制到新的数组中。

        指导意义：开发中建议大家使用：StringBuffer(int capacity) 或 StringBuilder(int capacity)

2、String、StringBuffer与StringBulider效率对比
StringBulider》StringBuffer》String

1.4.2常用方法

StringBuffer append(xxx)：提供了很多的append()方法，用于进行字符串拼接
StringBuffer delete(int start,int end)：删除指定位置的内容
StringBuffer replace(int start, int end, String str)：把[start,end)位置替换为str
StringBuffer insert(int offset, xxx)：在指定位置插入xxx
StringBuffer reverse() ：把当前字符序列逆转
public int indexOf(String str)
public String substring(int start,int end):返回一个从start开始到end索引结束的左闭右开区间的子字符串
public int length()
public char charAt(int n )
public void setCharAt(int n ,char ch)

（二）比较器

一、说明：Java中的对象，正常情况下，只能进行比较：== 或 != 。不能使用 > 或 < 的但是在开发场景中，我们需要对多个对象进行排序，言外之意，就需要比较对象的大小。
如何实现？使用两个接口中的任何一个：Comparable 或 Comparator

二、Comparable接口与Comparator的使用的对比：
Comparable接口的方式一旦一定，保证Comparable接口实现类的对象在任何位置都可以比较大小。
Comparator接口属于临时性的比较。

2.1使用Comparable接口实现自然排序

定义一个商品类，实现商品类对象的比较

public class CompareTest {
    
    
    /*
    Comparable接口的使用举例：  自然排序
    1.像String、包装类等实现了Comparable接口，重写了compareTo(obj)方法，给出了比较两个对象大小的方式。
    2.像String、包装类重写compareTo()方法以后，进行了从小到大的排列
    3. 重写compareTo(obj)的规则：
        如果当前对象this大于形参对象obj，则返回正整数，
        如果当前对象this小于形参对象obj，则返回负整数，
        如果当前对象this等于形参对象obj，则返回零。
    4. 对于自定义类来说，如果需要排序，我们可以让自定义类实现Comparable接口，重写compareTo(obj)方法。
       在compareTo(obj)方法中指明如何排序
     */
    @Test
    public void test1(){
    
    
        String[] arr = new String[]{
    
    "AA","CC","KK","MM","GG","JJ","DD"};
        //
        Arrays.sort(arr);

        System.out.println(Arrays.toString(arr));

    }

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

        Arrays.sort(arr);

        System.out.println(Arrays.toString(arr));
    }

在商品类中，重写ComparaTo方法

/**
 * 商品类
 * @author shkstart
 * @create 2019 下午 4:52
 */
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) {
    
    
//        System.out.println("**************");
        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;
               return -this.name.compareTo(goods.name);
            }
            //方式二：
//           return Double.compare(this.price,goods.price);
        }
//        return 0;
        throw new RuntimeException("传入的数据类型不一致！");
    }
}

2.2使用Comparator接口实现定制排序

Comparator接口的使用：定制排序
1.背景：
当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码，
或者实现了java.lang.Comparable接口的排序规则不适合当前的操作，
那么可以考虑使用 Comparator 的对象来排序
2.重写compare(Object o1,Object o2)方法，比较o1和o2的大小：
如果方法返回正整数，则表示o1大于o2；
如果返回0，表示相等；
返回负整数，表示o1小于o2。

public void test3(){
    
    
        String[] arr = new String[]{
    
    "AA","CC","KK","MM","GG","JJ","DD"};
        Arrays.sort(arr,new Comparator(){
    
    

            //按照字符串从大到小的顺序排列
            @Override
            public int compare(Object o1, Object o2) {
    
    
                if(o1 instanceof String && o2 instanceof  String){
    
    
                    String s1 = (String) o1;
                    String s2 = (String) o2;
                    return -s1.compareTo(s2);
                }
//                return 0;
                throw new RuntimeException("输入的数据类型不一致");
            }
        });
        System.out.println(Arrays.toString(arr));
    }

    @Test
    public void test4(){
    
    
        Goods[] arr = new Goods[6];
        arr[0] = new Goods("lenovoMouse",34);
        arr[1] = new Goods("dellMouse",43);
        arr[2] = new Goods("xiaomiMouse",12);
        arr[3] = new Goods("huaweiMouse",65);
        arr[4] = new Goods("huaweiMouse",224);
        arr[5] = new Goods("microsoftMouse",43);

        Arrays.sort(arr, new Comparator() {
    
    
            //指明商品比较大小的方式:按照产品名称从低到高排序,再按照价格从高到低排序
            @Override
            public int compare(Object o1, Object o2) {
    
    
                if(o1 instanceof Goods && o2 instanceof Goods){
    
    
                    Goods g1 = (Goods)o1;
                    Goods g2 = (Goods)o2;
                    if(g1.getName().equals(g2.getName())){
    
    
                        return -Double.compare(g1.getPrice(),g2.getPrice());
                    }else{
    
    
                        return g1.getName().compareTo(g2.getName());
                    }
                }
                throw new RuntimeException("输入的数据类型不一致");
            }
        });

        System.out.println(Arrays.toString(arr));
    }

}

（三）System、Math和BigDecimal

3.1System

在这里插入图片描述

3.2 Math

在这里插入图片描述

3.3Big

存比较大的整数和浮点型

在这里插入图片描述

（四）枚举类

4.1手工定义枚举类

注意：
1、枚举类对象的属性不应允许被改动, 所以应该使用 private final 修饰
2、枚举类的使用 private final 修饰的属性应该在构造器中为其赋值
3、若枚举类显式的定义了带参数的构造器, 则在列出枚举值时也必须对应的
传入参数

class Season{
    
    
	private final String SEASONNAME;//季节的名称
	private final String SEASONDESC;//季节的描述
	private Season(String seasonName,String seasonDesc){
    
    
	this.SEASONNAME = seasonName;
	this.SEASONDESC = seasonDesc;
}
	public static final Season SPRING = new Season("春天", "春暖花开");
	public static final Season SUMMER = new Season("夏天", "夏日炎炎");
	public static final Season AUTUMN = new Season("秋天", "秋高气爽");
	public static final Season WINTER = new Season("冬天", "白雪皑皑");
}

定义为final属性后，无法添加set方法，不允许修改

4.2使用enum定义枚举类

1、使用 enum 定义的枚举类默认继承了 java.lang.Enum类，因此不能再
继承其他类
2、枚举类的构造器只能使用 private 权限修饰符
3、枚举类的所有实例必须在枚举类中显式列出(, 分隔 ; 结尾)。列出的实例系统会自动添加 public static final 修饰
4、必须在枚举类的第一行声明枚举类对象

public enum SeasonEnum {
    
    
	SPRING("春天","春风又绿江南岸"),
	SUMMER("夏天","映日荷花别样红"),
	AUTUMN("秋天","秋水共长天一色"),
	WINTER("冬天","窗含西岭千秋雪");
	private final String seasonName;x
	private final String seasonDesc;
	private SeasonEnum(String seasonName, String seasonDesc) {
    
    
	this.seasonName = seasonName;
	this.seasonDesc = seasonDesc;
	}
	public String getSeasonName() {
    
    
	return seasonName;
	}
	public String getSeasonDesc() {
    
    
	return seasonDesc;
	}
}
//枚举类的使用
  public static void main(String[] args) {
    
    
        Season01 sp=Season01.Spring01;
        System.out.println(sp.getSensonDesc());

    }

4.3Enum常用方法

在这里插入图片描述

（五）注解

5.1什么是注解

① jdk 5.0 新增的功能
② Annotation 其实就是代码里的特殊标记, 这些标记可以在编译, 类加载, 运行时被读取, 并执行相应的处理。通过使用 Annotation,程序员可以在不改变原有逻辑的情况下, 在源文件中嵌入一些补充信息。
③在JavaSE中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在JavaEE/Android中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替JavaEE旧版中所遗留的繁冗代码和XML配置等。

5.2注解的使用

示例一：生成文档相关的注解
示例二：在编译时进行格式检查(JDK内置的三个基本注解)
@Override: 限定重写父类方法, 该注解只能用于方法
@Deprecated: 用于表示所修饰的元素(类, 方法等)已过时。通常是因为所修饰的结构危险或存在更好的选择
@SuppressWarnings: 抑制编译器警告

示例三：跟踪代码依赖性，实现替代配置文件功能

5.3自定义注解

如何自定义注解：参照@SuppressWarnings定义
- ① 注解声明为：@interface
- ② 内部定义成员，通常使用value表示
- ③ 可以指定成员的默认值，使用default定义
- ④ 如果自定义注解没有成员，表明是一个标识作用。

如果注解有成员，在使用注解时，需要指明成员的值。
自定义注解必须配上注解的信息处理流程(使用反射)才有意义。
自定义注解通过都会指明两个元注解：Retention、Target

5.4元注解

Retention
指定所修饰注解的生命周期，只有声明为RunTime才能通过反射获取
Target
用于指定被修饰注解能用于修饰哪些元素：能修饰类还是方法等。
Documented
用于指定被该元 Annotation 修饰的 Annotation 类将被
javadoc 工具提取成文档
Inherited
被它修饰的 Annotation 将具有继承性。

Java打怪之路----Java高级之常用类与注解

（一）字符串

1.1String的特点

1.2String对象的创建

1.2.1String对象

1.2.2字符串对象

1.2.3字符拼接

1.2.3字符串中函数的值传递

1.3String与其他类型的转换

1.4StringBuffer与StringBulider

1.4.1异同

1.4.2常用方法

（二）比较器

2.1使用Comparable接口实现自然排序

2.2使用Comparator接口实现定制排序

（三）System、Math和BigDecimal

3.1System

3.2 Math

3.3Big

（四）枚举类

4.1手工定义枚举类

4.2使用enum定义枚举类

4.3Enum常用方法

（五）注解

5.1什么是注解

5.2注解的使用

5.3自定义注解

5.4元注解

猜你喜欢