JAVA萌新学习day15 集合

JAVA萌新学习day15 集合

一.集合

1.概念
1.1
集合：就是一个储存数据的容器。
集合与数组一样，也是一个容器，与数组的区别：
1)数组长度固定，集合长度不固定。
2)数组可以储存基本类型和引用类型，集合中存储的元素类型只能是引用类型。
1.2集合与数组的对比
相同点：都是数据的容器，在一个数组或集合中可以储存多个数据。
不同点：
元素：数组中的元素只能是相同，集合中的元素是任意的。数组中可以储存基本类型和引用类型，集合只能存储引用类型。
长度(元素个数)：数组是定长的，一旦初始化长度就不可以修改。几何长度可以修改，可以删除元素和添加元素。

二.代码部分

Dog

package com.qf.java1904.day15;

public class Dog {
    //名称
    String name;
    //年龄
    int age;
    //品种
    String brand;

    public Dog(){
        this("",0,"");
    }

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

    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 getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    @Override
    public boolean equals(Object o){

        //如果两个对象的地址相等说明是同一个对象
        if(this == o){
            return true;
        }
        //如果另一个对象为空，两个对象肯定不相等
        if(o == null){
            return false;
        }
        //如果两个对象不是同类型，肯定不相等
        if(this.getClass() != o.getClass()){
            return false;
        }
        Dog dog = (Dog)o;
        if(!dog.name.equals(this.name)){
            return false;
        }
        else if(dog.age != this.age){
            return false;
        }
        else if(dog.brand.equals(this.brand)){
            return false;
        }

        return  true;
    }

    @Override
    public int hashCode(){
        //把所有的属性值都参与运算，得出一个整数
        // ((*31*p1)*31 + p2)*31 + p3

        final int prime = 31;//系数
        int code = 1;
        code = code * prime + age;
        //code = code * prime + height;
        if(this.name != null){
            code = code * prime + this.name.hashCode();
        }
        if(this.brand != null){
            code = code * prime + this.brand.hashCode();
        }
        return code;
    }

    @Override
    public String toString(){
        String str = "年龄：" + age + "，小名：" + name + "，品种：" + brand;
        return str;
    }
}

DogComparator

package com.qf.java1904.day15;

import java.util.Comparator;

public class DogComparator implements Comparator<Dog> {
    @Override
    public int compare(Dog o1, Dog o2){
        return o1.age - o2.age;
    }
}

SetMapDemo

package com.qf.java1904.day15;

import com.qf.java1904.day13.StudyDemo;

import java.util.*;

import java.util.Map;

public class SetMapDemo {
    public static void main(String[] args) {
        System.out.println("SetMapDemo.main");

        hashSetTest();
        treeSetTest();
        mapTest();

    }

    public static void hashSetTest(){
        //创建一个HashSet对象
        HashSet<String> hashSet = new HashSet<>();
        String[] names = {"Student", "Teacher", "学生","老师", "1", "2", "3", "4", "5", "6"};

        //向集合中添加元素
        //集合是无序的，不能添加重复元素
        //重复元素:调用对象的两个方法:equals 和 hashCode 如果都相同，说明是同一个对象.
        for (int i = 0; i < 20; i++) {

            String name = String.valueOf(i);

            hashSet.add(name);
        }

        //遍历集合中的元素
        for(String value : hashSet) {
            System.out.print(value);
            System.out.print(" ");
        }
        System.out.println();

        //遍历集合中的元素
        for(String value : hashSet) {
            System.out.print(value);
            System.out.print(" ");
        }
        System.out.println();

        //遍历集合中的元素
        for(String value : hashSet) {
            System.out.print(value);
            System.out.print(" ");
        }
        System.out.println();

        Iterator<String> iterator = hashSet.iterator();
        while(iterator.hasNext()){
            String value = iterator.next();
            System.out.print(value);
            System.out.print(" ");
        }
        System.out.println();

        //将集合元素保存到一个数组中，参数是泛型，所以需要指定具体类型
        String[] values = hashSet.toArray(new String[]{});
        for(String value : values){
            System.out.print(value + " ");
        }
        System.out.println();

        hashSet.clear();
        System.out.println("当前大小:" + hashSet.size());

        HashSet<Dog> dogSet = new HashSet<>();
        for (int i = 0; i < 10; i++) {
            Dog dog = new Dog("小白",i + 1,"二哈");

            dogSet.add(dog);
        }
        System.out.println("Dog当前大小:" + dogSet.size());

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

    public static void treeSetTest(){
        /*
        1.set接口是无序接口，不能保存相同元素
        2. 常用实现为 HashSer LinkedHashSet TreeSet
        3.HashSet不保证元素顺序
        4.LinkedHashSet 可根据田间的顺序遍历
        5.TreeSet 保证顺序，即排序
        */

        Random random = new Random();
        TreeSet<Dog> treeSet = new TreeSet<>(new DogComparator());
        for (int i = 0; i < 5; i++) {
            Dog dog = new Dog("小白", random.nextInt(10), "二哈");
            boolean success = treeSet.add(dog);
            String info = success?"成功":"失败";
            System.out.println("添加" + info);
        }

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

    public static void mapTest(){
        /*
        Map为键-值对的集合
        集合中的元素：是一个键值对，key不能重复，value可以重复
        */

        Map<String,Dog> map = new HashMap<>();

        for (int i = 0; i < 5; i++) {
            //根据循环条件，产生一个key，实际也可以是任意类型对象
            String key = "Key" + i;

            //用了我们day13的随机字符产生方法
            String name = StudyDemo.randomString(5);
            Dog dog = new Dog(name,i + 1,"二哈");

            //将当前键-值对保存到map集合中
            map.put(key,dog);
        }
        System.out.println(map.size());
        //要想获得map中的value，首先得知道key
        //先获得所有的key
        //用字符串泛型的集合保存key
        Set<String> keySet = map.keySet();
        //通过迭代器遍历集合
        Iterator<String> iterator = keySet.iterator();
        while(iterator.hasNext()){
            String key = iterator.next();
            //通过key获得对应的值
            Dog dog = map.get(key);
            System.out.println(dog);
        }
        System.out.println("-----------------------------------------------------------------------------");

        Set<Map.Entry<String,Dog>> entrySet = map.entrySet();

        //对键值对集合遍历 获得每一个Map.Entry类型对象
        for(Map.Entry entry : entrySet){
            //获得当前key
            System.out.println(entry.getKey());
            //获得当前value
            System.out.println(entry.getValue());
        }
        System.out.println("-----------------------------------------------------------------------------");

        //获得当前map对象所有值的合计
        Collection<Dog> values = map.values();

        for(Dog dog : values){
            System.out.println(dog);
        }

        /*
        Collection接口有两个子接口，分别是List 和 Set
        List接口有很多实现类(ArrayList,LinkedList,.....)统称管他们叫有序集合
        Set接口也有多实现类(HashSet,TrueSet,LinkedHashSet)统称管他们叫无序集合
        Map接口也有多实现类(HashMap,TreeMap,HashTable)统称管他们叫键值对集合

        我们实际使用时如何选择.
        1.首先根据有序，无序，还是键值对决定用什么
        2.其次再根据实际需求，选择不同的实现子类
        */
    }

}