java数组包含某个元素有多少个 java数组在哪个包

转载

mob6454cc65e0f6 2024-06-02 20:26:59

文章标签 java数组包含某个元素有多少个数组 System i++ 文章分类 Java 后端开发

深入了解Java中的数组

一、数组的概述

1.数组(Array)
2.常见概念
3.数组的分类

二、数组的使用

1.声明方式
2.初始化

（1）一维数组

动态初始化：
静态初始化：

（2）二维数组

动态初始化：
静态初始化：

3.使用

（1）一维数组的使用
（2）二维数组的使用

三、数组涉及到的常见算法

1. 数组元素的赋值(杨辉三角)
2. 求数值型数组中元素的最大值、最小值、平均数、总和等
3. 数组的复制、反转、查找(线性查找、二分法查找

四、Arrays工具类的使用
五、数组使用中的常见异常

一、数组的概述

1.数组(Array)

是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。

2.常见概念

数组名
下标(或索引)：可以直接通过下标(或索引)的方式调用指定位置的元素，速度很快
元素
数组的长度（长度一旦确定，就不能修改）

3.数组的分类

按照维度：一维数组、二维数组、三维数组
按照元素的数据类型分：基本数据类型元素的数组、引用数据类型元素的数组(即对象数组)

二、数组的使用

1.声明方式

int  brrr[] 或int[]  brrr
 int arr[][]或int[][] arr
 例如：
 int a[];
 int[] a1;
 double b[];
 String[] c;//引用类型变量数组

注意：
Java语言中声明数组时不能指定其长度(数组中元素的数)，例如：inta[5]; //非法

2.初始化

（1）一维数组

动态初始化：

数组声明且为数组元素分配空间与赋值的操作分开进行

int[] arr= new int[3];
arr[0] = 3;
arr[1] = 9;
arr[2] = 8;

String names[];
names = new String[3];
names[0] = “钱学森”;
names[1] = “邓稼先”;
names[2] = “袁隆平”;

静态初始化：

在定义数组的同时就为数组元素分配空间并赋值

int arr[] = new int[]{ 3, 9, 8};
或
int[] arr = {3,9,8};

String names[] = {“李四光”,“茅以升”,“华罗庚”};

（2）二维数组

动态初始化：

格式一

int[][] arr= new int[3][2];
定义了名称为arr的二维数组二维数组中有3个一维数组
每一个一维数组中有2个元素
一维数组的名称分别为arr[0], arr[1], arr[2]
给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78

格式二

int[][] arr= new int[3][];
二维数组中有3个一维数组。
每个一维数组都是默认初始化值null (注意：区别于格式1）
可以对这个三个一维数组分别进行初始化
arr[0] = new int[3];    arr[1] = new int[1];   arr[2] = new int[2];
注：int[][]arr= new int[][3];  //非法

静态初始化：

int[][] arr= new int[][]{{3,8,2},{2,7},{9,0,1,6}};
定义一个名称为arr的二维数组，二维数组中有三个一维数组
每一个一维数组中具体元素也都已初始化
第一个一维数组arr[0] = {3,8,2};
第二个一维数组arr[1] = {2,7};
第三个一维数组arr[2] = {9,0,1,6};
第三个一维数组的长度表示方式：arr[2].length

3.使用

（1）一维数组的使用

冒泡排序

public class Dat_7_1 {
   public static void Bubble(){
       int[] arr=new int[]{43,32,76,-98,0,64,33,-21,32,99};
       //遍历
       for(int i=0;i<arr.length;i++){
           System.out.print(arr[i]+"\t");
       }
       System.out.println("冒泡排序结果为：");
       //冒泡排序
       for(int i=0;i<arr.length-1;i++){
           for(int j=0;j<arr.length-1-i;j++){
               if(arr[j]>arr[j+1]){
                   int tmp=arr[j];
                   arr[j]=arr[j+1];
                   arr[j+1]=tmp;
               }
           }
       }
       //遍历
       for(int i=0;i<arr.length;i++){
           System.out.print(arr[i]+"\t");
       }
   }
   public static void main(String[] args) {
       Bubble();
   }
}

运行结果：

43	32	76	-98	0	64	33	-21	32	99	冒泡排序结果为：
-98	-21	0	32	32	33	43	64	76	99	
Process finished with exit code 0

（2）二维数组的使用

二维数组中数字的总和

public static void Sum(){
       int num=0;
       int[][] brr=new int[][]{{1,2,3},{7,8,9},{4,5,6}};
       for(int i=0;i<brr.length;i++){
           for(int j=0;j<brr[i].length;j++){
               num +=brr[i][j];
               System.out.print(brr[i][j]+"\t");
           }
           System.out.println();
       }
       System.out.println("总和为："+num);
   }

运行结果：

三、数组涉及到的常见算法

1. 数组元素的赋值(杨辉三角)

杨辉三角形

public static void Triangle(){
        //1.声明并初始化二维数组
        int[][] tri=new int[10][];
        //2.给数组元素赋值
        for (int i=0;i<tri.length;i++){
            tri[i]=new  int[i+1];
            //2.1给首末元素赋值
            tri[i][0]=tri[i][i]=1;
            //2.2给每行非首末元素赋值
            if(i>1){
                for(int j=1;j<tri[i].length-1;j++){
                    tri[i][j]=tri[i-1][j-1]+tri[i-1][j];
                }
            }
        }
        //3.遍历数组
        for (int i=0;i<tri.length;i++){
            for (int j=0;j<tri[i].length;j++){
                System.out.print(tri[i][j]+"\t");
            }
            System.out.println();
        }
    }

运行结果：

1	
1	1	
1	2	1	
1	3	3	1	
1	4	6	4	1	
1	5	10	10	5	1	
1	6	15	20	15	6	1	
1	7	21	35	35	21	7	1	
1	8	28	56	70	56	28	8	1	
1	9	36	84	126	126	84	36	9	1	

Process finished with exit code 0

2. 求数值型数组中元素的最大值、最小值、平均数、总和等

public static void Value(){
        int[] arr=new int[10];
        for (int i=0;i<arr.length;i++){
            arr[i]=(int)(Math.random()*(99-10+1)+10);
        }
        //遍历
        for (int i=0;i<arr.length;i++){
            System.out.print(arr[i]+"\t");
        }
        System.out.println();
        //求数组元素的最大值
        int maxValue=0;
        for(int i=0;i<arr.length;i++){
            if (maxValue<arr[i]){
                maxValue=arr[i];
            }
        }
        System.out.println("最大值为："+maxValue);
        //求数组元素的最小值
        int minValue=0;
        for(int i=0;i<arr.length;i++){
            if (minValue>arr[i]){
                minValue=arr[i];
            }
        }
        System.out.println("最小值为："+minValue);
        //求数组元素的总和
        int sum=0;
        for(int i=0;i<arr.length;i++){
            sum +=arr[i];
        }
        System.out.println("总和为："+sum);
        //求数组元素的平均值
        int avgValue=sum/arr.length;
        System.out.println("平均数为："+avgValue);
    }

3. 数组的复制、反转、查找(线性查找、二分法查找

/**
     *算法考察：数组的复制、反转、查找（线性查找、二分法查找）
     */
    public static void Algorithm(){
        String[] arr=new String[]{"aa","bb","cc","dd"};
        //数组的复制（区别于数组的赋值：arr1=arr）
        String[] arr1=new String[arr.length];
        for(int i=0;i<arr1.length;i++){
            arr1[i]=arr[i];
        }
        //遍历
        for(int i=0;i<arr1.length;i++){
            System.out.print(arr1[i]+"\t");
        }
        System.out.println();
        //数组的反转
         for(int i=0;i<arr.length/2;i++){
             String temp=arr[i];
             arr[i]=arr[arr.length-i-1];
             arr[arr.length-i-1]=temp;
         }
         //遍历
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+"\t");
        }
    }

    /**
     * 查找
     */
    public static void Find(){
        String[] arr=new String[]{"aa","bb","cc","dd"};
        //遍历
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+"\t");
        }
        System.out.println();
        //1.线性查找
        String brr="aa";
        for(int i=0;i<arr.length;i++){
            if(brr.equals(arr[i])){
                System.out.println("找到指定元素，位置为："+i);
                break;
            }
            System.out.println("很遗憾没有找到");
        }
        //2.二分法查找（所要查找的必须有序）
        int[] arr2=new int[]{-98,-34,2,34,54,66,79,105,210,333};
        //遍历
        for(int i=0;i<arr2.length;i++){
            System.out.print(arr2[i]+"\t");
        }
        System.out.println();
        int brr1=-34;
        int head=0;//初始的首索引
        int end=arr2.length-1;//初始的末索引
        boolean isFlag1=true;
        while (head<=end){
            int middle=(head+end)/2;
            if(brr1==arr2[middle]){
                System.out.println("找到指定元素，位置为："+middle);
                isFlag1=false;
                break;
            }else if(arr2[middle]>brr1){
                end=middle-1;
            }else {
                head=middle+1;
            }
        }
        if(isFlag1){
            System.out.println("很遗憾，没有找到");
        }
    }

四、Arrays工具类的使用

java.util.Arrays类即为操作数组的工具类，包含了用来操作数组（比如排序和搜索）的各种方法。

java数组包含某个元素有多少个 java数组在哪个包_数组

public class ArraysTest {
	public static void main(String[] args) {
		
		//1.boolean equals(int[] a,int[] b):判断两个数组是否相等。
		int[] arr1 = new int[]{1,2,3,4};
		int[] arr2 = new int[]{1,3,2,4};
		boolean isEquals = Arrays.equals(arr1, arr2);
		System.out.println(isEquals);
		
		//2.String toString(int[] a):输出数组信息。
		System.out.println(Arrays.toString(arr1));
		
			
		//3.void fill(int[] a,int val):将指定值填充到数组之中。
		Arrays.fill(arr1,10);
		System.out.println(Arrays.toString(arr1));
		

		//4.void sort(int[] a):对数组进行排序。
		Arrays.sort(arr2);
		System.out.println(Arrays.toString(arr2));
		
		//5.int binarySearch(int[] a,int key)
		int[] arr3 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
		int index = Arrays.binarySearch(arr3, 210);
		if(index >= 0){
			System.out.println(index);
		}else{
			System.out.println("未找到");
		}
	}
}

五、数组使用中的常见异常

java数组包含某个元素有多少个 java数组在哪个包_System_02

/*
 * 数组中的常见异常：
 * 1. 数组角标越界的异常：ArrayIndexOutOfBoundsExcetion
 * 
 * 2. 空指针异常：NullPointerException
 * 
 */
public class ArrayExceptionTest {
	public static void main(String[] args) {
		
		//1. 数组角标越界的异常：ArrayIndexOutOfBoundsExcetion
		int[] arr = new int[]{1,2,3,4,5};
		
//		for(int i = 0;i <= arr.length;i++){
//			System.out.println(arr[i]);
//		}
		
//		System.out.println(arr[-2]);
		
//		System.out.println("hello");
		
		//2.2. 空指针异常：NullPointerException
		//情况一：
//		int[] arr1 = new int[]{1,2,3};
//		arr1 = null;
//		System.out.println(arr1[0]);
		
		//情况二：
//		int[][] arr2 = new int[4][];
//		System.out.println(arr2[0][0]);
		
		//情况三：
		String[] arr3 = new String[]{"AA","BB","CC"};
		arr3[0] = null;
		System.out.println(arr3[0].toString());
	}
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：基于java师生交流管理系统 java学生管理系统ppt

下一篇：centos reids centos redis配置

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯

java数组包含某个元素有多少个 java数组在哪个包

java数组包含某个元素有多少个 java数组在哪个包

深入了解Java中的数组

一、数组的概述

1.数组(Array)

2.常见概念

3.数组的分类

二、数组的使用

1.声明方式

2.初始化

（1）一维数组

动态初始化：

静态初始化：

（2）二维数组

动态初始化：

静态初始化：

3.使用

（1）一维数组的使用

（2）二维数组的使用

三、数组涉及到的常见算法

1. 数组元素的赋值(杨辉三角)

2. 求数值型数组中元素的最大值、最小值、平均数、总和等

3. 数组的复制、反转、查找(线性查找、二分法查找

四、Arrays工具类的使用

五、数组使用中的常见异常

51CTO博客