操作(一)：功能：用左字符串，右字符串修饰的字符串或字符串容器
//返回一个用左字符串，右字符串修饰的字符串
publicString StringAdd(String info,String left,String right)
{return left+info+right;
}//用左字符串，右字符串修饰字符串容器
public List StringListAdd(ListinfoList,String left,String right)
{int num=infoList.size();
List ls=new ArrayList();for(int i=0;i
{
ls.add(left+infoList.get(i)+right);
}returnls;
}
操作(二)：功能：将容器组合成一个字符串,并且字符串和字符串之间添加decorate
//将字符串容器组合成一个字符串,并且字符串和字符串之间添加decorate
public String StringListIntoString(ListinfoList,String decorate)
{
String result=newString();int num=infoList.size();for(int i=1;i
{
result+=decorate+infoList.get(i);
}if(num>0)
result=infoList.get(0)+result;returnresult;
}//将整型容器组合成一个字符串,并且整型和字符串之间添加decorate
public String IntegerListIntoString(ListinfoList,String decorate)
{
String result=newString();int num=infoList.size();for(int i=1;i
{
result+=decorate+infoList.get(i);
}if(num>0)
result=infoList.get(0)+result;returnresult;
}
操作(三)：功能：字符串匹配正则表达式
//判断字符串是否符合正则表达式(全匹配)
public booleanStringIsSuitExep(String str,String exp)
{boolean isMatch =Pattern.matches(exp, str);returnisMatch;
}//判断字符串是否符合正则表达式(匹配子字符串)
public booleanStringIsSuitSubExep(String str,String exp)
{//编译正则表达式
Pattern pattern =Pattern.compile(exp);//忽略大小写的写法//Pattern pat = Pattern.compile(regEx, Pattern.CASE_INSENSITIVE);
Matcher matcher =pattern.matcher(str);//查找字符串中是否有匹配正则表达式的字符/字符串
boolean rs =matcher.find();returnrs;
}
//获得字符串中的符合正则表达式的值 返回结果为List
public ListgetExpString(String exp,String str)
{
Pattern pattern=Pattern.compile(exp);
Matcher matcher=pattern.matcher(str);
List result=new ArrayList();
while(matcher.find()) {
result.add(matcher.group());
} returnresult;
}
//将字符串中符合正则表达式的字符替换为空
public List StringListReplaceAll(Listinfos,String exp)
{
List result=new ArrayList();
int g_size=infos.size();
for(int i=0;i
{
String temp=infos.get(i).replaceAll(exp, "");
result.add(temp);
} returnresult;
}
//以对应正则表达式分隔字符并且将分隔后的字符串储存进字符串容器中
public List> StringSplitByExpToStringList(List strlist,String exp)
{
List> strresult=new ArrayList>();
int g_size=strlist.size();
for(int i=0;i
{
String list=strlist.get(i);
if(list==null||list.equals(""))
continue;
String []strnlist=list.split(exp);
strresult.add(StringNlistToStringList(strnlist));
}
return strresult;
}
//以对应正则表达式分隔字符并且将分隔后的字符串储存进类容器中
public List StringSplitByExpToTList(List strlist,String exp,String []namelist,Class clazz)
{
List tresult=new ArrayList();
int g_size=strlist.size();
for(int i=0;i
{
String list=strlist.get(i);
if(list==null||list.equals(""))
continue;
String []nlist=list.split(exp);
if(nlist.length
{
throw new IllegalArgumentException("The Length of namelist is longer than nlist");
}
T bean;
try {
bean = clazz.newInstance();
int num=namelist.length;
for(int j=0;j
{
Field fs=getDeclaredField(bean, namelist[j]);
if(fs==null){
throw new IllegalArgumentException("Could not find field["+
namelist[j]+"] on target ["+bean+"]");
}
makeAccessiable(fs);
try{
fs.set(bean, (Object)nlist[j]);
}
catch(IllegalAccessException e){
System.out.println("不可能抛出的异常");
}
}
tresult.add(bean);
} catch (InstantiationException | IllegalAccessException e1) {
// TODO 自动生成的 catch 块
e1.printStackTrace();
}
}
return tresult;
}
//以对应正则表达式分隔字符并且将分隔后的字符串储存进类容器中(自动型)
public List StringSplitByExpToTList(List strlist,String exp,Class clazz)
{
List tresult=new ArrayList();
int g_size=strlist.size();
for(int i=0;i
{
String list=strlist.get(i);
if(list==null||list.equals(""))
continue;
String []nlist=list.split(exp);
Field[ ] fields = clazz.getDeclaredFields( );
T bean;
try {
bean = clazz.newInstance();
// 循环遍历字段，获取字段相应的属性值
int j=0;
for ( Field field : fields )
{
// 假设不为空。设置可见性，然后返回
field.setAccessible( true );
try
{
Field fs=getDeclaredField(bean, field.getName( ));
if(fs==null){
throw new IllegalArgumentException("Could not find field["+
field.getName( )+"] on target ["+bean+"]");
}
makeAccessiable(fs);
try{
fs.set(bean, (Object)nlist[j]);
}
catch(IllegalAccessException e){
System.out.println("不可能抛出的异常");
}
// 设置字段可见，就可以用get方法获取属性值。
//result += field.get( o ) +" ";
++j;
}
catch ( Exception e )
{
// System.out.println("error--------"+methodName+".Reason is:"+e.getMessage());
}
}
tresult.add(bean);
} catch (InstantiationException | IllegalAccessException e1) {
// TODO 自动生成的 catch 块
e1.printStackTrace();
}
}
return tresult;
}
//删除string容器中符合正则表达式的元素
public List deleteStringListIsSuitExp(List strlist,String exp)
{
Iterator it = strlist.iterator();
while(it.hasNext()){
String x = it.next();
if(StringIsSuitExep(x, exp)){
it.remove();
}
}
return strlist;
}
//删除string容器的容器中符合正则表达式的元素
public List> deleteStringListListIsSuitExp(List> strlist,String exp)
{
int g_size=strlist.size();
for(int i=0;i
{
List itTemp=new ArrayList(strlist.get(i));
Iterator it = itTemp.iterator();
while(it.hasNext()){
if(StringIsSuitExep(it.next(), exp)){
it.remove();
}
}
strlist.set(i, itTemp);
}
return strlist;
}
操作(四)：功能：有关String类型的数据各种类型转换
//将Object容器转换为String容器
public List ObjectListToStringList(ListobjList)
{
List strList=new ArrayList();for(int i=0;i
{
strList.add((String)objList.get(i));
}returnstrList;
}//将Object数组转化为String数组
publicString[] ObjectListToStringNlist(Object []object)
{
List listTemp =java.util.Arrays.asList(object);
List list=ObjectListToStringList(listTemp);
String[] strings= newString[list.size()];
list.toArray(strings);returnstrings;
}//将String容器转换为String数组
public String[] StringListToStringNlist(Listlist)
{return list.toArray(newString[list.size()]);
}//将Stringlist转换为String
public String ListToString(Listlists)
{
String str="";for(int i=0;i
{
str+=lists.get(i);
}returnstr;
}//将String数组转换为String容器
public ListStringNlistToStringList(String []strlist)
{
List list =java.util.Arrays.asList(strlist);returnlist;
}
//将字符串容器的容器组合成一个字符串容器,并且字符串和字符串之间添加decorate
public List StringListListIntoStringList(List> infoList,String decorate)
{
List result=new ArrayList();
int num=infoList.size();
for(int i=0;i
{
int initnum=infoList.get(i).size();
String resultTemp=new String();
for(int j=1;j
{
resultTemp+=decorate+infoList.get(i).get(j);
}
if(initnum>0)
resultTemp=infoList.get(i).get(0)+resultTemp;
result.add(resultTemp);
}
return result;
}
//将字符串容器的容器拼接成字符串容器
public List StringListListAddToStringList(List> strllist)
{
List strResult=new ArrayList();
Integer g_size=strllist.size();
for(int i=0;i
{
strResult.addAll(strllist.get(i));
}
return strResult;
}
操作(五)：功能：判断一系列的以空格分开的字符串序列中的特定位置是否含有相对应的信息(全一致长度容器),有的话返回对应行数容器，没有的话返回null
//判断一系列的以空格分开的字符串序列中的特定位置是否含有相对应的信息(全一致长度容器),有的话返回对应行数容器，没有的话返回null
public List judgeStringListContainPerfect(List> info,intcount,String contain)
{
List numList=new ArrayList();int g_size=info.size();for(int i=0;i
{int g_initsize=info.get(i).size();if(g_initsize>count)
{return null;
}else{if(!info.get(i).get(count-1).equals(contain))
{continue;
}else{
numList.add(i);
}
}
}if(numList.size()==0)return null;else returnnumList;
}//判断一系列的以空格分开的字符串序列中的特定位置是否含有相对应的信息(非全一致长度容器),有的话返回对应行数容器，没有的话返回null
public List judgeStringListContain(List> info,intcount,String contain)
{
List numList=new ArrayList();int g_size=info.size();for(int i=0;i
{int g_initsize=info.get(i).size();if(g_initsize>count)
{continue;
}else{if(!info.get(i).get(count-1).equals(contain))
{continue;
}else{
numList.add(i);
}
}
}if(numList.size()==0)return null;else returnnumList;
}
操作(六)功能：String与map操作
//将字符串容器的值统计并记录进Map中
public Map StringListToMapValue(Liststrlist)
{
Map maplist=new HashMap();
Integer g_size=strlist.size();for(int i=0;i
Integer g_map=maplist.get(strlist.get(i));if(g_map==null)
{
maplist.put(strlist.get(i),1);
}else{
maplist.put(strlist.get(i), g_map+1);
}
}returnmaplist;
}//将两个字符串容器对应链接成Map
public Map StringListToMap(List list1,Listlist2)
{
Map map=new HashMap();int g_size=list1.size();if(list1.size()!=list2.size())returnmap;else{for(int i=0;i
{
map.put(list1.get(i), list2.get(i));
}
}returnmap;
}//将字符串容器和整型容器对应链接成Map
public Map StringListAndIntegerListToMap(List list1,Listlist2)
{
Map map=new HashMap();int g_size=list1.size();if(list1.size()!=list2.size())returnmap;else{for(int i=0;i
{
map.put(list1.get(i), list2.get(i));
}
}returnmap;
}
操作(七)功能：对于字符串容器内元素的操作
//抽取字符串容器容器中的某一列出来(perfect型)
public List StringListListInitSingleList(List>strlist,Integer index)
{
List strlistTemp=new ArrayList();int g_size=strlist.size();if(g_size==0)returnstrlistTemp;if(index>=strlist.get(0).size())returnstrlistTemp;for(int i=0;i
{
strlistTemp.add(strlist.get(i).get(index));
}returnstrlistTemp;
}//判断字符串列表精确包含某个字符串
public boolean StringListIsExContainString(Liststrlist,String it)
{int num=strlist.size();for(int i=0;i
{if(strlist.get(i).equals(it))return true;
}return false;
}//字符串容器和字符串容器中将互相包含的元素取出
public List StringListSameOutStringList(List strlist1,Liststrlist2)
{
List result=new ArrayList();int g_size=strlist1.size();int g_size2=strlist2.size();if(g_size==0||g_size2==0)returnresult;for(int i=0;i
{
String itTemp=strlist1.get(i);if(StringListIsExContainString(strlist2,itTemp))
{
result.add(itTemp);
}
}returnresult;
}//将字符串中重复的元素移除
public List StringListRemoveRepeat(Listinfos)
{
List result=new ArrayList();int g_size=infos.size();for(int i=0;i
{
String temp=infos.get(i);if(!StringListContainString(result,temp))
{
result.add(temp);
}
}returnresult;
}//判断字符串中是否含有
public boolean StringListContainString(Listinfo,String txt)
{int g_size=info.size();for(int i=0;i
{if(info.get(i).equals(txt))
{return true;
}
}return false;
}
操作(八)功能：字符串容器内元素关于正则表达式匹配
//返回字符串容器中符合正则的字符串容器
public List StringListGetSuitExpStringList(Liststrlist,String exp)
{
List temp=new ArrayList();int g_size=strlist.size();for(int i=0;i
{
String subtemp=strlist.get(i);if(StringIsSuitExep(subtemp,exp))
temp.add(subtemp);
}returntemp;
}//返回字符串容器中字符包含符合正则的字符串容器
public List StringListGetSuitSubExpStringList(Liststrlist,String subexp)
{
List temp=new ArrayList();int g_size=strlist.size();for(int i=0;i
{
String subtemp=strlist.get(i);if(StringIsSuitSubExep(subtemp,subexp))
temp.add(subtemp);
}returntemp;
}
操作(九)字符串容器与其他容器的转换
//将字符串转换成T类
public T StringToT(String str,Classit)
{return StringListToT(StringNlistToStringList(str.split(" ")),it);
}//将字符串容器的值转换为T
public T StringListToT(List it,Classclazz)
{
Field[ ] fields=clazz.getDeclaredFields( );
T bean=null;try{
bean=(T) clazz.newInstance();//循环遍历字段，获取字段相应的属性值
int j=0;for( Field field : fields )
{//假设不为空。设置可见性，然后返回
field.setAccessible( true);try{
Field fs=getDeclaredField(bean, field.getName( ));if(fs==null){throw new IllegalArgumentException("Could not find field["+field.getName( )+"] on target ["+bean+"]");
}
makeAccessiable(fs);try{
fs.set(bean, (Object)it.get(j));
}catch(IllegalAccessException e){
System.out.println("不可能抛出的异常");
}//设置字段可见，就可以用get方法获取属性值。//result += field.get( o ) +" ";
++j;
}catch( Exception e )
{//System.out.println("error--------"+methodName+".Reason is:"+e.getMessage());
}
}
}catch (InstantiationException |IllegalAccessException e1) {//TODO 自动生成的 catch 块
e1.printStackTrace();
}returnbean;
}//将T转换为字符串容器
public ListTToStringList(T it)
{
List result = new ArrayList();
Class> c=it.getClass();//获取类中的全部定义字段
Field[ ] fields =c.getDeclaredFields( );//循环遍历字段，获取字段相应的属性值
for( Field field : fields )
{//假设不为空。设置可见性，然后返回
field.setAccessible( true);try{//设置字段可见，就可以用get方法获取属性值。
result.add((String)field.get( it ));
}catch( Exception e )
{//System.out.println("error--------"+methodName+".Reason is:"+e.getMessage());
}
}returnresult;
}//将对应的T容器转换为字符串的容器的容器
public List> TListToStringListList(Listtlist)
{
List> result=new ArrayList>();int g_size=tlist.size();if(g_size==0)returnresult;
EntityToString ets=newEntityToString();for(int i=0;i
{
result.add(StringNlistToStringList(ets.getString(tlist.get(i), tlist.get(i).getClass()).split(" ")));
}returnresult;
}//将字符串容器的容器转换为T容器
public List StringListListToTlist(List> strlist,Class>clazz)
{
List tresult=new ArrayList();int g_size=strlist.size();
Field[ ] fields=clazz.getDeclaredFields( );for(int i=0;i
{
List list=strlist.get(i);if(list==null)continue;
String []nlist=StringListToStringNlist(list);
T bean;try{
bean=(T) clazz.newInstance();//循环遍历字段，获取字段相应的属性值
int j=0;for( Field field : fields )
{//假设不为空。设置可见性，然后返回
field.setAccessible( true);try{
Field fs=getDeclaredField(bean, field.getName( ));if(fs==null){throw new IllegalArgumentException("Could not find field["+field.getName( )+"] on target ["+bean+"]");
}
makeAccessiable(fs);try{
fs.set(bean, (Object)nlist[j]);
}catch(IllegalAccessException e){
System.out.println("不可能抛出的异常");
}//设置字段可见，就可以用get方法获取属性值。//result += field.get( o ) +" ";
++j;
}catch( Exception e )
{//System.out.println("error--------"+methodName+".Reason is:"+e.getMessage());
}
}
tresult.add(bean);
}catch (InstantiationException |IllegalAccessException e1) {//TODO 自动生成的 catch 块
e1.printStackTrace();
}
}returntresult;
}
操作(十)功能：字符串容器与对应字符串的操作
//返回对应子字符串容器中对应字符串中的位置的容器
public List StringListInStringListIndexof(List allinfo,Listsublist)
{
List numlist=new ArrayList();int g_size=allinfo.size();int g_size2=sublist.size();if(g_size==0||g_size2==0)returnnumlist;for(int i=0;i
{
numlist.add(allinfo.indexOf(sublist.get(i)));
}returnnumlist;
}//将字符串容器的容器中取出对应整型容器对应位置的字符串的容器的容器
public List> StringListListInitIndexOfIntegerList(List> ls,Listindexof)
{int g_size=ls.size();
System.out.println(g_size);int g_numsize=indexof.size();
List> result=new ArrayList>();for(int i=0;i
{
List temp=new ArrayList();for(int j=0;j
{
temp.add(ls.get(i).get(indexof.get(j)));
}
result.add(temp);
}returnresult;
}//将字符串容器的容器链接上对应字符串容器的容器
public List> StringListListAddToByStringListList(List> strlistlist,List>strlist)
{int g_size=strlistlist.size();
List> result=new ArrayList>();for(int i=0;i
{
List strTemp=new ArrayList(strlistlist.get(i));
strTemp.addAll(strlist.get(i));
result.add(strTemp);
}returnresult;
}//获得对应类容器中的字符串容器
public List getTSingleList(Listtlist,String name)
{
StringHandle sh=newStringHandle();
EntityToString ets=newEntityToString();return sh.StringListListInitSingleList(sh.TListToStringListList(tlist), ets.getNameIndexof(tlist.get(0).getClass(), name));
}//将字符串容器的容器链接上对应字符串容器
public List> StringListListAddToStringListList(List> strlistlist,Liststrlist)
{int g_size=strlistlist.size();
List> result=new ArrayList>();for(int i=0;i
{
List strTemp=new ArrayList(strlistlist.get(i));
strTemp.add(strlist.get(i));
result.add(strTemp);
}returnresult;
}
操作(十一)功能：判断字符串长度范围
//判断字符串的长度是否处于n到m个长度
public boolean StringIsSuitLength(String it,int n,intm)
{if(it.length()>=n&&it.length()<=m)return true;return false;
}
操作(十二)功能
//获取field属性，属性有可能在父类中继承
publicField getDeclaredField(Object obj,String fieldName){for (Class> clazz=obj.getClass(); clazz!=Object.class; clazz=clazz.getSuperclass()){try{returnclazz.getDeclaredField(fieldName);
}catch(Exception e){
}
}return null;
}//判断field的修饰符是否是public,并据此改变field的访问权限
public voidmakeAccessiable(Field field){if(!Modifier.isPublic(field.getModifiers())){
field.setAccessible(true);
}
}
348
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
