集合 学习

集合

集合类的特点：提供一种存储空间可变的存储模型，存储的数据容量可以随时发生改变。

1. Collection集合的概述

   • 是单类集合的顶层接口，他表示一组对象，这些对象也称为Collection的元素。

   • JDK 不提供此接口的任何直接实现，它提供更具体的子接口实现

2. 创建Collection集合的对象

   • 多态的方式

   • 具体的实现类ArrayList

List集合

List集合的特点

• 有序：存储和取出的元素顺序一致

• 可重复：存储的元素可以重复

List集合子类特点

• ArrayList :底层数据结构为数组，其查询快，增删慢。

• LinkedList：底层树结构为链表，增删快，查询慢。

常见的数据结构

• 栈 ： 是一种 --先进后出-- 的模型

• 队列：是一种--先进先出--的模型

• 数组：是一种查询快，增删慢的模型

• 链表：是一种增删快，查询慢的模型

   

set集合

• 不包含重复元素的集合

• 没有带索引的方法，不能使用普通的for循环

对象哈希值的特点

• 哈希值：是JDK根据 对象的地址 或者 字符串或者数字算出来的int类型的数值。

• 同一个对象多次调用hashCode（）方法，返回的哈希值是相同的

• 默认情况下，不同的对象的哈希值是不同的，重写hashCode（）方法，可以实现让不同的对象的哈希值相同。

   

HashSet集合

• 底层数据结构是哈希表

• 对集合的迭代顺序不做任何保证，不保证存储和取出的元素顺序一致。

• 没有带索引的方法，所以不能使用普通for循环

• 由于是Set集合，所以是不包含重复元素的集合。

LinkHashSet

• 哈希表和链表实现的set接口，居于可预测的迭代次序

• 有链表保证元素有序，也就是说元素的存储和取出顺序是一致的

• 有哈希表保证元素唯一，也就是说没有重复的元素。

TreeSet

• 元素有序，这里的顺序不是存储和取出的顺序，而是按照一定的规则进行排序，具体的排序方式取决于构造方法。TreeSet() 根据其元素的自然排序进行排序；TreeSet（Comparator comparator ）根据指定的比较器进行排序。

• 没有带索引的方法，所以不能使用普通的for循环

• 由于是Set集合，所以不包含重复元素的集合

自然排序Comparable

package com.yang.aggregate;
​
import java.util.Objects;
​
//需要implements Comparable接口，然后重写compareTo()方法
​
public 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 int compareTo(Teacher t) {
//        return 0;//不存储
//        return 1;//正序
//        return -1;//倒序
        //按照年龄排序
        int num = this.age - t.age;//小->大
//        int num = t.age - this.age;//大->小
        int num1 = num == 0 ? this.name.compareTo(t.name) : num;//比较名字
        return num1;
    }
}
​

• 用TreeSet 集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序

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

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

比较器排序Comparator

• 用TreeSet 集合存储自定义对象，带参构造方法使用的是-比较器-排序

• 比较器排序，就是让集合构造方法接收Compartor的实现类对象，重写compare(To 1,T o2)的方法

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

  //用比较器Comparable
  public class Demo08 {
      public static void main(String[] args) {
          TreeSet<Teacher> t = new TreeSet<>(new Comparator<Teacher>() {
              @Override
              public int compare(Teacher o1, Teacher o2) {
                  //this.age-s.age
                  //o1  o2
                  int num = o1.getAge() - o2.getAge();
                  int num2 = num == 0 ? o1.getName().compareTo(o2.getName()) : num;
                  return num2;
              }
          });

   

Map 集合

• Interface Map<K,V> k: 键的类型 V：值的类型

• 将键映射到值的对象；不能包含重复的键，每个键可以映射到最多一个值。

  • map集合的遍历方法

    package com.yang.set;
    ​
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    ​
    public class Demo04 {
        public static void main(String[] args) {
            Map<String,Student> map = new HashMap<>();
    ​
            Student s1 = new Student("小黄",20);
            Student s2 = new Student("小黄",20);
            Student s3 = new Student("小黄",20);
    ​
            map.put("001",s1);
            map.put("002",s2);
            map.put("003",s3);
    ​
            //遍历集合方法1
            Set<String> set = map.keySet();//获取所有的键
            for (String s:set
                 ) {//遍历键
                Student t = map.get(s);//获得value
                System.out.println(s+"=("+t.getName()+","+t.getAge()+")");
            }
            //遍历集合方法二
            //获得所有的实体对象
            Set<Map.Entry<String, Student>> entries = map.entrySet();
            for ( Map.Entry<String, Student> a : entries
                 ) {//遍历对象
                String key = a.getKey();
                Student value = a.getValue();
                System.out.println(key+"="+value.getName()+","+value.getAge());
            }
        }
    }
    ​

     

HashMap

package com.yang.set;
​
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;
//map集合中存储key是字符串，value是list集合
public class Demo07 {
    public static void main(String[] args) {
        //创建集合
        HashMap<String, ArrayList<String>> hm = new HashMap<>();
        ArrayList<String> a1 = new ArrayList<>();
        a1.add("小桥");
        a1.add("大桥");
        ArrayList<String> a2 = new ArrayList<>();
        a2.add("乔峰");
        a2.add("张无忌");
        ArrayList<String> a3 = new ArrayList<>();
        a3.add("在那个鳗鱼");
        a3.add("任盈盈");
        //添加
        hm.put("001", a1);
        hm.put("002", a2);
        hm.put("003", a3);
        //遍历
        Set<String> keySet = hm.keySet();
        for (String s : keySet) {
            ArrayList<String> arrayList = hm.get(s);
            for (String st : arrayList) {
                System.out.println(s+"="+st);
            }
        }
    }
}
​

package com.yang.set;
​
import java.util.HashMap;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;
​
public class Demo08 {
    public static void main(String[] args) {
        //键盘录入一串字符
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入字符");
        //接收字符
        String s = scanner.nextLine();
        //创建集合，这个时无序的。
//        HashMap<Character, Integer> hashMap = new HashMap<>();
        //这个是有序的，是对key
        TreeMap<Character, Integer> hashMap = new TreeMap<>();
        //遍历字符串
        for (int i = 0; i < s.length(); i++) {
            char key = s.charAt(i);//获取每一个字符
            Integer value = hashMap.get(key);
            if (value == null) {//如果等于null，说明没有这个字符，然后将字符作为键存储，值+1
                hashMap.put(key, 1);
            } else {
                value++;
                hashMap.put(key, value);
            }
        }
        //拼接字符串
        //创建字符串对象
        StringBuilder sb = new StringBuilder();
        //遍历hashMap集合
        Set<Character> characters = hashMap.keySet();//得到key的集合
        for (Character c : characters) {//得到每一个Key
            Integer value = hashMap.get(c);//得到value
            sb.append(c).append("(").append(value).append(")");//拼接字符串
        }
        String result = sb.toString();
        System.out.println(result);
    }
}
​

package com.yang.set;
​
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
//Collections工具类
//ArrayList集合存储，并排序
public class Demo09 {
    public static void main(String[] args) {
​
        //创建集合
        ArrayList<Student> array = new ArrayList<>();
        //创建学生对象
        Student s1 = new Student("hhh", 22);
        Student s2 = new Student("eee", 22);
        Student s3 = new Student("ccc", 22);
        //将学生对象添加进集合
        array.add(s1);
        array.add(s2);
        array.add(s3);
        //使用Collections对集合进行排序：年龄按小大，姓名按字母排序
        Collections.sort(array, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int num = o1.getAge() - o2.getAge();
                int num2 = num == 0 ? o1.getName().compareTo(o2.getName()) : num;
                return num2;
            }
        });
        //遍历集合
        for (Student s : array) {
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}
​

 

Collections

• 是针对集合操作的工具类