20210318Java常用类

Java常用类

编辑时间：2021/03/18

读完本节：大概花费40分钟，共4080词

1.StringBuffer、StringBuilder与String之间的转换

1. String --> StringBuffer、StringBuilder：调用StringBuffer、StringBuilder构造器
2. StringBuffer、StringBuilder --> String：①调用String的构造器；②使用StringBuffer、StringBuilder的toString()方法

2.JVM中字符串常量池存放位置说明

1. JDK1.6：字符串常量池存储在方法区（永久区）
2. JDK1.7：字符串常量池存储在堆空间
3. JDK1.8：字符串常量池存储在方法区（元空间）

3.字符串相关类常见算法题目

1. 模拟一个trim方法，去除字符串两端的空格

   使用递归方法实现trim方法去除字符串两端的空格

   /**
    * @Author: xuehai.XUE
    * @MailBox: xuehai.xue@qq.com
    * @Date: 2021/3/17 19:44
    * @Description: 手动实现String中的trim()方法：使用递归方法
    */
   public class MyTrimTest {
       public static void main(String[] args) {
           MyTrimTest tirmTest = new MyTrimTest();
           long start = 0L;
           long end = 0L;
   
           start = System.currentTimeMillis();
           System.out.println("-" + "       123123".trim() + "-");
           end = System.currentTimeMillis();
           System.out.println(end - start);
   
           start = System.currentTimeMillis();
           System.out.println("-" + tirmTest.myTrim("       123123") + "-");
           end = System.currentTimeMillis();
           System.out.println(end - start);
       }
   
       /** 使用递归方法 手动实现 String类 中的 trim()方法 */
       public String myTrim(String string){
           if(string != null && string.length() != 0){
               for (int i = 0; i < string.length(); i++) {
                   if(string.startsWith(" ")){
                       myTrim(string = string.substring(1));
                   }
                   if(string.endsWith(" ")){
                       myTrim(string = string.substring(0, (string.length() - 1)));
                   }
               }
               return string;
           }return "";
       }
   }
   

   String中trim方法的源码

   /**
    * Returns a string whose value is this string, with any leading and trailing
    * whitespace removed.
    * <p>
    * If this {@code String} object represents an empty character
    * sequence, or the first and last characters of character sequence
    * represented by this {@code String} object both have codes
    * greater than {@code '\u005Cu0020'} (the space character), then a
    * reference to this {@code String} object is returned.
    * <p>
    * Otherwise, if there is no character with a code greater than
    * {@code '\u005Cu0020'} in the string, then a
    * {@code String} object representing an empty string is
    * returned.
    * <p>
    * Otherwise, let <i>k</i> be the index of the first character in the
    * string whose code is greater than {@code '\u005Cu0020'}, and let
    * <i>m</i> be the index of the last character in the string whose code
    * is greater than {@code '\u005Cu0020'}. A {@code String}
    * object is returned, representing the substring of this string that
    * begins with the character at index <i>k</i> and ends with the
    * character at index <i>m</i>-that is, the result of
    * {@code this.substring(k, m + 1)}.
    * <p>
    * This method may be used to trim whitespace (as defined above) from
    * the beginning and end of a string.
    *
    * @return  A string whose value is this string, with any leading and trailing white
    *          space removed, or this string if it has no leading or
    *          trailing white space.
    */
   public String trim() {
       int len = value.length;
       int st = 0;
       char[] val = value;    /* avoid getfield opcode */
   
       while ((st < len) && (val[st] <= ' ')) {
           st++;
       }
       while ((st < len) && (val[len - 1] <= ' ')) {
           len--;
       }
       return ((st > 0) || (len < value.length)) ? substring(st, len) : this;
   }
   

2. 将一个字符串进行反转。将字符串中指定的部分进行反转。比如“asdfgh”反转为“agfdsh”

   /**
    * @Author: xuehai.XUE
    * @MailBox: xuehai.xue@qq.com
    * @Date: 2021/3/17 20:02
    * @Description: 实现字符串中指定起始位置和结束位置的字符串反转，
    * 然后将新的反转后的字符串替代原有字符串中的位置，然后返回该字符串
    */
   public class MyReverseTest {
       public static void main(String[] args) {
           MyReverseTest myReverseTest = new MyReverseTest();
           String string = myReverseTest.myInReverse("asdfgh", 1, 5);
           System.out.println(string);
       }
   
       /** 实现字符串中指定起止位置的反转，并替换后输出 */
       public String myInReverse(String string, int beginIndex, int endIndex){
           if(beginIndex < 0 || endIndex > string.length()){
               throw new RuntimeException("起止位置不合法");
           }
           if(string != null && string.length() != 0){
               StringBuffer str = new StringBuffer(string);
               StringBuffer midStr = new StringBuffer(str.substring(beginIndex, endIndex));
               str.replace(beginIndex, endIndex, new String(midStr.reverse()));
   
               return new String(str);
           }
           return null;
       }
   }
   

   /**
    * @Author: xuehai.XUE
    * @MailBox: xuehai.xue@qq.com
    * @Date: 2021/3/18 13:40
    * @Description:
    */
   public class StringReverseDemo {
   
       /** 将一个字符串进行反转，将字符串中指定的部分进行反转，
        *
        * 方式一：转换为char[]
        */
       public String reverse(String str, int startIndex, int endIndex){
           if(str != null){
               char[] arr = str.toCharArray();
               for(int x = startIndex, y = endIndex;x < y;x++, y++){
                   char temp = arr[x];
                   arr[x] = arr[y];
                   arr[y] = temp;
               }
               return new String(arr);
           }
           return null;
       }
   
       /** 方式二：使用String拼接 */
       public String reverse1(String str, int startIndex, int endIndex){
           if(str != null){
               //第一部分：
               String reverseStr = str.substring(0,startIndex);
               //第二部分：
               for(int i = endIndex;i >= startIndex;i--){
                   reverseStr += str.charAt(i);
               }
               //第三部分：
               reverseStr += str.substring(endIndex + 1);
   
               return reverseStr;
           }
           return null;
       }
   
       /** 方式三：使用StringBuffer / StringBuilder替换String */
       public String  reverse2(String str, int startIndex, int endIndex){
           if(str != null){
               StringBuilder builder = new StringBuilder(str.length());
               //第一部分：
               builder.append(str.substring(0,startIndex));
               //第二部分：
               for(int i = endIndex;i >= startIndex;i--){
                   builder.append(str.charAt(i));
               }
               //第三部分：
               builder.append(str.substring(endIndex + 1));
   
               return  builder.toString();
           }
           return null;
       }
   }
   

3. 获取一个字符串在另一个字符串中出现的次数

   import org.junit.Test;
   
   /**
    * @Author: xuehai.XUE
    * @MailBox: xuehai.xue@qq.com
    * @Date: 2021/3/18 16:00
    * @Description: substring 在 mainString 中出现的次数
    */
   public class SubstringCount {
       /** substring 在 mainString 中出现的次数 */
       public int getCount(String mainString, String subString){
           int mainLength = mainString.length();
           int subLength = subString.length();
           int count = 0;
           int index;
   
           if(mainLength >= subLength){
               while((index = mainString.indexOf(subString)) != -1){
                   count++;
                   mainString = mainString.substring(index + subLength);
               }
               return count;
           }else{
               return 0;
           }
       }
   
       @Test
       public void test(){
           SubstringCount substringCount = new SubstringCount();
           System.out.println(substringCount.getCount("asdfghjklhjkl","hjkl"));
       }
   }
   

4. 获取两个字符串中最大的相同子串（tips：将端的哪个串进行长度依次递减的字串与较长的串进行比较）

   /**
    * @Author: xuehai.XUE
    * @MailBox: xuehai.xue@qq.com
    * @Date: 2021/3/18 16:11
    * @Description:
    */
   public class GetMaxSameStringTest {
       /** 获取两个字符串中的最大的相同字串, 仅解决了存在一个最大相同字串 */
       public String getMaxSameString(String str1, String str2){
           String maxStr = (str1.length() >= str2.length()) ? str1 : str2;
           String minStr = (str1.length() < str2.length()) ? str1 : str2;
           int length = minStr.length();
   
           for (int i = 0; i < length; i++) {
               for(int x = 0, y = length - i; y <= length; x++,y++){
                   String subStr = minStr.substring(x,y);
                   if(maxStr.contains(subStr)){
                       return subStr;
                   }
               }
           }
           return null;
       }
   
       /** 如果存在多个长度相同的最大相同字，此时返回String[]，后面可以使用ArrayList替换，较为方便 */
       public String[] getMaxSameString1(String str1, String str2){
           if(str1 != null && str2 != null){
               StringBuffer stringBuffer = new StringBuffer();
               String maxStr = (str1.length() >= str2.length()) ? str1 : str2;
               String minStr = (str1.length() < str2.length()) ? str1 : str2;
   
               int len = minStr.length();
               for (int i = 0; i < len; i++) {
                   for(int x = 0,y = len - i;y <= len; x++, y++){
                       String subString = minStr.substring(x,y);
                       if(maxStr.contains(subString)){
                           stringBuffer.append(subString + ",");
                       }
                   }
                   if(stringBuffer.length() != 0){
                       break;
                   }
               }
               String[] split = stringBuffer.toString().replaceAll(",$","").split(",");
               return split;
           }
           return null;
       }
   }
   

4.java.lang.System类提供的日期API

1. System类提供的public static long currentTimeMillis()用来返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。
2. 时间标准：UTC（Coordinated Universal Time）、GMT（Greenwich Mean Time）、CST（Central Standard Time）

5.java.util.Date类及其子类Java.sql.Date

1. java.util.Date两个未过时的构造器的使用

   1. Date()：创建一个对应当前时间的Date对象
   2. Date(long millisTime)：创建指定毫秒数的Date对象

2. java.util.Date两个未过时的方法的使用

   1. toString()：显示当前的年、月、日、时、分、秒
   2. getTime()：获取当前Date对象对应的毫秒数。（时间戳）

3. 实例化java.sql.Date

   1. Date(long millisTime)：创建指定毫秒数的Date对象

4. 将java.util.Date对象转换为java.sql.Date对象

   1. 情况一：

      java.util.Date date = new java.sql.Date(long millistime);
      java.sql.Date date1 = (java.sql.Date) date;
      

   2. 情况二：

      java.util.Date date = new java.util.Date();
      java.sql.Date date1 = new java.sql.Date(date.getTime());
      

   3. 无论是情况一还是情况二，只要是出现了两个Date类，至少一个要以全类名的形式写出。

6.java.text.SimpleDateFormat类

1. Date类的API不易于国际化，大部分被废弃了，java.text.SimpleDateFormat类是一个不与语言环境有关的方式来格式化和解析日期的具体类。
2. 它允许进行格式化：日期→文本、解析：文本→日期
3. 格式化：
   1. SimpleDateFormat()：默认的语言模式和语言环境创建对象
   2. public SimpleDateFormat(String pattern)：该构造方法可以用参数pattern指定的格式创建对象，该对象调用public String format(Date date)：格式化时间对象date
   3. public String format(Date date)：格式化时间对象date
   4. public Date prase(String source)：从给定字符串的开始解析文本，以生成一个日期。

7.java.util.Calendar类

1. Calendar是以一个抽象基类，主要用于完成日期字段之间相互操作的功能。
2. 获取Calendar实例的方法
   1. 使用Calendar.getInstance()方法
   2. 调用它子类的构造器GregorianCalendar的构造器
3. 一个Calendar的实例时系统时间的抽象表示，通过get(int field)方法来取得想要的时间信息。比如YEAR,MONTH,DAY_OF_WEEK,HOUR_OF_DAY,MINUTE,SECOND
   1. public void set(int field, int value)
   2. public void add(int field, int amount)
   3. public final Date getTime()
   4. public final void setTime(Date date)
4. 使用Carlendar的注意点：
   1. 获取月份时：一月是0，二月是1，依次类推，12月是11
   2. 获取星期时：周日是1，周二是2，一次类推，周六是7

8.JDK8中新日期时间的API

1. Calendar和Date面临的问题：

   可变性：像日期和时间这样的类应该是不可变的

   偏移性：Date中的年份是从1900年开始的，而Calendar则不行

   格式化：格式化只对Date有用，Calendar则不行

   此外，它们线程都不是安全的，不能处理闰秒等

2. 新的时间日期API：

   1. java.time：包含值对象的基础包
   2. java.time.chrono：提供对不同日历系统的访问
   3. java.timeformat：格式化和解析时间和日期
   4. java.time.temporal：包括底层框架和扩展特性
   5. java.time.zone：包含时区支持的类

   

3. 瞬时：instant：时间点上的一个瞬时点。这可能被用来记录应用程序中的事件时间戳。

   1. 时间线中的一个点表示一个很大的数，这有利于计算机处理。在unix中，这个数从1970年开始，以秒为单位，同样的在Java中也是从1970年开始，但是以毫秒为单位
   2. java.time包通过只类型instant提供机器视图，不提供处理人类意义上的时间单位。instant表示时间上的一点，而不需要任何上下文信息。

   

9.其他时间相关的API

1. ZoneId：该类中包含了所有时区的信息，一个时区一个id
2. ZonedDateTime：一个在ISO-8601日历系统时区的日期时间，其中每个时区都对应着ID，地区ID都为“{区域}/{城市}”
3. Clock：使用时区提供对当前即时、日期和时间的访问时钟
4. Duration：持续时间，用于计算两个“时间”的间隔
5. Period：日期间隔，用于计算两个“日期”间隔
6. TemporalAdjuster：时间校正器，有时可能需要获取将日期调整到“下一个工作日”
7. TemporalAdjusters：该类通过静态方法(firstDayOfXxx()/lastDayOfXxx/nextXxx())提供了大量常用TemporalAdjuster的实现

10.与传统日期处理的转换

11.java比较器

1. Java中的对象正常情况下，只能进行==或!=。不能用>或<，但是在开发场景中，需要对多个对象进行排序，这个时候就需要比较对象的大小。实现对象之间大小比较需要借助两个接口中的一个：Comparable或Comparator
2. Comparable接口的使用举例：（自然排序：java.lang.Comparable）
   1. 像String、包装类等实现了Comparable接口，重写了compareTo()方法，给出了比较两个对象大小的规则
   2. 像String、包装类重写了compareTo()方法后，进行了从小到大的排列
   3. 重写compareTo(obj)的规则：
      1. 如果当前对象this大于形参对象obj，则返回正整数
      2. 如果当前对象this小于形参对象obj，则返回负整数
      3. 如果当前对象this等于形参对象obj，则返回零
   4. 对于自定义类来说，如果需要排序，我们可以让自定义类实现Comparable接口，重写compareTo(obj)方法，并在compareTo()中指明如何排序
   5. 实现Comparable接口的对象列表和数组可以通过Collection.sort或Arrays.sort进行自动排序。是仙女此接口的对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器
   6. 对于类C的每一个e1和e2来说，当且仅当e1.compareTo(e2) == 0与e1.equals(e2)具有相同的boolean值时，类C的自然排序才叫做与equals一致。建议（非必须）最好使自然排序与equals一致
3. 定制排序：java.util.Comparator
   1. 当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码，或者实现了java.lang.Comparable接口的排序规则不适合当前的操作，那么可以考虑使用Comparator的对象来排序，强行对多个对象进行整体排序的比较
   2. 重写compare(Object o1,Object o2)方法，比较o1和o2的大小：如果方法返回正整数，则表示o1大于o2；如果返回0，表示相等；返回负整数表示o1小于o2。
   3. 可以将Comparator传递给sort方法（如Collection.sort或Arrays.sort），从而允许在排序顺序上实现精确控制
   4. 还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序
4. Comparable接口与Comparator接口的使用对比：
   1. Comparable接口的方式一旦确定，保证Comparable接口实现类的对象在任何位置都可以比较大小
   2. Comparator接口属于临时性的比较

12.System类

1. System类在java.lang包下，系统级的很多属性和控制方法都放置在该类的内部

2. 由于该类的构造器是private的，所以无法创建该类的对象，也就是无法实例化该类。其内部的成员变量和成员方法都是static的。所以也可以很方便的进行调用

3. 成员变量：System类内部包含in、out、err三个成员变量，分别代表标准输入流（键盘输入），标准输入流（显示器）和标准错误输出流（显示器）

4. 成员方法：

   1. native long currentTimeMillis()：该方法的作用是返回当前计算机的时间，时间的表达式格式为当前计算机时间和GMT时间（格林威治标准时间）1970年1月1日0时0分0秒所差的毫秒数

   2. void exit(int status)：该方法的作用是退出程序。其中status的值为0代表正常退出，非零代表异常退出，使用该方法可以在图形界面编程中实现程序的退出功能等。

   3. void gc()：该方法的作用是请求系统进行垃圾回收。至于系统是否立刻回收，则取决于系统中垃圾回收算法的实现以及系统执行时的情况

   4. String getProperty(String key)：该方法的作用时获得系统中属性名为key的属性对应的值。系统中常见的属性名和以及属性的作用如下表示：

      属性名	属性说明
      java.verson	Java运行时环境版本
      java.home	Java安装目录
      os.name	操作系统的名称
      os.verson	操作系统的版本
      user.name	用户的账户名称
      user.home	用户的主目录
      user.dir	用户的当前工作目录

13.Math类

1. java.lang.Math提供了一系列静态方法用于科学计算。其方法的参数和返回值类型一般都为double型

2. 常用方法：

   方法名	方法功能
   abs	绝对值
   acos\asin\atan\cos\sin\tan	三角函数
   sqrt	平方根
   pow(double a, double b)	a的b次幂
   log	自然对数
   exp	e为低指数
   max(double a, double b)	求最大值
   min(double a, double b)	求最小值
   random()	返回0到1.0的随机数
   long round(double a)	double型数据a转换为long型（四舍五入）
   toDegrees(double angrad)	弧度→角度
   toRadians(double angdeg)	角度→弧度

14.BigInteger与BigDecimal

1. Integer类作为int的包装类，能存储的最大的整型值为2^{31-1，Long类也是有限的，最大为2}63-1如果要表示再大的整数，不管是基本数据类型还是它们的包装类都无能为力，更不用说进行运算了

2. java.math包的BigInteger可以表示不可变的任意精度的整数。BigInteger提供所有Java的基本整数操作符的对应物，并提供java.lang.Math的所有相关方法。另外，BigInteger还提供一下运算：模算数、GCD计算、质数测试、素数生成、位操作以及一些其他操作

3. 构造器：BigInteger(String val)：根据字符串构建BigInteger对象

4. 常用方法：

   

5. BigDecimal类：一般的Float类和Double类可以用来做科学计算或工程计算，但在商业计算中，要求数字精度比较高，故用到java.math.BigDecimal类

6. BigDecimal类支持不可变的，任意精度的有符号十进制定点数

7. BigDecimal类的构造器：

   1. public BigDecimal(double val)
   2. public BigDecimal(String val)

8. BigDecimal常用方法：

   1. public BigDecimal add(BigDecimal augend)
   2. public BigDecimal substract(BigDecimal subtrahend)
   3. public BigDecimal mutiply(BigDecimal multiplicand)
   4. public BigDecimal divide(BigDecimal divicor, int scale, int roundingMode)

STAY ANGER!!!