Day008-2021-08-09 异常 集合 ==/equals()/hashcode()

第八天，看一看集合，java编程中经常能用的到，也是工作中最常见到的

一、异常

1.1 编译时异常/运行时异常

1. 如果编译器有红波浪线提示，即为不能通过编译，这种异常叫编译时异常。
2. 如果编译器通过编译了，但是运行时产生了异常，这种异常叫运行时异常。

1.2 异常的捕获

异常可以通过捕获来避免，其格式：

try {
需要捕获异常的代码;
} catch (异常类型1 异常名1) {
出现异常1时执行的代码;
} catch (异常类型2 异常名2) {
出现异常2时执行的代码;
} finally {
方法结束前一定会执行的代码;
}

当运行正常时，会在 try 执行完后执行 finally；当异常发生时，会先执行 catch 到的异常所对应的代码，然后执行 finally；如果 catch 执行过程中有 return 提前结束该方法，在方法返回前仍然会执行 finally 内的代码。

二、集合

2.1 List

1. List 分为 ArrayList 和 LinkedList。
2. 遵循放入顺序，即有序性。
3. 允许有重复的成员。

2.2 Set

1. Set 分为 HashSet 和 TreeSet。
2. 不遵循放入顺序，即无序性。
3. 不允许重复的成员

2.3 Map

1. Map 分为 HashMap 和 TreeMap。
2. 是 key-value 对的集合，即键值对。
3. 二者区别类似于 HashSet 与 TreeSet。

2.4 ArrayList和LinkedList比对

1. ArrayList底层是数组，有下标体系，读取快，增删慢。
2. LinkedList底层是链表，无下标体系，读取慢，增删快。
3. 由于内存运算足够快，实际使用并无差别。

2.5 HashSet和TreeSet比对

同为不遵循放入顺序

1. HashSet 的顺序是内部按hash值计算的，不可自定义。
2. TreeSet 的顺序允许开发者自定义，可以通过外置比较器来实现。

2.6 List和Set比对

1. List 遵循放入順序，Set 不遵循放入顺序，至于 Set 遵循何种顺序取决于实现类。
2. List允许重复的成员，Set不允许重复的成员。重复与否，判断标准是 equals() 和 hashcode() 的联合判断。
3. 个别特例不一定符合以上两点。

三、==/equals()/hashcode()

1. 默认情况下，三者均针对地址。
2. 后两者是方法，可以按业务需求重写，重写后有可能针对地址，也可能针对内容，需要看重写的逻辑。
3. String 的 equals() 方法比对内容，不比对地址，String 重写过 equals() 和 hashcode() 方法。
4. 一个类，一旦重写了 equals() 方法，必须同步重写 hashcode() 方法，以保持二者一致。这是业界规范，目的是满足JDK内某些集合的判重机制。
5. 两个对象，equals() 为 true，则 hashcode() 一定相等。
6. 两个对象，hashcode() 相等，equals() 却有极小概率为 false，这称为hash碰撞。
7. Set的判重逻辑 : 先判 hashcode()，hashcode() 不相等，则一定是不同的成员。hashcode() 相等，则用 equals() 作最终判断。

四、练习

1. 统计水果数组中出现次数最多的水果：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

public class Fruit {
	public static void main(String[] args) {
		String[] arr = { "香蕉", "菠萝", "桃子", "西瓜", "菠萝", "西瓜", "梨子", "苹果", "西瓜", "菠萝", "苹果", "梨子", "菠萝", "桃子", "橘子",
				"桃子", };
		Map<String, Integer> map = new HashMap<String, Integer>();
		for (String str : arr) {
			if (map.containsKey(str)) {
				map.put(str, map.get(str) + 1);
			} else {
				map.put(str, 1);
			}
		}
		ArrayList<Map.Entry<String, Integer>> list = new ArrayList<Map.Entry<String, Integer>>(map.entrySet());
		Comparator<Map.Entry<String, Integer>> com = new Comparator<Map.Entry<String, Integer>>() {
			@Override
			public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) {
				return o2.getValue() - o1.getValue();
			}
		};
		Collections.sort(list, com);
		System.out.println("出现次数最多的水果是：" + list.get(0).getKey() + ",出现了" + list.get(0).getValue() + "次");
	}
}

运行结果：

2. 一个装有银行交易记录的 String 类型的 List,将其存入 Map 中，并合并数据：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Bank {
	public static void main(String[] args) {
		List<String> tempList = new ArrayList<String>();
		tempList.add("6330 0202 2002 2222_100.00_2011-02-01");
		tempList.add("6330 0202 2002 2332_200.00_2011-02-02");
		tempList.add("6330 0202 2002 2333_300.00_2011-02-01");
		tempList.add("6330 0202 2002 3456_400.00_2011-02-03");
		tempList.add("6330 0202 2002 3412_500.00_2011-02-06");
		tempList.add("6330 0202 2002 2222_199.00_2011-02-01");

		Comparator<String> com = new Comparator<String>() {
			@Override
			public int compare(String o1, String o2) {
				String time1 = o1.split("_")[2];
				String time2 = o2.split("_")[2];
				if (Integer.parseInt(time1.split("-")[0]) != Integer.parseInt(time2.split("-")[0])) {
					return Integer.parseInt(time1.split("-")[0]) - Integer.parseInt(time2.split("-")[0]);
				}
				if (Integer.parseInt(time1.split("-")[1]) != Integer.parseInt(time2.split("-")[1])) {
					return Integer.parseInt(time1.split("-")[1]) - Integer.parseInt(time2.split("-")[1]);
				}
				if (Integer.parseInt(time1.split("-")[2]) != Integer.parseInt(time2.split("-")[2])) {
					return Integer.parseInt(time1.split("-")[2]) - Integer.parseInt(time2.split("-")[2]);
				}
				return 0;
			}
		};
		Collections.sort(tempList, com);
		Map<String, String> map = new HashMap<String, String>();
		for (String str : tempList) {
			if (map.containsKey(str.split("_")[0])) {
				map.put(str.split("_")[0], (Double.parseDouble(map.get(str.split("_")[0]).split("_")[0])
						+ Double.parseDouble(str.split("_")[1])) + "_" + str.split("_")[2]);
			} else {
				map.put(str.split("_")[0], Double.parseDouble(str.split("_")[1]) + "_" + str.split("_")[2]);
			}
		}
		for (Map.Entry<String, String> et : map.entrySet()) {
			System.out.println(et.getKey() + "->" + et.getValue());
		}
	}
}

运行结果：