集合

• 数组和集合的区别

-相同点

• 都是容器，可以存储多个数据

-不同点

• 数组的长度是不可变的,集合的长度是可变的

• 数组可以存基本数据类型和引用数据类型

• 集合只能存引用数据类型，如果要存基本数据类型,需要存对应的包装类

Collection集合

1.1 Collection 集合概述和使用

• 是单例集合的顶层接口,它表示一组对象,这些对象也称为Collection的元素

• 是单例集合的顶层接口,它表示一组对象,这些对象也称为Collection的元素

• JDK 不提供此接口的任何直接实现.它提供更具体的子接口(如Set和List)实现

1.2 创建Collection集合的对象

• 多态的方式

• 具体的实现类ArrayListCollection

• 集合常用方法
  

public class Testmain {
    public static void main(String[] args) {  // 父类引用指向子类的对象
        Collection<String> collection = new ArrayList<>();
        collection.add("aaa");
        collection.add("bbb");
        collection.add("ccc");
        collection.add("dddd");
        System.out.println(collection);

        // 集合的长度
        System.out.println(collection.size());
        // 判断集合是否为空
        System.out.println(collection.isEmpty());
        // 判断是否存在指定的元素
        System.out.println(collection.contains("a"));
        System.out.println(collection.contains("aaa"));
        // 从集合中移除指定元素
        System.out.println(collection.remove("aaa"));
        // 删除符合条件的所有元素
        collection.removeIf(
                (String s)->{
                    return s.length() == 3;
                }
        );
        // 将集合所有元素都清除
        collection.clear();
        System.out.println(collection);
    }
}

1.3Collection集合的遍历

-迭代器介绍
迭代器，集合的专用遍历方式

• Iterator iterator(): 返回此集合中元素的迭代器，通过集合对象的iterator()方法得到
• Iterator中的常用方法
  boolean hasNext(): 判断当前位置是否有元素可以被取出
  ​E next(): 获取当前位置的元素,将迭代器对象移向下一个索引位置

集合的遍历

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Iteratortest {
    public static void main(String[] args) {
        //创建集合对象
        Collection<String> c = new ArrayList<>();
        //添加元素
        c.add("hello");
        c.add("world");
        c.add("java");
        c.add("javaee");

        //返回此集合中元素的迭代器，通过集合的iterator()方法得到
        Iterator<String> it = c.iterator();

        //用while循环改进元素的判断和获取
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}

List集合

List集合 概述&特点
-概述

• 有序集合,这里的有序指的是存取顺序

• 用户可以精确控制列表中每个元素的插入位置,用户可以通过整数索引访问元素,并搜索列表中的元素

• 与Set集合不同,列表通常允许重复的元素List集合的特点

-List集合的特点

• 存取有序
• 可以重复
• 有索引

-List集合的特有方法

add , get , set , remove
-数组结构
数组 就像身上编了号站成一排的人，要找第10个人很容易，根据人身上的编号很快就能找到。但插入、删除慢，要向某个位置插入或删除一个人时，后面的人身上的编号都要变。当然，加入或删除的人始终末尾的也快。查询快，增删慢

-链表结构
链表 是一种上一个元素的引用指向下一个元素的存储结构，链表通过指针来连接元素与元素。查询慢、增删快

List集合子类的特点

ArrayList集合

• 底层是数组结构实现，查询快、增删慢 ( )

• ArrayList的构造方法和添加方法

-ArrayList类常用方法

import java.util.ArrayList;

public class ArrayListpractice {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("大娃");
        list.add("二娃");
        list.add("三娃");
        list.add("四娃");
        list.add("五娃");
        list.add("六娃");
        list.add("七娃");

        list.remove(0);
        list.remove("二娃");
        list.set(2, "java");
        System.out.println(list.get(4));
        System.out.println(list.size());
        System.out.println(list);
    }
}

LinkedList集合

• 底层是链表结构实现，查询慢、增删快
  LinkedList集合的特有功能 特有方法

Set集合

-Set 集合概述和特点

• 不可以存储重复元素
• 存取顺序不一致
• 没有索引，不能使用带索引的方法，不能使用普通for循环遍历

import java.util.Iterator;
import java.util.TreeSet;

public class Treesettext {
    public static void main(String[] args) {
        TreeSet<Integer> set = new TreeSet<>();
        set.add(10);
        set.add(11);
        set.add(12);
        set.add(13);
        set.add(14);
        set.add(10);
        for (Integer integer : set) {
            System.out.println(integer);
        }
        System.out.println("----------------");
        Iterator<Integer> ite = set.iterator();
        while (ite.hasNext()){
            System.out.println(ite.next());
        }
    }
}

TreeSet-自然排序

• 如果返回值为负数，标识当前存入的元素是较小值，存左边
• 如果返回值为0，表式当前存入的元素跟集合中元素重复了，不存
• 如果返回值为正数，表式当前存入的元素是较大值，存右边

-自然排序，就是让元素所属的类实现Comparable接口，重写compareTo(T o)方法重写接口中的compareTo方法

-重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

• this – o : 升序
• o – this : 降序

public class Student implements Comparable<Student> {
    private String name;
    private int age;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Student o) {
        int result = this.age - o.age;
        return result = result == 0 ? this.name.compareTo(o.getName()) : result;
    }
}

public class Mytreeset {
    public static void main(String[] args) {
        TreeSet<Student> set = new TreeSet<>();
        Student s1 = new Student("hahaha",12);
        Student s2 = new Student("haha",14);
        Student s3 = new Student("ha",18);

        set.add(s1);
        set.add(s2);
        set.add(s3);

        for (Student student : set) {
            System.out.println(student);
        }

        System.out.println("------------------");

        Iterator<Student> ite = set.iterator();
        while (ite.hasNext()){
            System.out.println(ite.next());
        }
    }
}

1.2
-比较器排序Comparator的使用

• TreeSet的带参构造方法使用的是比较器排序对元素进行排序的-
• 比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare(T o1,T o2)方法
• 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

public class Teacher {
    private String name;
    private int age;

    public Teacher() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

import java.util.TreeSet;

public class Mytreeset {
    public static void main(String[] args) {
        TreeSet<Teacher> set = new TreeSet<>(new Comparator<Teacher>() {
            @Override
            public int compare(Teacher o1, Teacher o2) {
                int result = o1.getAge() - o2.getAge();
                return result=result == 0?o1.getName().compareTo(o2.getName()):result;
            }
        });
    }
}

HashSet集合

-HashSet集合概述和特点

• 底层数据结构是哈希表

• 存取无序

• 不可以存储重复元素没有索引，不能使用普通for循环遍历

  HashSet集合存储自定义类型元素,要想实现元素的唯一,要求必须重写hashCode方法和equals方法

import java.util.HashSet;
import java.util.Set;

public class HashSetPractice {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();
        Set.of("haha", "heihei", "hengheng", "papa").forEach(s -> System.out.println(s));
    }
}

Map集合

-Map集合概述和特点

• interface Map<K,V> K：键的类型；V：值的类型

-Map集合的特点

• 双列集合，一个键对应一个值
• 键不可以重复，值可以重复
• (键+值)这个整体，我们称之为“键值对”或者“键值对对象”，在Java中叫做“Entry对象“

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

public class Mappractice {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<String, Integer>();
        map.put("hahaha",12);
        map.put("haha",16);
        map.put("ha",19);
        System.out.println(map);
    }
}

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

public class Mapmethod {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<>();
        map.put("houhouhou",21);
        map.put("houhou",23);
        map.put("hou",26);
        //集合长度  也就是键值对个数
        System.out.println(map.size());
        //判断集合是否为空
        System.out.println(map.isEmpty());
        //判断集合是否包含指定的键
        System.out.println(map.containsKey("hou"));
        //判断集合是否包含指定的值
        System.out.println(map.containsValue(26));
        //根据键删除 键值对元素
        System.out.println(map.remove("hou"));
        //移除所有键值对元素
        map.clear();
        System.out.println(map);


    }
}

-Map集合的获取功能

-Map集合的遍历 方式1

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

public class Mapmethod {
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<>();
        map.put(1,"孙悟空");
        map.put(2,"猪八戒");
        map.put(3,"沙和尚");
        map.put(4,"唐僧");

        Set<Integer> keys = map.keySet();
        for (Integer key : keys) {
            String value = map.get(key);
            System.out.println(key+"------"+value);
        }
    }
}

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

public class Mapmethod {
    public static void main(String[] args) {
        Map<Integer, String> map = Map.ofEntries(
                Map.entry(1, "孙悟空"),
                Map.entry(2, "猪八戒"),
                Map.entry(3, "沙和尚"),
                Map.entry(4, "唐僧"));


        /*Set<Integer> keys = map.keySet();
        for (Integer key : keys) {
            String value = map.get(key);
            System.out.println(key+"------"+value);
        }*/

        //System.out.println(map.entrySet());

        Set<Map.Entry<Integer, String>> entries = map.entrySet();
        for (Map.Entry<Integer, String> entry : entries) {
            System.out.println(entry.getKey() + "---" + entry.getValue());
        }
    }
}

HashMap集合

-HashMap集合概述和特点

• HashMap底层是哈希表结构的
• 依赖hashCode方法和equals方法保证键的唯一
• 如果键要存储的是自定义对象，需要重写hashCode和equals方法

-HashMap集合应用案例

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

public class Hashmappractice {
    public static void main(String[] args) {
        HashMap<Student,String> hsmap = new HashMap<>();
        Student student = new Student("xiaohei",21);
        Student student1 = new Student("xiaohua",23);
        Student student2 = new Student("xiaoran",26);

        hsmap.put(student,"陕西");
        hsmap.put(student1,"山西");
        hsmap.put(student2,"上海");

        Set<Student> keys = hsmap.keySet();
        for (Student key : keys) {
            String value = hsmap.get(key);
            System.out.println(key+"----"+value);
        }
        System.out.println("===========================");

        Set<Map.Entry<Student, String>> entries = hsmap.entrySet();
        for (Map.Entry<Student, String> entry : entries) {
            String value = entry.getValue();
            Student key = entry.getKey();
            System.out.println(key+"----"+value);
        }

        System.out.println("------------------------");
        hsmap.forEach(
                (key,value)->{
                    System.out.println(key+"----"+value);
                }
        );

    }
}

class Student{
    private String name;
    private int age;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    
    @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;
    }
}
 	

TreeMap集合

-TreeMap集合概述和特点

• TreeMap底层是红黑树结构
• 依赖自然排序或者比较器排序，对键进行排序
• 如果键存储的是自定义对象，需要实现Comparable接口或者在创建TreeMap对象时候给出比较器排序规则

import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class Treemappractice {
    public static void main(String[] args) {
        TreeMap<Teacher, String> tree = new TreeMap<>();

        Teacher teacher1 = new Teacher("xiaobai", 23);
        Teacher teacher = new Teacher("xiaohei", 21);
        Teacher teacher2 = new Teacher("xiaohua", 26);

        tree.put(teacher, "江苏");
        tree.put(teacher1, "陕西");
        tree.put(teacher2, "上海");

        Set<Map.Entry<Teacher, String>> entries = tree.entrySet();
        Iterator<Map.Entry<Teacher, String>> keyss = entries.iterator();
        while (keyss.hasNext()) {
            Map.Entry<Teacher, String> entry = keyss.next();
            Teacher key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "--" + value);
        }
    }
}

class Teacher implements Comparable<Teacher> {
    private String name;
    private int age;

    public Teacher() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }


    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Teacher o) {
        int result = this.getAge() - o.getAge();
        result = result == 0 ? this.getName().compareTo(o.getName()) : result;
        return result;
    }
}