Java中如何将两个字符串合并,并且把重复的元素去掉，不能用任何排序指令那些，纯手打写出来。

Posted 2023-04-22

package test;
public class StringHeBing 
 public static String merge(String str1,String str2)
  int len = str2.length();
  for (int i = 0; i < len; i++) 
   char c = str2.charAt(i);
   if (str1.indexOf(c) == -1) 
    str1 = str1.concat(c+"");
   
  
  System.err.println(str1);
  return str1;
 
 public static void main(String[] args) 
  String str1 = "上海金融大厦";
  String str2 = "上港集团";
  merge(str1, str2);
 

 上面的做法只把加加进来的字符串去重，而未把原来的字符串去重复，下面做了个新的

public static String merge1(String str1,String str2)
        String add = str1.concat(str2);
        String result= add.charAt(0)+"";
        for (int i = 1; i < add.length(); i++)
            char c = add.charAt(i);
               if (result.indexOf(c) == -1) 
                   result = result.concat(c+"");
               
        
        return result;
    

参考技术A public class test1 
public static void main(String args[]) 
String str1 = "abdasidan";
String str2 = "absdaddsa";
String str = str1 + str2;//合并
System.out.println(str);
for (int i = 0; i < str.length(); i++) 
char c = str.charAt(i);
for (int j = i+1;j<str.length();j++) 
char cc = str.charAt(j);
if (c == cc) 
str = str.substring(0, j) + str.substring(j + 1);
j--;



System.out.println(str);

参考技术B 其实很简单的，用正则一句就够了，没必要写那么多
String a = "aabceesiojkdd";
String b= "khiehkkkhhssdfesee";

String c = (a+b).replaceAll("(.)\\1+", "");
System.out.println(c);//这里c就没有重复的字符了追问

我知道用指令直接就可以了，但是我现在不想用，我只想要一个思路而已

追答

你这就是舍近求远，
等等， 我给你写一下

追问

嗯，我不要答案只要过程

谢了！

追答

String a = "aadfe";
String b= "eggetsggr";
String str = test((a+b).toCharArray());
System.out.println(str);

//这个是去重的方法
private static String test(char[] str)
String s = "";

//用循环遍历当前字符串

for (int i = 0; i < str.length-1; i++)
//与后面一个字符不相等的加入进来，可以去重连续重复的字符

if (str[i] != str[i + 1])
s += str[i];


return s; //返回我们提取出来的字符

//修改了一下，一个参数就可以了，其实
//大概思路是这样子，这个方法不是完美的，还有些问题，理解思路就好

xslt2+ 如何将组与任何匹配的元素组合并删除元素的重复项

【中文标题】xslt2+ 如何将组与任何匹配的元素组合并删除元素的重复项

【英文标题】：xslt2+ How to combine groups with any matching elements and remove duplicates of elements

【发布时间】：2022-01-09 15:59:26

【问题描述】：

这是我将组与任何匹配元素组合并删除重复元素的解决方案。 例如，我画了一个简单的输入和输出应该是什么。如果两个组具有相同的元素，则将这些组合并为一个具有除重复之外的所有元素的组。 有其他方法吗？

<xsl:variable name="in">
   <g>
      <i>8</i>
      <i>2</i>
   </g>
   <g>
      <i>2</i>
      <i>4</i>
   </g>
   <g>
      <i>4</i>
      <i>5</i>
   </g>
   <g>
      <i>6</i>
      <i>7</i>
   </g>
</xsl:variable>

<xsl:template match="/">
 <out>
  <xsl:for-each-group select="$in/g/i" group-by="k2:iin(.,$in)[1]">
    <g>
    <xsl:for-each-group select="current-group()" group-by=".">
      <xsl:copy-of select="current-group()[1]"/>
    </xsl:for-each-group>
    </g>
  </xsl:for-each-group>
 </out>
</xsl:template>

<xsl:function name="k2:iin">
 <xsl:param name="i"/> <!-- current catch -->
 <xsl:param name="in"/> <!-- const catch scope -->
 <xsl:sequence select="
let $xi:=$in/g[i = $i]/i return
if($xi[not(. = $i)])then
 k2:iin($xi,$in) else
$xi
 "/>
</xsl:function>


<out>
   <g>
      <i>8</i>
      <i>2</i>
      <i>4</i>
      <i>5</i>
   </g>
   <g>
      <i>6</i>
      <i>7</i>
   </g>
</out>

【问题讨论】：

像$in/g[i = $i] 这样的比较通常建议您可以使用密钥<xsl:key name="by-i" match="g" use="i"/>。

谢谢。是否需要编辑表达式以调用 key() 以使用 ？

你可以用key函数来代替比较，也就是说，你可以用key('by-id', $i, $in)/i代替$in/g[i = $i]/i。

而<xsl:copy-of select="current-group()[1]"/>可以简单地写成<xsl:copy-of select="."/>，因为当前组中的第一项是for-each-group中的上下文项。

【参考方案1】：

除了 cmets 中的建议外，您可以将内部 xsl:for-each-group 替换为

<xsl:for-each select="distinct-values(current-group())">
   <i><xsl:value-of select="."/></i>
</xsl:for-each>

虽然distinct-values 不保证保留订单，但xsl:for-each-group 可以。所以你的方法没有真正的好处（但你确实要求替代方案......）

【讨论】：

这里不仅顺序受到影响，还必须手动重新创建元素

【参考方案2】：

正如问题所说的xslt2+ 我想到了一种紧凑或优雅的 XSLT 方法，看来您实际上并不需要使用分组，但可以只存储整数数组的序列。然而，不知何故，尝试使用fold-left 编写递归处理方法并没有真正给出紧凑或优雅的方法，我发布它只是为了展示尝试：

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  version="3.0"
  xmlns:xs="http://www.w3.org/2001/XMLSchema"
  xmlns:map="http://www.w3.org/2005/xpath-functions/map"
  exclude-result-prefixes="#all"
  expand-text="yes">

  <xsl:output method="xml" indent="yes"/>
  
  <xsl:template match="data">
    <xsl:copy>
      <xsl:variable name="i-value-groups" 
        select="fold-left(g, (), function($value, $g) 
                  let $i-values := distinct-values($g/i/xs:integer(.)),
                      $group := $value[?* = $i-values],
                      $group-pos := for $pos in 1 to count($value) return $pos[exists($value[?* = $i-values])]
                  return 
                    if (exists($group))
                    then (subsequence($value, 1, $group-pos - 1), array  distinct-values(($group?*, $i-values)) , subsequence($value, $group-pos + 1))
                    else ($value, array  $i-values )                  
                 
                )"/>
      <xsl:for-each select="$i-value-groups">
        <g>
          <xsl:for-each select="?*">
            <i>.</i>
          </xsl:for-each>
        </g>
      </xsl:for-each>      
    </xsl:copy>
  </xsl:template>
  
  <xsl:mode on-no-match="shallow-copy"/>

</xsl:stylesheet>

这假设输入样本像

<data>
   <g>
      <i>8</i>
      <i>2</i>
   </g>
   <g>
      <i>2</i>
      <i>4</i>
   </g>
   <g>
      <i>4</i>
      <i>5</i>
   </g>
   <g>
      <i>6</i>
      <i>7</i>
   </g>
</data>

当然，如果需要“分组”g 元素而不是普通整数，您可以使用相同的 fold-left 方法返回数组序列，或者在以下示例中，返回一个序列地图数量（在 XSLT/XPath 4 包裹或记录中）：

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  version="3.0"
  xmlns:xs="http://www.w3.org/2001/XMLSchema"
  xmlns:map="http://www.w3.org/2005/xpath-functions/map"
  xmlns:mf="http://example.com/mf"
  exclude-result-prefixes="#all"
  expand-text="yes">

  <xsl:output method="xml" indent="yes"/>
  
  <xsl:function name="mf:collect-parcels" as="map(xs:string, element(g)*)*">
    <xsl:param name="input-sequence" as="element(g)*"/>
    <xsl:sequence
      select="fold-left(
                $input-sequence,
                (), 
                function($parcel-ac, $g) 
                  let $i-elements := $g/i,
                      $matching-parcel-pos := 
                        for $pos in 1 to count($parcel-ac)
                        return $pos[exists($parcel-ac[$pos][?value/i = $i-elements])],
                      $matching-parcel := $parcel-ac[$matching-parcel-pos]
                  return 
                    if (exists($matching-parcel))
                    then (subsequence($parcel-ac, 1, $matching-parcel-pos - 1), map:entry('value', ($matching-parcel?value, $g)), subsequence($parcel-ac, $matching-parcel-pos + 1))
                    else ($parcel-ac, map:entry('value', $g))                  
                
              )"/>
  </xsl:function>
  
  <xsl:template match="data">
    <xsl:copy>
      <xsl:for-each select="mf:collect-parcels(g)">
        <g>
          <xsl:for-each-group select="?value/i" group-by=".">
            <xsl:copy-of select="."/>
          </xsl:for-each-group>
        </g>
      </xsl:for-each>      
    </xsl:copy>
  </xsl:template>
  
  <xsl:mode on-no-match="shallow-copy"/>

</xsl:stylesheet>

【参考方案3】：

我意识到可以上升到Groups级别（不需要Items的序列）

<xsl:template match="/">
 <out>
  <xsl:for-each-group
  select="$in/g"
  group-by="k2:g(.)[1]"
  >
    <g>
    <xsl:for-each-group
    select="current-group()/i"
    group-by="."
    >
      <xsl:copy-of select="."/>
    </xsl:for-each-group>
    </g>
  </xsl:for-each-group>
 </out>
</xsl:template>

<xsl:function name="k2:g">
 <xsl:param name="g"/>
 <xsl:sequence select="
let $xg:=$g[1]/../g[i[. = $g/i]] return
if(count($xg) gt count($g))then k2:g($xg) else
$xg
 "/>
</xsl:function>

为了尽量避免分组的开销，您可以先收集所有消失的组。 （当然，要为解决方案控制的这种复杂性买单）

<xsl:template match="/">
 <xsl:variable name="gmap" select="k2:gmap(1,$in/g[1],map)"/>
 <xsl:message select="$gmap"/>
 <out>
  <xsl:comment select="'+gmap()'"/>
  <xsl:for-each-group
  select="$in/g"
  group-by="
let $x:=(1 + count(preceding-sibling::g)) return
($gmap($x),$x)[1]
  "
  >
    <g>
    <xsl:for-each-group
    select="current-group()/i"
    group-by="."
    >
      <xsl:copy-of select="."/>
    </xsl:for-each-group>
    </g>
  </xsl:for-each-group>
 </out>
</xsl:template>

<xsl:function name="k2:g">
 <xsl:param name="g"/>
 <xsl:sequence select="
let $xg:=$g[1]/../g[i[. = $g/i]] return
if(count($xg) gt count($g))then k2:g($xg) else
$xg
 "/>
</xsl:function>

<xsl:function name="k2:gmap">
 <xsl:param name="gpos"/>
 <xsl:param name="g"/>
 <xsl:param name="gmap"/>
 <xsl:sequence select="
if(empty($g))then $gmap else
let $xg:=if($gmap($gpos))then () else k2:g($g) return
k2:gmap(
 $gpos + 1
,$g/following-sibling::g[1]
,if(empty($xg[2]))then $gmap else
 map:merge(
  ($gmap
  ,for $x in subsequence($xg,2) return
   map:entry(1 + count($x/preceding-sibling::g),$gpos)
  )
 )
)
 "/>
</xsl:function>