Java-数组集合

最新推荐文章于 2025-05-15 17:11:29 发布

Jensen_79

最新推荐文章于 2025-05-15 17:11:29 发布

阅读量483

点赞数

分类专栏： JAVA 文章标签： java 开发语言 jvm

本文链接：https://blog.youkuaiyun.com/qq_30036471/article/details/127914021

版权

JAVA 专栏收录该内容

16 篇文章

订阅专栏

Java-数组集合

过程中用到一些类也记录一下主要是配合集合搭配使用的

1. Student Class

package cn.collectionTest.output;

/**
 * @author Jensen
 * {@data 2022/11/17}
 */
public class Student {
    private String key;
    private String pass;

    public Student() {
    }

    public Student(String key, String pass) {
        this.key = key;
        this.pass = pass;
    }

    public String getKey() {
        return key;
    }

    public void setKey(String key) {
        this.key = key;
    }

    public String getPass() {
        return pass;
    }

    public void setPass(String pass) {
        this.pass = pass;
    }

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

2. EncryptionDAO Class

package cn.collectionTest.output;

import java.util.Objects;

/**
 * @author Jensen
 * {@data 2022/11/17}
 */
public class EncryptionDAO {
    private int index;
    private String data;

    public EncryptionDAO() {
    }

    public EncryptionDAO(int index, String data) {
        this.index = index;
        this.data = data;
    }

    @Override
    public String toString() {
        return "EncryptionDAO{" +
                "index=" + index +
                ", data='" + data + '\'' +
                '}';
    }

    public int getIndex() {
        return index;
    }

    public void setIndex(int index) {
        this.index = index;
    }

    public String getData() {
        return data;
    }

    public void setData(String data) {
        this.data = data;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        EncryptionDAO that = (EncryptionDAO) o;
        return index == that.index && Objects.equals(data, that.data);
    }

    @Override
    public int hashCode() {
        return Objects.hash(index, data);
    }
}

CollectionsGather Class

里面包含了运用到的数组集合示例以及笔记内容

package cn.collectionTest.output;

import java.util.*;

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

public class CollectionsGather {
    /**
     * 泛型示例
     */
    public void genericityTest(){
        /**
         * 类型更安全
         * 避免类型转换
         * 泛型一般只和集合类结合使用
         * 泛型是jdk5的新特性
         * 从jdk7开始泛型也被称之为菱形泛型
         *     Tips: 因为后面不用在写具体类型两个<>就像个菱形
         */
        List<String> strings = new ArrayList<>();
        strings.add("Zmpsa3NkamZrbHNkam");
        strings.add("Zsa2RzamtsanNka2xmanN");
        strings.add("c2Rmc2Rmc2Rmc2Rmc");
        ListIterator<String> literals = strings.listIterator();
        while (literals.hasNext()) {
            String aa = (String) literals.next();
            if ("c2Rmc2Rmc2Rmc2Rmc".equals(aa)){
                literals.add("Rmc2RmZHNmZA==");
            }
        }
        int count = 0;
        for (String string : strings) {
            try {
                Thread.sleep(1000);
            }catch (InterruptedException e) {
                e.printStackTrace();
            }
            count ++;
            System.out.println("正在读取数据： "+count+"\t"+string);
        }
        System.out.println(">>>读取完毕{200}");

    }

    /**
     * ArrayList示例
     * Iterator示例
     * ListIterator示例
     */
    public void arrayTest(){
        List list = new ArrayList();
        list.add("aGVsbG93b3JsZAo=");
        list.add("aGVsbG93b3JsZAo=");
        list.add("aGVsbG93b3JsCg==");
        list.add("aGVsbG93b3JsZAo=");

        //增强for循环
        for (Object o : list) {
            System.out.println(o);
        }

        /**
         * 迭代器普通用法
         */
        System.out.println("______________________");
        Iterator it = list.iterator();
        while (it.hasNext()) {
            String test = (String) it.next();
            System.out.println(test);
        }
        /**
         * 列表迭代器： listIterator
         * 用途增加数据
         */
        ListIterator lit = list.listIterator();
        while (lit.hasNext()) {
            /**
             * 获取元素并向下转型成String类型
             */
            String test = (String) lit.next();
            if ("aGVsbG93b3JsCg==".equals(test)){
                lit.add("5paw5aKe5pWw5o2uCg==");
            }
        }
        System.out.println(list);




    }

    /**
     * Collections工具类的使用
     */
    public void collections() {
        List<Integer> encrypSave = new ArrayList<>();
        encrypSave.add(1);
        encrypSave.add(2);
        encrypSave.add(3);
        encrypSave.add(4);
        encrypSave.add(5);
        /**
         * 获取最大数值
         */
        Integer max = Collections.max(encrypSave);
        Integer min = Collections.min(encrypSave);
        System.out.println("最大的是："+max+"\n最小的是："+min);
        /**
         * 从小到大排序
         * 是直接重新写入到List集合里面了的
         */
        Collections.sort(encrypSave);
        System.out.println("排序之后: "+encrypSave);
        /**
         * 倒序排列,前提是要先正序排列之后才能倒序
         */
        Collections.reverse(encrypSave);
        System.out.println("倒序之后："+encrypSave);

        /**
         * shuffle: 置乱/洗牌
         * 特点： 每次洗牌都不一样
         */
        Collections.shuffle(encrypSave);
        System.out.println("洗牌： "+encrypSave);





    }

    /**
     * Set集合示例
     */
    public void setTest(){
        /**
         * 特点： 无序(元素存储位置不一致)， 具有唯一性;
         * 需求： 往Set添加4个对象，然后通过iterator遍历;
         * 总结： Set集合保证唯一性的依赖： equals() and hashCode();
         */
        /**
         * 1. 创建集合对象
         */
        Set<EncryptionDAO> set = new HashSet<>();
        /**
         * 添加元素对象
         */
        EncryptionDAO d1 = new EncryptionDAO(1,"Zmpsa3NkamZrbHNkam");
        EncryptionDAO d2 = new EncryptionDAO(2,"Zsa2RzamtsanNka2xmanN");
        EncryptionDAO d5 = new EncryptionDAO(2,"Zsa2RzamtsanNka2xmanN");
        EncryptionDAO d3 = new EncryptionDAO(3,"c2Rmc2Rmc2Rmc2Rmc");
        EncryptionDAO d4 = new EncryptionDAO(4,"Rmc2RmZHNmZA==");
        EncryptionDAO d6 = new EncryptionDAO(3,"c2Rmc2Rmc2Rmc2Rmc");
        /**
         * 往Set集合里面添加元素对象
         */
        set.add(d1);
        set.add(d2);
        set.add(d3);
        set.add(d4);
        set.add(d5);
        set.add(d6);

        /**
         * 普通输出
         */
        System.out.println("***************************");
        System.out.println(set);

        /**
         * 增强for循环进行遍历输出
         */
        System.out.println("***************************");
        for (EncryptionDAO encryptionDAO : set) {
            System.out.println(encryptionDAO);
        }

        /**
         * 迭代器进行循环
         */
        System.out.println("***************************");
        Iterator<EncryptionDAO> it = set.iterator();
        while (it.hasNext()) {
            /**
             * 对象名 实例名
             */
            EncryptionDAO a = it.next();
            System.out.println(a);
        }
        /**
         *  为什么Set没有去重;
         *  因为Set集合保证数据唯一性是依赖equals() and hashCode()这两个方法；
         *  因为EncryptionDAO这个类中没有重写 这两个方法;
         *  所以默认调用的是object里面的这两个方法;
         *  所以此时Set默认通过Object查重机制也是通过内存地址的唯一性进行评定的;
         *  重d1开始每次都是new一个新的元素对象所以这里就有没有去重的假象了;
         *  解决方案：
         *      1. 重写 equals() and hashCode()
         */

    }

    /**
     * Map示例
     */
    public void mapTest(){
        /*
        Map<Integer, EncryptionDAO> map = new HashMap<>();
        EncryptionDAO d1 = new EncryptionDAO(1,"123456789");
        EncryptionDAO s1 = map.put(d1.getIndex(), d1);
        System.out.println(s1);
        System.out.println(d1);
         */
        /**
         * 设置一个map集合
         */
        Map<Integer, EncryptionDAO> map = new HashMap<>();
        //创建新元素对象
        EncryptionDAO e1 = new EncryptionDAO(1,"123");
        EncryptionDAO e2 = new EncryptionDAO(2,"456");
        EncryptionDAO e3 = new EncryptionDAO(3,"789");

        EncryptionDAO i1 = map.put(1, e1);
        EncryptionDAO i2 = map.put(2, e2);
        EncryptionDAO i3 = map.put(3, e3);
        /**
         * 这是覆盖key(1) value 的值；
         * EncryptionDAO i2 = map.put(1, e2);
         */

        /**
         * 增强for循环输出内容
         */
        for (Integer integer : map.keySet()) {
            // 获取map 的所有key值 类似于 map.length();  System.out.println(integer);
            System.out.println("Key: "+integer+" Values: "+map.get(integer));
        }
        /**
         * iterator
         */
        System.out.println("**************************");
        Iterator<Integer> it = map.keySet().iterator();
        while (it.hasNext()) {
            /**
             * 获取map 的所有key值 类似于 map.length();
             */
            int nums = it.next();
            System.out.println(">>>Iterator: Key = "+nums+" values: "+map.get(nums));
        }
    }

    public static void main(String[] args) {
        CollectionsGather t1 = new CollectionsGather();
        //1. 泛型示例;
        //t1.genericityTest();
        //2. ArrayList示例;
        //t1.arrayTest();
        //3. Collections 工具类的使用;
        //t1.collections();
        //4. Set集合示例;
        //t1.setTest();
        //5. Map集合示例;
        t1.mapTest();


    }

}