1. public static void main(String[] args)
   
2.         {
   
3.          //数组去重复
   
4.         int[] arr = new int[]{4,2,4,6,1,2,4,7,8};
   
5.         StringBuilder sb=new StringBuilder();
   
6.         sb.append("{");
   
7.                         for (int i = 0; i < arr.length; i++)
   
8.                         {
   
9.                                 if (!(sb.toString().contains(String.valueOf(arr[i]))))
   
10.                 sb.append(arr[i]+",");   
    
11.                         }
    
12.                         sb.replace(sb.length()-1, sb.length(), "}");
    
13.                         System.out.println(sb);
    
14.         }

复制代码

还有更简单的吗?

判断条件可以简化一下：
if (sb.indexOf(String.valueOf(arr[i])) == -1)

这代码通用性。。额。。这不是面向对象的代码。。

崔湖尧 发表于 2014-6-24 18:16
判断条件可以简化一下：
if (sb.indexOf(String.valueOf(arr)) == -1)

恩，你这个直接索引位置的方法也不错，比我要少一个单词{:2_32:}

Alan_Kwan 发表于 2014-6-24 18:46
这代码通用性。。额。。这不是面向对象的代码。。

面向对象的话，你觉得该怎么弄比较好

陈培果 发表于 2014-6-24 19:03
面向对象的话，你觉得该怎么弄比较好

面向对象的话，我的理解是：
1、逻辑与显示应该分开。
2、代码通用性要强，假如不是int类型的数组呢？考虑这个问题。。

不过可能是我想多了。。你标题写的是String，是我想太多了。。

Alan_Kwan 发表于 2014-6-24 19:06
面向对象的话，我的理解是：
1、逻辑与显示应该分开。
2、代码通用性要强，假如不是int类型的数组呢？考 ...

你说的是把那个抽成方法，用泛型来操作吗

:L既然都写到这个程度了，貌似可以封装起来：
public static  String  delDup （int[] arr）｛
StringBuilder sb=new StringBuilder();
        sb.append("{");
                        for (int i = 0; i < arr.length; i++)
                        {
                                if (!(sb.toString().contains(String.valueOf(arr[i]))))
                sb.append(arr[i]+",");   
                        }
                        sb.replace(sb.length()-1, sb.length(), "}");
return sb;
｝

基础的东西也要回忆一下

陈培果 发表于 2014-6-24 19:10
你说的是把那个抽成方法，用泛型来操作吗

1. import java.util.*;
   
2. 
   
3. class Test
   
4. {
   
5.    public static void main(String[] args)
   
6.     {
   
7.         // Integer[] arr = new Integer[]{4,2,4,6,1,2,4,7,8};
   
8.         Character [] arr = new Character[]{'a','b','c','a','d','c','e'};
   
9.         print(arr);
   
10.         print(originalRe(arr));
    
11.     }
    
12. 
    
13.     public static <T> Object [] originalRe(T [] arr)
    
14.     {
    
15.         ArrayList<T> alist = new ArrayList<T>();
    
16.         for(T t : arr)
    
17.         {
    
18.             if(!alist.contains(t))
    
19.                  alist.add(t);      
    
20.         }
    
21. 
    
22.         return alist.toArray();
    
23.     }
    
24. 
    
25.     public static <T> void print(T [] arr)
    
26.     {
    
27.         StringBuilder sb = new StringBuilder();
    
28.         sb.append("{");
    
29. 
    
30.         for(T a : arr)
    
31.         {
    
32.             sb.append(a+", ");
    
33.         }
    
34. 
    
35.         sb.replace(sb.length()-2, sb.length(), "}");
    
36.         System.out.println(sb.toString());
    
37.     }
    
38. }

复制代码

dispensable 发表于 2014-6-24 19:10
既然都写到这个程度了，貌似可以封装起来：
public static  String  delDup （int[] arr）｛
StringBuild ...

你的方法返回类型该是StringBuilder。封装起来的话，要做到通用性，再加上泛型和控制遍历。这样方法就强大了，那样做起来要麻烦一点。

crazystraw 发表于 2014-6-24 19:15
基础的东西也要回忆一下

我在复习，看到以前写的这个程序好长的，就优化了一下

Alan_Kwan 发表于 2014-6-24 19:17

恩恩，这样做通用性很好，不错不错{:2_31:}

来学习一下！

陈培果 发表于 2014-6-24 19:02
恩，你这个直接索引位置的方法也不错，比我要少一个单词

少一个单词，嗯
这一个单词包括了String对象的建立，内存分配，String的初使化，String的回收

崔湖尧 发表于 2014-6-24 21:23
少一个单词，嗯
这一个单词包括了String对象的建立，内存分配，String的初使化，String的回收 ...

哈哈，有道理，{:3_47:}

{:2_31:}{:2_31:}{:2_31:}{:2_31:}{:2_31:}{:2_31:}

看了颇有领悟,新手飘过~~

Alan_Kwan 发表于 2014-6-24 19:17

利用list还是比较方便的

这算不上优化