【java基础知识】集合类（含Collection类和Map类）

集合类

Collection<>

常用方法

Collection<String> c = new ArrayList<String>();
c.add("java");
c.add("hello");
c.add("my");
System.out.println(c); // [java, hello, my]System.out.println(c.size()); // 3c.remove("java");System.out.println(c); // [hello, my]System.out.println(c.contains("java")); // falsec.clear();System.out.println(c); // []

遍历

增强for循环

作用；方便遍历原理；内置迭代器推荐：只要遍历的时候推荐使用

/*
格式；
for（元素数据类型 变量名 : 数据或Collection集合）{输出变量名即可完成遍历
}
*/
for (String i : l) {System.out.println(i);
}

三种遍历方法

Iterator<Student> it = l.iterator();
while (it.hasNext()) {Student s = it.next();System.out.println(s.getName());
}
for (int i = 0; i < l.size(); i++) {Student s = l.get(i);System.out.println(s.getName());
}
for (Student s : l) {System.out.println(s.getName());
}

List<>

有序，可重复

常用方法

List<String> l = new ArrayList<>();
l.add("add");
l.add("java");
// void add(int index, E element)
l.add(1, "hello");
System.out.println(l); // [add, hello, java]// E remove(int index), E remove(Object o)
l.remove(0);
l.remove("java");
System.out.println(l); // [hello]// E set(int index, E element)
l.set(0, "java");
System.out.println(l); // [java]// E get(int index)
l.get(0); // java

并发修改异常

ConcurrentModificationException

实际修改值和预期修改值不相等

解决方案：用for循环遍历

for (int i = 0; i < l.size(); i++) {String s = l.get(i);System.out.println(s);
}

ArrayList<>

数组

// 用多态创建对象
Collection<String> c = new ArrayList<String>();
c.add("java");
c.add("hello");
System.out.println(c); // [java, hello]

LinkedList<>

链表

LinkedList<String> c = new LinkedList<>();;
c.add("hello");
c.add("world");
c.add("java");
System.out.println(c); // [hello, world, java]c.addFirst("first");
c.addLast("last");
System.out.println(c); // [first, hello, world, java, last]System.out.println(c.getFirst());
System.out.println(c.getLast());
c.removeFirst();
c.removeLast();
System.out.println(c); // [hello, world, java]

ListIterator<>

extends List<>

常用方法:

正向遍历

ListIterator<String> lit = l.listIterator();
while (lit.hasNext()) {String s = lit.next();System.out.println(s);
}

逆向遍历

ListIterator<String> lit = l.listIterator();
while (lit.hasPrevious()) {String s = lit.previous();System.out.println(s);
}

add（）不会造成并发修改异常，add方法里让实际操作值和预期的相等

ListIterator<String> lit = l.listIterator();
while (lit.hasNext()) {String s = lit.next();if (s.equals("hello")) {lit.add("world");}
}
System.out.println(l); // [add, java, hello, world]

Set<>

不包含重复元素，没有索引，不能用for循环遍历

Set<String> set = new HashSet<>();
set.add("java");
set.add("hello");
set.add("world");
set.add("java");
for (String s : set) {System.out.println(s);
}
/*输出    HashSet不不保证迭代顺序
java
world
hello
没有出现两个"java"
*/

HashSet<>

为了使HashSet具有元素唯一性，要重写equals()和hashCode()

@Override
public boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Student student = (Student) o;if (age != student.age) return false;return name != null ? name.equals(student.name) : student.name == null;
}@Override
public int hashCode() {int result = name != null ? name.hashCode() : 0;result = 31 * result + age;return result;
}

LinkedHashSet<>

保证迭代的有序性，同时具有唯一性

LinkedHashSet<String> lhs = new LinkedHashSet<>();
lhs.add("hello");
lhs.add("java");
lhs.add("world");
lhs.add("java");for (String s : lhs) {System.out.println(s);
}/*hellojavaworld*/

TreeSet<>

有序：元素按照一定的规则进行排序，有自然排序和比较器排序

没有索引，不能用普通for循环遍历

TreeSet<Integer> t = new TreeSet<>();
t.add(11);
t.add(12);
t.add(9);
t.add(8);
for (Integer i : t) {System.out.println(i);
}
//8
//9
//11
//12

Comparable<>

比较器

public class Student implements Comparable<Student>{@Override
public int compareTo(Object o) {//   return 0; // 只返回第一个//   return 1; // 按序返回 第二个比第一个大//   return -1; // 倒序返回// 按年龄从大到小进行排序int num = this.age - s.age;return num;
}
// this 升前降后 升：从小到大

用TreeSet<>带参构造

TreeSet<Student> t = new TreeSet<>(new Comparator<Student>() {@Overridepublic int compare(Student s1, Student s2) {int num = s1.getAge() - s2.getAge(); // s1 相当于this，s2为上文sreturn num;}
});

一般要有主要条件和次要条件

三元运算符：如num==0?s1.getName().compareTo(s2.getName) : num

上述先判断num是否等于0，true就返回s1.getName().compareTo(s2.getName)，false就返回num，而compareTo按字母排序比较字符串

产生十个不重复随机数并遍历

Set<Integer> s = new HashSet<>();
Random r = new Random();while (s.size() < 10) {int i = r.nextInt(20) + 1;s.add(i);
}
for (Integer i :s) {System.out.println(i);
}

Map<>

基本功能

键有唯一性，重复的键就相当于修改的操作

Map<String, String> map = new HashMap<>();
map.put("hello", "java");
map.put("hi", "mysql");
map.put("hello", "navicat");
System.out.println(map); // {hi=mysql, hello=navica}System.out.println(map.size()); // 2map.remove("hello");System.out.println(map); // {hi=mysql}System.out.println(map.containsKey("hi")); // trueSystem.out.println(map.containsValue("mysql")); // truemap.clear();System.out.println(map.isEmpty()); // true

获取功能

Map<String, String> map = new HashMap<>();
map.put("hello", "java");
map.put("hi", "mysql");
map.put("greet", "navicat");System.out.println(map.get("greet")); // navicat
Set<String> ke = map.keySet();
for (String s : ke) {System.out.println(s);
}
/* 获取键的集合
hi
greet
hello
*/
Collection<String> values = map.values();
for (String s1 : values) {System.out.println(s1);
}
/* 获取值的集合
mysql
navicat
java
*/

遍历

// 1.获取键的集合
Set<String> keySet = map.keySet();
// 2.遍历每一个元素
for (String key : keySet) {// 3.根据键找到值String values = map.get(key);System.out.println(key + "," + values);
}

// 1.获取键值对的集合
Set<Map.Entry<String, String>> entrySet = map.entrySet();
// 2.遍历每一个键值对
for (Map.Entry<String, String> my : entrySet) {String key = my.getKey();String value = my.getValue();System.out.println(key + "," + value);
}

案例

1.HashMap<String, Student>案例

public static void main(String[] args) {HashMap<String, Student> hs = new HashMap<>();Student s1 = new Student("你", 10);Student s2 = new Student("它", 11);Student s3 = new Student("他", 15);Student s4 = new Student("我", 42);hs.put("daqi1", s1);hs.put("daqi2", s2);hs.put("daqi3", s3);hs.put("daqi4", s4);Set<String> keySet = hs.keySet();for (String key : keySet) {Student student = hs.get(key);System.out.println(key + "," + student.getName() + "," + student.getAge());}/*daqi3,他,15daqi4,我,42daqi1,你,10daqi2,它,11*/Set<Map.Entry<String, Student>> entrySet = hs.entrySet();for (Map.Entry<String, Student> me : entrySet) {String key = me.getKey();Student value = me.getValue();System.out.println(key + "," + value.getName() + "," + value.getAge());}
}

ps：上述如果将HasMap<…>改为HasMap<Student, String>,为了确保键的唯一性，要重写equals和HasCode方法，用快捷键Alt + Insert快速生成即可

2.嵌套

ArrayList<HashMap<String, String>>

ArrayList<HashMap<String, String>> array = new ArrayList<>();HashMap<String, String> hm1 = new HashMap<>();
hm1.put("java", "mysql");
hm1.put("Navicat", "Tomcat");
array.add(hm1);HashMap<String, String> hm2 = new HashMap<>();
hm1.put("notion", "music");
hm1.put("math", "Chinese");array.add(hm2);for (HashMap<String, String> hm : array) {Set<String> keySet = hm.keySet();for (String key : keySet) {String value = hm.get(key);System.out.println(key + "," + value);}
}

3.统计字符串中每个字符出现的个数

public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.println("请输入字符串：");String line = sc.nextLine();HashMap<Character, Integer> hm = new HashMap<>();// TreeMap<Character, Integer> tm = new TreeMap<>(); // TreeMap 可以对键进行自然排序// 创建StringBuild来存储字符串StringBuilder sb = new StringBuilder();// 遍历字符串的每一个字符for (int i = 0; i < line.length(); i++) {char key = line.charAt(i);Integer value = hm.get(key);if (value == null) {hm.put(key, 1);} else {value++;hm.put(key, value);}}Set<Character> set = hm.keySet();for (Character key : set) {Integer value = hm.get(key);sb.append(key).append("(").append(value).append(")");}String s = sb.toString();System.out.println(s);}

Collections类

集合操作的工具类，静态方法，直接调用

常用方法

List<Integer> l = new ArrayList<>();
// 添加元素
l.add(10);
l.add(39);
l.add(49);
l.add(100);
l.add(49);Collections.sort(l);
System.out.println(l); // [10, 39, 49, 49, 100]Collections.reverse(l);
System.out.println(l); // [100, 49, 49, 39, 10]Collections.shuffle(l); // 随机排序
System.out.println(l); // [49, 49, 100, 10, 39]