Java面向对象8常用类2（MathString）

Math

1、直接使用&＃xff0c;无需导包

package java.lang;


2、final 修饰类 不能被继承

public final class Math


3、构造器私有化&＃xff0c;不能创建Math类的对象

private Math() {}


4、Math所有的属性和方法都被static修饰&＃xff0c;直接 类名. 调用

5、常用方法

package msb.javase.oop.javase_220310_math;public class Test {public static void main(String[] args) {System.out.println(Math.random());System.out.println(Math.PI);System.out.println(Math.abs(-80));//绝对值System.out.println(Math.ceil(9.1));//向上取值System.out.println(Math.floor(9.9));//向下取值System.out.println(Math.round(3.5));//四舍五入System.out.println(Math.max(3, 6));//取大值System.out.println(Math.min(3, 6));//取小值}
}

6、静态导入

import static java.lang.Math.*;
System.out.println(random());


存在问题&＃xff1a;如果跟Math中的方法重复&＃xff0c;那么会优先走本类的自定义方法&＃xff08;就近原则&＃xff09;

package msb.javase.oop.javase_220310_math;import static java.lang.Math.*;public class Test {public static void main(String[] args) {System.out.println(random()); //100}public int random(){return 100;}
}

Random

package msb.javase.oop.javase_220311_random;import java.util.Random;public class Test {public static void main(String[] args) {//学习Random类//&＃xff08;1&＃xff09;利用带参数的构造器创建对象&＃xff08;相对用得比较少&＃xff09;Random r1 &＃61; new Random(System.currentTimeMillis());System.out.println(r1.nextInt());//&＃xff08;2&＃xff09;利用空参构造器创建对象Random r2 &＃61; new Random();//表面是在调用无参构造器&＃xff0c;底层还是在调用带参构造器System.out.println(r2.nextInt(10));System.out.println(r2.nextDouble());}
}

Math.random()

String

1、直接使用&＃xff0c;无需导包

package java.lang;


2、形象地说一下

* The {&＃64;code String} class represents character strings.


3、所有字符串字面常量都是String的具体 实例/对象

* All string literals in Java programs, such as {&＃64;code "abc"}, are* implemented as instances of this class.


4、字符串是不可变的

* Strings are constant;


5、String类不能有子类&＃xff0c;不可以被继承

public final class String


6、字符串底层是一个char类型的数组

private final char value[];


7、常用方法

&＃xff08;1&＃xff09;Constructor
底层就是给对象底层的value数组进行赋值操作

String s1 &＃61; new String("abc");String s2 &＃61; new String(new char[]{&＃39;a&＃39;,&＃39;b&＃39;,&＃39;c&＃39;});


&＃xff08;2&＃xff09;length、isEmpty、charAt

//字符串长度System.out.println("s1的长度&＃xff1a;"&＃43;s1.length());//s1的长度&＃xff1a;3//是否为空String s3 &＃61; new String();System.out.println("s3为空&＃xff1a;"&＃43;s3.isEmpty());//s3为空&＃xff1a;trueSystem.out.println("s1为空&＃xff1a;"&＃43;s1.isEmpty());//s1为空&＃xff1a;false//charAtSystem.out.println("s1的第3个字符&＃xff1a;"&＃43;s1.charAt(2));//s1的第3个字符&＃xff1a;c


&＃xff08;3&＃xff09;equals&＃xff08;重点&＃xff09;
比较字符串内容&＃xff0c;而非比较对象

String s6 &＃61; new String("abc");String s7 &＃61; new String("edf");System.out.println(s6.equals(s7));//false


&＃xff08;4&＃xff09;compareTo&＃xff08;重点&＃xff09;
String类实现了Comparable接口&＃xff0c;里面有一个抽象方法叫compareTo&＃xff0c;所以String一定要对这个方法重写
只要字符串不一样&＃xff0c;返回非0

String s8 &＃61; new String("abc");String s9 &＃61; new String("abc");System.out.println(s8.compareTo(s9)); //0


&＃xff08;5&＃xff09;subString、concat、replace、split、toUpperCase、toLowerCase、trim
subString&＃xff1a;字符串的截取
concat&＃xff1a;字符串的合并/拼接
replace&＃xff1a;字符串中字符的替换
split&＃xff1a;按照指定的字符串分裂为数组
trim&＃xff1a;去除首尾空格

String s10 &＃61; new String("abcdefjk");System.out.println(s10.substring(3));//defjkSystem.out.println(s10.substring(2,6));//[3,6)


System.out.println(s10.concat("bbb"));//abcdefjkbbb


String s11 &＃61; s10.replace("k","c");System.out.println(s11);//abcdefjc


String s12 &＃61; new String("a-b-c-d-e-f");String[] strs &＃61; s12.split("-");System.out.println(Arrays.toString(strs));//[a, b, c, d, e, f]


注意此处Arrays.toString的使用

String s12 &＃61; new String("a-b-c-d-e-f");System.out.println(s12.toUpperCase());//A-B-C-D-E-FSystem.out.println(s12.toUpperCase().toLowerCase());//a-b-c-d-e-f


String s13 &＃61; new String(" a b c ");System.out.println(s13.trim());//a b c


&＃xff08;6&＃xff09;valueOf&＃xff1a;转换为String类型

System.out.println(String.valueOf(13));//13System.out.println(String.valueOf(13.4));//13.4System.out.println(String.valueOf(false));//false


8、String的内存分析

&＃xff08;1&＃xff09;字符串拼接


内存&＃xff1a;

&＃xff08;2&＃xff09;new关键字创建对象

String s6 &＃61; new String("abc");


内存&＃xff1a;开辟两个空间&＃xff08;1.字符串常量池中的字符串 2.堆中开辟的对象空间&＃xff09;

&＃xff08;3&＃xff09;有变量参与的字符串拼接

package msb.javase.oop.javase_220312_string;public class Test2 {public static void main(String[] args) {//有变量参与的字符串拼接String a &＃61; "abc";String b &＃61; a &＃43; "def"; //a变量在编译时不知道a的值是"abc"&＃xff0c;所以不会进行编译期优化&＃xff0c;不会直接合并为"abcdef"System.out.println(b);}
}

a变量在编译时不知道a的值是"abc"&＃xff0c;所以不会进行编译期优化&＃xff0c;不会直接合并为"abcdef"

反编译&＃xff08;反汇编&＃xff09;过程&＃xff1a;为了更好的分析字节码文件是如何进行解析的

1. 重新编译Build->Recompile ‘Test03.java’
2. 在out文件夹找到.class字节码文件&＃xff0c;重新同步syntho/reload
3. Terminal:
   cd out/production/testJava/msb/javase/oop/javase_220312_string/
   javap -c Test2.class

9、可变字符串StringBuilder/StringBuffer

extends AbstractStringBuilder


/*** The value is used for character storage.*/char[] value;/*** The count is the number of characters used.*/int count;


count&＃xff1a;数组有效长度&＃xff08;被使用的长度&＃xff09;

StringBuilder sb &＃61; new StringBuilder();//底层是对value数组进行初始化&＃xff0c;且长度为16StringBuilder sb2 &＃61; new StringBuilder(30);//底层是对value数组进行初始化&＃xff0c;指定长度


表面上调用StringBuilder空构造器&＃xff0c;实际底层是对value数组进行初始化&＃xff0c;且长度固定

public StringBuilder() {super(16);}


public StringBuilder(int capacity) {super(capacity);}


与上述两种情况不同&＃xff0c;传入str的情况下&＃xff0c;源码分析&＃xff1a;

第一部分

StringBuilder sb3 &＃61; new StringBuilder("abc");


1. 第一步

public StringBuilder(String str) {super(str.length() &＃43; 16);append(str);}


2. 第二步

&＃64;Overridepublic StringBuilder append(String str) {super.append(str);return this;}


public AbstractStringBuilder append(String str) {int len &＃61; str.length(); //3ensureCapacityInternal(count &＃43; len);str.getChars(0, len, value, count); //this.value即调用者StringBuilder的valuecount &＃43;&＃61; len; //count数组被使用的长度&＃xff0c;此时为默认值0return this;}


private void ensureCapacityInternal(int minimumCapacity) {// overflow-conscious codeif (minimumCapacity - value.length > 0) { // 3-19&＃61;-16不满足value &＃61; Arrays.copyOf(value,newCapacity(minimumCapacity));}}


public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) { //分别为 0 3 value 0System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin); //此处value为调用者str的底层value&＃xff08;字符串"abc"的value&＃xff09;}


第二部分

字符串append

sb3.append("def");


1. 第一步

public StringBuilder append(String str) {super.append(str);return this;}


2. 第二步

public AbstractStringBuilder append(String str) {int len &＃61; str.length();ensureCapacityInternal(count &＃43; len); //此时count为3str.getChars(0, len, value, count); //"def"调用getCharscount &＃43;&＃61; len;return this;}


private void ensureCapacityInternal(int minimumCapacity) {// overflow-conscious codeif (minimumCapacity - value.length > 0) { //3-19value &＃61; Arrays.copyOf(value,newCapacity(minimumCapacity));}}


public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);}


第三部分

空间不够进行扩容

sb.append("def").append("aaaaaaaa").append("bbb").append("ooooooo");

private void ensureCapacityInternal(int minimumCapacity) {// overflow-conscious codeif (minimumCapacity - value.length > 0) { //24-19>0 空间不够进行扩容value &＃61; Arrays.copyOf(value,newCapacity(minimumCapacity));}}


private int newCapacity(int minCapacity) {// overflow-conscious codeint newCapacity &＃61; (value.length << 1) &＃43; 2; // 19*2 &＃43; 2 &＃61; 40if (newCapacity - minCapacity < 0) {newCapacity &＃61; minCapacity;}return (newCapacity <&＃61; 0 || MAX_ARRAY_SIZE - newCapacity < 0)? hugeCapacity(minCapacity): newCapacity;}


7个o赋值到新的长度为40的空间

PS: return this 才可以串连调用

StringBuilder sb4 &＃61;sb3.append("def").append("aaaaaaaa").append("bbb").append("ooooooo"); //return this 才可以串连调用System.out.println(sb4);//abcdefdefaaaaaaaabbbooooooo