4、java数组详解--创建数组、处理（读取）数组、计算数组、数组排序、二分法元素查找、数组的复制方法及java.util.Arrays类的使用、多维数组、不规则数组

最新推荐文章于 2023-07-29 21:10:20 发布

Jalen data analysis

最新推荐文章于 2023-07-29 21:10:20 发布

阅读量603

点赞数 5

分类专栏： java基础文章标签： java数组 java定义数组 java数组的计算 java数组排序数组操作案例

本文链接：https://blog.csdn.net/weixin_41685388/article/details/102875104

版权

java基础专栏收录该内容

5 篇文章 0 订阅

订阅专栏

一、Java一维数组

1、声明数组变量

dataType[] arrayRefVar; // 首选的方法 
或 
dataType arrayRefVar[]; // 效果相同，但不是首选方法

double[] arr; //等价于 double arr[];

2、创建数组

dataType[] arrayRefVar = new dataType[arraySize];
另外：
dataType[] arrayRefVar = {value0, value1, ..., valuek};
dataType[] arrayRefVar = new dataType[] {value0, value1, ..., valuek};

double[] arr = new double[3];  //表示创建了默认为3个0.0元素的数组arr
double[] arr = {12.0,12.5,13.2,14.5}; //创建并直接添加元素值
double[] arr = new double[] {12.0,12.5,13.2,14.5}; //创建并直接添加元素值

3、案例1

public class Demo4 {
	   public static void main(String[] args) {
	      // 数组大小
	      int size = 10;
	      // 定义数组
	      double[] myList = new double[size];
	      //给数组写入新的值
	      myList[0] = 1.0;
	      myList[1] = 2.0;
	      myList[2] = 3.0;
	      myList[3] = 4.0;
	      myList[4] = 5.0;
	      myList[5] = 6.0;
	      myList[6] = 7.0;
	      myList[7] = 8.0;
	      myList[8] = 9.0;
	      myList[9] = 10.0;
	      // 计算所有元素的总和
	      double sum = 0;
	      for (int i = 0; i < size; i++) {
	         sum += myList[i];
	      }
	      System.out.println("总和为： " + sum);
	   }
	}

4、处理数组

数组的元素类型和数组的大小都是确定的，所以当处理数组元素时候，我们通常使用基本循环或者 For-Each 循环（增强for）。

普通for和增强for的区别：
1.增强for只能顺序遍历；
2.增强for不能指定范围遍历，只能遍历所有。
3.增强for不能改变数组元素的值。

//方法1：for循环
public class Arr {
   public static void main(String[] args) {
      double[] myList = {0.9, 1.9, 2.9, 3.9};
 
      // 打印所有数组元素
      for (int i = 0; i < myList.length; i++) {
         System.out.print(myList[i] + " ,");
      }
	  System.out.println();

      // 计算所有元素的总和
      double sum = 0;
      for (int i = 0; i < myList.length; i++) {
         sum += myList[i];
      }
      System.out.println("sum is " + sum);
      
	  // 查找最大元素
      double max = myList[0];
      for (int i = 1; i < myList.length; i++) {
         if (myList[i] > max){ 
			 max = myList[i];
			 }
      }
      System.out.println("Max is " + max);
   }
}

/* 方法2：For-Each 循环
for(type element: array)
{
    System.out.println(element);
}
*/
public class Arr {
   public static void main(String[] args) {
      double[] myList = {0.9, 1.9, 2.9, 3.9};
 
      // 只能打印所有数组元素
      for (double arr:myList) {
		  System.out.println(arr);
	  }
   }
}

5、计算数组

5.1、数组求和、均值、最值、中位数、比较（判断）元素

import java.util.Arrays;
import java.util.Scanner;

public class Demo5 {

	public static void main(String[] args) {
		double[] arr = new double[] {2.2,1.1,2.2,1.1,4.4,5.5,1.1};
		double sumArr = 0;
		double maxArr = arr[0];
		double minArr = arr[0];
		for(int i=0;i<arr.length;i++) {
			sumArr = sumArr + arr[i];
			if (arr[0]<arr[i]) {maxArr = arr[i];}
			if (arr[0]>arr[i]) {minArr = arr[i];}
			System.out.print(arr[i] + ", ");
		}
		System.out.println();
		System.out.println("计数："+arr.length);
		System.out.println("合计："+(float) sumArr);
		System.out.println("均值："+  (float)(sumArr/arr.length));
		System.out.println("最大值："+maxArr);
		System.out.println("最小值："+minArr);
		//求中位数，需要先排序
		Arrays.sort(arr);  //从此数组的的顺序就被改变为升序了
		if (arr.length % 2 !=0) {
			System.out.println("中位数："+arr[(int) (arr.length / 2.0)]);
		}else {
			System.out.println("中位数："+(arr[(int) (arr.length / 2.0)] + arr[(int) (arr.length / 2.0 -1)] )/2.0 );
		};
		//判断从控制台输入的值是否在数组内，下标值
		Scanner superman = new Scanner(System.in);
		double n;
		System.out.println("输入一个Double类型的数：");
		n = superman.nextDouble();
		int j=0;
		for(;j<arr.length;j++) {
			if(arr[j]==n) {System.out.println("存在，下标是：" + j);
			break;
			}
		}
		if (j==(arr.length)) {System.out.println("不存在");}
	}
}

6、数组排序（冒泡、选择、插入、快速排序）

6.1、冒泡排序

冒泡排序:是将数组中的两个相邻的元素进行比较，并将最小的元素交换到前面，多轮比较交换位置，直到全部比较完毕

//数组排序：冒泡排序
public class Demo6 {
	//升序
	public static void main(String[] args) {
		double[] array = new double[] {1.0,2.2,5.6,3.5,4.9};
		double box = 0;
		for (int i = 0;i<(array.length - 1);i++) {       //排序轮次array.length-1次
			for (int j=0;j<(array.length - 1 - i);j++) {  //每轮对比次数
				if(array[j] > array[j+1]){  //相邻的比较
					box = array[j];
					array[j] = array[j+1];
					array[j+1] = box;
				}
			}	
		}
		for (double array1:array) {
			System.out.println(array1);
		}
	}
}

6.2、选择排序

选择排序：某个位置和这个位置后的所有元素比较。

package test;
//选择排序：某个位置和这个位置后的所有元素比较。
public class Demo7 {
	//升序
	public static void main(String[] args) {
		double[] array = new double[] {5.2, 6.2, 7.2, 3.2, 4.2,0.1};
		double box = 0.0;
		for(int i =0;i<(array.length-1);i++) {  //位置
			for(int j =i+1;j < array.length;j++) {
				if(array[i]>array[j]) {
					box = array[i];
					array[i] = array[j];
					array[j] = box;
				}
			}	
		}
		for (double array1:array) {
			System.out.println(array1);
		}
	}
}

6.3、插入排序

某个位置与前边所有元素比较，这个位置的元素比前边元素小，那么把这个位置的元素插入到比它大的那个元素的位置。

//插入排序：某个位置（第2，3，...，array.length-1位置）与前边所有元素比较，
//升序
//这个位置的元素比前边元素小，
//那么把这个位置的元素插入到比它大的那个元素的位置。

public class Demo9 {
//升序
	public static void main(String[] args) {
		int[] array = new int[] {8,5,9,4,3,6,7,2,1};
		int box ;
		for (int i = 1;i<array.length;i++) {  //位置
			for (int j = 0;j<i;j++) {  //位置前边所有元素比较
				if(array[i]<array[j]) {
					box=array[i];   //拿出位置上的元素
					for(int k = i;k>j;k--) {  //插入覆盖
						array[k] = array[k-1];
					}
					array[j] =  box;
					}
			}	
		}
		for (int array1:array) {
			System.out.println(array1);
		}
	}
}

6.4、快速排序法

6.4.1、快速排序法--降序排序

public class Demo12 {
//java快速排序法--降序
	public static void main(String[] args) {
		// 定义一个数组
		int[] array = {1,3,5,7,9,2,4,6,8,10,5};//任意数组
		//调用快速排序的方法
		quickSort( array, 0, array.length-1);
		
		//遍历输出数组
		for(int i=0;i<array.length;i++) {
			System.out.print(array[i] + ", ");
		}
	}
	/*
	 定义一个方法，用来进行快速排序
	 */
	public static void quickSort(int[] array, int left, int right) {
		//前提条件，左边索引应该是小于右边索引的
		if( left> right ) {return; }
		//定义一个变量存基准数
		int base = array[left];
		//定义变量i,指向最左边
		int i = left;
		//定义变量j，指向最右边
		int j = right;
		
		while (i != j) {   //当i != j时
			//第一轮:
			//当i和j不相撞时，先由j从右往左检索，直到检索到小于基准数的就停下
			while(array[j]<=base && i<j) {
				j--;   //j向左移动,直到找到>=base的位置
			}
			//i从左向右检索，直到检索到大于基准数的就停下
			while(array[i]>=base && i<j) {
				i++;   //i向右移动,直到找到<=base的位置
			}
			//i和j都停下来了，就交换这两个位置的元素
			if(i<j) {
				int box ;
				box = array[i];
				array[i] = array[j];
				array[j] = box;
			}
		}
		//当跳出循环i=j时，把相撞位置的数与基准数交换
		array[left] = array[j];
		array[j] = base;
		
		//基准数归为，左边都大(>=)，右边都小(<=)
		
		//第二轮
		//排基准数的左边，排法和第一轮一样,调用第一轮的方法。
		quickSort(array, left, j - 1);
		//排右边
		quickSort(array, j+1,right);
	}	
}

6.4.2、快速排序法--升序

public class Demo10 {
//java快速排序法：升序
	public static void main(String[] args) {
		// 定义一个数组
		int[] array = {6,4,3,5,1,9,8,7,2,6,9,0,10};//任意数组
		//调用快速排序的方法
		quickSort( array, 0, array.length-1);
		
		//遍历输出数组
		for(int i=0;i<array.length;i++) {
			System.out.print(array[i] + ", ");
		}
	}
	/*
	 定义一个方法，用来进行快速排序
	 */
	public static void quickSort(int[] array, int left, int right) {
		//前提条件，左边索引应该是小于右边索引的
		if( left> right ) {return; }
		//定义一个变量存基准数
		int base = array[left];
		//定义变量i,指向最左边
		int i = left;
		//定义变量j，指向最右边
		int j = right;
		
		while (i != j) {   //当i != j时
			//第一轮:
			//当i和j不相撞时，先由j从右往左检索，直到检索到小于基准数的就停下
			while(array[j]>=base && i<j) {
				j--;   //j向左移动
			}
			//i从左向右检索，直到检索到大于基准数的就停下
			while(array[i]<=base && i<j) {
				i++;   //i向右移动
			}
			//i和j都停下来了，就交换这两个位置的元素
			if(i<j) {
				int box ;
				box = array[i];
				array[i] = array[j];
				array[j] = box;
			}
		}
		//当跳出循环i=j时，把相撞位置的数与基准数交换
		array[left] = array[j];
		array[j] = base;
		
		//基准数归为，左边的都比他小，右边的都比他大
		
		//第二轮
		//排基准数的左边，排法和第一轮一样,调用第一轮的方法。
		quickSort(array, left, j - 1);
		//排右边
		quickSort(array, j+1,right);
	}	
}

7、二分法查找数组元素

要点：必须先排序，再进行二分查找。

package test;
//二分法查找元素
import java.util.Scanner;

public class Demo11 {
	public static void main(String[] args) {
		Scanner superman = new Scanner(System.in);
		
		int[] array = new int[] {8,3,5,7};
		//冒泡排序法
		int box; 
		for (int i=0;i<array.length;i++) {
			for(int j=i+1;j<array.length;j++) {
				if (array[i]>array[j]) {
					box=array[i];
					array[i] = array[j];
					array[j] = box;
				}
			}
		}
		for (int array1:array) {
			System.out.println(array1);
		}
		//二分法查找元素
		System.out.println("请输入需要查找的元素：");
		int  value = superman.nextInt();
		int start = 0;
		int end = array.length-1;
		int middle = (start+ end)/2;
		while(value !=array[middle] ){
			if(value < array[middle] ) {
				end = (middle-1);		
			}else if(value > array[middle]) {
				start= (middle+1);
			}
			if (end<start) {
				middle = -1;
				break;
			}
			middle = (start+ end)/2;
		}
		if(middle == -1) {
			System.out.println("不存在" );
		}else {
			System.out.println("存在，第" +middle +"元素" );
		}
	}
}

8、数组的复制方法及java.util.Arrays类的使用

import java.util.Arrays;

public class Demo13 {
//将一个数组存放到另外一个数组中去
	public static void main(String[] args) {
		int[] array = {22,20,13,9,17};
		
		//--方法1：-------------------------------------------------------------------
		System.out.println("方法1");
		//让array1也指向array数组存放的内存地址
		int[] array1 = array;  //直接像变量赋值一样用等于符号
		for (int arr:array1) {
			System.out.print(arr + ", ");//输出数组
		}
		//两个的内存地址是相同的，重点哈
		System.out.println("\n" + array); //输出array内存地址
		System.out.println(array1);//输出array1内存地址
	
		//--方法2：------------------------------------------------------------------------
		System.out.println("方法2");
		//数组的克隆，创建并返回一个副本
		int[] array2 = array.clone();
		for (int arr:array2) {
			System.out.print(arr + ", ");//输出数组
		}
		//既然是副本，那么内存地址就是不相同的，重点哈
		System.out.println("\n" + array); //输出array内存地址
		System.out.println(array2);//输出array2内存地址
		
		//--方法3：------------------------------------------------------------------------
		System.out.println("方法3");
		//创建一个长度相同的空数组，然后遍历赋值
		int[] array3 = new int[array.length];
		for (int i = 0;i<array.length;i++) {
			array3[i] = array[i];
		}
		for (int arr:array3) {
			System.out.print(arr + ", ");//输出数组
		}
		//既然是新建赋值，那么内存地址就是不相同的，重点哈
		System.out.println("\n" + array); //输出array内存地址
		System.out.println(array3);//输出array2内存地址
		
		//--方法4：------------------------------------------------------------------------
		System.out.println("方法4");
		//用系统自带的类复制，System.arraycopy(src, srcPos, dest, destPos, length);
		//src:源数组；srcPos：复制的起始位置；dest：目标数组；destPos：目标数组粘贴的起始位置； length：复制数组的长度
		int[] array4 = new  int[array.length];//创建数组
		System.arraycopy(array, 0, array4, 0, array.length);
		for (int arr:array4) {
			System.out.print(arr + ", ");//输出数组
		}
		//既然是新建复制粘贴，那么内存地址就是不相同的，重点哈
		System.out.println("\n" + array); //输出array内存地址
		System.out.println(array4);//输出array2内存地址
		
		//--方法5：------------------------------------------------------------------------	
		System.out.println("方法5");
		//导入java.util.Arrays的类进行操作
		//copyOf(源数组,复制长度少于则截取，多了0来补)：复制数组
		int[] array5 = Arrays.copyOf(array2, array2.length);
		System.out.println(Arrays.toString(array5));
		//copyOfRange :指定范围复制
//		int[] array5_0 = Arrays.copyOfRange(array2,0, array2.length);
//		System.out.println(Arrays.toString(array5_0));
		
		//--常用的Arrays类方法：----------------------------------------------------
		System.out.println("常用的Arrays类方法：");
		//导入java.util.Arrays;的类进行操作
		//常用的Arrays类方法：
		//toString：字符串的形式展示数组
		System.out.println(Arrays.toString(array));
		//sort/parallelSort：对数组进行排序
		Arrays.sort(array1); //对数组进行升序（快速排序）
		System.out.println(Arrays.toString(array1));//字符串形式查看数组
		Arrays.sort(array2, 1, 3);//指定位置排序，这里的排序位置为[1,3),重点啊半闭半开，前闭后开，
			                                       //1指的是第2个元素，3指第4个元素，但3是开区间，最后一个位置是不参与的
		System.out.println(Arrays.toString(array2));//字符串形式查看数组
		//binarySearch(a, key)：二分查找法，前提是需要排序,a为数组，key为需要查找的元素
		Arrays.sort(array2);
		System.out.println(Arrays.binarySearch(array2, 17));//返回排序后的下标
		//当查找值不存在时，返回负的插入点-1
		System.out.println(Arrays.binarySearch(array1, 10));
		//binarySearch，支持范围查找
		System.out.println(Arrays.binarySearch(array1, 0, 2, 13));
		//equals：判断两个数组是否相同，对应位置都相同返回true
		System.out.println(Arrays.equals(array1, array3));
		//fill：填充(替换)数组，不指定范围全部替换填充，当然可以指定填充替换 也是半开半闭[n1,n2)
		Arrays.fill(array2, 0, 1, 222);
		System.out.println(Arrays.toString(array2));
		//copyOf(源数组,复制长度少于则截取，多了0来补)：复制数组
		int[] array5_1 = Arrays.copyOf(array2, array2.length);
		System.out.println(Arrays.toString(array5_1));
		//copyOfRange :指定范围复制同样范围半开半闭
		int[] array5_2 = Arrays.copyOfRange(array2, 2, 4);
		System.out.println(Arrays.toString(array5_2));		
	}
}

9、一维数组综合操作案例

import java.util.Scanner;

public class Demo8 {

	public static void main(String[] args)  {
	//(1)阶段：定义数组，添加数组元素，输出数组
		//定义数组，
		String[] array1 = new String[100];//会员编号
		String[] array2 = new String[100] ;//会员生日
		int[] array3 = new int[100] ;//会员积分
		//添加数组
		array1[0]= "v1001";
		array2[0]= "12/20";
		array3[0]= 1800;
		array1[1]= "v1002";
		array2[1]= "10/03";
		array3[1]= 2000;
		array1[2]= "v1003";
		array2[2]= "11/09";
		array3[2]= 2000;
		System.out.println("会员编号\t会员生日\t会员积分");
		//输出数组
		for(int i = 0;i<array1.length;i++) {   //输出已有会员信息
			if (array1[i] ==null ) {break;}
			System.out.println(array1[i]+ "\t"+ array2[i]+ "\t"+ array3[i]);
			}
	//（2）第二阶段，添加控制台循环输入添加新会员信息
		Scanner superman = new Scanner(System.in);
		String next;
		System.out.print("是否添加新会员（y/n）：");
		next = superman.next();
		while (next.equals("y")) {   
			for (int j=0;j<array1.length;j++) {
				if(array1[j]==null && array2[j]==null && array3[j]==0) {
					System.out.print("输入会员编号：");
					array1[j] = superman.next();
					System.out.print("输入会员生日(月/日)：");
					array2[j] = superman.next();
					System.out.print("输入会员积分：");
					array3[j] = superman.nextInt();
					break;
				}
			}
			System.out.print("是否继续输入新会员(y/n)：");
			next = superman.next();
		}
	//（3）第三阶段：输出会员列表，并找到积分最大的会员,如果最值存在多个一起找到
			System.out.println("------------添加新会员后的会员列表----------------------");
			System.out.println("会员编号\t会员生日\t会员积分");
			int maxArray3 = array3[0];
			for(int i = 0;i<array1.length;i++) {   
				if (array3[i] ==0 ) {
					break;
					}else {
						if(maxArray3<array3[i]) {maxArray3 = array3[i];}  //找最值
						System.out.println(array1[i]+ "\t"+ array2[i]+ "\t"+ array3[i]);
					}
				}
			System.out.println("最高积分为：" + maxArray3);
			//找最值对应的下标,输出会员信息
			for(int i = 0;i<array3.length;i++) {
				if(array3[i] != 0) {
					if( maxArray3 == array3[i]) {
						System.out.println(array1[i]+ "\t"+ array2[i]+ "\t"+ array3[i]+"目前积分最高");
					}
				}else {break;}
			}
		}
}

二、java二(多)维数组

二维数组在java中也相当于一维数组

行\列	0列	1列
0行	15	5
1行	8	18
2行	10	3

存储原理

1、声明二维数组变量

类型[][] 变量名;
int [][] array;
double[][] arr;

2、创建二维数组

dataType[][] arrayRefVar = new dataType[rowLength][columnLength];
int[][] array = new int[3][2];
另：
int[][] array；
array = int[3][2];

3、创建二维数组并赋值

import java.util.Arrays;
import java.util.Scanner;
//二维数组
public class Demo14 {
	public static void main(String[] args) {
		//静态初始化
//		int [][] array = {{15,5},{8,18},{10,3}};  
		int [][] array = new int[][] {{15,5},{8,18},{10,3}};  
		
		//按照单个元素赋值
//		int [][] array; //申明一个整数型的2维数组
//		array= new int[3][2];  //创建一个3行2列的二维数组
//		array[0][0] = 15;  //给数组赋值
//		array[0][1] = 5;
//		array[1][0] = 8;
//		array[1][1] = 18;
//		array[2][0] = 10;
//		array[2][1] = 3;
		
		//控制台给数组赋值
//		int[][] array = new int[3][2];
//		Scanner superman = new Scanner(System.in);
		System.out.println(array.length);//结果为3行
//		System.out.println("输入元素：");
//		for(int i = 0;i<array.length;i++) {
//			for(int j=0;j<array[i].length;j++) {
//				array[i][j] = superman.nextInt();
//			}
//		}
		//输出数组
		for (int i = 0 ;i<array.length;i++) {  //行
			for(int j =0;j<array[i].length;j++) {  //列
				System.out.print(array[i][j] + "\t");
			}
			System.out.println();	
		 }	
		//计算2维数组--按照行求和
		int sum = 0;
		for (int i =0;i<array.length;i++) {
			sum = 0;//清零
			for(int j = 0;j<array[i].length;j++) {
				sum += array[i][j];
			}
			System.out.println(sum);
		}
	}
}

三、不规则数组

public class Demo15 {
//不规则数组
	public static void main(String[] args) {
//		int[][] array = new int[3][];
		array[0] = new int[2];
		array[1] = new int[3];
		array[1] = new int[4];
//		array[0] = new int[] {4,6};
//		array[1] = new int[] {2,5,3};
//		array[2] = new int[] {2,1,4,3};
		int[][] array = {{4,6},{2,5,3},{2,1,4,3}};
//		int[][] array = new int[][] {{4,6},{2,5,3},{2,1,4,3}};
		for(int i = 0;i<array.length;i++) {
			for(int j = 0;j<array[i].length;j++) {
				System.out.print(array[i][j] + "\t");
			}
			System.out.println();
		}
	}
}

Jalen data analysis

关注

5
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
4、java数组详解--创建数组、处理（读取）数组、计算数组、数组排序、二分法元素查找、数组的复制方法及java.util.Arrays类的使用、多维数组、不规则数组

一、Java一维数组1、声明数组变量dataType[] arrayRefVar; // 首选的方法或 dataType arrayRefVar[]; // 效果相同，但不是首选方法double[] arr; //等价于 double arr[];2、创建数组dataType[] arrayRefVar = new dataType[arraySize];另外：d...
复制链接

扫一扫

专栏目录