JavaSE（09）（Set集合）

hashSet测试类:
package zz.itheima.set;

import java.util.HashSet;

public class TestHashSet {
    // hashSet测试类
    public static void main(String[] args) {
        HashSet hs = new HashSet();
        //1.唯一性：和无序性
        hs.add("aaa");
        hs.add("bbb");
        hs.add("aaa");
        hs.add("ccc");
        hs.add("ddd");
        hs.add("eee");
        hs.add("fff");
        System.out.println(hs);
        //2.测试hashset存储自定义类型
        HashSet<Stu> stus = new HashSet<>();
        stus.add(new Stu("a", 11));
        stus.add(new Stu("b", 12));
        stus.add(new Stu("c", 13));
        stus.add(new Stu("d", 14));
        stus.add(new Stu("d", 14));
        System.out.println(stus);
        //3.遍历集合
        for (Stu stu : stus) {
            System.out.println(stu);
        }
        //4.删除
        stus.remove(new Stu("c", 13));
        System.out.println(stus);
        //测试hashcode
        Stu s1=new Stu("a", 11);
        Stu s2=new Stu("a", 11);
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
    }
}
运行结果：
[fff, aaa, ddd, ccc, bbb, eee]
[Stu [name=d, age=14], Stu [name=b, age=12], Stu [name=c, age=13], Stu [name=a, age=11]]
Stu [name=d, age=14]
Stu [name=b, age=12]
Stu [name=c, age=13]
Stu [name=a, age=11]
[Stu [name=d, age=14], Stu [name=b, age=12], Stu [name=a, age=11]]
1399
1399
测试LinkedHashSet：
package zz.itheima.set;

import java.util.LinkedHashSet;

public class TestLinkedHashSet {
    //测试LinkedHashSet
    public static void main(String[] args) {
        LinkedHashSet lhs = new LinkedHashSet();
        lhs.add("aaa");
        lhs.add("bbb");
        lhs.add("aaa");
        lhs.add("ccc");
        System.out.println(lhs);
        for (Object object : lhs) {
            System.out.println(object);
        }
    }
}
运行结果：
[aaa, bbb, ccc]
aaa
bbb
ccc
测试TreeSet是否按自然排序：
package zz.itheima.set;

import java.util.TreeSet;

public class TestTreeSet {

    public static void main(String[] args) {
        // 测试TreeSet是否按自然排序
        TreeSet ts = new TreeSet(); 
        ts.add("a");
        ts.add("b");
        ts.add("a");
        ts.add("d");
        ts.add("e");
        ts.add("c");
        System.out.println(ts);

//      public Object ceiling(Object e)
        System.out.println(ts.ceiling("c"));//大于等于c的元素，如果没有就返回null
//      public Object floor(Object e)
        System.out.println(ts.floor("c"));//小于等于c的元素，如果没有就返回null
//      public Object first()
        System.out.println(ts.first());
//      public Object last()
        System.out.println(ts.last());
//      public Object higher(Object e)
        System.out.println(ts.higher("c"));
//      public Object lower(Object e)
        System.out.println(ts.lower("c"));
    }
}
运行结果：
[a, b, c, d, e]
c
c
a
e
d
b
测试foreach：
package zz.itheima.set;

import java.util.ArrayList;

public class TestForeach {

    public static void main(String[] args) {
        //测试foreach
        int[] arr = {1,2,3,4,5,6};
        for (int i = 0; i < arr.length; i++) {
            int temp = arr[i];
            System.out.println(temp);
        }
        for (int i : arr) {
            System.out.println(i);
        }
        System.out.println("*********************");
        ArrayList al = new ArrayList();
        al.add("a");
        al.add("b");
        al.add("c");
        for (int i = 0; i < al.size(); i++) {
            if (al.get(i).equals("b")) {
                al.remove(i);
            }
        }
        System.out.println(al);
    }
}
运行结果：
1
2
3
4
5
6
1
2
3
4
5
6
*********************
[a, c]
迭代器内部实现细节：
package zz.itheima.set;

public class MyIterator {
    //迭代器内部实现细节
    int [] arr = {1,2,3,4,5,6};
    int index = 0;

    public boolean hasNext(){
        if (index<arr.length) {
            return true;
        }else {
            return false;
        }
    }

    public int next(){
        return arr[index++];
    }

}
package zz.itheima.set;

public class TestMyIterator {
    //测试迭代器
    public static void main(String[] args) {
        MyIterator myIterator = new MyIterator();
//      System.out.println(myIterator.next());
//      System.out.println(myIterator.next());
//      System.out.println(myIterator.next());
//      System.out.println(myIterator.next());
//      System.out.println(myIterator.next());
//      System.out.println("***********************");
        while (myIterator.hasNext()) {
            System.out.println(myIterator.next());
        }
    }

}
运行结果：
1
2
3
4
5
6
测试hashset迭代器：
package zz.itheima.set;

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;

public class TestDiedai {

    //可以设计一个方法遍历所有的集合，这能体现出迭代器的好处
    public static void dieDai(Collection c){
        Iterator it = c.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }

    }
    public static void main(String[] args) {
        //测试hashset迭代器
        HashSet hs = new HashSet();
        hs.add("aaa");
        hs.add("bbb");
        hs.add("ccc");
        hs.add("ddd");
        hs.add("eee");
        Iterator it = hs.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }

}
运行结果：
aaa
ddd
ccc
bbb
eee
迭代器增删改查：
package zz.itheima.set;

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

public class Demo1 {

    public static void main(String[] args) {
        //使用HashSet实现对图书(书名、价格)的增(保证唯一）、删(根据书名)、遍历输出和单个查询(书名)
        HashSet<Book> hs = new HashSet<>();
        //增加
        hs.add(new Book("a", 10.0));
        hs.add(new Book("b", 10.0));
        hs.add(new Book("c", 10.0));
        hs.add(new Book("d", 10.0));
        System.out.println(hs);
        //foreach遍历(能对集合遍历)
        for (Book book : hs) {
            System.out.println(book);
        }
        //查询
        String keyName = "d";
        boolean flag = true;
        for (Book book : hs) {
            if (book.getName().equals(keyName)) {
                System.out.println("存在，找到了");
                flag = false;
                break;
            }
        }
        if (flag) {
            System.out.println("不存在，没有找到");
        }
        //根据书名删除
        for (Book book : hs) {
            if (book.getName().equals("c")) {
                hs.remove(book);
                break;
            }
        }
        System.out.println(hs);
        //迭代器
        Iterator<Book> it = hs.iterator();
        while (it.hasNext()) {
            Book temp = it.next();
            if (temp.getName().equals("a")) {
                it.remove();
            }
        }
        System.out.println(hs);
    }

}
运行结果：
[d:10.0, b:10.0, c:10.0, a:10.0]
d:10.0
b:10.0
c:10.0
a:10.0
存在，找到了
[d:10.0, b:10.0, a:10.0]
[d:10.0, b:10.0]
各种遍历：
package zz.itheima.set;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class Demo2 {

    public static void main(String[] args) {
        //把之前的图书管理程序中的遍历改为迭代器实现
        List<Book> hs = new ArrayList<>();
        hs.add(new Book("a", 10.0));
        hs.add(new Book("b", 11.0));
        hs.add(new Book("c", 12.0));
        hs.add(new Book("d", 13.0));
        //一般的for
        for (int i = 0; i < hs.size(); i++) {
            Book temp = hs.get(i);
            System.out.println(temp);
        }
        System.out.println("**************");
        //foreach
        for (Book book : hs) {
            System.out.println(book);
        }
        System.out.println("*********************");
        //迭代器
        Iterator<Book> it = hs.iterator();
        while (it.hasNext()) {
            Book temp = it.next();
            System.out.println(temp);
        }
        System.out.println("&&&&&&&&&&&&&&&&&&");
        ListIterator<Book> lt = hs.listIterator();
        while (lt.hasNext()) {
            Book temp = lt.next();
            System.out.println(temp);
        }
        System.out.println("^^^^^^^^^^^^^^^^");
        while (lt.hasPrevious()) {
            Book temp = lt.previous();
            System.out.println(temp);
        }
    }

}
运行结果
c:12.0
d:13.0
**************
a:10.0
b:11.0
c:12.0
d:13.0
*********************
a:10.0
b:11.0
c:12.0
d:13.0
&&&&&&&&&&&&&&&&&&
a:10.0
b:11.0
c:12.0
d:13.0
^^^^^^^^^^^^^^^^
d:13.0
c:12.0
b:11.0
a:10.0