List<string> str = new List<string> { "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11","12","13" };

string[] temp = {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10"};

想实现 temp 最后的结果是 {"11","12","13" } 即：排除相同元素后，剩下的

该如何写代码呢？

for + if 就Ok了

最后再加上remove 相同的数值

哥们儿在上班时间偷做的，没上机验证过啊，不知道能不能通过；

1. //
   
2. import java.util.*;
   
3. 
   
4. class StringList
   
5. {
   
6.         List<string> list = new List<string> { "1", "2", "3", "4", "5", "6", "7", "8", "9",
   
7. 
   
8. "10", "11","12","13" };
   
9. 
   
10.         String[] arr = {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10"};
    
11. 
    
12.         String[] finalArr = null;        //存放剔除相同元素后的数组；
    
13. 
    
14.         public void convert()               
    
15.         {
    
16.                 List<String> asList = arr.asList();    //将arr数组转换为集合；
    
17.                 //用列表迭代器迭代出list集合中的每一个元素，如果在asList集合中有相同元素，则移
    
18. 
    
19. 除该元素，如果没有将该元素添加进asList集合中；
    
20.                 for(ListIterator<String> li = list.listIterator(); li.hasNext();)
    
21.                 {
    
22.                         String temp = li.next();
    
23.                         if(asList.contains(temp))
    
24.                         {
    
25.                                 asList.remove(temp);
    
26.                         }
    
27.                         else   asList.add(temp);   
    
28.                 }
    
29.                 //将转换后的asList集合转换为数组
    
30.                 finalArr = asList.toArray(new String[asList.size()]);
    
31.         }
    
32. 
    
33.         public static void sop()        //打印最终修改过的数组；
    
34.         {
    
35.                 for(int i =0; i <= finalArr.length; i++)
    
36.                 {
    
37.                         System.out.println(finalArr[i]);
    
38.                 }
    
39.         }
    
40. }
    
41. 
    
42. public class MainAction
    
43. {
    
44.         public static void main(String [] args)
    
45.         {
    
46.                 StringList sl = new StringList();
    
47.                 sl.convert();    //调用convert方法对数组进行处理；
    
48.                 sl.sop();        //对最终修改过的数组打印输出；
    
49.         }
    
50. }

复制代码

1. static void Main(string[] args)
   
2.         {
   
3.             
   
4.             List<string> str = new List<string> { "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11","12","13" };
   
5.            
   
6.             string[] temp = {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10"};
   
7.            
   
8.            
   
9.             //想实现 temp 最后的结果是 {"11","12","13" } 即：排除相同元素后，剩下的
   
10. 
    
11.             for (int i = 0; i < str.Count;i++ )
    
12.             {
    
13.                 for (int j = 0; j < temp.Length; j++)
    
14.                 {
    
15.                     if (str[i] == temp[j])
    
16.                     {
    
17.                         str.Remove(str[i]);
    
18. 
    
19.                     }
    
20. 
    
21.                 }
    
22. 
    
23.             }
    
24. 
    
25.             foreach (var item in str)
    
26.             {
    
27.                 Console.WriteLine("去掉相同的后，结果"+item);
    
28.             }
    
29.             Console.ReadKey();
    
30.         }

复制代码

我写的这个不知道符不符合要求

方法: 循环temp,str Contains 和 Remove即可
完整代码如下:

1. using System;
   
2. using System.Collections.Generic;
   
3. 
   
4. namespace test11
   
5. {
   
6. internal class Program
   
7. {
   
8. /*List<string> str = new List<string> { "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11","12","13" };
   
9. string[] temp = {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10"};
   
10. 想实现 temp 最后的结果是 {"11","12","13" } 即：排除相同元素后，剩下的
    
11. */
    
12. private static void Main(string[] args)
    
13. {
    
14. var str = new List<string> { "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13" };
    
15. string[] temp = { "1", "2", "3", "4", "5", "6", "7", "8", "9", "10" };
    
16. PrintLst(str);
    
17. foreach (var t in temp)
    
18. {
    
19. if (str.Contains(t))
    
20. {
    
21. str.Remove(t);
    
22. }
    
23. }
    
24. PrintLst(str);
    
25. Console.ReadKey();
    
26. }
    
27. /// <summary>
    
28. /// List打印
    
29. /// </summary>
    
30. /// <param name="lst">需处理List</param>
    
31. public static void PrintLst(List<string> lst)
    
32. {
    
33. Console.Write("[ ");
    
34. for (var x = 0; x < lst.Count; x++)
    
35. {
    
36. //如果不是最后一个元素则加','否则加']'
    
37. if (x != lst.Count - 1)
    
38. {
    
39. Console.Write(lst[x] + ", ");
    
40. }
    
41. else
    
42. {
    
43. Console.WriteLine(lst[x] + " ]");
    
44. }
    
45. }
    
46. }
    
47. }
    
48. }

复制代码

来个超级简单的

1.             foreach (string s in temp)
   
2.             {
   
3.                 str.Remove(s);
   
4.             }
   
5.             foreach (string s in str)
   
6.             {
   
7.                 Console.Write(s + "\t");
   
8.             }

复制代码

1. List<string> str = new List<string> { "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13" };
   
2.             string[] temp = { "1", "2", "3", "4", "5", "6", "7", "8", "9", "10" };
   
3.             int j = 0;
   
4. 
   
5.             while(true) {               
   
6.                 while(j < temp.Length) {
   
7.                     //每次把str的第一个与temp中的元素进行比较，如相等就移除str的元素
   
8.                     if(str[0] == temp[j]) {
   
9.                         str.Remove(str[0]); //移除（每次移除一个元素，后面的元素就向前移动一个位置）
   
10.                         j++;    //自加1
    
11.                         break;  //跳出内层循环
    
12.                         //（与str的第一个相等，因此没必要再去把temp的元素与第一个进行比较）
    
13.                     }
    
14.                 }
    
15.                 //判断temp数组是否遍历完毕
    
16.                 if(j >= temp.Length) {
    
17.                     break;  //跳出外层循环
    
18.                 }
    
19.             }

复制代码

此代码要比“转达小朋友”好，他那个做了很多没必要的比较。而我这个改用while循环更简洁。如有不妥之处欢迎指正。

不过，题目有点局限性：如果temp中有与str不同的元素，这种方法不适合。

效果图：

黄文超 发表于 2013-6-24 20:22
来个超级简单的

这个确实漂亮！