原始碼的github地址,可以下載到本地執行

串的陣列實現

package impl;

import Interface.IString;

/**
 * 定長順序儲存表示串
 * <p>
 * 用一組地址連續的儲存單元儲存串值的字元序列
 * 在串的定長順序儲存結構中，按照預定義的大小，為每個定義的串變數分配一個固定長度的儲存區
 * 串的實際長度 可以在定長範圍內隨意
 * <p>
 * 定長陣列，超出部分自動截斷
 * <p>
 * <p>
 * 通俗的說，就是用字元陣列來實現字串
 * <p>
 * ps:
 * 串賦值，串比較,求串長,串連線，求子串(SubString) 這五種操作是最小操作，其他的串操作可以用這五種組合成
 *
 * 儲存密度=串值所佔的儲存單位/實際分配的儲存單位
 * 因此 陣列型實現的串儲存密度大於連結串列型儲存實現的串
 *
 *
 *
 */

public class ArrayString implements IString {

    private final int MAXSTRLEN = 10;
    private char[] values;

    /**
     * 生成一個其值等於chars的串T
     *
     * @param chars
     * @return
     */
    public IString StrAssign(char[] chars) {
        int len = chars.length > MAXSTRLEN ? MAXSTRLEN : chars.length;
        values = new char[len];
        copyArray(values, chars);
        return this;
    }

    /**
     * 將串的內容複製給target
     *
     * @param
     * @return
     */
    public IString StrCopy(IString target) {
        target.StrAssign(this.values);
        return target;
    }

    /**
     * 若是串為空 則返回true 否則返回false
     *
     * @return
     */
    public Boolean StrEmpty() {
        if (StrLength() == 0) {
            return Boolean.TRUE;
        } else {
            return Boolean.FALSE;
        }
    }

    /**
     * 如果本字串比target大，則返回大於0 若是相等 返回0  若是不等 則返回-1
     *
     * @param target
     * @return
     */
    public int StrCompare(IString target) {
        char[] c2 = target.toArray();
        for (int i = 0; i < this.values.length && i < c2.length; i++) {
            if (this.values[i] != c2[i]) {
                return -1;
            }
        }
        return (this.values.length - c2.length);
    }

    /**
     * 返回串的長度 即元素個數
     *
     * @return
     */
    public int StrLength() {
        if (values != null) {
            return values.length;
        } else {
            return 0;
        }
    }


    /**
     * 將串清空為空串
     */
    public Boolean ClearString() {
        values = null;
        return true;
    }

    /**
     * 連線為新串，並返回新串
     */
    public IString Concat(IString s2) {
        int len = StrLength() + s2.StrLength() > MAXSTRLEN ? MAXSTRLEN : StrLength() + s2.StrLength();
        char[] charNews = new char[len];
        copyArray(charNews, this.values);
        char[] cs2 = s2.toArray();
        int limit = StrLength() + s2.StrLength() > MAXSTRLEN ? MAXSTRLEN - StrLength() : s2.StrLength();
        for (int i = 0; i < limit; i++) {
            charNews[StrLength() + i] = cs2[i];
        }
        IString newS = new ArrayString();
        newS.StrAssign(charNews);
        return newS;
    }

    /**
     * 返回串的第post個字元起，長度為len的子串
     */
    public IString SubString(int pos, int len) {
        if (pos < 0 || len + pos - 1 > StrLength()) {
            return null; //超出界限
        }
        char[] c = new char[len];
        for (int i = pos; i < len + pos; i++) {
            c[i - pos] = values[i - 1];
        }

        IString s = new ArrayString();
        s.StrAssign(c);
        return s;
    }

    /**
     * 若主串中存在和串T值相同的子串，則返回它在主串中第pos個位置之後的第一次出現的位置，否則返回0
     * 利用 compare subString 組合使用
     *
     * @param T   子串
     * @param pos 指定位置
     * @return
     */
    public int index(IString T, int pos) {

        if (pos + T.StrLength() > StrLength()) {
            return 0;
        }

        for (int i = pos; i < StrLength(); i++) {
            if (SubString(i, T.StrLength()).StrCompare(T) == 0) {
                return i;
            }
        }
        return 0;
    }


    /**
     * 用V替換所有在主串中出現的所有與T相等的不重疊的子串
     * <p>
     * 思路為 先找到相等的串，然後刪除掉，再在原來的位置插入新的。
     * 因為如果直接替換元素，T V 若是長度不同，則會破壞原來資料的完整
     *
     * @param T
     * @return
     */
    public IString Replace(IString T, IString V) {

        IString news = this;
        int tag = news.index(T, 1);
        while (tag != 0) {
            news = news.StrDelete(tag, T.StrLength()).StrInsert(V, tag);
            tag = news.index(T, tag);
        }
        return news;
    }


    /**
     * 在主串的第pos個字元之前插入串T
     *
     * 要考慮到末尾插入的情況！！ 特殊情況！！
     * @param T
     * @param pos
     * @return
     */
    public IString StrInsert(IString T, int pos) {
        if (pos >= 1) {
            int len = StrLength() + T.StrLength() <= MAXSTRLEN ? StrLength() + T.StrLength() : MAXSTRLEN;
            char[] newc = new char[len];
            char[] inc = T.toArray();
            copyArray(newc, values);

            //在末尾插入
            if (StrLength() < pos && pos < MAXSTRLEN) {
                for (int i = 0; i < T.StrLength(); i++) {
                    newc[pos-1+i] = inc[i];

                }
            } else {
                //挪開位置
                for (int i = 0; i <= T.StrLength(); i++) {
                    newc[len - 1 - i] = newc[StrLength() - 1 - i];
                }
                //插入新值
                for (int i = 0; i < T.StrLength(); i++) {
                    newc[pos - 1 + i] = inc[i];
                }
            }

            IString news = new ArrayString();
            news.StrAssign(newc);
            return news;

        }

        return null;
    }

    /**
     * 從主串中刪除第pos個字元起長度為len的子串
     *
     * @param pos
     * @param len
     * @return
     */
    public IString StrDelete(int pos, int len) {
        int leng = pos - 1 + len > StrLength() ? pos : StrLength() - len;
        char[] c = new char[leng];
        copyArray(c, SubString(1, pos - 1).toArray());
        IString s = new ArrayString();
        if (pos + len > StrLength()) {
            s.StrAssign(c);
            return s;
        } else {
            for (int i = 0; i <= leng - pos; i++) {
                c[pos - 1 + i] = values[pos + len + i - 1];
            }

            s.StrAssign(c);
            return s;
        }
    }

    public IString DestroyString() {
        return null;
    }

    public void print() {
        for (int i = 0; i < values.length; i++) {
            System.out.print(values[i]);
        }
        System.out.println();
    }

    public char[] toArray() {
        char[] c = new char[values.length];
        copyArray(c, values);
        return c;
    }

    private void copyArray(char[] target, char[] source) {
        for (int i = 0; i < source.length; i++) {
            target[i] = source[i];
        }
    }

    public static void main(String[] args) {
        //賦值
        System.out.println("賦值");
        ArrayString as = new ArrayString();
        char[] chars = new char[]{'a', 'b', 'c', 'd', 'e'};
        as.StrAssign(chars);
        as.print();
        //拷貝
        System.out.println("拷貝");
        ArrayString as2 = new ArrayString();
        as.StrCopy(as2);
        as2.print();

        System.out.println("轉為陣列");
        System.out.println(as.toArray());
        char[] c2 = as.toArray();
        c2[2] = 'x';
        System.out.println(as.toArray());
        System.out.println(c2);

        System.out.println("求串長");
        System.out.println(as.StrLength());

        System.out.println("判空");
        System.out.println(as.StrEmpty());

        System.out.println("比較兩個字串");
        IString as3 = new ArrayString();
        as3.StrAssign(new char[]{'A', 'B'});
        System.out.println(as.StrCompare(as2));
        System.out.println(as.StrCompare(as3));


        System.out.println("連線 未截斷");
        as.Concat(as2).print();
        System.out.println("連線 截斷");

        IString as4 = new ArrayString();
        as4.StrAssign(new char[]{'1', '2', '3', '4', '5', '6', '7', '8', '9'});
        as.Concat(as4).print();

        System.out.println("擷取子串 從第2個位置開始 擷取4位");
        as4.SubString(2, 3).print();


        System.out.println("子串匹配");
        IString as5 = new ArrayString();
        as5.StrAssign(new char[]{'6', '7'});
        System.out.println(as4.index(as5, 1));


        System.out.println("插入新值");
        IString as6 = new ArrayString();
        as6.StrAssign(new char[]{'a', 'b', 'c'});
        as6.StrInsert(as5, 2).print();


        System.out.println("刪除指定位置2開始 長度為3的子串");
        as4.print();
        as4.StrDelete(2, 3).print();
        as4.StrDelete(5, 2).print();


        System.out.println("子串替換");
        IString as7 = new ArrayString();
        as7.StrAssign(new char[]{'a', 'b', 'c', 'd', 'e', 'c', 'd'});

        IString T = new ArrayString();
        T.StrAssign(new char[]{'c', 'd'});

        IString V = new ArrayString();
        V.StrAssign(new char[]{'1', '2'});
        as7.Replace(T, V).print();
    }


}


 

輸出
賦值
abcde
拷貝
abcde
轉為陣列
abcde
abcde
abxde
求串長
5
判空
false
比較兩個字串
0
-1
連線 未截斷
abcdeabcde
連線 截斷
abcde12345
擷取子串 從第2個位置開始 擷取4位
234
子串匹配
6
插入新值
a67bc
刪除指定位置2開始 長度為3的子串
123456789
156789
1234789
子串替換
ab12e12

原始碼的github地址,可以下載到本地執行