Java学习笔记六（集合）

注释：数组（固定长度）或集合（可扩展长度），用来存储相同类型的多条数据。

集合选择方式：

1 Collection接口

常用Collection接口函数：

(1) 添加元素：boolean add(E e);

(2) 添加结合：boolean addAll(Collection c);

(3) 删除元素：boolean remove(Object o);

(4) 删除集合：boolean removeAll(Collection c);

(5) 删除全部：void clear();

(6) 获取长度：int size();

(7) 判断空：boolean isEmpty();

(8) 集合转数组：Object[] toArray();

(9) 元素存在判断：boolean contains(Object o);

(10) 集合元素存在判断：boolean containsAll(Collection c);

(11) 迭代器：Iterator <E> iterator();

1.1 List接口

常用List接口函数：

(1) 添加元素：boolean add([int index,] E e); 

(2) 添加集合：boolean addAll([int index,] Collection c);

(3) 删除元素：boolean remove(int index);

(4) 获取元素：Object get(int index);

(5) 获取下标：int indexOf(Object o);

(6) 获取元素最后所在下标：int lastIndexOf(Object o);

(7) 修改元素：Object set(int index, Object o);

(8) List转数组：list.toArray() 

(9) 数组转List：Arrays.toList(数组)

(10) 获取迭代器：ListIterator <E> listIterator(); // 在变量集合时，会修改元素的情况下使用

遍历集合：

Iterator it = list.listIterator();
while (it.hasNext()) { // 判断是否有下一个元素
    xx = it.next(); // 获取下一个元素，并且光标下移
    it.remove();    // 删除元素，用list.remove(it.next());会异常
}

for (Object o ： list) { // 增强型for循环，遍历集合
    ...
}

for (int i; i<10; i++) {
    list.get(i); // 获取元素
    list.remove(i); // 删除元素，为正常继续执行，需要 i--
}

1.1.1 ArrayList 实现类

数据存储有序（数据按插入的先后顺序排列），查询速度快

1.1.2 LinkedList 实现类

数据存储有序（数据按插入的先后顺序排列），随机插入效率高

1.1.3 Vector 实现类

数据存储有序（数据按插入的先后顺序排列），线程安全

1.2 Set接口

1.2.1 HashSet  实现类

数据存储无序，存储数据值唯一，可存null

1.2.2 LinkedHashSet 实现类

数据存储有序（数据按插入的先后顺序排列），存储数据值唯一，可存null

1.2.3 TreeSet 实现类

数据存储有序（自动升序），存储数据值唯一，不可存null

2 Map接口

(1) 添加元素：Object put(Object key, Object value)

(2) 添加集合：void putAll(Map map)

(3) 删除元素：Object remove(Object key);

(4) 删除元素：boolean remove(Object key, Object value)

(5) 获取元素：Object get(Object key)

(6) 获取元素：Object getOrDefault(Object key, Object defaultValue)

(7) 获取长度：int size()

(8) 判断是否为空：boolean isEmpty()

(9) 获取键集合：Set keySet();

(10) 获取键值对集合：Set entrySet();

(11) 获取值集合：Collection values();

(12) 键存在判断：boolean containsKey(Object key)

(13) 值存在判断：boolean containsValue(Object value)

遍历Map集合：

Set<String> keys = map.keySet();
for (String key : keys) { // 遍历键集合
    ...
}

Set<Entry<String, Object>> entrys = map.entrySet();
for (Entry e : entrys) {    // 遍历键值对集合
    String key = e.getKey();
    Object obj = e.getValue();
}

List<String> list = map.values(); // 变量Map值的集合
for (String val : list) {
    ...
}

2.1 HashMap 实现类

数据存储无序，键唯一（可null），值（可null）

2.2 LinkedHashMap 实现类

数据存储有序（数据按插入顺序存储），键唯一（可null），值（可null）

2.3 TreeMap 实现类

数据存储有序（键升序），键唯一（不可null），值（可null）

2.4 Hashtable 实现类

数据存储无序，键唯一（不可null），值（不可null），线程安全

3 排序

3.1 默认排序

3.1.1 数组排序

(1) Arrays.sort(args)

String[] args =  new String[3];
args[0] = "2"; args[1] = "1"; args[2] = "3";

Arrays.sort(args); // 默认排序 1,2,3

for (String str : args) {
    System.out.println(str);
}

3.1.2 List排序

(1) Collections.sort

List<String> list = new ArrayList<String>();
list.add("3");list.add("1");list.add("2");

Collections.sort(list); // 默认排序 1,2,3

for (String str : list) {
    System.out.println(str);
}

(2）list.sort(null)

List<String> list = new ArrayList<String>();
list.add("3");list.add("1");list.add("2");

list.sort(null); // 默认排序 1,2,3

for (String str : list) {
    System.out.println(str);
}

3.2 自定义排序（Comparator）

3.2.1 数组排序

(1) Arrays.sort(args, Comparator)

注释：基本类型数组，必须定义为包装类类型

// 基本类型必须使用 包装类（Integer...等）
String[] args =  new String[3];
args[0] = "2"; args[1] = "1"; args[2] = "3";

Arrays.sort(args, (s1, s2) -> s1.compareTo(s2)); // 升序排序 1,2,3
Arrays.sort(args, (s1, s2) -> s2.compareTo(s1)); // 降序排序 3,2,1

for (String str : args) {
    System.out.println(str);
}

3.2.2 List排序

(1) Collections.sort(list, Comparator)

List<String> list = new ArrayList<String>();
list.add("3");list.add("1");list.add("2");

Collections.sort(list, (s1, s2) -> s1.compareTo(s2)); // 升序 1,2,3
Collections.sort(list, (s1, s2) -> s2.compareTo(s1)); // 降序 3,2,1

for (String str : list) {
    System.out.println(str);
}

(2）list.sort(Comparator)

List<String> list = new ArrayList<String>();
list.add("3");list.add("1");list.add("2");

list.sort((s1, s2) -> s1.compareTo(s2)); // 升序 1,2,3
list.sort((s1, s2) -> s2.compareTo(s1)); // 降序 3,2,1

for (String str : list) {
    System.out.println(str);
}

3.3 对象排序（Comparable）

排序实现方式：对象实现Comparable接口，重写compareTo方法。

// 对象类
public class Test implements Comparable<Test> {
	private String name;
	private int age;

	@Override
	public int compareTo(Test t) {
//		return name.compareTo(t.getName()); // 按名称升序
//		return t.getName().compareTo(name); // 按名称降序
//		return age - t.getAge(); // 按年龄升序
		return t.getAge() - age; // 按年龄降序
	}
}

// 测试类
Test t1 = new Test();
t1.setAge(10);
t1.setName("S2");
    	
Test t2 = new Test();
t2.setAge(15);
t2.setName("S1");
    	
Test t3 = new Test();
t3.setAge(18);
t3.setName("S3");
    	
List<Test> list = new ArrayList<Test>();
list.add(t1);
list.add(t2);
list.add(t3);
    	
Collections.sort(list); // 方式1：自定义对象compareTo的排序
list.sort(null);        // 方式2：自定义对象compareTo的排序
    	
for (Test test : list) {
    System.out.println(test.getName());
}