8.从零开始学习Java-常用类_resctype

常用类

一、内部类

1.1 概念：

在一个类的内部再定义一个完整的类。

例如：Outer$Inner.class//内部类

1.2 特点：

• 编译之后可生成独立的字节码文件。
• 内部类可直接访问外部类的私有成员，而不破坏封装。
• 可为外部类提供必要的内部功能组件。

public class Outer {
    private int a;
     private class Inner{//为外部类提供必要的内部功能组件
        public void m1(){
            System.out.println("innter method - m1()" + a);//可访问外部类的私有成员
        }
    }
}
1
2
3
4
5
6
7
8

1.3 分类：

1.3.1 成员内部类（实例级别）

//实例级别

//实例变量又叫成员变量

在类的内部定义，与实例变量、实例方法同级别的类。
外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象。

• Outer out = new Outer();
• Outer.Inner in = out.new Inner();

public class Outer {
    private int a;
    class Inner{//为外部类提供必要的内部功能组件
        int b;
        public void m1(){
            System.out.println("innter method - m1()" + a);//可访问外部类的私有成员,封装依旧在
        }
    }
}
public class TestMember {
    public static void main(String[] args){
//        Inner inner = new  Inner();//错误，不能脱离外部类对象而独立存在
        Outer outer = new Outer();
        //创建成员内部类的对象（必须依赖外部类对象）,静态内部类不需要此步，即不依赖外部类对象。
        Outer.Inner inner = outer.new Inner();
        System.out.println(inner.b);
        inner.m1();
//        System.out.println(outer.a);//错误，封装依然在，无法从外部获取，需要依赖成员内部类获取。
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

当外部类、内部类存在重名属性时，会优先访问内部类属性。
成员内部类不能定义静态成员//内部类需要依赖外部类存在的

public class Outer {
    private int a = 10;
    class Inner{//为外部类提供必要的内部功能组件
        int a = 20;
        /*static*/ String field = "abc";//内部成员类不能定义静态成员
        public void m1(){
            int a = 30;
            System.out.println("innter method - m1()" + a);//内部类可以访问自身局部变量
            System.out.println("innter method - m1()" + this.a);//内部类可以直接访问内部类的实例变量
            System.out.println("innter method - m1()" + Outer.this.a);//内部类可以访问外部类实例变量
        }
    }
}
结果：
innter method - m1()20
innter method - m1()20
innter method - m1()10
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

1.3.2 静态内部类（静态级别）

//静态级别

//静态内部类需要有静态方法

• 不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员。
• 只能直接访问外部类的静态成员（实例成员需实例化外部类对象）。

• Outer.Inner inner = new Outer.Inner();

• Outer.Inner.show();

public class TestStaticClass {

	public static void main(String[] args) {
		//外部类的静态属性
		System.out.println(Outer.a);	
		//外部类的静态方法
		Outer.m1();
		//创建静态内部类对象时，可以直接通过完整名称进行创建
		Outer.Inner in = new Outer.Inner();//静态内部类的创建，不依赖外部类的对象	
		//创建内部类对象后，访问实例属性和方法
		System.out.println(in.b);
		in.m2();
		//&&额外比成员内部类多了一个定义的内容（静态属性和静态方法）&&	
		//通过外部类类名.内部类类名.内部类的静态属性
		System.out.println(Outer.Inner.field);
		//通过外部类类名.内部类类名.内部类的静态方法
		Outer.Inner.m3();
	}
}

class Outer{
	static int a = 10;
	static class Inner{
		int b = 20;	
		static String field = "abc";	
		public void m2(){
			System.out.println("Inner m2()");
		}		
		public static void m3(){
			System.out.println(a);
		}		
	}	
	static void m1(){
		System.out.println("Outer m1()");
	}	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

//逻辑代码不能写在类下，可以写在结构里，方法里。

public class Bank {//银行功能业务模块
    /*
    //User [] users = new User[5];//1.实例属性赋值
    static User[] users = new User[5];//对外不可见
    //static {} 2.静态代码块（第二选择方法）
    static {
        users[0] = new User();
        users[1] = new User();
    }

    {
        //3.动态代码块（第三选择方法）
    }

    public Bank(){//4.构造方法，靠前执行(但为了不是每次创建对象覆盖一次，不能写在这里)
        users[0] = new User("张三", 1);
    }
    public void login(){

    }
    */
    private static class Information {
        private static User[] users = new User[5];
        static {
            users[0] = new User();
            users[1] = new User();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

1.3.3 局部内部类（局部级别）

//局限于当前方法

• 定义在外部类方法中，作用范围和创建对象范围仅限于当前方法。
• 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final。
• 限制类的使用范围。

//对象在堆中，局部变量在栈中，两者回收时机不同，栈中内容立即回收，对象不会立即回收，伴随的垃圾收集器回收。

//局部变量的生命周期可能和局部内部类对象的生命周期不一致。加入fianl可以保证局部变量的生命周期大于内部类对象的声明周期。

public class Outer {
    int a = 10;//外部类的实例变量
    public void m1(){
        //外部类方法的局部变量
        final String local = "Hello";
        //局部内部类
        class Inner{
            int a = 20;//内部类的实例变量
            public void m2(){
                int a = 30;//局部变量
                System.out.println("Inner -- m2"+a);
                System.out.println("Inner -- m2"+local);//访问外部类的局部变量，
            }

        }

        Inner in = new Inner();//局部内部类，方法块结束后就没有了。
        in.m2();
    }
    public static void m2(){

    }
}

public class TestLocalClass {
    public static void main(String[] args){
        //m1
        Outer outer = new Outer();
        outer.m1();

        //m2
        Outer.m2();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

public class TestSchool {
    public static void main(String[] args){
//        Teacher t1 = new AdvencedTeacher();
//        t1.teach();

        Teacher t = School.randomChoose(1);
        t.teach();
    }
}
class School{
    public static Teacher randomChoose(int classNo){
        //隐藏类信息
        class BeginnerTeacher extends Teacher{
            @Override
            public void teach() {
                System.out.println("初级老师在上课");
            }
        }
        class AdvencedTeacher extends Teacher{
            @Override
            public void teach() {
                System.out.println("高级老师在上课");
            }
        }
        Teacher t = null;
        if (classNo % 2!=0){
            t = new AdvencedTeacher();
        }else {
            t = new BeginnerTeacher();
        }
        return t;
    }
}
abstract class Teacher{
    public abstract void teach();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

1.3.4 匿名内部类

//不需要独立定义，定义类，实现类，创造对象，三步合一。

• 没有类名的局部内部类（一切特征都与局部内部类相同）。
• 必须继承一个父类或者实现一个接口。
• 定义类、实现类、创建对象的语法合并，只能创建一个该类的对象。
• 优点：减少代码量。

• 缺点：可读性较差。

 public class TestSchool {
    public static void main(String[] args){
//        Teacher t1 = new AdvencedTeacher();
//        t1.teach();

        Teacher t = School.randomChoose(1);
        t.teach();
    }
}
class School{
    public static Teacher randomChoose(int classNo){
        //隐藏类信息（局部内部类）
        class BeginnerTeacher extends Teacher{
            @Override
            public void teach() {
                System.out.println("初级老师在上课");
            }
        }
        class AdvencedTeacher extends Teacher{
            @Override
            public void teach() {
                System.out.println("高级老师在上课");
            }
        }
        Teacher t = null;
        if (classNo % 2!=0){
            t = new AdvencedTeacher();
            //匿名内部类,符合程序员开发规则，书写习惯，但是需要频繁创建对象。
            t = new Teacher() {//想要xxx的实现类，直接用，然后在方法里面实现
                @Override
                public void teach() {
                    System.out.println("匿名内部类，注意后面的分号");
                }
            };
        }else {
            t = new BeginnerTeacher();
        }
        return t;
    }
}
abstract class Teacher{
    public abstract void teach();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

二、Object类

2.1 特点：

• 超类、基类，所有类的直接或间接父类，位于继承树的最顶层。
• 任何类，如没有书写extends显示继承某个类，都默认直接继承Object类， 否则为间接继承。
• Object类中所定义的方法，是所有对象都具备的方法。
• Object类型可以存储任何对象。

• 作为参数，可接受任何对象。
• 作为返回值，可返回任何对象。

public class TestObject {
    public static void main(String[] args){
      Object o = new Object();//不是抽象类
        Object o2 = new Cat();
    }
    public static void method(Object object){

    }
    public void me(){

    }
    public static Object buyVehicle(int n){
        return null;//可返回任何对象
    }
}

class Dog{}
class Cat{}
class Student{}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

使用API文档：

2.2 getClass()方法

• public final Class<?> getClass(){}
• 返回引用中存储的实际对象类型。
• 应用：通常用于判断两个引用中实际存储对象类型是否一致。

package java0807;

public class TestGetClass {
    public static void main(String[] args){
      Student1 s = new Student1();
      System.out.println(s.getClass());
      Object o = new Object();
      System.out.println(o.getClass());
      Anmial1 a = new Dog1();
      System.out.println(a.getClass());
      Anmial1 anmial1 = new Cat1();//当成什么看，其实还是Cat
//      if (anmial1 instanceof Dog1){
//          if (a instanceof Dog1){
//              System.out.println();
//          }
//      }else if (a instanceof Cat1){
//          if (anmial1 instanceof Cat1){
//
//          }
//      }
        if (anmial1.getClass() == a.getClass()){
            System.out.println("一样");
        }else {
            System.out.println("不一样");
        }
    }
}
class Student1{}
class Dog1 extends Anmial1{}
class Cat1 extends Anmial1{}
abstract class Anmial1{}
测试结果：
class java0807.Student1
class java.lang.Object
class java0807.Dog1
不一样
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

2.3 hashCode()方法

• public int hashCode(){}
• 返回该对象的十进制的哈希码值。
• 哈希算法根据对象的地址或字符串或数字计算出来的int类型的数值。
• 哈希码并不唯一，可保证相同对象返回相同哈希码，尽量保证不同对象返回 不同哈希码。

public class TestHashCode {
    public static void main(String[] args){
        for (int i = 0; i < 5; i++) {
            Object o = new Object();
            System.out.println(o.hashCode() + "\t" + o);//o=o.toString
        }
    }
}
测试结果：
460141958	java.lang.Object@1b6d3586
1163157884	java.lang.Object@4554617c
1956725890	java.lang.Object@74a14482
356573597	java.lang.Object@1540e19d
1735600054	java.lang.Object@677327b6
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.4 toString()方法

• public String toString(){}
• 返回该对象的字符串表示（表现形式）。
• 可以根据程序需求覆盖该方法，如：展示对象各个属性值。

//官方的toString方法。

//存储的实际对象类型+“@”+哈希码的十六进制表示。

public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
1
2
3

//例如： java.lang.Object@1b6d3586

public class TestHashCode {
    public static void main(String[] args){
        for (int i = 0; i < 5; i++) {
            Object o = new Object();
//            System.out.println(o.hashCode() + "\t" + o);
//            System.out.println("  ");
//            System.out.println(o.hashCode() + "\t" + o.toString());
            Object o1 = new Teacher1("h1",11,"男");
            System.out.println(o1.toString());
            System.out.println(((Teacher1) o1).toString1());
        }
    }
}
class Teacher1{
    String name;
    int age;
    String sex;

    public Teacher1(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public String toString1(){
        //自己可以重写tostring方法
       // return this.getClass().getName() + "@" +Integer.toHexString(this.hashCode());
        return this.name + "\t" + this.age + "\t" + this.sex;
    }
    @Override
    public String toString() {
        return "Teacher1{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
}
测试结果 ：
Teacher1{name='h1', age=11, sex='男'}
h1	11	男
Teacher1{name='h1', age=11, sex='男'}
h1	11	男
Teacher1{name='h1', age=11, sex='男'}
h1	11	男
Teacher1{name='h1', age=11, sex='男'}
h1	11	男
Teacher1{name='h1', age=11, sex='男'}
h1	11	男
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

2.5 equals()方法覆盖步骤

• 比较两个引用是否指向同一个对象。（地址相同，直接true，无需比较）
• 判断obj是否为null。（空的直接false）
• 判断两个引用指向的实际对象类型是否一致。（比较类型，getclass或instanceof，不一致就false）
• 强制类型转换。
• 依次比较各个属性值是否相同。（最后再依次比较属性值）

//==比较的是地址。

public class TestEquals {

	public static void main(String[] args) {
		/*
		Object o = new Object();
		
		Object o2 = new Object();
		
		System.out.println(o.equals(o2));
		
		System.out.println(o == o2);//无法人为干预
		*/				
		//两个地址不同，而内容相同的对象（可以进行比较）
		Object s1 = new Student("tom",20,"男",99D);
		
		Object s2 = new Student(new String("tom"),20,"男",99D);
		
		System.out.println(s1 == s2);//false 表示两个对象的地址不同		
		System.out.println(s1.equals(s2));//true 表示两个地址不同而内容相同的对象属于重复对象				
		//情况1（自己和自己比）
		//s1.equals(s1);		
		//情况2（自己和null比）
		//s1.equals(null);		
		//情况3（自己和公交车比）
		//s1.equals(new Bus());		
	}
}
//this ---> s1
class Student{
	String name;
	int age;
	String sex;
	double score;
	public Student(String name, int age, String sex, double score) {
		super();
		this.name = name;
		this.age = age;
		this.sex = sex;
		this.score = score;
	}
	
	@Override
	public boolean equals(Object obj){		
		System.out.println("Executed");		
		if(this == obj){
			 return true;
		}
		if(obj == null){
			return false;
		}		
		
		if(this.getClass() != obj.getClass()){
			return false;
		}		
		Student s = (Student)obj;				
		//使用this的各个属性值与o的各个属性值一一进行比较，如果所有属性都全完相同，则代表二者相同
		if(this.name.equals(s.name)  && this.age.equals(s.age) && this.sex.equals(s.sex) && this.score.equals(s.score)){//源码中八种包装类型+String都覆盖了equals方法
			return true;
		}		
		return false;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

//覆盖加@override，避免出错。

2.6 equals()方法

• public boolean equals(Object obj){}
• 默认实现为(this == obj)，比较两个对象地址是否相同。
• 可进行覆盖，比较两个对象的内容是否相同。

2.7 finalize()方法

//一个对象的遗言。

//java有自动回收垃圾机制。目前交由jvm自动管理。

//用以标记垃圾对象。

• 当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象， 进入回收队列。
• 垃圾对象：没有有效引用指向此对象时，为垃圾对象。（必须要为有效引用）（可达性分析算法引用为引用）
• 垃圾回收： 由GC销毁垃圾对象，释放数据存储空间。
• 自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象。
• 手动回收机制：使用System.gc(); 通知JVM执行垃圾回收。（不是立即执行，只是通知，会有延迟。）

三、包装类

3.1 概念：

• 基本数据类型所对应的引用数据类型。
• Object可统一所有数据，包装类的默认值是null。

3.2 包装类对应：

3.3 类型转换与装箱、拆箱:

//基本类型和包装类型对象之间的转型，基本类型转换为包装类型为装箱，包装类型转换为基本类型为拆箱。

//有自动装箱和自动拆箱以后，两者的使用基本没有差别，只是包装类型对象有方法，而基本类型没有。

• 8种包装类提供不同类型间的转换方式：

• • Number父类中提供的6个共性方法。
• • parseXXX()静态方法（除了Character）。
• • valueOf()静态方法。

• 注意：需保证类型兼容，否则抛出NumberFormatException异常。

public class TestEncapasulate {
    public static void main(String[] args){
//Byte Short Integer Long Float Double 都具有将自身类
// 型的对象，转换成其他6中基本类型的方法
        //将包装类型转换为基本类型
        Short s = new Short("10");
        byte v1 = s.byteValue();
        short v2 = s.shortValue();
        int v3 = s.intValue();
        long v4 = s.longValue();
        float v5 = s.floatValue();
        double v6 = s.doubleValue();

        System.out.println(v1);
        System.out.println(v2);
        System.out.println(v3);
        System.out.println(v4);
        System.out.println(v5);
        System.out.println(v6);

        //将字符串转换成byte
        byte b1 = Byte.parseByte("123");
        byte b2 = new Byte("123").byteValue();
        //将字符串转换成int
        int i1 = Integer.parseInt("234");
        int i2 = new Integer("345").intValue();

        //valueOf
        Byte b3 = Byte.valueOf((byte)123);

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

• JDK 5.0之后，自动装箱、拆箱。基本数据类型和包装类自动转换。

3.4 整数缓冲区

• Java预先创建了256个常用的整数包装类型对象。
• 在实际应用当中，对已创建的对象进行复用。

源码实现：

    private static class ShortCache {
        private ShortCache(){}

        static final Short cache[] = new Short[-(-128) + 127 + 1];

        static {
            for(int i = 0; i < cache.length; i++)
                cache[i] = new Short((short)(i - 128));
        }
    }
1
2
3
4
5
6
7
8
9
10

测试：

public class TestAutoEncap {
    public static void main(String[] args){
        //语法糖（Java语言规范）
        Byte b = 10;//自动装箱 调用valueOf（byte b）
        Byte b3 = 20;
        byte b2 = b;//自动拆箱 调用byteValue(); shortValue()  intValue() BooleanValue()
        Object o = 10;
        m(20);
        Short s1 = 100;//从长度为256的数组中，取出预先创建好的一个Short对象（此对象代表整数100）0x7777
        //常量缓存，高频内容进行复用
        Short s2 = 100;

        Short s3 = 200;//0x1234
        Short s4 = 200;//0x6789

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

    }
    public static void m(Object o){
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

四、String

4.1 特点

• Java程序中的所有字符串文本（例如“abc”）都是此类的实例。
  字符串字面值是常量，创建之后不可改变。

//源码实现：
public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];
   ...
1
2
3
4
5
6

• 字符串字面值存储再字符串池中，可以共享。
• 常用创建方式：
  • String str1 = “Hello”;//产生一个对象，字符串池中存储。
  • String str2 = new String(“World”);//产生两个对象，堆、池各存储一个。

public class TestString {
    public static void main(String[] args){
        System.out.println("abc");
        String s = "abc";
        s+="d";//地址不同,存储在字符串池中
        System.out.println(s);
    }
}
1
2
3
4
5
6
7
8

public class TestString2 {
    public static void main(String[] args){
      String s1 = "abc";//产生1个对象
      String s2 = "abc";//没有产生对象
      String s3 = new String("abc");//再新创建一个对象
      System.out.println(s1 == s2);//true
      System.out.println(s1 == s3);//false
    }
}
class TestString3{
    public static void main(String[] args){
        String s3 = new String("abc");//池中创建一个对象，堆中创建一个对象
        String s1 = "abc";//0
        String s2 = "abc";//0
        System.out.println(s1 == s2);//true
        System.out.println(s1 == s3);//false
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

4.2 常用方法：

String(byte[] bytes, Charset charset) 
构造一个新的String由指定用指定的字节的数组解码charset 。 
1
2

• public char charAt(int index)：根据下标获取字符。

• public boolean contains(String str)：判断当前字符串中是否包含str。

• public char[] toCharArray()：将字符串转换成数组。

//源码实现：
public char[] toCharArray() {
    // Cannot use Arrays.copyOf because of class initialization order issues
    char result[] = new char[value.length];
    System.arraycopy(value, 0, result, 0, value.length);//复制一份
    return result;
}
1
2
3
4
5
6
7

• public int indexOf(String str)：查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1。

• public int length()：返回字符串的长度。

//源码实现：
    public int length() {
        return value.length;
    }
1
2
3
4

• public String trim()：去掉字符串前后的空格。

• public String toUpperCase()：将小写转成大写。

• public boolean endsWith(String str)：判断字符串是否以str结尾。

• public String replace(char oldChar,char newChar)：将旧字符串替换成新字符串

• public String[] split(String str)：根据str做拆分。

• public String subString(int beginIndex,int endIndex)：在字符串中截取出一个子字符串。

public class TestStringMethods {
   public static void main(String[] args){
     String s1 = "HelloMyWorld";


     System.out.println(s1.charAt(6));//y

     System.out.println(s1.contains("lo"));//true

       char[] chs = s1.toCharArray();
       for (int i = 0; i < chs.length; i++) {
           chs[i] = 'A';//全部变成A，但是s1并没有变化啊。
           System.out.println(chs[i]);//输出为数组
       }

       System.out.println(s1.indexOf("W"));//可以为AS码，也可以为“字符”。//通过字符拿下标
       System.out.println(s1.indexOf("lo"));//可以为AS码，也可以为“字符”。//通过字符拿下标
       System.out.println(s1.indexOf("o",5 ));

       s1.length();

       String s2 = "                   he        llo           ";//                   he        llo
       System.out.println(s2.trim());//he        llo

       String s3 = s1.toUpperCase();
       String s4 = s1.toLowerCase();

       System.out.println(s3.equals(s4));//false
       System.out.println(s3.equalsIgnoreCase(s4));//true

       String fileName = "HelloWorld.java";
       System.out.println(fileName.endsWith(".java"));//true
       System.out.println(fileName.startsWith("Hello"));//true

       System.out.println(s1.replace('o', '0'));//Hell0MyW0rld

       String s5 = "你好，大家好，都挺好";
//        String[] strings = s5.split("，");//注意符号的中英文
       String[] strings1 = s5.split("好");//注意符号的中英文
       for (String string : strings1) {
           System.out.println(string);
       }

       String s6 = s1.substring(3,7);//只截取3，4，5，6//loMy
       System.out.println(s6);

   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

4.3 可变字符串：

//可变的特性，可变的话和String比，应该用StringBuffer，初始容量为16

• 概念：可在内存中创建可变的缓冲空间，存储频繁改变的字符串。
• 常用方法：

​ • public StringBuilder append(String str)
• StringBuilder：可变长字符串，JDK5.0提供，运行效率快、线程不安全。
• StringBuffer：可变长字符串，JDK1.0提供，运行效率慢、线程安全。

public class TestStringBuffer {
    public static void main(String[] args){
      String s1 = "abc";
      String s2 = "abc";//s1和s2对应常量池同一地址。可共享的内容
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("abc");//追加，存储在堆中
    }
}

public class TestStringBuffer2 {
    public static void main(String[] args){
      String empName = "lmc";
      String email = appendEnds(empName);
      System.out.println(email);
    }
    public static  String appendEnds(String emailName){
        //百度公司 @baidu.com.cn
        StringBuffer buffer = new StringBuffer();
        buffer.append("@baidu.com.cn");
        return buffer.toString();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

public class TestStringBuilder {
    public static void main(String[] args){
      String str = "Hello";//定义字符串Hello
        str += "World";
        //1.创建StringBuilder对象
        //2.调用append追加的方法
        //3.调用toString转换回String
        System.out.println(str);//打印追加后的str
    }
}
1
2
3
4
5
6
7
8
9
10

五、BigDecimal类

//double是近似值存储

很多实际应用中需要精确运算，而 double是近似值存储，不再符合要求， 需要借助BigDecimal。

位置：

java.math包中。

作用：

精确计算浮点数。

创建方式：

BigDecimal bd=new BigDecimal(“1.0”);

方法：

• BigDecimal add(BigDecimal bd) 加

• BigDecimal subtract(BigDecimal bd) 减

• BigDecimal multiply(BigDecimal bd) 乘

• BigDecimal divide(BigDecimal bd) 除

利用BigDecimal可以进行数值计算：

• 除法：divide(BigDecimal bd,int scal,RoundingMode mode)
• 参数scale ：指定精确到小数点后几位。
• 参数mode ：

• 指定小数部分的取舍模式，通常采用四舍五入的模式，
• 取值为BigDecimal.ROUND_HALF_UP。

public class TestBigDecimal {
    public static void main(String[] args){
        BigDecimal bigDecimal1 = new BigDecimal("2.2");//字符串构建
        BigDecimal bigDecimal2 = new BigDecimal("2.2");//字符串构建
        System.out.println(bigDecimal1);
        BigDecimal add = bigDecimal1.add(bigDecimal2);//ctil+alt+v
        System.out.println(add);//add.sout
        BigDecimal subtract = bigDecimal1.subtract(bigDecimal2);
        System.out.println(subtract);
        BigDecimal multiply = bigDecimal1.multiply(bigDecimal2);
        System.out.println(multiply);
        BigDecimal divide = bigDecimal1.divide(bigDecimal2, 2, BigDecimal.ROUND_UP);
        System.out.println(divide);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

六、时间类型

6.1 Date

• Date表示特定的瞬间，精确到毫秒。

• Date类中的大部分方法都已经被Calendar类中的方法所取代。
• 时间单位

• 1秒=1000毫秒
• 1毫秒=1000微秒
• 1微秒=1000纳秒

6.2 Calendar

• Calendar提供了获取或设置各种日历字段的方法。

• protected Calendar() 构造方法为protected修饰，无法直接创建该对象。

• 其他方法

6.3 SimpleDateFormat

• SimpleDateFormat是以与语言环境有关的方式来格式化和解析日期的类。

• 进行格式化（日期 -> 文本）、解析（文本 -> 日期）。

• 常用的时间模式字母

七、Math

Math类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

八、Random

• 此类的实例用于生成伪随机数流。

• 此类使用 48 位的种子，使用线性同余公式 (linear congruential form) 对其进行了修改所得。

若long种子确定，则在不同程序中，相同次数产生的随机数是相同的。

九、System类

System系统类，主要用于获取系统的属性数据和其他操作。

十、Runtime类

每个 Java 应用程序都有一个Runtime类实例，使应用程序能够与其运行的 环境相连接。可以通过getRuntime方法获取当前运行时。

修改JVM运行内存

• 修改堆初始内存大小：-Xms300m
• 修改堆最大内存大小：-Xmx4000m
• 修改栈空间大小：-Xss2m jdk1.5之前256k jdk1.5之后1m

总结：

内部类：

• 在一个类的内部再定义一个完整的类。包含：成员内部类、静态内部类、局部内部类、匿名内部类。

Object类：

• 所有类的直接或间接父类，可存储任何对象。

包装类：

• 基本数据类型所对应的引用数据类型，可以使Object统一所有数据。

String类：

• Java程序中的所有字符串文本（例如“abc”）都是此类的实例。字符串字面值是常量，创建之后不可改变。

BigDecimal：

• 可精确计算浮点数。

时间相关类：Date、Calendar、SimpleDateFormat、System