Java常用类库

不是小桔

已于 2022-03-21 22:17:18 修改

阅读量802

点赞数

文章标签： java

于 2022-03-21 11:26:51 首次发布

本文链接：https://blog.csdn.net/qq_48965607/article/details/123614796

版权

1.1、StringBuffer类（重点）

1.1、StringBuffer类（重点）

String类的特点：

· String类的对象有两种实例化方式，一种是直接赋值，只会开辟一块堆内存空间，而且对象可以自动入池，另外一种方式使用构造方法完成，会开辟两块空间，有一块空间将成为垃圾，并且不会自动入池，但是可以通过intern()方法手工入池；

· 字符串常量一旦声明则不可改变，而字符串对象可以改变，但是改变的是其内存地址的指向；

通过以上的几个特点就可以清楚的发现，String类是表示字符串使用最多的类，但是其不适合于被频繁修改的字符串操作上，所以在这种情况下，往往可以使用StringBuffer类，即：StringBuffer类方便用户进行内容的修改。在String类之中使用“+”作为数据库的连接操作，而在StringBuffer类之中使用append()方法进行数据的连接。

范例：使用StringBuffer操作，StringBuffer的内容可以改变

public class TestDemo {
	public static void main(String[] args) throws Exception {
		StringBuffer buf = new StringBuffer();
		buf.append("Hello ").append("World ."); // 连接内容
		fun(buf);
		System.out.println(buf);
	}
	public static void fun(StringBuffer temp) {
		temp.append("\n").append("Hello MLGB");
	}
}

运行结果：

Hello World .
Hello MLGB

StringBuffer类在日后主要用于频繁修改字符串的操作上，但是在任何的开发之中，面对字符串的操作，98%都先考虑String，只有那2%会考虑StringBuffer。

现在表示字符串的操作类就有了两个：String、StringBuffer，那么下面通过这两个类的定义来研究一下关系：

String类：

StringBuffer类：

public final class String

extends Object

implements Serializable, Comparable<String>, CharSequence

public final class StringBuffer

extends Object

implements Serializable, CharSequence

现在发现String和StringBuffer类都实现了一个CharSequence接口，日后一定要记住，如果看见了CharSequence最简单的理解做法就是传字符串，但是虽然这两个类是同一个接口的子类，不过这两个类对象之间却不能互相直接转型。

操作一： 将String变为StringBuffer

方法一：直接利用StringBuffer类的构造方法，public StringBuffer(String str)
```
public class TestDemo {
	public static void main(String[] args) throws Exception {
		String str = "Hello World ." ;
		StringBuffer buf = new StringBuffer(str);
		System.out.println(buf);
	}
}
```
- 方法二：利用StringBuffer类的append()方法
- ```
public class TestDemo {
	public static void main(String[] args) throws Exception {
		String str = "Hello World ." ;
		StringBuffer buf = new StringBuffer();
		buf.append(str) ;
		System.out.println(buf);
	}
}
```
  操作二：将StringBuffer变为String，利用StringBuffer类的toString()方法完成
  - ```
  public class TestDemo {
  	public static void main(String[] args) throws Exception {
  		StringBuffer buf = new StringBuffer();
  		buf.append("Hello World .") ;
  		String str = buf.toString() ;
  		System.out.println(str); 
  	}
  }
```
  在String类之中定义了许多的操作方法，同样，在StringBuffer类之中也定义了许多的操作方法，而且有些方法还是String类所有没有的支持。
- 范例：字符串反转操作，public StringBuffer reverse()
- ```
public class TestDemo {
	public static void main(String[] args) throws Exception {
		StringBuffer buf = new StringBuffer();
		buf.append("Hello World .") ;
		System.out.println(buf.reverse()); 
	}
}
```
    范例：替换指定范围内的数据，public StringBuffer replace(int start, int end, String str)
  - ```
  public class TestDemo {
  	public static void main(String[] args) throws Exception {
  		StringBuffer buf = new StringBuffer();
  		buf.append("Hello World .") ;
  		System.out.println(buf.replace(6, 12, "MLDN")); 
  	}
  }
```
  范例：在指定位置上插入数据，public StringBuffer insert(int offset, 数据类型变量)
  - ```
  public class TestDemo {
  	public static void main(String[] args) throws Exception {
  		StringBuffer buf = new StringBuffer();
  		buf.append("World .").insert(0, "Hello ") ;
  		System.out.println(buf); 
  	}
  }
```
    面试题：请解释String和StringBuffer的区别？
    
    String的内容不可改变，而StringBuffer的内容可以改变。
  - 1.2、Runtime类
    -                 在每一个JVM进程之中，都会存在一个运行时的操作类的对象，而这对象所属的类型就是Runtime类。打开这个类的文档可以发现，在这个类之中并没有构造方法定义，可是按照之前所学，每个类至少有一个构造方法，而这个类的构造方法实际上存在只是不被外部看见而已，因为构造方法被私有化了，这是一个标准的单例设计模式，既然是单例设计模式则在这个类就一定会存在一个static型的方法，可以取得本类的实例化对象：public static Runtime getRuntime()。
      
      而当取得了这个类的实例化对象之后，可以利用这个类取得一些JVM的信息，例如：
      
              · 取得最大可用内存：public long maxMemory()；
      
              · 总共可以使用的内存：public long totalMemory()；
      
              · 空闲的内存：public long freeMemory()。
      
      发现取得内存信息的时候所有的数据返回的类型是long，在之前讲解基本数据类型的时候强调long型数据的使用就在两种情况：表示文件大小、表示日期时间。
      
      在Runtime类有一个非常重要的方法：public void gc()，运行垃圾收集器，释放垃圾空间。
      
      public class TestDemo { public static void main(String[] args) throws Exception { Runtime run = Runtime.getRuntime() ; // 取得对象 System.out.println("1.MAX_MEMORY：" + run.maxMemory()); System.out.println("1.TOTAL_MEMORY：" + run.totalMemory()); System.out.println("1.FREE_MEMORY：" + run.freeMemory()); String str = "" ; for (int x = 0; x < 30000; x++) { str += x ; // 产生垃圾 } System.out.println("2.MAX_MEMORY：" + run.maxMemory()); System.out.println("2.TOTAL_MEMORY：" + run.totalMemory()); System.out.println("2.FREE_MEMORY：" + run.freeMemory()); run.gc() ; System.out.println("3.MAX_MEMORY：" + run.maxMemory()); System.out.println("3.TOTAL_MEMORY：" + run.totalMemory()); System.out.println("3.FREE_MEMORY：" + run.freeMemory()); } }
      
      面试题：请解释一下什么叫gc()？Java是如何处理的？
      
              GC（Garbage Collector）：垃圾收集器，可以释放掉垃圾空间所占用的内存。在java之中GC有两种方式处理：一种是由JVM不定期的执行GC操作，另外一种是由用户自己手工调用Runtime类的gc()方法进行垃圾空间的释放。
      
      1.3、System类
      
      System类一直很熟悉，从未被了解，从最早的系统输出，后来的数组拷贝都属于System类的操作，下面来看一下数组排序的方法定义：
      
      · 之前的格式：System.arraycopy(源数组名称，源数组开始点，目标数组名称，目标数组开始点，长度) ;
      
      · System类定义：public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)。
      
      在System类之中有一个取得当前日期时间的方法：public static long currentTimeMillis()。
      
      范例：使用System类的currentTimeMillis()方法来统计一个操作所花费的时间
      
      public class TestDemo { public static void main(String[] args) throws Exception { long start = System.currentTimeMillis(); String str = ""; for (int x = 0; x < 30000; x++) { str += x; // 产生垃圾 } long end = System.currentTimeMillis(); System.out.println("花费的时间：" + (end - start)); } }
      
              在日后的许多开发之中，都会出现自动统计操作时间的功能，出现之后应该可以立刻清楚是通过System.currentTimeMilllis()方法完成的。
      
              可是在System类之中还存在了一个很有意思的方法：public static void gc()，但是这个gc()方法并不是一个新的操作方法，而是间接调用了Runtime类之中的gc()方法，不表示一个重写的方法。
      
      问题：现在如果说一个对象产生的话，可以通过构造方法处理一些对象产生时的操作，但是，当一个对象被回收了呢？发现没有像C++那样的析构函数（对象回收前的收尾），如果现在希望在一个对象收尾的时候执行一些收尾工作，则对象所在的类可以实现一个finalize()方法，此方法由Object类定义：protected void finalize() throws Throwable。在对象回收之前有可能出现异常或者是错误，但是即使出现了，这些错误或者是异常都不会影响程序的执行，即：不会因为异常而导致程序的中断执行。
      
      class Person { public Person() { System.out.println("狂风乱起，地动山摇，海啸，告诉大家：妖孽出生了 —— 玉史"); } @Override protected void finalize() throws Throwable { System.out.println("妖孽被除了。。。玉史：老子18年后又是一条好虫。"); throw new Exception("祸害人间。"); // 抛异常了 } } public class TestDemo { public static void main(String[] args) throws Exception { Person per = new Person(); per = null; // 消失了 System.gc() ; } }
      
      面试题：请解释final、finally、finalize的区别？
      
      · final表示终结器，用于定义不能被继承的父类，不能被覆写的方法，常量；
      
      · finally是异常处理的出口；
      
      · finalize()是Object类定义的一个方法，用于执行对象回收前的收尾操作。
      
      1.4、随机数类：Random
      
              java.util.Random的主要目的是产生随机数，下面直接通过一个代码来观察就行。
      
      范例：产生10个0~100之间的正整数
      
      import java.util.Random; public class TestDemo { public static void main(String[] args) throws Exception { Random rand = new Random(); for (int x = 0; x < 10; x++) { System.out.println(rand.nextInt(101)); } } }
      
      1.5、数学公式类：Math
      
              在java.lang.Math类之中定义了所有的与数学有关的基本公式，在这个类之中所有的方法都是static型的方法，而在这个类只强调一个方法：round()，public static long round(double a)，表示四舍五入。
      
      public class TestDemo { public static void main(String[] args) throws Exception { System.out.println(Math.round(15.5)); // 16 System.out.println(Math.round(15.51)); // 16 System.out.println(Math.round(15.6)); // 16 System.out.println(Math.round(15.2356)); // 15 System.out.println(Math.round(-15.5)); // -15 System.out.println(Math.round(-15.51)); // -16 System.out.println(Math.round(-15.6)); // -16 } }
      
              如果现在使用的是Oracle的round()函数，那么对于-15.5的结果一定是-16，但是Java的Math.round()方法不太一样：如果是负数，其小数位的数值小于5的话，那么不会进位，如果大于了5，才会进位。
      
      1.6、大数字操作类
      
      如果说现在有两个非常大的数字要进行数学操作，你们认为该怎么做？这个时候数字已经超过了double的范围，那么只能利用字符串来表示，取出每一位字符变为数字后进行数学计算，但是这种方式的难度较高，为了解决这样的问题，在Java里面提供了两个大数字操作类：java.math.BigInteger、java.math.BigDecimal，而这两个类是属于Number的子类。
      
      1、 大整数操作类：BigInteger
      
              之前已经强调过了，如果数字较大，肯定按照String来处理，所以这一点可以通过BigInteger的构造方法来观察：
      
              · 构造：public BigInteger(String val)；
      
      而且在BigInteger类之中定义了一些基本的数学计算：
      
              · 加法：public BigInteger add(BigInteger val)；
      
              · 减法：public BigInteger subtract(BigInteger val)；
      
              · 乘法：public BigInteger multiply(BigInteger val)；
      
              · 除法（不保存余数）：public BigInteger divide(BigInteger val)；
      
              · 除法（保存余数）：public BigInteger[] divideAndRemainder(BigInteger val)，数组第一个元素是商，第二个元素是余数；
      
      范例：进行BigInteger的演示
      
      import java.math.BigInteger; public class TestDemo { public static void main(String[] args) throws Exception { BigInteger bigA = new BigInteger("234809234801"); BigInteger bigB = new BigInteger("8939834789"); System.out.println("加法结果：" + bigA.add(bigB)); System.out.println("减法结果：" + bigA.subtract(bigB)); System.out.println("乘法结果：" + bigA.multiply(bigB)); System.out.println("除法结果：" + bigA.divide(bigB)); BigInteger result[] = bigA.divideAndRemainder(bigB); System.out.println("商：" + result[0] + "，余数：" + result[1]); } }
      
      2、 大小数操作类：BigDecimal
      
              BigDecimal类表示的是大小数操作类，但是这个类也具备了与之前同样的基本计算方式，而在实际的工作之中，使用这个类最多的情况是进行准确位数的四舍五入操作，如果要完成这一操作需要关心BigDecimal类中的以下定义：
      
              · 构造：public BigDecimal(double val)；
      
              · 除法：public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)；
      
              · 进位模式：public static final int ROUND_HALF_UP。
      
      范例：完成准确位的四舍五入操作
      
      import java.math.BigDecimal; class MyMath { public static double round(double num, int scale) { BigDecimal big = new BigDecimal(num); BigDecimal result = big.divide(new BigDecimal(1), scale, BigDecimal.ROUND_HALF_UP); return result.doubleValue(); // Number类的方法 } } public class TestDemo { public static void main(String[] args) throws Exception { System.out.println(MyMath.round(15.5, 0)); // 16 System.out.println(MyMath.round(-15.5, 0)); // -15 System.out.println(MyMath.round(168.98765, 2)); // 168.99 } }

不是小桔

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Java常用类库

目录1.1、StringBuffer类（重点）1.2、Runtime类1.3、System类1.4、随机数类：Random1.5、数学公式类：Math1.6、大数字操作类1.1、StringBuffer类（重点）String类的特点：·String类的对象有两种实例化方式，一种是直接赋值，只会开辟一块堆内存空间，而且对象可以自动入池，另外一种方式使用构造方法完成，会开辟两块空间，有一块空间将成为垃圾，并且不会自动入池，但是可以通过intern()方法手工...
复制链接

扫一扫