第二十六讲——集合

第二十六讲——集合

目录

1——集合概念

  • 概念； 对象的容器 定义了对多个对象进行操作的常用方法(add.delete.update.query)。有着可实现数组的功能。

  • 和数组的区别；

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

  • 集合的类全在 位置； java.util.* 使用集合时要导入这个位置

2——Collection体系

Collection 父接口

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

  • 方法；

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

点击跳往 Api—帮助文档

Collection的使用(1) type

Application

package Test.Test06;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**
 *Collection 接口的使用
 * (1)添加元素  add
 * (2)删除     remove 移除  clear 清除
 * (3)遍历     Iterator 迭代器
 * (4)判断     contains
 * @author 夏天的风
 * */
public class Test01 {
    public static void main(String[]args){
        //创建集合
        //ArrayList -> List -> collection  List 继承了collection相当于new了collection
        Collection collection = new ArrayList();
        //父类的引用指向子类
     // (1)添加元素
        collection.add("苹果");
        collection.add("西瓜");
        collection.add("榴莲");
        System.out.println("元素个数;  "+collection.size());
        System.out.println(collection.toString());
        System.out.println("====  remove  =============");
     //(2)删除
        //collection.remove("榴莲");  remove 移除
        //collection.clear();  clear 清除
        System.out.println("删除之后;  "+collection.size());
     //(3)遍历
        System.out.println("====  遍历  =============");
        // -增强for 遍历  for是不可以的 因为 for需要下标  而增强for是不需要下标的
        for (Object object :collection){
            System.out.print(object+"\t");
        }
        System.out.println();
        // -使用迭代器(迭代器就是专门用来遍历(迭代)集合的方式)
        Iterator it = collection.iterator(); //Iterator是一个接口 实现的原理附图 可以在迭代中用remove删除但不能用clear清除 （并且 remove 删除的是对象并不是String 因此可以中正常打印String 相当于一个 打印并删除的操作）
        while(it.hasNext()){
            String s =(String)it.next();
            System.out.print(s+"\t");
            //it.remove();//边遍历边删除的意思   ps;网友说remove方法会删除上次next返回的值
        }
        System.out.println("\n"+"元素个数;  "+collection.size());
     //(4)判断 集合中有没有该元素
        System.out.println("====  contains  =============");
        System.out.println(collection.contains("西瓜"));
        System.out.println(collection.contains("苹果"));
        System.out.println(collection.isEmpty());//
    }
}

Print

F:\Application\out\production\Application Test.Test06.Test01
元素个数;  3
[苹果, 西瓜, 榴莲]
====  remove  =============
删除之后;  3
====  遍历  =============
苹果	西瓜	榴莲	
苹果	西瓜	榴莲	
元素个数;  3
====  contains  =============
true
true
false

Process finished with exit code 0

Collection的使用(2) object

Class

jpackage Test.Test07;

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

    public Student() {
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

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

Application

package Test.Test07;
import java.util.Collection;
import java.util.ArrayList;
import java.util.Iterator;
/**
 * collection 的使用(2)
 * 保存学生信息
 * @author 夏天的风
 * */
public class Demo01 {
    public static void main(String[]args){
         // 新建集合对象  collection
        Collection collection = new ArrayList();//LIst 可重复
        // 新建 学生对象
        Student s1 = new Student(12,"张三");
        Student s2 = new Student(52,"张三疯");
        Student s3 = new Student(82,"李明");
        // 1.添加数据
        collection.add(s1);
        collection.add(s2);
        collection.add(s3);//collection.add(s3); 可重复
        System.out.println("元素个数; "+collection.size());
        System.out.println(collection.toString());
        System.out.println("==========================删除 清除 ==================");
        // 2.删除 remove  clear
        collection.remove(s3);//2
        collection.remove(new Student(12,"张三"));// 删除不了 对象中的张三 因为它不在对象中
        System.out.println("删除之后——元素个数; "+collection.size());
        //collection.clear();
        //System.out.println("清除之后——元素个数; "+collection.size());
        System.out.println("==========================遍历 ==================");
        // 3.遍历  增强for  迭代器 iterator
        for (Object o : collection) {
            System.out.println(o);
        } // 视频中用了强制转换 因为以上是 Object 类型不是Student类型 所以要强转
        System.out.println("=============强转后效果一样================");
        for (Object o : collection) {
           Student s = (Student)o;
            System.out.println(s.toString());
        }
        System.out.println("=============Iterator================");
       // Iterator  hasNext()  next() remove()  其他方法都不能用
        Iterator it = collection.iterator();
        while(it.hasNext()){
            Student s = (Student)it.next();
            System.out.println(s.toString());
        }
        // 4.判断是否包含 contains isEmpty 是否为null
        System.out.println(collection.contains(s1));
        System.out.println(collection.isEmpty());
    }
}

Print

F:\Application\out\production\Application Test.Test07.Demo01
元素个数; 3
[Student{age=12, name='张三'}, Student{age=52, name='张三疯'}, Student{age=82, name='李明'}]
==========================删除 清除 ==================
删除之后——元素个数; 2
==========================遍历 ==================
Student{age=12, name='张三'}
Student{age=52, name='张三疯'}
=============强转后效果一样================
Student{age=12, name='张三'}
Student{age=52, name='张三疯'}
=============Iterator================
Student{age=12, name='张三'}
Student{age=52, name='张三疯'}
true
false

Process finished with exit code 0

3——List(序列) 接口

  • 特点； 有序，有下标，元素可以重复

  • 方法；

    • void add(int index,Object o); // 在 index 位置插入对象 o

    • boolean addAll(int index, Collection c); //将集合中的元素添加到此集合中 index 的位置

    • Object get(int index); // 返回集合中指定 index 位置的元素

    • List subList(int fromIndex,int toIndex); //返回 fromIndex 和 toIndex 之间的集合元素 含头不含尾

List(序列) 接口的使用(1) object

Application

package Test.Test08;
import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;
import java.util.ListIterator;

/**
 * List的使用  (1)
 * @author 夏天的风
 * */
public class Demo01 {
    public static void main(String[] args) {
        // 创建 List 对象
        List list = new ArrayList();
        // 1. 添加元素
        list.add("苹果");
        list.add("华为");
        list.add("小米");
        System.out.println(list.size());
        System.out.println(list.toString());
        System.out.println("==============================");
        // 2. 删除元素 remove clear
        list.remove(0);// List 是有序的所以用 index 下标进行删除
        //list.clear();
        System.out.println("删除之后; "+list.size());
        System.out.println(list.toString());
        System.out.println("=============for 遍历=================");
        // 3. 遍历 因为它继承的 collection 所以也能用增强for和 iterator 遍历 不仅如此 因为它有下标还能用for
        // 3.1 for 遍历
        for (int i = 0; i < list.size(); i++) {
            // System.out.println(list.get(i)); 这显示的是对象 如果要显示基本类型的话需要强制转换
            String s = (String)list.get(i);
            System.out.print(s+"\t");
        }
        System.out.println();
        // 3.2 增强for 遍历
        System.out.println("=============增强for 遍历=================");
        for (Object o : list) {
            // System.out.println(o);  这显示的是对象 如果要显示基本类型的话需要强制转换
            String s = (String)o;
            System.out.print(s+"\t");
        }
        System.out.println();
        // 3.3 iterator 遍历
        System.out.println("=============iterator 遍历=================");
        Iterator it = list.iterator();
        while(it.hasNext()){
            System.out.print(it.next()+"\t");
        }
        System.out.println();
        // 3.4 列表迭代器 遍历 和collection 中 iterator 的区别，listIterator可以向前向后遍历，添加，删除，修改元素。
        System.out.println("=============listIterator 遍历=================");
        ListIterator lit = list.listIterator();
        System.out.println( "listIterator 从前往后打印");
        while(lit.hasNext()){
            System.out.print(lit.nextIndex()+":"+lit.next()+"\t");
        }
        System.out.println();
        //在一组对象上 可以想象有一个指针 当指针在前时，可以从前往后，要实现从后往前，那就得把指针移到最后，前面打印最后的元素时已经移到最后了
        System.out.println( "listIterator 从后往前打印");
        while(lit.hasPrevious()){
            System.out.print(lit.previousIndex()+":"+lit.previous()+"\t");
        }
        System.out.println();
        // 4. 判断
        System.out.println("==============================");
        System.out.println(list.contains("苹果"));
        System.out.println(list.isEmpty());
        // 5. 获取位置
        System.out.println("==============================");
        System.out.println(list.indexOf("华为"));
    }
}

Print

F:\Application\out\production\Application Test.Test08.Demo01
3
[苹果, 华为, 小米]
==============================
删除之后; 2
[华为, 小米]
=============for 遍历=================
华为	小米	
=============增强for 遍历=================
华为	小米	
=============iterator 遍历=================
华为	小米	
=============listIterator 遍历=================
listIterator 从前往后打印
0:华为	1:小米	
listIterator 从后往前打印
1:小米	0:华为	
false
false
0

Process finished with exit code 0

List(序列) 接口的使用(2) type

Application

package Test.Test09;
import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;
/**
 *  List 的使用(2)
 * @author xxz
 * */
public class Test00 {
    public static void main(String[] args) {
     // 1. 创建集合
     List list = new ArrayList();
     // 2. 添加数字数据  在输入基本类型的时候 会自动装箱 变成包装类
        list.add(10);
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);
        System.out.println("元素个数; "+list.size());
        System.out.println(list.toString());
/*        // 3.0 删除
        list.remove(0); // 因为这是 list 是有序的 应该用 index 删除元素
        // 3.1 如果不想用下标删除元素  这里提供两种方法
        list.remove(new Integer(30));
        // 3.2
        list.remove((Object)40);
        System.out.println(list.toString());*/
        // 4. suList  返回子集合 含头不含尾
        List subList = list.subList(1,3);
        System.out.println(subList.toString());
    }
}

Print

F:\Application\out\production\Application Test.Test09.Test00
元素个数; 5
[10, 20, 30, 40, 50]
[20, 30]

Process finished with exit code 0

4——List实现类

  • ArrayList【重点】
    • 数组结构实现，查询快，增删慢
    • 运行效率快，线程不安全
  • Vector；
    • 数组结构实现，查询快，增删慢
    • 运行效率快，线程安全
  • LinkedList；（链表其实是一个引用关系支持着他们遍历的过程）
    • 链表结构实现，增删快，查询慢

Class

package Test.Test10;

import java.util.Objects;

public class Student {

    private int age;
    private String name;

    public Student() {
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
    // 视频中说 打 equals+ Enter 就能自动重写方法 然而并没有 我手敲的
    //注意要有重写标志才是重写
    public boolean equals(Object obj) {
        // 1. 判断是不是同一个对象
        if (this == obj) {// 比较 对象地址 不会有错
            return true;
        }
        // 2. 判断是否为 null
        if (obj == null) {
            return false;
        }
        // 3. 判断是否是Student
        if (obj instanceof Student) {
            Student s = (Student) obj; // 这里为什么要强转 我不知道
            // 4. 比较属性
            if (this.name.equals(s.getName()) && this.age == s.getAge()) {
                return true;
            }
        }
        // 5. 不满足条件
        return false;

    }
}

Application

package Test.Test10;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Collection;
public class Test01 {
    public static void main(String[] args) {
        // 实现在 remove() 中删除 new 的同属性 对象
        // 创建集合
        ArrayList arrayList = new ArrayList();
        // 1. 添加
        Student s1 = new Student(22,"刘德华");
        Student s2 = new Student(22,"梁朝伟");
        Student s3 = new Student(22,"郭富城");
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        arrayList.add(s3);// 可重复
        arrayList.remove(new Student(22,"刘德华")); // equals(this == obj)  真的删除了！！！
        System.out.println(arrayList.size());
    }
}

Print

F:\Application\out\production\Application Test.Test10.Test01
3

Process finished with exit code 0
  • 主菜

Class

package Test.Test10;

import java.util.Objects;

public class Student {

    private int age;
    private String name;

    public Student() {
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
    // 视频中说 打 equals+ Enter 就能自动重写方法 然而并没有 我手敲的
    //注意要有重写标志才是重写
    public boolean equals(Object obj) {
        // 1. 判断是不是同一个对象
        if (this == obj) {// 比较 对象地址 不会有错
            return true;
        }
        // 2. 判断是否为 null
        if (obj == null) {
            return false;
        }
        // 3. 判断是否是Student
        if (obj instanceof Student) {
            Student s = (Student) obj; // 这里为什么要强转 我不知道
            // 4. 比较属性
            if (this.name.equals(s.getName()) && this.age == s.getAge()) {
                return true;
            }
        }
        // 5. 不满足条件
        return false;

    }
}

Application

package Test.Test10;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Collection;
import java.util.ListIterator;
/**
 * ArrayList 的使用
 *  储存结构; 数组 查找遍历快 增删慢
 *  特点; 和父类 List一样  有序 、有下标、可重复、
 *  @author 夏天的风
 * */

public class Application {
    public static void main(String[] args) {
        // 创建集合
        ArrayList arrayList = new ArrayList();
        // 1. 添加
        Student s1 = new Student(22,"刘德华");
        Student s2 = new Student(22,"梁朝伟");
        Student s3 = new Student(22,"郭富城");
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        arrayList.add(s3);// 可重复
        System.out.println(arrayList.size());
        System.out.println(arrayList.toString());
        p();
        // 2. 删除 remove() clear()
/*        arrayList.remove(s2);
        arrayList.remove(new Student(22,"刘德华")); // 重写 equals() 方法 用来删除同名的 new 对象
        System.out.println(arrayList.size());*/
        /*arrayList.clear();
        System.out.println(arrayList.size());
        p();*/
        // 3. 遍历
        System.out.println("=========遍历1.0——普通迭代器===========");
        Iterator it = arrayList.iterator();
        while(it.hasNext()){
            Student s = (Student)it.next();
            System.out.println(s.toString());
        }
        System.out.println("=========遍历2.0——列表迭代器===========");
        ListIterator l = arrayList.listIterator(); // 类名 大驼峰 方法名 小驼峰
        while(l.hasNext()){
            Student s = (Student)l.next();
            System.out.println(s.toString());
        }
        System.out.println("=========遍历3.0——列表迭代器逆序===========");
        while(l.hasPrevious()){
            Student s = (Student)l.previous();
            System.out.println(s.toString());
        }
        p();
        // 4. 判断
        System.out.println(arrayList.contains(s1));
        System.out.println(arrayList.contains(new Student(22,"梁朝伟")));
        System.out.println(arrayList.isEmpty());
        p();
        // 5. 查找
        System.out.println(arrayList.indexOf(s1)); // 返回所在的下标
        System.out.println(arrayList.indexOf(new Student(22,"梁朝伟")));
    }
    public static void p(){
        System.out.println("======================");
    }

}

Print

F:\Application\out\production\Application Test.Test10.Application
4
[Student{age=22, name='刘德华'}, Student{age=22, name='梁朝伟'}, Student{age=22, name='郭富城'}, Student{age=22, name='郭富城'}]
======================
=========遍历1.0——普通迭代器===========
Student{age=22, name='刘德华'}
Student{age=22, name='梁朝伟'}
Student{age=22, name='郭富城'}
Student{age=22, name='郭富城'}
=========遍历2.0——列表迭代器===========
Student{age=22, name='刘德华'}
Student{age=22, name='梁朝伟'}
Student{age=22, name='郭富城'}
Student{age=22, name='郭富城'}
=========遍历3.0——列表迭代器逆序===========
Student{age=22, name='郭富城'}
Student{age=22, name='郭富城'}
Student{age=22, name='梁朝伟'}
Student{age=22, name='刘德华'}
======================
true
true
false
======================
0
1

Process finished with exit code 0

ArrayList 的源码分析！！！

  •  默认容量  final int DEFAULT_CAPACITY = 10;
         注意; 如果没有添加任何元素时候 默认容量 0 ， 添加任意一个元素的时候，容量变10， 每次扩容是原来的 1.5倍
存放元素的数组 transient Object[] elementData;
size 实际元素个数

--

未完待续~

5——Vector 使用

Application

package Test.Test11;
import java.util.Enumeration;
import java.util.Vector;
/**
 * Demo Vector 集合的使用
 * 储存结构 ; 数组
 *
 *
 * @author 夏天的风
 * */
public class Test {
    public static void main(String[] args) {
        // 创建 集合
        Vector vector = new Vector();
        // 1. 添加元素
        vector.add("草莓");
        vector.add("西瓜");
        vector.add("蓝莓");
        vector.add("苹果");
        System.out.println(vector.size());
        p();
        // 2. 删除 三种方法
/*        vector.remove("草莓");
        vector.remove(2);
        vector.clear();
        System.out.println(vector.size());*/
        p();
        // 3. 遍历  增强for for Iterator()  elements()枚举
        Enumeration en = vector.elements();
        while(en.hasMoreElements()){
            String str = (String)en.nextElement();
            System.out.println(str);
        }
        p();
        // 4. 判断  contains() isEmpty()
        System.out.println(vector.contains("草莓"));
        System.out.println(vector.isEmpty());
        p();
        // 5. firstElement() 第一个、lastElement() 最后一个、elementAt()
        System.out.println(vector.elementAt(1));// 返回该下标的元素
        System.out.println(vector.firstElement());
        System.out.println(vector.lastElement());
    }
    public static void p(){
        System.out.println("=============================");
    }
}

Print

F:\Application\out\production\Application Test.Test11.Test
4
=============================
=============================
草莓
西瓜
蓝莓
苹果
=============================
true
false
=============================
西瓜
草莓
苹果

Process finished with exit code 0

LinkedList 的使用

  • LinkedList；
    • 链表结构实现 增删快 查询慢

Class

package Test.Test12;

import java.util.Objects;

public class Student {

    private int age;
    private String name;

    public Student() {
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
    // 视频中说 打 equals+ Enter 就能自动重写方法 然而并没有 我手敲的
    //注意要有重写标志才是重写
    public boolean equals(Object obj) {
        // 1. 判断是不是同一个对象
        if (this == obj) {// 比较 对象地址 不会有错
            return true;
        }
        // 2. 判断是否为 null
        if (obj == null) {
            return false;
        }
        // 3. 判断是否是Student
        if (obj instanceof Student) {
            Student s = (Student) obj; // 这里为什么要强转 我不知道
            // 4. 比较属性
            if (this.name.equals(s.getName()) && this.age == s.getAge()) {
                return true;
            }
        }
        // 5. 不满足条件
        return false;

    }
}

Application

package Test.Test12;
import java.util.LinkedList;
import java.util.Iterator;
import java.util.ListIterator;

/**
 * LinkedList 的使用
 * 存储结构; 双向链表 互相引用
 * @author 夏天的风
 * */
public class Application {
    public static void main(String[] args) {
        // 创建集合
        LinkedList linkedList = new LinkedList();

        // 1. 添加
        Student s1 = new Student(22,"刘德华");
        Student s2 = new Student(22,"梁朝伟");
        Student s3 = new Student(22,"郭富城");
        linkedList.add(s1);
        linkedList.add(s2);
        linkedList.add(s3);
        linkedList.add(s3); // 可重复
        System.out.println("元素个数; "+ linkedList.size());
        System.out.println(linkedList.toString());
        p();
        // 2. 删除
/*        linkedList.remove(s1);
        System.out.println(linkedList.size());
        linkedList.remove(new Student(22,"郭富城"));
        System.out.println(linkedList.size());*/
        p();
        // 3. 遍历 for 增强for
        System.out.println("==============for ==============");
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.get(i));
        }
        System.out.println("==============增强 for ==============");
        for (Object o : linkedList) {
            Student s = (Student) o;
            System.out.println(s.toString());
        }
        System.out.println("==============Iterator 迭代器 ==============");
        Iterator it = linkedList.iterator();
        while(it.hasNext()){
            Student s = (Student)it.next();
            System.out.println(s);
        }
        System.out.println("==============ListIterator 列表迭代器 ==============");
        ListIterator lit = linkedList.listIterator();
        while(lit.hasNext()){
            Student s = (Student)lit.next();
            System.out.println(s);
        }
        System.out.println("==============ListIterator 列表迭代器 逆向==============");
        while(lit.hasPrevious()){
            Student s = (Student)lit.previous();
            System.out.println(s);
        }
        p();
        // 4. 判断
        System.out.println(linkedList.contains(s1));
        System.out.println(linkedList.isEmpty());
        p();
        // 5. 获取
        System.out.println(linkedList.indexOf(s2));// 返回该元素的index
        System.out.println(linkedList.indexOf(s1));
        p();

    }
    public static void p(){
        System.out.println("======================");
    }
}

Print

"D:\java\IDEA—2019\IntelliJ IDEA 2019.3.3\jbr\bin\java.exe" "-javaagent:D:\java\IDEA—2019\IntelliJ IDEA 2019.3.3\lib\idea_rt.jar=56018:D:\java\IDEA—2019\IntelliJ IDEA 2019.3.3\bin" -Dfile.encoding=UTF-8 -classpath F:\Application\out\production\Application Test.Test12.Application
元素个数; 4
[Student{age=22, name='刘德华'}, Student{age=22, name='梁朝伟'}, Student{age=22, name='郭富城'}, Student{age=22, name='郭富城'}]
======================
======================
==============for ==============
Student{age=22, name='刘德华'}
Student{age=22, name='梁朝伟'}
Student{age=22, name='郭富城'}
Student{age=22, name='郭富城'}
==============增强 for ==============
Student{age=22, name='刘德华'}
Student{age=22, name='梁朝伟'}
Student{age=22, name='郭富城'}
Student{age=22, name='郭富城'}
==============Iterator 迭代器 ==============
Student{age=22, name='刘德华'}
Student{age=22, name='梁朝伟'}
Student{age=22, name='郭富城'}
Student{age=22, name='郭富城'}
==============ListIterator 列表迭代器 ==============
Student{age=22, name='刘德华'}
Student{age=22, name='梁朝伟'}
Student{age=22, name='郭富城'}
Student{age=22, name='郭富城'}
==============ListIterator 列表迭代器 逆向==============
Student{age=22, name='郭富城'}
Student{age=22, name='郭富城'}
Student{age=22, name='梁朝伟'}
Student{age=22, name='刘德华'}
======================
true
false
======================
1
0
======================

Process finished with exit code 0

LinkedList 源码分析

未完待续。。。。

ArrayList与LinkedList 的区别

ArrayList ; 必须开辟连续空间，查询快，增删慢，把数据一个一个放进去就行 而且有 index

LinkedList； 无需开辟连续空间，查询慢，增删快，是一个双向的链表，无 index

6——泛型类

  • Java泛型是JDK1.5中引入的一个性特性，其本质是参数化类型，把类型作为参数传递。
  • 常见的形式有，泛型类、泛型接口、泛型方法
  • 语法；
    • <T，，，> T称为类型占位符，表示一种引用类型
  • 好处；
    1. 提高代码的重用性
    2. 防止类型转换异常，提高代码的安全性

泛型类 MyGeneric

Class

package Test.Test13;
/**
 * 泛型类
 * 语法;  MyGeneric<T> 类名 <T,E....> (多个泛型可以用 , 隔开)
 * T 是类型占位符, 表示一种引用类型
 * @author 夏天的风
 * */
public class MyGeneric<T> {
    //使用泛型 T
    // 1. 创建变量
    T t; // 相当与 String t;
    // 2. 作为方法的参数
    public void show(T t){// 如果传递 String 类型 相当于 （String t）
        // T 可以传递变量 但不能直接创建 new 对象，T表示是一种引用类型，但是不确定是什么类型，不能保证它的构造方法能用，万一是私有的
        System.out.println(t);
    }
    // 3. 泛型作为方法的返回值
    public T getT(){ // 这里相当于 返回值是 String 的方法
        return t;
    }


}

Application

package Test.Test13;

public class TestGeneric {
    public static void main(String[] args) {
        // 使用泛型类 创建对象 ·1
        /**
         * 注意点;
         *  -泛型只能用引用类型
         *  -不同泛型类型对象之间不能互相赋值  // MyGeneric<Character> myGeneric02 = myGeneric01;
         * */
        MyGeneric<String> myGeneric = new MyGeneric<String>();
                //在使用泛型类的时候，就不能使用占位符了，需要给它一个实际的引用类型(包装类) = 号后面可以不写
        myGeneric.t="Hello JAVA";//使用 String 作为实际类型后不能传递其他类型
        myGeneric.show("大家好");
        String str = myGeneric.getT(); // 这里 get和返回  属性t的值
        System.out.println(str);

        MyGeneric<Integer> meyGeneric01 = new MyGeneric<Integer>();
        meyGeneric01.t = 200;
        meyGeneric01.show(100);
        Integer integer = meyGeneric01.getT();
        System.out.println(integer); // 属性 t 的值

    }
}

Print

F:\Application\out\production\Application Test.Test13.TestGeneric
大家好
Hello JAVA
100
200

Process finished with exit code 0

泛型接口

Inter face

package Test.Test13;
/**
 * 泛型接口
 * 语法;  接口名<T>
 *  - 不能使用泛型来创建静态常量
 * @author 夏天的风
 * */
public interface MyInterface<T> { // 声明为泛型类接口

    String name = "张三";
    T Server(T t);

}

implements01

package Test.Test13;

public class MyInterfaceImpl implements MyInterface<String>{
    @Override
    public String Server(String t) {
        System.out.println(t);
        return t;
    }

}

implements02

package Test.Test13;

public class MyInterfaceImpl02<T> implements MyInterface<T>{ 
    // 声明为 泛型 类 实现类 且不传递 类型
    @Override
    public String Server(String t) {
        System.out.println(t);
        return t;
    }

}

Application

package Test.Test13;

public class Application {
    public static void main(String[] args) {
        //第一种  在写实现类时 传递 引用类型 给接口
        MyInterface<String> impl = new MyInterfaceImpl();
        impl.Server("王小明");
        //第二种  接口和 实现类都 <T>
        //在实例化时 传递类型
        MyInterface<Integer> impl2 = new MyInterfaceImpl2<>();
        impl2.Server(1000);

    }
}

Print

F:\Application\out\production\Application Test.Test13.Application
王小明
1000

Process finished with exit code 0

泛型方法

  • 体现了方法的重用性 ，一个方法可以多种类型 不需要重载方法来实现

Class

package Test.Test14;
/**
 * 泛型方法
 * 语法;  <T> 返回值类型
 * @author 夏天的风
 * */
public class MyGenericMethod {

    //泛型方法
    public <T>void show(T t){
        System.out.println("泛型方法 "+t);
    }

    public <T>T shout(T t){
        System.out.println(t);
        return t;
    }

}

Application

package Test.Test14;

public class Application {
    public static void main(String[] args) {
        // 泛型方法的类型 是不需要设置的 由传递的数据决定 传什么 变什么
        MyGenericMethod myGenericMethod = new MyGenericMethod();
        myGenericMethod.show(1230);
        myGenericMethod.show(3.14);
        myGenericMethod.shout("王小明");
    }
}

泛型集合

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

  • 特点；

    1. 编译时即可检查，而非运行时抛出异常
    2. 访问时，不必类型转换(拆箱）
    3. 不同泛型之间引用不能互相复制，泛型不存在多态

Class

package Test.Test15;

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

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

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

Application

package Test.Test15;
import java.util.ArrayList;
import java.util.Iterator;
public class Demo01 {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList<>();
        //ArrayList<String> arrayList = new ArrayList<String>();  这样的话 把泛型定义成字符串 其他的类型 全都不能使用了
        arrayList.add("xxx");
        arrayList.add("yyy");
        arrayList.add(10);
        arrayList.add(20);
        for (Object o : arrayList) {
            System.out.println(o);
        }
        System.out.println("===============================");
        //这里确实可以打印出数据 但是它是一个对象 如果我们需要取的是基本类型呢？
        // 下面就使用泛型 实现
        // 方法 1. 设置泛型为 String
        ArrayList<String> arrayList01 = new ArrayList<String>();
        arrayList01.add("xxx");
        arrayList01.add("yyy");
/*        arrayList01.add(10);
        arrayList01.add(20);*/
        for (String s : arrayList01) {
            System.out.println(s);
        }
        // 上面 是对字符串类 操作 如果是自己写的类呢？
        System.out.println("===============================");
        // 如果泛型 声明了某一个类 那么 只能对某个类 操作
        ArrayList<Student> arrayList02 = new ArrayList<Student>();
        Student s1 = new Student(22,"刘德华");
        Student s2 = new Student(22,"梁朝伟");
        Student s3 = new Student(22,"郭富城");
        arrayList02.add(s1);
        arrayList02.add(s2);
        arrayList02.add(s3);
        //arrayList02.add(123); 只能 Student 操作
        //arrayList02.add("xxz"); 只能对 Student 类操作
        // 1. 创建 Iterator
        // Iterator it = arrayList.iterator();
        // 这个 迭代器是继承了 Object 类所以迭代出来的也是 obj 类 是需要强转的 但是 添加泛型就不用了
        Iterator<Student> it = arrayList02.iterator();
        // 2. 创建 While
        while(it.hasNext()){
            Student s = it.next();
            System.out.println(s.toString());
        }



    }
}

print

F:\Application\out\production\Application Test.Test15.Demo01
xxx
yyy
10
20
===============================
xxx
yyy
===============================
Student{age=22, name='刘德华'}
Student{age=22, name='梁朝伟'}
Student{age=22, name='郭富城'}

Process finished with exit code 0

7——Set 集合

  • 特点； 无序、无下标、元素不可重复
  • 方法；全部继承自 Collection 中的方法 没有提供其他方法

Set 接口的使用

  • HashSet；
    1. 基于 HashCode 计算元素存放位置，实现元素不重复
    2. 当存入元素的哈希码相同时，会调用equals 进行确认，如果结果为 true ，则拒绝后者存入。
  • TreeSet（二叉树）；
  • 基于排列顺序实现元素不重复

Application

package Test.Test16;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
/**
 * Test Set 接口的使用
 * 特点;
 *  -无序、没有下标
 *  -不能重复
 * @author 夏天的风
 * */
public class Demo01 {
    public static void main(String[] args) {
        // 创建集合
        Set<String> set = new HashSet<>();// 这里泛型应该是可以省略不写
        // 1. 添加数据
        set.add("华为");
        set.add("小米");
        set.add("iphone");
        //set.add("华为"); 不会录入 重复数据

        System.out.println("数据个数; "+ set.size());
        System.out.println(set.toString());
        // 2. 删除
        set.remove("小米");
        System.out.println(set.size());
        set.clear();
        System.out.println(set.size());
        // 3. 遍历
        // 增强for 遍历
        for (String s : set) {
            System.out.println(s);
        }
        // Iterator 迭代器
        Iterator<String> it = set.iterator();
        while(it.hasNext()){
            String str = it.next();
            System.out.println(str);
        }
        // 3. 判断
        System.out.println(set.contains("华为"));
        System.out.println(set.isEmpty());
    }
}

Print

F:\Application\out\production\Application Test.Test16.Demo01
数据个数; 3
[华为, iphone, 小米]
2
0
false
true

Process finished with exit code 0

HashSet 的使用（一）

Application

package Test.Test17;
import com.sun.source.tree.WhileLoopTree;

import java.util.HashSet;
import java.util.Iterator;
/**
 * HashSet 集合的使用
 * 存储结构; 哈希表(数组+链表+红黑树)
 *
 * @author 夏天的风
 */
public class Demo {
    public static void main(String[] args) {
        // 新建集合
        HashSet<String> hashSet = new HashSet<String>();
        // 1. 添加元素
        hashSet.add("梁朝伟");
        hashSet.add("刘德华");
        hashSet.add("林志玲");
        hashSet.add("周润发");
        //hashSet.add("刘德华")  不能重复数据
        System.out.println("元素集合; "+ hashSet.size());
        System.out.println(hashSet.toString());
        // 2. 删除数据
        hashSet.remove("刘德华");
        System.out.println(hashSet.size());
        // hashSet,clear(); 清除
        System.out.println("========================");
        // 3. 遍历
        // 增强for
        for (String s : hashSet) {
            System.out.println(s);
        }
        // Iterator 迭代器
        Iterator<String> it = hashSet.iterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("=============================");
        // 4. 判断 包含和是否为null
        System.out.println(hashSet.contains("郭富城"));
        System.out.println(hashSet.isEmpty());
    }
}

Print

"D:\java\IDEA—2019\IntelliJ IDEA 2019.3.3\jbr\bin\java.exe" "-javaagent:D:\java\IDEA—2019\IntelliJ IDEA 2019.3.3\lib\idea_rt.jar=52257:D:\java\IDEA—2019\IntelliJ IDEA 2019.3.3\bin" -Dfile.encoding=UTF-8 -classpath F:\Application\out\production\Application Test.Test17.Demo
元素集合; 4
[林志玲, 梁朝伟, 周润发, 刘德华]
3
========================
林志玲
梁朝伟
周润发
林志玲
梁朝伟
周润发
=============================
false
false

Process finished with exit code 0

HashSet 的使用（二）

Class

package Test.Test00.Test18;

import java.util.Objects;

/**
 *  人类
 * @author xxz
 *
 * */
public class Person {
    private int age;
    private String name;

    public Person() {
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
    //(1)根据 hashcode 计算保存的位置(指数组的位置)，如果此位置为空，则直接保存，如果不为空执行第二步
    //重写 hashCode()
    @Override
    public int hashCode() {
        //return Objects.hash(age, name);
        int n1 = this.name.hashCode();
        int n2 = this.age;
        return n1+n2;
    }
    //(2)再执行 equals 方法，如果 equals 方法为true ，则认为是重复，否则形成链表
    //true 重复  false 不重复
    @Override
    public boolean equals(Object o) {
        // 1. 比较对象地址
        if(this == o){ return true; }
        // 2. 该对象是否为空
        if(o == null){ return false;}
        // 3. 判断是否是 Person 的实例
        if( o instanceof Person){
            // 4. 如果是强制转换
            Person p = (Person)o;
            // 5. 比较属性
            if (this.age == p.getAge() && this.name.equals(p.name)){ return true; }

        }
        // 6. 否则 false
        return false;
    }

    public void remove(Object o){

    }
}

Application

package Test.Test00.Test18;
import java.util.HashSet;
import java.util.Iterator;
/**
 * HashSet 的使用
 * 存储结构 ; 哈希表(数组+链表+红黑树)
 * 储存过程 ;
 * (1)根据 hashcode 不同的对象可能会计算出同值，同个对象一定是同值。计算保存的位置(指数组的位置)，如果此位置为空，则直接保存，如果不为空执行第二步
 * (2)再执行 equals 方法，如果 equals 方法为true ，则认为是重复，否则形成链表
 *
 * @author 夏天的风
 */

public class Application {
    public static void main(String[] args) {
        // 创建 集合
        HashSet<Person> person = new HashSet<>();
        // 创建对象
        Person p1 = new Person(12,"xxz");
        Person p2 = new Person(21,"刘谦");
        Person p3 = new Person(25,"刘德华");
        // 1. 添加数据
        person.add(p1);
        person.add(p2);
        person.add(p3);
        System.out.println("元素个数; "+person.size());
        System.out.println(person.toString());
        person.add(p1); //不会录入重复信息
        person.add(new Person(25,"刘德华"));
        System.out.println("元素个数; "+person.size());
        // 视频中这个时可以录入的，为什么？——判断的是 对象地址 并不是内容 在类中 重写 equals 方法就会发现原因了
        //因为 在 Set 中判断的是对象地址是否重复，而 new 的匿名对象 会被分配一个新的地址 所以会被判断不重复
        /** 以下是视频中的 equals 方法 显然判断的是对象地址 而 new 是开辟新的地址 因此反馈 false 可以录入
         * public boolean equals(Object obj){
         *    return super.equals(obj);
         * }
         * */
        // ==接下来 按照视频的问题在类中 重写 equals 方法用来实现 同属性不能重复录入。
        // 2. 删除 remove()  clear()
/**        person.remove(p1);
        person.remove(new Person(25,"刘德华"));
        //删除也是根据 hashCode 和 equals 来删除的 这里会 拿这个匿名的对象去比 发现和 p3 是重复的，因此删除 p3
        System.out.println("删除后元素个数; "+person.size());// 2*/
        System.out.println("===============================");
        //3. 遍历 增强for  迭代器 Iterator
        Iterator<Person> it = person.iterator();
        while(it.hasNext()){
            System.out.println(it.next().toString());
        }// 这是类的属性 所以就不转换了 如果是 字符串可以强制转换一下
        System.out.println("===============================");
        // 4. 判断
        System.out.println(person.contains(new Person(25,"刘德华")));
        System.out.println(person.contains(p3));
        System.out.println(person.isEmpty());
    }
}

Print

F:\Application\out\production\Application Test.Test00.Test18.Application
元素个数; 3
[Person{age=12, name='xxz'}, Person{age=25, name='刘德华'}, Person{age=21, name='刘谦'}]
元素个数; 3
===============================
Person{age=12, name='xxz'}
Person{age=25, name='刘德华'}
Person{age=21, name='刘谦'}
===============================
true
true
false

Process finished with exit code 0

8——TreeSet 类

TreeSet 是一个红黑树的储存结构

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

TreeSet 的使用

  • 属性集合

Application

package Test.Test00.Test19;

import java.util.TreeSet;
import java.util.Iterator;
/**
 * TreeSet 的使用
 * 存储结构; 红黑树
 * @author 夏天的风
 */
public class Application {
    public static void main(String[] args) {
        // 创建 集合
        TreeSet<String> treeSet = new TreeSet();
        // 1. 添加元素
        treeSet.add("xxz");
        treeSet.add("yyt");
        treeSet.add("Hello");
        treeSet.add("xxz");
        System.out.println("元素个数; "+treeSet.size());
        System.out.println(treeSet.toString());// 它有一定的排列顺序按照字典表
        System.out.println("========================");
        // 2. 删除
/*        treeSet.remove("xxz");
        treeSet.clear();
        System.out.println("元素个数; "+treeSet.size());*/
        System.out.println("=======================");
        // 3. 遍历 增强for  Iterator 迭代器
        //因为这里设置了 泛型 所以不需要强转
        for (String s : treeSet) {
            System.out.println(s);
        }
        System.out.println("=======================");
        // 创建 迭代器
        Iterator<String> it = treeSet.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        // 4. 判断 contains() isEmpty()
        System.out.println(treeSet.contains("xxz"));
        System.out.println(treeSet.isEmpty());
        
    }
}

Print

F:\Application\out\production\Application Test.Test00.Test19.Application
元素个数; 3
[Hello, xxz, yyt]
========================
=======================
Hello
xxz
yyt
=======================
Hello
xxz
yyt
true
false

Process finished with exit code 0
  • 对象集合

Class

package Test.Test00.Test19;
import java.util.Objects;
/**
 *  人类
 * @author xxz
 *
 * */
public class Person implements Comparable<Person>{
    private int age;
    private String name;

    public Person() {
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

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

    }

//=============================Compare 接口中只有一个方法 compareTo 重写它
    // 先比较 姓名后比较年龄
    // 这里 的比较是指 首先比较是否相同 相同返回0 则不入 非0然后比大小 小的在左 大的在右 后者不是我们定义的 数据结构本身定义的
    @Override
    public int compareTo(Person o) {
        int n1 = this.getName().compareTo(o.name);//compareTo 相同 返回 0 大于返回1 小于 -1
        int n2 = this.age-o.age;
        return n1==0?n2:n1;
        //return 0;
    }
}

Application

package Test.Test00.Test19;
import java.util.TreeSet;
import java.util.Iterator;

/**
 * 使用 TreeSet 保存数据
 * 储存结构; 红黑树
 * 要求; 元素必须实现 Comparable 接口，comparableTo() 方法返回值为0，认为是重复元素
 */

public class Demo {
    public static void main(String[] args) {
        // 创建集合
        TreeSet<Person> treeSet = new TreeSet<>();
        Person p1 = new Person(12,"张三");
        Person p2 = new Person(25,"王五");
        Person p3 = new Person(24,"人才");
        Person p4 = new Person(52,"张三");
        Person p5 = new Person(52,"张三");
        // 1. 添加元素
        treeSet.add(p1);
        treeSet.add(p2);
        treeSet.add(p3);
        treeSet.add(p4);
        treeSet.add(p4);
        // 有两个张三 小的 在前 大的在后
        System.out.println("元素个数; "+treeSet.size());
        System.out.println(treeSet.toString());
        // 如果直接运行会类型转换报错！！！ 原因是储存结构红黑树 应该要提供 元素对比的属性
        // 元素必须实现 Comparable 接口 实现接口 必须重写方法
        // 2. 删除元素 remove() clear()
/*        treeSet.remove(p1);
        treeSet.remove(new Person(52,"张三"));// 可以删除因为比较的是数性 name age
        System.out.println(treeSet.size());*/
        System.out.println("================================");
        // 3. 遍历  增强for  迭代器 Iterator
        Iterator<Person> it = treeSet.iterator();
        while(it.hasNext()){
            System.out.println(it.next().toString());
        }
        System.out.println();
        for (Person s : treeSet) {
            System.out.println(s.toString());
        }
        System.out.println();
        // 4. 判断   contains()  isEmpty()
        System.out.println(treeSet.contains(p1));
        System.out.println(treeSet.contains(new Person(52,"张三")));
        System.out.println(treeSet.isEmpty());
    }
}

Print

F:\Application\out\production\Application Test.Test00.Test19.Demo
元素个数; 4
[Person{age=24, name='人才'}, Person{age=12, name='张三'}, Person{age=52, name='张三'}, Person{age=25, name='王五'}]
================================
Person{age=24, name='人才'}
Person{age=12, name='张三'}
Person{age=52, name='张三'}
Person{age=25, name='王五'}

Person{age=24, name='人才'}
Person{age=12, name='张三'}
Person{age=52, name='张三'}
Person{age=25, name='王五'}

true
true
false

Process finished with exit code 0

Comparator 接口

Class

package Test.Test00.Test20;
import java.util.Objects;
/**
 *  人类
 * @author xxz
 *
 * */
public class Person {
    private int age;
    private String name;

    public Person() {
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

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

Application

package Test.Test00.Test20;
import java.util.Comparator;
import java.util.TreeSet;

/**
 * TreeSet 集合的使用
 * Comparator ; 实现定制比较(比较器)
 * Comparable ; 可比较的
 * @author 夏天的风
 */
public class Demo {
    public static void main(String[] args) {
        // 创建集合
        // 在创建集合的时候 同时把接口在匿名类中重写实现 并定义比较的规则 所以呢 也不用在类中 实现接口
        TreeSet<Person> person = new TreeSet<>(new Comparator<Person>(){
            @Override
            public int compare(Person p1, Person p2) {
                int n1 = p1.getAge()-p2.getAge();
                int n2 = p1.getName().compareTo(p2.getName());
                return n1==0?n2:n1;
            }
        });
        // 创建对象
        Person p1 = new Person(12,"刘德华");
        Person p2 = new Person(21,"周润发");
        Person p3 = new Person(22,"彭于晏");
        Person p4 = new Person(22,"彭于晏");
        person.add(p1);
        person.add(p2);
        person.add(p3);
        System.out.println("元素个数"+person.size());
        System.out.println(person.toString());

    }
}

Print

F:\Application\out\production\Application Test.Test00.Test20.Demo
元素个数3
[Person{age=12, name='刘德华'}, Person{age=21, name='周润发'}, Person{age=22, name='彭于晏'}]

Process finished with exit code 0

TreeSet 设置比较规则案例

Application

package Test.Test00.Test21;
import java.util.Comparator;
import java.util.TreeSet;

/**
 *  要求使用TreeSet 集合实现字符串按照长度进行排序 (默认是以编码表的顺序排序)
 *  Comparator 接口实现定制比较
 * @author 夏天的风
 */
public class Application {
    public static void main(String[] args) {
        // 创建集合
        TreeSet<String> treeSet = new TreeSet<>(new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                int n0 = s1.length()-s2.length();
                int n1 = s1.compareTo(s2); //原本的比较规则
                return n0==0?n1:n0;
            }
        });
        // 定制比较方法的匿名类
        treeSet.add("浙江大学");
        treeSet.add("杭州电子科技大学");
        treeSet.add("浙江理工大学");
        treeSet.add("浙江工业大学");
        treeSet.add("宁波诺丁汉大学");
        treeSet.add("嘉兴学院");
        System.out.println(treeSet.toString());
    }
}

Print

F:\Application\out\production\Application Test.Test00.Test21.Application
[嘉兴学院, 浙江大学, 浙江工业大学, 浙江理工大学, 宁波诺丁汉大学, 杭州电子科技大学]

Process finished with exit code 0

9——Map 集合

Map接口的特点；

  • 用于存储任意键值对 （如果说Collection是一个单身数据，那么Map集合就是夫妻对）
  • 键；无序 、无下标、不可重复
  • 值；无序、无下标、可重复

常用方法；

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

Map 接口的使用

  • 值 篇

Application

package Test.Test00.Test22;
import java.util.Map;
import java.util.HashMap;
import java.util.Set;

/**
 * Map 接口的使用
 * 特点; 1.储存键值对 2.键不能重复，值可以重复 3.无序
 */
public class Demo {
    public static void main(String[] args) {
        // 创建 Map 集合
        Map<String,String> map = new HashMap<>();
        // 1. 添加元素
        // 添加重复的 key 会覆盖前面的 value
        map.put("cn","中国");
        map.put("uk","英国");
        map.put("usa","美国");
        map.put("cn","中华");
        System.out.println("元素个数; "+map.size());
        System.out.println(map.toString());
        System.out.println("===================");
        // 2. 删除
        map.remove("usa");
        System.out.println("删除之后; "+map.size());
        System.out.println("===================");
        // 3. 遍历
        //=============使用 keySet()============
        System.out.println("--------KeySet 遍历---------");
        Set<String> keySet = map.keySet();
        for (String s : keySet) {//可以合在一起 写成 String s : map.keySet() 上面一行可略
            System.out.println(s+"---"+map.get(s));
        }
        System.out.println("--------entrySet()-------");
        // =============entrySet() 遍历===========
        Set<Map.Entry<String,String>> entrySet = map.entrySet();
        /**
         * 它返回的是一个 Set 集合 因此 可以使用 增强for 和 Iterator
         * entrySet() 它返回的是 entry 键值对 既有 key 也有 value
         *  Set<Map.Entry> Map.Entry 是 Map 中的内部接口
         *  内部接口加前缀 Map.Entry
         */
        for (Map.Entry<String, String> entry : entrySet) {
            System.out.println(entry.getKey()+"---"+entry.getValue());
        }
        // 4. 删除
        System.out.println("=======================");
        System.out.println(map.containsKey("cn"));
        System.out.println(map.containsValue("泰国"));
    }
}

Print

F:\Application\out\production\Application Test.Test00.Test22.Demo
元素个数; 3
{usa=美国, uk=英国, cn=中华}
===================
删除之后; 2
===================
--------KeySet 遍历---------
uk---英国
cn---中华
--------entrySet()-------
uk---英国
cn---中华
=======================
true
false

Process finished with exit code 0

HashMap 的使用

  • HashMap；

    JdK1.2后出现，线程不安全(视频说只能在单线程使用)，运行效率快，允许null 作为 key 或 value

初始容量； 初始的容量 16

加载因子； 0.75 是指到填充容量百分之75时，扩容

Appication

package Test.Test00.Test23;

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

/**
 * HashMap 的使用
 * 存储结构; 哈希表（数组+链表+红黑树）
 * 默认是允许对象内的属性相同  如果需要禁止输入重复属性 需要重写   hascode 和 equals 作为重复
 * @author 夏天的风
 */
public class Application {
    public static void main(String[] args) {
        // 创建集合
        //刚刚创建的 hashMap 没有添加元素前 table = null  size = 0
        HashMap<Student ,String> students = new HashMap<Student,String>();
        // 1. 添加元素
        Student s1 = new Student(12,"周润发");
        Student s2 = new Student(22,"刘德华");
        Student s3 = new Student(20,"孙悟空");
        students.put(s1,"北京");
        students.put(s2,"上海");
        students.put(s3,"深圳");
        students.put(s3,"台湾");// key 重复 会覆盖前值
        students.put(new Student(20,"孙悟空"),"南京");
        System.out.println("元素个数; "+students.size());
        System.out.println(students.toString());
        System.out.println("====================");
        // 2. 删除元素
        students.remove(s1);
        //students.clear();
        System.out.println("删除之后; "+students.size());
        System.out.println("====================");
        // 3. 遍历
        // 使用 forEach
        for (Student key:students.keySet()) {
            System.out.println(key+"---"+students.get(key));
        }
        // 使用 entrySet()
        for (Map.Entry<Student,String> entry : students.entrySet()) {
            System.out.println(entry.getKey()+"---"+entry.getValue());
        }
        // 4. 判断
        System.out.println(students.containsKey(s1));
        System.out.println(students.containsValue("杭州"));
        System.out.println(students.isEmpty());
    }
}

Print

F:\Application\out\production\Application Test.Test00.Test23.Application
元素个数; 3
{Student{age=12, name='周润发'}=北京, Student{age=20, name='孙悟空'}=南京, Student{age=22, name='刘德华'}=上海}
====================
删除之后; 2
====================
Student{age=20, name='孙悟空'}---南京
Student{age=22, name='刘德华'}---上海
Student{age=20, name='孙悟空'}---南京
Student{age=22, name='刘德华'}---上海
false
false
false

Process finished with exit code 0

hashMap 的源码分析

  • 当链表的长度大于 8 且 数组长度大于等于64 变成树
  • 当链表的长度小于 8 变回来

Hashtable 的使用 tm 直接过 说不常用

  • 线程安全，效率慢，不允许 null 作为 key 或 value
  • 子类 Propertise ；
    • 要求 key value 都是String 通常用于配置文件的读取

TreeMap

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

Application

package Test.Test00.Test;


import java.util.Comparator;
import java.util.Map;
import java.util.TreeMap;

public class Application {
    public static void main(String[] args) {
        TreeMap<Student,String> students = new TreeMap<>(/*new Comparator<Student>() {
            @Override
            public int compare(Student student, Student t1) {
                return 0;
            }
        }*/);
        // 1. 添加元素
        // 添加 tree 集合元素 必须实现 Comparable 并重写 compareTo 方法定义排序
        // 或者定制 排序规则 就不需要实现类了
        //Api 文档 ; 比较器 TreeMap(Comparator<? super K> comparator) 构造一个新的、空的树映射，该映射根据给定比较器进行排序。
       Student s1 = new Student(12,"周润发");
       Student s2 = new Student(22,"刘德华");
       Student s3 = new Student(20,"孙悟空");
        students.put(s1,"北京");
        students.put(s2,"上海");
        students.put(s3,"深圳");
        System.out.println("元素个数; "+students.size());
        System.out.println(students.toString());
        System.out.println("======================");
        // 2. 删除
        students.remove(s1);
        //students.clear();
        System.out.println("======================");
        // 3. 遍历
        // 使用 keySet
        for (Student key : students.keySet()) {
            System.out.println(key+"---"+students.get(key));
        }
        // entrySet()
        for (Map.Entry<Student,String> entry: students.entrySet()) {
            System.out.println(entry.getKey()+"---"+entry.getValue());
        }
        System.out.println("======================");
        // 判断
        System.out.println(students.containsKey(s1));
        System.out.println(students.containsValue("北京"));
        System.out.println(students.isEmpty());

    }
}

Print

F:\Application\out\production\Application Test.Test00.Test.Application
元素个数; 3
{Student{age=12, name='周润发'}=北京, Student{age=20, name='孙悟空'}=深圳, Student{age=22, name='刘德华'}=上海}
======================
======================
Student{age=20, name='孙悟空'}---深圳
Student{age=22, name='刘德华'}---上海
Student{age=20, name='孙悟空'}---深圳
Student{age=22, name='刘德华'}---上海
======================
false
false
false

Process finished with exit code 0

10——Collections 工具类

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

方法；

  • reverse（List<> List） //反转元素顺序
  • shuffle（List<> List） //随机排序
  • sort（List List） //升序排序（元素必须实现 Cpmparable 接口）

Application

package Test.Test00.Test24;
import java.lang.reflect.Array;
import java.util.*;

/**
 * 演示 Collections 工具类的使用
 * @author 夏天的风
 */

public class Application {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(20);
        list.add(13);
        list.add(78);
        list.add(48);
        list.add(16);
        list.add(15);
        // sort
        System.out.println("排序之前 " +list.toString());
        Collections.sort(list/*, new Comparator<Integer>() {
            @Override
            public int compare(Integer integer, Integer t1) {
                return 0;
            }
        }*/);//默认是升序 可以重写 sort 方法定制排序规则
        System.out.println("排序之后 "+ list.toString());
        // binarySearch 二分查找
       int i = Collections.binarySearch(list,12);
       // 如果找到返回 <= 0 的数 没找到 -1
        System.out.println(i);
        // copy 复制
        List<Integer> dest = new ArrayList<>();
        for (int j = 0; j < list.size(); j++) {
            dest.add(0);
        }
        Collections.copy(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());
        System.out.println("=================");
        // list ————> 数组
        Integer[] arr = list.toArray(new Integer[0]);
        //new Integer[0] 这里放什么数字 都行 不能大于 list 的长度
        System.out.println(arr.length);
        System.out.println(Arrays.toString(arr));
        // 数字 ————> List
        // 当数组 变成集合后 不能添加和删除
        String[] name = {"张三","李四","王五"};
        List<String> list00 = Arrays.asList(name);
        System.out.println(list00.toString());
        System.out.println("=====================");
        // 把基本类型数组 转集合时 需要修改为包装类
        int[] sum = {11,2,6,8,8,9};//int[] -- Integer[]
        List<int[]> list01 = Arrays.asList(sum);// int[] -- Integer[]





    }
}

Print

F:\Application\out\production\Application Test.Test00.Test24.Application
排序之前 [20, 13, 78, 48, 16, 15]
排序之后 [13, 15, 16, 20, 48, 78]
-1
[13, 15, 16, 20, 48, 78]
[78, 48, 20, 16, 15, 13]
[48, 16, 15, 13, 78, 20]
=================
6
[48, 16, 15, 13, 78, 20]
[张三, 李四, 王五]
=====================

Process finished with exit code 0

新增单词

0 Collection 集合 科啦科寻~
1 List List接口 列表的意思 李sT~
2 ArrayList 数组列表 艾瑞莉斯特
3 LinkedList 链表 李克特李sT
4 HashSet 散列集 哈希Set
5 SortedSet 接口 suoT的 sort 排序 Set的接口
6 TreeSet 类 崔Set tree 树 Set的接口
7 remove 移除 瑞姆芙~
8 clear 清扫 清除 克利尔~
9 iterator 迭代器 唉特瑞t~
10 contains 是否包含 砍泰尼丝~
11 isEmpty 是否为null is 安噗踢 collection.isEmpty()
12 subList 获取列表中指定范围的子列表 sub list
13 addAll 将指定 collection 中的所有元素都添加到此 collection 中
14 from 从……起
15 listIterator 迭代器 唉特瑞特
16 previousIndex 返回对 previous 的后续调用所返回元素的索引。 噗瑞 vi yes 前一个 上一个
17 binarySearch 二分查找法 拜呢瑞 涩琪 Search 涩琪 查找
18 hasPrevious 如果以逆向遍历列表，列表迭代器有多个元素，则返回 true 噗瑞 vi yes hasNext 是否有上一个
19 Vector 向量 歪可特 List 实现类的一种
20 elements 元素 唉莱们s
21 Enumeration 枚举 唉牛门瑞寻
22 MyGeneric 泛型 MyG奶瑞科
23 comparable 可比较的 com 噗瑞伯
24 compareTo 与....比较 com 派儿 to
25 Comparator 比较器 com 派儿 tor
26 put 添加
27 entrySet 映射项（键-值对） 嗯崔
28 shuffle 打乱 宵父
posted @ 2021-05-23 12:45  项晓忠  阅读(70)  评论(0)  编辑  收藏  举报