Java_集合框架

编程语言 2022-04-23 06:19:54 阅读次数: 0

课件下载

1.集合的概念

概念：对象的容器，定义了对多个对象进行操作的常用方法。可实现数组的功能；

和数组的区别：

  1. 数组的长度固定，集合的长度不固定
  2. 数组可以存储基本类型和引用类型，而集合只能存储引用类型

位置：java.uti.*

2.Collection接口

Collection体系集合


List接口的特点：有序、有下标、元素可重复

Set接口的特点：无序、无下标、元素不能重复

Collection父接口

概念：代表一组任意类型的对象，无序、无下标、不能重复

方法：

  • boolean add(Object obj)//添加一个对象
  • boolean addAll(Collection c)//将一个集合中的所有对象添加到此集合中
  • void clear()//清空此集合中的所有对象
  • boolean contains(Object o)//检查此集合中的是否包含o对象
  • boolean equals(Object o)//比较此集合是否与指定集合相等
  • boolean isEmpty()//判断此集合是否为空
  • boolean remove(Object o)//在此集合中移除对象o
  • int size()//返回此集合中元素的数量
  • Object[] toArray()//将此集合转换成数组

iterator迭代器

  • boolean hasNext()//是否还有下一个元素
  • E next()//取出当前元素
  • void remove()//删除当前元素

Collection使用（1）

保存元素

//Demo0_1
package Demo0;

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


/**
 * Collection接口的使用
 * （1）添加元素
 * （2）删除元素
 * （3）遍历元素
 * （4）判断
 * @author dl
 */
public class Demo0_1 {
    
    
    public static void main(String[] args) {
    
    
        //创建集合
        Collection collection = new ArrayList();
        //增加元素
        collection.add("苹果");
        collection.add("西瓜");
        collection.add("榴莲");
        collection.add("香蕉");
//        System.out.println("元素个数：" + collection.size());
//        System.out.println(collection);
//        //删除元素
//        collection.remove("西瓜");
//        System.out.println(collection);
//        collection.clear();
//        System.out.println("清空之后：" + collection.size());
        //遍历元素*
            //遍历使用高级 for
        for(Object object : collection) {
    
    
            System.out.println(object);
        }
        
            //使用迭代器（迭代专门用来遍历集合）
        Iterator it = collection.iterator();
        while(it.hasNext()) {
    
    
            String op = (String)it.next();
            System.out.println(op);
            //it.remove();
        }
        
        System.out.println(collection.size());
        //判断
        System.out.println(collection.contains("西瓜"));
        System.out.println(collection.contains("土豆"));
        System.out.println("是否为空：" + collection.isEmpty());
    }
}
/*
苹果
西瓜
榴莲
香蕉
苹果
西瓜
榴莲
香蕉
4
true
false
是否为空：false
*/

Collection使用（2）

保存学生信息

给集合里面添加，其实加的是地址（引用），其实删除的是地址，对象仍在堆里面；

//Student
package Demo0.Demo0_2;

/**
 * 学生类
 * @author dl
 */
public class 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 +
                '}';
    }
}
//Demo0_2
package Demo0.Demo0_2;

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

/**
 * Collection的使用，保存学生的信息
 * @author dl
 */
public class Demo0_2 {
    
    
    public static void main(String[] args) {
    
    
        //新建Collection对象
        Collection collection = new ArrayList();
        Student s1 = new Student("dl", 21);
        Student s2 = new Student("cll", 20);
        Student s3 = new Student("dc", 10);
        //添加数据
        collection.add(s1);
        collection.add(s2);
        collection.add(s3);
        collection.add(s1);
        System.out.println(collection.size());
        System.out.println(collection.toString());
        //删除
//        collection.remove(s1);
//        collection.remove(new Student("dl", 21));
        /*这个是新new的 只是和前面的属性相同 和前面的并不是一个东西 并不能删除上面的那一个*/

        System.out.println("删除之后：" + collection.size());
        //清空
//        collection.clear();
        /*这里的清空 只是对集合中的清空 原来的对象还是存在的*/

        System.out.println("清空之后：" + collection.size());
        //判断
        System.out.println(collection.contains(s1));
        //遍历
            //1.增强for
        for(Object object : collection) {
    
    
            Student student = (Student)object;
            System.out.println(student.getName() + " " + student.getAge());
        }
            //2.使用迭代器Iterator
        Iterator it = collection.iterator();
        while(it.hasNext()) {
    
    
            Student student = (Student)it.next();
            System.out.println(student.getName() + " " + student.getAge());
            it.remove();
        }
        System.out.println("遍历完之后：" + collection.size());
        /*在Iterator迭代器遍历的过程中 不能使用collection的remove*/

        //判断是否为空
        System.out.println(collection.isEmpty());
    }
}
/*
4
[Student{name='dl', age=21}, Student{name='cll', age=20}, Student{name='dc', age=10}, Student{name='dl', age=21}]
删除之后：4
清空之后：4
true
dl 21
cll 20
dc 10
dl 21
dl 21
cll 20
dc 10
dl 21
遍历完之后：0
true
*/

3.List接口与实现类

List子接口

List使用（1）

List 继承了 Collection父类的所有方法；

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

方法：

  • void add(int index, Object o)//在index位置插入元素o
  • boolean addAll(int index, Collection c)//将一个集合中的元素添加到此集合中的index位置
  • Object get(int index)//返回集合中指定位置的元素
  • List subList(int fromIndex, int toIndex)//返回fromIndex和toIndex之间的集合元素
//Demo0_3
package Demo0.Demo0_3;
/**
 *List子接口的使用
 * 特点：有序、有下标、可以重复
 * @author dl
 */

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

public class Demo0_3 {
    
    
    public static void main(String[] args) {
    
    
        //创建集合
        List list = new ArrayList();//实例化它的子类
        //添加元素
        list.add("手机");
        list.add("小米");
        list.add("华为");
        list.add(0, "苹果");
        list.add(2, "大米");//下标从 0 开始 在下标的前面添加
        System.out.println("元素的个数：" + list.size());
        System.out.println(list.toString());
        //删除元素
        list.remove(0);
        System.out.println("删除之后：" + list.size());
        System.out.println(list.toString());
        //遍历
            //使用for
        for(int i = 0; i < list.size(); i ++) {
    
    
            System.out.println(list.get(i));
        }
            //使用加强for
        for(Object object : list) {
    
    
            String str = (String)object;
            System.out.println(str);
        }
            //使用迭代器Iterator
        Iterator it = list.iterator();
        while(it.hasNext()) {
    
    
            String str = (String)it.next();
            System.out.println(str);
//            it.remove();
        }
            //使用列表迭代器listIterator 和Iterator的区别，listIterator可以向前或者向后遍历、添加、删除、修改元素
        ListIterator lit =  list.listIterator();
                //使用列表迭代器从前往后
        while(lit.hasNext()) {
    
    
            System.out.println(lit.nextIndex() + ", " + lit.next());
        }
                //使用列表迭代器从后往前
        while(lit.hasPrevious()) {
    
    
            System.out.println(lit.previousIndex() + ", " + lit.previous());
        }
        
        System.out.println("遍历后的元素个数：" + list.size());
        //判断是否存在
        System.out.println(list.contains("小米"));
        //判断是否为空
        System.out.println(list.isEmpty());
        //返回下标
        System.out.println(list.indexOf("小米"));//下标从 0 开始
        //返回元素
        System.out.println(list.get(3).toString());

    }
}
/*
元素的个数：5
[苹果, 手机, 大米, 小米, 华为]
删除之后：4
[手机, 大米, 小米, 华为]
手机
大米
小米
华为
手机
大米
小米
华为
手机
大米
小米
华为
0, 手机
1, 大米
2, 小米
3, 华为
3, 华为
2, 小米
1, 大米
0, 手机
遍历后的元素个数：4
true
false
2
华为
*/

List使用（2）

//Demo0_4
package Demo0.Demo0_4;

import java.util.ArrayList;
import java.util.List;

public class Demo0_4 {
    
    
    public static void main(String[] args) {
    
    
        //创建集合
        List list = new ArrayList();
        //添加数字数据（自动装箱）
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);
        list.add(60);
        System.out.println("元素个数：" + list.size());
        System.out.println(list.toString());
        //删除
//        list.remove(0);//根据下标
        list.remove(new Integer(20));
        /*如果直接写20的话 这里会报错 因为超出下标范围了 所以要将20装箱 这样才能找到从而删除*/
        System.out.println("删除后的元素个数：" + list.size());
        System.out.println(list.toString());
        //补充方法 subList()
        List sublist = list.subList(1, 3);
        System.out.println(sublist.toString());
    }
}
/*
元素个数：5
[20, 30, 40, 50, 60]
删除后的元素个数：4
[30, 40, 50, 60]
[40, 50]
*/

List实现类

ArrayList【重点】：

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

源码分析：

默认容量：DEFAULT_CAPACITY = 10，注意，没有向集合中添加任何元素的时候默认是 0 ，添加一个元素之后就变成了 10，超过10每次扩容为原来的1.5倍（15）；

存放元素的数组：elementData；

实际的元素：size；

//Student
package Demo0.Demo0_5;

/**
 * Student类
 */
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) {
    
    
        if(this == obj) return true;
        if(obj == null) return false;
        if(obj instanceof Student) {
    
    
            Student std = (Student) obj;
            if(this.getAge() == ((Student) obj).getAge() && this.getName().equals(((Student) obj).getName())) {
    
    
                return true;
            }
        }
        return false;
    }
}
//Demo0_5
package Demo0.Demo0_5;

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

/**
 * ArrayList的使用
 * 特点：有序、有下标、元素可以重复
 * 存储结构：数组、查找遍历速度快，增删速度慢
 * @author dl
 */
public class Demo0_5 {
    
    
    public static void main(String[] args) {
    
    
        //创建集合
        ArrayList arrayList = new ArrayList();
        //1.添加元素
        Student s1 = new Student("dl", 21);
        Student s2 = new Student("cll", 21);
        Student s3 = new Student("cd", 10);
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        System.out.println("添加后的元素数量：" + arrayList.size());
        System.out.println(arrayList.toString());
            //按照下标添加一个
        Student s4 = new Student("ddd", 1);
        arrayList.add(1, s4);
        System.out.println("添加元素之后：" + arrayList.size());
        System.out.println(arrayList.toString());
        //2.删除元素
            //根据学生类删除
        arrayList.remove(s4);
        System.out.println("删除之后的个数：" + arrayList.size());
        System.out.println(arrayList.toString());
            //根据下标删除
        arrayList.remove(1);
        System.out.println("删除之后的个数：" + arrayList.size());
        System.out.println(arrayList.toString());
            //特别注意的是下面这种做法 并不能删除元素 默认对比的是地址 当然我们自己可以重写equals 重写之后就可以正常删除了
        arrayList.remove(new Student("dl", 21));
        System.out.println("删除之后的个数：" + arrayList.size());
        System.out.println(arrayList.toString());
        arrayList.add(s2);
        arrayList.add(s3);
        //3.遍历元素
            //简单的for遍历
        for(int i = 0; i < arrayList.size(); i ++) {
    
    
            Student ss = (Student) arrayList.get(i);
            System.out.println(ss.getName() + "：" + ss.getAge());
        }
            //高级for遍历
        for(Object object : arrayList) {
    
    
            Student ss = (Student) object;
            System.out.println(ss.getName() + ", " + ss.getAge());
        }
            //使用迭代器
                //第一种迭代器Iterator
        Iterator it = arrayList.iterator();
        while(it.hasNext()) {
    
    
            Student std = (Student) it.next();
            System.out.println(std.getName() + "::" + std.getAge());
        }
                //第二种迭代器ListIterator
        ListIterator lit = arrayList.listIterator();
                    //从前往后遍历
        while(lit.hasNext()) {
    
    
            Student std = (Student) lit.next();
            System.out.println(std.getName() + ",," + std.getAge());
        }
                    //从后往前遍历
        while(lit.hasPrevious()) {
    
    
            Student std = (Student) lit.previous();
            System.out.println(std.getName() + "  " + std.getAge());
        }
        //4.判断
        System.out.println(arrayList.contains(s3));
        System.out.println(arrayList.contains(new Student("cll", 21)));//因为已经改变了原来的equals 所以输出true
        System.out.println(arrayList.isEmpty());
        //查找
        System.out.println(arrayList.get(1).toString());
        System.out.println(arrayList.indexOf(s3));
        System.out.println(arrayList.indexOf(new Student("cll", 21)));//因为Student类重写了equals方法
    }
}
/*
添加后的元素数量：3
[Student{name='dl', age=21}, Student{name='cll', age=21}, Student{name='cd', age=10}]
添加元素之后：4
[Student{name='dl', age=21}, Student{name='ddd', age=1}, Student{name='cll', age=21}, Student{name='cd', age=10}]
删除之后的个数：3
[Student{name='dl', age=21}, Student{name='cll', age=21}, Student{name='cd', age=10}]
删除之后的个数：2
[Student{name='dl', age=21}, Student{name='cd', age=10}]
删除之后的个数：1
[Student{name='cd', age=10}]
cd：10
cll：21
cd：10
cd, 10
cll, 21
cd, 10
cd::10
cll::21
cd::10
cd,,10
cll,,21
cd,,10
cd  10
cll  21
cd  10
true
true
false
Student{name='cll', age=21}
0
1
*/

Vector：

  1. 数组结构实现、查询快、增删慢；
  2. JDK1.0版本，运行效率慢、线程安全；
//Demo0_6
package Demo0.Demo0_6;

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

/**
 * Vector集合的使用
 * 存储结构：数组
 * @author dl
 */
public class Demo0_6 {
    
    
    public static void main(String[] args) {
    
    
        //创建集合
        Vector vector = new Vector();
        //1.添加元素
        vector.add("草莓");
        vector.add("苹果");
        vector.add("西瓜");
        System.out.println("元素个数：" + vector.size());
        //2.删除
//        vector.remove(1);
//        vector.remove("西瓜");
//        vector.clear();
        //3.遍历
            //使用枚举器
        Enumeration en = vector.elements();
        while(en.hasMoreElements()) {
    
    
            String s = (String) en.nextElement();
            System.out.println(s);
        }
        //4.判断
        System.out.println(vector.contains("西瓜"));
        System.out.println(vector.isEmpty());
        //5.其他方法
//        vector.firstElement();
//        vector.lastElement();
//        vector.elementAt();
    }
}
/*
元素个数：3
草莓
苹果
西瓜
true
false
*/

LinkedList：

  1. 链表结构实现、查询慢、增删快；
//Student
package Demo0.Demo0_7;

/**
 * Student学生类
 * @author dl
 */
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 +
                '}';
    }
}
//Demo0_7
package Demo0.Demo0_7;

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

/**
 * LinkedList的使用
 * 存储结构：双向链表
 * @author dl
 */
public class Demo0_7 {
    
    
    public static void main(String[] args) {
    
    
        //创建集合
        LinkedList linkedList = new LinkedList();
        //1.添加元素
        Student s1 = new Student("dl", 21);
        Student s2 = new Student("cll", 21);
        Student s3 = new Student("dc", 10);
        linkedList.add(s1);
        linkedList.add(s2);
        linkedList.add(s3);
        System.out.println("元素的个数：" + linkedList.size());
        System.out.println(linkedList.toString());
        //2.删除
        linkedList.remove(s1);
        System.out.println("删除之后：" + linkedList.size());
        System.out.println(linkedList.toString());
//        linkedList.clear();
        //3.遍历
            //使用for遍历
        for(int i = 0; i < linkedList.size(); i ++) {
    
    
            Student std = (Student) linkedList.get(i);
            System.out.println(std.getName() + " , " + std.getAge());
        }
            //增强for
        for(Object object : linkedList) {
    
    
            Student std = (Student) object;
            System.out.println(std.getName() + " , " + std.getAge());
        }
            //使用迭代器Iterator
        Iterator it = linkedList.iterator();
        while(it.hasNext()) {
    
    
            Student std = (Student) it.next();
            System.out.println(std.getName() + " , " + std.getAge());
        }
            //使用列表迭代器ListIterator
        ListIterator lit = linkedList.listIterator();
        while(lit.hasNext()) {
    
    
            Student std = (Student) lit.next();
            System.out.println(std.getName() + " , " + std.getAge());
        }
        //4.判断
        System.out.println(linkedList.contains(s2));
        System.out.println(linkedList.isEmpty());
        //5.查询
        System.out.println(linkedList.indexOf(s2));
    }
}
/*
元素的个数：3
[Student{name='dl', age=21}, Student{name='cll', age=21}, Student{name='dc', age=10}]
删除之后：2
[Student{name='cll', age=21}, Student{name='dc', age=10}]
cll , 21
dc , 10
cll , 21
dc , 10
cll , 21
dc , 10
cll , 21
dc , 10
true
false
0
*/

源码分析：

集合的大小：size；

链表的头结点：Node first；

链表的尾节点：Node last；

不同结构实现方式

ArrayList
必须开辟连续的空间，查询快，增删慢；
LinkedList
无需开辟连续的空间，查询慢，增删快；

4.泛型和工具类

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

常见的形式：泛型类、泛型接口、泛型方法；

语法：<T, . . .> T 表示类型占位符，表示一种引用类型；

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

泛型类

注意： 泛型只能是引用类型，不同的泛型对象之间不能相互赋值；

//MyGeneric
package Demo0.Demo0_8;

/**
 * 泛型类的使用
 * 语法：类名<T>
 *T是类型占位符 表示一种引用类型 可以写多个 用,隔开
 * @author dl
 */
public class MyGeneric<T> {
    
    
    //使用泛型T
    //1.创建变量
    T t;

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

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

}
//TestMyGeneric
package Demo0.Demo0_8;

/**
 * 使用泛型类来创建对象
 * @author dl
 */
public class TestGeneric {
    
    
    public static void main(String[] args) {
    
    
        //使用泛型类来创建对象
        MyGeneric<String> stringMyGeneric = new MyGeneric<>();
        stringMyGeneric.t = "dl";
        stringMyGeneric.show("大家好，加油！");
        System.out.println(stringMyGeneric.getT());
        
        MyGeneric<Integer> integerMyGeneric = new MyGeneric<>();
        integerMyGeneric.t = 2;
        integerMyGeneric.show(2);
        System.out.println(integerMyGeneric.getT());
    }
}
/*
大家好，加油！
dl
2
2
*/

泛型接口

在创建接口的时候对接口泛型

//MyInterface
package Demo0.Demo0_9;

/**
 * 泛型接口
 * 语法：接口名<T>
 * 注意：不能泛型常量
 * @author dl
 */
public interface MyInterface<T> {
    
    
    String name = "dl";
    T server(T t);
}
//MyInterfaceImpl_1
package Demo0.Demo0_9;

public class MyInterfaceImpl_1 implements MyInterface<String> {
    
    
    @Override
    public String server(String s) {
    
    
        System.out.println(s);
        return s;
    }
}
//MyInterfaceImpl_2
package Demo0.Demo0_9;

public class MyInterfaceImpl_2 implements MyInterface<Integer>{
    
    
    @Override
    public Integer server(Integer integer) {
    
    
        System.out.println(integer);
        return integer;
    }
}
//TestMyInterfaceImpl
package Demo0.Demo0_9;

public class TestMyInterfaceImpl {
    
    
    public static void main(String[] args) {
    
    
        MyInterfaceImpl_1 myInterfaceImpl_1 = new MyInterfaceImpl_1();
        myInterfaceImpl_1.server("XXX");
        MyInterfaceImpl_2 myInterfaceImpl_2 = new MyInterfaceImpl_2();
        myInterfaceImpl_2.server(2);
    }
}
/*
XXX
2
*/

对接口的实现类泛型

//MyInterface
package Demo0.Demo0_9;

/**
 * 泛型接口
 * 语法：接口名<T>
 * 注意：不能泛型常量
 * @author dl
 */
public interface MyInterface<T> {
    
    
    String name = "dl";
    T server(T t);
}
//MyInterfaceImpl
package Demo0.Demo0_9;

public class MyInterfaceImpl<T> implements MyInterface<T> {
    
    
    @Override
    public T server(T t) {
    
    
        System.out.println(t);
        return t;
    }
}
//TestMyInterfaceImpl
package Demo0.Demo0_9;

public class TestMyInterfaceImpl {
    
    
    public static void main(String[] args) {
    
    
        MyInterfaceImpl<String> stringMyInterface = new MyInterfaceImpl<>();
        stringMyInterface.server("XXX");
        MyInterfaceImpl<Integer> integerMyInterface = new MyInterfaceImpl<>();
        integerMyInterface.server(1);
    }
}
/*
XXX
1
*/

泛型方法

类型是由传递的数据所决定的；

//MyGenericMethod
package Demo0.Demo0_10;

/**
 * 泛型方法
 * 语法：<T> 返回值类型
 * @author dl
 */
public class MyGenericMethod {
    
    
    //泛型方法
    public <T> T show(T t) {
    
    
        System.out.println("泛型方法：" + t);
        return t;
    }
    public void haha() {
    
    
    }
}
//TestMyGenericMethod
package Demo0.Demo0_10;

public class TestMyGenericMethod {
    
    
    public static void main(String[] args) {
    
    
        MyGenericMethod myGenericMethod = new MyGenericMethod();
        myGenericMethod.show("XXX");
        myGenericMethod.show(2);
    }
}
/*
泛型方法：XXX
泛型方法：2
*/

泛型集合

概念： 参数化类型、类型安全的集合、强制集合元素的类型必须一致；

特点：

  • 编译的时候就可以检查，而非运行时抛出异常；
  • 访问时，不必类型转换（拆箱）；
  • 不同泛型之间引用不能相互赋值，泛型不存在多态；

类型转换异常

//Demo0_11
package Demo0.Demo0_11;

import java.util.ArrayList;

public class Demo0_11 {
    
    
    public static void main(String[] args) {
    
    
        ArrayList arrayList = new ArrayList();
        arrayList.add("dl");
        arrayList.add("cll");
        arrayList.add(1);
        arrayList.add(2);
        for(Object object : arrayList) {
    
    
        /*不知道集合原来的类型 不能特指*/
            String str = (String) object;
            System.out.println(str);
        }
    }
}

解决类型转换异常

采用泛型集合来避免类型转换错误的问题，在创建集合对象的时候，就已经确定了集合中的元素的类型；

//Student
package Demo0.Demo0_11;

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 +
                '}';
    }
}
//Demo0_11
package Demo0.Demo0_11;

import Demo0.Demo0_2.Student;

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

public class Demo0_11 {
    
    
    public static void main(String[] args) {
    
    
        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("dl");
        arrayList.add("cll");
        for(String string : arrayList) {
    
    
            System.out.println(string);
        }

        ArrayList<Student> students = new ArrayList<Student>();
        Student s1 = new Student("dl", 21);
        Student s2 = new Student("cll", 21);
        Student s3 = new Student("dc", 21);
        students.add(s1);
        students.add(s2);
        students.add(s3);
        Iterator<Student> it = students.iterator();
        while(it.hasNext()) {
    
    
            Student std = it.next();
            System.out.println(std.getAge() + " : " + std.getName());
        }
    }
}
/*
dl
cll
21 : dl
21 : cll
21 : dc
*/

5.Set接口与实现类

Set子接口

特点： 无序、无下标、元素不可以重复；

方法： 全部继承自 Collection 中的方法；

//Demo1_1
package Demo1.Demo1_1;

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

/**
 * Set接口的使用
 * 特点：无序、无下标。不能重复
 * @author dl
 */
public class Demo1_1 {
    
    
    public static void main(String[] args) {
    
    
        //创建集合
        Set<String> set = new HashSet<>();
        //1.添加数据
        set.add("小米");
        set.add("华为");
        set.add("苹果");
        set.add("香蕉");
        set.add("华为");
        System.out.println("添加元素的个数：" + set.size());
        System.out.println(set.toString());
        //2.删除
        set.remove("华为");
        System.out.println(set.toString());
//        set.clear();
        //3.遍历
            //增强for遍历
        for(String string : set) {
    
    
            System.out.println(string);
        }
            //使用迭代器Iterator
        Iterator<String> it = set.iterator();
        while(it.hasNext()) {
    
    
            System.out.println(it.next());
        }
        //4.判断
        System.out.println(set.contains("华为"));
        System.out.println(set.isEmpty());
    }
}
/*
添加元素的个数：4
[苹果, 香蕉, 华为, 小米]
[苹果, 香蕉, 小米]
苹果
香蕉
小米
苹果
香蕉
小米
false
false
*/

HashSet【重点】

  • 基于HashCode，计算元素存储位置，实现元素不重复；
  • 当存入元素的哈希码相同时，会调用equals进行确认，如果结果为true，则拒绝后者存入；
//Demo1_2_1
package Demo1.Demo1_2;

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

/**
 * HashSet集合的使用
 * 存储结构：哈希表（数组+链表+红黑树）
 * @author dl
 */
public class Demo1_2 {
    
    
    public static void main(String[] args) {
    
    
        //1.新建集合
        HashSet<String> hashSet = new HashSet<>();
        //2.添加元素
        hashSet.add("小明");
        hashSet.add("张三");
        hashSet.add("李四");
        hashSet.add("XXX");
        hashSet.add("XXX");
        System.out.println("元素的个数：" + hashSet.size());
        System.out.println(hashSet.toString());
        //2.删除
        hashSet.remove("XXX");
        System.out.println("输出后的元素：" + hashSet.size());
        System.out.println(hashSet.toString());
//        hashSet.clear();
        //3.遍历
            //增强for
        for(String string : hashSet) {
    
    
            System.out.println(string);
        }
            //使用迭代器Iterator
        Iterator<String> it = hashSet.iterator();
        while(it.hasNext()) {
    
    
            System.out.println(it.next());
        }
        //4.判断
        System.out.println(hashSet.contains("XXX"));
        System.out.println(hashSet.isEmpty());
    }
}
/*
元素的个数：4
[李四, 张三, 小明, XXX]
输出后的元素：3
[李四, 张三, 小明]
李四
张三
小明
李四
张三
小明
false
false
*/

存储过程：
（1）根据hashcode计算保存的位置，如果此位置为空，那么直接保存，要是此位置不为空，则执行第二步；
（2）再执行equals，如果equals方法为true，则认为是重复，否则，形成链表；

//Person
package Demo1.Demo1_2;

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

    @Override
    public int hashCode() {
    
    
        int num1 = this.name.hashCode();
        int num2 = this.age;
        return num1 + num2;
    }

    @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.name) && this.age == p.age) {
    
    
                return true;
            }
        }
        return false;
    }
}
//Demo1_2_2
package Demo1.Demo1_2;

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

/**
 * HashSet的使用
 * 存储结构：哈希表
 * @author dl
 */
public class Demo1_2_2 {
    
    
    public static void main(String[] args) {
    
    
        //1.创建集合
        HashSet<Person> stringHashSet = new HashSet<>();
        //2.添加数据
        Person p1 = new Person("小明", 21);
        Person p2 = new Person("小丁", 20);
        Person p3 = new Person("小柴", 21);
        stringHashSet.add(p1);
        stringHashSet.add(p2);
        stringHashSet.add(p3);
        stringHashSet.add(new Person("小丁", 20));
        /*这样添加的元素和p2添加的元素都可以添加进去 为了避免这种情况 可以重写 hashcode方法来避免这种情况*/
        System.out.println("元素个数：" + stringHashSet.size());
        System.out.println(stringHashSet.toString());
        //2.删除元素
        stringHashSet.remove(p1);
        stringHashSet.remove(new Person("小丁", 20));//可以删掉 因为重写了hashcode和equals
        System.out.println("删除之后：" + stringHashSet.size());
        System.out.println(stringHashSet.toString());
        //3.遍历
            //增强for遍历
        for(Person person : stringHashSet) {
    
    
            System.out.println(person);
        }
            //使用迭代器Iterator
        Iterator<Person> it = stringHashSet.iterator();
        while(it.hasNext()) {
    
    
            System.out.println(it.next().getName());
        }
        //4.判断
        System.out.println(stringHashSet.contains(new Person("小柴", 21)));//true 因为重写了hashcode和equals
    }
}
/*
元素个数：3
[Person{name='小柴', age=21}, Person{name='小丁', age=20}, Person{name='小明', age=21}]
删除之后：1
[Person{name='小柴', age=21}]
Person{name='小柴', age=21}
Person{name='小柴', age=21}
true
*/

重写hashcode和equals的注意点

public static int hashCode(Object a[]) {
    
    
    if (a == null)
        return 0;

    int result = 1;

    for (Object element : a)
        result = 31 * result + (element == null ? 0 : element.hashCode());

    return result;
}

这里是31的原因：

（1）31是质数，可以减少散列冲突（使得计算的哈希值尽量不一样）；
（2）可以提高执行效率（31*i = (i << 5) - i）；

TreeSet

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

基本操作：

//Demo1_3
package Demo1.Demo1_3;

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

/**
 * TreeSet的使用
 * 存储结构：红黑树
 * @author dl
 */
public class Demo1_3 {
    
    
    public static void main(String[] args) {
    
    
        //创建集合
        TreeSet<String> treeSet = new TreeSet<>();
        //1.添加元素
        treeSet.add("aaa");
        treeSet.add("fff");
        treeSet.add("ccc");
        treeSet.add("ccc");
        System.out.println("元素的个数：" + treeSet.size());
        System.out.println(treeSet.toString());
        //2.删除
        treeSet.remove("ccc");
        System.out.println("删除之后：" + treeSet.size());
        System.out.println(treeSet.toString());
        //3.遍历
            //增强for
        for(String string : treeSet) {
    
    
            System.out.println(string);
        }
            //使用迭代器
        Iterator<String> it = treeSet.iterator();
        while(it.hasNext()) {
    
    
            System.out.println(it.next());
        }
        //4.判断
        System.out.println(treeSet.contains("aaa"));
        System.out.println(treeSet.isEmpty());
    }
}
/*
元素的个数：3
[aaa, ccc, fff]
删除之后：2
[aaa, fff]
aaa
fff
aaa
fff
true
false
*/

对象是类的操作：

//Person
package Demo1.Demo1_3;

import java.util.Comparator;

public class Person implements Comparable<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 String toString() {
    
    
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    /*先按照姓名来比家 再按照年龄来比较*/
    @Override
    public int compareTo(Person o) {
    
    
        int num1 = this.getName().compareTo(o.getName());
        int num2 = this.getAge() - o.getAge();
        return num1 == 0 ? num2 : num1;
    }
}
//Demo1_3_2
package Demo1.Demo1_3;

import java.util.TreeSet;

/**
 * TreeSet保存数据
 * 存储结构：红黑树
 * 元素必须实现Comparable接口 自定义比较方式
 * CompareTo方法返回值为 0 则认为是重复元素
 * @author dl
 */
public class Demo1_3_2 {
    
    
    public static void main(String[] args) {
    
    
        //创建集合
        TreeSet<Person> treeSet = new TreeSet<>();
        //1.添加元素
        Person p1 = new Person("dl", 21);
        Person p2 = new Person("dl", 20);
        Person p3 = new Person("cll", 21);
        Person p4 = new Person("dc", 20);
        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(p2);
        treeSet.remove(new Person("dl", 21));
        /*也可以删除 我们重写的compareTo方法比较的是name和age*/

        System.out.println("元素的个数：" + treeSet.size());
        System.out.println(treeSet.toString());
        //3.遍历
            //增强for
            //使用迭代器Iterator
        //4.判断
    }
}
/*
元素的个数：4
[Person{name='cll', age=21}, Person{name='dc', age=20}, Person{name='dl', age=20}, Person{name='dl', age=21}]
元素的个数：2
[Person{name='cll', age=21}, Person{name='dc', age=20}]
*/

Comparator接口：

可以不用实现上述的 Comparator 接口；

//Person
package Demo1.Demo1_4;

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

    @Override
    public String toString() {
    
    
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + 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;
    }
}
//Demo1_4
package Demo1.Demo1_4;

import Demo1.Demo1_3.Person;

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

/**
 * TreeSet集合的使用
 * Comparator：实现定制比较（比较器）
 * Comparable：可比较的
 * @author dl
 */
public class Demo1_4 {
    
    
    public static void main(String[] args) {
    
    
        //创建集合 并指定比较规则
        TreeSet<Person> treeSet = new TreeSet<>(new Comparator<Person>() {
    
    
            @Override
            public int compare(Person o1, Person o2) {
    
    
                int num1 = o1.getAge() - o2.getAge();
                int num2 = o1.getName().compareTo(o2.getName());
                return num1 == 0 ? num2 : num1;
            }
        });
        //1.添加元素
        Person p1 = new Person("dl", 21);
        Person p2 = new Person("dl", 20);
        Person p3 = new Person("cll", 21);
        Person p4 = new Person("dc", 20);
        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(p2);
        treeSet.remove(new Person("dl", 21));
        /*也可以删除 我们重写的compareTo方法比较的是name和age*/

        System.out.println("元素的个数：" + treeSet.size());
        System.out.println(treeSet.toString());
        //3.遍历
            //增强for
            //使用迭代器Iterator
        //4.判断
    }
}
/*
元素的个数：4
[Person{name='dc', age=20}, Person{name='dl', age=20}, Person{name='cll', age=21}, Person{name='dl', age=21}]
元素的个数：2
[Person{name='dc', age=20}, Person{name='cll', age=21}]
*/

案例

使用treeSet 实现字符串长度的比较，若字符串的长相同，则按照默认字典排序

//Demo1_5
package Demo1.Demo1_5;

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

/**
 * treeSet的使用
 * comparator自制
 * @author dl
 */
public class Demo1_5 {
    
    
    public static void main(String[] args) {
    
    
        TreeSet<String> treeSet = new TreeSet<>(new Comparator<String>() {
    
    
            @Override
            public int compare(String o1, String o2) {
    
    
                int num1 = o1.length() - o2.length();
                int num2 = o1.compareTo(o2);
                return num1 == 0 ? num2 : num1;
            }
        });
        treeSet.add("abcd");
        treeSet.add("abc");
        treeSet.add("acc");
        treeSet.add("ccc");
        treeSet.add("cccdddd");
        Iterator<String> it = treeSet.iterator();
        while(it.hasNext()) {
    
    
            System.out.println(it.next());
        }
    }
}
/*
abc
acc
ccc
abcd
cccdddd
*/

6.Map接口与实现类

Map体系集合


Map接口的特点：

  • 用于存储任意的键对值（Key- Value）；
  • 键：无序、无下标、不允许重复（唯一）；
  • 值：无序、无下标、允许重复；

Map父接口

特点： 存储一对数据（Key-Value），无序，无下标，键不可以重复，值可以重复；

方法：
V put(K key, V value)//将对象存入到集合当中，关联键值，key重复则覆盖原值；
Object get(Object key)//根据键获取对应的值；
Set<K>//返回所有key；
Collection<V> values()//返回包含所有值的Collection集合；
Set<Map.Entry(K, V)>//键值匹配的Set集合；

注意： entrySet 的效率要高于 keySet；

//Demo2_1
package Demo2;

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

/**
 * Map接口的使用
 * 特点：使用的键值对，key 无序、无下标、不可以重复 value 无序、无下标、可以重复 无序
 * @author dl
 */
public class Demo2_1 {
    
    
    public static void main(String[] args) {
    
    
        //创建Map集合
        Map<Integer, String> map = new HashMap<>();
        //1.添加元素
        map.put(1, "dl");
        map.put(2, "cll");
        map.put(3, "dc");
        map.put(3, "cn");
        map.put(4, "dc");
        System.out.println("元素个数：" + map.size());
        System.out.println(map.toString());
        System.out.println("=========");
        //2.删除元素
        map.remove(3);
        System.out.println("删除之后：" + map.size());
        System.out.println(map.toString());
        System.out.println("=========");
        //遍历
            //使用keySet
        Set<Integer> keyset = map.keySet();
        for(Integer integer : keyset) {
    
    
            System.out.println(integer + " " + map.get(integer));
        }
        System.out.println("=========");
            //使用entrySet()方法
        Set<Map.Entry<Integer, String>> entrySet = map.entrySet();
        for(Map.Entry<Integer, String> entries : entrySet) {
    
    
            System.out.println(entries.getKey() + " " + entries.getValue());
        }
        System.out.println("=========");
            //使用迭代器
        Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator();
        while(it.hasNext()) {
    
    
            Map.Entry<Integer, String> str = (Map.Entry<Integer, String >) it.next();
            System.out.println(str.getKey() + " " + str.getValue());
        }
        System.out.println("=========");
        //判断
        System.out.println(map.containsValue("dl"));
    }
}
/*
元素个数：4
{1=dl, 2=cll, 3=cn, 4=dc}
=========
删除之后：3
{1=dl, 2=cll, 4=dc}
=========
1 dl
2 cll
4 dc
=========
1 dl
2 cll
4 dc
=========
1 dl
2 cll
4 dc
=========
true
*/

Map集合的实现类

HashMap【重点】

JDK1.2版本，线程不安全，运效率快，允许用null，作为key或者 是value；

//Student
package Demo2.Demo2_2;

import java.util.Objects;

public class Student {
    
    
    private String name;
    private String iphone;

    public Student() {
    
    
    }

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

    public String getName() {
    
    
        return name;
    }

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

    public String getIphone() {
    
    
        return iphone;
    }

    public void setIphone(String iphone) {
    
    
        this.iphone = iphone;
    }

    @Override
    public boolean equals(Object o) {
    
    
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return name.equals(student.name) && iphone.equals(student.iphone);
    }

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

    @Override
    public String toString() {
    
    
        return "Student{" +
                "name='" + name + '\'' +
                ", iphone='" + iphone + '\'' +
                '}';
    }
}
//Demo2_2
package Demo2.Demo2_2;

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

/**
 * HashMap的使用
 * 存储结构：哈希表（数组+链表+红黑树）
 * @author dl
 */
public class Demo2_2 {
    
    
    public static void main(String[] args) {
    
    
        //创建集合
        HashMap<Student, String> hashMap = new HashMap<>();
        //1.添加元素
        Student p1 = new Student("dl", "1934010");
        Student p2 = new Student("cll", "2034010");
        Student p3 = new Student("dc", "2134010");
        hashMap.put(p1, "大三");
        hashMap.put(p2, "大二");
        hashMap.put(p3, "大一");
        hashMap.put(new Student("dl", "1934010"), "大三");
        /*为了让这个加不进来，可以重写hashcode和equals方法*/
        System.out.println("元素个数：" + hashMap.size());
        System.out.println(hashMap.toString());
        System.out.println("================");
        //2.删除
        hashMap.remove(p3);
        System.out.println("元素个数：" + hashMap.size());
        System.out.println(hashMap.toString());
        System.out.println("================");
        //3.遍历
            //使用keySet
        Set<Student> keyset = hashMap.keySet();
        for(Student key : keyset) {
    
    
            System.out.println(key.getName() + " " + key.getIphone());
        }
        System.out.println("================");
        //使用entrySet
        Set<Map.Entry<Student, String>> entries = hashMap.entrySet();
        for(Map.Entry<Student, String> entryset : entries) {
    
    
            System.out.println(entryset.getKey().getName() + " " + entryset.getKey().getIphone() + " " + entryset.getValue());
        }
        System.out.println("================");
        //使用迭代器
        Iterator<Map.Entry<Student, String>> it = hashMap.entrySet().iterator();
        while(it.hasNext()) {
    
    
            Map.Entry<Student, String> str = (Map.Entry<Student, String>) it.next();
            System.out.println(str.getKey().getName() + " " + str.getKey().getIphone() + " " + str.getValue());
        }
        System.out.println("================");
        //判断
        System.out.println(hashMap.containsKey(p2));
        System.out.println(hashMap.containsKey(new Student("cll", "2034010")));
    }
}
/*
元素个数：3
{Student{name='dl', iphone='1934010'}=大三, Student{name='cll', iphone='2034010'}=大二, Student{name='dc', iphone='2134010'}=大一}
================
元素个数：2
{Student{name='dl', iphone='1934010'}=大三, Student{name='cll', iphone='2034010'}=大二}
================
dl 1934010
cll 2034010
================
dl 1934010 大三
cll 2034010 大二
================
dl 1934010 大三
cll 2034010 大二
================
true
true
*/

源码分析：


刚创建hashmap的时候，没有添加任何的元素，table=null，size=0，目的是为了节省空间；

Hashtable

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

Properties

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

TreeMap
实现了SortedMap接口（是Map的子接口），可以对key自动排序；

//Student
package Demo2.Demo2_3;

import java.util.Objects;

public class Student implements Comparable<Student>{
    
    
    private String name;
    private int age;

    @Override
    public int compareTo(Student o) {
    
    
        int num1 = this.name.compareTo(o.name);
        int num2 = this.age - o.age;
        return num2 == 0 ? num1 : num2;
    }

    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 +
                '}';
    }
}
//Demo2_3_1
package Demo2.Demo2_3;

import java.util.TreeMap;

/**
 * TreeMap的使用
 * 存储结构：红黑树
 * @author dl
 */
public class Demo2_3_1 {
    
    
    public static void main(String[] args) {
    
    
        //新建集合
        TreeMap<Student, String> treemap = new TreeMap<>();
        //1.添加元素
        Student p1 = new Student("dl", 1934010);
        Student p2 = new Student("cll", 2034010);
        Student p3 = new Student("dc", 2134010);
        treemap.put(p1, "大三");
        treemap.put(p2, "大二");
        treemap.put(p3, "大一");
        treemap.put(new Student("dc", 2134010), "大一");
        System.out.println("元素个数：" + treemap.size());
        System.out.println(treemap.toString());
        System.out.println("================");
        //删除
        treemap.remove(p1);
        treemap.remove(new Student("cll", 2034010), "大二");
        System.out.println("元素个数：" + treemap.size());
        System.out.println(treemap.toString());
        System.out.println("================");
        //遍历
            //keySet遍历
            //entrySet遍历
        //判断
        System.out.println(treemap.containsKey(new Student("dc", 2134010)));
    }
}
/*
元素个数：3
{Student{name='dl', age=1934010}=大三, Student{name='cll', age=2034010}=大二, Student{name='dc', age=2134010}=大一}
================
元素个数：1
{Student{name='dc', age=2134010}=大一}
================
true
*/

使用自制的comparator作比较；

//Student
package Demo2.Demo2_3;

import java.util.Objects;

public class Student implements Comparable<Student>{
    
    
    private String name;
    private int age;

    @Override
    public int compareTo(Student o) {
    
    
        int num1 = this.name.compareTo(o.name);
        int num2 = this.age - o.age;
        return num2 == 0 ? num1 : num2;
    }

    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 +
                '}';
    }
}
//Demo2_3_2
package Demo2.Demo2_3;

import javax.swing.text.StyledDocument;
import java.util.Comparator;
import java.util.TreeMap;

/**
 * comparator 实现定制比较
 */
public class Demo2_3_2 {
    
    
    public static void main(String[] args) {
    
    
        TreeMap<Student, String> treemap = new TreeMap<>(new Comparator<Student>() {
    
    
            @Override
            public int compare(Student o1, Student o2) {
    
    
                int num1 = o1.getName().compareTo(o2.getName());
                int num2 = o1.getAge() - o2.getAge();
                return num2 == 0 ? num1 : num2;
            }
        });
        //1.添加元素
        Student p1 = new Student("dl", 1934010);
        Student p2 = new Student("cll", 2034010);
        Student p3 = new Student("dc", 2134010);
        treemap.put(p1, "大三");
        treemap.put(p2, "大二");
        treemap.put(p3, "大一");
        treemap.put(new Student("dc", 2134010), "大四");
        System.out.println("元素个数：" + treemap.size());
        System.out.println(treemap.toString());
        System.out.println("================");
        //删除
        treemap.remove(p1);
        treemap.remove(new Student("cll", 2034010), "大二");
        System.out.println("元素个数：" + treemap.size());
        System.out.println(treemap.toString());
        System.out.println("================");
        //遍历
        //判断
    }
}
/*
元素个数：3
{Student{name='dl', age=1934010}=大三, Student{name='cll', age=2034010}=大二, Student{name='dc', age=2134010}=大四}
================
元素个数：1
{Student{name='dc', age=2134010}=大四}
================
*/

7.Collections工具类

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

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

重点是把集合转成数组和把数组转成集合；

//Demo2_4
package Demo2.Demo2_4;

import java.util.*;

/**
 * Collections 工具类的使用
 * @author dl
 */
public class Demo2_4 {
    
    
    public static void main(String[] args) {
    
    
        List<Integer> list = new ArrayList<>();
        list.add(20);
        list.add(5);
        list.add(12);
        list.add(30);
        list.add(6);
        //sort排序
        System.out.println(list.toString());
        Collections.sort(list);
        System.out.println(list.toString());
        //binarySearch二分查找
        System.out.println(Collections.binarySearch(list, 12));
        //copy复制
        List<Integer> dest = new ArrayList<>();
        for(int i = 0; i < list.size(); i ++) {
    
    
            dest.add(null);
        }
        Collections.copy(dest, list);
        /*需要注意的是 dest 和 list 大小必须一致 才能复制成功*/

        System.out.println(dest .toString());
        //reverse实现反转
        Collections.reverse(list);
        System.out.println(list.toString());
        //shuffle 随机打乱
        Collections.shuffle(list);
        System.out.println(list.toString());

        //***补充：list 转成数组
        Integer[] arr = list.toArray(new Integer[0]);
        System.out.println(arr.length);
        System.out.println(Arrays.toString(arr));
        //***补充：数组转成集合
        Integer[] ar = new Integer[10];
        for(int i = 0; i < 10; i ++) {
    
    
            ar[i] = i;
        }
        List<Integer> li = Arrays.asList(ar);
        /*此时得到的集合是受限制的 不能够进行添加和删除的操作*/

        System.out.println(li.toString());
    }
}
/*
[20, 5, 12, 30, 6]
[5, 6, 12, 20, 30]
2
[5, 6, 12, 20, 30]
[30, 20, 12, 6, 5]
[20, 6, 30, 12, 5]
5
[20, 6, 30, 12, 5]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
*/

8.集合总结

猜你喜欢

转载自blog.csdn.net/qq_45459526/article/details/123989014
今日推荐
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
周排行
Java基础复习_day13_Collection集合
2018.11.16 c语言学习经验
且看Java内置四大核心函数式接口
小程序云开发中数据库的数据分段和显示图片
python的函数
Web-JS进阶
【干货】C++常用代码积累笔记大全
Spring的ioc操作 与 IOC底层原理
构建之法20191121-11 Scrum立会报告+燃尽图 07
Spring boot之Hello World访问404
每日归档
更多
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022