java 常用API 接口 总结

API

API(Application Programming interface) 应用程序编程接口.

通俗来说就是
java已经帮我们写好的，我们直接拿来用的东西。

Ojbect中的 toString方法

public String toString() 默认是返回当前对象在堆内存中的地址信息：类的全限名@内存地址

让子类重写，以便返回子类对象的内容。

equals

默认比较 两个对象的 地址 是否相同。

父类equals方法存在的意义就是为了被子类重写，以便子类自己来定制比较规则。

首先 判断 类型 是否 是 同一个个

正则表达 s.match() 方法

public class Test {

  public static void main(String[] args) {
    System.out.println(check("123dsa"));
    System.out.println(check("1234567"));
    System.out.println(check("null"));
    System.out.println("---------------------");
    System.out.println(check2("123dsa"));
    System.out.println(check2("1234567"));
    System.out.println(check2("null"));
  }

  public static boolean check2(String s1) {
//      /d 表示全部是数字
//      {6,20} 表示 最少 出现 6位， 最多出现 20位
      return s1 != null && s1.matches("\\d{6,20}");
  }

  public static boolean check(String s1) {
      if  (s1 == null && s1.length() < 6 || s1.length() > 20) return false;

      for (int i = 0; i < s1.length(); i++) {
          char c = s1.charAt(i);

          if (c < '0' || c > '9') return false;
      }

      return true;
  }
}
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

匹配规则

例子

Array类接口API

toString ，sort方法 和 binarySearch方法

public class Test {

  public static void main(String[] args) {
      int[] arr = {10,2,55,23,24,100,11};

    System.out.println(arr);
    // 打印数组内容
    System.out.println(Arrays.toString(arr));

    // Arrays自动排序 API
      Arrays.sort(arr);
    System.out.println(Arrays.toString(arr));

    // 二分搜索技术(前提 数组必须排好序)
      // 找到 返回 索引位置，找不到 返回 -1 * 该数字应该插入的位置
    System.out.println(Arrays.binarySearch(arr,3));

  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

[I@6f94fa3e
[10, 2, 55, 23, 24, 100, 11]
[2, 10, 11, 23, 24, 55, 100]
-2
1
2
3
4

Comparator 接口

import java.util.Arrays;
import java.util.Comparator;

public class Test {

  public static void main(String[] args) {
      // Array.sort方法 的默认值的数组 升序排序
      int[] arr = {10,2,55,23,24,100,11};
      Arrays.sort(arr);
      System.out.println("arr1:" + Arrays.toString(arr));

      // 自定义 comparator比较方法， 只能 支持 引用数据类型 排序！！
//      Arrays.sort(arr, new Comparator<>()); // error

      /**
       *  参数1： 被排序数组 必须是 引用类型的 元素
       *  参数2： 匿名内部类对象，代表了一个比较器对象。
       */

      Integer[] arr2 = {10,2,55,23,24,100,11};
    Arrays.sort(
        arr2,
        new Comparator<Integer>() {
          @Override
          public int compare(Integer o1, Integer o2) {
            // 指定 比较规则

//            if (o1 > o2) {
//              return 1;
//            } else if (o1 < o2) {
//              return -1;
//            }
//            return 0;
//            return o1 - o2; // 默认升序
              return o2 - o1; // 修改降序
          }
        });
      System.out.println("arr2:" + Arrays.toString(arr2));
  }
}

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

import java.util.Arrays;
import java.util.Comparator;

public class Test {

  public static void main(String[] args) {


      Student[] students = new Student[3];

      students[0] = new Student("'zzz", 13,178.0);
      students[1] = new Student("'zz", 12,175.0);
      students[2] = new Student("'z", 14,171.0);
      System.out.println(Arrays.toString(students));

      Arrays.sort(students, new Comparator<Student>() {
          @Override
          public int compare(Student s1, Student s2) {
//              return s1.getAge() - s2.getAge(); // 年龄升序
//              return s2.getAge() - s1.getAge(); // 年龄降序

              return Double.compare(s1.getHeight(), s2.getHeight()); // 升序
              return Double.compare(s2.getHeight(), s1.getHeight()); // 降序

          }
      });

    System.out.println(Arrays.toString(students));
  }
}


class Student{
    private String name;
    private int age;
    private double height;


    public Student(String name, int age, double height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }

    public String getName(){
        return this.name;
    }

    public void SetName(String name){
        this.name = name;
    }

    public int getAge(){
        return this.age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", height=" + height +
                '}';
    }
}
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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

Lambda表达式

注意：Lambda表达式只能简化函数式接口的匿名内部类的写法形式

什么是 函数式接口？

首先必须是接口、其次接口中有且仅有一个抽象方法的形式。
通常我们会在接口上加上一个@Functionallnterface注解，标记该接口必须是满足函数式接口。

import java.util.Arrays;
import java.util.Comparator;

public class Test {

  public static void main(String[] args) {

//
//      Swimming s1 = new Swimming() {
//          @Override
//          public void swim() {
//              System.out.println("the Teacher swims very well!");
//          }
//      };
//      go(s1);

//      go(new Swimming() {
//          @Override
//          public void swim() {
//              System.out.println("the Teacher swims very well!");
//          }
//      });


//      Swimming s1 = () -> {
//          System.out.println("the Teacher swims very well!");
//      };
//
//      go(s1);

      go(()-> {System.out.println("the Teacher swims very well!");});

    }

    public static void go(Swimming s) {
    System.out.println("Start!");
    s.swim();
    System.out.println("End!");
    }
}

@FunctionalInterface // 一旦加上这个注解，那么必须是函数接口，里面只能有一个 抽象方法
interface Swimming{
    void swim();
}
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

Lambda简化 借口

Lambda 简化Compatator

Lambda 简化 ActionListener匿名内部类

HashMap遍历

import java.util.HashMap;
import java.util.Map;

public class Test {

  public static void main(String[] args) {
      Map<Integer, Integer> map = new HashMap<>();

      int n = 8;
      for (int i = 1; i < n; i++) {
          map.put(i, i + i);
      }


      for (Integer key: map.keySet()) {
        System.out.println(key);
      }

      for (Integer value: map.values()) {
        System.out.println(value);
      }

      for (Map.Entry<Integer, Integer> entry: map.entrySet()) {
        System.out.println(entry);

      System.out.println("key: " + entry.getKey());
      System.out.println("value: " + entry.getValue());
      }
  }
}
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

1
2
3
4
5
6
7
2
4
6
8
10
12
14
1=2
key: 1
value: 2
2=4
key: 2
value: 4
3=6
key: 3
value: 6
4=8
key: 4
value: 8
5=10
key: 5
value: 10
6=12
key: 6
value: 12
7=14
key: 7
value: 14

Process finished with exit code 0

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