java day04之数组

青旅半醒 2022-04-15 04:48 134阅读 0赞

## 数组： ##

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");
    		}
    	}
    
    }