2021-02-23

集合

如果并不知道程序运行时会需要多少对象，或者需要更复杂方式存储对象——可以使用Java集合框架

集合概念： 存放多个 相同类型 的元素的 数据结构

List：

1、分类

ArrayList

JDK中使用数组 实现 ArrayList ， 数组的默认长度10
对应的数据结构：线性表（一段地址连续的内存空间）
特征：
1.元素访问的效率高
2.插入和删除操作的效率低

LinkedList

对应的数据结构：双向链表（每个数据节点中除了保存元素值以外，还包括上一个元素的地址和下一个元素的地址）

19.png

特征

1.插入和删除的效率高
2.元素访问的效率低

Set

1、特征

是一种无序集合（即：元素顺序与放入顺序无关）
是一种不可重复集合（即：集合中的元素不可以重复）

HashSet特性

数据结构

哈希赛特列表

特点：

HashSet判断元素不重复的方式

向HashSet中放入一个元素：

获取元素对象的hashCode值
根据hash散列算法，算出 哈希表的索引值
判断该位置是否已经有元素：
没有：直接放入该位置 --》 结束
有：调用已有对象的equals方法（或者 == 运算符）和要放入的对象比较
返回true ： 舍弃要放入的元素 --》 结束
返回false：在当前位置下，以链表的形式追加(在jdk8+，对其做了优化，当链表长度大于等于8的时候，会将其数据结构重构为 平衡二叉树) --> 结束

Map

1、简介：

是一种对应关系，这种对应关系，叫做 键值对（key-value） / 映射，指的是： 根据一个key 值能够唯一的找到一个 Value 值（一个value值可以对应一个或者多个或者0个key值），所有的Map的实现类，都能保存 Key - Value 的 对应关系

2、常用API

put
get
containsKey / containsValue
remove / clear
size / isEmpty

HashMap特性：

HashMap 数据结构： 哈希赛特列表

HashSet 的底层是 HashMap ， HashSet中的元素是作为HashMap的Key 存储的，Value 是一个Object对象

HashMap判断key是否重复的方式：
获取元素Key的hashCode值
根据hash散列算法，算出 哈希表的索引值
判断该位置是否已经有元素：
没有：直接放入该位置 --》 结束
有：调用已有对象的equals方法（或者 == 运算符）和要放入的对象比较
返回true ： 使用要放入的元素覆盖原有值 --》 结束
返回false：在当前位置下，以链表的形式追加(在jdk8+，对其做了优化，当链表长度大于等于8的时候，会将其数据结构重构为 平衡二叉树) --> 结束

通过一个企鹅代码来简单了解集合：

先来一个企鹅类存放数据

package penguinlist;

public class Penguin {

//设置并封装属性
    private int id;
    private String name;
    private String sex;
//有参数与无参数构造方法，构造企鹅
    public Penguin() {
    }

    public Penguin(int id, String name, String sex) {
        this.id = id;
        this.name = name;
        this.sex = sex;
    }

//get和set的读写权限
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

//to String方法用来显示
    @Override
    public String toString() {
        return "Penguin{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                '}';
    }
}

测试ArrayList类

package penguinlist;

import java.util.ArrayList;

public class TestPenguin {

    public static void main(String[] args) {
//使用泛型，后面的代码就不用强转了，省了很多事情
        ArrayList<Penguin> list=new ArrayList<Penguin>();
//创建对象的同时的进行赋值
        Penguin q1=new Penguin(1,"欧欧","Q仔");
        Penguin q2=new Penguin(2,"美美","Q妹");
        Penguin q3=new Penguin(3,"丫丫","Q妹");
        Penguin q4=new Penguin(4,"天天","Q仔");
        Penguin q5=new Penguin(5,"田田","Q妹");
//向集合里面添加元素的方法
        list.add(q1);
        list.add(q2);
        list.add(q3);
        list.add(0,q4);

//list.size()表示集合的长度，也就是集合里面元素的个数
        System.out.println("共计有"+list.size()+"只企鹅");
        //遍历并且显示数据
        for (int i=0;i<list.size();i++){
            Penguin penguin=list.get(i);
            System.out.println(penguin.getId()+"\t\t"+penguin.getName()+"\t\t"+penguin.getSex());
        }
        System.out.println("删除下标为1的元素");
        Penguin removePenguin=list.remove(1);
        System.out.println("删除的对象:"+removePenguin.getName());
        for (int i=0;i<list.size();i++){
            Penguin penguin=list.get(i);
            System.out.println(penguin.getId()+"\t\t"+penguin.getName()+"\t\t"+penguin.getSex());
        }
    }
}

测试结果：

共计有4只企鹅
4		天天		Q仔
1		欧欧		Q仔
2		美美		Q妹
3		丫丫		Q妹
删除下标为1的元素
删除的对象:欧欧
4		天天		Q仔
2		美美		Q妹
3		丫丫		Q妹

Process finished with exit code 0

测试LinkedList类：

package penguinlist;

import java.util.LinkedList;

public class TestPenguin1 {

    public static void main(String[] args) {

        LinkedList<Penguin> list = new LinkedList<Penguin>();

        Penguin q1 = new Penguin(1, "欧欧", "Q仔");
        Penguin q2 = new Penguin(2, "美美", "Q妹");
        Penguin q3 = new Penguin(3, "丫丫", "Q妹");
        Penguin q4 = new Penguin(4, "天天", "Q仔");
        Penguin q5 = new Penguin(5, "田田", "Q妹");

        list.add(q1);
        list.add(q4);
        list.addFirst(q3);//添加第一只企鹅
        list.addLast(q2);//添加最后一只企鹅

        System.out.println("共计有" + list.size() + "只企鹅");
        Penguin penguinFirst = list.getFirst();
        Penguin penguinLast = list.getLast();

        System.out.println("第一只企鹅:" + penguinFirst.getName());
        System.out.println("最后一只企鹅:" + penguinLast.getName());

        System.out.println("===============================================");
        for (int i = 0; i < list.size(); i++) {
            Penguin penguin = list.get(i);
            System.out.println(penguin.getId() + "\t\t" + penguin.getName() + "\t\t" + penguin.getSex());
        }

        System.out.println("===============================================");
        System.out.println("删除下标为1的元素");
        Penguin removePenguin =  list.remove(1);
        System.out.println("删除的对象:" + removePenguin.getName());
        for (int i = 0; i < list.size(); i++) {
            Penguin penguin = list.get(i);
            System.out.println(penguin.getId() + "\t\t" + penguin.getName() + "\t\t" + penguin.getSex());
        }
    }
}

测试结果：

共计有4只企鹅
第一只企鹅:丫丫
最后一只企鹅:美美
===============================================
3		丫丫		Q妹
1		欧欧		Q仔
4		天天		Q仔
2		美美		Q妹
===============================================
删除下标为1的元素
删除的对象:欧欧
3		丫丫		Q妹
4		天天		Q仔
2		美美		Q妹

Process finished with exit code 0

测试HashSet类：

package penguinlist;

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

public class TestPenguin2 {

    public static void main(String[] args) {

        Set<Penguin> set=new HashSet<Penguin>();

        Penguin q1=new Penguin(1,"欧欧","Q仔");
        Penguin q2=new Penguin(2,"美美","Q妹");
        Penguin q3=new Penguin(3,"丫丫","Q妹");
        Penguin q4=new Penguin(4,"天天","Q仔");
        Penguin q5=new Penguin(5,"田田","Q妹");

        set.add(q1);
        set.add(q2);
        set.add(q3);
        set.add(q4);
        set.add(q2);

        System.out.println(set.size());

        for (Object obj:set){
            Penguin penguin=(Penguin)obj;
            System.out.println(penguin.getId()+"\t\t"+penguin.getName()+"\t\t"+penguin.getSex());
        }

        System.out.println("===============================================");

        System.out.println("删除下标为2的元素");
        boolean removepenguin = set.remove(q2);


        for (Object obj:set){
            Penguin penguin=(Penguin)obj;
            System.out.println(penguin.getId()+"\t\t"+penguin.getName()+"\t\t"+penguin.getSex());
        }

    }
}

测试结果：

4
3		丫丫		Q妹
2		美美		Q妹
4		天天		Q仔
1		欧欧		Q仔
===============================================
删除下标为2的元素
3		丫丫		Q妹
4		天天		Q仔
1		欧欧		Q仔

Process finished with exit code 0

测试Map类：

package penguinlist;

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.logging.Logger;

public class TestMap {

    private static Logger logger=Logger.getLogger(String.valueOf(TestMap.class));

    public static void main(String[] args) {

        Map penguins=new HashMap();

        Penguin q1=new Penguin(1,"欧欧","Q仔");
        Penguin q2=new Penguin(2,"美美","Q妹");
        Penguin q3=new Penguin(3,"丫丫","Q妹");
        Penguin q4=new Penguin(4,"天天","Q仔");
        Penguin q5=new Penguin(5,"田田","Q妹");

        //"a"是键 "q1"是相对应的值
        penguins.put("a",q1);
        penguins.put("b",q2);
        penguins.put("c",q3);
        penguins.put("d",q4);

        Scanner input=new Scanner(System.in);
        logger.info("请输入要查找的对象：");
        String key=input.next();
        if (penguins.containsKey(key)){
             Penguin penguin=(Penguin) penguins.get(key);
            System.out.println("key:"+key+"名字："+penguin);
        }else {
            System.out.println("没有找到！");
        }
    }
}

测试结果：

二月 23, 2021 10:19:27 上午 penguinlist.TestMap main
信息: 请输入要查找的对象：
a
key:a名字：Penguin{id=1, name='欧欧', sex='Q仔'}

Process finished with exit code 0

测试Map类Iterator循环遍历：

package penguinlist;

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

public class TestIterator {

    public static void main(String[] args) {
        Map penguins=new HashMap();
        Penguin q1=new Penguin(1,"欧欧","Q仔");
        Penguin q2=new Penguin(2,"美美","Q妹");
        Penguin q3=new Penguin(3,"丫丫","Q妹");
        Penguin q4=new Penguin(4,"天天","Q仔");
        Penguin q5=new Penguin(5,"田田","Q妹");

        penguins.put("a",q1);
        penguins.put("b",q2);
        penguins.put("c",q3);
        penguins.put("d",q4);

        Iterator it=penguins.keySet().iterator();

        while (it.hasNext()){
            String key=(String)it.next();
            Penguin penguin=(Penguin)penguins.get(key);
            System.out.println(key+"\t\t"+penguin.getName()+"\t\t"+penguin.getSex());
        }
        System.out.println("=================foreach=================");
        for (Object str:penguins.keySet()){
            String key=(String)str;
            Penguin penguin=(Penguin)penguins.get(key);
            System.out.println(key+"\t\t"+penguin.getName()+"\t\t"+penguin.getSex());
        }
    }
}

测试结果：

a		欧欧		Q仔
b		美美		Q妹
c		丫丫		Q妹
d		天天		Q仔
=================foreach=================
a		欧欧		Q仔
b		美美		Q妹
c		丫丫		Q妹
d		天天		Q仔

Process finished with exit code 0

泛型和综合测试：

package penguinlist;


import java.util.*;

public class Test {
    public static void main(String[] args) {
        Penguin q1 = new Penguin(1, "欧欧", "Q仔");
        Penguin q2 = new Penguin(2, "丫丫", "Q妹");
        Penguin q3 = new Penguin(3, "花花", "Q妹");
        List<Penguin> list = new ArrayList<>();
        list.add(q1);
        list.add(q2);
        for (Penguin penguin : list) {
            System.out.println(penguin.getName() + "\t\t" + penguin.getSex());
        }
        for(int i = 0;i<list.size();i++){
            Penguin penguin = list.get(i);
            System.out.println(penguin.getName() + "\t\t" + penguin.getSex());
        }
        //Element
        LinkedList<Penguin> linkedList = new LinkedList<Penguin>();
        linkedList.add(q1);

        Set<Penguin> set =new HashSet<>();
        set.add(q1);
        set.add(q2);
        set.add(q3);
        System.out.println("========set=========");
        for(Penguin penguin : set){
            System.out.println(penguin);
        }

        System.out.println("=======map+======");
        Map<String ,Penguin>map=new HashMap<String ,Penguin>();
        map.put("a",q1);
        map.put("b",q2);
        map.put("c",q3);
        Iterator<String> it = map.keySet().iterator();
        while(it.hasNext()){
            String key = it.next();
            Penguin dog = map.get(key);
            System.out.println(dog);
        }

    }
}

测试结果：

欧欧		Q仔
丫丫		Q妹
欧欧		Q仔
丫丫		Q妹
========set=========
Penguin{id=3, name='花花', sex='Q妹'}
Penguin{id=2, name='丫丫', sex='Q妹'}
Penguin{id=1, name='欧欧', sex='Q仔'}
=======map+======
Penguin{id=1, name='欧欧', sex='Q仔'}
Penguin{id=2, name='丫丫', sex='Q妹'}
Penguin{id=3, name='花花', sex='Q妹'}

Process finished with exit code 0