Java 运行时创建内存效率高的常量的技术_Java_Enums

Java 运行时创建内存效率高的常量的技术

java enums

Java 运行时创建内存效率高的常量的技术,java,enums,Java,Enums,目前，我的应用程序中有以下设计，使用enum作为内存效率常数 public enum Board { Toronto // Toronto stock Exchange } public class Stock { private final Board board; private final Code code; .... } 这是一种节省内存的方法。同样，如果一个证券交易所中有数千只股票，那么只会创建一个板实例 Stock stock0 = new

目前，我的应用程序中有以下设计，使用

enum

作为内存效率常数

public enum Board {
    Toronto    // Toronto stock Exchange
}

public class Stock {
    private final Board board;
    private final Code code;
    ....
}

这是一种节省内存的方法。同样，如果一个证券交易所中有数千只

股票

，那么只会创建一个

板

实例

Stock stock0 = new Stock(Code.newInstance("AAA.TO"), Board.Toronto);
Stock stock1 = new Stock(Code.newInstance("AAB.TO"), Board.Toronto);

// 2 Toronto board instance will be created! Not memory efficient when we have huge stock list.
Stock stock0 = new Stock(Code.newInstance("AAA.TO"), Board.newInstance("Toronto"));
Stock stock1 = new Stock(Code.newInstance("AAB.TO"), Board.newInstance("Toronto"));
Stock stock2 = new Stock(Code.newInstance("TRU.V"), Board.newInstance("TSXV"));

然而，这肯定有一些缺点。证券交易所将不时推出新的董事会。当这样的事情发生时，我需要

在enum
```
Board中添加新成员
```


编译并向用户重新部署应用程序



我想避免这样的不便。我最初的计划是
public class Board {
    private final String board;
    private Board(String board) {
        this.board = board;
    }
    public Board newInstance(String board) {
        return new Board(board);
    }
}

但是，这不是一种内存有效的方法。如图所示，将创建板的多个实例
Stock stock0 = new Stock(Code.newInstance("AAA.TO"), Board.Toronto);
Stock stock1 = new Stock(Code.newInstance("AAB.TO"), Board.Toronto);

// 2 Toronto board instance will be created! Not memory efficient when we have huge stock list.
Stock stock0 = new Stock(Code.newInstance("AAA.TO"), Board.newInstance("Toronto"));
Stock stock1 = new Stock(Code.newInstance("AAB.TO"), Board.newInstance("Toronto"));
Stock stock2 = new Stock(Code.newInstance("TRU.V"), Board.newInstance("TSXV"));

我想知道，我可以应用什么样的数据结构，这样我就可以有一种高效的内存方式来表示常量（在我的上下文中，它指的是板类）
我不喜欢使用String
，因为我更喜欢使用类型安全，以区分Board
和realString
嗯，将Board存储在集合或地图中如何？这样，您就可以确保每个实例只有一个实例
伪代码：
public class Board {
    private static final Set<Board> boards = new HashSet<>();

    public static Board getInstance(String board) {
        //search if board already exists on boards set, if it is, return that instance; else, add to list and return the newly created instance.
    }
    //override equals and hashCode appropriately
}

公共课程委员会{
私有静态最终集boards=新HashSet（）；
公共静态板getInstance（字符串板）{
//搜索boards集合中是否已存在boards，如果已存在，则返回该实例；否则，添加到列表并返回新创建的实例。
}
//适当地重写equals和hashCode
}
Hmm，把电路板存储在一组或一张地图中如何？这样，您就可以确保每个实例只有一个实例
伪代码：
public class Board {
    private static final Set<Board> boards = new HashSet<>();

    public static Board getInstance(String board) {
        //search if board already exists on boards set, if it is, return that instance; else, add to list and return the newly created instance.
    }
    //override equals and hashCode appropriately
}

公共课程委员会{
私有静态最终集boards=新HashSet（）；
公共静态板getInstance（字符串板）{
//搜索boards集合中是否已存在boards，如果已存在，则返回该实例；否则，添加到列表并返回新创建的实例。
}
//适当地重写equals和hashCode
}
Hmm，把电路板存储在一组或一张地图中如何？这样，您就可以确保每个实例只有一个实例
伪代码：
public class Board {
    private static final Set<Board> boards = new HashSet<>();

    public static Board getInstance(String board) {
        //search if board already exists on boards set, if it is, return that instance; else, add to list and return the newly created instance.
    }
    //override equals and hashCode appropriately
}

公共课程委员会{
私有静态最终集boards=新HashSet（）；
公共静态板getInstance（字符串板）{
//搜索boards集合中是否已存在boards，如果已存在，则返回该实例；否则，添加到列表并返回新创建的实例。
}
//适当地重写equals和hashCode
}
Hmm，把电路板存储在一组或一张地图中如何？这样，您就可以确保每个实例只有一个实例
伪代码：
public class Board {
    private static final Set<Board> boards = new HashSet<>();

    public static Board getInstance(String board) {
        //search if board already exists on boards set, if it is, return that instance; else, add to list and return the newly created instance.
    }
    //override equals and hashCode appropriately
}

公共课程委员会{
私有静态最终集boards=新HashSet（）；
公共静态板getInstance（字符串板）{
//搜索boards集合中是否已存在boards，如果已存在，则返回该实例；否则，添加到列表并返回新创建的实例。
}
//适当地重写equals和hashCode
}
在我看来，最好的解决方案是将Board添加到您的数据库中，当业务方提出新的Board时，您必须更新您的数据库，您的Board可能会日复一日地变化以适应业务需求，因此我认为它不适合常量或枚举，最好的解决方案是将Board添加到您的数据库中，当业务方提出新的Board时，您必须更新您的数据库，您的Board可能会日复一日地变化以适应业务需求，因此我认为它不适合常量或枚举，最好的解决方案是将Board添加到您的数据库中，当业务方提出新的Board时，您必须更新您的数据库，您的Board可能会日复一日地变化以适应业务需求，因此我认为它不适合常量或枚举，最好的解决方案是将Board添加到数据库中，当业务方提出新的Board时，您必须更新数据库。您的Board可能会日复一日地变化以适应业务需求，因此它不适合常量或枚举。这是一种线程安全的方法。我不确定这样的实现是否可以被视为Flyweight模式。然而，我已经尽了最大努力确保它是线程安全的。如果发现任何可能的故障，请随时修改代码
import java.util.concurrent.ConcurrentHashMap;

/**
 *
 * @author yccheok
 */
public class Board {
    private Board(String board) {
        this.board = board;
    }

    public static Board newInstance(String board) {
        if (board == null) {
            throw new java.lang.IllegalArgumentException("board cannot be null");
        }

        Board result = map.get(board);
        if (result == null) {
            final Board instance = new Board(board);
            result = map.putIfAbsent(board, instance);
            if (result == null) {
                return instance;
            }
        }

        assert(result != null);
        return result;
    }

    @Override
    public int hashCode() {
        int result = 17;
        result = 31 * result + board.hashCode();

        return result;
    }

    @Override
    public boolean equals(Object o) {
        if (o == this) {
            return true;
        }

        if (!(o instanceof Board)) {
            return false;
        }

        return this.board.equals(((Board)o).board);
    }

    @Override
    public String toString() {
        return board;
    }

    // Avoid using interface. We want it to be fast!
    private static final ConcurrentHashMap<String, Board> map = new ConcurrentHashMap<>();
    private final String board;
}

import java.util.concurrent.ConcurrentHashMap；
/**
*
*@作者yccheok
*/
公共班级委员会{
专用板（线板）{
this.board=董事会；
}
公共静态板newInstance（字符串板）{
如果（线路板==null）{
抛出新的java.lang.IllegalArgumentException（“board不能为null”）；
}
线路板结果=map.get（线路板）；
如果（结果==null）{
最终板实例=新板（板）；
结果=map.putIfAbsent（板、实例）；
如果（结果==null）{
返回实例；
}
}
断言（结果！=null）；
返回结果；
}
@凌驾
公共int hashCode（）{
int结果=17；
结果=31*result+board.hashCode（）；
返回结果；
}
@凌驾
公共布尔等于（对象o）{
如果（o==这个）{
返回true；
}
如果（！（o板实例））{
返回false；
}
返回此.board.equals（（board）o.board）；
}
@凌驾
公共字符串toString（）{
返回板；
}
//避免使用界面。我们希望它是快速的！
私有静态最终ConcurrentHashMap=新ConcurrentHashMap（）；
私人终审委员会；
}
这是一种线程安全的方法。我不确定这样的实现是否可以被视为Flyweight模式。然而，我已经尽了最大努力确保它是线程安全的。如果发现任何可能的故障，请随时修改代码
import java.util.concurrent.ConcurrentHashMap;

/**
 *
 * @author yccheok
 */
public class Board {
    private Board(String board) {
        this.board = board;
    }

    public static Board newInstance(String board) {
        if (board == null) {
            throw new java.lang.IllegalArgumentException("board cannot be null");
        }

        Board result = map.get(board);
        if (result == null) {
            final Board instance = new Board(board);
            result = map.putIfAbsent(board, instance);
            if (result == null) {
                return instance;
            }
        }

        assert(result != null);
        return result;
    }

    @Override
    public int hashCode() {
        int result = 17;
        result = 31 * result + board.hashCode();

        return result;
    }

    @Override
    public boolean equals(Object o) {
        if (o == this) {
            return true;
        }

        if (!(o instanceof Board)) {
            return false;
        }

        return this.board.equals(((Board)o).board);
    }

    @Override
    public String toString() {
        return board;
    }

    // Avoid using interface. We want it to be fast!
    private static final ConcurrentHashMap<String, Board> map = new ConcurrentHashMap<>();
    private final String board;
}

import java.util.concurrent.ConcurrentHashMap；
/**
*
*@作者yccheok
*/
公共班级委员会{
公共关系