java填充容器的几种方法

最新推荐文章于 2024-07-26 03:35:53 发布
最新推荐文章于 2024-07-26 03:35:53 发布
阅读量989 收藏
点赞数
分类专栏： 语言 文章标签： java 容器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sife_007/article/details/80231054
版权

1.使用Generator填充Collection

首先定义一个Generator的接口

public interface Generator<T> {
    T next();
}

用适配器模式将Generator适配到Collection的构造器上，这个类使用Generator在容器中放置所需数量的对象，然后所产生的容器可以传递给任何Collection的构造器。

public class CollectionData<T> extends ArrayList<T>{
    public CollectionData(Generator<T> gen, int quantity){
        for (int i = 0; i < quantity; i++){
            add(gen.next());
        }
    }
    public static <T> CollectionData<T> list(Generator<T> gen, int quantity){
        return new CollectionData<T>(gen, quantity);
    }
}

测试，addAll()方法是所有Collection子类型的一部分，用来组装现有的Collection。

class Goverment implements Generator{

    String[] foundation = ("strange women lying in ponds distributing swords" +
            " is no basis for a system of government").split(" ");
    private int index;
    @Override
    public Object next() {
        return foundation[index++];
    }
}
public class CollectionDataTest {

    public static void main(String[] args) {
        //构造器填充
        Set<String> set = new LinkedHashSet<String>(new CollectionData<String>(new Goverment(), 15));
        System.out.println(set);
        //list填充
        set.addAll(CollectionData.list(new Goverment(), 15));
        System.out.println(set);
    }
}

2.Map生成器

首先定义一个Pair类，因为为了组装Map，每次调用Generator的next()方法都必须产生一个“对象对”。key和value域都是public和final，为了使Pair成为只读的数据传输对象。

public class Pair<K,V> {
    public final K key;
    public final V value;
    public Pair(K k, V v){
        this.key = k;
        this.value = v;
    }
}

Map适配器

public class MapData<K,V> extends LinkedHashMap<K,V> {
    //参数为一个单独的pair的构造器
    public MapData(Generator<Pair<K,V>> gen, int quantity){
        for (int i = 0; i < quantity; i++){
            Pair<K,V> p = gen.next();
            put(p.key,p.value);
        }
    }
    //参数为两个不同Generator对象的构造器
    public MapData(Generator<K> genK, Generator<V> genV, int quantity){
        for (int i = 0; i < quantity; i++){
            put(genK.next(), genV.next());
        }
    }
    //key一个为Generator对象，value为普通对象的构造器
    public MapData(Generator<K> genK, V value, int quantity){
        for (int i = 0; i < quantity; i++){
            put(genK.next(), value);
        }
    }
    //key为迭代器对象，value为Generator对象
    public MapData(Iterable<K> genK, Generator<V> genV){
        for (K key : genK){
            put(key, genV.next());
        }
    }
    //key为迭代器对象，value为普通对象
    public MapData(Iterable<K> genK, V value){
        for (K key : genK){
            put(key, value);
        }
    }

    //对应的静态方法
    public static <K,V> MapData<K,V> map(Generator<Pair<K,V>> gen, int quantity){
        return new MapData<K, V>(gen,quantity);
    }
    public static <K,V> MapData<K,V> map(Generator<K> genK, Generator<V> genV, int quantity){
        return new MapData<K, V>(genK,genV, quantity);
    }
    public static <K,V> MapData<K,V> map(Generator<K> genK, V value, int quantity){
        return new MapData<K, V>(genK, value, quantity);
    }
    public static <K,V> MapData<K,V> map(Iterable<K> genK, Generator<V> genV){
        return new MapData<K, V>(genK, genV);
    }
    public static <K,V> MapData<K,V> map(Iterable<K> genK, V value){
        return new MapData<K, V>(genK, value);
    }
}

测试类

class Letters implements Generator<Pair<Integer,String>>,Iterable<Integer>{

    private int size = 9;
    private int number = 1;
    private char letter = 'A';

    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            @Override
            public boolean hasNext() {
                return number < size;
            }

            @Override
            public Integer next() {
                return number++;
            }

            public void remove(){
                throw new UnsupportedOperationException();
            }
        };
    }

    @Override
    public Pair<Integer, String> next() {
        return new Pair<Integer,String>(number++,"" + letter++);
    }
}
public class MapDataTest {
    public static void main(String[] args) {
        // Pair Generator
        System.out.println(MapData.map(new Letters(), 11));
        //Two separate generators
        System.out.println(MapData.map(new CountingGenerator.Character(),
                new RandomGenerator.String(3), 8));
        //a key Generator and a single value
        System.out.println(MapData.map(new CountingGenerator.Character(), "Value", 6));
        //An Iterable and a value Generator
        System.out.println(MapData.map(new Letters(), new RandomGenerator.String(3)));
        //An Iterable and a single value
        System.out.println(MapData.map(new Letters(), "Pop"));
    }
}
public class CountingGenerator {
    public static class Boolean implements Generator<java.lang.Boolean>{
        private boolean value = false;
        public java.lang.Boolean next(){
            value = !value;
            return value;
        }
    }
    public static class Byte implements Generator<java.lang.Byte>{
        private byte value = 0;
        public java.lang.Byte next(){
            return value++;
        }
    }
    static char[] chars = ("abcdefghijklmnopqrstuvwxyz" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ").toCharArray();
    public static class Character implements Generator<java.lang.Character>{
        int index = -1;
        public java.lang.Character next(){
            index = (index + 1) % chars.length;
            return chars[index];
        }
    }
    public static class String implements Generator<java.lang.String>{
        private int length = 7;
        Generator<java.lang.Character> cg = new Character();
        public String(){}
        public String(int length){
            this.length = length;
        }
        public java.lang.String next(){
            char[] buf = new char[length];
            for (int i = 0; i < length; i++){
                buf[i] = cg.next();
            }
            return new java.lang.String(buf);
        }
        public static class Short implements Generator<java.lang.Short>{
            private short value = 0;
            public java.lang.Short next(){
                return value++;
            }
        }
        public static class Integer implements Generator<java.lang.Integer>{
            private int value = 0;
            public java.lang.Integer next(){
                return value++;
            }
        }
        public static class Long implements Generator<java.lang.Long>{
            private long value = 0;
            public java.lang.Long next(){
                return value++;
            }
        }
        public static class Float implements Generator<java.lang.Float>{
            private float value = 0;
            public java.lang.Float next(){
                float result = value;
                value += 1.0;
                return result;
            }
        }
        public static class Double implements Generator<java.lang.Double>{
            private double value = 0;
            public java.lang.Double next(){
                double result = value;
                value += 1.0;
                return result;
            }
        }
    }
}
public class RandomGenerator {
    private static Random r= new Random(47);
    public static class Boolean implements Generator<java.lang.Boolean>{
        public java.lang.Boolean next(){
            return r.nextBoolean();
        }
    }
    public static class Byte implements Generator<java.lang.Byte>{
        public java.lang.Byte next(){
            return (byte)r.nextInt();
        }
    }
    public static class Character implements Generator<java.lang.Character>{
        public java.lang.Character next(){
            return CountingGenerator.chars[r.nextInt(CountingGenerator.chars.length)];
        }
    }
    public static class String extends CountingGenerator.String{
        {cg = new Character();}
        public String(){}
        public String(int length){super(length);}
    }
    public static class Integer implements Generator<java.lang.Integer>{
        private int mod = 10000;
        public Integer(){}
        public Integer(int modulo){mod = modulo;}
        public java.lang.Integer next(){
            return r.nextInt();
        }
    }
    public static class Short implements Generator<java.lang.Short>{
        public java.lang.Short next(){
            return (short)r.nextInt();
        }
    }
    public static class Long implements Generator<java.lang.Long>{
        private int mod = 10000;
        public Long(){}
        public Long(int module){mod = module;}
        public java.lang.Long next(){
            return new java.lang.Long(r.nextInt(mod));
        }
    }
    public static class Float implements Generator<java.lang.Float>{
        public java.lang.Float next(){
            //Math.round():四舍五入
            int trimmed = Math.round(r.nextFloat() * 100);
            return ((float)trimmed) / 100;
        }
    }
    public static class Double implements Generator<java.lang.Double>{
        public java.lang.Double next(){
            long trimmed = Math.round(r.nextDouble() * 100);
            return ((double)trimmed) / 100;
        }
    }
}

3.使用Abstract类

享元模式：可以在普通的解决方案需要过多的对象，或者产生普通对象太多时使用享元。享元模式使得对象的一部分可以被具体化，因此，与对象中的所有事物都包含在对象内部不同，我们可以在更加高效的外部表中查找对象的一部分或整体。
下面的实例通过继承java.util.Abstract来创建定制的MapCollection。为了创建只读的Map，可以继承AbstractMap并实现entrySet()。为了创建只读的Set，可以继承AbstractSet并实现iterator()和size()。

public class Countries {
    public static final String[][] DATA = {
            {"ALGERIA","Algiers"}, {"ANGOLA","Luanda"}, {"BENIN","Porto-Novo"},
            {"BOTSWANA","Gaberone"}, {"BURKINA FASO", "Ouagadoudou"}
    };
    //use AbstractMap by implementing entrySet()
    private static class FlyweightMap extends AbstractMap<String,String>{
        //Entry:Map中的一个对象，只存储对象的索引
        private static class Entry implements Map.Entry<String,String>{
            int index;
            Entry(int index){ this.index = index; }
            public boolean equals(Object o){
                return DATA[index][0].equals(o);
            }
            public String getKey() { return DATA[index][0]; }
            public String getValue() { return DATA[index][1]; }
            public String setValue(String value) {
                throw new UnsupportedOperationException();
            }
            public int hashCode(){
                return DATA[index][0].hashCode();
            }
        }
        //Use AbstractSet by implementing size() & iterator
        //Map对象的集合
        static class EntrySet extends AbstractSet<Map.Entry<String,String>>{
            private int size;
            EntrySet(int size){
                if (size < 0)
                    this.size = 0;
                else if (size > DATA.length)
                    this.size = DATA.length;
                else
                    this.size = size;
            }
            public int size() { return size; }
            //迭代Entry对象，迭代器只存储对象的索引
            private class Iter implements Iterator<Map.Entry<String,String>>{
                //Only one Entry object per Iterator
                private Entry entry = new Entry(-1);
                public boolean hasNext(){
                    return entry.index < size - 1;
                }
                public Map.Entry<String,String> next(){
                    entry.index++;
                    return entry;
                }
                public void remove(){
                    throw new UnsupportedOperationException();
                }
            }
            public Iterator<Map.Entry<String,String>> iterator(){
                return new Iter();
            }
        }
        private static Set<Map.Entry<String,String>> entries = new EntrySet(DATA.length);
        public Set<Map.Entry<String,String>> entrySet(){
            return entries;
        }
        //Create a partial(局部的) map of 'size' countries
        static Map<String,String> select(final int size){
            return new FlyweightMap(){
                public Set<Map.Entry<String,String>> entrySet(){
                    return new EntrySet(size);
                }
            };
        }
        static Map<String,String> map = new FlyweightMap();
        public static Map<String,String> capitals(){
            return map;
        }
        public static Map<String,String> capitals(int size){
            return select(size);
        }
        static List<String> names= new ArrayList<String>(map.keySet());
        public static List<String> names() { return names; }
        public static List<String> names(int size){
            return new ArrayList<String>(select(size).keySet());
        }
    }
}
Sife_007
关注
专栏目录
Java 中的几种基本数据类型是什么？对应的包装类型是什么？各自占用多少字节呢？
一切总会归于平淡
05-06 148
Java 中的几种基本数据类型是什么？对应的包装类型是什么？各自占用多少字节呢？
java画图填充多边形，给大家安排上！
m0_57700125的博客
07-12 264
本文框架如下 第一部分，主要是在阅读代码过程中的日志和笔记； 第二部分，主要介绍了 Redis 的主要框架，以及 Redis 是如何提供服务的，从一个最简单的命令开始讲起； 第三部分，主要介绍 Redis 底层用作存储的数据结构，这一部分很有趣； 第四部分，主要讲解了 Redis 的核心功能，包括持久化，订阅/发布模式，主从复制，事务机制，集群等等； 第五部分，展示了 Redis 几个简单的应用； 第六部分，介绍了 Redis 和 Memcached 的区别，以及稍稍讲解了 Memcached。 Tips：
Java容器填充-1
liyuming0000的专栏
10-31 1212
使用Collections.nCopies()和Collections.fill()实现对容器的简单填充。 具体代码如下： import java.util.ArrayList; import java.util.Collections; import java.util.List; public class FillingLists { public static void main
java容器的深入理解----填充
lihuihao2的博客
12-03 233
容器的填充，数组填充我前面提到了Arrays，那么容器呢，相应的也有Collections的一些方法，其中也有fill（）。下面我们看个示例： class StringAddress { private String s; public StringAddress(String s){this.s = s;} /*public String toString() { ...
java字符串 填充位数
最新发布
weixin_40881698的博客
07-26 15
字符串相关学习资料：https://edu.51cto.com/video/3832.htmlhttps://edu.51cto.com/video/4055.htmlJava字符串填充位数：新手指南 作为一名经验丰富的开发者，我经常被问到如何实现Java字符串的填充位数。对于刚入行的小白来说，这可能是一个比较棘手的问...
容器深入研究（2）：填充容器（下）
游王子的博客
04-05 217
一、使用Abstract类 对于生产用于容器的测试数据问题，另一种解决方式是创建定制的Collection和Map实现。每个java.util容器都有其自己的Abstract类，它们提供了该容器的部分实现，因此你必须做的只是去实现那些产生想要的容器所必需的方法。如果所产生的容器是只读的，就像它通常用测试数据那样，那么你需要提供的方法数量将减少到最少。 尽管在本例中不是特别需要，...
Java编程记录 --- 工具箱(填充中...)
xck503c
07-20 796
本篇是记录自己在学习中遇到一些用法(比较泛，只要是我认为比较奇怪，惊艳的，有价值的都可以)。还有一些我经常会用到的和一些有趣的封装，先记录吧，可能后面多了会很乱，到时再说。 字符串 null字符串 这是一个很有意思的现象，我到现在才知道，原来会出现 String name = null; System.out.println(name+""); System.out.println(""...
think in java填充容器（事例简述）
GP的空间
07-21 1264
在学习think in java 在容器深入研究--填充容器这一章节，刚开始看到的例子很是迷惑，后来做了下仔细研究，现在分享下。   摘自think in java中的一段代码： //: net/mindview/util/CountingMapData.java // Unlimited-length Map containing sample data. package net.mi
Java填充List容器方法及源码介绍
刘小义的博客
04-16 3811
Java填充List容器方法及源码介绍 Collections提供了两个填充容器的静态方法fill,nCopies 用法 // 创建一个存放int型的数组，同时填充四个整型对象1 List<Integer> intArr = new ArrayList<Integer>(Collections.nCopies(4, 1)); System....
Java容器简图.docx
05-08
Java提供了以下几种实现： - `HashSet`：基于`HashMap`实现，不保证元素顺序，插入和查找速度较快。 - `TreeSet`：实现了`SortedSet`接口，内部使用`TreeMap`，元素按自然顺序或自定义比较器进行排序。 - `...
java 重试_Java实现几种简单的重试机制
weixin_29264201的博客
03-05 2852
背景当业务执行失败之后，进行重试是一个非常常见的场景，那么如何在业务代码中优雅的实现重试机制呢？设计我们的目标是实现一个优雅的重试机制，那么先来看下怎么样才算是优雅无侵入：这个好理解，不改动当前的业务逻辑，对于需要重试的地方，可以很简单的实现可配置：包括重试次数，重试的间隔时间，是否使用异步方式等通用性：最好是无改动(或者很小改动)的支持绝大部分的场景，拿过来直接可用针对上面的几点，分别看下右什么...
java 设置组件填充_如何使Java Swing组件填充可用空间？
weixin_34551660的博客
02-27 634
我似乎不能让我的Java Swing组件一起工作正确。我想做的是，有一个JPanel填充JTabbedPane内的所有可用空间。目前，我的设置如下：public class Gui extends JFrame {private final EventBus eventBus = EventBus.getInstance();private final ToolkitUtil toolkitUti...
java容器的用法,Java 学习笔记(10)——容器
weixin_29271263的博客
03-22 176
之前学习了java中从语法到常用类的部分。在编程中有这样一类需求，就是要保存批量的相同数据类型。针对这种需求一般都是使用容器来存储。之前说过Java中的数组，但是数组不能改变长度。Java中提供了另一种存储方式，就是用容器类来处理这种需要动态添加或者删除元素的情况概述Java中最常见的容器有一维和多维。单维容器主要是一个节点上存储一个数据。比如列表和Set。而多维是一个节点有多个数据，例如Map，...
Java 对象头那点事
虚幻私塾
05-11 292
🚀 优质资源分享 🚀 学习路线指引（点击解锁） 知识定位 人群定位 🧡 Python实战微信订餐小程序 🧡 进阶级 本课程是python flask+微信小程序的完美结合，从项目搭建到腾讯云部署上线，打造一个全栈订餐系统。 💛Python量化交易实战💛 入门级 手把手带你打造一个易扩展、更安全、效率更高的量化交易系统 概览 对象头 存放：关于堆对象的布局、类型、GC状态、同步状态和标识哈希码的基本信息。Java对象和vm内部对象都有一个共同的对象头格式。 （后面做详细介绍） 实
java模板填充
mcband的博客
08-21 773
java模板
java 字符串 填充_如何在Java中填充字符串？
weixin_35808091的博客
02-12 2535
有一些简单的方法可以在Java中填充字符串吗？似乎应该在类似StringUtil的API中使用某些东西，但是我找不到能做到这一点的东西。#1楼这怎么样字符串为“ hello”，所需填充为15，左侧填充为“ 0”String ax="Hello";while(ax.length() < 15) ax="0"+ax;#2楼简单的事情：该值应该是一个字符串。 如果不是，则将其转换为字符串。 如""...
java实现颜色填充各种形状
热门推荐
ztyhhxx_的专栏
03-07 1万+
代码如下 import java.awt.*; import java.awt.event.*; public class test extends Frame {    public static final int SIDE = 100;    public static void main(String[] args) {      new test().launchFrame(
java 填充颜色_java 画圆，改变其填充颜色。设置的color 属性为什么不能改变其颜色...
weixin_30898967的博客
02-16 1144
g.setColor(Color.green);和你写的public void setColor(Color color) {this.color = color;repaint();}完全没有任何关系......你在jbt.addActionListener(new ActionListener(){@Overridepublic void actionPerformed(ActionEvent...
Java AWT图形界面编程：绘图与容器
本资源主要介绍了如何在Java中使用AWT进行绘图和用户界面设计，包括基本的绘图方法以及AWT中的容器、Frame和Panel的使用，还有布局管理器的概念。" 在Java编程中，AWT（抽象窗口工具包）提供了创建图形用户界面的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值