java 集合的基础学习

集合的定义

集合的定义

集合是用来干啥的：
集合就相当于一个人容器，用来存储数据的
Collection：
JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现。此接口通常
用来传递collection，并在需要最大普遍性的地方操作这些 collection。

集合与数组的区别

1.数组的长度是固定的，集合中的长度是可以改变的
2.数组中可以存储基本数据类型和引用数据类型，集合中只能存储引用数据类型
3.数组中只能存储一种数据类型，集合中可以存储多种数据类型

集合的接口

public class Student {
//    成员变量(属性)
    private int id;//学号
    private String name;//姓名
    private int age;//年龄
    private String sex;//性别

    public Student() {
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    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;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

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

`

list接口

List集合存储的数据是有顺序、可以重复、有索引

ArrayList

            ArrayList：底层实现是数组，查询快、增删慢，线程不安全，效率高(特别重要)

public class StudentTest {
    public static void main(String[] args) {
//        集合中的尖括号叫做泛型，泛型其实就是集合中存储数据的一个类型
//        ArrayList<String> arrayList = new ArrayList<>();
        因为集合的泛型是String，所以只能存储String类型的数据
        arrayList.add(123);
//        arrayList.add("aaa");

//        创建一个ArrayList集合，用来从来存储学生信息
        ArrayList<Student> arrayList = new ArrayList<>();
//        创建Student对象，并给属性赋值
        Student student1 = new Student(1,"张三",20,"男");
        Student student2 = new Student(2,"李四",18,"女");
        Student student3 = new Student(3,"王五",22,"男");
        Student student4 = new Student(4,"赵六",19,"女");
//        添加到集合中
        arrayList.add(student1);
        arrayList.add(student2);
        arrayList.add(student3);
        arrayList.add(student4);
//        第一种输出方法：使用增强for循环遍历并输出
        for (Student student : arrayList) {
            System.out.println(student);
        }

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

//        第二种输出方法：使用迭代器(iterator)
//        使用迭代器遍历集合中的每个元素
        Iterator<Student> iterator = arrayList.iterator();
//        如果集合中有元素就一直循环，知道集合中没有元素
        while (iterator.hasNext()){
//            获取迭代出的元素
            Student next = iterator.next();
//            输出迭代出的元素
            System.out.println(next);
        }
//        求这个案例中学生的平均年龄、最大年龄和学生人数
    }
}

public class Test01 {
    public static void main(String[] args) {
//        创建一个ArrayList集合
        ArrayList arrayList = new ArrayList();
//        添加元素
        arrayList.add("aaa");
        arrayList.add(111);
        arrayList.add(222);
        arrayList.add("aaa");
//        在指定的位置插入指定的元素
        arrayList.add(1,"qqq");
//        想要得到集合中的元素，是需要遍历的
        System.out.println(arrayList);
//        输出集合中元素的个数
        System.out.println("集合中一共有"+arrayList.size()+"个元素");
//        修改集合中的元素
        arrayList.set(2,"bbb");
//        删除集合中的元素（可以根据元素删除，也可以根据索引删除）,根据元素时候，如果有相同的元素那就删除前面的
        arrayList.remove("aaa");

//        使用增强for，遍历输出集合中的元素，Object是所有类的父类，Object可以是所有类
        for (Object o : arrayList) {
            System.out.println(o);
        }
        System.out.println("--------------------------------------------------");
//        获取集合中某个元素
        System.out.println(arrayList.get(2));
//        清空集合中所有的元素
        arrayList.clear();

        System.out.println("--------------------------------------------------");
        for (Object o : arrayList) {
            System.out.println(o);
        }
    }
}

LinkList

            LinkedList：底层实现是数组，增删快、查询慢，线程不安全，效率高

public class Test02 {
    public static void main(String[] args) {
//        创建一个LinkedList集合
        LinkedList linkedList = new LinkedList();
//        给LinkedList中添加数据
        linkedList.add(111);
        linkedList.add("aaa");
        linkedList.add("bbb");
        linkedList.add(111);
        给这条数据添加到集合的第一个位置
//        linkedList.addFirst("qqq");
        给这条数据添加到集合的最后一个位置
//        linkedList.addLast("www");
//        删除集合中的元素（可以根据元素删除，也可以根据索引删除）,根据元素时候，如果有相同的元素那就删除前面的
//        linkedList.remove(2);
//        linkedList.remove("bbb");
//        linkedList.removeFirst();
//        linkedList.removeLast();
//        修改集合中的数据
        linkedList.set(2,"123");
        System.out.println("集合中一共有"+linkedList.size()+"条数据");
//        遍历输出集合中所有的元素
        for (Object o : linkedList) {
            System.out.println(o);
        }
    }
}

案例作业

1.创建一个学生类，属性有：学号、姓名、年龄、性别，属性创建为私有的，
2.在测试类创建一个LinkedList集合，
3.创建5个学生对象并存到LinkedList集合中
4.求这个案例中学生的平均年龄、最大年龄和学生人数

public class Lswzye {
//     1.创建一个学生类，属性有：学号、姓名、年龄、性别，属性创建为私有的，
        2.在测试类创建一个LinkedList集合，
        3.创建5个学生对象并存到LinkedList集合中
        4.求这个案例中学生的平均年龄、最大年龄和学生人数
public static void main(String[] args) {
    int max =0 ,sum = 0,avg = 0;
//    创建集合
    LinkedList<Student> linkedList = new LinkedList<>();
//    创建五个学生对象
    linkedList.add(new Student(1,"张三",20,"男"));
    linkedList.add(new Student(2,"李四",18,"女"));
    linkedList.add(new Student(2,"李四",18,"女"));
    linkedList.add(new Student(4,"赵六",19,"女"));
    linkedList.add(new Student(5,"沈七",23,"女"));
    for (int i = 0; i<linkedList.size();i++)
    {
        sum+=linkedList.get(i).getAge();
        if (linkedList.get(i).getAge()>max)
        {
            max =linkedList.get(i).getAge();
        }
    }
    avg = sum/linkedList.size();
    System.out.println("学生的平均年龄是"+avg+"\t学生年纪的最大值"+max+"\t一共有"+linkedList.size()+"个学生");
}
}

Vector

            Vector：底层实现是数组，查询快、增删改慢，线程安全，效率低(没用)

set接口

Set集合存储的数据是没有顺序、不可以重复、没有索引
HashSet：底层是HashMap，数组+链表实现，不允许元素重复，无序
案例

public class Student {
    private String name;
    private  int age;
    private String sex;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name) &&
                Objects.equals(sex, student.sex);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age, sex);
    }

    public Student() {
    }

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

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    /**
     * 获取
     * @return sex
     */
    public String getSex() {
        return sex;
    }

    /**
     * 设置
     * @param sex
     */
    public void setSex(String sex) {
        this.sex = sex;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + ", sex = " + sex + "}";
    }
}

```java
public class Hashset {
    public static void main(String[] args) {
        HashSet<Student> s1 = new HashSet<>();
        Student s2 = new Student("aaa",18,"男");
        Student student3 = new Student("aaa",18,"男");
        s1.add(s2);
        s1.add(student3);
        s1.add(new Student("BBB",19,"男"));
        s1.add(new Student("BBB",19,"男"));
        System.out.println();
        System.out.println(s1);
        System.out.println(s2.hashCode());
        System.out.println(student3.hashCode());
        System.out.println(s2.equals(student3));
    }
}

                TreeSet：底层实现是红黑二叉树，实现元素排序，排序案例如下
            

```java
public class Apple {
    private String name;
    private String color;
    private  int price;

    public Apple() {
    }

    public Apple(String name, String color, int price) {
        this.name = name;
        this.color = color;
        this.price = price;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return color
     */
    public String getColor() {
        return color;
    }

    /**
     * 设置
     * @param color
     */
    public void setColor(String color) {
        this.color = color;
    }

    /**
     * 获取
     * @return price
     */
    public int getPrice() {
        return price;
    }

    /**
     * 设置
     * @param price
     */
    public void setPrice(int price) {
        this.price = price;
    }

    public String toString() {
        return "Apple{name = " + name + ", color = " + color + ", price = " + price + "}";
    }
}

public class TreeSet {
    public static void main(String[] args) {
        Apple apple1 = new Apple("红富士", "红色", 18);
        Apple apple2 = new Apple("富士", "蓝色", 13);
        Apple apple3 = new Apple("红士", "绿色", 19);
        Apple apple4 = new Apple("士", "青色", 8);
//        TreeSet排序
        java.util.TreeSet<Apple> objects = new java.util.TreeSet<>(
                new Comparator<Apple>() {
                    @Override
                    public int compare(Apple o1, Apple o2) {
                        return o2.getPrice()-o1.getPrice();
                    }
                }
        );
        objects.add(apple1);
        objects.add(apple2);
        objects.add(apple3);
        objects.add(apple4);
        System.out.println(objects);
    }
}

map接口

key-value键值对形式存储数据的

HashMap

hahmap：底层是数组+链表实现，无序(特别重要）

public class StudentTest2 {
    public static void main(String[] args) {
//        1.创建一个学生类，属性有：学号、姓名、年龄、性别，属性创建为私有的
//        2.在测试类创建一个HashMap集合
//        3.创建3个学生对象并存到HashMap集合中

//        创建一个HashMap集合
        HashMap<Integer, Student> hashMap = new HashMap<>();
//        创建3个学生对象并存到HashMap集合中
//        Student student1 = new Student(1,"张三",20,"男");
//        Student student2 = new Student(2,"李四",18,"女");
//        Student student3 = new Student(3,"王五",22,"男");
//        hashMap.put(1,student1);
//        hashMap.put(2,student2);
//        hashMap.put(3,student3);
        hashMap.put(1,new Student(1,"张三",20,"男"));
        hashMap.put(2,new Student(2,"李四",18,"女"));
        hashMap.put(3,new Student(3,"王五",22,"男"));
//        通过keySet方法获取集合中所有的key值，并遍历
        Set<Integer> integers = hashMap.keySet();
        System.out.print("集合中key分别为：");
        for (Integer integer : integers) {
            System.out.print(integer+" ");
        }

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

//        通过values方法获取集合中所有的value值，并遍历
        Collection<Student> values = hashMap.values();
        for (Student value : values) {
            System.out.println("value值为："+value);
        }

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

//        第一种遍历Map集合的方法：通过keySet方法获取集合中所有的key值，在通过key值获取集合所有的value值(推荐使用)
        Set<Integer> integers1 = hashMap.keySet();
        for (Integer integer : integers1) {
            System.out.println("key值为："+integer+"，对应的value值为："+hashMap.get(integer));
        }

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

//        第二种遍历Map集合的方法：通过泛型遍历
        Set<Map.Entry<Integer,Student>> entrySet = hashMap.entrySet();
        for (Map.Entry<Integer,Student> entry : entrySet){
            System.out.println("key值为："+entry.getKey()+"，对应的value值为："+entry.getValue());
        }

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

//        使用key作为对象
        HashMap<Student, Integer> map = new HashMap<>();
        map.put(new Student(1,"张三",20,"男"),1);
        map.put(new Student(2,"李四",18,"女"),2);
        map.put(new Student(3,"王五",22,"男"),3);
//        通过keySet方法获取集合中所有的key值，在通过key值获取集合所有的value值
        Set<Student> students = map.keySet();
        for (Student student : students) {
            System.out.println("key值为："+student+"，对应的value值为："+map.get(student));
        }
    }
}

TreeMap

TreeMap：底层实现是红黑二叉树，实现元素排序

案例作业

使用键盘录入输入一个字符串，键作为某个字符串，值作为字符串的个数
// 比如：asdasdaad
// 结果：
// 键=a，值=4
// 键=s，值=2
// 键=d，值=3

public class Test04 {
    public static void main(String[] args) {
//        使用键盘录入输入一个字符串，键作为某个字符串，值作为字符串的个数
//        比如：asdasdaad
//        结果：
//        键=a，值=4
//        键=s，值=2
//        键=d，值=3

//        创建一个Scanner对象
        Scanner scanner = new Scanner(System.in);
//        提示语句
        System.out.println("请输入一个字符串：");
//        接受语句
        String next = scanner.next();
//        创建一个HashMap集合，键是字符串，值是字符串出现的次数
        HashMap<Character, Integer> map = new HashMap<>();
//        遍历输入字符串中的每个字符串
        for (int i = 0; i < next.length(); i++) {
//            取出每个字符
            char ch = next.charAt(i);
//            得到每个字符
            System.out.print(ch+" ");
//            拿这个字符去HashMap集合中看看有没有这个key，如果有的话就给对应的值+1，没有的话就说明这个字符串还是
//            第一次统计，就直接存进去
            if (map.containsKey(ch)){
//                有的话就给对应的值+1
                map.put(ch,map.get(ch)+1);
            }else {
//                没有就直接存进去
                map.put(ch,1);
            }
        }
        System.out.println("\n键："+map.keySet()+",值："+map.values());
    }
}