1. public class Shuzu {
   
2.         public static void main(String[] args){
   
3.                 int[] arr = new int[]{2,2,2,4,5,7,98,4};        //旧数组；
   
4.                 int[] arr1 = new int[]{2,2,2,2,2,2,2};                                        //新数组；
   
5.                 boolean flag=true;int index=0;                        //初始化布尔值和角标值；
   
6.                 for(int i=0;i<arr.length;i++){                        //外圈：轮流取得旧数组的值；
   
7.                         for(int j=0;j<arr1.length;j++){                //内圈：比较外圈值在内圈是否存在；
   
8.                                 if(arr[i]==arr1[j]){
   
9.                                         //如果旧值等于新值，那么就让布尔为false，控制新数组装数打印。
   
10.                                         flag=false;
    
11.                                         }
    
12.                                 }
    
13.                         while(flag){                System.out.print(arr[i]);                                //新数组装数，仅当旧值不等新值时；
    
14.                                 arr1[index]=arr[i];       
    
15.                                 //if(index==8)
    
16.                                         //index=8;//装数
    
17.                                 //else index++;
    
18.                                 index++;
    
19.                                 }
    
20.                         }
    
21.                         for(int n=0;n<index;n++)                        //遍历，打印。
    
22.                                 System.out.print(arr1[n]+"  ");
    
23.         }       
    
24. }

复制代码

新书组装不重复的旧数组元素、、怎么搞，上面代码有什么问题？流程说下？灰常感谢.感谢你一辈子...

楼主想实现什么功能？出现什么问题说下

楼主是要实现什么功能都不明确

从代码看，第一个问题是boolean声明的位置错误，应当声明在第一个for循环也就是外层循环内
第二个问题是arr1[index]=arr,比如当循环到arr[3]=4时，会把arr1[0]赋值成4，也就是arr1[0]=4,当循环到arr[7]=4时，在内层循环中比较时，arr[7]=arr1[0],都等于4，所以flag被赋值成false
解决代码如下：

1. 
   
2. public static void main(String[] args)
   
3. {
   
4.         int[] arr = {2,2,2,4,5,7,98,4};                       //旧数组；
   
5.         int[] arr1 = {2,2,2,2,2,2,2};                         //新数组；
   
6.         int[] arr2 = new int[arr.length];                                          //新增数组
   
7.         int index=0;                                          //初始化布尔值和角标值；
   
8.         for(int i=0;i<arr.length;i++)                         //外圈：轮流取得旧数组的值；
   
9.         {
   
10.                     boolean flag=true;
    
11.                 for(int j=0;j<arr1.length;j++)                //内圈：比较外圈值在内圈是否存在；
    
12.                 {                                            
    
13.                         if(arr[i]==arr1[j])
    
14.                         {
    
15.                                 flag=false;
    
16.                                 break;
    
17.                         }
    
18.                 }
    
19.                 if(flag)
    
20.                 {               
    
21.                         System.out.print(arr[i]+" ");                 //新数组装数，仅当旧值不等新值时；
    
22.                     arr2[index]=arr[i];        
    
23.                     index++;
    
24.                 }
    
25.         }
    
26.         
    
27.         for(int n=0;n<index;n++)                               //遍历，打印。
    
28.                         System.out.print(arr2[n]+"  ");

复制代码

public class Shuzu
{
        public static void main(String[] args)
        {
                int[] arr = new int[]{2,98,4};//旧数组；
        int[] arr1 = new int[]{2,2}; //新数组；
        int[] arr2 = new int[arr1.length+arr.length];
        System.out.println(arr[1]);
        
        boolean flag = true;
        int index=0;                        //初始化布尔值和角标值；
        for(int i=0;i<arr.length;i++)
        {
               
                for(int j=0;j<arr1.length;j++)
                {               
                        //内圈：比较外圈值在内圈是否存在；
                if(arr[i]==arr1[j])
                        flag=false;//如果旧值等于新值，那么就让布尔为false，控制新数组装数打印。
                else
                        flag = true;
                //System.out.println(flag);
             }
                if(flag)
                {               
                        //System.out.println(arr[i]); //新数组装数，仅当旧值不等新值时；
                        arr2[index++]=arr[i];
                }
        }
        for(int j=0;j<arr1.length;j++)
            {
                System.out.println(index);
                arr2[index++]=arr1[j];
            }
        
        
        for(int n=0;n<index;n++)//遍历，打印。
                System.out.print(arr2[n]+"  ");
        }        
}

刚才的代码没修改好
public class Shuzu
{
        public static void main(String[] args)
        {
                int[] arr = new int[]{2,98,4};//旧数组；
        int[] arr1 = new int[]{2,2}; //新数组；
        int[] arr2 = new int[arr1.length+arr.length];
        
        boolean flag = true;
        int index=0;                        //初始化布尔值和角标值；
        for(int i=0;i<arr.length;i++)
        {
                for(int j=0;j<arr1.length;j++)
                {               
                        //内圈：比较外圈值在内圈是否存在；
                if(arr[i]==arr1[j])
                        flag=false;//如果旧值等于新值，那么就让布尔为false，控制新数组装数打印。
                else
                        flag = true;
             }
                if(flag)
                {               
                        //新数组装数，仅当旧值不等新值时；
                        arr2[index++]=arr[i];
                }
        }
        //把arr1的值放到arr2里面
        for(int j=0;j<arr1.length;j++)
            {
                arr2[index++]=arr1[j];
            }

        for(int n=0;n<index;n++)//遍历，打印。
                System.out.print(arr2[n]+"  ");
        }        
}
判断条件应该用if，还有数组长度是固定的，创建好了就不能修改了