Java：Collection集合和Iterator迭代器（10）

 Student类：

package demo21Collection集合;
/*
重写排序规则，需要重写Compareable接口，重写cpmpareTo方法
 */
public class Student implements Comparable<Student>{
    private String name;
    private int 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;
    }

    public Student() {
    }

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

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

    //重写排序规则
    @Override
    public int compareTo(Student o) {
        //自定义比较规则，比较两个人的年龄（this，参数Student）
        //自己（this）-参数：代表升序
        return this.getAge()-o.getAge();//this调用方法的那个人，年龄升序排序
    }
}

Collections工具类的方法：

package demo21Collection集合;

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

/*
java.util.Collections集合工具类，用来对集合进行操作，部分方法如下：
 -public static <T> boolean addAll(Collection<T> c, T..elements):往集合中添加一些元素
 -public static void shuffle(List<?> list>):打乱顺序
 -public static <T> void sort(List<T> list):将集合中的元素按照默认规则排序 只能传list集合

 -sort(List<T> list):要想按照默认的排序规则，必须需要重写Compareable接口，重写cpmpareTo方法
   自己（this）-参数：代表升序
 -public static <T> void sort(List<T> list,Compatator<? super T>)
 Comparator的排序规则：
  o1-o2:升序
 */
public class Collections工具类的方法 {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        //往集合中添加多个元素
        list.add("a");
        list.add("b");
        list.add("c");
        //如果存放的元素很多，我们就可以通过集合工具类addAll()往集合中一次性添加多个元素
        //-public static <T> boolean addAll(Collection<T> c, T..elements):往集合中添加一些元素
        Collections.addAll(list,"d","e","f","g","h");
        System.out.println(list);
        // -public static void shuffle(List<?> list>):打乱顺序
        Collections.shuffle(list);
        System.out.println(list);//[g, a, e, h, d, f, b, c],每次执行不一样
        System.out.println("====================");

        ArrayList<Integer> list01=new ArrayList<>();
        list01.add(1);
        list01.add(3);
        list01.add(2);
        System.out.println(list01);
       // -public static <T> void sort(List<T> list):将集合中的元素按照默认规则排序 只能传list集合  默认是升序
        Collections.sort(list01);//[1, 3, 2]
        System.out.println(list01);//[1, 2, 3]

        ArrayList<String> list02=new ArrayList<>();
        list02.add("a");
        list02.add("c");
        list02.add("b");
        System.out.println(list02);//[a, c, b]
        Collections.sort(list02);
        System.out.println(list02);//[a, b, c]

        //sort参数是自定义类型，必须重写方法compleTo
        ArrayList<Student> list03=new ArrayList<>();
        list03.add(new Student("张三",18));
        list03.add(new Student("李四",20));
        list03.add(new Student("王五",15));
        System.out.println(list03);//[Student{name='张三', age=18}, Student{name='李四', age=20}, Student{name='王五', age=15}]
        Collections.sort(list03);
        System.out.println(list03);//[Student{name='王五', age=15}, Student{name='张三', age=18}, Student{name='李四', age=20}]

        System.out.println("====================");
        ArrayList<Integer> list04=new ArrayList<>();
        list04.add(1);
        list04.add(3);
        list04.add(2);
        System.out.println(list04);
        Collections.sort(list04, new Comparator<Integer>() {//Comparator接口，传递接口的匿名内部类
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;//升序排序
            }
        });
        System.out.println(list04);

    }
}

 Test01类：

package demo21Collection集合;

import java.util.ArrayList;
import java.util.Collection;

/*
java.util.Collection接口所有单列集合的最顶层接口，定义了所有单列集合共性方法
任意的单列集合都可以使用Collecton接口中的方法

共性方法：
boolean add(E e) 向集合中添加元素
boolean remove(E e) 删除集合中的某个元素
void clear() 清空集合所有的元素
boolean contains(E e) 判断集合是否包含某个元素
boolean isEmpty() 判断集合是否为空,有没有内容
int size() 获取集合的长度
Object[] toArray() 将集合转成一个数组
 */
public class Test01 {
    public static void main(String[] args) {
        //创建集合对象
        Collection<String> coll=new ArrayList<>();
        System.out.println(coll);//[] 重写了toString方法
        //boolean add(E e) 向集合中添加元素
        coll.add("hello");
        coll.add("world");
        coll.add("heima");
        coll.add("java");
        System.out.println(coll);//[hello, world, heima, java]
       // boolean remove(E e) 删除集合中的某个元素
        boolean result=coll.remove("hello");
        System.out.println(result);//true
        System.out.println(coll);//[world, heima, java]
        //void clear() 清空集合所有的元素
       // coll.clear();
       // System.out.println(coll);//[]

        //boolean contains(E e) 判断集合是否包含某个元素
        boolean result1=coll.contains("java");
        System.out.println(result1);//true

        //boolean isEmpty() 判断集合是否为空
        System.out.println(coll.isEmpty());//false

        //int size() 获取集合的长度
        System.out.println(coll.size());//3

        //Object[] toArray() 将集合转成一个数组
        Object[] arr=coll.toArray();
        for (int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}

 DemoIterator类：

package demo22Iterator迭代器;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/*
public E next() 返回迭代的下一个元素
public bollean hasNext()  如果有元素可以迭代，返回true

Itrrator迭代器，是一个接口，我们无法直接使用，需要使用Iterator接口的实现类对象，获取实现类的方式比较特殊
Collection接口中有一个方法，叫iterator(),这个方法返回的就是迭代器的实现类对象
  Iterator<E> iterator() 返回在collection的元素上进行迭代的迭代器

 使用步骤：
 1.使用集合中的方法iterator方法iterator() 获取迭代器的实现类对象，使用Iterator接口接收（多态）
 2.使用Iterator接口中的方法hasNest()方法，判断有没有下一个元素
 3.使用Iterator接口中的方法next()方法，取出集合中的写一个元素
 */
public class DemoIterator {
    public static void main(String[] args) {
        //创建一个集合对象
        Collection<String> coll=new ArrayList<>();
        //往集合中添加元素
        coll.add("姚明");
        coll.add("科比");
        coll.add("麦迪");
        coll.add("詹姆斯");

        /*
        1.使用集合中的方法iterator方法iterator() 获取迭代器的实现类对象，使用Iterator接口接收（多态）
             Iterator<E> 接口也是有泛型的，迭代器的泛型看集合是什么泛型，迭代器就是什么泛型
         */
        //多态 （接口）       实现类
        Iterator<String> it=coll.iterator();
        // 2.使用Iterator接口中的方法hasNest()方法，判断有没有下一个元素
        Boolean b=it.hasNext();
        System.out.println(b);
        //3.使用Iterator接口中的方法next()方法，取出集合中的写一个元素
        String s=it.next();//true
        System.out.println(s);//姚明
        s=it.next();//true
        System.out.println(s);//科比
        //往下去当没有元素，在.next取元素会报异常

        /*
        当不知道集合有多少元素，使用while循环 结束条件：hasNext方法返回false
         */
        System.out.println("================");
        while(it.hasNext()){
            String e=it.next();
            System.out.println(e);
        }
        System.out.println("-------------------------");
        //for循环迭代
        for (Iterator<String> it2=coll.iterator();it2.hasNext();){//hasNext判断是否有下一个元素，即查看有没有有元素，又会把指针下移一位
            String e=it2.next();
            System.out.println(e);
        }
    }
}

Foreach类：

package demo22Iterator迭代器;

import java.util.ArrayList;

/*
增强for循环也称for each循环是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的，它的内部原理是一个迭代器，
所以在遍历的过程中，不能对集合中的元素进行增删操作

JDK1.5之后出现的新特性，Collectioo<E>extends Iterable<E>:所有的单列集合都可以使用增强for
public interface Iterable<T>实现这个接口允许对象成为foreach语句目标
增强for循环：用来遍历集合和数组
格式：
for(集合/数组的数据类型 变量名：集合名/数组名){

}
 */
public class Foreach {
    public static void main(String[] args) {
        //demo();
        demo01();
    }
    //增强for循环遍历集合
    private static void demo01(){
        ArrayList<String> list=new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        for (String s:list){
            System.out.println(s);
        }

    }
    //增强for循环遍历数组
    private static void demo(){
        int[] arr={1,2,3,4,5};
        for (int i:arr){
            System.out.println(i);
        }
    }
}