5月6（信息差）

目录

常用类与基础API---String

String的内存结构

构造器和常用方法

字符串构建

String与其他结构间的转换

String的常用API

系列1：常用方法

 系列2：查找

系列3：字符串截取

 系列4：和字符/字符数组相关

 系列5：开头与结尾

 系列6：替换

 StringBuffer、StringBuilder

 StringBuilder、StringBuffer的API

 Java比较器 

Comparable

Comparator

java.lang.System类

  java.lang.Runtime类

数学类 

 java.lang.Math

java.math包 

BigInteger

BigDecimal

java.util.Random

常用类与基础API---String

源码中的声明：

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence,
               Constable, ConstantDesc {

特性： 

String的内存结构

因为字符串对象设计为不可变，那么所以字符串有常量池来保存很多常量对象。

JDK6中，字符串常量池在方法区。JDK7开始，就移到堆空间，直到目前JDK17版本。

由于字符串常量池不允许两个相同的字符串，所以在声明字符串时其实是得到了地址：

String s1 = "hello";
String s2 = "hello";
System.out.println(s1 == s2);
// 内存中只有一个"hello"对象被创建，同时被s1和s2共享。

同样，如果给字符串赋新的值，则是在常量池中开辟新的地址存放

创建字符串有两种方式，其内存结构是不一样的：

String s1 = "javaEE";
String s2 = "javaEE";
String s3 = new String("javaEE");
String s4 = new String("javaEE");

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

一些特殊情况：

        String s1 = "hello";
        String s2 = "world";
        String s3 = "hello" + "world";
        String s4 = s1 + "world";  //相当于new了一个对象
        String s5 = s1 + s2;
        String s6 = (s1 + s2).intern();

        System.out.println(s3 == s4);
        System.out.println(s3 == s5);
        System.out.println(s4 == s5);
        System.out.println(s3 == s6);
//        false
//        false
//        false
//        true

构造器和常用方法

字符串构建

String str = "hello";

//构造器定义方式：无参构造
String str1 = new String();

//构造器定义方式：创建"hello"字符串常量的副本
String str2 = new String("hello");

//构造器定义方式：通过字符数组构造
char chars[] = {'a', 'b', 'c','d','e'};     
String str3 = new String(chars);
String str4 = new String(chars,0,3);

//构造器定义方式：通过字节数组构造
byte bytes[] = {97, 98, 99 };     
String str5 = new String(bytes);
String str6 = new String(bytes,"GBK");

String与其他结构间的转换

//        字符串 --> 基本数据类型、包装类：
        String str1 = "123";
        System.out.println(Integer.parseInt(str1));

//        基本数据类型、包装类 --> 字符串：
        int num1 = 122;
        System.out.println(String.valueOf(num1));

//        字符数组 --> 字符串：
        char chars[] = {'a','b','c'};
        System.out.println(new String(chars));

//        字符串 --> 字节数组：（编码）
        String str2 = "asdqwe";
        byte byte1[] = str2.getBytes();
        System.out.println(new String(byte1));

String的常用API

系列1：常用方法

        String str1 = "123";
        System.out.println(str1.isEmpty());

        String str2 = "qwe";
        String str3 = str1.concat(str2);
        System.out.println(str3);

        String str4 = "qwe";
        System.out.println(str2.equals(str4));

        String str5 = "QwE";
        System.out.println(str2.equalsIgnoreCase(str5));

        System.out.println(str2.compareTo(str4));

        System.out.println(str5.toLowerCase());

        System.out.println(str2.toUpperCase());

        String str6 = "   sadsa   ";
        System.out.println(str6.trim());

        str6.intern();
        
        System.out.println(str3.charAt(1));

 系列2：查找

        String str = "尚硅谷是一家靠谱的培训机构，尚硅谷可以说是IT培训的小清华，JavaEE是尚硅谷的当家学科，尚硅谷的大数据培训是行业独角兽。尚硅谷的前端和UI专业一样独领风骚。";
        System.out.println("是否包含清华：" + str.contains("清华"));
        System.out.println("培训出现的第一次下标：" + str.indexOf("培训"));
        System.out.println("培训出现的最后一次下标：" + str.lastIndexOf("培训"));

系列3：字符串截取

        String str = "helloworldjavaatguigu";
        String sub1 = str.substring(5);
        String sub2 = str.substring(5,10);
        System.out.println(sub1);
        System.out.println(sub2);

 系列4：和字符/字符数组相关

 系列5：开头与结尾

		String name = "张三";
		System.out.println(name.startsWith("张"));

 系列6：替换

    String str1 = "hello244world.java;887";
    //把其中的非字母去掉
    str1 = str1.replaceAll("[^a-zA-Z]", "");
    System.out.println(str1);

    String str2 = "12hello34world5java7891mysql456";
    //把字符串中的数字替换成,，如果结果中开头和结尾有，的话去掉
    String string = str2.replaceAll("\\d+", ",").replaceAll("^,|,
    String str1 = "hello244world.java;887";
    //把其中的非字母去掉
    str1 = str1.replaceAll("[^a-zA-Z]", "");
    System.out.println(str1);

    String str2 = "12hello34world5java7891mysql456";
    //把字符串中的数字替换成,，如果结果中开头和结尾有，的话去掉
    String string = str2.replaceAll("\\d+", ",").replaceAll("^,|,$", "");
    System.out.println(string);
quot;, "");
    System.out.println(string);

 StringBuffer、StringBuilder

  StringBuffer内部有两个变量：value和count

 StringBuffer在创建时，会预留16的容量，以便改变：

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

 不断的添加，一旦count要超过value.length时，就需要扩容:默认扩容为原有容量的2倍+2。
并将原有value数组中的元素复制到新的数组中。

• StringBuilder 和 StringBuffer 非常类似，均代表可变的字符序列，而且提供相关功能的方法也一样。

 StringBuilder、StringBuffer的API

其他api

 Java比较器 

• Java实现对象排序的方式有两种：

  • 自然排序：java.lang.Comparable
  • 定制排序：java.util.Comparator

Comparable

Comparable接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序。

实现 Comparable 的类必须实现Comparable接口，实现 compareTo(Object obj) 方法，两个对象即通过 compareTo(Object obj) 方法的返回值来比较大小

class Student implements Comparable {
    private int id;
    private String name;
    private int score;
    private int age;

    public Student(int id, String name, int score, int age) {
        this.id = id;
        this.name = name;
        this.score = score;
        this.age = age;
    }
    

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", score=" + score +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Object o) {
        //这些需要强制，将o对象向下转型为Student类型的变量，才能调用Student类中的属性
        //默认按照成绩比较大小，返回成绩的差值
        Student stu = (Student) o;
        return this.score - stu.score;
    }
}

        Student[] arr = new Student[5];
        arr[0] = new Student(3,"张三",90,23);
        arr[1] = new Student(1,"熊大",100,22);
        arr[2] = new Student(5,"王五",75,25);
        arr[3] = new Student(4,"李四",85,24);
        arr[4] = new Student(2,"熊二",85,18);

        //单独比较两个对象
        System.out.println(arr[0].compareTo(arr[1]));  //-10
        System.out.println(arr[1].compareTo(arr[2]));  //25
        System.out.println(arr[2].compareTo(arr[2])); //0

        Arrays.sort(arr);

        for(int i=0;i< arr.length;i++){   //从成绩小到大排序
            System.out.println(arr[i]);
        }reTo(arr[2])); //0

Comparator

• 当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码
• 如果一个类，实现了Comparable接口，也指定了两个对象的比较大小的规则，但是此时此刻不想按照它预定义的方法比较大小，但是又不能随意修改

可使用Comparator

        Student[] arr = new Student[5];
        arr[0] = new Student(3,"张三",90,23);
        arr[1] = new Student(1,"熊大",100,22);
        arr[2] = new Student(5,"王五",75,25);
        arr[3] = new Student(4,"李四",85,24);
        arr[4] = new Student(2,"熊二",85,18);

        Comparator comparator = new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Student s1 = (Student) o1;
                Student s2 = (Student) o2;
                return s1.age - s2.age;
            }
        };

        Arrays.sort(arr,comparator);

        for(int i=0;i< arr.length;i++){   //从年龄小到大排序
            System.out.println(arr[i]);
        }

java.lang.System类

成员方法 

  java.lang.Runtime类

    public static void main(String[] args) {
        Runtime runtime = Runtime.getRuntime();
        long initialMemory = runtime.totalMemory(); //获取虚拟机初始化时堆内存总量
        long maxMemory = runtime.maxMemory(); //获取虚拟机最大堆内存总量
        String str = "";
        //模拟占用内存
        for (int i = 0; i < 10000; i++) {
            str += i;
        }
        long freeMemory = runtime.freeMemory(); //获取空闲堆内存总量
        System.out.println("总内存：" + initialMemory / 1024 / 1024 * 64 + "MB");
        System.out.println("总内存：" + maxMemory / 1024 / 1024 * 4 + "MB");
        System.out.println("空闲内存：" + freeMemory / 1024 / 1024 + "MB") ;
        System.out.println("已用内存：" + (initialMemory-freeMemory) / 1024 / 1024 + "MB");
    }

数学类 

 java.lang.Math

java.math包 

BigInteger

        BigInteger b1 = new BigInteger("12345678912345678912345678");
        BigInteger b2 = new BigInteger("78923456789123456789123456789");

        //System.out.println("和：" + (b1+b2));//错误的，无法直接使用+进行求和

        System.out.println("和：" + b1.add(b2));
        System.out.println("减：" + b1.subtract(b2));
        System.out.println("乘：" + b1.multiply(b2));
        System.out.println("除：" + b2.divide(b1));
        System.out.println("余：" + b2.remainder(b1));

BigDecimal

    BigInteger bi = new BigInteger("12433241123");
    BigDecimal bd = new BigDecimal("12435.351");
    BigDecimal bd2 = new BigDecimal("11");
    System.out.println(bi);
    // System.out.println(bd.divide(bd2));
    System.out.println(bd.divide(bd2, BigDecimal.ROUND_HALF_UP));
    System.out.println(bd.divide(bd2, 15, BigDecimal.ROUND_HALF_UP));

java.util.Random

    Random r = new Random();
    System.out.println("随机整数：" + r.nextInt());
    System.out.println("随机小数：" + r.nextDouble());
    System.out.println("随机布尔值：" + r.nextBoolean());

 当然直接使用Math.random也能达到类似效果