常用类

字符串相关的类：String

String的特性

  • String类：代表字符串。Java程序中的所有字符串字面值（如“abc”）都作为此类的实例实现。

  • String是一个final类，代表不可变的字符序列。不可被继承的。

    • 体现：当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值。
    • 当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。
    • 当调用String的replace()方法修改字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。

  • String实现了Serializable接口：表示字符串是支持序列化的。

  • String实现了Comparable接口：表示String可以比较大小。

  • 字符串是常量，用双引号引起来表示。它们的值在创建之后不能更改。

  • String对象的字符内容是存储在一个字符数组value[]中的。

  • 通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串值声明在字符串常量池中。

    • 代码演示

      1. public void Test1(){
      2.    String s1="abc";//字面量的定义方式
      3.    String s2="hello";
      4.    s1="hello";
      6.    System.out.println(s1==s2);//比较s1和s2的地址值
      8.    System.out.println(s1);
      9.    System.out.println(s2);
      11. }

  • 字符串常量池中是不会存储相同内容的字符串。

    • 图示：

String对象的创建

String str =”hello”;

String s1 = new String();

String s2 = new String(String original);

String s3 = new String(char[] a);

String s4 = new String(char[] a,int stratIndex,int count);

  • 字符串常量存储在字符串常量池，目的是共享。

  • 字符串非常量对象存储在堆中。

  • String S = new String(“abc”);方式创建对象，在内存中创建了几个对象？

    • 两个：一个是堆空间中new结构，另一个是char[]对应的常量池中的数据：”abc”。
    1.   public void Test3(){
    2.       String s1="javaEE";
    3.       String s2="hadoop";
    4.       String s3="javaEEhadoop";
    5.       String s4="javaEE"+"hadoop";
    6.       String s5=s1+"hadoop";
    7.       String s6="javaEE"+s2;
    8.       String s7=s1+s2;
    9.       System.out.println(s3==s4);
    10.       System.out.println(s3==s5);
    11.       System.out.println(s3==s6);
    12.       System.out.println(s3==s7);
    13.   }
  • 结论：常量与常量拼接结果再常量池。且常量池中不会存在相同内容的常量。
  • 只要其中有一个是变量，结果就是再堆中。
  • 如果拼接的结果调用intern()方法，返回值就在常量池中。
    • 代码练习: ```java package String;

public class StringTest1 { String str=new String(“good”); char[] ch={‘t’,’e’,’s’,’t’};

  1. public void change(String str,char ch[]){
  2.     str="test ok";
  3.     ch[0]='b';
  4. }
  6. public static void main(String[] args) {
  7.     StringTest1 ex=new StringTest1();
  8.     ex.change(ex.str, ex.ch);
  9.     System.out.println(ex.str);//引用类型传的是地址，且String是不可变的，所以change方法中的str指向的是外部定义的str的地址。
  10.     System.out.println(ex.ch);
  11. }

}

  4. <a name="80d15176"></a>
  5. ### String类与基本数据类型转换
  7. - 
  8. **字符串** **——>** **基本数据类型、包装类**
  10.    - 
  11. Integer包装类的public static int **parseInt(String s)**：可以将由“数字”字
  12. <br />    符组成的字符串转换为整型。
  14.    - 
  15. 类似地,使用java.lang包中的Byte、Short、Long、Float、Double类调相应
  16. <br />    的类方法可以将由“数字”字符组成的字符串，转化为相应的基本数据类型。
  18. - 
  19. **基本数据类型、包装类** **——>  **字符串
  21.    - 
  22. 调用String类的public String **valueOf(int n)**可将int型转换为字符串
  24.    - 
  25. 相应的valueOf(byte b)、valueOf(long l)、valueOf(float f)、valueOf(double
  26. <br />    d)、valueOf(boolean b)可由参数的相应类型到字符串的转换
  28. - 
  29. 字符数组——>字符串
  31.    - String类的构造器：String(char[])和String(char[],int offset,int length)分别用字符数组中的全部字符和部分字符创建字符串对象。
  32. - 
  33. 字符串——>字符数组
  35.    - public char[] toCharArray()：将字符串中的全部字符放在一个字符数组中的方法。
  36.    - public void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)：提供了将指定索引范围内的字符串放到数组中的方法。
  37. - 
  38. 代码练习：
  40. - 
  41. ```java
  42. package String;
  44. import org.junit.Test;
  46. public class StringTest2 {
  47.     @Test
  48.     public void test(){
  49.         String str1="123";
  50.         int num=Integer.parseInt(str1);
  51.         System.out.println(num);
  53.         num=234;
  54.         String str2=String.valueOf(num);
  55.         System.out.println(str2);
  56.     }
  58.     @Test
  59.     public void test2(){
  60.         String str1="abc123";
  61.         char[] charArray=str1.toCharArray();
  62.         for (int i = 0; i < charArray.length; i++) {
  63.             System.out.print(charArray[i]+"\t");
  64.         }
  66.         char[] array=new char[]{'h','e','l','l','o'};
  67.         String str2=new String(array);
  68.         System.out.println(str2);
  69.     }
  70.     @Test
  71.     public void test3(){
  72.         String str1="abc123";
  73.         char[] charArray=str1.toCharArray();
  74.         for (int i = 1; i <=2; i++) {
  75.             char  temp=' ';
  76.             temp=charArray[i];
  77.             charArray[i]=charArray[5-i];
  78.             charArray[5-i]= temp;
  79.         }
  80.         String s = new String(charArray);
  81.         System.out.println(s);
  82.     }
  83. }

String常用方法

  • int length:返回字符串的长度：return value.length。
  • char charAt(int index)：返回某索引处的字符return value[index]。
  • boolean isEmpty()：判断是否是空字符串：return value.length == 0。
  • String toLowerCase()：使用默认语言环境，将String中的所有字符转换为小写。
  • String toUpperCase()：使用默认语言环境，将String中的所有字符串转换为大写。
  • String trim()：返回字符串的副本，忽略前导空白和尾部空白。
  • boolean equals(Object obj)：比较字符串的内容是否相同。
  • boolean equalsIgnoreCase(String anotherString)：与equals方法类似，忽略大小写。
  • String concat(String str)：将指定字符串连接到此字符串的结尾。等价于用“+”。
  • int compareTo(String anotherString)：比较两个字符串的大小。
  • String substring(int beginIndex)：返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。
  • String substring(int beginIndex，int endIndex)：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex（不包含）的一个子字符串。
  • boolean endsWith(String suffix)：测试此字符串是否以指定的后缀结束。
  • boolean startsWith(String prefix)：测试此字符串是否以指定的前缀开始。
  • boolean startsWith(String prefix,int toffset)：测试此字符串从指定索引开始的字符串是否以指定前缀开始。
  • boolean contains(CharSequence s)：当且仅当此字符串包含指定的char值序列时，返回true。
  • int indexOf(String str)：返回指定子字符串在此字符串中第一次出现的索引。
  • int indexOf(String str,int fromlndex)：返回指定子字符串在此字符串中第一次出现的索引，从指定的索引开始。
  • int lastIndexOf(String str)：返回指定子字符串在此字符串中最右边出现处的索引。

  • int lastIndexOf(String str,int fromIndex)：返回指定子字符串在此字符串中最后一次出现的索引，从指定的索引开始反向搜索。

    • indexOf和lastIndexOf方法如果未找到都是返回-1.
  • String replace(char oldChar,char newChar)：返回一个新的字符串，它是通过用newChar替换此字符串中出席那的所有oldChar得到的。
  • String replace(CharSequence target,CharSequence replacement)：使用指定的字面值替换序列替换此字符串所有匹配字面值的子字符串。
  • String replaceAll(String regex,String replacement)：使用给定的replacement替换此字符串所有匹配给定的正则表达式的子字符串。
  • String replaceFirst(String regex,String replacemnet)：使用给定的replacement替换此字符串匹配给定的正则表达式的第一个子字符串。
  • boolean mathces(String regex)：告知此字符串是否匹配给定的正则表达式。
  • String[] split(String regex)：根据给定的正则表达式拆分此字符串。
  • String[] split(String regex,int limit)：根据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。

StringBuffer和StringBuilder

  • String、StringBuffer、StringBuilder三者的异同

    • String：不可变的字符序列。底层使用char[]进行存储。
    • StringBuffer：可变的字符序列。线程安全的，效率低。底层使用char[]存储。
    • StringBuilder：可变的字符序列。线程不安全的，效率高。底层使用char[]存储。

  • StringBuffer类的常用方法

    • StringBuffer apend(xxx)：提供了很多的append()方法，用于进行字符串拼接。
    • StringBuffer delete(int start,int end)：删除指定位置的内容。
    • StringBuffer replace(int start,int end,String str)：把[start,end)位置替换为str。
    • StringBuffer insert(int offset,xxx)：在指定位置插入xxx。

    • StringBuffer reversr()：把当前字符序列逆转。

      • 当append和insert时，如果原来value数组长度不够，可扩容。
      • 如上这些方法支持链操作。

日期时间的API

java.util.Date类

表示特定的瞬间

  • 构造器：

    • Date()：使用无参构造器的对象可以获取本地当前时间。创建一个对应当前时间的对象。
    • Date(long date)：创建指定毫秒数的date()对象。

  • 常用方法

    • getTime()：返回自1970年1月1 日00：00：00GMT以来此Date对象表示的毫秒数。
    • toString()：把此Date对象转换为一下形式的String：dow mon ddhh:mm:ss zzz yyyy 其中：dow是一周中的某一天（Sun，Mon，Tue，Wed，Thu，Fri，Sat），zzz是时间标准。就是显示当前时间的年、月、日、时、分、秒。
    • 其他很多方法都过时了。

java.sql.Date

对应着数据库中的日期类型的变量。

  • 如何实例化：

      1. java.sql.Date date = new java.sql.Date();

  • 如何将java.util.date转换为java.sql.date：

    • 强制转换：
      1. Date date1=new java.sql.Date(2323232323233223L);
      2. java.sql.Date date2=(java.sql.Date)date1;
    1. Date date3 = new Date();
    2. java.sql.Date date4=new java.sql.Date(date3.getTime());

SimpleDateFormat的使用

  • SimpleDateFormat对日期Date()类的格式化和解析。

  • 两个操作：

    • 格式化：日期——>指定格式的字符串

      • 代码演示:

        1. SimpleDateFormat sdf = new SimpleDateFormat();
        2. Date d1 = new Date();
        3. System.out.println(d1);
        5. String format = sdf.format(d1);
        6. System.out.println(format);

  • 解析：格式化的逆过程，指定的字符串——>日期

    • 代码演示
      1. String str="2021/3/1 下午3:57";
      2. try {
      3.     Date date = sdf.parse(str);
      4.     System.out.println(date);
      5. } catch (ParseException e) {
      6.     e.printStackTrace();
      7. }

Calendar类

  • Calendar是一个抽象基类，主要用于完成日期字段之间相互操作的功能。

  • 获取Calendar实例的方法：

    • 使用Calendar.Instance()方法。
    • 调用它的子类GregorianCalendar的构造器。
  • 一个Calendar的实例是系统时间的抽象表示，通过get(int filed)方法来取得想要的时间信息。

  • 常用方法

    • get()
    • set()
    • add()
    • getTime()
    • setTime()

LocalDate等

  • LocalDate、LocalTime、LocalDateTime类是较重要的几个类，它们的实例是不可变对象。分别表示使用ISO-8601日历系统的日期，时间，日期时间。它们提供了简单的本地的日期或时间，并不包含当前的时间信息，也不包含与时区相关的信息。

    • LocalDate代表IOS格式（yyy-MM-dd）的日期，可以存储生日、纪念日等日期。
    • LocalTime表示一个时间而不是日期。
    • LocalDateTime是用来表示日期和时间的，是最常用的一个类。

Instant瞬时

  • 时间线上的一个瞬时点。这可能被用来记录应用程序中的时间戳。、

  • 方法

    • now()：静态方法，返回默认UTC时区的instant类的对象。
    • ofEpochMilli(long epochMili)：静态方法，返回在1970-01-01 00:00:00基础上加指定毫秒数之后的instant类的对象。
    • atOffest(ZoneOffest offset)：结合即即时的偏移来创建一个OffsetDateTime。
    • toEpochMilli()：返回1970-01-01 00:00:00到当前时间的毫秒数，即为时间戳。

比较器

  • 在Java中经常会涉及到对象数组的排序问题，那么就涉及到对象之间的比较问题。

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

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

自然排序：java.lang.Comparable

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

  • 实现Comparable的类必须实现CompareTo(Object obj)方法，两个对象即通过compareTo(Object obj)的方法返回值来比较大小。如果当前对象this大于形参对象obj则返回正整数，如果当前对象this小于形参对象obj，则返回负整数，如果当前对象this等于形参对象obj，则返回零。

  • 像String，包装类等实现了Comparable接口，重写了compareTo(obj)方法，给出了两个比较对象大小的方式。

  • 对于自定义类来说，如果需要排序，我们可以让自定义类来实现Compare接口，重写compareTo(obj)方法。在compareTo(obj)方法中指明如何排序。

  • 代码实现： ```java /*

    • 商品类 */

public class Goods implements Comparable{ private String name; private double price;

  1. public Goods() {
  2. }
  4. public Goods(String name, double price) {
  5.     this.name = name;
  6.     this.price = price;
  7. }
  9. public String getName() {
  10.     return name;
  11. }
  13. public void setName(String name) {
  14.     this.name = name;
  15. }
  17. public double getPrice() {
  18.     return price;
  19. }
  21. public void setPrice(double price) {
  22.     this.price = price;
  23. }
  25. @Override
  26. public String toString() {
  27.     return "Goods{" +
  28.             "name='" + name + '\'' +
  29.             ", price=" + price +
  30.             '}';
  31. }
  33. //指明商品比较大小的方式:按照价格从低到高进行排序
  34. @Override
  35. public int compareTo(Object o) {
  36.     if (o instanceof Goods){
  37.         Goods goods=(Goods) o;
  38.         if (this.price>goods.price){
  39.             return 1;
  40.         }else if (this.price<goods.price){
  41.             return -1;
  42.         }else {
  43.             return 0;
  44.         }
  45.     }
  46.     throw new RuntimeException("传入的类型不一致");
  47. }

}

  2. ```java
  3.     @Test
  4.     public void test2(){
  5.         Goods[] array=new Goods[4];
  6.         array[0]=new Goods("手机",6000);
  7.         array[1]=new Goods("电脑",8000);
  8.         array[2]=new Goods("平板",5000);
  9.         array[3]=new Goods("鞋子",1000);
  11.         Arrays.sort(array);
  13.         System.out.println(Arrays.toString(array));
  15.     }

定制排序

  • 当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码，
    或者实现了java.lang.Comparable接口的排序规则不适合当前的操作，那
    么可以考虑使用 Comparator 的对象来排序，强行对多个对象进行整体排
    序的比较。

  • 重写compare(Object o1,Object o2)方法，比较o1和o2的大小：如果方法返
    回正整数，则表示o1大于o2；如果返回0，表示相等；返回负整数，表示
    o1小于o2。

  • 可以将 Comparator 传递给 sort 方法（如 Collections.sort 或 Arrays.sort），
    从而允许在排序顺序上实现精确控制。

  • 还可以使用 Comparator 来控制某些数据结构（如有序 set或有序映射）的
    顺序，或者为那些没有自然顺序的对象 collection 提供排序。

  1.  public void test4(){
  2.         String[] str= new String[]{"aa","dd","ee","ff","gg"};
  3.         Arrays.sort(str, new Comparator() {
  4.             @Override
  5.             public int compare(Object o1, Object o2) {
  6.                 if (o1 instanceof String && o2 instanceof String){
  7.                     String s1= (String) o1;
  8.                     String s2= (String) o2;
  9.                     return -s1.compareTo(s2);
  10.                 }
  11.                 throw new RuntimeException("输入的类型数据不一致");
  12.             }
  13.         });
  14.         System.out.println(Arrays.toString(str));
  15.     }

System类

  • System类代表系统，系统级的很多属性和控制方法都放置在该类的内部。该类位于java.lang包。

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

  • 成员变量

    • System类内部包含in、out和err三个成员变量，分别代表标准输入流(键盘输入)，标准输出流(显示器)和标准错误输出流(显示器)。

  • 成员方法

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

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

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

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

  1. public void test1(){
  2.         String javaVersion = System.getProperty("java.version");
  3.         System.out.println("java的version:" + javaVersion);
  4.         String javaHome = System.getProperty("java.home");
  5.         System.out.println("java的home:" + javaHome);
  6.         String osName = System.getProperty("os.name");
  7.         System.out.println("os的name:" + osName);
  8.         String osVersion = System.getProperty("os.version");
  9.         System.out.println("os的version:" + osVersion);
  10.         String userName = System.getProperty("user.name");
  11.         System.out.println("user的name:" + userName);
  12.         String userHome = System.getProperty("user.home");
  13.         System.out.println("user的home:" + userHome);
  14.         String userDir = System.getProperty("user.dir");
  15.         System.out.println("user的dir:" + userDir);
  16.     }

Math类

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

abs 绝对值

acos,asin,atan,cos,sin,tan 三角函数

sqrt 平方根

pow(double a,doble b) a的b次幂

log 自然对数

exp e为底指数

max(double a,double b)

min(double a,double b)

random() 返回0.0到1.0的随机数

long round(double a) double型数据a转换为long型（四舍五入）

toDegrees(double angrad) 弧度—>角度

toRadians(double angdeg) 角度—>弧度

BigInteger与BigDecimal

  • Integer类作为int的包装类，能存储的最大整型值为2 31-1，Long类也是有限的，最大为2 63-1。如果要表示再大的整数，不管是基本数据类型还是他们的包装类都无能为力，更不用说进行运算了。
  • java.math包的BigInteger可以表示不可变的任意精度的整数。BigInteger 提供所有 Java 的基本整数操作符的对应物，并提java.lang.Math 的所有相关方法。另外，BigInteger 还提供以下运算：模算术、GCD 计算、质数测试、素数生成、位操作以及一些其他操作。

  • 构造器

    • BigInteger(String val)：根据字符串构建BigInteger对象。

BigInteger类

  • 常用方法：

    • public BigInteger abs()：返回此 BigInteger 的绝对值的 BigInteger。
    • BigInteger add(BigInteger val) ：返回其值为 (this + val) 的 BigInteger
    • BigInteger subtract(BigInteger val) ：返回其值为 (this - val) 的 BigInteger
    • BigInteger multiply(BigInteger val) ：返回其值为 (this * val) 的 BigInteger
    • BigInteger divide(BigInteger val) ：返回其值为 (this / val) 的 BigInteger。整数相除只保留整数部分。
    • BigInteger remainder(BigInteger val) ：返回其值为 (this % val) 的 BigInteger。
    • BigInteger[] divideAndRemainder(BigInteger val)：返回包含 (this / val) 后跟(this % val) 的两个 BigInteger 的数
    • BigInteger pow(int exponent) ：返回其值为 (thisexponent) 的 BigInteger。

BigDecimal类

  • 一般的Float类和Double类可以用来做科学计算或工程计算，但在商业计算中，要求数字精度比较高，故用到java.math.BigDecimal类。
  • BigDecimal类支持不可变的、任意精度的有符号十进制定点数。

  • 构造器

    • public BigDecimal(double val)
    • public BigDecimal(String val)
    • 常用方法
    • public BigDecimal add(BigDecimal augend)
    • public BigDecimal subtract(BigDecimal subtrahend)
    • public BigDecimal multiply(BigDecimal multiplicand)
    • public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)
  1. public void testBigInteger() {
  2. BigInteger bi = new BigInteger("12433241123");
  3. BigDecimal bd = new BigDecimal("12435.351");
  4. BigDecimal bd2 = new BigDecimal("11");
  5. System.out.println(bi);
  6. // System.out.println(bd.divide(bd2));
  7. System.out.println(bd.divide(bd2, BigDecimal.ROUND_HALF_UP));
  8. System.out.println(bd.divide(bd2, 15, BigDecimal.ROUND_HALF_UP));
  9. }