• Java-集合框架

    Java-集合框架

    1. 分类

    1. Collection Array and Linked
    2. Map hashmap
    3. 泛型集合（generic）有效解决强类型转换问题

    Dog class

    这是根据这个类为延伸的类

    package cn.collectionTest.output;

/**
 * @author Jensen
 * {@data 2022/11/9}
 */
public class Dog {
    private String name;
    private String type;

    public Dog(String name, String type){
        this.name = name;
        this.type = type;
    }

    /**
     * huoq
     * @return
     */
    public String getName() {
        return this.name;
    }

    public String getType() {
        return this.type;
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    ArrayList 使用方法 以及Iterator 遍历输出循环方法

    package cn.collectionTest.output;

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

/**
 * @author Jensen
 * {@data 2022/11/9}
 */
public class Test1 {
    public List dogs = new ArrayList();
    public void start(){
        Dog ououDog = new Dog("呕呕","雪纳瑞");
        Dog damiDog = new Dog("大米", "拉布拉多");
        Dog meimeiDog = new Dog("美美", "雪纳瑞");
        Dog feifeiDog = new Dog("菲菲","拉布拉多");

        /**
         * 正常插入
         */
        dogs.add(ououDog);
        dogs.add(damiDog);
        dogs.add(meimeiDog);
        /**
         * 菲菲狗狗插入到了第三位
         */
        dogs.add(2,feifeiDog);
        System.out.println("共计有"+dogs.size()+"只狗狗\n分别是： ");
        for (int i = 0;i < dogs.size(); i++){
            /**
             * 这里进行了强制转换哈
             */
            Dog dog = (Dog) dogs.get(i);
            System.out.println(dog.getName() + "\t" + dog.getType());
        }


    }
    public void run() {
        System.out.println("\n使用 Iterator 遍历 所有狗狗的信息以及种类分别是：");
        Iterator its = dogs.iterator();
        while (its.hasNext()) {
            Dog dog = (Dog) its.next(); //这里需要强类型转换;
            System.out.println(dog.getName() + "\t"+dog.getType());


        }

    }
    public static void main(String[] args) {
        Test1 start = new Test1();
        start.start();
        start.run();
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    package cn.collectionTest.output;

/**
 * @author Jensen
 * {@data 2022/11/9}
 */
import java.util.List;
import java.util.ArrayList;
public class Test2 {
    public void run(){
        Dog ououDog = new Dog("呕呕","雪纳瑞");
        Dog damiDog = new Dog("大米", "拉布拉多");
        Dog meimeiDog = new Dog("美美", "雪纳瑞");
        Dog feifeiDog = new Dog("菲菲","拉布拉多");

        /**
         * 定义一个列表需要导入两个库
         * import java.util.ArrayList;
         * import java.util.List;
         */
        List dogs = new ArrayList();
        /**
         * 正常插入
         */
        dogs.add(ououDog);
        dogs.add(damiDog);
        dogs.add(meimeiDog);
        /**
         * 菲菲狗狗插入到了第三位
         */
        dogs.add(2,feifeiDog);
        /**
         * 输出删除之前狗子
         */
        System.out.println("删除之前共有的"+dogs.size()+"狗狗");
        dogs.remove(0);
        dogs.remove(feifeiDog);
        /**
         * 输出删除后的狗狗
         */
        System.out.println("\n删除之后还有 "+dogs.size()+" 只狗狗\n分别是： ");
        for(int i = 0;i<dogs.size();i++){
            Dog dog = (Dog)  dogs.get(i);
            System.out.println(dog.getName()+"\t"+dog.getType());
        }
        if (dogs.contains(meimeiDog)){
            System.out.println("\n集合中包含美美的信息");
        }else {
            System.out.println("\n集合中不包含美美的信息");
        }
    }
    public static void main(String[] args) {
        Test2 start = new Test2();
        start.run();

    }

}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    package cn.collectionTest.output;

import java.util.ArrayList;
import java.util.List;
/**
 * @author Jensen
 * {@data 2022/11/9}
 */
public class Test3 {
    public void run(){
        /**
         * 定义初始数据
         */
        ComputerLanguage cp1 = new ComputerLanguage("java","5");
        ComputerLanguage cp2 = new ComputerLanguage("php","4");
        ComputerLanguage cp3 = new ComputerLanguage("python","3");
        ComputerLanguage cp4 = new ComputerLanguage("js","2");

        /**
         * 追加到集合ArraylList框架中
         */
        List list = new ArrayList();
        list.add(cp1);
        list.add(cp2);
        list.add(cp3);
        list.add(1,cp4);
        System.out.println("目前有 "+ list.size() + "个数据");
        System.out.println("*******************************");
        for (int i = 0; i < list.size(); i++) {
            ComputerLanguage cl = (ComputerLanguage) list.get(i);
            System.out.println("["+(i+1)+"] "+cl.getLanguage()+"\tleve: "+cl.getLevel());
        }
        System.out.println("*******************************");

        /**
         * 检测删除php操作
         */
        System.out.println("删除java数据：");
        if (list.contains(cp1)){
            list.remove(cp1);
            System.out.println(">>>java 数据已删除(200)\n");
        }else {
            System.out.println("java数据不存在");
        }

        System.out.println("(删除后)目前有 "+ list.size() + "个数据");
        System.out.println("*******************************");
        for (int i = 0; i < list.size(); i++) {
            ComputerLanguage cl = (ComputerLanguage) list.get(i);
            System.out.println("["+(i+1)+"] "+cl.getLanguage()+"\tleve: "+cl.getLevel());
        }
        System.out.println("*******************************");

    }
    public static void main(String[] args){
        Test3 t1 = new Test3();
        t1.run();

    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61

    LinkedList 使用方法

    package cn.collectionTest.output;

/**
 * @author Jensen
 * {@data 2022/11/9}
 */
import java.util.*;
public class Test4 {
    public void run(){
        Dog ououDog = new Dog("呕呕","雪纳瑞");
        Dog damiDog = new Dog("大米", "拉布拉多");
        Dog meimeiDog = new Dog("美美", "雪纳瑞");
        Dog feifeiDog = new Dog("菲菲","拉布拉多");

        /**
         * 这里需要定义LInkedList类 再自定义 dogs 别名 去实例化 LinkedList()这个类
         */
        LinkedList dogs = new LinkedList();
        /**
         * 正常插入
         */
        dogs.addFirst(feifeiDog);
        dogs.add(damiDog);
        dogs.add(meimeiDog);
        dogs.addLast(ououDog);

        /**
         * 查看集合中第一条狗狗信息
         * 此时应该是 feifeidog;
         */
        Dog dogsFirst = (Dog) dogs.getFirst();
        System.out.println("第一条狗狗名字 ： "+ dogsFirst.getName()+"\n品种是： "+dogsFirst.getType()+"\n");


        /**
         * 显示 呕呕 狗狗
         */
        Dog dogsLast = (Dog) dogs.getLast();
        System.out.println("最后一条狗狗名字 ： "+ dogsLast.getName()+"\n品种是： "+dogsLast.getType()+"\n");

        /**
         * 执行删除操作
         * 删除第一条和最后一条狗狗信息
         */
        dogs.removeFirst();
        dogs.removeLast();

        /**
         * 显示删除后的数据
         */
        System.out.println("现在是删除后的数据： " + dogs.size()+" 条");
        for (int i = 0; i < dogs.size(); i++) {
            Dog dog = (Dog) dogs.get(i);
            System.out.println(dog.getName() +"\t"+ dog.getType());

        }
    }
    public static void main(String[] args) {
        Test4 t1 = new Test4();
        t1.run();
    }

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63

    hashMap 使用法

    package cn.collectionTest.output;

/**
 * @author Jensen
 * {@data 2022/11/9}
 */

/**
 * 这两个类都需要引用才能使用
 */
import java.util.Map;
import java.util.HashMap;

public class Test5 {
    public void start(){
        Map countries = new HashMap();
        countries.put("CN","中国");
        countries.put("RU","俄罗斯");
        countries.put("FR","法国");
        countries.put("US","美国");
        String country = (String) countries.get("CN");
        System.out.println("CN 对应的国家是： "+country);

        /**
         * 显示总数
         */
        System.out.println("Map 总共有： "+countries.size()+" 个数据");

        /**
         * 判断Map中是否存在 FR key
         */
        System.out.println("\n判断Map中是否存在 FR key");
        if (countries.containsKey("FR")){
            System.out.println("Map 存在： "+countries.get("FR"));
        }else {
            System.out.println("不存在 FR");
        }

        /**
         * 分别显示key and values
         */
        System.out.println("\n这里是key的集合： "+countries.keySet());
        System.out.println("\n这里是values集合： "+countries.values());
        System.out.println("\n这里是key + values： "+countries);

        /**
         * 清空hashmap中所有数据
         */
        countries.clear();
        if(countries.isEmpty()){
            System.out.println("\nHashmap 已清空!");
        }
    }


    public static void main(String[] args) {
        Test5 test5 = new Test5();
        test5.start();
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61

    测试通过Ierator 遍历 List

    package cn.collectionTest.output;

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

/**
 * @author Jensen
 * {@data 2022/11/9}
 */
public class Test6 {
    public Map dogMap = new HashMap();
    /**
     * 测试通过Ierator 遍历 List
     */
    public void run(){
        Dog ououDog = new Dog("呕呕","雪纳瑞");
        Dog damiDog = new Dog("大米", "拉布拉多");
        Dog meimeiDog = new Dog("美美", "雪纳瑞");
        Dog feifeiDog = new Dog("菲菲","拉布拉多");

        /**
         * 这里使用了 hashmap 进行遍历;
         */
        dogMap.put(ououDog.getName(),ououDog);
        dogMap.put(damiDog.getName(),damiDog);
        dogMap.put(meimeiDog.getName(),meimeiDog);
        dogMap.put(feifeiDog.getName(),feifeiDog);

        /**
         * 通过迭代器一次输出集合中所有狗狗信息;
         */
        System.out.println(">>>这里使用Iterator进行遍历： \n所有狗狗信息分别是： \n");
        /**
         * 这里还要import 一个 Set 类;
         */
        Set Keys = dogMap.keySet(); // 取出key值
        Iterator it = Keys.iterator();  // 取出key值对应的values
        while (it.hasNext()) { //并循环里面的value达到一个遍历效果
           String key = (String) it.next(); // 不断下一个下一个输出
           Dog dog = (Dog) dogMap.get(key); //这里进行 输出宠物名称 值强类型转换
           System.out.println(key+"\t"+dog.getType()); //输出 狗子类型

        }


    }

    public void run2(){
        System.out.println("\n所有集合中的狗狗信息： ");
        Set keys = dogMap.keySet(); //取出所有key的集合;
        for(Object key:keys){
            Dog dog = (Dog) dogMap.get(key); //根据Key取出对应的值;
            System.out.println(key+"\t"+dog.getType());
        }

    }
    public static void main(String[] args) {
        Test6 t1 = new Test6();
        t1.run();
        t1.run2();

    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66

    泛型集合 (generic) hashMap

    package cn.collectionTest.output;

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

/**
 * @author Jensen
 * {@data 2022/11/9}
 */
import java.util.*;
public class GenericTest2 {
    /**
     * 标记元素类型
     * 否则会出现类型不兼容的情况
     */
    public Map<String, Dog> dogs = new HashMap<String,Dog>();

    public void start(){
        Dog ououDog = new Dog("呕呕","雪纳瑞");
        Dog damiDog = new Dog("大米", "拉布拉多");
        Dog meimeiDog = new Dog("美美", "雪纳瑞");
        Dog feifeiDog = new Dog("菲菲","拉布拉多");

        /**
         * 正常插入
         */
        dogs.put(ououDog.getName(), ououDog);
        dogs.put(damiDog.getName(), damiDog);
        dogs.put(meimeiDog.getName(), meimeiDog);
        dogs.put(feifeiDog.getName(), feifeiDog);

        System.out.println("使用iterator遍历所有的狗狗名称及品种: ");
        Set<String> keys = dogs.keySet();  //取出所有key的集合
        Iterator<String> it = keys.iterator(); // 获取Iterator对象
        while (it.hasNext()) {
            String key = it.next();  //取出key，无需类型强制转换
            Dog dog = dogs.get(key);  // 根据key取出对应的值，无需类型强制转换
            System.out.println(key+"\t"+dog.getType());
        }
    }

    public static void main(String[] args) {
        GenericTest2 test = new GenericTest2();
        test.start();

    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48

    泛型集合 (generic) ArrayList

    package cn.collectionTest.output;

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

/**
 * @author Jensen
 * {@data 2022/11/9}
 */
public class GenericTest1 {
    /**
     * 标记元素类型
     * 否则会出现类型不兼容的情况
     */
    public List <Dog> dogs = new ArrayList <Dog> ();

    public void start(){
        Dog ououDog = new Dog("呕呕","雪纳瑞");
        Dog damiDog = new Dog("大米", "拉布拉多");
        Dog meimeiDog = new Dog("美美", "雪纳瑞");
        Dog feifeiDog = new Dog("菲菲","拉布拉多");

        /**
         * 正常插入
         */
        dogs.add(ououDog);
        dogs.add(damiDog);
        dogs.add(meimeiDog);
        /**
         * 菲菲狗狗插入到了第三位
         */
        dogs.add(2,feifeiDog);
        Dog dog3 = (Dog) dogs.get(3);
        System.out.println("三个狗狗的信息如下： ");
        System.out.println(dog3.getName() + "\t" +dog3.getType());

        /**
         * 使用foreach语句遍历dogs对象
         */
        System.out.println("\n所有修勾信息如下:");
        for(Dog dog:dogs){
            System.out.println(dog.getName() + "\t" +dog.getType());
        }
    }

    public static void main(String[] args) {
        GenericTest1 test = new GenericTest1();
        test.start();

    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52

    最后做个总结：

    Java 的集合框架中有两大接口

    1. Collection

    其中有两个接口即： LIst 和 Set
    Collection接口存储一组不唯一，无序的对象；
    Set 接口继承 Collection 接口 ，存储一组唯一，无序的对象；
    List 接口 继承 Collection 接口， 存储一组不唯一，有序的对象；

    1. Map

    Map 接口存储一组成堆的 键-值对象，提供key到values的映射，key不要求有序，但不允许重复，value同样不要求有序，也不要求重复

    Java 八大类型：

    1. Byte
    2. Long
    3. Short
    4. Integer
    5. Double
    6. Boolean
    7. Float
    8. Character
  • 相关阅读:
    【PWN · ret2text | RISC-V异构】[2023 羊城杯]login
    GPT-4从0到1搭建一个Agent简介
    微软ML Copilot框架释放机器学习能力
    C++征途 --- 模板 --- 类模板
    利用SpringBoot框架轻松上手常用的设计模式
    JAVA面试中的SSM框架基础面试题
    Spring Bean 的生命周期，如何被管理的
    mysql之count（*）
    C++：构造函数与析构函数
    @Autowired 到底是怎么把变量注入进来的？
  • 原文地址：https://blog.csdn.net/qq_30036471/article/details/127764964