javaSE（11）（集合迭代器与比较器）

迭代器接口：
package zz.itheima.comparator;

public interface Iterator {
    public boolean hasNext();
    public int next();
}
package zz.itheima.comparator;

public interface Interable {
    public Iterator iterator();
}
ArrList类：
package zz.itheima.comparator;

public class ArrList {
    //此类就当成ArrayList
    private int[] num;
    private int index;
    public ArrList() {
        num = new int[10];
        index = 0;
    }
    public void add(int o){
        for (int i = 0; i < num.length; i++) {
            if (num[i]==0) {//数组的默认值为0；
                num[i] = o;
                break;
            }
        }
    }
    public int get(int index){
        return num[index];
    }
    public int size(){
        return num.length;
    }
    public Iterator iterator(){
        return new Iterator0();
    }
    class Iterator0 implements Iterator{

        @Override
        public boolean hasNext() {
            if (index<num.length) {
                return true;
            }else {
                return false;
            }
        }
        @Override
        public int next() {
            return num[index++];
        }

    }
}
TestArrList ：
package zz.itheima.comparator;


public class TestArrList {

    public static void main(String[] args) {
        ArrList al = new ArrList();
        al.add(10);
        al.add(18);
        System.out.println(al.get(0));
        for (int i = 0; i < al.size(); i++) {
            System.out.println(al.get(i));
        }
        System.out.println("**************************");
        Iterator it = al.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }
}
运行结果：
10
10
18
0
0
0
0
0
0
0
0
**************************
10
18
0
0
0
0
0
0
0
0

beans类：
package zz.itheima.comparator;

public class Book implements Comparable<Book>{
    private String name;
    private int price;
    public Book(String name, int price) {
        super();
        this.name = name;
        this.price = price;
    }
    public Book() {
        super();
        // TODO Auto-generated constructor stub
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getPrice() {
        return price;
    }
    public void setPrice(int price) {
        this.price = price;
    }
    @Override
    public String toString() {
        return "Book [name=" + name + ", price=" + price + "]";
    }
    //此方法必须从写
    @Override
    public int compareTo(Book o) {
        int res = this.getName().compareTo(o.getName());
        if (res==0) {//名字相等
            return this.getPrice()-o.getPrice();//名字相等的话比较价格
        }else {
            return res;//名字不相等话就直接返回int型数字，正数是大于，负数是小于
        }
    }

}
package zz.itheima.comparator;

public class Stu implements Comparable<Stu> {
    private String name;
    private int age;
    public Stu(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Stu() {
        super();
        // TODO Auto-generated constructor stub
    }
    @Override
    public String toString() {
        return "Stu [name=" + name + ", 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(Stu o) {
// int res = this.getName().compareTo(o.getName());
// if (res==0) {//名字相等的情况下比较年龄
// return this.getAge() - o.getAge();
// }else {
// return res;
// }
        int res=this.age-o.getAge();
        if(res==0)
        {
            return this.name.compareTo(o.getName());
        }
        else {
            return res;
        }
    }
}
TestStu类：
package zz.itheima.comparator;

import java.util.TreeSet;

public class TestStu {

    public static void main(String[] args) {
        TreeSet<Stu> hs = new TreeSet<Stu>();
        hs.add(new Stu("张一", 80));
        hs.add(new Stu("张三", 10));
        hs.add(new Stu("李四", 16));
        System.out.println(hs);
    }

}
运行结果：
[Stu [name=张三, age=10], Stu [name=李四, age=16], Stu [name=张一, age=80]]
TestSort类：
package zz.itheima.comparator;

import java.util.Arrays;

public class TestSort {

    public static void main(String[] args) {
        // 回顾一下Arrays.sort()方法的作用，并思考一下如果数组存储的是自定义类型的数据，会怎么排序？
        String[] str = {"bcd","aca","abc"}; 
        Arrays.sort(str);
        for (int i = 0; i < str.length; i++) {
            System.out.println(str[i]);
        }
        System.out.println("**********************");
        //如果数组存储的是自定的类型的数据
        Book[] book = new Book[3];
        book[0] = new Book("b", 2);
        book[1]=new Book("c", 3);
        book[2]=new Book("a", 1);
        Arrays.sort(book);
        for (int i = 0; i < book.length; i++) {
            System.out.println(book[i]);
        }

    }

}
运行结果：
abc
aca
bcd
**********************
Book [name=a, price=1]
Book [name=b, price=2]
Book [name=c, price=3]
泛型：
package zz.itheima.comparator;

import java.util.ArrayList;

public class GenericType<T>{
    private T o;
    public void setO(T o){
        this.o = o;
    }
    public T geto(){
        return o;
    }
    GenericType<Book> fx = new GenericType<Book>();
    ArrayList<Book> al = new ArrayList<Book>();
}
BookComparator1类：
package zz.itheima.comparator;

import java.util.Comparator;

//自定义了一个专门用于图书类的比较器(第一种算法)
public class BookComparator1 implements Comparator<Book> {

    @Override
    public int compare(Book o1, Book o2) {
        int res = o1.getName().compareTo(o2.getName());
        if (res==0) {
            return o1.getPrice() - o2.getPrice();
        }else {
            return res;
        }
    }
}
BookComparator2类：
package zz.itheima.comparator;

import java.util.Comparator;
//自定义了一个专门用于图书类的比较器(第二种算法)
public class BookComparator2 implements Comparator<Book>{

    @Override
    public int compare(Book o1, Book o2) {
        int res = o1.getPrice() - o2.getPrice();
        if (res==0) {
            return o1.getName().compareTo(o2.getName());
        }else {
            return res;
        }

    }
}
TestComparator类：
package zz.itheima.comparator;

import java.util.TreeSet;

public class TestComparator {

    public static void main(String[] args) {
        /*自定义图书类不实现任何接口 创建一个该接口的实现类实现排序算法(按书名) 在一个TreeSet(有参构造)中存储几个图书对象，并输出该TreeSet进行测试 如果书名一样，价格不同，会怎样？*/


        /*java.util.Comparator接口 int compare(T o1,T o2) 自定义一个类实现该接口并重写该方法实现排序算法 TreeSet类有一个public TreeSet(Comparator<T> comp)构造方法可以指定排序算法类*/
        TreeSet<Book> ts=new TreeSet<Book>(new BookComparator2());
        ts.add(new Book("abc", 10));
        ts.add(new Book("aa", 1));
        ts.add(new Book("aa", 10));
        System.out.println(ts);
    }

}
运行结果：
[Book [name=aa, price=1], Book [name=aa, price=10], Book [name=abc, price=10]]
TestBinarySerach类：
package zz.itheima.comparator;

import java.util.ArrayList;
import java.util.Collections;

public class TestBinarySerach {

    public static void main(String[] args) {
        ArrayList<Book> al2=new ArrayList<Book>();
        al2.add(new Book("accc", 21));
        al2.add(new Book("aaa", 10));
        al2.add(new Book("abc", 11));
        al2.add(new Book("ddd", 12));
        al2.add(new Book("eee", 13));
        Collections.sort(al2, new BookComparator2());
        System.out.println(al2);
        System.out.println("*********************");
        int res = Collections.binarySearch(al2,new Book("accc", 21), new BookComparator2());
        System.out.println(res);
    }

}
运行结果：
[Book [name=aaa, price=10], Book [name=abc, price=11], Book [name=ddd, price=12], Book [name=eee, price=13], Book [name=accc, price=21]]
*********************
4
TestCollections类：
package zz.itheima.comparator;

import java.util.ArrayList;
import java.util.Collections;

public class TestCollections {

    public static void main(String[] args) {
// public static <T> int binarySearch(List list, T key)
        ArrayList<String> al1 = new ArrayList();
        al1.add("aaa");al1.add("bbb");al1.add("ccc");
        String key = "bbdfg";
        int res1 = Collections.binarySearch(al1, key);
        System.out.println(res1);
        System.out.println("******************");
// public static <T> int binarySearch(List list, T key, Comparator c)
        ArrayList<Book> al2=new ArrayList<Book>();
        al2.add(new Book("accc", 12));
        al2.add(new Book("aaa", 10));
        al2.add(new Book("bbb", 11));
        al2.add(new Book("ddd", 11));
        al2.add(new Book("eee", 11));
        System.out.println(al2);
        Collections.sort(al2,new BookComparator2());
        int res2=Collections.binarySearch(al2, new Book("accc", 12),new BookComparator2());
        System.out.println(res2);
        System.out.println("**************************");
// public static <T > T max(Collection<T> coll)
        ArrayList<String> al3=new ArrayList<String>();
        al3.add("aaa");
        al3.add("abc");
        al3.add("cdf");
        al3.add("add");
        System.out.println(Collections.max(al3));
        System.out.println("*********************");

// public static <T> T max(Collection<T> coll, Comparator<T> comp)
        ArrayList<Book> al4=new ArrayList<Book>();
        al4.add(new Book("ccc", 10));
        al4.add(new Book("aaa", 12));
        al4.add(new Book("bbb", 11));
        System.out.println(Collections.max(al4, new BookComparator2()));
        System.out.println("*******************");

// public static <T> T min(Collection<T> coll)
// public static <T> T min(Collection<T> coll, Comparator<T> comp)
// public static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)
        ArrayList<String> al5=new ArrayList<String>();
        al5.add("aaa");
        al5.add("abc");
        al5.add("cdf");
        al5.add("abc");
        al5.add("add");
        al5.add("abc");

        //Collections.replaceAll(al5, "abc", "hello");
        System.out.println(al5);

// public static void reverse(List<T> list)
        Collections.reverse(al5);
        System.out.println(al5);

// public static <T> void sort(List<T> list)
        Collections.sort(al5);
        System.out.println(al5);

// public static <T> void sort(List<T> list, Comparator<T> c)
        Collections.sort(al4, new BookComparator2());
        System.out.println(al4);

// public static void shuffle(List<?> list)
        Collections.shuffle(al5);
        System.out.println(al5);//重新洗牌
    }

}
运行结果：
-3
******************
[Book [name=accc, price=12], Book [name=aaa, price=10], Book [name=bbb, price=11], Book [name=ddd, price=11], Book [name=eee, price=11]]
4
**************************
cdf
*********************
Book [name=aaa, price=12]
*******************
[aaa, abc, cdf, abc, add, abc]
[abc, add, abc, cdf, abc, aaa]
[aaa, abc, abc, abc, add, cdf]
[Book [name=ccc, price=10], Book [name=bbb, price=11], Book [name=aaa, price=12]]
[cdf, abc, aaa, abc, add, abc]