(在2020后的版本把2018写的ArrayMap改成了ArraySet，因而上面的案例基于ArraySet)
所有的类都隐式地继承了Object，且蕴含Object的以下办法:
- String toString()
- boolean equals(Object obj)
- Class <?> getClass()
- int hashCode()
- protected Objectclone()
- protected void finalize()
- void notify()
- void notifyAll()
- void wait()
- void wait(long timeout)
- void wait(long timeout, int nanos)
本次课咱们重点介绍前两个办法
1.toString()
当你每次调用System.out.println(x)时，无论x本来的类型是什么，都会产生隐式地转换，System.out.println(Object x) calls x.toString() 即
(If you’re curious: println calls String.valueOf which calls toString)
String x = x.toString();System.out.println(x);默认的Object的toString()办法转换的格局为:
classname @ hex_memory类名@十六进制内存地址因而如果打印咱们本人写的ArraySet，其后果是:
$ java ArraySetPrintDemoArraySet@75412c2f然而Java.util内置的List,Set,Map均Override了Object原来的toString()办法，因而如果咱们应用内置的List：
public static void main(String[] args ) { List<Integer> a = new ArrayList<>(); a.add(1); a.add(2); a.add(3); System.out.println(a); }就会打印出赏心悦目的后果:
[1, 2, 3]咱们的指标是，让咱们本人写的ArraySet也打印出这种丑陋的后果，也就是咱们须要Override本来的toString()
先回顾一下咱们的ArraySet:
public class ArraySet<T> implements Iterable<T> { private T[] items; private int size; // the next item to be added will be at position size public ArraySet() { items = (T[]) new Object[100]; size = 0; } /* Returns true if this map contains a mapping for the specified key. */ public boolean contains(T x) { for (int i = 0; i < size; i += 1) { if (items[i].equals(x)) { return true; } } return false; } /* Associates the specified value with the specified key in this map. Throws an IllegalArgumentException if the key is null. */ public void add(T x) { if (x == null) { throw new IllegalArgumentException("can't add null"); } if (contains(x)) { return; } items[size] = x; size += 1; } /* Returns the number of key-value mappings in this map. */ public int size() { return size; } @Override public String toString() { /* hmmm */ } @Override public boolean equals(Object other) { /* hmmm */ } public static void main(String[] args) { ArraySet<Integer> aset = new ArraySet<>(); aset.add(5); aset.add(23); aset.add(42); //toString System.out.println(aset); }解决方案:
@Overridepublic String toString() { String returnString = "{"; for (int i = 0; i < size; i += 1) { returnString += keys[i]; returnString += ", "; } returnString += "}"; return returnString;}这样的toString()尽管能实现咱们的指标，然而效率上非常低，这是因为Java中，String是不变量(还记得不变量吗？回顾一下以前的笔记),因而当每次执行字符串拼接时:
returnString += keys[i];Java都是从头创立一个新的正本，而后再将字符拼接，最初返回该正本，因而，假如拼接一个字符须要1s，对字符串"{ 1 2 3 }"进行拼接，则须要
- { (1s)
- { + 1 = { 1 (2s)
- { + 1 + 2 = { 1 2 (3s)
- { + 1 + 2 + 3 = {1 2 3 (4s)
- { + 1 + 3 + } = {1 2 3} (5s)
可见每次拼接都是从头开始，上述过程的总耗时为1 + 2 + 3 + 4 + 5 = 15s
如果一个字符串的长度为n，则以下面的算法拼接字符串的工夫复杂度是 O(1 + 2 + 3 + 4 +......+ n-1 + n) = O(n(n-1)/2)，即O(n²)
如何让字符串拼接变得更加高效？
为了解决这个问题，Java 有一个非凡的类，称为StringBuilder. 它创立一个可变的字符串对象，因而您能够持续追加到同一个字符串对象上，而不是每次都创立一个新对象。
应用StringBuilder重写toString()办法:
public String toString() { StringBuilder returnSB = new StringBuilder("{"); for (int i = 0; i < size - 1; i += 1) { returnSB.append(items[i].toString()); returnSB.append(", "); } returnSB.append(items[size - 1]); returnSB.append("}"); return returnSB.toString(); }此算法的工夫复杂度是线性的,O(n)
2.equals() vs. ==
后面咱们有提到 Object.equals(Object o)办法是比拟两个Object的值，而Java中 == 则是比拟二者的内存地址是否雷同，或者说是否指向同一Object
举例:
因而当前如果要比拟两个Object通常意义下的相等，请应用.equals()
然而事实上，Java的Object.equals()办法默认是与 == 等效的，在内置的Java.util 的Set,Map,List均Override了本来的equals()，因而咱们应用起来才没问题
如果咱们一成不变地应用默认的equals()办法，同样会相当于应用 == 判断两个内存地址不同的Object，从而返回false：
因而咱们的指标是Override默认的equals()办法，使之实用于咱们的ArraySet
请留神 List是有序元素汇合，Set是无序元素汇合。因而，如果咱们须要重写自定义的ArrayList的equals()，须要逐项比拟两个List中的元素是否程序雷同且元素值相等
而Set是惟一元素的无序汇合。因而，要将两个汇合视为相等，您只须要查看它们之间是否互相蕴含雷同的元素。
解决方案:
@Overridepublic boolean equals(Object other) { if (this == other) { return true; } if (other == null) { return false; } if (other.getClass() != this.getClass()) { return false; } ArraySet<T> o = (ArraySet<T>) other; if (o.size() != this.size()) { return false; } for (T item : this) { if (!o.contains(item)) { return false; } } return true; }getClass()办法是返回以后Object的class type，例如this.getClass() = ArraySet.class
总结:
3.Even Better toString() and ArraySet.of()
String.join()
实现字符串拼接还有一种办法，应用String.join()
@Overridepublic String toString() { List<String> lisOfItems = new ArrayList<>(); for(T x : this) { lisOfItems.add(x.toString()); } return "{" + String.join(",", lisOfItems) + "}";}.Of()
回顾一下以前做过的lab，咱们以 .Of()形式创立一个List，或者Set，例如:
Set<Integer> javaset = Set.of(5, 23, 42);就能创立一个Set，其内容为{5,23,42}，十分的不便
因而，咱们想实现属于本人的.Of()办法，使之可能达到下面的成果
解决方案:
public static <Glerp> ArraySet<Glerp> of(Glerp... stuff) { ArraySet<Glerp> returnSet = new ArraySet<>(); for (Glerp x : stuff) { returnSet.add(x); } return returnSet;}语法点:
- 泛型办法，在办法返回类型前加<T>，后面笔记有介绍
- Varargs: ... 可变长度参数
在 Java 5 中提供了变长参数，容许在调用办法时传入不定长度的参数。变长参数是 Java 的一个语法糖，实质上还是基于数组的实现，Java的可变参数，会被编译器转型为一个数组
void foo(String... args);void foo(String[] args);更多可见this link