二、常用 API

1：数组

int[] arr = new int[3];
int[] arr = new int[]{1,2,3,4,5};
int[] arr = {1,2,3,4,5};

Arrays 类

来操作数组的各种方法，比如排序和搜索等。其所有方法均为静态方法，调用起来非常简单。
// 定义 int 数组
int[] arr = {2,34,35,4,657,8,69,9};
// 打印数组,输出地址值
System.out.println(arr); // [I\@2ac1fdc4
// 数组内容转为字符串
String s = Arrays.toString(arr);
public static String toString(int[] a) ：返回指定数组内容的字符串表示形式。
public static void sort(int[] a) ：对指定的 int 型数组按数字升序进行排序。

Vector 类

实现类似动态数组的功能
创建了一个向量类的对象后，可以往其中随意地插入不同的类的对象，既不需顾及类型也不需预先选定向量的容量，并可方便地进行查找。
对于预先不知或不愿预先定义数组大小，并需频繁进行查找、插入和删除工作的情况，可以考虑使用向量类。
构造
public vector() public vector(int initialcapacity,int capacityIncrement) public vector(int initialcapacity)
就算设定了容量，当真正存放的数据个数超过容量时，系统也会扩充向量对象。
方法
插入

• public final synchronized void addElement(Object obj)
• public final synchronized void setElementAt(object obj,int index)
• public final synchronized void insertElementAt(Object obj,int index)

删除

• public final synchronized void removeElement(Object obj)
• public final synchronized void removeAllElement()
• public final synchronized void removeElementlAt(int index)

查询搜索

2：Object 类

Java 语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。在对象实例化的时候，最终找的父类就是 Object。

• public String toString()：返回该对象的字符串表示。
• public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。

这里的“相同”有默认和自定义两种方式。
默认地址比较
如果没有覆盖重写 equals 方法，那么 Object 类中默认进行==运算符的对象地址比较，只要不是同一个对象，结果必然为 false。
对象内容比较
如果希望进行对象的内容比较，即所有或指定的部分成员变量相同就判定两个对象相同，则可以覆盖重写 equals 方法。

• hashCode() ：返回哈希值，

散列值相同的两个对象不一定等价

• clone() ：克隆

浅拷贝 ：拷贝对象和原始对象的引用类型引用同一个对象。
深拷贝 ：拷贝对象和原始对象的引用类型引用不同对象。
wait ，notify notifyall

1：Scanner 类

Scanner sc = new Scanner(System.in);

int b = sc.nextInt();

2：Random 类

Random r = new Random();
int i = r.nextInt();
###

3：ArrayList 类

大小可变的数组的实现，
ArrayList 对象不能存储基本类型，只能存储引用类型的数据。
ArrayList list = new ArrayList<>();
public boolean add(E e) ：将指定的元素添加到此集合的尾部。
public E remove(int index) ：移除此集合中指定位置上的元素。返回被删除的元素。
public E get(int index) ：返回此集合中指定位置上的元素。返回获取的元素。
public int size() ：返回此集合中的元素数。遍历集合时，可以控制索引范围，防止越界。

4：String 类

1：String 类为什么是不可变的 final 类型？

• 为了实现字符串池(只有当字符是不可变的，字符串池才有可能实现）

如果字符串可变的话，当两个引用指向指向同一个字符串时，对其中一个做修改就会影响另外一个。

• 为了线程安全(字符串自己便是线程安全的)
• 为了保证 String 的 HashCode 永远保持一致，每次使用时不用重复计算

(Map 的 key 一般 String 用的最多原因就是这个)，故不能被继承
2：String s=new String(“abc”) 创建了几个对象?
“abc” 创建一个字符对象
new String（） 创建一个引用对象。
String s , 这个语句声明一个类 String 的引用变量 s
3：判断
String a = “AAA”;//常量池地址
String b = new String(“AAA”);//堆的地址
a==b;//false
String s3 = “zs”;
String s4 = “AAAzs”;
String s5 = a + s3;//会new一个对象进行拼接重新指向
s4 == s5;//false
final String s7 =”zs”;
final String s8 =”zs”;
String s9 = s7 + s8;//进行优化，变成常量
String s10 =”zszs”;
s5 == s9//true
“AAA”在常量池里，对象在堆里

5：StringBuilder 与 StringBuffer

线程安全：
StringBuild 线程不安全，StringBuffer 线程安全
执行效率：
StringBuilder > StringBuffer > String
存储空间：
String 的值是不可变的，每次对 String 的操作都会生成新的 String 对象，效率低耗费大量内存空间，从而引起 GC(垃圾回收)。StringBuffer 和 StringBuilder 都是可变。
使用场景：
1 如果要操作少量的数据用 String
2.单线程操作字符串缓冲区 下操作大量数据 = StringBuilder
3.多线程操作字符串缓冲区 下操作大量数据 = StringBuffer
构造

• public StringBuilder()：构造一个空的 StringBuilder 容器。
• public StringBuilder(String str)：构造一个 StringBuilder 容器，并将字符串添加进去。

方法

• public StringBuilder append(…)：添加任意类型数据的字符串形式，并返回当前对象自身。

• public String toString()：将当前 StringBuilder 对象转换为 String 对象。

  锁消除 lock eliminate

  public void add(String str1,String str2){
  StringBuffer sb = new StringBuffer();
  sb.append(str1).append(str2);
  }
  我们都知道 StringBuffer 是线程安全的，因为它的关键方法都是被 synchronized 修饰过的，但我们看上面这段代码，我们会发现，sb 这个引用只会在 add 方法中使用，不可能被其它线程引用（因为是局部变量，栈私有），因此 sb 是不可能共享的资源，JVM 会自动消除 StringBuffer 对象内部的锁。

  锁粗化 lock coarsening

  public String test(String str){

   int i = 0;<br />       StringBuffer sb = new StringBuffer():<br />       while(i < 100){<br />           sb.append(str);<br />           i++;<br />       }<br />       return sb.toString():<br />}<br />JVM 会检测到这样一连串的操作都对同一个对象加锁（while 循环内 100 次执行 append，没有锁粗化的就要进行 100 次加锁/解锁），此时 JVM 就会将加锁的范围粗化到这一连串的操作的外部（比如 while 虚幻体外），使得这一连串操作只需要加一次锁即可。

  6：Math 类

  public static double abs(double a) ：返回 double 值的绝对值。

public static double ceil(double a) ：返回大于等于参数的最小的整数。

public static double floor(double a) ：返回小于等于参数最大的整数。

public static long round(double a) ：返回最接近参数的 long。(相当于四舍五入方法)

8：Date 类

构造
// 创建日期对象，把当前的时间
System.out.println(new Date()); // Tue Jan 16 14:37:35 CST 2018
// 创建日期对象，把当前的毫秒值转成日期对象
System.out.println(new Date(0L)); // Thu Jan 01 08:00:00 CST 1970
* public long getTime() 把日期对象转换成对应的时间毫秒值。
DateFormat format = new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);
- public String format(Date date)：将 Date 对象格式化为字符串。
- public Date parse(String source)：将字符串解析为 Date 对象。
String str = df.format(date);

9：DateFormat 类

java.text.DateFormat 是日期/时间格式化子类的抽象类，我们通过这个类可以帮我们完成日期和文本之间的转换,也就是可以在 Date 对象与 String 对象之间进行来回转换。

• 格式化：按照指定的格式，从 Date 对象转换为 String 对象。
• 解析：按照指定的格式，从 String 对象转换为 Date 对象。

构造
// 对应的日期格式如：2018-01-16 15:06:38
DateFormat format = new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);
常用的格式规则为：

方法：

• public String format(Date date)：将 Date 对象格式化为字符串。

    Date date = new Date();<br />        // 创建日期格式化对象,在获取格式化对象时可以指定风格<br />        DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");<br />        String str = df.format(date);<br />        System.out.println(str); // 2008年1月23日

• public Date parse(String source)：将字符串解析为 Date 对象。

    DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");<br />        String str = "2018年12月11日";<br />        Date date = df.parse(str);<br />        System.out.println(date); // Tue Dec 11 00:00:00 CST 2018

  9：Calendar 类

  构造
  public static Calendar getInstance()：使用默认时区和语言环境获得一个日历
  Calendar cal = Calender.getInstance();
  方法：

• public int get(int field)：返回给定日历字段的值。

• public void set(int field, int value)：将给定的日历字段设置为给定值。
• public abstract void add(int field, int amount)：根据日历的规则，为给定的日历字段添加或减去指定的时间量。
• public Date getTime()：返回一个表示此 Calendar 时间值（从历元到现在的毫秒偏移量）的 Date 对象。

• Calendar 类中提供很多成员常量，代表给定的日历字段： |
  - 字段值
  |
  - 含义
  | | —- | —- | |
  - YEAR
  |
  - 年
  | |
  - MONTH
  |
  - 月（从 0 开始，可以+1 使用）
  | |
  - DAY_OF_MONTH
  |
  - 月中的天（几号）
  | |
  - HOUR
  |
  - 时（12 小时制）
  | |
  - HOUR_OF_DAY
  |
  - 时（24 小时制）
  | |
  - MINUTE
  |
  - 分
  | |
  - SECOND
  |
  - 秒
  | |
  - DAY_OF_WEEK
  |
  - 周中的天（周几，周日为 1，可以-1 使用）
  |

  // 创建Calendar对象
  Calendar cal = Calendar.getInstance();
  // 设置年
  int year = cal.get(Calendar.YEAR);
  // 设置月
  int month = cal.get(Calendar.MONTH) + 1;
  // 设置日
  int dayOfMonth = cal.get(Calendar.DAY_OF_MONTH);
  // 使用add方法
  cal.add(Calendar.DAY_OF_MONTH, 2); // 加2天
  cal.add(Calendar.YEAR, -3); // 减3年

  10：System 类

  方法

• public static long currentTimeMillis()：返回以毫秒为单位的当前时间。

获取当前系统时间与 1970 年 01 月 01 日 00:00 点之间的毫秒差值
//获取当前时间毫秒值
System.out.println(System.currentTimeMillis();

• public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将数组中指定的数据拷贝到另一个数组中。

System.arraycopy 方法具有 5 个参数，含义分别为：

2：equals（）和==
Equals 方法用来比较对象时，若没有对 equals 进行重写，其都是调用的 Object 类的 equals 方法，而 Object 方法中的 equals 方法返回的却是==判断
1、基本数据类型比较
==和 Equals 都比较两个值是否相等。相等为 true 否则为 false；
2、引用对象比较
==和 Equals 都是比较栈内存中的地址是否相等 。相等为 true 否则为 false；
需注意几点：
1、string 是一个特殊的引用类型。对于两个字符串的比较，不管是 == 和 Equals 这两者 比较的都是字符串是否相同；
3：HashCode 的作用：
返回对象的哈希代码值（就是散列码），用来支持哈希表，例如：HashMap
如果两对象 equals()是 true,那么它们的 hashCode()值一定相等
如果两对象的 hashCode()值相等，它们的 equals 不一定相等（hash 冲突啦）

3：基本数据类型与自动拆箱

11： Comparable 接口和 Comparator 接口

List a = new LinkedList<>();
a.sort((o1,o2)->o2-o1);
//数组只能正着排
Arrays.sort(arr);
Comparable 接口只包含 compareTo()方法
Comparator 接口包含 compare（Object ，Object ）方法和 equals（）方法

• public int compare(Object o1, Object o2)：比较其两个参数的顺序。
• 两个对象比较的结果有三种：大于，等于，小于。
• 如果要按照升序排序， 则 o1 小于 o2，返回（负数），相等返回 0，01 大于 02 返回（正数） 如果要按照降序排序 则 o1 小于 o2，返回（正数），相等返回 0，01 大于 02 返回（负数）

compareTo 方法被称为它的自然比较方法。
实现此接口的对象列表（和数组）可以通过 Collections.sort（Arrays.sort）进行自动排序。实现此接口的对象可以用作有序映射中的键 or 有序集合中的元素，无需指定比较器。
Comparator 强行对某个对象 collection 进行整体排序的比较函数。可以将 Comparator 传递给 sort 方法（如 Collections.sort 或者 Arrays.sort），从而允许在排序上实现精准控制。还可以使用 Comparator 来控制某些数据结构（如有序 set 或有序映射）的顺序，or 为那些没有自然顺序的对象 Collection 提供排序。
Comparable 是排序接口：
若一个类实现了 Comnparable 接口，就意味着“该类支持排序”，既然实现了 Comparable 接口的类支持排序，
假设现在存在“实现 Comparable 接口类的对象的 List 列表（or 数组）”，则该 List 列表（or 数组）可以通过 Collection.sort（or Arrays.sort）进行排序。
此外，“实现 Comparable 接口的类的对象”可以用作“有序映射（TreeMap）”中的键或“有序集合（TreeSet）”中的元素，而不需要指定比较器。
Comparator 也可以看成一种排序算法的实现，将算法和数据分离。
应用场景：
1 开始设计类的时候，没有考虑到比较问题而没有实现 Comparable，可以通过 Comparator 来实现排序而不必改变对象本身。
2 可以使用多种排序标准，比如员工按照员工号，年龄，名字，升序 or 降序排序等，并调用（如 Collections.sort 或者 Arrays.sort）方法，对 Collection 进行排序
// 自然排序按照员工号的顺序
public int compareTo(Employee obj) {
Employee employee = (Employee) obj;
return this.no - employee.no;
}

/*

*

• 按照员工的年龄进行比较的比较器。

*/

public class AgeComparator implements Comparator {
@Override
public int compare(Employee o1, Employee o2) {
return o1.getAge()-o2.getAge();
}
}
Comparable 是【】排序接口，若一个类实现了 Coparable 接口，说明该类支持排序此外，“实现 Comparable 接口的类的对象”可以用作“有序映射(如 TreeMap)”中的键或“有序集合(TreeSet)”中的元素，而不需要指定比较器。
接口中通过 x.compareTo(y)来比较 x 和 y 的大小。若返回负数，意味着 x 比 y 小；返回零，意味着 x 等于 y；返回正数，意味着 x 大于 y。
5：Java 中的 Math. round(-1. 5) 等于多少？
等于 -1，因为在数轴上取值时，中间值（0.5）向右取整，所以正 0.5 是往上取整，负 0.5 是直接舍弃。
6：String 的常用方法：
7：数组与 List 的转换
List.toArray(); Arrays.asList(array);
8：重构与重载
重载：方法重载是让类以统一的方法处理不同类型的数据的一种手段
重构即重写：子类重写父类的方法

序列化接口

把对象转换成可传输的字节序列的过程。
作用：便于对象的保存于重建，跨平台存储，方便网络传输，安全
根据类的结构生成序列化版本号 serialVersionUID，进行反序列化时，程序会比较磁盘中的序列化版本 ID 跟当前的类结构生成的版本号 ID 是否一致，如果一致则反序列化成功。

转载 https://www.yuque.com/jykss/jykss/zezf4y#1rvA7