集合（十七）
集合（十七）
Collection
List
List是有序并且可以重复的集合，List常用的有ArrayList和LinkedList
ArrayList
ArrayList常用的方法：
- add() 添加元素
- remove() 删除元素
- contains() 是否包含某个元素
- get() 获取元素
- size() 查看List的长度
需要了解的是：ArrayList是可迭代的，建议用迭代器Iterator来遍历List, 增强型的for循环实际上也是使用迭代器的方式来遍历，实现遍历不同对象的方法统一。
LinkedList
LinkedList是使用链表的方式实现List, 它的每个元素都指向下一个元素，LinkedList占用的内存较大，通常情况下我们使用ArrayList
LinkedList常用的方法有：getFirst() 获取首元素 getLast() 获取尾元素
package com.luca.jihe;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
public class ListDemo1 {
public static void main(String[] args) {
//创建ArrayList
List<String> list = new ArrayList<>();
list.add("apple"); //添加元素
list.add("orange");
list.add(1, "cherry");
list.remove(1); //去除元素
System.out.println(list.size()); //获得长度
//使用增强for循环便利List
for (String l :
list) {
System.out.println(l);
}
System.out.println("===================");
//使用迭代器遍历List
for (Iterator<String> it = list.iterator(); it.hasNext(); ) {
String s = it.next();
System.out.println(s);
}
System.out.println("===================");
//简单使用LinkedList
LinkedList<String> ls = new LinkedList<>();
ls.add("AAA");
ls.add("BBB");
ls.add("CCC");
System.out.println(ls.getFirst()); //获取第一个元素
System.out.println(ls.getLast()); //获取最后一个元素
System.out.println("====================");
System.out.println("List----->Array"); //List转换为数组
List<Integer> li = List.of(1, 2, 3, 4, 5, 6);
Integer[] i1 = li.toArray(new Integer[li.size()]);
for (Integer i :
i1) {
System.out.print(i+" ");
}
System.out.println("====================");
System.out.println("Array----->List"); //数组转换为List
String[] st = {"a", "b", "c", "d"};
List<String> l2 = List.of(st);
for (Iterator<String> it = l2.iterator(); it.hasNext(); ) {
System.out.printf("%s ", it.next());
}
}
}
Set
在Collection中另一种集合是Set, Set是无序的并且Set中的元素不可重复。常用的实现类有HashSet和TreeSet.
通常情况下使用HashSet, 与List类似，有add, remove, contains方法。
TreeSet是拥有排序的Set, 不太常用。
package com.collection;
import java.util.HashSet;
import java.util.Set;
public class SetDemo1 {
public static void main(String[] args) {
Set<String> s1 = new HashSet<>();
s1.add("apple");
s1.add("pear");
s1.add("banana");
s1.add("apple"); //重复的值会添加失败
System.out.println(s1);
boolean hasPear = s1.contains("pear");
System.out.println(hasPear);
}
}
package com.collection;
import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;
public class SetDemo2 {
public static void main(String[] args) {
Set<Integer> s2 = new TreeSet<>();
s2.add(1);
s2.add(2);
s2.add(3);
System.out.println(s2);
System.out.println("============");
Set<Integer> s3 = new HashSet<>();
s3.add(1);
s3.add(2);
s3.add(3);
System.out.println(s3);
}
}
Map
Map是Collection外的一种集合类型，相当于Python中的字典Dict.
Map中常用的有HashMap和TreeMap, 与Set的命名上一样，TreeMap的特性就是增加了排序。
HashMap
HashMap中常用的方法有：
- put() 往Map中添加元素
- get() 从Map中获取元素
- contains() 查看Map中是否包含元素
- keySet() Map中所有的key, 可以用来遍历Map
- entrySet() 遍历Map中所有的key和value
package com.luca.jihe;
import javax.swing.tree.VariableHeightLayoutCache;
import java.util.HashMap;
import java.util.Map;
public class MapDemo1 {
public static void main(String[] args) {
Student xiaoMing = new Student("XiaoMing", 78);
//创建HashMap
Map<String, Student> map = new HashMap<>();
//添加键值对，String: Student
map.put("xm", xiaoMing);
//通过key获取值
System.out.println(map.get("xm").score);
Student s = map.get("xm");
System.out.println(s.equals(xiaoMing)); //true 说明是同一个实例
System.out.println(map.containsKey("xm")); //判断是否包含key
System.out.println(map.containsKey("xh"));
Student xh = new Student("XiaoHong", 99);
map.put("xh", xh);
//遍历HashMap，通过keySet
for (String key: map.keySet()) {
System.out.print(map.get(key).name+"\t");
}
System.out.println("==================");
//同时遍历key和value，使用entrySet
for (Map.Entry<String, Student> entry: map.entrySet()) {
String name = entry.getKey();
Student value = entry.getValue();
System.out.println(name+"-->"+value.name+"-->"+value.score);
}
}
}
class Student {
public String name;
public int score;
public Student(String name, int score) {
this.name = name;
this.score = score;
}
}
TreeMap
TreeMap要实现排序的效果，需要Map中的key实现Comparable接口，实现过程参考下面
package com.collection;
import java.util.Comparator;
import java.util.TreeMap;
public class TreeMapDemo1 {
public static void main(String[] args) {
//TreeMap中的key必须实现Comparable接口，String,Integer已经默认实现了
TreeMap<String, Integer> tm = new TreeMap<>();
tm.put("apple", 1);
tm.put("pear", 2);
tm.put("banana", 3);
for (String key : tm.keySet()) {
System.out.printf("%s-->%d", key, tm.get(key));
System.out.println(); //apple-->banana-->pear顺序遍历
}
System.out.println("================");
// 如果作为key的class没有实现Comparable接口，则需要在TreeMap创建时指定一个排序算法
TreeMap<Student, String> ss = new TreeMap<>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o1.name.compareTo(o2.name);
}
});
ss.put(new Student("xm", 21), "xiaoming");
ss.put(new Student("xh", 18), "xiaohong");
for (Student s: ss.keySet()) {
System.out.println(ss.get(s));
}
}
}
class Student {
public String name;
public int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
}
Collections
Collections是Java提供的一个方便来操作集合的类，常用的方法有：
- emptyList(创建空集合)
- singletonList(创建单元素集合)
- sort(排序)
- shuffle(洗牌)
package com.collection;
import java.util.*;
public class CollectionsDemo1 {
public static void main(String[] args) {
//创建空集合
List<String> list1 = Collections.emptyList(); //创建出的空集合无法add元素
Set<Integer> set1 = Collections.emptySet();
Map<Integer, String> map1 = Collections.emptyMap();
System.out.println(list1);
System.out.println(set1);
System.out.println(map1);
System.out.println("====================");
//创建单元素集合
List<String> list2 = Collections.singletonList("apple"); //创建的单元素集合也无法add元素
Set<Integer> set2 = Collections.singleton(111);
Map<Integer, String> map2 = Collections.singletonMap(1, "apple");
System.out.println(list2);
System.out.println(set2);
System.out.println(map2);
System.out.println("====================");
List<String> list3 = new ArrayList<>();
list3.add("apple");
list3.add("pear");
list3.add("banana");
list3.add("cherry");
System.out.println(list3); //[apple, pear, banana, cherry]
//使用Collections排序，排序会改变原有的list顺序
Collections.sort(list3);
System.out.println(list3); //[apple, banana, cherry, pear]
System.out.println("====================");
//使用Collections洗牌，打乱顺序
Collections.shuffle(list3);
System.out.println(list3);
}
}
后续会补充队列、栈相关内容，暂时没有接触到。
