Java---Collection讲解（二）

---

1. 列表迭代器

?1. ListIterator：列表迭代器。通过List集合的listIterator()方法得到的，所以说它是List集合特有的迭代器。

?2. ListIterator中的常用方法：

• E next()：返回迭代中的下一个元素。
• boolean hasNext()：如果迭代具有更多元素，则返回true。
• E previous()：返回列表的上一个元素。
• boolean hasPrevious()：如果此列表迭代器在相反方向遍历元素时具有更多元素，则返回true。
• void add(E e)：将指定的元素插入列表。

import java.util.*;

public class Demo {
    public static void main(String[] args) {
        List<String> list=new ArrayList<String>();
        list.add("hello");
        list.add("world");
        list.add("Java");
        ListIterator<String> lit = list.listIterator();
        while(lit.hasNext()){
            System.out.println(lit.next());//hello world Java
        }
        while (lit.hasPrevious()){
            System.out.println(lit.previous());//Java world hello
        }
        while(lit.hasNext()){
            String s=lit.next();
            if(s.equals("world")){
                lit.add("Javaee");//通过迭代器添加元素
            }
        }
        System.out.println(list);//输出：[hello, world, Javaee, Java]
    }
}

2. 增强for循环

?1. 增强for：简化数组和Collection集合的遍历。

?2. 格式如下：

import java.util.*;

public class Demo {
    public static void main(String[] args) {
        List<String> list=new ArrayList<String>();
        list.add("hello");
        list.add("world");
        list.add("Java");
        ListIterator<String> lit = list.listIterator();
        for(String s:list){
            System.out.println(s); //hello world Java
        }
    }
}

3. 小案例分析

import java.util.*;

public class Demo {
    public static void main(String[] args) {
        List<Student> list=new ArrayList<Student>();
        Student s1=new Student("张三",18);
        Student s2=new Student("李四",19);
        Student s3=new Student("王五",20);

        list.add(s1);
        list.add(s2);
        list.add(s3);
        Iterator<Student> it = list.iterator();
        while(it.hasNext()){
            Student s=it.next();
            System.out.println(s.getName()+" "+s.getAge()+"岁");
        }
        System.out.println("------");
        for(int i=0;i<list.size();i++){
            Student s=list.get(i);
            System.out.println(s.getName()+" "+s.getAge()+"岁");
        }
        System.out.println("------");
        for(Student s:list){
            System.out.println(s.getName()+" "+s.getAge()+"岁"); //hello world Java
        }
    }
}

4. List集合子类的特点

?1. List集合的常用子类：ArrayList、LinkedList。

• 数据结构：ArrayList基于动态数组的数据结构，而LinkedList则基于链表的数据结构。
• 内存空间：ArrayList在内存中开辟的是一块连续的空间，而LinkedList则是不连续的，通过指针来进行数据的访问。
• 访问方式：在随机访问（get和set操作）的情况下，ArrayList速度要优于LinkedList，因为LinkedList要移动指针从前往后依次查找，增加了时间复杂度。而在增加和删除（add和remove操作）数据时，LinkedList的效率更高，因为ArrayList增删数据会影响操作点之后所有数据的下标索引，需要进行数据的移动。

import java.util.*;

public class Demo {
    public static void main(String[] args) {
        //同理LinkedList
        ArrayList<Student> list=new ArrayList<Student>();//
        Student s1=new Student("张三",18);
        Student s2=new Student("李四",19);
        Student s3=new Student("王五",20);

        list.add(s1);
        list.add(s2);
        list.add(s3);

        for(Student s:list){
            System.out.println(s.getName()+" "+s.getAge()+"岁"); //hello world Java
        }
    }
}

5. LinkedList集合特有的功能

方法名	说明
public void addFirst(E e)	在该列表的开头插入指定元素
public void addLast(E e)	将指定的元素追加到该列表的末尾
public E getFirst()	返回此列表的第一个元素
public E getLast()	返回此列表的最后一个元素
public E removeFirst()	返回此列表中删除并返回的第一个元素
public E removeLast()	返回此列表中删除并返回的最后一个元素

import java.util.*;

public class Demo {
    public static void main(String[] args) {
        LinkedList<String> l=new LinkedList<String>();
        l.add("hello");
        l.add("Java");
        l.add("难学");
        l.addFirst("1");
        System.out.println(l); //[1, hello, Java, 难学]

        l.addLast("2");
        System.out.println(l);

        System.out.println(l.getFirst()); //1
        System.out.println(l.getLast()); //2

        l.removeFirst();
        l.removeLast();
        System.out.println(l);//[hello, Java, 难学]
    }
}

6. Set集合的概述与特点

?1. Set集合特点：(1) 不包含重复元素的集合。 (2) 没有带索引的方法，所以不能使用普通的for循环遍历。

?2. Set是接口，有具体类实现。

import java.util.*;

public class Demo {
    public static void main(String[] args) {
        Set<String> l=new HashSet<String>();
        l.add("hello");
        l.add("Java");
        l.add("难学");
        l.add("难学");
        System.out.println(l);//[Java, 难学, hello]
        for (String s:l){
            System.out.println(s);//Java、难学、hello
        }
    }
}

7. 哈希值

?1. 哈希值：是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值。

?2. Object类中有一个方法可以获取对象的哈希值：public int hashCode()。

?3. 对象的哈希值特点：(1) 同一个对象多次调用hashCode()方法返回的哈希值是相同的。 (2) 默认情况下，不同对象的哈希值是不同的；但是重写hashCode()方法可以实现让不同对象的哈希值相同。

public class Demo {
    public static void main(String[] args) {
        System.out.println("hello".hashCode());//99162322
        System.out.println("world".hashCode());//113318802
        System.out.println("hello".hashCode());//99162322
    }
}

8. HashSet集合概述和特点

?1. HashSet集合特点：(1) 底层数据结构是哈希表。 (2) 对集合迭代的顺序不做保证。 (3) 没有带索引的方法，所以不能使用普通的for循环遍历。 (4) 由于实现Set接口，所以是不包含重复元素的集合。

?2. HashSet集合练习：

import java.util.*;

public class Demo {
    public static void main(String[] args) {
        HashSet<String> hs=new HashSet<String>();
        hs.add("hello");
        hs.add("Java");
        hs.add("难学");
        hs.add("Java");
        System.out.println(hs);//[Java, 难学, hello]
        for(String s:hs){
            System.out.println(s);//Java、难学、hello
        }
    }
}

9. 小案例分析

public class Student {
    private String name;
    private int age;
    public Student(){}
    public Student(String name,int age){
        this.name=name;
        this.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;
    }
}

public class Demo {
    public static void main(String[] args) {
        HashSet<Student> hs=new HashSet<Student>();
        Student s1=new Student("张三",18);
        Student s2=new Student("李四",19);
        Student s3=new Student("王五",20);
        Student s4=new Student("王五",20);
        hs.add(s1);
        hs.add(s2);
        hs.add(s3);
        hs.add(s4);
        for(Student s:hs){
            System.out.println(s.getName()+" "+s.getAge()+"岁");
            //李四 19岁
            //张三 18岁
            //王五 20岁
            //王五 20岁
        }
    }
}

import java.util.Objects;

public class Student {
    private String name;
    private int age;
    public Student(){}
    public Student(String name,int age){
        this.name=name;
        this.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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

import java.util.*;

public class Demo {
    public static void main(String[] args) {
        HashSet<Student> hs=new HashSet<Student>();
        Student s1=new Student("张三",18);
        Student s2=new Student("李四",19);
        Student s3=new Student("王五",20);
        Student s4=new Student("王五",20);
        hs.add(s1);
        hs.add(s2);
        hs.add(s3);
        hs.add(s4);
        for(Student s:hs){
            System.out.println(s.getName()+" "+s.getAge()+"岁");
            //李四 19岁
            //张三 18岁
            //王五 20岁
        }
    }
}

10. LinkedHashSet集合的概述和特点

?1. LinkedHashSet集合特点：(1) 哈希表和链表实现的Set接口，具有可预测的迭代顺序。 (2) 由链表保证元素有序，也就是说元素的存储和取出顺序一致。 (3) 由哈希表保证元素唯一，也就是说没有重复的元素。

?2. LinkedHashSet集合练习：

import java.util.*;

public class Demo {
    public static void main(String[] args) {
        LinkedHashSet<String> lhs=new LinkedHashSet<String>();
        lhs.add("s1");
        lhs.add("s2");
        lhs.add("s3");
        lhs.add("s2");
        System.out.println(lhs);//[s1, s2, s3]
    }
}

11. TreeSet集合的概述和特点

?1. TreeSet集合特点：(1) 元素有序。① 可以用TreeSet()：根据其元素的自然排序进行排序。 ② TreeSet(Comparator comparator)：根据指定的比较器进行排序。 (2) 没有带索引的方法，所以不能使用普通的for循环遍历。 (3) 不包含重复元素。

?2. TreeSet集合练习：

import java.util.*;
public class Demo {
    public static void main(String[] args) {
        //所有基本类型存储时，一定要用包装类型
        TreeSet<Integer> t=new TreeSet<Integer>();
        t.add(10);
        t.add(30);
        t.add(40);
        t.add(20);
        t.add(10);
        System.out.println(t);//[10, 20, 30, 40]
    }
}

12. 自然排序Comparable的使用

public class Student implements Comparable<Student> {
    private String name;
    private int age;
    public Student(){}
    public Student(String name,int age){
        this.name=name;
        this.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(Student s) {
        //return 0; //只返回张三 18岁
        //return 1; //整个的正序
        //return -1; //整个的逆序

        //按照年龄升序排列
        int num=this.age-s.age;

        int num2=num ==0?this.name.compareTo(s.name):num;
        return num2;
    }
}

import java.util.*;
public class Demo {
    public static void main(String[] args) {
        TreeSet<Student> t=new TreeSet<Student>();
        Student s1=new Student("张三",18);
        Student s2=new Student("李四",20);
        Student s3=new Student("王五",17);
        Student s4=new Student("赵六",18);

        t.add(s1);
        t.add(s2);
        t.add(s3);
        t.add(s4);
        for(Student s:t){
            System.out.println(s.getName()+" "+s.getAge()+"岁");
        }
    }
}
//王五 17岁
//张三 18岁
//赵六 18岁
//李四 20岁

?结论：(1) 用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的。 (2) 自然排序，就是让元素所属的类实现Comparable接口，重写compareTo(T o)方法。 (3) 重写方法时一定要注意排序规则，必须按照要求的主要条件和次要条件来写。

13. 比较器排序Comparator的使用

public class Student  {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.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;
    }
}

import java.util.*;
public class Demo {
    public static void main(String[] args) {   //匿名内部类
        TreeSet<Student> t=new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int num= s1.getAge()-s2.getAge();
                int num2=num==0 ? s1.getName().compareTo(s2.getName()):num;
                return num2;
            }
        });
        Student s1=new Student("张三",18);
        Student s2=new Student("李四",20);
        Student s3=new Student("王五",17);
        Student s4=new Student("赵六",18);

        t.add(s1);
        t.add(s2);
        t.add(s3);
        t.add(s4);
        for(Student s:t){
            System.out.println(s.getName()+" "+s.getAge()+"岁");
        }
    }
}

14. 小案例分析

public class Student  {
    private String name;
    private int chinese;
    private int math;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getChinese() {
        return chinese;
    }

    public void setChinese(int chinese) {
        this.chinese = chinese;
    }

    public int getMath() {
        return math;
    }

    public void setMath(int math) {
        this.math = math;
    }

    public int getSum(){
        return this.chinese+this.math;
    }
}

public class Demo {
    public static void main(String[] args) {
        TreeSet<Student> t=new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int num= s1.getSum()-s2.getSum();
                int num2=num==0?s1.getChinese()-s2.getChinese():num;
                int num3=num2==0?s1.getName().compareTo(s2.getName()):num2;
                return num3;
            }
        });
        Student s1=new Student("张三",94,96);
        Student s2=new Student("李四",95,92);
        Student s3=new Student("王五",90,100);
        Student s4=new Student("赵六",87,99);
        Student s5=new Student("七七",88,99);
        Student s6=new Student("八八",88,99);

        t.add(s1);
        t.add(s2);
        t.add(s3);
        t.add(s4);
        t.add(s5);
        t.add(s6);
        for(Student s:t){
            System.out.println(s.getName()+" 语文:"+s.getChinese()+" 数学:"+s.getMath()+" 总分:"+s.getSum());
        }
    }
}

15. 小案例分析

import java.util.*;
public class Demo {
    public static void main(String[] args) {
       //Set<Integer> s=new HashSet<Integer>();//输出结果无序
        Set<Integer> s=new TreeSet<Integer>(); //输出结果有序
        Random r=new Random();//随机数对象
        while(s.size()<10){
            int number=r.nextInt(20)+1; //[0,20)+1
            s.add(number);
        }
        for(int i:s){
            System.out.println(i);
        }
    }
}