JavaSe第六天笔记小记

1、集合

java中的集合类存放在java.util包中，是一个用来存放对象的容器

集合只能存放对象，如果存放基本数据类型，那么会自动转换成对应的引用类型
集合中存放的是多个对象的引用，对象本身还是放在堆内存中
集合可以存放不同类型，不限数量的数据类型

集合框架体系

java中的集合可分为Set、List和Map三大类

Set：无序、不可重复的集合
List：有序，可重复的集合
Map：具有映射关系的集合

jdk5之后增加了泛型，java集合可以记住容器中对象的数据类型

HashSet

HashSet是Set接口的典型实现，大多数时候使用Set集合时都使用这个实现类，大多数时候说的Set集合指的都是HashSet

HashSet按Hash算法来存储集合中的元素，具有很好的存取和查找能力

不能保证元素的排列顺序
不可重复
HashSet不是线程安全的，如果多个线程尝试同时修改 HashSet，则最终结果是不确定的
集合元素可以是null

过程分析：当向HashSet集合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值，然后根据该值决定该对象在HashSet中的存储位置

注：如果两个元素的equals()方法返回true，但它们的hashCode()返回值不相等，hashSet将会把它们存储在不同的位置，但依然添加成功，即元素是否重复看的是哈希值，而不是equals()方法的返回值

常用方法：

1、添加元素——add()

import java.util.HashSet;

public class MyException {
    public static void main(String[] args) {
        HashSet hashSet = new HashSet();

        hashSet.add(1);
        hashSet.add('c');
        hashSet.add("c");
        
        System.out.println(hashSet);
    }
}

[1, c, c]

2、判断元素是否存在——contains()

import java.util.HashSet;

public class RunoobTest {
    public static void main(String[] args) {
    HashSet<String> sites = new HashSet<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");
        sites.add("Runoob");     // 重复的元素不会被添加
        for (String i : sites) {
            System.out.println(i);
        }
    }
}

true

3、删除元素——remove()

import java.util.HashSet;

public class RunoobTest {
    public static void main(String[] args) {
    HashSet<String> sites = new HashSet<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");
        sites.add("Runoob");     // 重复的元素不会被添加
        sites.remove("Taobao");  // 删除元素，删除成功返回 true，否则为 false
        System.out.println(sites);
    }
}

[Google, Runoob, Zhihu]

4、元素个数——size()

// 引入 HashSet 类      
import java.util.HashSet;

public class RunoobTest {
    public static void main(String[] args) {
    HashSet<String> sites = new HashSet<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");
        sites.add("Runoob");     // 重复的元素不会被添加
        System.out.println(sites.size());  
    }
}

4

5、迭代HashSet——for-each

import java.util.HashSet;

public class RunoobTest {
    public static void main(String[] args) {
    HashSet<String> sites = new HashSet<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");
        sites.add("Runoob");     // 重复的元素不会被添加
        for (String i : sites) {
            System.out.println(i);
        }
    }
}

Google
Runoob
Zhihu
Taobao

TreeSet

SortedSet接口的实现类，TreeSet可以确保集合元素处于排序状态

支持两种排序方法：自然排序和定制排序，默认下使用自然排序

自然排序：

TreeSet会调用集合元素的compareTo(Ovject obj)方法来比较元素之间的大小关系，然后将集合元素按升序排列

如果this>obj，返回正数1
如果this<obj，返回负数-1
如果this=obj，返回0，则认为两个对象相等
必须是相同类型的对象，否则会有类型转换错误异常，使用泛型来约束

List

之前写过的博客

Map

Map用于保存具有映射关系的数据，因此Map集合里保存着两组值，一组保存Map里的Key，另外一组保存Map里的Value

Map里的key和value都可以是任意类型的数据
key不允许重复
key和value之间存在单向一对一关系

通常情况下说的Map指的都是HashMap类，该类实现了Map接口

import java.util.HashMap;
import java.util.Map;

public class MyException {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();

        // 添加元素
        map.put(1, "aaa");
        map.put(3, "ccc");
        map.put(2, "bbb");
        map.put(4, "ddd");
        System.out.println(map);

        System.out.println("——————————————————");
        // 删除元素
        map.remove(2);
        System.out.println(map);

        System.out.println("——————————————————");
        // 根据key取值
        System.out.println(map.get(2));
        System.out.println(map.get(3));
        System.out.println(map.get("bbb"));      // 根据value取值，如不存在返回null

        System.out.println("——————————————————");
        // 输出元素个数
        System.out.println(map.size());

        System.out.println("——————————————————");
        // 判断当前map集合中是否包含指定的key和value
        System.out.println(map.containsKey(3));
        System.out.println(map.containsValue("bbb"));

        System.out.println("——————————————————");
        // 遍历，通过map.keySet()
        // keySet(),获取集合的所有key值
        // values(),获取集合的所有value值
        for(Integer key : map.keySet()){
            System.out.println("key:" + key + " value:" + map.get(key));
        }
    }
}

遍历的改进版（通过map.entrySet()）

https://www.cnblogs.com/guoxu/articles/1703393.html

https://blog.csdn.net/kyi_zhu123/article/details/52769469

2、Collections工具类

Collections是一个操作Set、List集合的工具类，提供了大量方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可见、对集合对象实现同步控制等方法

排序操作：

reverse(List)：反转List中元素的顺序
shuffle(List)：对List集合元素进行随机排序
sort(List)：根据元素的自然顺序对指定List集合元素按升序排序
sort(List，Comparator)：根据指定的Comparator产生的顺序对List集合元素进行排序
swap(List, int, int)：将指定List集合中的i处元素和j处元素进行交换

import java.util.*;

public class MyException {
    public static void main(String[] args) {
        List<Person> personList = new ArrayList<>();

        Person s1 = new Person(1, "aaa");
        Person s2 = new Person(4, "ddd");
        Person s3 = new Person(2, "bbb");
        Person s4 = new Person(3, "ccc");

        personList.add(s1);
        personList.add(s2);
        personList.add(s3);
        personList.add(s4);
        
        // 按年龄进行升序排序
        Collections.sort(personList, new Person());

        for(Person k : personList){
            System.out.println("age: " + k.age + " name: " + k.name);
        }

    }
}


class Person implements Comparator<Person> {
    int age;
    String name;

    Person(){}

    Person(int age, String name){
        this.age = age;
        this.name = name;
    }

    @Override
    public int compare(Person o1, Person o2) {
        if(o1.age > o2.age)
            return 1;
        else if( o1.age < o2.age)
            return -1;
        return 0;
    }
}

查找、替换

Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
Object max(Collection, Comparator)：根据指定的Comparator产生的顺序，返回给定集合中的最大元素
Object min(Collection)
Object min(Collection, Comparator)
int frequency(Collection, Object)：返回指定集合中指定元素的出现次数
boolean replaceAll(List list, Object oldVal, Object newVal)：使用新值替换List对象的所有旧值

3、泛型

之前写过的博客