1. package com.itheima;
   
2. /**
   
3. * 第八题：数组去重复，例如: 原始数组是{4,2,4,6,1,2,4,7,8}，
   
4. * 得到结果{4,2,6,1,7,8}
   
5. *
   
6. * 思路：    1，先用循环把数组遍历。
   
7. *       2，把重复的数组过滤掉。
   
8. *       3，具体的方法是重新定义一个数组，把重复的通过continue略过，不重复的放入新数组。
   
9. */
   
10. public class Test8
    
11. {
    
12.         public static void main(String[] args)
    
13.         {
    
14.                 int[] nums={4,2,4,6,1,2,4,7,8};
    
15.                 int[] newArr = new int[9];
    
16.                 int x=0;
    
17.                 for(int i=0;i<nums.length;i++)
    
18.                 {
    
19.                         for(int j=1;j<nums.length;j++)
    
20.                                 if(nums[i]==nums[j])
    
21.                                         continue;
    
22.                                 else
    
23.                              {
    
24.                                         newArr[x]=nums[i];
    
25.                                  x++;
    
26.                              }
    
27.                
    
28.         }
    
29.                 printArr(newArr);       
    
30. }
    
31. public static void printArr(int[] arr)
    
32. {
    
33.         System.out.print("{");
    
34.         for(int i=0;i<arr.length;i++)
    
35.         {
    
36.                 if(i!=arr.length-1)
    
37.                         System.out.print(arr[i]+",");
    
38.                 else
    
39.                         System.out.print(arr[i]+"}");
    
40.         }
    
41. }
    
42. }

复制代码

1. int[] nums={4,2,4,6,1,2,4,7,8};
   
2.                 int[] newArr = new int[9];
   
3.                 int x=0;
   
4.                   for(int i=0;i<nums.length;i++)
   
5.                 {
   
6.                          //给新数组赋值，右边可以变，但是如果发现右边是唯一值，就跳到下一个元素
   
7.                         newArr[x]=nums[i];
   
8.                         //唯一值判定判定标记
   
9.                         boolean flag=false;
   
10.                     for(int j=i+1;j<nums.length-i;j++)
    
11.                     {
    
12.                             //循环从本元素的下一个元素开始，一直到数组末尾哈 假如从外循是0,内循是1，判断8次
    
13.                             //发现有相同，就判读不唯一
    
14.                         if(nums[j]==nums[i])
    
15.                                 flag=true;
    
16.                     }
    
17.                     //如果判定唯一，新数组跳下一个赋值
    
18.                     if(!flag)
    
19.                             x++;
    
20.                
    
21.                 }

复制代码

楼主你看看这个算法可以不，在你那个算法上改进的

请问是基础测试题吗？
        public static void main(String[] args) {
                String str = "abc";
                List<String> strAss = new ArrayList<String>();
                for (int i = 0; i < str.length(); i++) {
                        for (int j = i + 1; j <= str.length(); j++) {
                                String sub = str.substring(i, j);
                                int r = 0;
                                while (r++ < sub.length()) {
                                        strAss.add(sub);
                                        sub = sub.substring(1) + sub.substring(0, 1);
                                }
                        }
                }
                for (String a : strAss) {
                        System.out.println(a);
                }
        }
}

1. public class Test
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 int[] nums={4,2,4,6,1,2,4,7,8};
   
6.                 List<Integer> newList = new ArrayList();
   
7.               
   
8.                 for(int i=0;i<nums.length;i++)
   
9.                 {
   
10.                         if(!newList.contains(nums[i])){
    
11.                                 newList.add(i);
    
12.                         }
    
13.                         
    
14.                 }
    
15.                 System.out.println(newList);
    
16. }

复制代码

你的思路需要稍微调整下，非重复数据不要放在数组里，而是集合。若放数组里你要遍历2次，一次要判断是否重复，一次需要判断放入新数组的下标位置。见我回复的代码。

你的外层循环的i>=1的时候内层循环的j就有j==i了，就等于是第一个后的都跳过了

1. /**
   
2. * 第八题：数组去重复，例如: 原始数组是{4,2,4,6,1,2,4,7,8}， 得到结果{4,2,6,1,7,8}
   
3. *
   
4. * 思路： 1，先用循环把数组遍历。 2,判断新数组是否存在该值。
   
5. * 3，存在结束内循环判断下一个，不存在则加入新数组
   
6. *
   
7. */
   
8. public class Test8 {
   
9.         public static void main(String[] args) {
   
10.                 int[] nums = { 4, 2, 4, 6, 1, 2, 4, 7, 8 };
    
11.                 int[] newArr = new int[9];
    
12. 
    
13.                 int flag = 0;//判断新数组是否存在相同的值
    
14.                 int pos = 0;//记录新数组实际值得个数
    
15.                 for (int i = 0; i < nums.length; i++) {
    
16.                         for (int j = 0; j < newArr.length; j++) {// 判断nums[i]是否已在newArr中
    
17.                                 if (nums[i] == newArr[j]) {
    
18.                                         flag = 1;
    
19.                                         break;
    
20.                                 }
    
21.                         }
    
22.                         if (flag == 1) {
    
23.                                 flag = 0;
    
24.                         } else {
    
25.                                 newArr[pos] = nums[i];
    
26.                                 pos++;
    
27.                         }
    
28.                 }
    
29.                 System.out.print("[");
    
30.                 for (int i = 0; i < pos; i++) {
    
31.                         System.out.print(newArr[i] + ",");
    
32.                 }
    
33.                 System.out.println("]");
    
34. 
    
35.         }
    
36. }

复制代码

楼主搞混了continue和break，break是结束当前循环，continue是当前循环直接进入下一次，

yuanlingqi 发表于 2014-11-8 14:40

这个算法简洁清晰，不过有个问题，newList.add(i);添加的是数组脚标号，应该是newList.add(nums);然后导个包import java.util.*;再在末尾加个}，就OK了

陈召 发表于 2014-11-8 13:33
请问是基础测试题吗？
        public static void main(String[] args) {
                String str = "abc";

是基础测试题，我已经提交了，但是代码不能输出结果，郁闷得很，就拿来问了

方法很多，楼主将你自己的程序的外层循环加个标签试试，continue直接跳到外层循环

int[] arr={4,2,4,6,1,2,4,7,8};//定义原始数组
                int sum=0;//用来计算修改了几次原数组
                         for(int x=0;x<arr.length-1;x++){
                                for(int y=x+1;y<arr.length;y++){
                                                        if(arr[x]==arr[y]){//如果数字相同
                                                                arr[x]=-1;//将数字改为-1
                                                                sum++;//每次更改加一次
                                                        }
                                                        else{//如果不同进行下次内循环
                                                                continue;
                                                                }
                                                        }
                                }
                        System.out.println("修改后的原数组");
                        for(int x=0;x<arr.length;x++){
                                        System.out.println(arr[x]);
                        }
                        //定义一个新的数组大小为原数组减去更改的次数
                        int[] newarr=new int[arr.length-sum];
                        int i=0;
                        for(int x=0;x<arr.length;x++){
                                        if(arr[x]!=-1){
                                                        newarr[i]=arr[x];
                                                        i++;
                                        }
                        }
                        System.out.println("修改后的新数组");
                                for(int x=0;x<newarr.length;x++){
                                System.out.println(newarr[x]);
                                }
不用集合，楼主看看这个办法可以吗？

第一次拿4跟集合中的每一个数比较，发现2！=4，把第一个2加入数组中，可是，后面还有一个2，又加入一次，所以，程序并没有去重

for(int j=1;j<nums.length;j++)

                          if(nums[i]==nums[j])
楼主不应该拿有重复数据的每一个元素跟自己数组的数比较，应该遍历nums数组的数组，跟newArr数组里的数据比，当然刚开始newArr里面的初始值都是0。二楼写的还行，这个题可以用集合，也可以用数组，多看看，在纸上画画，就知道自己哪里错了

楼主你的continue只能跳出内部循环让其从头执行，而这样的话外部循环每循环一次就会有几个元素添加到新数组，新数组里只能有九个元素，角标肯定会越界的。

楼主，既然是Java，你用集合会更好一些

1. for(int i=0;i<nums.lenth;i++){
   
2.   for(int j=0,x=0;j<x;j++){
   
3.       if(num[i]==newArr[j])
   
4.              break;
   
5.        }
   
6.       if(j==x)
   
7.          newArr[x++]=num[i];
   
8. }
   
9.          
   
10.          
    

复制代码

王会涛 发表于 2014-11-9 14:53
for(int j=1;j

谢谢意见

遍历一边得到除去重复的元素个数是多少 ，再new出一个新的数组，长度是去重复元素的，你这样得到的结果似乎最后几个没去除的角标位的元素是0啊

下面是按你的思路做的，但不应该用continue进行下次循环，而应该用break跳出本次for循环，进行nums数组中下一元素的判断。
package com.itheima;

public class Test8
{
        public static void main(String[] args)
        {
                int[] nums={4,2,4,6,1,2,4,7,8};
                int[] newArr = new int[9];
                int x=0;
                newArr[0]=nums[0]; //先把第一个元素赋给新数组
                for(int i=1;i<nums.length;i++) //从第二个元素开始遍历nums数组
                {
                        for(int j=0;j<newArr.length;j++) //从第一个元素遍历新数组
                                if(nums[i]==newArr[j]) //比较nums数组的元素是否和新数组当前元素相同，相同就退出本循环，进行nums数组的下一个数据判断
                                        break;
                              if(j==x) //遍历完新数组，没有相同的而且是最后一个，就赋新值。
                             {
                                        newArr[x]=nums[i];
                                 x++;
                             }
               
             }
                printArr(newArr);        
}
public static void printArr(int[] arr)
{
        System.out.print("{");
        for(int i=0;i<arr.length;i++)
        {
                if(i!=arr.length-1)
                        System.out.print(arr[i]+",");
                else
                        System.out.print(arr[i]+"}");
        }
}
}

zzg8888 发表于 2014-11-9 10:30
方法很多，楼主将你自己的程序的外层循环加个标签试试，continue直接跳到外层循环 ...

对，我几天也做了类似的题，是随机生成0~9八个不同的数，然后查找缺少那两个 。后面的查找缺少跟lu的思维很像，但有输入，但结果不对，后来在外层的for循环加了标记。判断一样之后直用continue直接跳出外循环的当前循环，进行下一次循环。