Java_集合框架

课件下载

1.集合的概念

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

和数组的区别

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

位置java.uti.*

2.Collection接口

Collection体系集合

Java_集合框架_第1张图片
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
无需开辟连续的空间,查询慢,增删快;
Java_集合框架_第2张图片

4.泛型和工具类

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

常见的形式:泛型类、泛型接口、泛型方法;

语法: T 表示类型占位符,表示一种引用类型;

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

泛型类

注意: 泛型只能是引用类型,不同的泛型对象之间不能相互赋值;

//MyGeneric
package Demo0.Demo0_8;

/**
 * 泛型类的使用
 * 语法:类名
 *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;

/**
 * 泛型接口
 * 语法:接口名
 * 注意:不能泛型常量
 * @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;

/**
 * 泛型接口
 * 语法:接口名
 * 注意:不能泛型常量
 * @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;

/**
 * 泛型方法
 * 语法: 返回值类型
 * @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);
        }
    }
}

Java_集合框架_第3张图片

解决类型转换异常

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

//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体系集合

Java_集合框架_第4张图片
Map接口的特点:

  • 用于存储任意的键对值(Key- Value);
  • 键:无序、无下标、不允许重复(唯一);
  • 值:无序、无下标、允许重复;

Map父接口

特点: 存储一对数据(Key-Value),无序,无下标,键不可以重复,值可以重复;

方法:
V put(K key, V value)//将对象存入到集合当中,关联键值,key重复则覆盖原值;
Object get(Object key)//根据键获取对应的值;
Set//返回所有key;
Collection values()//返回包含所有值的Collection集合;
Set//键值匹配的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
*/

源码分析:

Java_集合框架_第5张图片
刚创建hashmap的时候,没有添加任何的元素,table=null,size=0,目的是为了节省空间;

Java_集合框架_第6张图片

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 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.集合总结

Java_集合框架_第7张图片

你可能感兴趣的:(Java,java,开发语言,后端)