Java—数组常见的操作

最新推荐文章于 2022-07-28 00:29:08 发布

Coder米

最新推荐文章于 2022-07-28 00:29:08 发布

阅读量237

点赞数

分类专栏： Java基础

本文链接：https://blog.csdn.net/qq_41384351/article/details/84073436

版权

Java基础专栏收录该内容

12 篇文章 0 订阅

订阅专栏

一、如何搜索数组中的最小值和最大元素,并求出其下标。

（思路：将数组的第一个值设为最大和最小值，利用for循环，将数组中每个数与这个数相比较，如果比最小值小，则设为最小值，比最大值大，则设为最大值）

public class Maxmin {
    public static void maxmin(int[] array) {
        int max = array[0];
        int min = array[0];
        int maxN = 0;
        int minN = 0;
        for(int i = 0;i <array.length;i ++) {  //i
            if (array[i] > max) {          //比最大值大，则置为最大值
                max = array[i];
                maxN = i ;
            }
            if (array[i] < min) {    //比最小值小，则置为最小值
                min = array[i];
                minN = i;

            }
        }
        System.out.println("数组最大值为："+max+" "+"下标为："+maxN);
        System.out.println("数组最小值为："+min+" "+"下标为："+minN);
    }

    public static void main(String[] args) {
        int[] array = {9,1,6,2,3,12};
        maxmin(array);
    }
}

执行结果：
在这里插入图片描述

二、如何逆置数组

（不是把数组逆序输出，而是在当前的数组上逆置。）
（思路：数组的第一个数字和最后一个数组交换）

import java.util.Arrays;
public class Opposite {

    public static void oppo(int[] array) {
        int l = array.length; 
        System.out.print("数组的长度为"+l+" ");              //打印数组的长度
        for (int i = 0, j = l - 1; i < j; i++, j--) {         //i为数组0号下标，j为数组最后一个下标
            int tmp = array[i]; //把数组第一个值放入tmp
            array[i] = array[j]; //把数组最后一个值放到第一个值
            array[j] = tmp;   //把tmp的值放到最后一个值
        }
        System.out.println("逆置后的数组为" + Arrays.toString(array));
    }
    public static void main(String[] args) {
        int[] array = {1, 3, 4, 6, 2, 5};      
        System.out.println("原始数组为" + Arrays.toString(array));  //调用Arrays.toString方法输出数组
        oppo(array);
    }
}

执行结果：
在这里插入图片描述

三、如何合并两个数组

（思路：定义第三个数组，长度为前两个数组的长度和，依次把这两个数组放入第三个数组）

import java.util.Arrays;
public class TwoArraySum {

    public static int[] TwoarraySum(int[] array1, int[] array2) {

        int[] c = new int[array1.length + array2.length];  //定义第三个数组，长度为前两个数组的和
        int num = 0;                //定义一个计数器
        for (int i = 0; i < array1.length; i++) {        //先把第一个数组按序放入第三个数组
            c[i] = array1[i];
            num++;                         //计算放入数字的次数
        }
        for (int j = 0; j < array2.length; j++) {   //把第二个数组放进第三个数组，注意，此时从第num个下标开始存放
            c[num] = array2[j]; 
            num++;
        }
        return c;
    }
    public static void main(String[] args) {
        int[] a = {9, 1, 6, 2, 3, 12};
        int[] b = {78, 89, 99, 69};
        System.out.println("第一个数组为"+Arrays.toString(a));
        System.out.println("第二个数组为"+Arrays.toString(b));
        int[] c = TwoarraySum(a, b);
        System.out.println("合并后的数组为："+Arrays.toString(c));
    }
}

执行结果：
在这里插入图片描述

四、将斐波那契数列填充到数组中

import java.util.Arrays;
public class Fibonaci {

    public static void fun(int[] array) {
        array[0] = 1;
        array[1] = 1;
        for (int i = 2;i < array.length;i++) {    
            array[i] = array[i-1]+array[i-2];   //i从数组的第2个下标开始，值等于前两个下标所指值的和
        }
    }
    public static void main(String[] args) {
        int[] array = new int[20];     //定义一个长度为20的数组
        fun(array);
        System.out.println(Arrays.toString(array));
    }
}

执行结果:
在这里插入图片描述

五、删除数组中指定元素

（思路：找到要删除的元素下标n，从n+1个元素开始到最后一个元素依次向前平移一个位置）

public class DeleteArray {


   public static void delete(int[] array,int val) {
        int a;
        for (int item:array)  //for each输出数组的值
            System.out.printf("%4d",item);
        System.out.println();
       Scanner scanner = new Scanner(System.in);
       System.out.println("输入要删除的数：");
       String s = scanner.nextLine();
       int m = Integer.parseInt(s);
        int l = array.length;    //数组的长度
        for (a = 0; a < l; a++) {
            if (m == array[a])     //找到和输入的数相等的数组元素的下标
                break;
        }
            if (a == l) {  //输入的数等于数组的长度
            System.out.println("数组中没有这个数,请重新输入！");
            return;
        }
        int k;
        for (k = a + 1 ; k < l; k++)
            array[k - 1] = array[k];
        System.out.println("删除后的数组为：");
        for (k = 0; k < l - 1; k++)
            System.out.printf("%4d",array[k]);

    }

    public static void main(String[] args) {
        int[] arra = {11, 22, 33, 43, 45, 56, 67};
        System.out.println("原始数组为：");
        delete(arra,1);
    }
}

执行结果：
在这里插入图片描述

六、填充数组

用到Arrays的工具类，Arrays.fill填充：分为部分填充和全部填充

部分填充
Arrays.fill（数组名，起始数组下标，终止数组下标，填充的数字）
切记：部分填充的范围[起始下标，终止下标)，不包括终止下标的值
全部填充
Arrays.fill（数组名，填充的数字）

import java.util.Arrays;
public class FillArray {
    public static void main(String[] args) {    //填充数组Arrays.fill
        int[] array = {2, 4, 5, 6, 8, 7};
        System.out.println(Arrays.toString(array));
        Arrays.fill(array, 5);//调用Arrays.fill进行全部填充
        System.out.println("全部填充" + Arrays.toString(array));
        int[] array1 = {2, 4, 5, 6, 8, 7};
        System.out.println(Arrays.toString(array1));
        Arrays.fill(array1, 2, 4, 0);//调用Arrays.fill进行部分填充，将数组下标第[2,4）不包括4，两个数填充为0
        System.out.println("部分填充" + Arrays.toString(array1));
    }
}

执行结果：
在这里插入图片描述

七、交换两个数的值

(思路：定义第三个变量tmp，将第一个值放进tmp，把第二个值赋给第一个变量，再把tmp的值赋给第二个变量)
①

public class TestDemo2 {
    public static void swap(int[] array) {
        int tmp = array[0];
        array[0] = array[1];
        array[1] = tmp;
    }
    public static void main(String[] args) {
        int[] array = {10,20};
        System.out.println(array[0]);
        System.out.println(array[1]);
        swap(array);
        System.out.println(array[0]);
        System.out.println(array[1]);
    }

执行结果：
在这里插入图片描述
②

class MyData {
    int val;//实例变量
}

public class TestDemo1 {
    int data1 = 10;//实例变量
    public static void swap(MyData data1,MyData data2) {
        int tmp = data1.val;
        data1.val = data2.val;
        data2.val = tmp;
    }

    public static void main(String[] args) {
        MyData myData = new MyData();
        myData.val = 10;
        MyData myData2 = new MyData();
        myData2.val = 20;
        System.out.println(myData.val);//10
        System.out.println(myData2.val);//20
        System.out.println("================");
        swap(myData,myData2);
        System.out.println(myData.val);//20
        System.out.println(myData2.val);//10
    }
}

执行结果：
在这里插入图片描述

③反例：

public class TestDemo2 {
    public static void swap(int a,int b) {
        int tmp = a;
        a = b;
        b = tmp;
    }
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        swap(a,b);
        System.out.println(a);
        System.out.println(b);
    }

执行结果：
在这里插入图片描述
结果是a和b的值并没有交换
函数调用时，参数传递的方式主要有两种：

值传递（java使用）
引用传递
值传递是把变量的值、常数或常量传递给参数。
引用传递，是把变量的所在内存中的地址传递给参数，参数通过地址找到变量的值。很明显，引用传递不能把常数传递给参数。
值传递和引用传递还有一个很大的不同：对于像int这样的小类型变量来说，值传递没副作用，而引用传递有。也就是说，在函数调用的执行过程中，不能改变传递给参数的变量的值
在代码中的swap方法中，定义的a和b为形式参数，例如a的地址为100，b的地址为200，给a赋值10，b赋值20，因此10所指的地址就是100，20所指的地址就是200，在main方法中定义的a和b为实际参数，交换a和b值的时候，地址并没有交换，a依旧指向的是地址100，b依旧指向地址200。所以a和b的值交换后结果依旧是10和20。

八、数组当中，所有的数字，都出现了两次，但是只有一个数字出现了一次，求这个数字

（思路：让数组中的第一个值和0进行或运算，例如{1.3.2.1.2}：1|0 =1，1|3=3, 3|2=3, 3|1=3, 3|2=3,只有3出现了一次）

public class Practice {

    public static int  findnum (int[] array) {  
        int m = 0;
        for (int i = 0; i < array.length ; i++)
            m = array[i] ^ m;   //下标从0开始的值和0相与
        return m;
    }
    public static void main(String[] args) {
        int[] array = {1, 3, 2, 1, 2};
        int n = findnum(array);
        System.out.println(n);
    }

执行结果：
在这里插入图片描述

九、求数组当中重复的数字

（思路：异或）

    public static int samenum(int[] arr) { //求数组当中重复的数字
        int tmp = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if ((arr[i] ^ arr[j]) == 0) { //前一个值和后一个值异或，结果为0则返回前一个值
                    return arr[i];
                }
            }
        }
        return tmp;
    }

  public static void main(String[] args) {
        int[] array = {1,2,3,2,4};
        int n = samenum(array);
        System.out.println(n);
    }
}

执行结果：
在这里插入图片描述

十、将一个数组中的奇数放在偶数前面

public class Prac {

    public static void evenAfterOdd(int[] array) {
        if(array == null || array.length <= 1) {   //防御性检查
            return;
        }
        int i = 0;
        int j = array.length-1;
        while(i < j) {
            while(i < j && array[i] % 2 != 0) {//奇数的情况
                i++;
            }
            while(i < j && array[j] % 2 == 0) { //偶数情况
                j--;
            }
            if(i < j) {
                int tmp = array[i];
                array[i] = array[j];
                array[j] = tmp;
            }
        }
    }
    public static void main(String[] args) {
        int[] array = {9,4,5,8,3,1,6};
        System.out.println(Arrays.toString(array));
         evenAfterOdd(array);
        System.out.println(Arrays.toString(array));
    }
}

执行结果：
在这里插入图片描述

Coder米

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Java—数组常见的操作

一、如何搜索数组中的最小值和最大元素,并求出其下标。（思路：将数组的第一个值设为最大和最小值，利用for循环，将数组中每个数与这个数相比较，如果比最小值小，则设为最小值，比最大值大，则设为最大值）public class Maxmin { public static void maxmin(int[] array) { int max = array[0]; ...
复制链接

扫一扫