关于一个字符处理的问题

Question

比如输入一个表示集合的字符串{1,a,{5,6},<4,6>}
处理的目标是这样的
遇到1则生成一个Integer对象，遇到a生成一个String对象，遇到{5，6}生成另外一个集合对象，遇到<4，6>则生成一个自定义的对象。
这种情况怎么处理啊 各位大侠给点思路啊

Answer 1

此回复为自动发出,仅用于显示而已，并无任何其他特殊作用
楼主【cut21】截止到2008-07-25 11:24:58的历史汇总数据(不包括此帖)：
发帖的总数量:8                        发帖的总分数:380                      每贴平均分数:47                       
回帖的总数量:5                        得分贴总数量:0                        回帖的得分率:0%                       
结贴的总数量:8                        结贴的总分数:380                      
无满意结贴数:1                        无满意结贴分:30                       
未结的帖子数:0                        未结的总分数:0                        
结贴的百分比:100.00%               结分的百分比:100.00%                  
无满意结贴率:12.50 %               无满意结分率:7.89  %                  
敬礼!

Answer 2

子集合用递归取，非子集合就用对象的.getClass()取

Answer 3

题目描述的不是很清楚,不知道具体的串到底是什么情况的.
比如输入一个表示集合的字符串{1,a,{5,6}, <4,6>} 
1是个数字,是否允许多为的数存在?
a这里是否允许多个字母的串?
提供一个基本的思路,类似于编译原理中的词法分析吧.
循环判断
一开始可以使用一个count计数,记录访问到字符串中的第几个字符.
判断,如果是数字(多位的话继续取),如何处理..
如果是字母(多个字母的串同样向下取),处理...
如果是'{‘，直接从当前位置开始找下一个配对的’}‘，把这两个位置中的串取出，就是一个子集合，count计数跳到’}‘的后面，继续循环
如果是’<'，直接从当前位置找下一个配对的‘>',把这两个位置中的串取出，创建你自定义的对象，count技术跳到‘>'的后面，继续循环
如果是',',改变count，进入下一次循环差不多这个意思，思想很简单，可能有不完善的地方，拍砖就不必了。

Answer 4

关于字符里面的{跳转到}和<跳转到>的跳转如何实现啊 跳转还要取出里面的数据 如何取？

Answer 5

substring取得子串
indexOf()方法可以从指定位置开始查找某个字符的位置。

Answer 6

我想写一个类似容器里面set的集合类Sembling 
构造方法为public Sembling(string str)
比如str传入{a,c,d,{e,f}} 
能将a,c,d变成string对象 将{e,f}转换成集合对象（也就是Sembling）（将一个一个对象按不同格式选出来）存储到集合的数据结构当中
另外再请教各位高手一个问题
集合当中重复元素是怎样处理的 大家给个思路
此贴明日将加到100分

Answer 7

重复元素可以通过hash表来处理.

Answer 8

把你要处理的数据保存到hash表中,重复的内容它会只保留一份.

Answer 9

import java.util.Iterator;
import java.util.Vector;public class Sembling{
public static final String LEFTCOL = "{"; //符号标识,"{",可以根据需要变成"<"
public static final String RIGHTCOL = "}"; //符号标识,"}",可以根据需要变成">"
public static final String SPLITER = ","; //符号标识,",",可以根据需要变成";"
//{a,c,d,{e,f}}
Vector sets; //集合
String toString; //只是用来toString()，方便打印
public Sembling(String para){
sets = parse(para);
toString = para;
}

/**
 * 解析字符串比如传入{a,c,d,{e,f}}能将a,c,d变成string对象 将{e,f}转换成集合对象（也就是Sembling）（将一个一个对象按不同格式选出来）存储到集合的数据结构当中 
 * @param str
 * @return
 */
public Vector parse(String str){
Vector vec = new Vector();

//step1，或取"{""}"的位置
int subStartPos = str.indexOf(LEFTCOL);
if(subStartPos >=0 ){
subStartPos += 1;
}else{
subStartPos = 0;
}

int subEndPos = str.lastIndexOf(RIGHTCOL);
if(subEndPos <0 ){
subEndPos = str.length();
}
//step2取数据,既去掉"{}";
String tmp = str.substring(subStartPos,subEndPos);

//step3将数据一个一个取出，并放入vec中
String[] groups = tmp.split("\\" + LEFTCOL);
for(int i=0; i<groups.length; i++){
if(groups[i].indexOf(RIGHTCOL) >=0){
vec.add(new Sembling(LEFTCOL + groups[i]));
}else{
String[] strGroups = groups[i].split(SPLITER);
for(int j=0; j<strGroups.length; j++){
vec.add(strGroups[j]);
}
}
}
return vec;
}

/**
 * 或取集合
 * @return
 */
public Vector getSets(){
return sets;
}

public int size() {
return sets.size();
}

public String toString(){
return toString;
}

/**
 * 测试：将一个Sembling中的每一个元素打印出
 * @param args
 */
public static void main(String[] args){
Sembling sm = new Sembling("{a,c,d,{e,f}}");
Iterator itor = sm.getSets().iterator();
while(itor.hasNext()){
System.out.println(itor.next().toString());
}
}
}

Answer 10

我是自己写数据结构存储，不是用java里面的容器。
我的问题是如何处理存入的元素有重复的现象

Answer 11

TO finalzhzhk 
这几行代码有点问题
//step3将数据一个一个取出，并放入vec中 
String[] groups = tmp.split("\\" + LEFTCOL); 
for(int i=0; i <groups.length; i++){ 
if(groups[i].indexOf(RIGHTCOL) >=0){ 
vec.add(new Sembling(LEFTCOL + groups[i])); 
}
……
如果构造方法传的是{d,{e,f},w,t}则这里的
groups[0]=d//正确
groups[1]={e,f},w,t//会讲w,t误传入到新new的Sembling当中

Answer 12

恩，确实有错，我的思路就是这样的。
step3中的bug修改修改（用正则简单一些）。
（下午有事，晚上来修改）重复的数据只是数据重复而已，这些数据还有坐标啊，所以可以存在重复的数据，如果不想保存重复的数据，在
vec.add()时处理一下就可以了

Answer 13

import java.util.Iterator;
import java.util.Vector;public class Sembling {
public static final String LEFTCOL = "{"; // 符号标识,"{",可以根据需要变成" <"
public static final String RIGHTCOL = "}"; // 符号标识,"}",可以根据需要变成">"
public static final String SPLITER = ","; // 符号标识,",",可以根据需要变成";"
// {a,c,d,{e,f}}
Vector sets; // 集合
String toString; // 只是用来toString()，方便打印
SemQueue semQueue = new SemQueue(); public Sembling(String para) {
sets = parse(para);
toString = para;
} /**
 * 解析字符串比如传入{a,c,d,{e,f}}能将a,c,d变成string对象
 * 将{e,f}转换成集合对象（也就是Sembling）（将一个一个对象按不同格式选出来）存储到集合的数据结构当中
 * 
 * @param str
 * @return
 */
public Vector parse(String str) {
Vector vec = new Vector(); // step1，获取"{""}"的位置
int subStartPos = str.indexOf(LEFTCOL);
if (subStartPos >= 0) {
subStartPos += 1;
} else {
subStartPos = 0;
} int subEndPos = str.lastIndexOf(RIGHTCOL);
if (subEndPos < 0) {
subEndPos = str.length();
}
// step2取数据,既去掉"{}";
char[] tmp = str.substring(subStartPos, subEndPos).toCharArray(); int count = 0; // 记录"{"的个数,嵌套递归用
// step3将数据一个一个取出，并放入vec中
for (int i = 0; i < tmp.length; i++) {
if (String.valueOf(tmp[i]).equalsIgnoreCase(LEFTCOL)) {
count++;
} if (String.valueOf(tmp[i]).equalsIgnoreCase(SPLITER)) {
if (count == 0) {
if (!semQueue.isEmpty()) {
vec.add(semQueue.getQueue());
}
continue;
}
} semQueue.add(tmp[i]);// 放入队列
if (String.valueOf(tmp[i]).equalsIgnoreCase(RIGHTCOL)) {
count--;
if (count == 0) {
vec.add(new Sembling(semQueue.getQueue()));
}
} }
// step4:因为","有可能不结尾，所以需要将semQueue中的值取出
String lastObj = semQueue.getQueue();
if (lastObj.indexOf(LEFTCOL) >= 0) {
vec.add(new Sembling(lastObj));
} else {
vec.add(lastObj);
} return vec;
} /**
 * 获取集合
 * 
 * @return
 */
public Vector getSets() {
return sets;
} public int size() {
return sets.size();
} public String toString() {
return toString;
} /**
 * 测试：将一个Sembling中的每一个元素打印出
 * 
 * @param args
 */
public static void main(String[] args) {
Sembling sm = new Sembling("{a,c,d,{e,k},y,{{e,ks},{3,4}},s}");
Iterator itor = sm.getSets().iterator();
while (itor.hasNext()) {
System.out.println(itor.next().toString());
}
}
}/**
 * 一个队列,缓存用.
 * 
 * @author Administrator
 * 
 */
class SemQueue extends Vector { /**
 * 返回队列的值:c 或 {s,e},并清空
 * 
 * @return
 */
public String getQueue() {
StringBuffer buf = new StringBuffer();
for (int i = 0; i < this.size(); i++) {
buf.append(this.get(i));
} this.removeAllElements();
return buf.toString();
}
}

Answer 14

呵呵,新的实现:
1,改进了19楼的问题
2,支持嵌套递归(即大括号中含有n层Sembling)如解析{a,c,d,{e,k},y,{{e,ks},{3,4}},s}
输出:
a
c
d
{e,k}
y
{{e,ks},{3,4}}
s

Answer 15

在我这里结果似乎是
a
c
d
{e,k},y,{e,k},
{3,4}},s

Answer 16

不应该啊,而且{e,ks}你的输出怎么会把s丢了?