栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Java----数组?初识数组~练习数组~

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Java----数组?初识数组~练习数组~

数组
  • 什么是数组
  • 创建数组
  • 数组的使用
    • 获取长度
    • 访问元素
    • 遍历数组
  • 数组作为方法的参数
  • 数组作为方法的返回值
  • 数组练习
    • 数组转字符串
    • 数组拷贝
    • 找数组中的最大元素
    • 求数组中元素的平均值
    • 查找数组中指定元素
      • 顺序查找
      • 二分查找
    • 检查数组有序性
    • 冒泡排序
    • 数组逆序
    • 数组数字排序
  • 二维数组

什么是数组

让我们“批量”创建相同类型的变量

创建数组

数据类型 [ ] 数组名称=new 数据类型 [ ] {初始化数据};//动态初始化
例:int [ ] arr=new int [ ] {1,2,3,4};
数据类型 [ ] 数组名称= {初始化数据};//静态初始化
例:int [ ] arr= {1,2,3,4};

数组的使用 获取长度

数组名.length

public class test {
    public static void main(String[] args) {
        int [] arr={1,2,3};
        System.out.println("len="+arr.length);
    }

}

访问元素

使用[ ]访问元素以及更改元素,下标从0开始,范围为[0~length-1],防止越界

public class test {
    public static void main(String[] args) {
        int [] arr={1,2,3};
        System.out.println("len="+arr.length);
        System.out.println("arr[0]="+arr[0]);
        System.out.println("arr[1]="+arr[1]);
        System.out.println("arr[2]="+arr[2]);
        arr [1]=298;//修改下标为1的元素
        System.out.println("修改后arr[1]="+arr[1]);
    }

}

System.out.println("arr[4]="+arr[4]);

数组越界异常:

遍历数组

1、循环遍历

public class test {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        for (int i = 0; i < arr.length; i++) {
            System.out.println("arr" +"["+ i+"]" + "=" + arr[i]);

        }
    }

}


2、使用for-each遍历

public class test {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        for (int x:arr) {
            System.out.println("arr" +"["+ x+"]" + "=" + x);

        }
    }

}

数组作为方法的参数

数组名是“引用”,数组传参,是按照引用传参,相当于传的是一个地址。

public class test {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        System.out.println("arr[0]="+arr[0]);
        fun(arr);
        System.out.println("arr[0]="+arr[0]);

        }
        public static void fun(int [] arr){
        arr [0]=100;
        }
    }


传地址过去形参的改变影响实参的改变
传值形参改变就不会影响实参

public class test {
    public static void main(String[] args) {
        int a=1;
        System.out.println("a="+a);
        fun(a);
        System.out.println("a="+a);

        }
        public static void fun(int a){
        a=100;
        }
    }

数组作为方法的返回值

将数组的元素翻倍

public class test {
    public static void main(String[] args) {
        int [] arr={1,2,3,4,5};
        transArray(arr);
        printArray(arr);

    }
    public static void printArray(int [] arr){
        for(int x:arr){
            System.out.print(x+" ");
        }

    }
    public static void transArray(int [] arr){
        for(int i=0;i
            arr [i]=arr[i]*2;
        }

    }
}


但是这种方法直接改变了数组之前的值
要是不想改变原来的值,就得返回一个新的数组

public class test {
    public static void main(String[] args) {
        int [] arr={1,2,3,4,5};
        int [] newarr=transArray(arr);
        printArray(arr);
        System.out.println();
        printArray(newarr);

    }
    public static void printArray(int [] arr){
        for(int x:arr){
            System.out.print(x+" ");
        }

    }
    public static int [] transArray(int [] arr){
        int [] ret=new int [arr.length];
        for(int i=0;i
            ret [i]=arr[i]*2;
        }
        return ret;
    }

}

数组练习 数组转字符串

1、利用字符串拼接完成

public class test {
    public static void main(String[] args) {
        int [] arr ={1,2,3,4,5,6};
        System.out.println(toString(arr));
    }
    public static String toString(int [] arr){
        String ret ="[";
        for(int i=0;i
            ret+=arr[i];
            if(i
                ret+=",";
            }
        }
        ret+="]";
        return ret;
    }


2、利用java.util.Arrays这个包提供的toString方法直接转换

import java.util.Arrays;

public class test {
    public static void main(String[] args) {
        int [] arr={1,2,3,4,5,6};
        String newArr= Arrays.toString(arr);
        System.out.println(newArr);
    }
}

数组拷贝

1、创建一个新的数组直接一一拷贝

public class test {
    public static void main(String[] args) {
        int [] arr={1,2,3,4,5,6};
        int [] newArr=copy(arr);
       for(int x:newArr){
           System.out.print(x+" ");
       }
    }
    public static int [] copy(int [] arr){
        int [] ret=new int [arr.length];
        for(int i=0;i
            ret [i]=arr[i];
        }
        return ret;
    }
}


2、利用java.util.Arrays提供的数组拷贝方法

import java.util.Arrays;

public class test {
    public static void main(String[] args) {
        int [] arr ={1,2,3,4,5,6};
        int [] newArr=Arrays.copyOf(arr,arr.length);//深拷贝
        System.out.println("newArr:"+Arrays.toString(newArr));
        arr[0]=10;
        System.out.println("arr:"+Arrays.toString(arr));//原来数组的改变不影响拷贝后的数组
        System.out.println("newArr:"+Arrays.toString(newArr));
        int [] newArr1=Arrays.copyOfRange(arr,2,5);//范围拷贝:[2~5)
        System.out.println("newArr1:"+Arrays.toString(newArr1));


    }
}

找数组中的最大元素
public class test {
    public static void main(String[] args) {
        int [] arr={11,2,34,56,34,56,78,92,1};
        System.out.println(Max(arr));
    }
    public static int Max(int [] arr){
        int max=0;
        for(int i=0;i
            if(arr[i]>max){
                max=arr[i];
            }
        }
        return max;
    }
}

求数组中元素的平均值

由于结果可能位小数,所以这里用double类型表示

public class test {
    public static void main(String[] args) {
        int [] arr ={1,23,45,4,6,77,9};
        System.out.println(Avg(arr));
    }
    public static double Avg(int [] arr){
        int sum=0;
        for(int x:arr){
             sum+=x;
        }
        return (double) sum/(double) arr.length;
    }
}

查找数组中指定元素 顺序查找
public class test {
    public static void main(String[] args) {
        int [] arr ={1,23,45,89,67,90,78,};
        System.out.println(Find(arr,89));
    }
    public static int Find(int [] arr,int tofind){
        for(int i=0;i
            if(arr[i]==tofind){
                System.out.print("找到了,下标为:");
                return i;
            }
        }
        return -1;//找不到返回-1
    }
}

二分查找

针对有序数组,二分查找效率更高

public class test {
    public static void main(String[] args) {
        int [] arr ={1,2,3,4,5,6,7,8,9,10};
        System.out.println(binarysearch(arr,6));
    }
    public static int binarysearch(int [] arr,int n){
        int left=0;
        int right=arr.length-1;
        while(left<=right){
            int mid=(left+right)/2;

            if(arr[mid]
               left=mid+1;
           }else if(arr [mid]>n){
               right=mid-1;
           }else {
               System.out.println("找到了,下标为:");
               return mid;
           }
        }
        System.out.println("没找到");
        return -1;
    }
}


元素个数越多,效率就越高

public class test {
    static int count=0;
    static int count1=0;
    public static void main(String[] args) {
        int [] arr=createBigArray();
        int ret =binarySearch(arr,9999);
        int ret1=Find(arr,9999);
        System.out.println("ret="+ret+" count="+count);
        System.out.println("ret1="+ret1+" count1="+count1);

    }
    public static int [] createBigArray(){
        int [] arr=new int [10000];
        for(int i=0;i<10000;i++){
            arr[i]=i;
        }
        return arr;
    }
    public static int binarySearch(int [] arr,int n){
        int left=0;
        int right =arr.length-1;
        while(left<=right){
            count++;
            int mid=(left+right)/2;
            if(arr[mid]>n){
                right=mid-1;
            }else if(arr[mid]
                left=mid+1;
            }else{
                return arr[mid];
            }
        }
        return -1;
    }
    public static int Find (int []arr,int tofind){
        for(int i=0;i
            count1++;
            if(arr[i]==tofind){
                return arr[i];
            }
        }
        return -1;
    }
}

数据多的时候,二分查找次数明显比顺序查找次数少了很多

检查数组有序性

给定一个数组,检查这个数组是否为升序或降序,仅需要判断后一个元素是否大于或者小于前一个即可(若有重复元素,加上=的条件)

public class test {
    public static void main(String[] args) {
        int [] arr={1,2,3,6,7,8,9};
        System.out.println(isAsc(arr));
    }
    public static boolean isAsc(int [] arr){
        for(int i=0;i
            if(arr[i]>arr[i+1]){
                return false;
            }
        }
        return true;
    }
}

冒泡排序

给定一个数组,让数组升序排列,每次找到当前待排序区间的最小或者最大的元素,放到数组最前面或者最后面,降序同理。

import java.util.Arrays;

public class test {
    public static void main(String[] args) {
        int [] arr ={2,1,3,4,7,9,6,8,5};
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void bubbleSort(int [] arr){
        for(int i=0;i
            for(int j=0;j
                if(arr[j]>arr[j+1]){
                    int tmp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=tmp;
                }
            }
        }
    }
}


在Java中提供了一个更高效的排序方法

import java.util.Arrays;

public class test {
    public static void main(String[] args) {
        int []arr={2,3,1,5,7,4,9,8,6};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

数组逆序
import java.util.Arrays;

public class test {
    public static void main(String[] args) {
        int []arr={1,2,3,4};
        reverse(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void reverse(int []arr){
        int left =0;
        int right=arr.length-1;
        while(left
            int tmp=arr[left];
            arr[left]=arr[right];
            arr[right]=tmp;
            left++;
            right--;
        }
    }
}

数组数字排序

将一个数组的偶数部分放在前面,奇数部分放在后面

public class Test {
    public static int[] Swap(int[] arr){
        int left=0;
        int right=arr.length -1;
        while(left
            if(arr[left]%2==0) {
                left++;
            }
                if(arr[right]%2!=0){
                    right--;
                }
            int tmp=arr[left];
            arr[left]=arr[right];
            arr[right]=tmp;
            left++;
            right--;
        }
        return arr;
    }

public static void main(String[]args){
    int []array={1,2,3,4,5,6};
    String ret= Arrays.toString(array);
    System.out.println(ret);
    System.out.println("===================");
    String ret1=Arrays.toString(Swap(array));
    System.out.println(ret1);
    }
}

二维数组

二维数组本质上也是一维数组,只不过里面的每个元素又是一个一维数组
初始化方式:
1、数据类型[][]数组名={{数据},{数据}……};
int [] []arr={{1,2,3},{4,5,6}};
2、数据类型 [ ] [ ] 数组名=new 数据类型[ 行数] [列数 ] ;
int [] [] arr=new int [2][3];
3、数据类型 [ ] [ ] 数组名=new 数据类型[ ] [] {{数据},{数据}……};
int [] [] arr=new int [][]{{1,2,3},{4,5,6}};

public class test {
    public static void main(String[] args) {
        int [] []arr={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
        for(int row =0;row//arr.length 为二维数组的行数
            for(int col=0;col
                System.out.printf("%dt",arr[row][col]);
            }
            System.out.println(" ");
        }
    }

}

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/937145.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号