java day04之数组

最新推荐文章于 2022-05-27 10:52:32 发布

A.张呀张

最新推荐文章于 2022-05-27 10:52:32 发布

阅读量551

点赞数

文章标签：数组案例

本文链接：https://blog.csdn.net/Come__on_/article/details/84327317

版权

数组：

1.数组是多个相同类型的数据的组合，实现对这些数据的统一管理

2.数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型

3.数组属引用类型，数组型数据是对象，数组中的每个元素相当于该对象的成员变量

数组元素的引用：

1.定义并用运算符new为之分配空间后，才可以引用数组中的每个元素

2.数组元素的引用方式：数组名[数组元素下标]

a：数组元素下标可以是整型常量或整型表达式，如a[3]，b[i] ,c[6*i]；

b：数组元素下标从0开始：长度为n的数组的合法下标取值范围：0-->n-1

3.每个数组都有一个属性length指明他的长度，例如a.length指明数组a的长度（元素个数）

4.数组一旦初始化，其长度是不可变的。

5.数组之间的赋值，需要for循环来实现。

栈：存放局部变量，对象的引用。

堆：new出来的东西存放在堆内存中

数组的声明并初始化的几种方式

一维数组：

（1）动态初始化

①: int[] i=new int [12];

i[0]=12;

(2)静态初始化

②:int [] j=new int []{1,2,3};

二维数组：

(1)动态初始化

①String[][] str=new String[4][3];

②String [][]str1=new String [6][];

str1[0]=new String[3];

str1[1]=new String[5];

...

str1[5]=new String[3];

（2）静态初始化

int[][]arr=new int [][]{{1,2,3},{5,7},{3,8}};

关于数组元素的默认初始化值

1）byte short int long 而言：0

2）float double 而言：0.0

3）char 而言:空格

4）boolean而言：false

5）引用类型变量而言：null

数组的反转

(1)for（int i=0;i<arr.length/2;i++）{

int temp=arr[i];

arr[i]=arr[arr.length-1-i];

arr[arr.length-1-i]=temp;

}

(2)for(int x=0,y=arr.length-1;x<y;x++,y--){

int temp=arr[x];

arr[x]=arr[y];

arr[y]=temp;

}

数组的排序：

（1）插入排序：直接选择排序，折半插入排序，shell排序

（2）交换排序：冒泡排序，快速排序（或分区交换排序）

（3）选择排序：简单选择排序，堆排序

（4）归并排序：基数排序

定义数组以及数组的声明

package com.huake.java;

public class TestArray {
   public static void main(String [] args){
	   int j=12;
	   boolean b=true;
	   //1.如何来定义一个数组
	   //数组的声明 加个[]表明是一个数组
	   String[] names;
	   int [] scores;
	   //数组初始化
	   //第一种：静态初始化:初始化数组与给数组元素赋值同时进行
	   names=new String[]{"张三","李四","王五"};
	   //第二种：动态初始化：初始化数组与给数组赋值分开进行
	   scores=new int[4];
	   //如何调用相应的数组元素：通过数组元素的下角标的方式来调用。
	   //下角标从0开始，到n-1结束，其中n表示数组的长度。
	   scores[0]=87;
	   scores[1]=89;
	   scores[2]=90;
	   scores[3]=66;
	   //数组的长度，通过数组的length属性获得。
	   System.out.println(names.length);
	   System.out.println(scores.length);
	   //如何来遍历数组中的元素
	   for(int i=0;i<names.length;i++){
		   System.out.println(names[i]);
	   }  
   }
}

数组元素的默认初始化值

package com.huake.java;

public class TestArray1 {
  public static void main(String [] args){
	  String[] strs=new String[4];
	  strs[0]="AA";
	  strs[1]="BB";
	  strs[2]="CC";
	  strs[3]="DD";
	  //遍历数组元素
	  for(int i=0;i<strs.length;i++){
		  System.out.println(strs[i]);
	  }  
	  //基于基本数据类型的变量创建的数组：byte short int long float double char boolean
	  //对于byte short int long而言 创建数组后默认值为0
	  int [] scores=new int [4];
	  scores[0]=65;
	  scores[3]=89;
	  for(int i=0;i<scores.length;i++){
		  System.out.println(scores[i]);
	  }
	  
	  byte [] scores1=new byte [4];
	  scores1[0]=65;
	  scores1[3]=89;
	  for(int i=0;i<scores1.length;i++){
		  System.out.println(scores1[i]);
	  }
	  
	  //对于float double而言，他们的默认值为0.0
	  float [] f=new float[3];
	  f[0]=1.2f;
	  for(int i=0;i<f.length;i++){
		  System.out.println(f[i]);
	  }
	  //对于char类型而言 默认为空格
	  char [] c=new char[3];
	  for(int i=0;i<c.length;i++){
		  System.out.println(c[i]);
	  }
	  //对于boolean而言 默认是false
	  boolean[] b=new boolean[3];
	  for(int i=0;i<b.length;i++){
		  System.out.println(b[i]);
	  }
	  //对于引用类型的变量构成的数组，默认初始化值为null
	  String [] s=new String[3];
	  for(int i=0;i<s.length;i++){
		  System.out.println(s[i]);
	  }
  }
}

一维数组的练习

package com.huake.java;
/*
 *1.(1)定义类Pritimive，在类中定义一个有3个元素的boolean类型的数组t作为其成员变量
                数组元素未赋值
  定义类TestPritimive，在TestPritimive的main()方法中创建Pritimive对象d，输出其成员变量t的三个元素值
  练习目的：检验基本数据类型数组创建时的 自动赋值
  （2）给对象d的成员变量t赋值为{true,true,true},并输出t的三个元素值
  */
public class TestPritimive {
	public static void main(String [] args){
		//创建Pritimive对象
		Pritimive d=new Pritimive();
		//遍历d的数组元素
		for(int i=0;i<d.t.length;i++){
			System.out.println(d.t[i]);
		}
		//给d的数组元素重新赋值
		d.t[0]=true;
		d.t[1]=true;
		d.t[2]=true;
		for(int i=0;i<d.t.length;i++){
			System.out.println(d.t[i]);
		}
		
	}

}
class Pritimive{
	
	boolean [] t=new boolean[3];

}

一维数组之输出学生成绩及等级

package com.huake.java;
/*
          从键盘读入学生成绩，找出最高分，并输出学生成绩等级。
	成绩>=最高分-10    等级为’A’   
	成绩>=最高分-20    等级为’B’
	成绩>=最高分-30    等级为’C’   
	其余                            等级为’D’
	
	提示：先读入学生人数，根据人数创建int数组，存放学生成绩。

 */
import java.util.Scanner;
public class TestStudentScore {

	public static void main(String[] args) {
		//1.创建Scanner的对象，并从键盘获取学生的个数
		Scanner s=new Scanner(System.in);
		System.out.println("请输入学生的个数：");
		int count=s.nextInt();
		//2.根据输入的学生的个数n，创建一个长度为n的int型的数组、
		int [] scores=new int[count];
	    int max=0;
		//3.依次从键盘获取n个学生的成绩，并赋给相应的数组元素，并获取n个学生中的最高分
	    System.out.println("请输入"+count+"个5学生成绩");
		for(int i=0;i<scores.length;i++){
			int score=s.nextInt();//依次从键盘获取学生的成绩
			scores[i]=score;
			if(scores[i]>max){
				max=scores[i];
			}
		}
		//4.遍历学生成绩的数组，并根据学生成绩与最高分的差值赋予相应的等级，并输出
		System.out.println("最高分为："+max);
		for(int i=0;i<scores.length;i++){
			char level;
			if(scores[i]>=max-10){
				level='A';
			}else if(scores[i]>=max-20){
				level='B';
			}else if(scores[i]>=max-30){
				level='C';
			}else{
				level='D';
			}
			System.out.println("student"+i+"score is"+scores[i]+"grade is"+level);
		}

	}

}

二维数组的初始化及遍历

package com.huake.java;

public class TestArray2 {
	public static void main(String[] args) {
		int [] score1=new int [10];
		int [][]score2;
		String [][]names;
		//1.二维数组初始化
		score2=new int [][]{{1,2,3},{3,4,5},{6}};//静态初始化
		
		names=new String[3][2];  //动态初始化方式一
		names=new String[6][];//动态初始化方式二
		names[0]=new String[5];
		names[1]=new String[4];
		names[2]=new String[7];
		names[3]=new String[5];
		names[4]=new String[8];
		names[5]=new String[4];
		//错误的初始化方式
		//names=new String[][];
		//names=new String[][5];
		//2.如何来引用具体的某一个元素
		int [][]i=new int [3][2];
		i[1][0]=90;
		i[2][1]=99;
		//3.数组的长度
		//二维数组的长度，length属性
		System.out.println(i.length); //3 相当于输出的是行数
		System.out.println(i[0].length);//2
		System.out.println(names.length);//6
		System.out.println(names[4].length);//8
		//4.如何遍历二维数组
		for(int m=0;m<score2.length;m++){  //控制行数
			for(int n=0;n<score2[m].length;n++){
				System.out.print(score2[m][n]);
				}
			System.out.println();
		}
	}

}

数组的常见异常

package com.huake.java;

public class TestException {
public static void main(String[] args) {
	 // 1.数组下标越界异常java.lang.ArrayIndexOutOfBoundsException
	  int []i=new int [10];
	  i[0]=0;
	  i[10]=9;
	  for(int m=0;m<=i.length;m++){  //遍历异常
		  System.out.println(i[m]);
	  }
	  //2.空指针异常java.lang.NullPointerException
	 //第一种
	  boolean [] b=new boolean[3];
	  b=null;  //相当于把b的地址改为null
	  System.out.println(b[0]);
	  //第二种
	  String[]str=new String[4];
	  System.out.println(str[3].toString());
      //第三种
	   int[][]j=new int[3][];
	   j[2][0]=12;
	   
   }
}

求二维数组元素的和

package com.huake.java;

public class TestGetSum {

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

	}

}

打印杨辉三角

package com.huake.java;
/*
 * 用二维数组打印一个十行的杨辉三角*/
public class YangHuiSanJiao {

	public static void main(String[] args) {
		int [][]yangHui=new int [10][];
		
		//初始化二维数组
		for(int i=0;i<yangHui.length;i++){
			yangHui[i]=new int [i+1];
			
		}
		//现实的为二维数组的每个元素赋值
		for(int i=0;i<yangHui.length;i++){
			for(int j=0;j<yangHui[i].length;j++){
				yangHui[i][0]=yangHui[i][i]=1;
				if(i>1&&j>0&&j<i){
					yangHui[i][j]=yangHui[i-1][j]+yangHui[i-1][j-1];
				}
			}
		}
	
		//遍历二维数组
		for(int i=0;i<yangHui.length;i++){
			for(int j=0;j<yangHui[i].length;j++){
				System.out.print(yangHui[i][j]+"\t");
			}
			System.out.println();
		}

	}

}

求数组元素的最大值最小值总和平均值及数组的复制和反转

package com.huake.java;

public class TestArray3 {

	public static void main(String[] args) {
		int [] arr=new int []{12,43,9,0,-65,-99,100,9};
		//最大值
		int max=arr[0];
		for(int i=1;i<arr.length;i++){
			if(max<arr[i]){
				max=arr[i];
			}
		}
		System.out.println("最大值为："+max);
		//最小值
		int min=arr[0];
		for(int i=1;i<arr.length;i++){
			if(min>arr[i]){
				min=arr[i];
			}
		}
		System.out.println("最小值为："+min);
		//总值
		int sum=0;
		for(int i=0;i<arr.length;i++){
			sum+=arr[i];
		}
		System.out.println("总和为："+sum);
		//平均数
		int avg=0;
		avg=sum/arr.length;
		System.out.println("平均值为："+avg);
		//数组元素的复制
		int [] arr1=new int [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++){
			int temp=arr[i];
			arr[i]=arr[arr.length-1-i];
			arr[arr.length-1-i]=temp;
		}
		for(int i=0;i<arr.length;i++){
			System.out.print(arr[i]+"\t");
		}
		
		

	}

}

使用冒泡排序或者直接选择排序对数组进行排序

package com.huake.java;

public class TestOrder {

	public static void main(String[] args) {
		int [] arr=new int []{12,23,-99,9,0,56,100,-45};
		//使用冒泡排序使数组元素从小到大排序
		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 temp=arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=temp;
				}
			}
		}
		System.out.println();
		for(int i=0;i<arr.length;i++){
			System.out.print(arr[i]+"\t");
		}
		//使用直接选择排序
		for(int i=0;i<arr.length-1;i++){
			for(int j=i+1;j<arr.length;j++){
				if(arr[i]>arr[j]){
					int temp=arr[i];
					arr[i]=arr[j];
					arr[j]=temp;
				}
			}
		}
		System.out.println();
		for(int i=0;i<arr.length;i++){
			System.out.print(arr[i]+"\t");
		}
	}

}

A.张呀张

关注

0
点赞
踩
0

收藏

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

数组：1.数组是多个相同类型的数据的组合，实现对这些数据的统一管理2.数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型 3.数组属引用类型，数组型数据是对象，数组中的每个元素相当于该对象的成员变量数组元素的引用：1.定义并用运算符new为之分配空间后，才可以引用数组中的每个元素2.数组元素的引用方式：数组名[数组元素下标] a：数组元素下标可以是整型...
复制链接

扫一扫