java之数组

.弗兰克

已于 2022-03-28 11:38:35 修改

阅读量777

点赞数

文章标签： java 开发语言后端

于 2022-03-03 23:30:31 首次发布

本文链接：https://blog.csdn.net/z2768557792/article/details/123266575

版权

文章目录

数组

数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型。即数组就是一组数据


   //遍历数组求出数组所有元素的和   
public class text {
	public  static void  main(String [] args) {
	
	double[]   a = {18,9,43,53,57,19} ;
	
	double max = 0;
	
//	for(int i=0; i < 6 ;i++) {       此时的6可以换成数组a.length的长度
	for(int i=0; i < a.length ;i++) { 
		max += a[i];
		
	}
	System.out.println(max);  
	

	}	
}

数组的定义

有三种定义方式，两动态，一静态初始化，而且 int a [ ] 相等于 int [ ] a
数组的引用就是数组的使用
遍历数组，遍历就是输出所有的数

数组赋值机制

基本数据类型赋值 是值拷贝；

而数组默认情况下是引用传递，赋的值是地址，赋值方式为引用赋值，就是拷贝地址

int [] arr1 = {1,2,3};
int [] arr2 = arr1;        数组arr2的变化会影响数组arr1
arr2 [0] = 10;  //因为arr1引用地址给arr2，双方共用一个地址，所以arr1[0] = 10，arr1的其他元素不变

请添加图片描述

使用方式 1 动态初始化

语法：数据类型数组名 [ ] = new 数据类型[大小]

int a [ ] = new int[ 5 ] ; //创建了一个数组，名叫a，存放了五个int


import java.util.Scanner;
public class text {
	public  static void  main(String [] args) {
		
		Scanner  scanner = new Scanner(System.in); 
		//创建数组a，里面放5个double
		double score [] = new double[5]; 
		
		
		
		//score.length指的是数组score的长度/个数
		for(int i = 0; i< score.length ; i++) {		
			System.out.println("请输入第"+(i+1)+"位考生的成绩");	  
		     score [i] =  scanner.nextDouble();	         	  	  
		}
		
		//遍历数组
		for(int i = 0; i< score.length ; i++) {					   
		     System.out.println("第"+(i+1)+"位考生的成绩："+score[i]);	   
			 
		}
	}		
}

使用方式 2 动态初始化

语法：先声明数组 ,后创建数组

数据类型数组名[ ]

数组名= new 数据类型 [ 大小]

      int  a[ ]; //声明一个数组，但还没分配空间
      a= new int[5];//分配了内存空间，可以存放数据


import java.util.Scanner;
public class text {
	public  static void  main(String [] args) {
		
		Scanner  scanner = new Scanner(System.in); 
		//声明数组 ,后创建数组  
		double score[]; 
		score= new double[5];
		
		
		//score.length指的是数组score的长度/个数
		for(int i = 0; i< score.length ; i++) {		
			System.out.println("请输入第"+(i+1)+"位考生的成绩");	  
		     score [i] =  scanner.nextDouble();	         	  	  
		}
		
		//遍历数组
		for(int i = 0; i< score.length ; i++) {					   
		     System.out.println("第"+(i+1)+"位考生的成绩："+score[i]);	   
			 
		}
	}		
}

使用方式 3 静态初始化

语法：数据类型数组名[ ] = {元素1，元素2，元素3……}

     int a[] = {4,5,7,8,4,9};     和   int a[];  a =  new int[6];     int a [] = new int[6];看情况使用

注意事项

数组是多个相同类型数据的集合。
数组中的元素可以是任何数据类型，包括基本类型和引用类型(比如说对象，接口)，但不能混用
数组如果没赋值，则赋予默认值。
[ 数组的默认值 int ,short,byte,long都是0 ； float，double 0.0 ；char \u0000 ; bo0lean false, String null ]
数组的下标必须在指定范围内使用，否则报错，下标越界异常
数组属于引用类型，数组型数据是对象（object）


int m [] = {1,2,3,4,3.45}  这是错误的，属于double类型转int
doubel m [] = {23.4,1.3,34,56}  这是可以的，属于int 转double

数组的应用案例

创建一个char类型的26元素的数组，分别放置‘A-Z’，使用for循环访问所有元素并打印出来。



  public  class  text  {
public  static  void main(String[]  args)  {
//创建一个数组m用于存放26大写字母
char m [] =new char[26];
 
	for(char i =0; i < m.length ; i++) {   
		m[i]= (char)( 'A' + i );

		System.out.println(m[i]);
	
		}	
	}
}

请求一个数组int[]的最大值{4,-1,9,10,23},并得到对应的下标



       public class text {
       	public  static void  main(String [] args) {
       		
       	
       	int  x []={56,-1,9,10,23};
       	
       int m=0;  //用于接收下标
       	int Max = x[0]; //假设最大值Max=x[0]
       	
       		for(int i = 1; i < x.length ;i++) {
       
       				if(Max < x[i]) {
       					Max = x[i];
       					 m=i;
       				}						
       		}
       
       		System.out.println(Max+" "+m);	
       		
       	}
       }

将数组a{11，22，33，44，55，66}交换成数组a{66，55，44，33，22，11 }



思路 定义一个变量temp用于接收第1个数，循环（交换双方，再让temp进行交换）

public class text {
	public  static   void main(String[] args) {
		
		
		int  [] a = {11,22,33,44,55,66}; 
		
	   int temp = 0;	  //设置个变量用来接收a[0]
	   
	   
		for(int i=0;i<(a.length/2);i++) {  //为什么这里除了2，因为交换只需要循环3次
			
			   temp =a[i];
				a[i]=a[5-i];
				a[5-i]=temp; 
		}
			
		for(int i=0;i<a.length;i++) {
			
				System.out.println(a[i]);
	
		}	
	
	}
	
}

将数组a{11，22，33，44，55，66}交换成数组a{66，55，44，33，22，11 }

思路：定义一个新数组b逆序接收数组a，再将数组a的地址指向数组b

public class text {
	public  static   void main(String[] args) {
		
		
		int  [] a = {11,22,33,44,55,66}; 
		int [] b = new int[a.length];
		for(int i = 0 ; i < a.length ;i++) {  //for(int i = 0 ; i < a.length ;i++) { 
			b[a.length-1-i]= a[i];   
			
		}
		
		   a = b;  //将b的数据空间共享给a使用，就是数组a指向数组b的地址，并且数组a的空间没使用，则会被垃圾回收空间
			for(int i=0;i<a.length;i++) {
			
				System.out.println(b[i]);
	
		}	
 }
}

实现动态给数组添加元素


	//实现动态给数组添加元素
import java.util.Scanner;

 public  class  text  {
public  static  void main(String[]  args)  {
	
	Scanner scanner  = new Scanner(System.in);
	int [] arr1={1,2,3};
		
System.out.println("你要添加几个数字");  
//接收变量x用于数组arr2新增的次数
int x=scanner.nextInt();			
int [] arr2 =new int[x+3];
 
  //遍历将arr1的3个元素赋给arr2
			for( int i=0;i<3;i++) {
			arr2[i]= arr1[i];
			}			
//将数组arr指向arr2地址
	arr1= arr2;	
			for(int i=3;1>0;i++) {							
				System.out.println("是否继续,y/n");  
				//接收字符串key用于判断是否继续下去
				String key =  scanner.next();
	
							if ( "y".equals(key) ) {	
									System.out.println("请输入你要添加"+"第"+(i-2)+"的数字");  
									//m用于接收新的元素
									int m=scanner.nextInt();					
										arr2[i]=m;	
									//每次增加元素都打印数组	
									for( x=0;x<i+1;x++) {		
								    	System.out.print(arr2[x ]+"\t");
									}												
		                	}
						
							else if ("n".equals(key) ) {						
							System.out.println("程序正在退出");  break;
											
								}		
					}							

}
	}

实现动态给数组添加元素



	
import java.util.Scanner;
 public  class  text  {
public  static  void main(String[]  args)  {
	
	Scanner scanner  = new Scanner(System.in);
	int [] arr = {1,2,3};
	
	
do{
	
	int  [] arr_new = new int [arr.length+1];
	
	for(int i=0;i<arr.length;i++) {
		arr_new[i]=arr[i];
	}
	
		System.out.println("请输入你要添加的元素"); 
	         //m用于接收新的元素
		int m=scanner.nextInt();	
		
	arr_new[arr_new.length-1]=m;
	
	arr=arr_new; //将新增元素的数组arr_new的地址拷贝给arr
	
	
	
	//遍历输出指向arr_new数组地址的数组arr
		for(int i=0;i<arr.length;i++) {
				System.out.println(arr[i]);
		}
	
System.out.println("是否继续添加 y/n");
char key  = scanner.next().charAt(0);
		if(key == 'n'){
			break;
		 }
		 
		 
}while(ture);	
	
	}
 }

数组依次在原有的菜单添加菜名

 import  java.util.Scanner;
 
public class text {
	public  static  void main(String[] args) {
		
	String [] arr = { "蛋炒饭" ,"荷包蛋面","肉丁茄子"};
	
	 
	Scanner scanner = new Scanner(System.in);
	 
do{ 
	
	System.out.println(" 请输入要添加的菜名");
String insertNum = scanner.next();
	
	
	//创建一个新数组arr_new用于指向旧数组arr
	String [] arr_new  = new  String [arr.length+1];
		
		//将没添加之前arr的元素赋给arr_new
			for(int i = 0; i < arr.length; i++ ) {
				arr_new[i] = arr[i];
			}
		
		//将添加的数 赋给于 数组arr最后一个数
			arr_new[ arr_new.length - 1] = insertNum;
				
			
	//将数组arr 指向 数组arr_new		
	arr = arr_new;
	
	
	
		//遍历输出指向arr_new数组地址的数组arr
		System.out.println(" 添加后的数组");
		for(int i=0;i<arr.length;i++) {
				System.out.print( arr[i] + "\t" );
		}
		
		System.out.println("是否继续,y/n");  
		
		char  x = scanner.next().charAt(0);
		if( x == 'n') {
			break;
		}
		
		
}while(true);
	
	}
}

实现动态给数组依次减少最后一个元素


import java.util.Scanner;

 public  class  text  {
public  static  void main(String[]  args)  {
	
	Scanner scanner  = new Scanner(System.in);
	int [] arr={1,2,3,4,5};
	int count=0;
	
	do{
		  
		
		    int  []  new_arr = new int [arr.length-1];
		
				for(int i = 0 ; i <arr.length-1 ; i++){
							new_arr[i]=arr[i];	
						}
				
				 arr =new_arr;   
				 
			for(int i = 0 ; i <arr.length ; i++){
				System.out.print(arr[i]);	
	
				}		
				
			   
			if(count ==4){
				break;
			}
			
			count++;
			
			System.out.println("是否继续,y/n");  
			char m= scanner.next().charAt(0);
			if(m == 'n') {
				break;
			}
		
	}while(true);		
  }	
 }

.弗兰克

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
java之数组

数组数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型。即数组就是一组数据 //遍历数组求出数组所有元素的和 public class text { public static void main(String [] args) { double[] a = {18,9,43,53,57,19} ; double max = 0; // for(int i=0; i < 6 ;i++) { 此时的6可以换成数组a.length的长度
复制链接

扫一扫