1、字符串类

1.1 String

  1. public final class String     
  2. implements java.io.Serializable, Comparable<String>, CharSequence{}

概述：代表字符串类，Java程序中所有字符串字面值都作为此类的实例实现。String是final类，代表不可变的字符串序列。字符串是常量，在创建之后就不可改变。String对象的字符内容是存储在一个字符数组里面的。

1.1.1 实例化

1）使用字面量的方式

  1. String str = "halo world"

2）使用new关键字

  1. String str = new String("halo world")
  2. // 这种方式创建了两个对象，一个是new在堆中创建了一个String对象，另一个是在字符串常量池中创建了一个字符串常量对象

1.1.2 字符串拼接

1）在连接字符串的时候，两个都是字面值时，则在字符串常量池中声明新的字符串或者指向已存在的字符串常量
2）如果使用变量来连接字符串时，则在堆中开辟一个空间来存储新的字符串对象
3）通过字符串调用intern()，返回此字符串在字符串常量池中的字面量

1.1.3 常用方法

  1. int length() // 返回字符串的长度
  2. char charAt(int index) // 返回索引位置的字符，从0开始
  3. boolean isEmpty() // 判断是否是空字符串
  4. String toLowerCase() // 使用默认语言环境，将 String 中的所有字符转换为小写
  5. String toUpperCase() // 使用默认语言环境，将 String 中的所有字符转换为大写
  6. String trim() // 返回字符串的副本，忽略前导空白和尾部空白
  7. boolean equals(Object obj) // 比较字符串的内容是否相同
  8. boolean equalsIgnoreCase(String anotherString) // 与equals方法类似，忽略大小写
  9. String concat(String str) // 将指定字符串连接到此字符串的结尾。等价于用“+”
  10. int compareTo(String anotherString) // 比较两个字符串的大小
  11. String substring(int beginIndex) // 返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。
  12. String substring(int beginIndex, int endIndex) // 返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
  • （二）
    1. boolean endsWith(String suffix) // 测试此字符串是否以指定的后缀结束
    2. boolean startsWith(String prefix) // 测试此字符串是否以指定的前缀开始 
    3. boolean startsWith(String prefix, int toffset) // 测试此字符串从指定索引开始的子字符串是否以指定前缀开始
    4. boolean contains(CharSequence s) // 当且仅当此字符串包含指定的 char 值序列时，返回 true
    5. int indexOf(String str) // 返回指定子字符串在此字符串中第一次出现处的索引
    6. int indexOf(String str, int fromIndex) // 返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
    7. int lastIndexOf(String str) // 返回指定子字符串在此字符串中最右边出现处的索引 
    8. int lastIndexOf(String str, int fromIndex) // 返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索
    9. String replace(char oldChar, char newChar) // 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的
    10. String replace(CharSequence target, CharSequence replacement) // 使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串
    11. String replaceAll(String regex, String replacement) // 使用replacement替换在调用者中所有的的regex字符串，并返回新的字符串
    12. String replaceFirst(String regex, String replacement) // 使用replacement替换在调用者中的第一个regex字符串，并返回新的字符串

    1.1.4 和其他类相互转化

    1）与包装类型和基本数据类型
    1. String-->包装类、基本数据类型：调用包装类Xxx的parseXxx()
    2. 包装类、基本数据类型--> String：调用String的valueOf()
    3. 这种：String str2 = 123 + ""; 底层需要创建SringBuilder,并调用append()导致效率低于valueOf()
    2）与char数组，byte数组转换

    String—->char[ ]：调动String的toCharArray()

  1. String str1 = "halo";
  2. char[] chars = str1.toCharArray();

编码：String—->byte[ ]：getBytes( )

  1. byte[] bytes = "halo".getBytes();

解码 String的构造器

  1. String str1 = new String(bytes);

1.2 StringBuffer、StringBuilder

jdk8及以前都是使用char数组存储，jdk9以后改为byte数组+字符集存储。

  1. StringBuffer：可变的字符串序列，线程安全，效率略低
  2. StringBuilder：可变的字符串序列，线程不安全，效率高，JDK1.5引入
  • 常用方法 ```java StringBuffer append(xxx) // 提供了很多的append()方法，用于进行字符串拼接 delete(int start,int end) // 删除指定位置的内容 StringBuffer replace(int start, int end, String str) // 把[start,end)位置替换为str StringBuffer insert(int offset,xxx) // 在指定位置插入xxx StringBuffer reverse() // 把当前字符序列逆转 public intindexOf(String str) public String substring(int start,int end) public int length() public char charAt(int n ) public void setCharAt(int n ,char ch) void setLength(int newLength) // 重新设置数组指针

StringBuffer sb =new StringBuffer(“halo”); sb.setLength(1); sb.append(“aaaa”); // 此时 sb—> haaaa

  1. <a name="Texe1"></a>
  2. # 2、Java比较器
  3. > 实现对象的排序，可以考虑实现两个接口：①Comparable，②Comparator
  5. <a name="GyUVh"></a>
  6. ## 2.1 Comparable
  7. ①像String、包装类、Date等已经实现了Comparable接口，则可以实现同一个类的不同对象的大小的比较。<br />②默认情况下，String、包装类、Date等类型进行排序的话，默认从小到大的方式排序<br />③自定义的类，要想实现排序，需要考虑实现Comparable接口，重写compareTo()。在此方法中，指明如何比较大小。<br />标准：如果当前对象大，返回正数，如果当前对象小，返回负数，如果两个对象相等，返回0
  8. ```java
  9. public class ComparableTest implements Comparable {
  10.     private String name;
  11.     private int age;
  12.     public ComparableTest(String name, int age) {
  13.         this.name = name;
  14.         this.age = age;
  15.     }
  16.     @Override
  17.     public int compareTo(Object o) {
  18.         // 按照年龄排序
  19.         if (o instanceof ComparableTest) {
  20.             ComparableTest com = (ComparableTest) o;
  21.             if (this.age < com.age) {
  22.                 return -1;
  23.             } else if (this.age > com.age) {
  24.                 return 1;
  25.             } else {
  26.                 return 0;
  27.             }
  28.         } else {
  29.             throw new RuntimeException("输入的数据类型不一致");
  30.         }
  31.     }
  32.     public static void main(String[] args) {
  33.         ComparableTest com1 = new ComparableTest("lz", 18);
  34.         ComparableTest com2 = new ComparableTest("hkj", 20);
  35.         int i = com1.compareTo(com2);
  36.         if (i == 1) {
  37.             System.out.println("lz年龄大");
  38.         }else if (i==-1){
  39.             System.out.println("hkj年龄大");
  40.         }else {
  41.             System.out.println("lz,hkj年龄相等");
  42.         }
  43.     }
  44. }

2.2 Comparator

1）定制排序
①针对于StringBuffer 或 StringBuilder的多个对象构成的数组，如何实现排序呢？
②针对于String、Date、包装类，如何实现从大到小的顺序排序呢？
③除了使用自然排序之外，还可以使用定制排序：实现Comparator接口
2）使用步骤：
①提供Comparator接口的实现类
②重写compare(Object o1,Object o2),指明对象如何比较大小
③实例化Comparator接口的类，并在需要的位置使用即可。

  1. Goods[] all = new Goods[4];
  2. all[0] = new Goods("War and Peace", 100);
  3. all[1] = new Goods("Childhood", 80);
  4. all[2] = new Goods("Scarlet and Black", 140);
  5. all[3] = new Goods("Notre Dame de Paris", 120);
  6. Arrays.sort(all, new Comparator() {
  7.     @Override
  8.     public int compare(Object o1, Object o2) {
  9.         Goods g1 = (Goods) o1;
  10.         Goods g2 = (Goods) o2;
  11.         return g1.getName().compareTo(g2.getName());
  12.     }
  13. });
  14. System.out.println(Arrays.toString(all));

3、JDK8之前的时间日期API

获取当前时间戳的方式：

  1. System.currentTimeMillis()

  2. new Date().getTime()。

    3.1 Date

    java.util.Date：表示特点的瞬间，精确到毫秒
    1）构造器：

  3. Date()：无参构造器，获取本地当前时间

  4. Date(long date)：以指定的时间来创建date对象

    1. // 创建指定时间戳的date对象
    2. Date date1 = new Date(1584097017656L);

    2）方法：

  5. toString()方法

  6. getTime()：返回当前时间戳

    3.2 SimpleDataFormat

    java.text.SimpleDateFormat：格式化和解析日期的工具类
    这个类可以完成格式化：日期=》文本，解析：文本=》日期
    常用方法：

    1. // 构造器
    2. public SimpleDateFormat() // 默认的模式和语言环境创建对象
    3. public SimpleDateFormat(String pattern) // 该构造方法可以用参数pattern指定的格式创建一个对象，以该格式来格式化Date
    4. // 格式化
    5. public String format(Date date) //方法格式化时间对象date
    6. // 解析
    7. public Date parse(String source) // 从给定字符串的开始解析文本，以生成一个日期

    解析和格式化实例：

    1. public void test(){
    2.  Date date = new Date();
    3.  SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    4.  String s = sdf.format(date);
    5.  System.out.println(s);
    7.  Date d1 = sdf.parse("2019-05-18 22:41:10");
    8.  System.out.println(d1.toString());
    9. }

    3.3 Calendar

    java.util.Calendar：日历类
    Calendar是一个抽象基类，主要用于完成日期字段之间相互操作的功能。
    1）获取Calendar实例对象

  7. 使用Calendar.getInstance()方法

  8. 调用它的子类GregorianCalendar的构造器

2）Calendar的实例是系统时间的抽象表示，通过get(int field)方法来取得想要的时间信息。

  1. 比如YEAR、MONTH、DAY_OF_WEEK、HOUR_OF_DAY 、MINUTE、SECOND

  2. 常用方法：

    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)

    注意：
    ①获取月份时：一月是0，二月是1，以此类推，12月是11
    ②获取星期时：周日是1，周二是2 ， 。。。。周六是7

    1. Calendar calendar = Calendar.getInstance();
    2. // 从一个 Calendar 对象中获取 Date 对象
    3. Date date = calendar.getTime();
    4. // 使用给定的 Date 设置此 Calendar 的时间
    5. date = new Date(234234235235L);
    6. calendar.setTime(date);
    7. calendar.set(Calendar.DAY_OF_MONTH, 8);
    8. System.out.println("当前时间日设置为8后,时间是:" + calendar.getTime());
    9. calendar.add(Calendar.HOUR, 2);
    10. System.out.println("当前时间加2小时后,时间是:" + calendar.getTime());
    11. calendar.add(Calendar.MONTH, -2);
    12. System.out.println("当前日期减2个月后,时间是:" + calendar.getTime());

    4、Math类

    4.1 常用方法

    1. abs(int/long/float/double) // 绝对值
    2. acos,asin,atan,cos,sin,tan // 三角函数
    3. sqrt() // 平方根
    4. pow(double a,doble b) // a的b次幂
    5. log() // 自然对数
    6. exp() // e为底指数
    7. max(double a,double b) 
    8. min(double a,double b)
    9. random() // 返回0.0到1.0的随机数
    10. long round(double a) // double型数据a转换为long型（四舍五入）
    11. toDegrees(double angrad) // 弧度—>角度
    12. toRadians(double angdeg) // 角度—>弧度

    4.2 四个取整的方法

    ①floor：向下取整，意思就是取一个比它小并且是最接近它的整数
    ②ceil：向上取整，意思是取一个比它大并且是最接近它的整数
    ③rint：返回一个最接近次数的整数，如果有两个，那么取偶数那个
    ④round：四舍五入，返回值是long类型

    1. public class Test1 {
    2.  public static void main(String[] args) {
    3.      double d1 = 19.3;
    4.      double d2 = -3.8;
    6.      System.out.println(Math.floor(d1)); // 19.0
    7.      System.out.println(Math.ceil(d1)); // 20.0
    8.      System.out.println(Math.rint(d2)); // -4.0
    9.      System.out.println(Math.round(d2)); // -4
    10.      long round = Math.round(d2); // 返回值是long类型
    11.  }
    12. }

    5、Object类

    Object类是所有其他类的根父类、根基类。任何一个类（除了Object类）如果没有显式的声明其父类的话，则默认继承于java.lang.Object类。 Object中的常用方法：equals()，toString() 了解：finalize()，wait()，notify()，hashCode()，getClass()

5.1 equals()

  1. // JDK8源码 
  2. public boolean equals(Object obj) {     
  3.     return (this == obj); 
  4. }

此方法比较两个对象的地址是否相等。
和 == 相比：

  • == 在比较基本类型的数据时，只比较两个数值是否相等。在比较引用类型时，只有地址相同才会返回true。
  • equals() 只能比较引用类型，不能比较基本类型，其作用与“==”相同,比较是否指向同一个对象。

注意：在String类中，equals()方法已经被重写，比较的是两个字符串是否相同。除此之外，在File，Date，包装类（Wrapper Class）来说，也是重写了equals() 方法，不是单单比较两个对象的地址是否相等。

5.2 toString()

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

①toString()方法在Object类中定义，其返回值是String类型，返回类名和它的引用地址。
②在进行String与其它类型数据的连接操作时，自动调用toString()方法。

  1. Date now=new Date();
  2. System.out.println("now=" + now);  相当于
  3. System.out.println("now=" + now.toString());

③可以根据需要在用户自定义类型中重写toString()方法。如String 类重写了toString()方法，返回字符串的值。

  1. s1="hello";
  2. System.out.println(s1); // 相当于System.out.println(s1.toString());

④基本类型数据转换为String类型时，调用了对应包装类的toString()方法

  1. int a = 10;   
  2. System.out.println("a=" + a);

5.3 clone()

  1. // JDK8源码
  2. protected native Object clone() throws CloneNotSupportedException;

在自己创建的类中，如果想要使用基类中的clone() 方法，那么需要实现接口 Cloneable。clone() 方法克隆处理的对象是通过浅拷贝的。如果类中的属性有引用类型，那么它和它拷贝的对象的属性是一致的，执行地址相同。

6、包装类

针对八种基本数据类型定义相应的引用类型—包装类（封装类）。有了类的特点，就可以调用类中的方法，Java才是真正的面向对象。

基本数据类型 包装类 父类
byte Byte Number
short Short Number
int Integer Number
long Long Number
float Float Number
double Double Number
boolean Boolean Object
char Character Object 
  1. // 数值的包装类型都继承了Number类和实现了Seriable接口
  2. extends Number implements Comparable
  1. public class WrapperTest {
  2.     public static void main(String[] args) {
  3.         Integer i1 = 200;
  4.         Integer i2 = 200;
  5.         Integer i3 = 100;
  6.         Integer i4 = 100;
  7.         /**
  8.          * 在 -127 ~ 128 之间，数值是从缓冲池中返回的，指向的是同一个对象
  9.          * 如果不在此区间之内，那么这时候会隐式地创建一个Integer对象
  10.          */
  11.         System.out.println(i1 == i2); //false
  12.         System.out.println(i3 == i4); //true
  13.     }
  14. }

6.1 装箱

意思是：将基本数据类型包装成包装类的实例。

  • 可以通过包装类的构造器实现

    1. int i = 500;   
    2. Integer t = new Integer(i);

    6.2 拆箱

    意思是：将包装类对象拆分出基本数据类型变量

  • 调用包装类的 .xxxValue() 方法

    1. boolean b = bObj.booleanValue();

    在JDK1.5后，支持自动装箱，自动拆箱，但是类型必须匹配上。

    7、JDK中常用工具类

    JDK中内置了很多常用的工具类，且多以“s”结尾，如：集合工具类Collections，数组工具类Arrays，对象工具类Objects，文件工具类Files，路径工具类Paths，数学工具类Maths；但也有一些不是以“s”结尾的工具类，如TimeUnit和System。

    7.1 Objects

    1.   /**
    2.    * equals，判断两个对象是否相等，两者都可以为null
    3.    */
    4.   @Test
    5.   public void equalsTest() {
    6.       Person person = new Person();
    7.       Person person1 = new Person();
    8.       boolean b = Objects.equals(person, person1);
    9.       System.out.println(b);
    10.   }
    12.   /**
    13.    * isNull，判读是否为空
    14.    */
    15.   @Test
    16.   public void nullTest(){
    17.       String str1 = "";
    18.       String str2 = null;
    19.       System.out.println(Objects.isNull(str1)); // false
    20.       System.out.println(Objects.isNull(str2)); // true
    21.   }

    7.2 Arrays

    1. public class ArraysTest {
    2.   int[] arr = new int[]{1, 4, 6, 8, 3};
    4.   /**
    5.    * 对数组进行排序
    6.    */
    7.   @Test
    8.   public void sortTest() {
    9.       Arrays.sort(arr);
    10.       // 13468
    11.       Arrays.stream(arr).forEach(System.out::print);
    12.   }
    14.   /**
    15.    * 使用二分查找来找到数组中的特定值，并返回索引下标
    16.    * 注意：数组必须是有序的
    17.    */
    18.   @Test
    19.   public void searchTest() {
    20.       Arrays.sort(arr);
    21.       int i = Arrays.binarySearch(arr, 3);
    22.       System.out.println(i);
    23.   }
    25.   /**
    26.    * 使用指定值来填充数组，数组的所有元素都相等
    27.    */
    28.   @Test
    29.   public void fillTest() {
    30.       Arrays.fill(arr, 9);
    31.       Arrays.stream(arr).forEach(System.out::print);
    32.   }
    34.   /**
    35.    * 复制数组，可以字有指定长度，窃取或者使用默认值填充
    36.    */
    37.   @Test
    38.   public void copyTest() {
    39.       int[] res = Arrays.copyOf(arr, 4);
    40.       Arrays.stream(arr).forEach(System.out::print);
    41.       System.out.println();
    42.       Arrays.stream(res).forEach(System.out::print);
    43.   }
    44. }
    1.   /**
    2.    * toString，将数组打印转化为字符串，方便打印
    3.    * stream，获取数组流
    4.    */
    5.   @Test
    6.   public void test(){
    7.       String s = Arrays.toString(arr);
    8.       System.out.println(s);
    9.       Arrays.stream(arr).forEach(System.out::print);
    10.   }

    7.3 System

    系统类，主要用于获取系统的属性数据，构造方法私有，不能实例化。
    有一个 Properties 属性，可以存储一些环境变量的数据，在JVM加载的时候，这个属性开始实例化，就存入一些当前本地环境的一些 kv 值

    1. @Test
    2. public void test1() {
    3.   System.setProperty("halo", "java");
    4.   Properties properties = System.getProperties();
    5.   for (Map.Entry<Object, Object> entry : properties.entrySet()) {
    6.       // 打印 System 中存储的一些环境变量
    7.       System.out.println(entry.getKey() + " : " + entry.getValue());
    8.   }
    9. }

获取当前时间的秒级时间值

  1. @Test
  2. public void test2() {
  3.     // 获取当前时刻的毫秒级
  4.     System.out.println(System.currentTimeMillis());
  5.     // 获取当前时刻的纳秒级
  6.     System.out.println(System.nanoTime());
  7. }