Java中数组相关的一些题目

一、将一个给定的整型数组转置输出，

                例如： 源数组，1 2 3 4 5 6
                                     转置之后的数组，6 5 4 3 2 1

                      在看到这道题时，我首先想到的是，创建一个新数组，通过数组下标把一个数组倒着放到另一个数组中，即int[] arr={1,2,3,4,5,6} int[]  arr1 = new int[6] ,arr1[0]=arr[5]，代码如下：                      

 1 //错误示例
 2 public class daozhi_Arrary {
 3     public static void main(String[] args) {
 4         int[] arr = {1, 2, 3, 4, 5, 6};
 5         int[] arr1 = new int[6];
 6         for (int i = 5; i >= 0; i--) {
 7             for (int j = 0; j <= 5; j++) {
 8                 arr1[j] = arr[i];
 9             }
10         }
11         for (int i = 0; i<=5;i++){
12             System.out.println(arr1[i]);
13         }
14     }
15 }

　　　　　　写完我发现运行结果和想象中的不太一样，运行结果是：

                                           

                   然后我就在想，既然这样不行，我以前学过C中的数组倒置，即在原数组中进行数据操作，过程就是折中取半不遍历整个数组了遍历一半，那么就/2就可以 ，但是计算机数数的方法是从0开始的也就是说最后一个值里面是没有任何意义的 ，所以要在最后一个值那-1，且还要定义一个空的变量  因为要用到三步换值（变量） 不定义也可以。代码实现如下；

public class daozhi2_array {
    public static void main(String[] args) {
        int[] arr = new int[]{1,2,3,4,5,6};
        System.out.print("oldArry:");
        for(int i = 0;i < arr.length;i++){
            System.out.print(arr[i]+" ");
        }
        System.out.println();
        for(int i=0;i < arr.length / 2;i++){  //折中取半
            int temp = arr[i];
            arr[i] = arr[arr.length - 1 -i]; //将数组中后面的数往前面换，也就是，arr[0] = arr[5],arr[1] = arr [4], arr [2]=arr[3]，这样就完成数组的倒置，方法更简单
            arr[arr.length - 1 -i] = temp;
        }

        System.out.print("newArry:");
        for(int i = 0;i < arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }

运行结果：

         

然后我又在瞎想，能不能把这封装在一个方法中，使用的时候调用它，我又做了一边尝试，代码如下：

//代码优化过后

class DaoXv {
    public void daozhi( int arr[],int size){
        for(int i=0;i < arr.length / 2;i++){  //折中取半
            int temp = arr[i];
            arr[i] = arr[arr.length - 1 -i]; //将数组中后面的数往前面换，也就是，arr[0] = arr[5],arr[1] = arr [4], arr [2]=arr[3]，这样就完成数组的倒置，方法更简单
            arr[arr.length - 1 -i] = temp;
        }

        System.out.print("newArry:");
        for(int i = 0;i < arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }
}


public class daozhi2_array {
    public static void main(String[] args) {
        int[] arr = new int[]{1,2,3,4,5,6};
        System.out.print("oldArry:");
        for(int i = 0;i < arr.length;i++){
            System.out.print(arr[i]+" ");
        }
        System.out.println();
        DaoXv ax = new DaoXv();
        ax.daozhi(arr,6);
    }
}

 运行结果：

      

                   这样当我每次需要数组倒置的时候只需调用方法，即可，心里美滋滋。至此，数组的导致算是告一段落了。(弊端：只能操作int类型的数组)

 

二、现在有如下的一个数组：int[] oldArr = {1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5} ;要求将以上数组中值为0的项去掉，将不为0的值存入一个新的数组，生成的新数组为：int[] newArr = {1,3,4,5,6,6,5,4,7,6,7,5} ;

        我在想，是否能通过if()条件语句进行判断，通过if条件语句判断if(oldArr[i]==0)，就把他从数组中剔除出去，实现方法如下:

 1 public class deleat0_array {
 2     public static void main(String[] args) {
 3 
 4             int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5};
 5             int n=0; // 统计0的个数
 6             for(int i=0;i<oldArr.length;i++){
 7                 if(oldArr[i]==0){
 8                     n++;
 9                 }
10             }
11             int newArr[]=new int[oldArr.length-n]; // 定义新的数组 长度是 原来旧的数组的长度减去0的个数
12             int j=0; // 新数组的索引
13             for(int i=0;i<oldArr.length;i++){ // 遍历原来旧的数组
14                 if(oldArr[i]!=0){ // 假如不等于0
15                     newArr[j]=oldArr[i]; // 赋值给新的数组
16                     j++;
17                 }
18             }
19         System.out.println("oldArry length："+oldArr.length);
20         System.out.println("newArry length："+newArr.length);
21         System.out.print("oldArry：");
22         for(int k=0;k<oldArr.length;k++){
23             System.out.print(oldArr[k]+" ");
24         }
25         System.out.println();
26             System.out.print("newArry：");
27             for(int k=0;k<newArr.length;k++){
28                 System.out.print(newArr[k]+" ");
29             }
30 
31     }
32 }                 

  我又在想，是否也能封装在一个方法中，然后代码如下：

 1 class DeleatMethod{
 2     public void method(int oldArr[],int size){
 3         int n=0; // 统计0的个数
 4         for(int i=0;i<oldArr.length;i++){
 5             if(oldArr[i]==0){
 6                 n++;
 7             }
 8         }
 9         int newArr[]=new int[oldArr.length-n]; // 定义新的数组 长度是 原来旧的数组的长度减去0的个数
10         int j=0; // 新数组的索引
11         for(int i=0;i<oldArr.length;i++){ // 遍历原来旧的数组
12             if(oldArr[i]!=0){ // 假如不等于0
13                 newArr[j]=oldArr[i]; // 赋值给新的数组
14                 j++;
15             }
16         }
17         System.out.println("oldArry length："+oldArr.length);
18         System.out.println("newArry length："+newArr.length);
19         System.out.print("oldArry：");
20         for(int k=0;k<oldArr.length;k++){
21             System.out.print(oldArr[k]+" ");
22         }
23         System.out.println();
24         System.out.print("newArry：");
25         for(int k=0;k<newArr.length;k++){
26             System.out.print(newArr[k]+" ");
27         }
28 
29     }
30 }
31 
32 public class deleat0_array {
33     public static void main(String[] args) {
34 
35             int[] oldArr={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5};
36         DeleatMethod  dm= new DeleatMethod();
37         dm.method(oldArr,oldArr.length);
38     }
39 }

运行结果：

不出所料，能实现这种方法。

三、现在给出两个数组：

                              数组a："1,7,9,11,13,15,17,19"
                              数组b："2,4,6,8,10"
                              两个数组合并为数组c。

public class hebing {

        public static void main(String args[]) {
            int a[] = { 1,7,9,11,13,15,17,19};
            int b[] = { 2,4,6,8,10};
            int m=a.length+b.length;
            int[] c = new int[m];
            int num = 0;       //定义一个标识，让下一个数组赋值时可以知道上一个数组的长度，和从哪里开始赋值

            for (int i = 0; i < a.length; i++) {
                c[i] = a[i];
                num++;
            }
            for (int j = 0; j < b.length; j++) {
                c[num++] = b[j];
            }
            System.out.print("数组a:");
            for (int i = 0; i < a.length; i++){
                System.out.print(a[i]+"  ");
            }
            System.out.println();
            System.out.print("数组b:");
            for (int i = 0; i < b.length; i++){
                System.out.print(b[i]+"  ");
            }
            System.out.println();
            System.out.print("重组数组:");
            for (int i = 0; i < c.length; i++)
                System.out.print(c[i] + "  ");
        }


}

运行结果：

 

转载于:https://www.cnblogs.com/LOL-toulan/p/10754406.html