diff --git a/icu4j/main/classes/core/src/com/ibm/icu/impl/units/MeasureUnitImpl.java b/icu4j/main/classes/core/src/com/ibm/icu/impl/units/MeasureUnitImpl.java
new file mode 100644
index 0000000..db98db0
--- /dev/null
+++ b/icu4j/main/classes/core/src/com/ibm/icu/impl/units/MeasureUnitImpl.java
@@ -0,0 +1,737 @@
+// © 2020 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+
+package com.ibm.icu.impl.units;
+
+import com.ibm.icu.util.*;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+
+public class MeasureUnitImpl {
+
+    /**
+     * The full unit identifier.  Null if not computed.
+     */
+    private String identifier = null;
+
+    /**
+     * The complexity, either SINGLE, COMPOUND, or MIXED.
+     */
+    private MeasureUnit.Complexity complexity = MeasureUnit.Complexity.SINGLE;
+
+    /**
+     * The list of simple units. These may be summed or multiplied, based on the
+     * value of the complexity field.
+     * <p>
+     * The "dimensionless" unit (SingleUnitImpl default constructor) must not be
+     * added to this list.
+     * <p>
+     * The "dimensionless" <code>MeasureUnitImpl</code> has an empty <code>singleUnits</code>.
+     */
+    private ArrayList<SingleUnitImpl> singleUnits;
+
+    public MeasureUnitImpl() {
+        singleUnits = new ArrayList<>();
+    }
+
+    public MeasureUnitImpl(SingleUnitImpl singleUnit) {
+        this();
+        this.appendSingleUnit(singleUnit);
+    }
+
+    /**
+     * Parse a unit identifier into a MeasureUnitImpl.
+     *
+     * @param identifier The unit identifier string.
+     * @return A newly parsed object.
+     * @throws <code>IllegalArgumentException</code> in case of incorrect/non-parsed identifier.
+     */
+    public static MeasureUnitImpl forIdentifier(String identifier) {
+        return UnitsParser.parseForIdentifier(identifier);
+    }
+
+    /**
+     * Used for currency units.
+     */
+    public static MeasureUnitImpl forCurrencyCode(String currencyCode) {
+        MeasureUnitImpl result = new MeasureUnitImpl();
+        result.identifier = currencyCode;
+        return result;
+    }
+
+    public MeasureUnitImpl clone() {
+        MeasureUnitImpl result = new MeasureUnitImpl();
+        result.complexity = this.complexity;
+        result.identifier = this.identifier;
+        result.singleUnits = (ArrayList<SingleUnitImpl>) this.singleUnits.clone();
+        return result;
+    }
+
+    /**
+     * Returns the list of simple units.
+     */
+    public ArrayList<SingleUnitImpl> getSingleUnits() {
+        return singleUnits;
+    }
+
+    /**
+     * Mutates this MeasureUnitImpl to take the reciprocal.
+     */
+    public void takeReciprocal() {
+        this.identifier = null;
+        for (SingleUnitImpl singleUnit :
+                this.singleUnits) {
+            singleUnit.setDimensionality(singleUnit.getDimensionality() * -1);
+        }
+    }
+
+    /**
+     * Extracts the list of all the individual units inside the `MeasureUnitImpl`.
+     * For example:
+     * -   if the <code>MeasureUnitImpl</code> is <code>foot-per-hour</code>
+     * it will return a list of 1 <code>{foot-per-hour}</code>
+     * -   if the <code>MeasureUnitImpl</code> is <code>foot-and-inch</code>
+     * it will return a list of 2 <code>{ foot, inch}</code>
+     *
+     * @return a list of <code>MeasureUnitImpl</code>
+     */
+    public ArrayList<MeasureUnitImpl> extractIndividualUnits() {
+        ArrayList<MeasureUnitImpl> result = new ArrayList<MeasureUnitImpl>();
+        if (this.getComplexity() == MeasureUnit.Complexity.MIXED) {
+            // In case of mixed units, each single unit can be considered as a stand alone MeasureUnitImpl.
+            for (SingleUnitImpl singleUnit :
+                    this.getSingleUnits()) {
+                result.add(new MeasureUnitImpl(singleUnit));
+            }
+
+            return result;
+        }
+
+        result.add(this.clone());
+        return result;
+    }
+
+    /**
+     * Mutates this MeasureUnitImpl to append a single unit.
+     *
+     * @return true if a new item was added. If unit is the dimensionless unit,
+     * it is never added: the return value will always be false.
+     */
+    public boolean appendSingleUnit(SingleUnitImpl singleUnit) {
+        identifier = null;
+
+        if (singleUnit == null) {
+            // We don't append dimensionless units.
+            return false;
+        }
+
+        // Find a similar unit that already exists, to attempt to coalesce
+        SingleUnitImpl oldUnit = null;
+        for (int i = 0, n = this.singleUnits.size(); i < n; i++) {
+            SingleUnitImpl candidate = this.singleUnits.get(i);
+            if (candidate.isCompatibleWith(singleUnit)) {
+                oldUnit = candidate;
+                break;
+            }
+        }
+
+        if (oldUnit != null) {
+            // Both dimensionalities will be positive, or both will be negative, by
+            // virtue of isCompatibleWith().
+            oldUnit.setDimensionality(oldUnit.getDimensionality() + singleUnit.getDimensionality());
+
+            return false;
+        }
+
+        // Add a copy of singleUnit
+        this.singleUnits.add(singleUnit.clone());
+
+        // If the MeasureUnitImpl is `UMEASURE_UNIT_SINGLE` and after the appending a unit, the singleUnits are more
+        // than one singleUnit. thus means the complexity should be `UMEASURE_UNIT_COMPOUND`
+        if (this.singleUnits.size() > 1 && this.complexity == MeasureUnit.Complexity.SINGLE) {
+            this.setComplexity(MeasureUnit.Complexity.COMPOUND);
+        }
+
+        return true;
+    }
+
+    /**
+     * Transform this MeasureUnitImpl into a MeasureUnit, simplifying if possible.
+     * <p>
+     * NOTE: this function must be called from a thread-safe class
+     */
+    public MeasureUnit build() {
+        return MeasureUnit.fromMeasureUnitImpl(this);
+    }
+
+    /**
+     * @return SingleUnitImpl
+     * @throws UnsupportedOperationException if the object could not be converted to SingleUnitImpl.
+     */
+    public SingleUnitImpl getSingleUnitImpl() {
+        if (this.singleUnits.size() == 0) {
+            return new SingleUnitImpl();
+        }
+        if (this.singleUnits.size() == 1) {
+            return this.singleUnits.get(0).clone();
+        }
+
+        throw new UnsupportedOperationException();
+    }
+
+
+    /**
+     * Returns the CLDR unit identifier and null if not computed.
+     */
+    public String getIdentifier() {
+        return identifier;
+    }
+
+    public MeasureUnit.Complexity getComplexity() {
+        return complexity;
+    }
+
+    public void setComplexity(MeasureUnit.Complexity complexity) {
+        this.complexity = complexity;
+    }
+
+    /**
+     * Normalizes the MeasureUnitImpl and generates the identifier string in place.
+     */
+    public void serialize() {
+        if (this.getSingleUnits().size() == 0) {
+            // Dimensionless, constructed by the default constructor: no appending
+            // to this.result, we wish it to contain the zero-length string.
+            return;
+        }
+        if (this.complexity == MeasureUnit.Complexity.COMPOUND) {
+            // Note: don't sort a MIXED unit
+            Collections.sort(this.getSingleUnits(), new SingleUnitComparator());
+        }
+
+        StringBuilder result = new StringBuilder();
+        boolean beforePer = true;
+        boolean firstTimeNegativeDimension = false;
+        for (SingleUnitImpl singleUnit :
+                this.getSingleUnits()) {
+            if (beforePer && singleUnit.getDimensionality() < 0) {
+                beforePer = false;
+                firstTimeNegativeDimension = true;
+            } else if (singleUnit.getDimensionality() < 0) {
+                firstTimeNegativeDimension = false;
+            }
+
+            String singleUnitIdentifier = singleUnit.getNeutralIdentifier();
+            if (this.getComplexity() == MeasureUnit.Complexity.MIXED) {
+                if (result.length() != 0) {
+                    result.append("-and-");
+                }
+            } else {
+                if (firstTimeNegativeDimension) {
+                    if (result.length() == 0) {
+                        result.append("per-");
+                    } else {
+                        result.append("-per-");
+                    }
+                } else {
+                    if (result.length() != 0) {
+                        result.append("-");
+                    }
+                }
+            }
+
+            result.append(singleUnitIdentifier);
+        }
+
+        this.identifier = result.toString();
+    }
+
+    public enum CompoundPart {
+        // Represents "-per-"
+        PER(0),
+        // Represents "-"
+        TIMES(1),
+        // Represents "-and-"
+        AND(2);
+
+        private final int index;
+
+        CompoundPart(int index) {
+            this.index = index;
+        }
+
+        public static CompoundPart getCompoundPartFromTrieIndex(int trieIndex) {
+            int index = trieIndex - UnitsData.Constants.kCompoundPartOffset;
+            switch (index) {
+                case 0:
+                    return CompoundPart.PER;
+                case 1:
+                    return CompoundPart.TIMES;
+                case 2:
+                    return CompoundPart.AND;
+                default:
+                    throw new AssertionError("CompoundPart index must be 0, 1 or 2");
+            }
+        }
+
+        public int getTrieIndex() {
+            return this.index + UnitsData.Constants.kCompoundPartOffset;
+        }
+
+        public int getValue() {
+            return index;
+        }
+    }
+
+    public enum PowerPart {
+        P2(2),
+        P3(3),
+        P4(4),
+        P5(5),
+        P6(6),
+        P7(7),
+        P8(8),
+        P9(9),
+        P10(10),
+        P11(11),
+        P12(12),
+        P13(13),
+        P14(14),
+        P15(15);
+
+        private final int power;
+
+        PowerPart(int power) {
+            this.power = power;
+        }
+
+        public static int getPowerFromTrieIndex(int trieIndex) {
+            return trieIndex - UnitsData.Constants.kPowerPartOffset;
+        }
+
+        public int getTrieIndex() {
+            return this.power + UnitsData.Constants.kPowerPartOffset;
+        }
+
+        public int getValue() {
+            return power;
+        }
+    }
+
+    public enum InitialCompoundPart {
+
+        // Represents "per-", the only compound part that can appear at the start of
+        // an identifier.
+        INITIAL_COMPOUND_PART_PER(0);
+
+        private final int index;
+
+        InitialCompoundPart(int powerIndex) {
+            this.index = powerIndex;
+        }
+
+        public static InitialCompoundPart getInitialCompoundPartFromTrieIndex(int trieIndex) {
+            int index = trieIndex - UnitsData.Constants.kInitialCompoundPartOffset;
+            if (index == 0) {
+                return INITIAL_COMPOUND_PART_PER;
+            }
+
+            throw new IllegalArgumentException("Incorrect trieIndex");
+        }
+
+        public int getTrieIndex() {
+            return this.index + UnitsData.Constants.kInitialCompoundPartOffset;
+        }
+
+        public int getValue() {
+            return index;
+        }
+
+    }
+
+    public static class UnitsParser {
+        // This used only to not build the trie each time we use the parser
+        private volatile static CharsTrie savedTrie = null;
+        private final String[] simpleUnits;
+        // This trie used in the parsing operation.
+        private CharsTrie trie;
+        // Tracks parser progress: the offset into fSource.
+        private int fIndex = 0;
+        // Set to true when we've seen a "-per-" or a "per-", after which all units
+        // are in the denominator. Until we find an "-and-", at which point the
+        // identifier is invalid pending TODO(CLDR-13700).
+        private boolean fAfterPer = false;
+        private String fSource;
+        // If an "-and-" was parsed prior to finding the "single
+        //     * unit", sawAnd is set to true. If not, it is left as is.
+        private boolean fSawAnd = false;
+
+        private UnitsParser(String identifier) {
+            this.simpleUnits = UnitsData.getSimpleUnits();
+            this.fSource = identifier;
+
+            if (UnitsParser.savedTrie != null) {
+                try {
+                    this.trie = UnitsParser.savedTrie.clone();
+                } catch (CloneNotSupportedException e) {
+                    throw new ICUCloneNotSupportedException();
+                }
+                return;
+            }
+
+            // Building the trie.
+            CharsTrieBuilder trieBuilder;
+            trieBuilder = new CharsTrieBuilder();
+
+            // Add syntax parts (compound, power prefixes)
+            trieBuilder.add("-per-", CompoundPart.PER.getTrieIndex());
+            trieBuilder.add("-", CompoundPart.TIMES.getTrieIndex());
+            trieBuilder.add("-and-", CompoundPart.AND.getTrieIndex());
+            trieBuilder.add("per-", InitialCompoundPart.INITIAL_COMPOUND_PART_PER.getTrieIndex());
+            trieBuilder.add("square-", PowerPart.P2.getTrieIndex());
+            trieBuilder.add("cubic-", PowerPart.P3.getTrieIndex());
+            trieBuilder.add("pow2-", PowerPart.P2.getTrieIndex());
+            trieBuilder.add("pow3-", PowerPart.P3.getTrieIndex());
+            trieBuilder.add("pow4-", PowerPart.P4.getTrieIndex());
+            trieBuilder.add("pow5-", PowerPart.P5.getTrieIndex());
+            trieBuilder.add("pow6-", PowerPart.P6.getTrieIndex());
+            trieBuilder.add("pow7-", PowerPart.P7.getTrieIndex());
+            trieBuilder.add("pow8-", PowerPart.P8.getTrieIndex());
+            trieBuilder.add("pow9-", PowerPart.P9.getTrieIndex());
+            trieBuilder.add("pow10-", PowerPart.P10.getTrieIndex());
+            trieBuilder.add("pow11-", PowerPart.P11.getTrieIndex());
+            trieBuilder.add("pow12-", PowerPart.P12.getTrieIndex());
+            trieBuilder.add("pow13-", PowerPart.P13.getTrieIndex());
+            trieBuilder.add("pow14-", PowerPart.P14.getTrieIndex());
+            trieBuilder.add("pow15-", PowerPart.P15.getTrieIndex());
+
+            // Add SI prefixes
+            for (MeasureUnit.SIPrefix siPrefix :
+                    MeasureUnit.SIPrefix.values()) {
+                trieBuilder.add(siPrefix.getIdentifier(), getTrieIndex(siPrefix));
+            }
+
+            // Add simple units
+            for (int i = 0; i < simpleUnits.length; i++) {
+                trieBuilder.add(simpleUnits[i], i + UnitsData.Constants.kSimpleUnitOffset);
+
+            }
+
+            // TODO: Use SLOW or FAST here?
+            UnitsParser.savedTrie = trieBuilder.build(StringTrieBuilder.Option.FAST);
+
+            try {
+                this.trie = UnitsParser.savedTrie.clone();
+            } catch (CloneNotSupportedException e) {
+                throw new ICUCloneNotSupportedException();
+            }
+        }
+
+
+        /**
+         * Construct a MeasureUnit from a CLDR Unit Identifier, defined in UTS 35.
+         * Validates and canonicalizes the identifier.
+         *
+         * @return MeasureUnitImpl object or null if the identifier is empty.
+         * @throws IllegalArgumentException in case of invalid identifier.
+         */
+        public static MeasureUnitImpl parseForIdentifier(String identifier) {
+            if (identifier == null || identifier.isEmpty()) {
+                return null;
+            }
+
+            UnitsParser parser = new UnitsParser(identifier);
+            return parser.parse();
+
+        }
+
+        private static MeasureUnit.SIPrefix getSiPrefixFromTrieIndex(int trieIndex) {
+            for (MeasureUnit.SIPrefix element :
+                    MeasureUnit.SIPrefix.values()) {
+                if (getTrieIndex(element) == trieIndex)
+                    return element;
+            }
+
+            throw new IllegalArgumentException("Incorrect trieIndex");
+        }
+
+        private static int getTrieIndex(MeasureUnit.SIPrefix prefix) {
+            return prefix.getSiPrefixPower() + UnitsData.Constants.kSIPrefixOffset;
+        }
+
+        private MeasureUnitImpl parse() {
+            MeasureUnitImpl result = new MeasureUnitImpl();
+
+            if (fSource.isEmpty()) {
+                // The dimensionless unit: nothing to parse. return null.
+                return null;
+            }
+
+            while (hasNext()) {
+                fSawAnd = false;
+                SingleUnitImpl singleUnit = nextSingleUnit();
+
+                boolean added = result.appendSingleUnit(singleUnit);
+                if (fSawAnd && !added) {
+                    throw new IllegalArgumentException("Two similar units are not allowed in a mixed unit.");
+                }
+
+                if ((result.singleUnits.size()) >= 2) {
+                    // nextSingleUnit fails appropriately for "per" and "and" in the
+                    // same identifier. It doesn't fail for other compound units
+                    // (COMPOUND_PART_TIMES). Consequently we take care of that
+                    // here.
+                    MeasureUnit.Complexity complexity =
+                            fSawAnd ? MeasureUnit.Complexity.MIXED : MeasureUnit.Complexity.COMPOUND;
+                    if (result.getSingleUnits().size() == 2) {
+                        // After appending two singleUnits, the complexity will be `UMEASURE_UNIT_COMPOUND`
+                        assert result.getComplexity() == MeasureUnit.Complexity.COMPOUND;
+                        result.setComplexity(complexity);
+                    } else if (result.getComplexity() != complexity) {
+                        throw new IllegalArgumentException("Can't have mixed compound units");
+                    }
+                }
+            }
+
+            return result;
+        }
+
+        /**
+         * Returns the next "single unit" via result.
+         * <p>
+         * If a "-per-" was parsed, the result will have appropriate negative
+         * dimensionality.
+         * <p>
+         *
+         * @throws IllegalArgumentException if we parse both compound units and "-and-", since mixed
+         *                                  compound units are not yet supported - TODO(CLDR-13700).
+         */
+        private SingleUnitImpl nextSingleUnit() {
+            SingleUnitImpl result = new SingleUnitImpl();
+
+            // state:
+            // 0 = no tokens seen yet (will accept power, SI prefix, or simple unit)
+            // 1 = power token seen (will not accept another power token)
+            // 2 = SI prefix token seen (will not accept a power or SI prefix token)
+            int state = 0;
+
+            boolean atStart = fIndex == 0;
+            Token token = nextToken();
+
+            if (atStart) {
+                // Identifiers optionally start with "per-".
+                if (token.getType() == Token.Type.TYPE_INITIAL_COMPOUND_PART) {
+                    assert token.getInitialCompoundPart() == InitialCompoundPart.INITIAL_COMPOUND_PART_PER;
+
+                    fAfterPer = true;
+                    result.setDimensionality(-1);
+
+                    token = nextToken();
+                }
+            } else {
+                // All other SingleUnit's are separated from previous SingleUnit's
+                // via a compound part:
+                if (token.getType() != Token.Type.TYPE_COMPOUND_PART) {
+                    throw new IllegalArgumentException("token type must be TYPE_COMPOUND_PART");
+                }
+
+                CompoundPart compoundPart = CompoundPart.getCompoundPartFromTrieIndex(token.getMatch());
+                switch (compoundPart) {
+                    case PER:
+                        if (fSawAnd) {
+                            throw new IllegalArgumentException("Mixed compound units not yet supported");
+                            // TODO(CLDR-13700).
+                        }
+
+                        fAfterPer = true;
+                        result.setDimensionality(-1);
+                        break;
+
+                    case TIMES:
+                        if (fAfterPer) {
+                            result.setDimensionality(-1);
+                        }
+                        break;
+
+                    case AND:
+                        if (fAfterPer) {
+                            // not yet supported, TODO(CLDR-13700).
+                            throw new IllegalArgumentException("Can't start with \"-and-\", and mixed compound units");
+                        }
+                        fSawAnd = true;
+                        break;
+                }
+
+                token = nextToken();
+            }
+
+            // Read tokens until we have a complete SingleUnit or we reach the end.
+            while (true) {
+                switch (token.getType()) {
+                    case TYPE_POWER_PART:
+                        if (state > 0) {
+                            throw new IllegalArgumentException();
+                        }
+
+                        result.setDimensionality(result.getDimensionality() * token.getPower());
+                        state = 1;
+                        break;
+
+                    case TYPE_SI_PREFIX:
+                        if (state > 1) {
+                            throw new IllegalArgumentException();
+                        }
+
+                        result.setSiPrefix(token.getSIPrefix());
+                        state = 2;
+                        break;
+
+                    case TYPE_SIMPLE_UNIT:
+                        result.setSimpleUnit(token.getSimpleUnitIndex(), simpleUnits);
+                        return result;
+
+                    default:
+                        throw new IllegalArgumentException();
+                }
+
+                if (!hasNext()) {
+                    throw new IllegalArgumentException("We ran out of tokens before finding a complete single unit.");
+                }
+
+                token = nextToken();
+            }
+        }
+
+        private boolean hasNext() {
+            return fIndex < fSource.length();
+        }
+
+        private Token nextToken() {
+            trie.reset();
+            int match = -1;
+            // Saves the position in the fSource string for the end of the most
+            // recent matching token.
+            int previ = -1;
+
+            // Find the longest token that matches a value in the trie:
+            while (fIndex < fSource.length()) {
+                BytesTrie.Result result = trie.next(fSource.charAt(fIndex++));
+                if (result == BytesTrie.Result.NO_MATCH) {
+                    break;
+                } else if (result == BytesTrie.Result.NO_VALUE) {
+                    continue;
+                }
+
+                match = trie.getValue();
+                previ = fIndex;
+
+                if (result == BytesTrie.Result.FINAL_VALUE) {
+                    break;
+                }
+
+                if (result != BytesTrie.Result.INTERMEDIATE_VALUE) {
+                    throw new IllegalArgumentException("result must has an intermediate value");
+                }
+
+                // continue;
+            }
+
+
+            if (match < 0) {
+                throw new IllegalArgumentException("Encountered unknown token starting at index " + previ);
+            } else {
+                fIndex = previ;
+            }
+
+            return new Token(match);
+        }
+
+        static class Token {
+
+            private final int fMatch;
+            private final Type type;
+
+            public Token(int fMatch) {
+                this.fMatch = fMatch;
+                type = calculateType(fMatch);
+            }
+
+            public Type getType() {
+                return this.type;
+            }
+
+            public MeasureUnit.SIPrefix getSIPrefix() {
+                assert this.type == Type.TYPE_SI_PREFIX;
+                return getSiPrefixFromTrieIndex(this.fMatch);
+            }
+
+            // Valid only for tokens with type TYPE_COMPOUND_PART.
+            public int getMatch() {
+                assert getType() == Type.TYPE_COMPOUND_PART;
+                return fMatch;
+            }
+
+            // Even if there is only one InitialCompoundPart value, we have this
+            // function for the simplicity of code consistency.
+            public InitialCompoundPart getInitialCompoundPart() {
+                assert (this.type == Type.TYPE_INITIAL_COMPOUND_PART
+                        &&
+                        fMatch == InitialCompoundPart.INITIAL_COMPOUND_PART_PER.getTrieIndex());
+                return InitialCompoundPart.getInitialCompoundPartFromTrieIndex(fMatch);
+            }
+
+            public int getPower() {
+                assert this.type == Type.TYPE_POWER_PART;
+                return PowerPart.getPowerFromTrieIndex(this.fMatch);
+            }
+
+            public int getSimpleUnitIndex() {
+                return this.fMatch - UnitsData.Constants.kSimpleUnitOffset;
+            }
+
+            // Calling calculateType() is invalid, resulting in an assertion failure, if Token
+            // value isn't positive.
+            private Type calculateType(int fMatch) {
+                if (fMatch <= 0) {
+                    throw new AssertionError("fMatch must have a positive value");
+                }
+
+                if (fMatch < UnitsData.Constants.kCompoundPartOffset) {
+                    return Type.TYPE_SI_PREFIX;
+                }
+                if (fMatch < UnitsData.Constants.kInitialCompoundPartOffset) {
+                    return Type.TYPE_COMPOUND_PART;
+                }
+                if (fMatch < UnitsData.Constants.kPowerPartOffset) {
+                    return Type.TYPE_INITIAL_COMPOUND_PART;
+                }
+                if (fMatch < UnitsData.Constants.kSimpleUnitOffset) {
+                    return Type.TYPE_POWER_PART;
+                }
+
+                return Type.TYPE_SIMPLE_UNIT;
+            }
+
+            enum Type {
+                TYPE_UNDEFINED,
+                TYPE_SI_PREFIX,
+                // Token type for "-per-", "-", and "-and-".
+                TYPE_COMPOUND_PART,
+                // Token type for "per-".
+                TYPE_INITIAL_COMPOUND_PART,
+                TYPE_POWER_PART,
+                TYPE_SIMPLE_UNIT,
+            }
+        }
+    }
+
+    class SingleUnitComparator implements Comparator<SingleUnitImpl> {
+        @Override
+        public int compare(SingleUnitImpl o1, SingleUnitImpl o2) {
+            return o1.compareTo(o2);
+        }
+    }
+}
diff --git a/icu4j/main/classes/core/src/com/ibm/icu/impl/units/SingleUnitImpl.java b/icu4j/main/classes/core/src/com/ibm/icu/impl/units/SingleUnitImpl.java
new file mode 100644
index 0000000..52595c0
--- /dev/null
+++ b/icu4j/main/classes/core/src/com/ibm/icu/impl/units/SingleUnitImpl.java
@@ -0,0 +1,157 @@
+// © 2020 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+
+package com.ibm.icu.impl.units;
+
+import com.ibm.icu.util.MeasureUnit;
+
+public class SingleUnitImpl {
+    /**
+     * Simple unit index, unique for every simple unit, -1 for the dimensionless
+     * unit. This is an index into a string list in unit.txt {ConversionUnits}.
+     * <p>
+     * The default value is -1, meaning the dimensionless unit:
+     * isDimensionless() will return true, until index is changed.
+     */
+    private int index = -1;
+    /**
+     * SimpleUnit is the simplest form of a Unit. For example, for "square-millimeter", the simple unit would be "meter"Ò
+     * <p>
+     * The default value is "", meaning the dimensionless unit:
+     * isDimensionless() will return true, until index is changed.
+     */
+    private String simpleUnit = "";
+    /**
+     * Determine the power of the `SingleUnit`. For example, for "square-meter", the dimensionality will be `2`.
+     * <p>
+     * NOTE:
+     * Default dimensionality is 1.
+     */
+    private int dimensionality = 1;
+    /**
+     * SI Prefix
+     */
+    private MeasureUnit.SIPrefix siPrefix = MeasureUnit.SIPrefix.ONE;
+
+    public SingleUnitImpl clone() {
+        SingleUnitImpl result = new SingleUnitImpl();
+        result.index = this.index;
+        result.dimensionality = this.dimensionality;
+        result.simpleUnit = this.simpleUnit;
+        result.siPrefix = this.siPrefix;
+
+        return result;
+    }
+
+    public MeasureUnit build() {
+        MeasureUnitImpl measureUnit = new MeasureUnitImpl(this);
+        return measureUnit.build();
+    }
+
+    /**
+     * Generates an neutral identifier string for a single unit which means we do not include the dimension signal.
+     *
+     * @throws IllegalArgumentException
+     */
+    public String getNeutralIdentifier() {
+        StringBuilder result = new StringBuilder();
+        int posPower = Math.abs(this.getDimensionality());
+
+        assert posPower > 0 : "getIdentifier does not support the dimensionless";
+
+        if (posPower == 1) {
+            // no-op
+        } else if (posPower == 2) {
+            result.append("square-");
+        } else if (posPower == 3) {
+            result.append("cubic-");
+        } else if (posPower <= 15) {
+            result.append("pow");
+            result.append(posPower);
+            result.append('-');
+        } else {
+            throw new IllegalArgumentException("Unit Identifier Syntax Error");
+        }
+
+        result.append(this.getSiPrefix().getIdentifier());
+        result.append(this.getSimpleUnit());
+
+        return result.toString();
+    }
+
+    /**
+     * Compare this SingleUnitImpl to another SingleUnitImpl for the sake of
+     * sorting and coalescing.
+     * <p>
+     * Takes the sign of dimensionality into account, but not the absolute
+     * value: per-meter is not considered the same as meter, but meter is
+     * considered the same as square-meter.
+     * <p>
+     * The dimensionless unit generally does not get compared, but if it did, it
+     * would sort before other units by virtue of index being < 0 and
+     * dimensionality not being negative.
+     */
+    int compareTo(SingleUnitImpl other) {
+        if (dimensionality < 0 && other.dimensionality > 0) {
+            // Positive dimensions first
+            return 1;
+        }
+        if (dimensionality > 0 && other.dimensionality < 0) {
+            return -1;
+        }
+        if (index < other.index) {
+            return -1;
+        }
+        if (index > other.index) {
+            return 1;
+        }
+        if (this.getSiPrefix().getSiPrefixPower() < other.getSiPrefix().getSiPrefixPower()) {
+            return -1;
+        }
+        if (this.getSiPrefix().getSiPrefixPower() > other.getSiPrefix().getSiPrefixPower()) {
+            return 1;
+        }
+        return 0;
+    }
+
+    /**
+     * Checks whether this SingleUnitImpl is compatible with another for the purpose of coalescing.
+     * <p>
+     * Units with the same base unit and SI prefix should match, except that they must also have
+     * the same dimensionality sign, such that we don't merge numerator and denominator.
+     */
+    boolean isCompatibleWith(SingleUnitImpl other) {
+        return (compareTo(other) == 0);
+    }
+
+    public String getSimpleUnit() {
+        return simpleUnit;
+    }
+
+    public void setSimpleUnit(int simpleUnitIndex, String[] simpleUnits) {
+        this.index = simpleUnitIndex;
+        this.simpleUnit = simpleUnits[simpleUnitIndex];
+    }
+
+    public int getDimensionality() {
+        return dimensionality;
+    }
+
+    public void setDimensionality(int dimensionality) {
+        this.dimensionality = dimensionality;
+    }
+
+    public MeasureUnit.SIPrefix getSiPrefix() {
+        return siPrefix;
+    }
+
+    public void setSiPrefix(MeasureUnit.SIPrefix siPrefix) {
+        this.siPrefix = siPrefix;
+    }
+
+    public int getIndex() {
+        return index;
+    }
+
+}
diff --git a/icu4j/main/classes/core/src/com/ibm/icu/impl/units/UnitsData.java b/icu4j/main/classes/core/src/com/ibm/icu/impl/units/UnitsData.java
new file mode 100644
index 0000000..87b4e20
--- /dev/null
+++ b/icu4j/main/classes/core/src/com/ibm/icu/impl/units/UnitsData.java
@@ -0,0 +1,92 @@
+// © 2020 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+
+package com.ibm.icu.impl.units;
+
+import com.ibm.icu.impl.ICUData;
+import com.ibm.icu.impl.ICUResourceBundle;
+import com.ibm.icu.impl.UResource;
+import com.ibm.icu.util.UResourceBundle;
+
+import java.util.ArrayList;
+
+/**
+ * Responsible for all units data operations (retriever, analysis, extraction certain data ... etc.).
+ */
+class UnitsData {
+    private volatile static String[] simpleUnits = null;
+
+    public static String[] getSimpleUnits() {
+        if (simpleUnits != null) {
+            return simpleUnits;
+        }
+
+        // Read simple units
+        ICUResourceBundle resource;
+        resource = (ICUResourceBundle) UResourceBundle.getBundleInstance(ICUData.ICU_BASE_NAME, "units");
+        SimpleUnitIdentifiersSink sink = new SimpleUnitIdentifiersSink();
+        resource.getAllItemsWithFallback("convertUnits", sink);
+        simpleUnits = sink.simpleUnits;
+
+        return simpleUnits;
+    }
+
+    public static class SimpleUnitIdentifiersSink extends UResource.Sink {
+        String[] simpleUnits = null;
+
+        @Override
+        public void put(UResource.Key key, UResource.Value value, boolean noFallback) {
+            assert key.toString().equals(Constants.CONVERSION_UNIT_TABLE_NAME);
+            assert value.getType() == UResourceBundle.TABLE;
+
+            UResource.Table simpleUnitsTable = value.getTable();
+            ArrayList<String> simpleUnits = new ArrayList<>();
+            for (int i = 0; simpleUnitsTable.getKeyAndValue(i, key, value); i++) {
+                if (key.toString().equals("kilogram")) {
+
+                    // For parsing, we use "gram", the prefixless metric mass unit. We
+                    // thus ignore the SI Base Unit of Mass: it exists due to being the
+                    // mass conversion target unit, but not needed for MeasureUnit
+                    // parsing.
+                    continue;
+                }
+
+                simpleUnits.add(key.toString());
+            }
+
+            this.simpleUnits = simpleUnits.toArray(new String[0]);
+        }
+    }
+
+    /**
+     * Contains all the needed constants.
+     */
+    public static class Constants {
+        // Trie value offset for simple units, e.g. "gram", "nautical-mile",
+        // "fluid-ounce-imperial".
+        public static final int kSimpleUnitOffset = 512;
+
+        // Trie value offset for powers like "square-", "cubic-", "pow2-" etc.
+        public static final int kPowerPartOffset = 256;
+
+
+        // Trie value offset for "per-".
+        public final static int kInitialCompoundPartOffset = 192;
+
+        // Trie value offset for compound parts, e.g. "-per-", "-", "-and-".
+        public final static int kCompoundPartOffset = 128;
+
+        // Trie value offset for SI Prefixes. This is big enough to ensure we only
+        // insert positive integers into the trie.
+        public static final int kSIPrefixOffset = 64;
+
+
+        /* Tables Names*/
+        public static final String CONVERSION_UNIT_TABLE_NAME = "convertUnits";
+        public static final String UNIT_PREFERENCE_TABLE_NAME = "unitPreferenceData";
+        public static final String CATEGORY_TABLE_NAME = "unitQuantities";
+        public static final String DEFAULT_REGION = "001";
+        public static final String DEFAULT_USAGE = "default";
+    }
+}
diff --git a/icu4j/main/classes/core/src/com/ibm/icu/util/MeasureUnit.java b/icu4j/main/classes/core/src/com/ibm/icu/util/MeasureUnit.java
index 7b9334a..32c05c4 100644
--- a/icu4j/main/classes/core/src/com/ibm/icu/util/MeasureUnit.java
+++ b/icu4j/main/classes/core/src/com/ibm/icu/util/MeasureUnit.java
@@ -14,10 +14,12 @@
 import java.io.ObjectOutput;
 import java.io.ObjectStreamException;
 import java.io.Serializable;
+import java.util.ArrayList;
 import java.util.Collections;
+import java.util.List;
+import java.util.Map;
 import java.util.HashMap;
 import java.util.HashSet;
-import java.util.Map;
 import java.util.Set;
 
 import com.ibm.icu.impl.CollectionSet;
@@ -25,8 +27,12 @@
 import com.ibm.icu.impl.ICUResourceBundle;
 import com.ibm.icu.impl.Pair;
 import com.ibm.icu.impl.UResource;
+import com.ibm.icu.impl.units.MeasureUnitImpl;
+import com.ibm.icu.impl.units.SingleUnitImpl;
 import com.ibm.icu.text.UnicodeSet;
 
+
+
 /**
  * A unit such as length, mass, volume, currency, etc.  A unit is
  * coupled with a numeric amount to produce a Measure. MeasureUnit objects are immutable.
@@ -48,6 +54,7 @@
     private static boolean cacheIsPopulated = false;
 
     /**
+     * If type set to null, measureUnitImpl is in use instead of type and subType.
      * @internal
      * @deprecated This API is ICU internal only.
      */
@@ -55,6 +62,7 @@
     protected final String type;
 
     /**
+     * If subType set to null, measureUnitImpl is in use instead of type and subType.
      * @internal
      * @deprecated This API is ICU internal only.
      */
@@ -62,6 +70,248 @@
     protected final String subType;
 
     /**
+     * Used by new draft APIs in ICU 68.
+     *
+     * @internal
+     */
+    private MeasureUnitImpl measureUnitImpl = null;
+
+    /**
+     * Enumeration for unit complexity. There are three levels:
+     * <p>
+     * - SINGLE: A single unit, optionally with a power and/or SI prefix. Examples: hectare,
+     * square-kilometer, kilojoule, one-per-second.
+     * - COMPOUND: A unit composed of the product of multiple single units. Examples:
+     * meter-per-second, kilowatt-hour, kilogram-meter-per-square-second.
+     * - MIXED: A unit composed of the sum of multiple single units. Examples: foot-and-inch,
+     * hour-and-minute-and-second, degree-and-arcminute-and-arcsecond.
+     * <p>
+     * The complexity determines which operations are available. For example, you cannot set the power
+     * or SI prefix of a compound unit.
+     *
+     * @draft ICU 68
+     * @provisional This API might change or be removed in a future release.
+     */
+    public enum Complexity {
+        /**
+         * A single unit, like kilojoule.
+         *
+         * @draft ICU 68
+         * @provisional This API might change or be removed in a future release.
+         */
+        SINGLE,
+
+        /**
+         * A compound unit, like meter-per-second.
+         *
+         * @draft ICU 68
+         * @provisional This API might change or be removed in a future release.
+         */
+        COMPOUND,
+
+        /**
+         * A mixed unit, like hour-and-minute.
+         *
+         * @draft ICU 68
+         * @provisional This API might change or be removed in a future release.
+         */
+        MIXED
+    }
+
+    /**
+     * Enumeration for SI prefixes, such as "kilo".
+     *
+     * @draft ICU 68
+     * @provisional This API might change or be removed in a future release.
+     */
+    public enum SIPrefix {
+
+        /**
+         * SI prefix: yotta, 10^24.
+         *
+         * @draft ICU 68
+         * @provisional This API might change or be removed in a future release.
+         */
+        YOTTA(24, "yotta"),
+
+        /**
+         * SI prefix: zetta, 10^21.
+         *
+         * @draft ICU 68
+         * @provisional This API might change or be removed in a future release.
+         */
+        ZETTA(21, "zetta"),
+
+        /**
+         * SI prefix: exa, 10^18.
+         *
+         * @draft ICU 68
+         * @provisional This API might change or be removed in a future release.
+         */
+        EXA(18, "exa"),
+
+        /**
+         * SI prefix: peta, 10^15.
+         *
+         * @draft ICU 68
+         * @provisional This API might change or be removed in a future release.
+         */
+        PETA(15, "peta"),
+
+        /**
+         * SI prefix: tera, 10^12.
+         *
+         * @draft ICU 68
+         * @provisional This API might change or be removed in a future release.
+         */
+        TERA(12, "tera"),
+
+        /**
+         * SI prefix: giga, 10^9.
+         *
+         * @draft ICU 68
+         * @provisional This API might change or be removed in a future release.
+         */
+        GIGA(9, "giga"),
+
+        /**
+         * SI prefix: mega, 10^6.
+         *
+         * @draft ICU 68
+         * @provisional This API might change or be removed in a future release.
+         */
+        MEGA(6, "mega"),
+
+        /**
+         * SI prefix: kilo, 10^3.
+         *
+         * @draft ICU 68
+         * @provisional This API might change or be removed in a future release.
+         */
+        KILO(3, "kilo"),
+
+        /**
+         * SI prefix: hecto, 10^2.
+         *
+         * @draft ICU 68
+         * @provisional This API might change or be removed in a future release.
+         */
+        HECTO(2, "hecto"),
+
+        /**
+         * SI prefix: deka, 10^1.
+         *
+         * @draft ICU 68
+         * @provisional This API might change or be removed in a future release.
+         */
+        DEKA(1, "deka"),
+
+        /**
+         * The absence of an SI prefix.
+         *
+         * @draft ICU 68
+         * @provisional This API might change or be removed in a future release.
+         */
+        ONE(0, ""),
+
+        /**
+         * SI prefix: deci, 10^-1.
+         *
+         * @draft ICU 68
+         * @provisional This API might change or be removed in a future release.
+         */
+        DECI(-1, "deci"),
+
+        /**
+         * SI prefix: centi, 10^-2.
+         *
+         * @draft ICU 68
+         * @provisional This API might change or be removed in a future release.
+         */
+        CENTI(-2, "centi"),
+
+        /**
+         * SI prefix: milli, 10^-3.
+         *
+         * @draft ICU 68
+         * @provisional This API might change or be removed in a future release.
+         */
+        MILLI(-3, "milli"),
+
+        /**
+         * SI prefix: micro, 10^-6.
+         *
+         * @draft ICU 68
+         * @provisional This API might change or be removed in a future release.
+         */
+        MICRO(-6, "micro"),
+
+        /**
+         * SI prefix: nano, 10^-9.
+         *
+         * @draft ICU 68
+         * @provisional This API might change or be removed in a future release.
+         */
+        NANO(-9, "nano"),
+
+        /**
+         * SI prefix: pico, 10^-12.
+         *
+         * @draft ICU 68
+         * @provisional This API might change or be removed in a future release.
+         */
+        PICO(-12, "pico"),
+
+        /**
+         * SI prefix: femto, 10^-15.
+         *
+         * @draft ICU 68
+         * @provisional This API might change or be removed in a future release.
+         */
+        FEMTO(-15, "femto"),
+
+        /**
+         * SI prefix: atto, 10^-18.
+         *
+         * @draft ICU 68
+         * @provisional This API might change or be removed in a future release.
+         */
+        ATTO(-18, "atto"),
+
+        /**
+         * SI prefix: zepto, 10^-21.
+         *
+         * @draft ICU 68
+         * @provisional This API might change or be removed in a future release.
+         */
+        ZEPTO(-21, "zepto"),
+
+        /**
+         * SI prefix: yocto, 10^-24.
+         *
+         * @draft ICU 68
+         * @provisional This API might change or be removed in a future release.
+         */
+        YOCTO(-24, "yocto");
+
+        private final int siPrefixPower;
+        private final String identifier;
+
+        SIPrefix(int siPrefixPower, String identifier) {
+            this.siPrefixPower = siPrefixPower;
+            this.identifier = identifier;
+        }
+
+        public String getIdentifier() {
+            return identifier;
+        }
+
+        public int getSiPrefixPower() {
+            return siPrefixPower;
+        }
+    }
+
+    /**
      * @internal
      * @deprecated This API is ICU internal only.
      */
@@ -72,6 +322,52 @@
     }
 
     /**
+     * Construct a MeasureUnit from a CLDR Unit Identifier, defined in UTS 35.
+     * Validates and canonicalizes the identifier.
+     *
+     * Note: dimensionless <code>MeasureUnit</code> is <code>null</code>
+     *
+     * <pre>
+     * MeasureUnit example = MeasureUnit::forIdentifier("furlong-per-nanosecond")
+     * </pre>
+     *
+     * @param identifier The CLDR Sequence Unit Identifier
+     * @throws IllegalArgumentException if the identifier is invalid.
+     * @draft ICU 68
+     * @provisional This API might change or be removed in a future release.
+     */
+    public static MeasureUnit forIdentifier(String identifier) {
+        if (identifier == null || identifier.isEmpty()) {
+            return NoUnit.BASE;
+        }
+
+        return MeasureUnitImpl.forIdentifier(identifier).build();
+    }
+
+    /**
+     * @internal
+     * @param measureUnitImpl
+     */
+    public static MeasureUnit fromMeasureUnitImpl(MeasureUnitImpl measureUnitImpl) {
+        measureUnitImpl.serialize();
+        String identifier = measureUnitImpl.getIdentifier();
+        MeasureUnit result = MeasureUnit.findBySubType(identifier);
+        if (result != null) {
+            return result;
+        }
+
+        return new MeasureUnit(measureUnitImpl);
+    }
+
+    private MeasureUnit(MeasureUnitImpl measureUnitImpl) {
+        type = null;
+        subType = null;
+        this.measureUnitImpl = measureUnitImpl.clone();
+    }
+
+
+
+    /**
      * Get the type, such as "length"
      *
      * @stable ICU 53
@@ -90,7 +386,187 @@
         return subType;
     }
 
+    /**
+     * Gets the CLDR Unit Identifier for this MeasureUnit, as defined in UTS 35.
+     *
+     * @return The string form of this unit.
+     * @draft ICU 68
+     * @provisional This API might change or be removed in a future release.
+     */
+    public String getIdentifier() {
+        String result = measureUnitImpl == null ? getSubtype() : measureUnitImpl.getIdentifier();
+        return result == null ? "" : result;
+    }
 
+    /**
+     * Compute the complexity of the unit. See Complexity for more information.
+     *
+     * @return The unit complexity.
+     * @draft ICU 68
+     * @provisional This API might change or be removed in a future release.
+     */
+    public Complexity getComplexity() {
+        if (measureUnitImpl == null) {
+            return MeasureUnitImpl.forIdentifier(getIdentifier()).getComplexity();
+        }
+
+        return measureUnitImpl.getComplexity();
+    }
+
+    /**
+     * Creates a MeasureUnit which is this SINGLE unit augmented with the specified SI prefix.
+     * For example, SI_PREFIX_KILO for "kilo".
+     * May return this if this unit already has that prefix.
+     * <p>
+     * There is sufficient locale data to format all standard SI prefixes.
+     * <p>
+     * NOTE: Only works on SINGLE units. If this is a COMPOUND or MIXED unit, an error will
+     * occur. For more information, see `Complexity`.
+     *
+     * @param prefix The SI prefix, from SIPrefix.
+     * @return A new SINGLE unit.
+     * @throws UnsupportedOperationException if this unit is a COMPOUND or MIXED unit.
+     * @draft ICU 68
+     * @provisional This API might change or be removed in a future release.
+     */
+    public MeasureUnit withSIPrefix(SIPrefix prefix) {
+        SingleUnitImpl singleUnit = getSingleUnitImpl();
+        singleUnit.setSiPrefix(prefix);
+        return singleUnit.build();
+    }
+
+    /**
+     * Returns the current SI prefix of this SINGLE unit. For example, if the unit has the SI prefix
+     * "kilo", then SI_PREFIX_KILO is returned.
+     * <p>
+     * NOTE: Only works on SINGLE units. If this is a COMPOUND or MIXED unit, an error will
+     * occur. For more information, see `Complexity`.
+     *
+     * @return The SI prefix of this SINGLE unit, from SIPrefix.
+     * @throws UnsupportedOperationException if the unit is COMPOUND or MIXED.
+     * @draft ICU 68
+     * @provisional This API might change or be removed in a future release.
+     */
+    public SIPrefix getSIPrefix() {
+        return getSingleUnitImpl().getSiPrefix();
+    }
+
+    /**
+     * Returns the dimensionality (power) of this MeasureUnit. For example, if the unit is square,
+     * then 2 is returned.
+     * <p>
+     * NOTE: Only works on SINGLE units. If this is a COMPOUND or MIXED unit, an exception will be thrown.
+     * For more information, see `Complexity`.
+     *
+     * @return The dimensionality (power) of this simple unit.
+     * @throws UnsupportedOperationException if the unit is COMPOUND or MIXED.
+     * @draft ICU 68
+     * @provisional This API might change or be removed in a future release.
+     */
+    public int getDimensionality() {
+        return getSingleUnitImpl().getDimensionality();
+    }
+
+    /**
+     * Creates a MeasureUnit which is this SINGLE unit augmented with the specified dimensionality
+     * (power). For example, if dimensionality is 2, the unit will be squared.
+     * <p>
+     * NOTE: Only works on SINGLE units. If this is a COMPOUND or MIXED unit, an exception is thrown.
+     * For more information, see `Complexity`.
+     *
+     * @param dimensionality The dimensionality (power).
+     * @return A new SINGLE unit.
+     * @throws UnsupportedOperationException if the unit is COMPOUND or MIXED.
+     * @draft ICU 68
+     * @provisional This API might change or be removed in a future release.
+     */
+    public MeasureUnit withDimensionality(int dimensionality) {
+        SingleUnitImpl singleUnit = getSingleUnitImpl();
+        singleUnit.setDimensionality(dimensionality);
+        return singleUnit.build();
+    }
+
+    /**
+     * Computes the reciprocal of this MeasureUnit, with the numerator and denominator flipped.
+     * <p>
+     * For example, if the receiver is "meter-per-second", the unit "second-per-meter" is returned.
+     * <p>
+     * NOTE: Only works on SINGLE and COMPOUND units. If this is a MIXED unit, an error will
+     * occur. For more information, see `Complexity`.
+     *
+     * @return The reciprocal of the target unit.
+     * @throws UnsupportedOperationException if the unit is MIXED.
+     * @draft ICU 68
+     * @provisional This API might change or be removed in a future release.
+     */
+    public MeasureUnit reciprocal() {
+        MeasureUnitImpl measureUnit = getCopyOfMeasureUnitImpl();
+        measureUnit.takeReciprocal();
+        return measureUnit.build();
+    }
+
+    /**
+     * Computes the product of this unit with another unit. This is a way to build units from
+     * constituent parts.
+     * <p>
+     * The numerator and denominator are preserved through this operation.
+     * <p>
+     * For example, if the receiver is "kilowatt" and the argument is "hour-per-day", then the
+     * unit "kilowatt-hour-per-day" is returned.
+     * <p>
+     * NOTE: Only works on SINGLE and COMPOUND units. If either unit (receivee and argument) is a
+     * MIXED unit, an error will occur. For more information, see `Complexity`.
+     *
+     * @param other The MeasureUnit to multiply with the target.
+     * @return The product of the target unit with the provided unit.
+     * @throws UnsupportedOperationException if the unit is MIXED.
+     * @draft ICU 68
+     * @provisional This API might change or be removed in a future release.
+     */
+    public MeasureUnit product(MeasureUnit other) {
+        MeasureUnitImpl implCopy = getCopyOfMeasureUnitImpl();
+
+        if (other == null /* dimensionless */) {
+            return implCopy.build();
+        }
+
+        final MeasureUnitImpl otherImplRef = other.getMayBeReferenceOfMeasureUnitImpl();
+        if (implCopy.getComplexity() == Complexity.MIXED || otherImplRef.getComplexity() == Complexity.MIXED) {
+            throw new UnsupportedOperationException();
+        }
+
+        for (SingleUnitImpl singleUnit :
+                otherImplRef.getSingleUnits()) {
+            implCopy.appendSingleUnit(singleUnit);
+        }
+
+        return implCopy.build();
+    }
+
+    /**
+     * Returns the list of SINGLE units contained within a sequence of COMPOUND units.
+     * <p>
+     * Examples:
+     * - Given "meter-kilogram-per-second", three units will be returned: "meter",
+     * "kilogram", and "one-per-second".
+     * - Given "hour+minute+second", three units will be returned: "hour", "minute",
+     * and "second".
+     * <p>
+     * If this is a SINGLE unit, a list of length 1 will be returned.
+     *
+     * @return An unmodifiable list of single units
+     * @internal ICU 68 Technology Preview
+     * @provisional This API might change or be removed in a future release.
+     */
+    public List<MeasureUnit> splitToSingleUnits() {
+        final ArrayList<SingleUnitImpl> singleUnits = getMayBeReferenceOfMeasureUnitImpl().getSingleUnits();
+        List<MeasureUnit> result = new ArrayList<>(singleUnits.size());
+        for (SingleUnitImpl singleUnit : singleUnits) {
+            result.add(singleUnit.build());
+        }
+
+        return result;
+    }
 
     /**
      * {@inheritDoc}
@@ -115,8 +591,8 @@
         if (!(rhs instanceof MeasureUnit)) {
             return false;
         }
-        MeasureUnit c = (MeasureUnit) rhs;
-        return type.equals(c.type) && subType.equals(c.subType);
+
+        return this.getIdentifier().equals(((MeasureUnit) rhs).getIdentifier());
     }
 
     /**
@@ -1546,6 +2022,39 @@
         return new MeasureUnitProxy(type, subType);
     }
 
+    /**
+     *
+     * @return this object as a SingleUnitImpl.
+     * @throws UnsupportedOperationException if this object could not be converted to a single unit.
+     */
+    private SingleUnitImpl getSingleUnitImpl() {
+        if (measureUnitImpl == null) {
+            return MeasureUnitImpl.forIdentifier(getIdentifier()).getSingleUnitImpl();
+        }
+
+        return measureUnitImpl.getSingleUnitImpl();
+    }
+
+    /**
+     *
+     * @return this object in a MeasureUnitImpl form.
+     */
+    private MeasureUnitImpl getCopyOfMeasureUnitImpl() {
+        return this.measureUnitImpl == null ?
+                MeasureUnitImpl.forIdentifier(getIdentifier()) :
+                this.measureUnitImpl.clone();
+    }
+
+    /**
+     *
+     * @return this object in a MeasureUnitImpl form.
+     */
+    private MeasureUnitImpl getMayBeReferenceOfMeasureUnitImpl(){
+        return this.measureUnitImpl == null ?
+                MeasureUnitImpl.forIdentifier(getIdentifier()) :
+                this.measureUnitImpl;
+    }
+
     static final class MeasureUnitProxy implements Externalizable {
         private static final long serialVersionUID = -3910681415330989598L;
 
@@ -1586,4 +2095,4 @@
             return MeasureUnit.internalGetInstance(type, subType);
         }
     }
-}
+}
\ No newline at end of file
diff --git a/icu4j/main/tests/core/src/com/ibm/icu/dev/test/format/MeasureUnitTest.java b/icu4j/main/tests/core/src/com/ibm/icu/dev/test/format/MeasureUnitTest.java
index 71f90cc..3b1c424 100644
--- a/icu4j/main/tests/core/src/com/ibm/icu/dev/test/format/MeasureUnitTest.java
+++ b/icu4j/main/tests/core/src/com/ibm/icu/dev/test/format/MeasureUnitTest.java
@@ -8,33 +8,6 @@
  */
 package com.ibm.icu.dev.test.format;
 
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
-import java.io.Serializable;
-import java.lang.reflect.Field;
-import java.text.FieldPosition;
-import java.text.ParseException;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-import java.util.Set;
-import java.util.TreeMap;
-
-import org.junit.Assert;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
 import com.ibm.icu.dev.test.TestFmwk;
 import com.ibm.icu.dev.test.serializable.FormatHandler;
 import com.ibm.icu.dev.test.serializable.SerializableTestUtility;
@@ -45,13 +18,17 @@
 import com.ibm.icu.text.MeasureFormat.FormatWidth;
 import com.ibm.icu.text.NumberFormat;
 import com.ibm.icu.util.Currency;
-import com.ibm.icu.util.CurrencyAmount;
-import com.ibm.icu.util.Measure;
-import com.ibm.icu.util.MeasureUnit;
-import com.ibm.icu.util.NoUnit;
-import com.ibm.icu.util.TimeUnit;
-import com.ibm.icu.util.TimeUnitAmount;
-import com.ibm.icu.util.ULocale;
+import com.ibm.icu.util.*;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.*;
+import java.lang.reflect.Field;
+import java.text.FieldPosition;
+import java.text.ParseException;
+import java.util.*;
 
 /**
  * See https://sites.google.com/site/icusite/processes/release/tasks/standards?pli=1
@@ -3485,4 +3462,405 @@
         fmt = MeasureFormat.getInstance(ULocale.forLanguageTag("da"), FormatWidth.NUMERIC);
         Assert.assertEquals("2.03,877", fmt.formatMeasures(fhours, fminutes));
     }
+
+    @Test
+    public void TestIdentifiers() {
+        class TestCase {
+            final String id;
+            final String normalized;
+
+            TestCase(String id, String normalized) {
+                this.id = id;
+                this.normalized = normalized;
+            }
+        }
+
+        TestCase cases[] = {
+                // Correctly normalized identifiers should not change
+                new TestCase("square-meter-per-square-meter", "square-meter-per-square-meter"),
+                new TestCase("kilogram-meter-per-square-meter-square-second",
+                        "kilogram-meter-per-square-meter-square-second"),
+                new TestCase("square-mile-and-square-foot", "square-mile-and-square-foot"),
+                new TestCase("square-foot-and-square-mile", "square-foot-and-square-mile"),
+                new TestCase("per-cubic-centimeter", "per-cubic-centimeter"),
+                new TestCase("per-kilometer", "per-kilometer"),
+
+                // Normalization of power and per
+                new TestCase(
+                        "pow2-foot-and-pow2-mile", "square-foot-and-square-mile"),
+                new TestCase(
+                        "gram-square-gram-per-dekagram", "cubic-gram-per-dekagram"),
+                new TestCase(
+                        "kilogram-per-meter-per-second", "kilogram-per-meter-second"),
+
+                // TODO(ICU-20920): Add more test cases once the proper ranking is available.
+        };
+
+
+        for (TestCase testCase : cases) {
+            MeasureUnit unit = MeasureUnit.forIdentifier(testCase.id);
+
+            final String actual = unit.getIdentifier();
+            assertEquals(testCase.id, testCase.normalized, actual);
+        }
+
+        assertEquals("for empty identifiers, the MeasureUnit will be null",
+                null, MeasureUnit.forIdentifier(""));
+    }
+
+    @Test
+    public void TestInvalidIdentifiers() {
+        final String inputs[] = {
+                "kilo",
+                "kilokilo",
+                "onekilo",
+                "meterkilo",
+                "meter-kilo",
+                "k",
+                "meter-",
+                "meter+",
+                "-meter",
+                "+meter",
+                "-kilometer",
+                "+kilometer",
+                "-pow2-meter",
+                "+pow2-meter",
+                "p2-meter",
+                "p4-meter",
+                "+",
+                "-",
+                "-mile",
+                "-and-mile",
+                "-per-mile",
+                "one",
+                "one-one",
+                "one-per-mile",
+                "one-per-cubic-centimeter",
+                "square--per-meter",
+                "metersecond", // Must have compound part in between single units
+
+                // Negative powers not supported in mixed units yet. TODO(CLDR-13701).
+                "per-hour-and-hertz",
+                "hertz-and-per-hour",
+
+                // Compound units not supported in mixed units yet. TODO(CLDR-13700).
+                "kilonewton-meter-and-newton-meter",
+        };
+
+        for (String input : inputs) {
+            try {
+                MeasureUnit.forIdentifier(input);
+                Assert.fail("An IllegalArgumentException must be thrown");
+            } catch (IllegalArgumentException e) {
+                continue;
+            }
+        }
+    }
+
+    @Test
+    public void TestCompoundUnitOperations() {
+        MeasureUnit.forIdentifier("kilometer-per-second-joule");
+
+        MeasureUnit kilometer = MeasureUnit.KILOMETER;
+        MeasureUnit cubicMeter = MeasureUnit.CUBIC_METER;
+        MeasureUnit meter = kilometer.withSIPrefix(MeasureUnit.SIPrefix.ONE);
+        MeasureUnit centimeter1 = kilometer.withSIPrefix(MeasureUnit.SIPrefix.CENTI);
+        MeasureUnit centimeter2 = meter.withSIPrefix(MeasureUnit.SIPrefix.CENTI);
+        MeasureUnit cubicDecimeter = cubicMeter.withSIPrefix(MeasureUnit.SIPrefix.DECI);
+
+        verifySingleUnit(kilometer, MeasureUnit.SIPrefix.KILO, 1, "kilometer");
+        verifySingleUnit(meter, MeasureUnit.SIPrefix.ONE, 1, "meter");
+        verifySingleUnit(centimeter1, MeasureUnit.SIPrefix.CENTI, 1, "centimeter");
+        verifySingleUnit(centimeter2, MeasureUnit.SIPrefix.CENTI, 1, "centimeter");
+        verifySingleUnit(cubicDecimeter, MeasureUnit.SIPrefix.DECI, 3, "cubic-decimeter");
+
+        assertTrue("centimeter equality", centimeter1.equals( centimeter2));
+        assertTrue("kilometer inequality", !centimeter1.equals( kilometer));
+
+        MeasureUnit squareMeter = meter.withDimensionality(2);
+        MeasureUnit overCubicCentimeter = centimeter1.withDimensionality(-3);
+        MeasureUnit quarticKilometer = kilometer.withDimensionality(4);
+        MeasureUnit overQuarticKilometer1 = kilometer.withDimensionality(-4);
+
+        verifySingleUnit(squareMeter, MeasureUnit.SIPrefix.ONE, 2, "square-meter");
+        verifySingleUnit(overCubicCentimeter, MeasureUnit.SIPrefix.CENTI, -3, "per-cubic-centimeter");
+        verifySingleUnit(quarticKilometer, MeasureUnit.SIPrefix.KILO, 4, "pow4-kilometer");
+        verifySingleUnit(overQuarticKilometer1, MeasureUnit.SIPrefix.KILO, -4, "per-pow4-kilometer");
+
+        assertTrue("power inequality", quarticKilometer != overQuarticKilometer1);
+
+        MeasureUnit overQuarticKilometer2 = quarticKilometer.reciprocal();
+        MeasureUnit overQuarticKilometer3 = kilometer.product(kilometer)
+                .product(kilometer)
+                .product(kilometer)
+                .reciprocal();
+        MeasureUnit overQuarticKilometer4 = meter.withDimensionality(4)
+                .reciprocal()
+                .withSIPrefix(MeasureUnit.SIPrefix.KILO);
+
+        verifySingleUnit(overQuarticKilometer2, MeasureUnit.SIPrefix.KILO, -4, "per-pow4-kilometer");
+        verifySingleUnit(overQuarticKilometer3, MeasureUnit.SIPrefix.KILO, -4, "per-pow4-kilometer");
+        verifySingleUnit(overQuarticKilometer4, MeasureUnit.SIPrefix.KILO, -4, "per-pow4-kilometer");
+
+        assertTrue("reciprocal equality", overQuarticKilometer1.equals(overQuarticKilometer2));
+        assertTrue("reciprocal equality", overQuarticKilometer1.equals(overQuarticKilometer3));
+        assertTrue("reciprocal equality", overQuarticKilometer1.equals(overQuarticKilometer4));
+
+        MeasureUnit kiloSquareSecond = MeasureUnit.SECOND
+                .withDimensionality(2).withSIPrefix(MeasureUnit.SIPrefix.KILO);
+        MeasureUnit meterSecond = meter.product(kiloSquareSecond);
+        MeasureUnit cubicMeterSecond1 = meter.withDimensionality(3).product(kiloSquareSecond);
+        MeasureUnit centimeterSecond1 = meter.withSIPrefix(MeasureUnit.SIPrefix.CENTI).product(kiloSquareSecond);
+        MeasureUnit secondCubicMeter = kiloSquareSecond.product(meter.withDimensionality(3));
+        MeasureUnit secondCentimeter = kiloSquareSecond.product(meter.withSIPrefix(MeasureUnit.SIPrefix.CENTI));
+        MeasureUnit secondCentimeterPerKilometer = secondCentimeter.product(kilometer.reciprocal());
+
+        verifySingleUnit(kiloSquareSecond, MeasureUnit.SIPrefix.KILO, 2, "square-kilosecond");
+        String meterSecondSub[] = {
+                "meter", "square-kilosecond"
+        };
+        verifyCompoundUnit(meterSecond, "meter-square-kilosecond",
+                meterSecondSub, meterSecondSub.length);
+        String cubicMeterSecond1Sub[] = {
+                "cubic-meter", "square-kilosecond"
+        };
+        verifyCompoundUnit(cubicMeterSecond1, "cubic-meter-square-kilosecond",
+                cubicMeterSecond1Sub, cubicMeterSecond1Sub.length);
+        String centimeterSecond1Sub[] = {
+                "centimeter", "square-kilosecond"
+        };
+        verifyCompoundUnit(centimeterSecond1, "centimeter-square-kilosecond",
+                centimeterSecond1Sub, centimeterSecond1Sub.length);
+        String secondCubicMeterSub[] = {
+                "cubic-meter", "square-kilosecond"
+        };
+        verifyCompoundUnit(secondCubicMeter, "cubic-meter-square-kilosecond",
+                secondCubicMeterSub, secondCubicMeterSub.length);
+        String secondCentimeterSub[] = {
+                "centimeter", "square-kilosecond"
+        };
+        verifyCompoundUnit(secondCentimeter, "centimeter-square-kilosecond",
+                secondCentimeterSub, secondCentimeterSub.length);
+        String secondCentimeterPerKilometerSub[] = {
+                "centimeter", "square-kilosecond", "per-kilometer"
+        };
+        verifyCompoundUnit(secondCentimeterPerKilometer, "centimeter-square-kilosecond-per-kilometer",
+                secondCentimeterPerKilometerSub, secondCentimeterPerKilometerSub.length);
+
+        assertTrue("reordering equality", cubicMeterSecond1.equals(secondCubicMeter));
+        assertTrue("additional simple units inequality", !secondCubicMeter.equals(secondCentimeter));
+
+        // Don't allow get/set power or SI prefix on compound units
+        try {
+            meterSecond.getDimensionality();
+            fail("UnsupportedOperationException must be thrown");
+        } catch (UnsupportedOperationException e) {
+            // Expecting an exception to be thrown
+        }
+
+        try {
+            meterSecond.withDimensionality(3);
+            fail("UnsupportedOperationException must be thrown");
+        } catch (UnsupportedOperationException e) {
+            // Expecting an exception to be thrown
+        }
+
+        try {
+            meterSecond.getSIPrefix();
+            fail("UnsupportedOperationException must be thrown");
+        } catch (UnsupportedOperationException e) {
+            // Expecting an exception to be thrown
+        }
+
+        try {
+            meterSecond.withSIPrefix(MeasureUnit.SIPrefix.CENTI);
+            fail("UnsupportedOperationException must be thrown");
+        } catch (UnsupportedOperationException e) {
+            // Expecting an exception to be thrown
+        }
+
+        MeasureUnit footInch = MeasureUnit.forIdentifier("foot-and-inch");
+        MeasureUnit inchFoot = MeasureUnit.forIdentifier("inch-and-foot");
+
+        String footInchSub[] = {
+                "foot", "inch"
+        };
+        verifyMixedUnit(footInch, "foot-and-inch",
+                footInchSub, footInchSub.length);
+        String inchFootSub[] = {
+                "inch", "foot"
+        };
+        verifyMixedUnit(inchFoot, "inch-and-foot",
+                inchFootSub, inchFootSub.length);
+
+        assertTrue("order matters inequality", !footInch.equals(inchFoot));
+
+
+        MeasureUnit dimensionless  = NoUnit.BASE;
+        MeasureUnit dimensionless2 = MeasureUnit.forIdentifier("");
+        assertEquals("dimensionless equality", dimensionless, dimensionless2);
+
+        // We support starting from an "identity" MeasureUnit and then combining it
+        // with others via product:
+        MeasureUnit kilometer2 = kilometer.product(dimensionless);
+
+        verifySingleUnit(kilometer2, MeasureUnit.SIPrefix.KILO, 1, "kilometer");
+        assertTrue("kilometer equality", kilometer.equals(kilometer2));
+
+        // Test out-of-range powers
+        MeasureUnit power15 = MeasureUnit.forIdentifier("pow15-kilometer");
+        verifySingleUnit(power15, MeasureUnit.SIPrefix.KILO, 15, "pow15-kilometer");
+
+        try {
+            MeasureUnit.forIdentifier("pow16-kilometer");
+            fail("An IllegalArgumentException must be thrown");
+        } catch (IllegalArgumentException e) {
+            // Expecting an exception to be thrown
+        }
+
+        try {
+            power15.product(kilometer);
+            fail("An IllegalArgumentException must be thrown");
+        } catch (IllegalArgumentException e) {
+            // Expecting an exception to be thrown
+        }
+
+        MeasureUnit powerN15 = MeasureUnit.forIdentifier("per-pow15-kilometer");
+        verifySingleUnit(powerN15, MeasureUnit.SIPrefix.KILO, -15, "per-pow15-kilometer");
+
+        try {
+            MeasureUnit.forIdentifier("per-pow16-kilometer");
+            fail("An IllegalArgumentException must be thrown");
+        } catch (IllegalArgumentException e) {
+            // Expecting an exception to be thrown
+        }
+
+        try {
+            powerN15.product(overQuarticKilometer1);
+            fail("An IllegalArgumentException must be thrown");
+        } catch (IllegalArgumentException e) {
+            // Expecting an exception to be thrown
+        }
+    }
+
+    @Test
+    public void TestDimensionlessBehaviour() {
+        MeasureUnit dimensionless = MeasureUnit.forIdentifier("");
+        MeasureUnit dimensionless2 = NoUnit.BASE;
+        MeasureUnit dimensionless3 = null;
+        MeasureUnit dimensionless4 = MeasureUnit.forIdentifier(null);
+
+        assertEquals("dimensionless must be equals", dimensionless, dimensionless2);
+        assertEquals("dimensionless must be equals", dimensionless2, dimensionless3);
+        assertEquals("dimensionless must be equals", dimensionless3, dimensionless4);
+
+        // product(dimensionless)
+        MeasureUnit mile = MeasureUnit.MILE;
+        mile = mile.product(dimensionless);
+        verifySingleUnit(mile, MeasureUnit.SIPrefix.ONE, 1, "mile");
+    }
+
+    private void verifySingleUnit(MeasureUnit singleMeasureUnit, MeasureUnit.SIPrefix prefix, int power, String identifier) {
+        assertEquals(identifier + ": SI prefix", prefix, singleMeasureUnit.getSIPrefix());
+
+        assertEquals(identifier + ": Power", power, singleMeasureUnit.getDimensionality());
+
+        assertEquals(identifier + ": Identifier", identifier, singleMeasureUnit.getIdentifier());
+
+        assertTrue(identifier + ": Constructor", singleMeasureUnit.equals(MeasureUnit.forIdentifier(identifier)));
+
+        assertEquals(identifier + ": Complexity", MeasureUnit.Complexity.SINGLE, singleMeasureUnit.getComplexity());
+    }
+
+
+    // Kilogram is a "base unit", although it's also "gram" with a kilo- prefix.
+    // This tests that it is handled in the preferred manner.
+    @Test
+    public void TestKilogramIdentifier() {
+        // SI unit of mass
+        MeasureUnit kilogram = MeasureUnit.forIdentifier("kilogram");
+        // Metric mass unit
+        MeasureUnit gram = MeasureUnit.forIdentifier("gram");
+        // Microgram: still a built-in type
+        MeasureUnit microgram = MeasureUnit.forIdentifier("microgram");
+        // Nanogram: not a built-in type at this time
+        MeasureUnit nanogram = MeasureUnit.forIdentifier("nanogram");
+
+        assertEquals("parsed kilogram equals built-in kilogram", MeasureUnit.KILOGRAM.getType(),
+                kilogram.getType());
+        assertEquals("parsed kilogram equals built-in kilogram", MeasureUnit.KILOGRAM.getSubtype(),
+                kilogram.getSubtype());
+        assertEquals("parsed gram equals built-in gram", MeasureUnit.GRAM.getType(), gram.getType());
+        assertEquals("parsed gram equals built-in gram", MeasureUnit.GRAM.getSubtype(),
+                gram.getSubtype());
+        assertEquals("parsed microgram equals built-in microgram", MeasureUnit.MICROGRAM.getType(),
+                microgram.getType());
+        assertEquals("parsed microgram equals built-in microgram", MeasureUnit.MICROGRAM.getSubtype(),
+                microgram.getSubtype());
+        assertEquals("nanogram", null, nanogram.getType());
+        assertEquals("nanogram", "nanogram", nanogram.getIdentifier());
+
+        assertEquals("prefix of kilogram", MeasureUnit.SIPrefix.KILO, kilogram.getSIPrefix());
+        assertEquals("prefix of gram", MeasureUnit.SIPrefix.ONE, gram.getSIPrefix());
+        assertEquals("prefix of microgram", MeasureUnit.SIPrefix.MICRO, microgram.getSIPrefix());
+        assertEquals("prefix of nanogram", MeasureUnit.SIPrefix.NANO, nanogram.getSIPrefix());
+
+        MeasureUnit tmp = kilogram.withSIPrefix(MeasureUnit.SIPrefix.MILLI);
+        assertEquals("Kilogram + milli should be milligram, got: " + tmp.getIdentifier(),
+                MeasureUnit.MILLIGRAM.getIdentifier(), tmp.getIdentifier());
+    }
+
+    private void verifyCompoundUnit(
+            MeasureUnit unit,
+            String identifier,
+            String subIdentifiers[],
+            int subIdentifierCount) {
+        assertEquals(identifier + ": Identifier",
+                identifier,
+                unit.getIdentifier());
+
+        assertTrue(identifier + ": Constructor",
+                unit.equals(MeasureUnit.forIdentifier(identifier)));
+
+        assertEquals(identifier + ": Complexity",
+                MeasureUnit.Complexity.COMPOUND,
+                unit.getComplexity());
+
+        List<MeasureUnit> subUnits = unit.splitToSingleUnits();
+        assertEquals(identifier + ": Length", subIdentifierCount, subUnits.size());
+        for (int i = 0; ; i++) {
+            if (i >= subIdentifierCount || i >= subUnits.size()) break;
+            assertEquals(identifier + ": Sub-unit #" + i,
+                    subIdentifiers[i],
+                    subUnits.get(i).getIdentifier());
+            assertEquals(identifier + ": Sub-unit Complexity",
+                    MeasureUnit.Complexity.SINGLE,
+                    subUnits.get(i).getComplexity());
+        }
+    }
+
+    private void verifyMixedUnit(
+            MeasureUnit unit,
+            String identifier,
+            String subIdentifiers[],
+            int subIdentifierCount) {
+        assertEquals(identifier + ": Identifier",
+                identifier,
+                unit.getIdentifier());
+        assertTrue(identifier + ": Constructor",
+                unit.equals(MeasureUnit.forIdentifier(identifier)));
+
+        assertEquals(identifier + ": Complexity",
+                MeasureUnit.Complexity.MIXED,
+                unit.getComplexity());
+
+        List<MeasureUnit> subUnits = unit.splitToSingleUnits();
+        assertEquals(identifier + ": Length", subIdentifierCount, subUnits.size());
+        for (int i = 0; ; i++) {
+            if (i >= subIdentifierCount || i >= subUnits.size()) break;
+            assertEquals(identifier + ": Sub-unit #" + i,
+                    subIdentifiers[i],
+                    subUnits.get(i).getIdentifier());
+        }
+    }
 }