Java进阶_集合

集合

一、集合的概念

1、什么是集合

  • 概念:对象的容器，定义了对多个对象进行操作的常用方法。可实现数组的功能。
  • 和数组区别:
    • （1）数组长度固定，集合长度不固定
    • （2）数组可以存储基本类型和引用类型，集合只能引用类型
  • 位置: java. util. *;

2、Collection体系集合

3、Collection父接口

Collection接口

  • 特点:代表一组任意类型的对象，无序、无下标、不能重复。、
  • 方法：
    • boolean?add(0bject?obj) //添加一个对象。
    • boolean?addAll (Collection?c) //将 一个集合中的所有对象添加到此集合中。
    • void?clear() //清空此集合中的所有对象。
    • boolean?contains (Object?o) //检查此集合中是否包含o对象
    • boolean?equals (0bject?o) //比较此集合是否与指定对象相等。
    • boolean?isEmpty() //判断此集合是否为空
    • boolean?remove (Object?o) //在 此集合中移除o对象
    • int?size() //返回此集合中的元素个数。
    • 0bject[]?toArray() //将此集合转换成数组。

二、Collection接口

Collection的使用一：

package com.mike.test;

/*
        collection接口的使用
        (1)添加元素
        (2)删除元素
        (3)遍历元素
        (4)判断
 */


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


public class Test {
    public static void main(String[] args){
        //创建集合
        //ArrayList     有序，有下标，可重复
        Collection collection = new ArrayList();
//        (1)添加元素
        collection.add("苹果");
        collection.add("西瓜");
        collection.add("香蕉");
        collection.add("青枣");
        collection.add("鸭梨");
        collection.add("火龙果");
        System.out.println("元素个数："+collection.size());
        System.out.println(collection);
//        (2)删除元素
        collection.remove("鸭梨");
        System.out.println("-------------------------------");
        System.out.println("元素个数："+collection.size());
        System.out.println(collection);
//        (3)遍历元素【重点】
        //3.1、使用增强的for（好处是不需要知道下标）
        System.out.println("-----第一种遍历方式，增强for-----");
        for (Object object : collection) {
            System.out.println(object);
        }
        //3.2、使用迭代器（迭代器是专门用来遍历集合的一种方式）
        //迭代过程不能使用集合的删除方法，否则会出现并发修改异常
        System.out.println("-----第二种遍历方式，使用迭代器-----");
        //hasNext();有没有下一个元素，
        //next();获取下一个元素
        //remove();删除当前元素
        Iterator it = collection.iterator();
        while (it.hasNext()){
            String s = (String) it.next();
            System.out.println(s);
        }
//        (4)判断
        System.out.println("----------------------------");
        System.out.println("是否有西瓜："+collection.contains("西瓜"));
        System.out.println("集合是否为空："+collection.isEmpty());
    }
}
            /*输出结果
            元素个数：6
            [苹果, 西瓜, 香蕉, 青枣, 鸭梨, 火龙果]
            -------------------------------
            元素个数：5
            [苹果, 西瓜, 香蕉, 青枣, 火龙果]
            -----第一种遍历方式，增强for-----
            苹果
            西瓜
            香蕉
            青枣
            火龙果
            -----第二种遍历方式，使用迭代器-----
            苹果
            西瓜
            香蕉
            青枣
            火龙果
            ----------------------------
            是否有西瓜：true
            集合是否为空：false
            */

Collection的使用二：

集合存对象

Student类

package com.mike.test;

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 String toString() {
        return "Student{" + "name=" + name + ", age=" + age + '}';
    }

    @Override
    public boolean equals(Object obj) {
        //1.是不是同一个对象
        if (this==obj){
            return true;
        }
        //2.是不是为空
        if (obj==null){
            return false;
        }
        //3.判断是否是Student类型
        if (obj instanceof Student){
            Student s =(Student) obj;
            //4.比较属性
            if (this.name.equals(s.getName())&&this.age==s.getAge()){
                return true;
            }
        }
        //5.不满足条件，返回false
        return false;
    }
}

Test类

package com.mike.test;

/*
        collection的使用：保存学生信息
        (1)添加元素
        (2)删除元素
        (3)遍历元素
        (4)判断
 */


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

public class Test {
    public static void main(String[] args){
        //新建Collection对象
        Collection collection = new ArrayList();
        Student student1 = new Student("唐僧", 19);
        Student student2 = new Student("孙悟空", 20);
        Student student3 = new Student("猪八戒", 20);
        Student student4 = new Student("沙僧", 27);
        Student student5 = new Student("白龙马", 21);
        //1、添加学生信息
        collection.add(student1);
        collection.add(student2);
        collection.add(student3);
        collection.add(student4);
        collection.add(student5);
        System.out.println("元素个数"+collection.size());
        System.out.println(collection.toString());
        //2、删除(这里的删除不是删除学生对象，而是删除学生对象在集合中的地址，new的学生对象还在堆当中)
        collection.remove(student1);
        //collection.clear();//清除集合中的元素
        System.out.println("------------------------------");
        System.out.println("删除之后");
        System.out.println("元素个数"+collection.size());
        System.out.println(collection.toString());
        //3、遍历3.1、增强for
        System.out.println("------------------------------");
        System.out.println("遍历元素增强for");
        for (Object object : collection) {
            Student s = (Student) object;
            System.out.println(s.toString());
        }
        //3、遍历3.2、迭代器
        System.out.println("------------------------------");
        System.out.println("遍历元素迭代器");
        Iterator it = collection.iterator();
        while (it.hasNext()){
            Student s = (Student) it.next();
            System.out.println(s.toString());
        }
        //4、判断
        System.out.println("------------------------------");
        System.out.println("判断元素是否存在");
        System.out.println("student1是否存在："+collection.contains(student1));
        System.out.println("student2是否存在："+collection.contains(student2));

    }
}
          /*输出结果
            元素个数5
            [Student{name=唐僧, age=19}, Student{name=孙悟空, age=20}, Student{name=猪八			戒, age=20}, Student{name=沙僧, age=27}, Student{name=白龙马, age=21}]
            ------------------------------
            删除之后
            元素个数4
            [Student{name=孙悟空, age=20}, Student{name=猪八戒, age=20}, Student{name=沙			僧, age=27}, Student{name=白龙马, age=21}]
            ------------------------------
            遍历元素增强for
            Student{name=孙悟空, age=20}
            Student{name=猪八戒, age=20}
            Student{name=沙僧, age=27}
            Student{name=白龙马, age=21}
            ------------------------------
            遍历元素迭代器
            Student{name=孙悟空, age=20}
            Student{name=猪八戒, age=20}
            Student{name=沙僧, age=27}
            Student{name=白龙马, age=21}
            ------------------------------
            判断元素是否存在
            student1是否存在：false
            student2是否存在：true
            */

三、List接口与实现类

List接口

  • List子接口

    • 特点。有序、有下标、元素可以重复。

    • 方法:

      • void?add(int?index，0bject?o) //在index位置插入对象o。
      • boolean?addAll(int?index，Collection?c) //将一个集合中的元素添加到此集合中的index位置。
      • Object?get(int index) //返回集合中指定位置的元素。
      • List?subList(int?fromIndex，int?toIndex) //返回fromIndex和toIndex之间的集合元素。

案例一：

package com.mike.test;

/*
        List子接口的使用
        1、有序，有下标，可以重复
 */


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

public class Test {
    public static void main(String[] args){
        //先创建集合对象
        List list = new ArrayList();
        //1、添加元素
        list.add("苹果");
        list.add("小米");
        list.add("华为");
        list.add(0,"OPPO");
        System.out.println("元素个数："+list.size());
        System.out.println(list.toString());
        //2、删除元素
        list.remove(0);
        System.out.println("-----------------------------");
        System.out.println("删除之后");
        System.out.println("元素个数："+list.size());
        System.out.println(list.toString());
        //3、遍历
        //3.1、使用for遍历
        System.out.println("---------使用for遍历--------------");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        //3.2、使用增强for
        System.out.println("-----------使用增强for-------------");
        for (Object object : list) {
            System.out.println(object.toString());
        }
        //3.3、使用迭代器
        System.out.println("-----------使用迭代器-------------");
        Iterator it = list.iterator();
        while (it.hasNext())
            System.out.println(it.next());
        //3.4、使用列表迭代器，, 和Iterator的区别，ListIterator可以向前或向后遍历，添加、删除、修改元素
        System.out.println("-----------使用列表迭代器-------------");
        ListIterator lit = list.listIterator();
        System.out.println("使用列表迭代器，从前往后迭代");
        while (lit.hasNext()) {
            System.out.println(lit.nextIndex()+":"+lit.next());
        }
        System.out.println("使用列表迭代器，从从后往前迭代");
        while (lit.hasPrevious()) {
            System.out.println(lit.previousIndex()+":"+lit.previous());
        }
        //4判断
        System.out.println("==================");
        System.out.println(list.contains("苹果"));
        System.out.println(list.isEmpty());

        //5获取位置
        System.out.println("获取华为下角标："+list.indexOf("华为"));


    }
}
          /*输出结果
            元素个数：4
            [OPPO, 苹果, 小米, 华为]
            -----------------------------
            删除之后
            元素个数：3
            [苹果, 小米, 华为]
            ---------使用for遍历--------------
            苹果
            小米
            华为
            -----------使用增强for-------------
            苹果
            小米
            华为
            -----------使用迭代器-------------
            苹果
            小米
            华为
            -----------使用列表迭代器-------------
            使用列表迭代器，从前往后迭代
            0:苹果
            1:小米
            2:华为
            使用列表迭代器，从从后往前迭代
            2:华为
            1:小米
            0:苹果
            ==================
            true
            false
            获取华为下角标：2
            */

案例二：

List集合添加基本数据类型（装箱操作）

package com.mike.test;

/*
        List子接口的使用
        1、有序，有下标，可以重复
 */


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

public class Test {
    public static void main(String[] args){
        //先创建集合对象
        List list = new ArrayList();
        //1、添加数字类型(由于集合不能添加基本数据类型，所以这里隐藏了一个步骤，叫装箱)
        //jdk1.5之后，自动装箱
        list.add(10);
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);
        System.out.println("元素个数："+list.size());
        System.out.println(list.toString());
        //2、删除
        //list.remove(0);//删除下标为0的元素
        list.remove(new Integer(20));//由于20是基本数据类型，所以这里必须转换为Integer类型
        System.out.println("元素个数："+list.size());
        System.out.println(list.toString());

        //3、补充方法subList:()返回子集合,含头不含尾
        List subList = list.subList(1, 3);
        System.out.println(subList.toString());

    }
}
          /*输出结果
            元素个数：5
            [10, 20, 30, 40, 50]
            元素个数：4
            [10, 30, 40, 50]
            [30, 40]
            */

List实现类

  • ArrayList【重点】:

    • 数组结构实现，查询快，增删慢;
    • JDK1. 2版本，运行效率快，线程不安全。

  • Vector:

    • 数组结构实现，查询快，增删慢;
    • JDK1. 0版本，运行效率慢，线程安全。

  • LinkedList:

    • 链表结构实现，增删快，查询慢;

ArrayList的使用

Student类

package com.mike.test;

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 String toString() {
        return "Student{" + "name=" + name + ", age=" + age + '}';
    }

    @Override
    public boolean equals(Object obj) {
        //1.是不是同一个对象
        if (this==obj){
            return true;
        }
        //2.是不是为空
        if (obj==null){
            return false;
        }
        //3.判断是否是Student类型
        if (obj instanceof Student){
            Student s =(Student) obj;
            //4.比较属性
            if (this.name.equals(s.getName())&&this.age==s.getAge()){
                return true;
            }
        }
        //5.不满足条件，返回false
        return false;
    }
}

Test类

package com.mike.test;

/*
        ArrayList的使用
        存储结构:数组，查找遍历速度快，增删慢
 */


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

public class Test {
    public static void main(String[] args){
        //创建集合
        ArrayList arrayList = new ArrayList();
        //1、添加元素
        Student s1 = new Student("刘德华",60);
        Student s2 = new Student("张学友",60);
        Student s3 = new Student("黎明",55);
        Student s4 = new Student("郭富城",56);

        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        arrayList.add(s4);
        arrayList.add(s4);

        System.out.println("元素个数："+arrayList.size());
        System.out.println(arrayList.toString());
        //2、删除元素
        //如果像下面这样写，我们并不能删除"刘德华",20这个数据，非要这样删除，只能重写equals方法
        //比较创建的对象和集合里面是否为同一个对象，如果数据一样，则认为是同一个对象，允许删除
        //arrayList.remove(new Student("刘德华",20));//equals(this==obj)重写equals方法
        arrayList.remove(4);
        System.out.println("元素个数："+arrayList.size());
        System.out.println(arrayList.toString());
        //3、遍历元素【重点】
        //3.1、迭代器
        System.out.println("---------迭代器遍历------------");
        Iterator it = arrayList.iterator();
        while (it.hasNext()){
            Student s = (Student) it.next();
            System.out.println(s.toString());
        }
        System.out.println("---------列表迭代器遍历------------");
        ListIterator lit = arrayList.listIterator();
        System.out.println("列表迭代器，从前往后");
        while (lit.hasNext()) {
            Student s = (Student) lit.next();
            System.out.println(lit.previousIndex()+":"+s.toString());//观察最后结果下标
        }
        System.out.println("列表迭代器，从后往前");
        while (lit.hasPrevious()) {
            Student s = (Student) lit.previous();
            System.out.println(lit.previousIndex()+":"+s.toString());//观察最后结果下标
        }
        //4、判断
        //因为这里的Student类重写了equals方法，所以比较的是内容
        System.out.println(arrayList.contains(new Student("郭富城", 56)));
        System.out.println("集合是否为空"+arrayList.isEmpty());
        //5、查找位置（查找下标）
        System.out.println(arrayList.indexOf(s3));
        System.out.println(arrayList.indexOf(s1));
    }
}
          /*输出结果
元素个数：5
[Student{name=刘德华, age=60}, Student{name=张学友, age=60}, Student{name=黎明, age=55}, Student{name=郭富城, age=56}, Student{name=郭富城, age=56}]
元素个数：4
[Student{name=刘德华, age=60}, Student{name=张学友, age=60}, Student{name=黎明, age=55}, Student{name=郭富城, age=56}]
---------迭代器遍历------------
Student{name=刘德华, age=60}
Student{name=张学友, age=60}
Student{name=黎明, age=55}
Student{name=郭富城, age=56}
---------列表迭代器遍历------------
列表迭代器，从前往后
0:Student{name=刘德华, age=60}
1:Student{name=张学友, age=60}
2:Student{name=黎明, age=55}
3:Student{name=郭富城, age=56}
列表迭代器，从后往前
2:Student{name=郭富城, age=56}
1:Student{name=黎明, age=55}
0:Student{name=张学友, age=60}
-1:Student{name=刘德华, age=60}
true
集合是否为空false
2
0
            */

ArrayList源码分析

  • 默认容量大小：DEFAULT_CAPACITY=10;
    • 注意:如果没有向集合中添加任何元素时，容量为0
    • 添加第一个元素之后容量变成10，后面如果需要再次扩容，那么扩容大小是原来的1.5倍
    • 0-->10-->15~~

存放元素的数组：elementData

Vector的使用

向量集合Vector

package com.mike.test;

/*
       Vector的使用
       存储结构:数组，查找遍历速度快，增删慢
 */


import java.util.Enumeration;
import java.util.Vector;

public class Test {
    public static void main(String[] args){
        //1、创建集合，实例化vector
        Vector vector = new Vector();
        //2、添加元素
        vector.add("草莓");
        vector.add("苹果");
        vector.add("西瓜");
        System.out.println("元素个数："+ vector.size());
        System.out.println(vector.toString());
        //3、删除
//        vector.remove(0);//根据下标移除
//        vector.remove("西瓜");//根据字段移除
//        vector.clear();//将元素从集合中全部移除
        //4、遍历
        //可以使用for，增强for，迭代器，列表迭代器
        //这里我们使用它特有的遍历方式：枚举器(和迭代器功能一模一样，不同名字罢了)
        System.out.println("------枚举器遍历元素------");
        Enumeration en = vector.elements();
        while (en.hasMoreElements()) {
            String o = (String) en.nextElement();
            System.out.println(o);
        }
        //5、判断
        System.out.println("判断是否有西瓜："+vector.contains("西瓜"));
        System.out.println("判断集合是否为空："+vector.isEmpty());
        //6、vector其他方法
        //firstElement、lastElement、elementAt()
    }
}
          /*输出结果
                元素个数：3
                [草莓, 苹果, 西瓜]
                ------枚举器遍历元素------
                草莓
                苹果
                西瓜
                判断是否有西瓜：true
                判断集合是否为空：false
            */

LinkedList的使用

package com.mike.test;

/*
       LinkedList的使用
       存储结构：双向链表
       链表结构实现，增删快，查询慢;
 */



import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;

public class Test {
    public static void main(String[] args){
        //1、创建集合，实例化vector
        LinkedList linkedList = new LinkedList();
        //2、添加元素
        Student s1 = new Student("小明",20);
        Student s2 = new Student("小红",18);
        Student s3 = new Student("小军",19);

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

        System.out.println("元素个数："+linkedList.size());
        System.out.println(linkedList.toString());
        //3、删除元素
//         linkedList.remove(s1);
//         linkedList.clear();//清除集合中所有元素
//        System.out.println("删除对象s1之后元素个数："+ linkedList.size());
//        System.out.println(linkedList.toString());
        //4、遍历
        //4.1使用for遍历
        System.out.println("--------使用for遍历-----------");
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.get(i));
        }
        //4.2使用增强for遍历
        System.out.println("--------使用增强for遍历-----------");
        for (Object o : linkedList) {
            Student s = (Student) o;
            System.out.println(s.toString());
        }
        //4.3使用迭代器遍历
        System.out.println("--------使用迭代器遍历-----------");
        Iterator it = linkedList.iterator();
        while (it.hasNext()) {
            Student s = (Student) it.next();
            System.out.println(s);
        }
        //4.4使用列迭代器
        System.out.println("--------使用列迭代器遍历-----------");
        //从后往前
        ListIterator lit = linkedList.listIterator();
        while (lit.hasNext()) {
            Student s = (Student) lit.next();
            System.out.println(s);
        }
        //5、判断
        System.out.println("判断对象s1是否存在："+linkedList.contains(s1));
        System.out.println("判断元素是否为空："+linkedList.isEmpty());
        //6、获取
        System.out.println("获取s2的下标位置:"+linkedList.indexOf(s2));

    }
}
          /*输出结果
元素个数：3
[Student{name=小明, age=20}, Student{name=小红, age=18}, Student{name=小军, age=19}]
--------使用for遍历-----------
Student{name=小明, age=20}
Student{name=小红, age=18}
Student{name=小军, age=19}
--------使用增强for遍历-----------
Student{name=小明, age=20}
Student{name=小红, age=18}
Student{name=小军, age=19}
--------使用迭代器遍历-----------
Student{name=小明, age=20}
Student{name=小红, age=18}
Student{name=小军, age=19}
--------使用列迭代器遍历-----------
Student{name=小明, age=20}
Student{name=小红, age=18}
Student{name=小军, age=19}
判断对象s1是否存在：true
判断元素是否为空：false
获取s2的下标位置:1
            */

LinkedList源码分析

  • int size：集合的大小
  • Node first;：链表的头节点
  • Node last：链表的尾节点
void linkLast(E e) {
    final Node l = last;
    final Node newNode = new Node<>(l, e, null);
    last = newNode;
    if (l == null)
        first = newNode;
    else
        l.next = newNode;
    size++;
    modCount++;
}

private static class Node {
    E item;
    Node next;
    Node prev;

    Node(Node prev, E element, Node next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

不同结构实现方式

四、泛型和工具类

介绍泛型

  • Java泛型是JDK1.5中引入的一个新特性，其本质是参数化类型，把类型作为参数传递。

  • 常见形式有泛型类、泛型接口、泛型方法。

  • 语法:

    • T称为类型占位符，表示一种引用类型。

  • 好处:

    • (1)提高代码的重用性
    • (2)防止类型转换异常，提高代码的安全性

创建泛型类

案例一：

package com.mike.test;

/*
        泛型类
        语法：类名
        T是类型占位符，表示一种引用类型，如果编写多个，用逗号隔开
 */


public class Test {
    //使用泛型T
    //1、创建变量
    T t;

    //2、作为方法的参数
    public void show(T t){
        System.out.println(t);
    }

    //3、泛型作为方法的返回值
    public T getT(){
        return t;
    }

    public static void main(String[] args){
        //使用泛型类创建对象
        //注意: 1泛型只能使用引用类型，2不同泛型类型对象之间不能相互赋值
        Test test1 = new Test();//jdk1.7之后后面尖括号可写可不写
        test1.t = "hello";
        test1.show("大家好！");
        String t = test1.getT();
        System.out.println(t);

        Test test2 = new Test();
        test2.t = 100;
        test2.show(200);
        Integer t1 = test2.getT();
        System.out.println(t1);
    }
}


          /*输出结果
                大家好！
                hello
                200
                100
            */

泛型接口

MyInterface接口

package com.mike.test;


/*
        泛型接口
        语法：接口名
        注意:不能使用泛型创建静态常量
        T是类型占位符，表示一种引用类型，如果编写多个，用逗号隔开
 */
public interface MyInterface {
    String name = "张三";

    T server(T t);

}

MyInterfaceImpl类

package com.mike.test;

public class MyInterfaceImpl implements MyInterface {
    @Override
    public T server(T t) {
        System.out.println(t);
        return t;
    }
}

MyInterfaceImpl2类

package com.mike.test;

public class MyInterfaceImpl2 implements MyInterface {
    @Override
    public String server(String s) {
        System.out.println(s);
        return s;
    }
}

Test类

package com.mike.test;

/*
        泛型类
        语法：类名
        T是类型占位符，表示一种引用类型，如果编写多个，用逗号隔开
 */


public class Test implements MyInterface {

    public static void main(String[] args) {
        Test test = new Test();
        test.server("你好！中国！");

        MyInterfaceImpl impl = new MyInterfaceImpl<>();
        impl.server(200);

        MyInterfaceImpl2 impl2 = new MyInterfaceImpl2();
        impl2.server("HelloWord");
    }

    @Override
    public String server(String s) {
        System.out.println(s);
        return s;
    }
}
          /*输出结果
                你好！中国！
                200
                HelloWord
            */

泛型方法

MyGenericMethod类

package com.mike.test;
/*
        泛型方法
        语法: 返回值类型
*/
public class MyGenericMethod {
    //泛型方法
    public  T show(T t){
        System.out.println("泛型方法:"+t);
        return t;
    }
}

Test类

package com.mike.test;


public class Test {
    public static void main(String[] args) {
        //泛型方法的调用
        MyGenericMethod myGenericMethod = new MyGenericMethod();
        myGenericMethod.show("中国加油");
        myGenericMethod.show(200);
        myGenericMethod.show(3.14);
    }
}
          /*输出结果
            泛型方法:中国加油
            泛型方法:200
            泛型方法:3.14
            */

泛型集合

  • 概念:参数化类型、类型安全的集合，强制集合元素的类型必须一致。

  • 特点:

    • 编译时即可检查，而非运行时抛出异常。
    • 访问时，不必类型转换(拆箱)。
    • 不同泛型之间引用不能相互赋值，泛型不存在多态。
package com.mike.test;


import java.util.ArrayList;
import java.util.ListIterator;

public class Test {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add("猪八戒");
        arrayList.add("孙悟空");

        for (String s : arrayList) {
            System.out.println(s);
        }

        System.out.println("------------------------------");
        ArrayList studentArrayList = new ArrayList();
        Student student1 = new Student("沙僧", 21);
        Student student2 = new Student("唐僧", 20);

        studentArrayList.add(student1);
        studentArrayList.add(student2);
        System.out.println("列迭代器遍历");
        ListIterator stl = studentArrayList.listIterator();
        while (stl.hasNext()) {
            Student s = stl.next();
            System.out.println(s.toString());
        }
    }
}
          /*输出结果
                猪八戒
                孙悟空
                ------------------------------
                列迭代器遍历
                Student{name=沙僧, age=21}
                Student{name=唐僧, age=20}
            */

五、Set接口与实现类

Set接口

  • 特点:无序、无下标、元素不可重复。
  • 方法:全部继承自Collection中的方法。

Set的使用

package com.mike.test;


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

/*
测试Set接口的使用
特点: (1) 无序、没有下标(2)不能重复
*/



public class Test {
    public static void main(String[] args) {
        //创建集合
        Set set = new HashSet();
        //1.添加数据
        set.add("苹果");
        set.add("菠萝");
        set.add("草莓");

        System.out.println("数据个数："+set.size());
        System.out.println(set.toString());

        //2.删除
        set.remove("苹果");
        System.out.println("数据个数："+set.size());
        System.out.println(set.toString());

        //3、遍历【重点】
        //3.1、增强for
        System.out.println("--------增强for-------");
        for (String s : set) {
            System.out.println(s);
        }
        //3.2、迭代器
        System.out.println("--------迭代器-------");
        Iterator it = set.iterator();
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }
        //4判断
        System.out.println("Set集合里是否有华为："+set.contains("菠萝"));
        System.out.println("Set集合是否为空："+set.isEmpty());
    }
}


          /*输出结果
            数据个数：3
            [苹果, 草莓, 菠萝]
            数据个数：2
            [草莓, 菠萝]
            --------增强for-------
            草莓
            菠萝
            --------迭代器-------
            草莓
            菠萝
            Set集合里是否有华为：true
            Set集合是否为空：false
            */

Set实现类

  • HashSet 【重点】:

    • 基于HashCode实现元素不重复。
    • 当存入元素的哈希码相同时，会调用equals进行确认， 如结果为true, 则拒绝后者存入。

  • TreeSet:

    • 基于排列顺序实现元素不重复。
    • 实现了SortedSet接口， 对集合元素自动排序。
    • 元素对象的类型必须实现Comparable接口，指定排序规则。
    • 通过CompareTo方法确定是否为重复元素。

HashSet使用案例一：

package com.mike.test;


/*
            HashSet集合的使用
            存储结构:哈希表(数组+链表+红黑树（jdk1.8之后）)
*/


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

public class Test {
    public static void main(String[] args) {
        //新建集合
        HashSet hashSet = new HashSet();
        //1、添加元素
        hashSet.add("刘德华");
        hashSet.add("梁朝伟");
        hashSet.add("林志玲");
        hashSet.add("周润发");
        System.out.println("元素个数："+hashSet.size());
        System.out.println(hashSet.toString());
        //2、删除数据
        hashSet.remove("刘德华");
        System.out.println("元素个数："+hashSet.size());
        System.out.println(hashSet.toString());

        //3、遍历操作
        //3.1、增强for
        System.out.println("------增强for-------");
        for (String s : hashSet) {
            System.out.println(s);
        }
        //3.2、使用迭代器
        System.out.println("-------使用迭代器--------");
        Iterator it = hashSet.iterator();
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }
        //4判断
        System.out.println("该集合中是否添加了郭富城："+hashSet.contains("郭富城"));
        System.out.println("该集合是否为空：");


    }
}
          /*输出结果
                元素个数：4
                [林志玲, 梁朝伟, 周润发, 刘德华]
                元素个数：3
                [林志玲, 梁朝伟, 周润发]
                ------增强for-------
                林志玲
                梁朝伟
                周润发
                -------使用迭代器--------
                林志玲
                梁朝伟
                周润发
                该集合中是否添加了郭富城：false
                该集合是否为空：
            */

HashSet使用案例二：

Person类

package com.mike.test;



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

    public Person() {
    }

    public Person(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 hashCode() {
        int n1 = this.name.hashCode();
        int n2 = this.age;

        return n1+n2;
    }

    @Override
    public boolean equals(Object obj) {
        if (this==obj){
            return true;
        }
        if (obj==null){
            return false;
        }
        if (obj instanceof Person){
            Person p =(Person) obj;

            if (this.name.equals(p.getName())&&this.age==p.getAge()){
                return true;
            }
        }
        return false;
    }




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

Test类

package com.mike.test;


/*
            HashSet集合的使用
            存储结构:哈希表(数组+链表+红黑树（jdk1.8之后）)
            存储过程：(重复依据)
            (1)根据hashcode计算保存的位置，如果此位置为空，则直接保存，如果不为空执行第二步。
            (2)再执行equals方法，如果equals方法为true，则认为是重复，否则，形成链表
*/


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

public class Test {
    public static void main(String[] args) {
        //新建集合
        HashSet hashSet = new HashSet();
        //1、添加元素

        Person p1 = new Person("张三", 18);
        Person p2 = new Person("李四", 19);
        Person p3 = new Person("王五", 20);
        Person p4 = new Person("赵六", 21);

        hashSet.add(p1);
        hashSet.add(p2);
        hashSet.add(p3);
        hashSet.add(p4);

        System.out.println("元素个数："+hashSet.size());
        System.out.println(hashSet.toString());
        //2、删除操作
//        hashSet.remove(p1);
        //当没有重写hashCode()和equals()方法时，下面这个操作是不能删除对象的
        //现在Person类里重写了hashCode()和equals()方法，所以hasSet认为这是集合中的同一个对象
//        hashSet.remove(new Person("赵六", 21));
//        System.out.println("元素个数："+hashSet.size());
//        System.out.println(hashSet.toString());

//        3、遍历【重点】
//        3.1、增强for
        System.out.println("------增强for-------");
        for (Person p : hashSet) {
            System.out.println(p);
        }

        //3.2、使用迭代器
        System.out.println("-------使用迭代器--------");
        Iterator it = hashSet.iterator();
        while (it.hasNext()) {
            Person p = it.next();
            System.out.println(p);
        }

        //4判断
//        System.out.println("该集合中是否添加了p1："+hashSet.contains(p1));
        System.out.println("该集合中是否添加了p3："+hashSet.contains(new Person("王五", 20)));
        System.out.println("该集合是否为空："+hashSet.isEmpty());

    }
}
          /*输出结果
            元素个数：4
            [Person{name='张三', age=18}, Person{name='王五', age=20}, Person{name='李			四', age=19}, Person{name='赵六', age=21}]
            ------增强for-------
            Person{name='张三', age=18}
            Person{name='王五', age=20}
            Person{name='李四', age=19}
            Person{name='赵六', age=21}
            -------使用迭代器--------
            Person{name='张三', age=18}
            Person{name='王五', age=20}
            Person{name='李四', age=19}
            Person{name='赵六', age=21}
            该集合中是否添加了p1：true
            该集合是否为空：false
            */

TreeSet使用

package com.mike.test;
/*
            TreeSet集合的使用
            存储结构:红黑树
            存储过程：(重复依据)
            (1)根据hashcode计算保存的位置，如果此位置为空，则直接保存，如果不为空执行第二步。
            (2)再执行equals方法，如果equals方法为true，则认为是重复，否则，形成链表
*/
import java.util.Iterator;
import java.util.TreeSet;

public class Test {
    public static void main(String[] args) {
        //新建集合
        TreeSet treeSet = new TreeSet<>();
        //1、添加元素
        treeSet.add("xyz");
        treeSet.add("abc");
        treeSet.add("hello");

        System.out.println("元素个数："+treeSet.size());
        System.out.println(treeSet.toString());
        //2、删除操作
//        treeSet.remove("xyz");
//        System.out.println("删除之后："+treeSet.toString());
//        System.out.println("元素个数："+treeSet.size());

//        3、遍历【重点】
//        3.1、增强for
        System.out.println("------增强for-------");
        for (String p : treeSet) {
            System.out.println(p);
        }

        //3.2、使用迭代器
        System.out.println("-------使用迭代器--------");
        Iterator it = treeSet.iterator();
        while (it.hasNext()) {
            String p = it.next();
            System.out.println(p);
        }

        //4判断
        System.out.println("该集合中是否添加了abc："+treeSet.contains("abc"));
        System.out.println("该集合是否为空："+treeSet.isEmpty());
    }
}
          /*输出结果
                元素个数：3
                [abc, hello, xyz]
                ------增强for-------
                abc
                hello
                xyz
                -------使用迭代器--------
                abc
                hello
                xyz
                该集合中是否添加了abc：true
                该集合是否为空：false
            */

用TreeSet集合添加对象

Person类

package com.mike.test;

import java.util.Objects;

public class Person implements Comparable {
    private String name;
    private int age;

    public Person() {
    }

    public Person(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 instanceof Person)) return false;

        Person person = (Person) o;

        if (age != person.age) return false;
        return name.equals(person.name);
    }


    @Override
    public int hashCode() {
        int result = name.hashCode();
        result = 31 * result + age;
        return result;
    }

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

//    先按姓名比，然后再按年龄比
    @Override
    public int compareTo(Person o) {
        int n1 = this.getName().compareTo(o.getName());
        int n2 = this.age-o.getAge();
        return n1== 0 ? n2 : n1;
    }
}

Test类

package com.mike.test;
/*
            TreeSet集合的使用
            存储结构:红黑树
            要求:元素必须要实现Comparable接日, compareTo()方法返回值为0,认为是重复元素
*/

import java.util.Iterator;
import java.util.TreeSet;

public class Test {
    public static void main(String[] args) {
        //新建集合
        TreeSet treeSet = new TreeSet();
        //1、添加元素

        Person p1 = new Person("刘德华", 55);
        Person p2 = new Person("谢霆锋", 56);
        Person p3 = new Person("郭富城", 57);
        Person p4 = new Person("周润发", 58);


        treeSet.add(p1);
        treeSet.add(p2);
        treeSet.add(p3);
        treeSet.add(p4);

        System.out.println("元素个数："+treeSet.size());
        System.out.println(treeSet.toString());
        //2、删除操作
//        treeSet.remove(p1);
//        treeSet.remove(new Person("周润发", 58));//这样删除也是可以的，因为重写了equals和hashcode
//        System.out.println("删除之后："+treeSet.toString());
//        System.out.println("元素个数："+treeSet.size());

//        3、遍历【重点】
//        3.1、增强for
        System.out.println("------增强for-------");
        for (Person p : treeSet) {
            System.out.println(p);
        }

        //3.2、使用迭代器
        System.out.println("-------使用迭代器--------");
        Iterator it = treeSet.iterator();
        while (it.hasNext()) {
            Person p = it.next();
            System.out.println(p);
        }

        //4判断
        System.out.println("该集合中是否添加了p1："+treeSet.contains(p1));
        System.out.println("该集合是否为空："+treeSet.isEmpty());
    }
}


          /*输出结果
元素个数：4
[Person{name='刘德华', age=55}, Person{name='周润发', age=58}, Person{name='谢霆锋', age=56}, Person{name='郭富城', age=57}]
------增强for-------
Person{name='刘德华', age=55}
Person{name='周润发', age=58}
Person{name='谢霆锋', age=56}
Person{name='郭富城', age=57}
-------使用迭代器--------
Person{name='刘德华', age=55}
Person{name='周润发', age=58}
Person{name='谢霆锋', age=56}
Person{name='郭富城', age=57}
该集合中是否添加了p1：true
该集合是否为空：false
            */

Comparator :实现定制比较(比较器)

package com.mike.test;


/*
            TreeSet集合的使用
            Comparator :实现定制比较(比较器)
            Comparable:可比较的
*/

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

public class Test {
    public static void main(String[] args) {
        //创建集合,并指定比较规则
        TreeSet treeSet = new TreeSet<>(new Comparator() {
            @Override
            public int compare(Person o1, Person o2) {
                int n1 = o1.getAge()-o2.getAge();
                int n2 = o1.getName().compareTo(o2.getName());
                return n1==0?n2:n1;
            }
        });

        Person p1 = new Person("xyz", 20);
        Person p2 = new Person("hello", 22);
        Person p3 = new Person("zhangsan", 25);

        treeSet.add(p1);
        treeSet.add(p2);
        treeSet.add(p3);

        System.out.println("元素个数："+treeSet.size());
        System.out.println(treeSet.toString());
    }
}
           /*输出结果
元素个数：3
[Person{name='xyz', age=20}, Person{name='hello', age=22}, Person{name='zhangsan', age=25}]
            */

TreeSet小案例

  • 要求:使用TreeSet集合实现字符串按照长度进行排序
  • helloworld?zhang?lisi?wangwu?beijing?xian?nanjing
package com.mike.test;

import java.util.Comparator;
import java.util.TreeSet;

//要求:使用TreeSet集合实现字符串按照长度进行排序
//helloworld  zhang  lisi  wangwu  beijing  xian  nanjing
//Comparator接口实现定制比较

public class Demo01 {
    public static void main(String[] args) {
        //创建集合，并指定比较规则
        TreeSet treeSet = new TreeSet(new Comparator() {
            @Override
            public int compare(String o1, String o2) {
                int n1 = o1.length()-o2.length();
                int n2 = o1.compareTo(o2);//调用compareTo自己的规则
                return n1==0?n2:n1;
            }
        });
        //添加数据
        treeSet.add("helloworld");
        treeSet.add("zhang");
        treeSet.add("lisi");
        treeSet.add("wangwu");
        treeSet.add("beijing");
        treeSet.add("xian");
        treeSet.add("nanjing");

        System.out.println(treeSet.toString());
    }
}
        /*输出结果：
        [lisi, xian, zhang, wangwu, beijing, nanjing, helloworld]
        */

六、Map接口与实现类

Map体系集合

Map父接口

  • 特点:存储一对数据(Key-Value)，无序、无下标，键不可重复，值可重复。

  • 方法:

    • V?put(K?key,V?value) //将对象存入到集合中，关联键值。key重复则覆盖原值。
    • Object ?get (Object?key) //根据键获取对应的值。
    • Set //返回所有key。
    • Collection?values() //返回包含所有值的Collection集合。
    • Set //键值匹配的Set集合。

Map接口的使用

遍历效率:keySet()

package com.mike.test;

/*
        Map接口的使用
        特点:(1)存储键值对(2)键不能重复，值可以重复(3)无序
*/

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Demo01 {
    public static void main(String[] args) {
        //创建Map集合
        Map map = new HashMap<>();
        //1、添加元素
        map.put("CN","中国");
        map.put("US","美国");
        map.put("UK","英国");
        map.put("FR","法国");
        map.put("CA","加拿大");
        map.put("IT","意大利");

        System.out.println("元素个数："+map.size());
        System.out.println(map.toString());

        //2、删除
//        map.remove("IT");
//        System.out.println("------删除Key=IT后------");
//        System.out.println("元素个数："+map.size());
//        System.out.println(map.toString());

        //3、遍历
        //3.1、使用keySet();
        System.out.println("----------1、使用keySet()遍历----------");
        Set keySet = map.keySet();
        for (String s : keySet) {
            System.out.println(s+"="+map.get(s));
        }
        //3.2、使用entrySet()方法
        System.out.println("----------2、使用entrySet()方法遍历----------");
        Set> entries = map.entrySet();
        for (Map.Entry entry : entries) {
            System.out.println(entry.getKey()+"="+entry.getValue());
        }

        //4、判断
        System.out.println(map.containsKey("CN"));
        System.out.println(map.containsValue("泰国"));
    }
}
/*
            元素个数：6
            {UK=英国, CN=中国, IT=意大利, FR=法国, US=美国, CA=加拿大}
            ----------1、使用keySet()遍历----------
            UK=英国
            CN=中国
            IT=意大利
            FR=法国
            US=美国
            CA=加拿大
            ----------2、使用entrySet()方法遍历----------
            UK=英国
            CN=中国
            IT=意大利
            FR=法国
            US=美国
            CA=加拿大
            true
            false
*/

Map集合的实现类

  • HashMap 【重点】
    • JDK1. 2版本，线程不安全，运行效率快;
    • 允许用null作为key或是value。
    • HashMap的无参构造默认初始容量是16，默认加载因子(0.75) 的空HashMap。

加载因子： 加载因子是哈希表在其容量自动增加之前可以达到多满的一种尺度。如果当哈希表中的条目数超出了 加载因子与当前容量的乘积时,则要对该哈希表进行rehash()操作,从而哈希表将具有大约两倍的桶数。

  • Hashtable：

    • JDK1.0版本，线程安全,运行效率慢;
    • 不允许null作为key或是value。

  • Propertiles：

    • Hashtable的子类，要求key和value都是String。通常用于配置文件的读取。

  • TreeMap：

    • 实现了SortedMap接口(是Map的子接口)，可以对key自动排序。

HashMap的使用

Student类

package com.mike.test;

import java.util.Objects;

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

    public Student() {
    }

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

    public int getStuNo() {
        return stuNo;
    }

    public void setStuNo(int stuNo) {
        this.stuNo = stuNo;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Student)) return false;

        Student student = (Student) o;

        if (stuNo != student.stuNo) return false;
        return name.equals(student.name);
    }

    @Override
    public int hashCode() {
        int result = stuNo;
        result = 31 * result + name.hashCode();
        return result;
    }

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

Demo01类

package com.mike.test;

/*
        HashMap集合的使用
        存储结构:哈希表(数组+链表+红黑树)
        使用key可hashcode和equals作为重复


*/

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Demo01 {
    public static void main(String[] args) {
        //创建Map集合
        HashMap students = new HashMap();
        //1、添加元素

        Student s1 = new Student(001, "孙悟空");
        Student s2 = new Student(002, "唐三藏");
        Student s3 = new Student(003, "猪八戒");
        Student s4 = new Student(004, "沙和尚");
        Student s5 = new Student(005, "白龙马");

        students.put(s1,"北京");
        students.put(s2,"南京");
        students.put(s3,"河北");
        students.put(s4,"河南");
        students.put(s5,"上海");

        System.out.println("元素个数："+students.size());
        System.out.println(students.toString());

        //2、删除
        students.remove(s1);
        System.out.println("------删除Key=s1后------");
        System.out.println("元素个数："+students.size());
        System.out.println(students.toString());

        //3、遍历
        //3.1、使用keySet();
        System.out.println("----------1、使用keySet()遍历----------");
        Set keySet = students.keySet();
        for (Student s : keySet) {
            System.out.println(s+"="+students.get(s));
        }
        //3.2、使用entrySet()方法
        System.out.println("----------2、使用entrySet()方法遍历----------");
        Set> entries = students.entrySet();
        for (Map.Entry entry : entries) {
            System.out.println(entry.getKey()+"="+entry.getValue());
        }

        //4、判断
        System.out.println(students.containsKey(s1));
        System.out.println(students.containsValue("上海"));
    }
}
 /*输出结果
元素个数：5
{Student{stuNo=1, name='孙悟空'}=北京, Student{stuNo=4, name='沙和尚'}=河南, Student{stuNo=3, name='猪八戒'}=河北, Student{stuNo=5, name='白龙马'}=上海, Student{stuNo=2, name='唐三藏'}=南京}
------删除Key=s1后------
元素个数：4
{Student{stuNo=4, name='沙和尚'}=河南, Student{stuNo=3, name='猪八戒'}=河北, Student{stuNo=5, name='白龙马'}=上海, Student{stuNo=2, name='唐三藏'}=南京}
----------1、使用keySet()遍历----------
Student{stuNo=4, name='沙和尚'}=河南
Student{stuNo=3, name='猪八戒'}=河北
Student{stuNo=5, name='白龙马'}=上海
Student{stuNo=2, name='唐三藏'}=南京
----------2、使用entrySet()方法遍历----------
Student{stuNo=4, name='沙和尚'}=河南
Student{stuNo=3, name='猪八戒'}=河北
Student{stuNo=5, name='白龙马'}=上海
Student{stuNo=2, name='唐三藏'}=南京
false
true
*/

Map源码分析

1 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;/ /hashMap初始容量大小
2 static final int MAXIMUM_CAPACITY = 1 << 30;/ /hashmap的数组最大容量
3 static final float DEFAULT_LOAD_ FACTOR = 0.75f; //默认加载因子
4 static final int TREEIFY_THRESHOLD = 8;//jdk1.8 当链表长度大于8时，调整成红黑数
5 static final int UNTREEIFY_THRESHOLD = 6;; //jdk1.8 当链表长度小于6时，调整成链表
6 static final int MIN.TREEIFY_CAPACITY = 64;//jdk1.8 当链表长度大于8时，并且集合元素个数大于等于64时，调整成红黑数
7 transient Node[] table;//哈希表中的数组
8 size;//元素个数
HashMap无参构造

刚创建HashMap之后没有添加元素table=null，size=0。（目的：节省空间）

public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR;//all other fields defaulted
    }
put方法
public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
   }

HashMap总结

(1)HashMap刚创建时，table是null，为了节省空间，当添加第一个元素时，table容量调整为16
(2)当元素个数大于阈值(16*0.75=12)时，会进行扩容，扩容后大小为原来的2倍。目的是减少调整元素的个数。
(3)jdk1.8每个链表长度大于8，并且元素个数大于等于64时，会调整为红黑树，目的提高执行效率
(4)jdk1.8当链表长度小于6时，调整成链表
(5)jdk1.8以前，链表是头插入，jdk1.8以后时是尾插入

Hashtable和Propertiles

  • Hashtable

    • 此类实现一个哈希表，该哈希表将键映射到相应的值。任何非nul1对象都可以用作键或值。
    • 为了成功地在哈希表中存储和获取对象，用作键的对象必须实现hashCode方法和equals 方法。

  • Propertiles

    • Properties类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串 。
    • 一个属性列表可包含另一个属性列表作为它的“默认值”;如果未能在原有的属性列表中搜索到属性键，则搜索第二个属性列表。

这里暂时认识一下Hashtable和Propertiles。

TreeMap的使用

Student类

package com.mike.test;

import java.util.Objects;

public class Student implements Comparable {
    private int stuNo;
    private String name;

    public Student() {
    }

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

    public int getStuNo() {
        return stuNo;
    }

    public void setStuNo(int stuNo) {
        this.stuNo = stuNo;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Student)) return false;

        Student student = (Student) o;

        if (stuNo != student.stuNo) return false;
        return name.equals(student.name);
    }

    @Override
    public int hashCode() {
        int result = stuNo;
        result = 31 * result + name.hashCode();
        return result;
    }

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

    @Override
    public int compareTo(Student o) {
        int n1 = this.stuNo-o.getStuNo();
        return n1;
    }
}

Demo01类

package com.mike.test;

/*
        TreeMap的使用
        存储结构:红黑树

*/

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class Demo01 {
    public static void main(String[] args) {
        //创建Map集合
        TreeMap treeMap = new TreeMap();
/*或者直接用匿名内部类
 TreeMap treeMap = new TreeMap(new Comparator() {
            @Override
            public int compare(Student o1, Student o2) {
                return 0;//在这里写比较规则
            }
        });
*/
        //1、添加元素
        Student s1 = new Student(001, "孙悟空");
        Student s2 = new Student(002, "唐三藏");
        Student s3 = new Student(003, "猪八戒");
        Student s4 = new Student(004, "沙和尚");
        Student s5 = new Student(005, "白龙马");

        treeMap.put(s1,"北京");
        treeMap.put(s2,"南京");
        treeMap.put(s3,"河北");
        treeMap.put(s4,"河南");
        treeMap.put(s5,"上海");

       
        System.out.println("元素个数："+treeMap.size());
        //要实现Student类的compareTo()方法，让Student类继承Comparable
        //定制比较规则
        System.out.println(treeMap.toString());

        //2、删除
//        treeMap.remove(s1);
//        System.out.println("------删除Key=s1后------");
//        System.out.println("元素个数："+treeMap.size());
//        System.out.println(treeMap.toString());

        //3、遍历
        //3.1、使用keySet();
        System.out.println("----------1、使用keySet()遍历----------");
        Set keySet = treeMap.keySet();
        for (Student s : keySet) {
            System.out.println(s+"="+treeMap.get(s));
        }
        //3.2、使用entrySet()方法
        System.out.println("----------2、使用entrySet()方法遍历----------");
        Set> entries = treeMap.entrySet();
        for (Map.Entry entry : entries) {
            System.out.println(entry.getKey()+"="+entry.getValue());
        }

        //4、判断
        System.out.println(treeMap.containsKey(s1));
        System.out.println(treeMap.containsValue("上海"));
    }
}
 /*输出结果
元素个数：5
{Student{stuNo=1, name='孙悟空'}=北京, Student{stuNo=2, name='唐三藏'}=南京, Student{stuNo=3, name='猪八戒'}=河北, Student{stuNo=4, name='沙和尚'}=河南, Student{stuNo=5, name='白龙马'}=上海}
----------1、使用keySet()遍历----------
Student{stuNo=1, name='孙悟空'}=北京
Student{stuNo=2, name='唐三藏'}=南京
Student{stuNo=3, name='猪八戒'}=河北
Student{stuNo=4, name='沙和尚'}=河南
Student{stuNo=5, name='白龙马'}=上海
----------2、使用entrySet()方法遍历----------
Student{stuNo=1, name='孙悟空'}=北京
Student{stuNo=2, name='唐三藏'}=南京
Student{stuNo=3, name='猪八戒'}=河北
Student{stuNo=4, name='沙和尚'}=河南
Student{stuNo=5, name='白龙马'}=上海
true
true
*/

Colletions工具类

  • 概念:集合工具类，定义了除了存取以外的集合常用方法。

  • 方法:

public static void reverse(List<?> list) //反转集合中元素的顺序
public static void shuffle(List<?> list) //随机重置集合元素的顺序
public static void sort(List list) //升序排序(元素类型必须实现Comparable接口)

演示Collections工具类的使用

package com.mike.test;

/*
           演示Collections工具类的使用
*/

import java.util.*;

public class Test {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(20);
        list.add(3);
        list.add(35);
        list.add(66);
        list.add(50);

        //sort排序
        System.out.println("-----排序前------");
        System.out.println(list.toString());
        Collections.sort(list);
        System.out.println("-----排序后------");
        System.out.println(list.toString());

        //binarySearch二分查找（只能用在有序的集合中）
        int i = Collections.binarySearch(list, 66);
        System.out.println("66的位置："+i);

        //copy复制
        List list2 = new ArrayList();
        for (int k = 0; k < list.size(); k++) {
            list2.add(0);
        }
        Collections.copy(list2,list);
        System.out.println("-----复制后------");
        System.out.println(list2.toString());

        //reverse反转
        Collections.reverse(list);
        System.out.println("-----反转后------");
        System.out.println(list.toString());


        //shuffle 打乱
        Collections.shuffle(list);
        System.out.println("-----打乱后------");//每次运行都不一样
        System.out.println(list.toString());


        //补充：list转成数组
        System.out.println("-----list转成数组------");
        Integer[] arr = list.toArray(new Integer[0]);
        System.out.println("长度："+arr.length);
        System.out.println(Arrays.toString(arr));

        //数组转成集合
        String[] names = {"张三","李四","王五","赵六"};
        for (String name : names) {
            System.out.println(name);
        }
        System.out.println("-----数组转成集合------");
        //集合是一个受限集合，不能添加和删除
        List strings = Arrays.asList(names);
        System.out.println(strings.toString());

        //把基本类型数组转成集合时，需要修改为包装类型
        Integer[] nums = {100,200,300,400,500};
        List ints = Arrays.asList(nums);
        System.out.println(ints);
    }
}
           /*输出结果
                -----排序前------
                [20, 3, 35, 66, 50]
                -----排序后------
                [3, 20, 35, 50, 66]
                66的位置：4
                -----复制后------
                [3, 20, 35, 50, 66]
                -----反转后------
                [66, 50, 35, 20, 3]
                -----打乱后------
                [66, 35, 20, 3, 50]
                -----list转成数组------
                长度：5
                [66, 35, 20, 3, 50]
                张三
                李四
                王五
                赵六
                -----数组转成集合------
                [张三, 李四, 王五, 赵六]
                [100, 200, 300, 400, 500]
            */

集合总结

  • 集合的概念:

    • 对象的容器，和数组类似，定义了对多个对象进行操作的常用方法。

  • List集合:

    • 有序、有下标、元素可以重复。 (ArrayList、 LinkedList、 Vector)

  • Set集合:

    • 无序、无下标、元素不可重复。 (HashSet、 TreeSet)

  • Map集合:

    • 存储一对数据，无序、无下标，键不可重复，值可重复。 (HashMap、 HashTable、 TreeMap)

  • Collections:

    • 集合工具类，定义了除了存取以外的集合常用方法。

相关

标签