java中set集合基础内容

set集合的基本使用

无序并且不重复的集合，我们一般叫它为集。并且只能有一个null元素。
这个集合的作用是性能好。
Java.uitl 包里边的内容。
HashSet()

集合的遍历：
因为HashSet集合的遍历是先转化成迭代器，然后通过迭代器进行遍历。如下代码:
迭代器的两个方法:
hashNext() 表示的是判断下一个是否还有数据
next()取出下一个数据

代码：

package com.demo;

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

public class ListDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String str1="blue";
        String str2="green";
        String str3="yellow";
        String str4="red";
        String str5="white";
        
        //生成一个集合
        Set hashset=new HashSet();
        //集合里边添加新的数据
        hashset.add(str1);
        hashset.add(str2);
        hashset.add(str3);
        hashset.add(str4);
        hashset.add(str5);
        
        //转换成迭代器
        Iterator it=hashset.iterator();
        //然后循环遍历这个迭代器
        while(it.hasNext()) {
            System.out.println(it.next()+",");
        }
    }

}

输出的结果是：
red,
green,
blue,
white,
yellow,

实例

Cat类的代码:

package com.dem.set;

public class Cat {
    //先定义属性
    private String name;
    private int age;
    private String species;
    
    //构造方法
    public Cat(String name,int age,String species) {
        super();
        this.name=name;
        this.age=age;
        this.species=species;
    }
    
    //get and  seT方法
    public String getName() {
        return this.name;
    }
    public void setName(String name) {
        this.name=name;
    }

    public int getAge() {
        return this.age;
    }
    public void setAge(int age) {
        this.age=age;
    }
    public String getSpecies() {
        return this.species;
    }
    public void setSpcies(String species) {
        this.species=species;
    }

    //重写toString方法
    @Override
    public String toString() {
        return "Cat [姓名=" + name + ", 年龄=" + age + ",品种=" + species + "]";
    }
}

cat类运行测试的代码：

package com.dem.set;
import java.util.Set;
import java.util.HashSet;
import java.util.Iterator;
public class CatTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Cat cat1=new Cat("花花",10,"英国短毛猫");
        Cat cat2=new Cat("凡凡",8,"中华田园猫");
        
        Set catSet=new HashSet();
        catSet.add(cat1);
        catSet.add(cat2);
        Iterator it=catSet.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());
        }
    }

}

** 测试代码输出的结果是：**
Cat [姓名=花花, 年龄=10,品种=英国短毛猫]
Cat [姓名=凡凡, 年龄=8,品种=中华田园猫]

HashCode和equels的原理。
为什么要重写。
以及这一次的Cat类的重写。

equels方法是用来判断类是否相等的默认方法。所以一个集合的两个类是否相等调用的就是这个类的方法。
所以，我们只要重写这个方法就可以改变类的是否相等方法。
类的对象都有默认的equels方法，一般指的是这个类的对象的地址。
如下代码，对象的内容是一样的，但是两个对象都可以添加进集合(set集合里边是不重复)：

        Cat cat1=new Cat("花花",10,"英国短毛猫");
        Cat cat2=new Cat("凡凡",8,"中华田园猫");
        //cat3和cat1的内容是一样的
        Cat cat3=new Cat("花花",10,"英国短毛猫");

输出的结果是：
Cat [姓名=花花, 年龄=10,品种=英国短毛猫]
Cat [姓名=花花, 年龄=10,品种=英国短毛猫]
Cat [姓名=凡凡, 年龄=8,品种=中华田园猫]

修改eques方法后
equels方法改写后的，如下代码：

@Override
    public boolean equals(Object obj) {
        //如果两个对象的引用是相等，那么这两个对象肯定是相等的
        if(this==obj) {
            return true;
        }
        //判断某个对象的类方法是getClass,这个判断只能双等于
        if(obj.getClass()==this.getClass()) {
            //如果要使用这个类的方法，就需要转成这个类
            Cat objCat=(Cat)obj;
            return objCat.getName()==this.getName() && 
                    objCat.getAge()==this.getAge() && objCat.getSpecies()==this.getSpecies();
        }
        
        return false;
    }

修改后的输出结果：
Cat [姓名=花花, 年龄=10,品种=英国短毛猫]
Cat [姓名=凡凡, 年龄=8,品种=中华田园猫]

泛型

就是规定某个集合、或者某个迭代器、或者某个变量接收的内容是固定的某个类型。
泛型的语法是<类型>这样的方式表示的。
例如以下代码:

        Set<Cat> catSet=new HashSet<Cat>();
        catSet.add(cat1);
        catSet.add(cat2);
        catSet.add(cat3);
        Iterator<Cat> it=catSet.iterator();

集合的的for循环遍历

for(Cat cat:set){} 这样的方式进行遍历的。
set表示集合，cat表示集合里边的每一个内容。
因为set的无序的集合，所以遍历的时候也是无序的。如果在遍历的过程中出现删除的现象，那么集合的顺序又会别打乱，这时遍历就会报错。
如下时报错的代码：

Cat cat1=new Cat("花花",10,"英国短毛猫");
        Cat cat2=new Cat("凡凡",8,"中华田园猫");
        //cat3和cat1的内容是一样的
        Cat cat3=new Cat("花花",10,"英国短毛猫");
        
        Set<Cat> catSet=new HashSet<Cat>();
        catSet.add(cat1);
        catSet.add(cat2);
        catSet.add(cat3);
        for(Cat cat:catSet) {
            if(cat.getName()=="花花") {
                //set集合是无序的，删除后集合会有变动。这样会报错。
                catSet.remove(cat);
            }
            System.out.println("结束了");
        }

所报错误：
结束了
Exception in thread "main" java.util.ConcurrentModificationException
at java.util.HashMap $HashIterator.nextNode(Unknown Source) at java.util.HashMap$ KeyIterator.next(Unknown Source)
at com.dem.set.CatTest.main(CatTest.java:19)

解决办法
如果是删除一个元素，那么删除后直接break；
如果删除多个元素可以用，set.removeAll(集合);可以把多个元素放入到这个集合再进行删除。

Map

Map是键值对的方式。
可以为null，但是不能够重复。
HashMap是这个Map的一个子类，使用Hash完成商品的信息。
实例如下:

Scanner consle=new Scanner(System.in);
        Map<String,Good> goodMap=new HashMap<String,Good>();
        
        int i=0;
        while(i<3) {
            System.out.println("请输入商品的3条信息:");
            System.out.println("**********************");
            System.out.println("请输入商品的id");
            String goodId=consle.next();
            System.out.println("请输入商品的名称");
            String goodName=consle.next();
            System.out.println("请输入商品的价格");
            double goodPrice=consle.nextDouble();
            //把输入的内容添加到商品
            Good good=new Good(goodId,goodName,goodPrice);
            goodMap.put(goodId, good);
            i++;
        }
        //关闭输入流
        consle.close();
        //输出商品的内容
        Iterator<Good> itGood=goodMap.values().iterator();
        while(itGood.hasNext()) {
            System.out.println(itGood.next());
        }
        
        System.out.println("***程序结束***");