【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()); // 3

 c.remove("java");
 System.out.println(c); // [hello, my]

 System.out.println(c.contains("java")); // false

 c.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);
}
 /*
 hello
 java
 world
 */

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>() {
    @Override
    public int compare(Student s1, Student s2) {
        int num = s1.getAge() - s2.getAge(); // s1 相当于this，s2为上文s
        return 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()); // 2

        map.remove("hello");
        System.out.println(map); // {hi=mysql}

        System.out.println(map.containsKey("hi")); // true
        System.out.println(map.containsValue("mysql")); // true
        map.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,他,15
    daqi4,我,42
    daqi1,你,10
    daqi2,它,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]