JavaSE(五)--数组

1.数组:

在内存内开辟一组连续空间来存值叫数组.

1.1 数组也是一种变量,也是一种引用数据类型.

1.2 数组由四个组成部分

数组名,数据类型,元素,索引(下标).

1.3 类型

同一个数组中,元素的数据类型相同的;不同的数组数据类型可以是java中任意类型.

1.4 索引

数组的索引从0开始.

1.5 访问数组中某个空间元素

数组名[索引].

1.6 空间

数组一但分配了空间,它的长度是固定的.

1.7长度

数组的长度:数组名.length

1.8 范围

数组的索引范围在:0~数组名.length-1

数组的索引如果超过范围报:ArrayIndexOutOfBoundsException

1.9 使用

数组只要分配空间就可以使用.

1.10 默认值

数组如果分配空间后,不赋值有默认值:

			String类型数组,默认值null
			int类型数组,默认值0
			double类型数组,默认值0.0
			char类型数组,默认值/u0000,在window系统上看着像空格
			boolean类型数组,默认值false

1.11 输出

数组如果直接输出,输出的是内存地址.

2.数组的使用:

2.1:声明数组语法:

数据类型[] 数组名;(推荐)
数据类型 数组名[];

		eg://声明数组,存学生姓名
		String[] studentNames;
		
		//声明数组,存学生年龄
		int studentAges[];

2.2:给数组分配空间:

语法:

  • 给已经声明的数组分配空间:

    数组名=new 数据类型[长度];

  • 在声明数组的同时分配空间语法:
    数据类型[] 数组名=new 数据类型[长度];
    数据类型 数组名[]=new 数据类型[长度];

		//eg://给已经声明的数组分配空间
		studentNames=new String[3];
		studentAges=new int[3];
		
		//在声明数组的同时赋值,存学生身高
		double[] studentHeight=new double[4];

2.3:给数组赋值:

2.3.1:动态赋值

适用于所有数组.
注意: 只有分配空间的数组,才可以使用动态赋值.
动态赋值的语法:数组名[索引]=值;

	    //eg://给数组动态赋值
		studentNames1[0]="张三";
		studentNames1[1]="李四";
		studentNames1[2]="王五";

2.3.2:静态赋值

适用于对数组中元素已知的情况.

2.3.2.1:静态赋值的第一种语法,在声明数组的同时给数组赋值:

数据类型[] 数组名=new 数据类型[]{值1,值2…};
可以写成:
数据类型[] 数组名;
数组=new 数据类型[]{值1,值2…};

				eg://声明数组的同时,静态赋值
		String[] studentNames2=new String[] {"赵六","钱七","老王","马云"}; 		
		
		int[] studentAges2;
		studentAges2=new int[] {17,18,19};

2.3.2.2:静态赋值的第二种语法,在声明数组的同时给数组赋值:

数据类型[] 数组名={值1,值2…};

		 eg:double[] studentHeight2= {1.7,1.8,1.9};

2.4:遍历数组:

遍历:访问数组中每个空间的元素的值.

2.4.1:用for循环遍历

		//eg://用for循环遍历数组
		for(int i=0;i<studentNames1.length;i++) {
			System.out.println("姓名为:"+studentNames1[i]);
		}

2.4.2:(扩展)用增强版for循环(foreach循环)遍历:

只用于访问数组和集合中每个元素.
语法:

		  for(数据类型 别名:数组/集合){

			   }

注意: 别名指代当前遍历集合中当前元素.数据类型指代遍历每个元素的类型.

	   eg://用增强for循环遍历
		  for (String stu : studentNames2) {
			System.out.println(stu);
		}

3.数组的扩容

3.1:自定义数组:

声明一个新数组,长度大于原数组,将原数组的元素复制过来.

	//eg:/*第一种:将原数组长度扩容到5*/
	//声明一个长度为5新数组
	int[] nums2=new int[5];
	//将原数组的元素复制新数组中
	for (int i = 0; i < nums1.length; i++) {
		nums2[i]=nums1[i];
	}

3.2:工具类1

Arrays.copyOfRange(原数组,起始索引,终止索引);不包含终止索引

	//将原数组的元素复制到新数组,复制时原数组的长度不够,补默认值.
	int[] nums3=Arrays.copyOfRange(nums1, 0, 5);

3.3:工具类2

Arrays.copyOf(原数组, 长度);

	/*第三种:将原数组长度扩容到5*/
	int[] nums4=Arrays.copyOf(nums1, 5);

4.动态参数(可变长参数)

参数个数可以是0个到多个.
语法:
数据类型…参数;

  • 动态参数的实参可以0个到多个参数.
  • 动态参数在方法中当作数组来用.
  • 动态参数的实参可以直接传数组.
  • 一个方法中只能有一个动态参数.
  • 动态参数只能作方法的最后一个参数.
//eg:
public class VariableElement {

	public static void main(String[] args) {
		//调用方法
		double result1=sum();
		double result2=sum(11.1,3.14,33);
		
		//动态参数的实参可以直接传数组
		double[] count= {33,11,77};
		double result3=sum("aa",count);
		
		System.out.println("结果为:"+result3);

	}
	
	/**
	 * 动态参数的使用方法
	 * @param num 动态参数
	 * @return 数字之和
	 */
	public static double sum(double...num) {
		//声明一个变量存总和
		double sum=0;
		//在方法中将动态参数作为数组用
		for (int i = 0; i < num.length; i++) {
			sum=sum+num[i];
		}
		return sum;
	}
	
	/**
	 * 动态参数的使用方法
	 * @param num 动态参数
	 * @return 数字之和
	 */
	public static double sum(String name,double...num) {
		System.out.println(name+"正在计算中...");
		//声明一个变量存总和
		double sum=0;
		//在方法中将动态参数作为数组用
		for (int i = 0; i < num.length; i++) {
			sum=sum+num[i];
		}
		return sum;
	}
}	

5.数组排序

5.1:求最大值和最小值

//eg:
	public static void main(String[] args) {
		//准备一个数组
		int[] nums= {5,8,1,7,6,3};
		
		//声明一个变量存最大值,默认数组第一个空间是最大值
		int max=nums[0];
		
		//声明一个变量存最小值,默认数组第一个空间是最小值
		int min=nums[0];
		
		//数组中其他元素依次与最大值或最小值比较
		for (int i = 1; i < nums.length; i++) {
			//求最大值
			if(max<nums[i]) {
				max=nums[i];
			}
			
			//求最小值
			if(min>nums[i]) {
				min=nums[i];
			}
		}
		
		System.out.println("数组中最大值 为:"+max);
		System.out.println("数组中最小值 为:"+min);
	}

5.2:冒泡排序:

第一轮从第一个元素开始两两比较,比到最后一个数,每轮比出当前所有数中最大值或最小值,下一轮又从第一个元素开始两两比较,比出剩下数中最大值或最小值,依次类推.
在这里插入图片描述

//eg:
	public static void main(String[] args) {
		//准备一个数组
		int[] nums= {5,8,1,7,6,3};
		
		System.out.println("排序前原数组为:");
		for (int n: nums) {
			System.out.print(n+",");
		}
		System.out.println();
		
		/*冒泡排序*/
		//外层循环控制比较轮数
		for(int i=0;i<nums.length-1;i++) {
			//内层循环控制比较次数
			for(int j=0;j<nums.length-1-i;j++) {
				//两两相比
				if(nums[j]<nums[j+1]) {
					int temp=nums[j];
					nums[j]=nums[j+1];
					nums[j+1]=temp;
				}
			}
		}

		System.out.println("排序后原数组为:");
		for (int n: nums) {
			System.out.print(n+",");
		}
		System.out.println();
	}

5.3:选择排序

第一轮从第一个元素开始依次与后面每个元素比较,比到最后一个数,每轮比出当前所有数中最大值或最小值,下一轮又从剩下数中第一个元素开始依次与后面每个元素比较,比到最后一个数,比出剩下数中最大值或最小值,依次类推.
在这里插入图片描述

//eg:
	public static void main(String[] args) {
		//准备一个数组
		int[] nums= {5,8,1,7,6,3};
		
		System.out.println("排序前原数组为:");
		for (int n: nums) {
			System.out.print(n+",");
		}
		System.out.println();
		
		/*选择排序*/
		//外层循环控制轮数,i表达轮数
		for(int i=0;i<nums.length-1;i++) {
			//内层循环控制比较次数,num[i]表示剩下数列中第一个数,num[j]表示每一个要与i比较的数
			for(int j=i+1;j<nums.length;j++) {
				if(nums[i]<nums[j]) {
					int temp=nums[i];
					nums[i]=nums[j];
					nums[j]=temp;
				}
			}
		}
		
		System.out.println("排序前原数组为:");
		for (int n: nums) {
			System.out.print(n+",");
		}
		System.out.println();
	}

5.4:jdk排序

Arrays.sort(数组名);默认升序排序.

6.(扩展)Arrays:数组的工具类.

  • 给数组进行升序排序:Arrays.sort(数组名);
  • 复制原数组中指定长度生成一个新数组
    Arrays.copyOf(原数组名, 长度);
  • 复制原数组中从指定起始索引,复制到终止索引
    Arrays.copyOfRange(原数组名, int from, int to)
  • 将数组转换为字符串:Arrays.toString(数组名);
  • 对已经排好序的数组进行二分查找:Arrays.binarySearch(数组名,要查找的数);
  • 对数组统一赋相同的值:Arrays.fill(数组名, 值);
		eg:public static void main(String[] args) {
		// 准备一个数组
		int[] nums = {5, 2,5,5, 8, 1, 7, 6, 3 };

		//将数组转换为字符串输出
		System.out.println("排序前原数组为:"+Arrays.toString(nums));
		
		//jdk中Arrays自带的方法排序
		Arrays.sort(nums);
		
		//将数组转换为字符串输出
		System.out.println("排序后数组为:"+Arrays.toString(nums));
		
		//获得具有从键盘上接收数据的能力
		Scanner input=new Scanner(System.in);
		System.out.println("请输入一个正整数:");
		int find=input.nextInt();
		
		//用二分查找法判断已经排好序的数组中是否包含输入要查找的数
		//将当前数列中mid= (最大索引+最小索引)/2
		//如果find>nums[mid],下次(最大索引+mid+1)/2
		//如果find<nums[mid],下次(mid-1+最小索引)/2
		int index=Arrays.binarySearch(nums,find);
		if (index>=0) {
			System.out.println("数组中包含要查找的数:"+find+",它在数组中位置为:"+index);
		}else {
			System.out.println("数组中查无此数!");
		}
		
		//声明一个数组,给数组统一赋值
		int[] nums2=new int[5];
		Arrays.fill(nums2, 6);
		System.out.println("数组为:"+Arrays.toString(nums2));
	}

题目:随机生成一个两位数,从键盘上接收你猜的数,如果猜对了,就不用再猜,如果猜错了,告诉猜大了,还是猜小了,然后接着猜,直到猜对了就不用再猜?

	注意://生成随机两位数
	int num=(int)(Math.random()*90+10);

二维数组

1.一维数组

在内存开辟一段连续的空间,每个空间存一个数.

2.二维数组

在内存开辟一段连续的空间,每个空间存一个一维数组.

n维数组

在内存开辟一段连续的空间,每个空间存一个(n-1)维数组.

3.二维数组的特征:

  • 1:二维数组也是一种变量,也是一种引用数据类型.
  • 2:二数组由四个组成部分:数组名,数据类型,元素(一维数组),索引(下标,二维数组的索引, 每个空间中一维数组的索引).
  • 3:同一个二维数组中,元素的数据类型相同的;不同的二维数组数据类型可以是java中任意类型.
  • 4:二维数组的索引从0开始,且每个空间的一维数组的索引也是从0开始.
  • 5:访问二数组中某个空间元素:数组名[二维数组的索引],如果要访问二维数组中每个空间一维数组中每个值:数组名[二维数组的索引][一维数组的索引]
  • 6:二维数组一但分配了空间,它的长度是固定的.
  • 7:二维数组的长度:数组名.length
  • 8:二维数组的索引范围在:0~数组名.length-1
    数组的索引如果超过范围报:ArrayIndexOutOfBoundsException
  • 9:二维数组只要分配空间就可以使用.
  • 10:二维数组如果分配空间后,不赋值有默认值,都是null.
    二维数组中每个一维数组如果分配了空间不赋值:
   		String类型数组,默认值null
   		int类型数组,默认值0
   		double类型数组,默认值0.0
   		char类型数组,默认值/u0000,在window系统上看着像空格
   		boolean类型数组,默认值false
  • 11:二维数组如果直接输出,输出的是内存地址.

4.二维数组的使用

4.1:二维数组的声明的语法:

		数据类型[][] 数组名;(推荐)
		数据类型 数组名[][];
		eg://声明二维数组
		  String[][] studentNames1;
		 int studentAges1[][];

4.2:二维数组分配空间

二维数组的空间的长度一定要分配,每个一维数组的长度可以统一分 配,也可单独分配(当二维数组中每个一维数组的长度不相同).

4.2.1:对已经声明的二维数组分配空间:

  • 数组名=new 数据类型[二维数组的长度][一维数组的长度]
    (二维数组中每个一维数组的长度相同且固定.)
				eg://对已声明二维数组分配空间
				studentNames1=new String[3][2];
  • 数组名=new 数据类型[二维数组的长度][]
    (二维数组中每具一维数组的长度没分配,可以手动分配)
		//eg:studentAges1=new int[3][];
		//给二维数组的每个一维数组单独分配空间
		//studentAges1[0]就是一维数组
		studentAges1[0]=new int[3];
		studentAges1[1]=new int[2];
		studentAges1[2]=new int[1];

4.2.1:在声明二维数组的同时分配空间的语法

  • 数据类型[][] 数组名=new 数据类型[二维数组的长度][一维数组的长度]
    (二维数组中每个一维数组的长度相同且固定.)
				eg;//声明二维数组的同时分配空间
				String[][] studentNames2=new String[2][3];
  • 数据类型[][] 数组名=new 数据类型[二维数组的长度][]
    (二维数组中每具一维数组的长度没分配,可以手动分配)
		//eg://给二维数组分配空间
		int[][] studentAge2=new int[3][];
		//单独为每一个一维数组分配空间
		studentAge2[0]=new int[1];
		studentAge2[1]=new int[2];
		studentAge2[2]=new int[3];

4.3:二维数组赋值

4.3.1:静态赋值

当数组中元素已知

4.3.1.1:语法
  • 数据类型[][] 数组名=new 数据类型[][]{{值11,值12},{值21}…};

  • 数据类型[][] 数组名={{值11,值12},{值21}…};

   		//eg://声明数组的同时静态赋值
   		String[][] studentNames3=new String[][] {{"黄国栋","赖盛豪"},{"陈健"}};
   		int[][] studentAges3= {{18,16},{15}};

4.3.2:动态赋值

适用于所有情况.

  • 语法:二维数组名[二维索引][一维索引]=值;
		//eg://给数组动态赋值
		studentNames2[0][0]="张三1";
		studentNames2[0][1]="张三2";
		studentNames2[1][0]="李四1";
		studentNames2[1][1]="李四2";

4.4:二维数组遍历

		eg:/*用嵌套for循环遍历*/
		//外层循环遍历二维数组,i二维数组的索引
		for (int i = 0; i < studentNames3.length; i++) {
			//内层循环遍历每个一维数组每个空间,j一维数组的索引
			for (int j = 0; j < studentNames3[i].length; j++) {
				System.out.print(studentNames3[i][j]+",");
			}
			System.out.println();
		}
		
		System.out.println("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$");
		
		/*用嵌套增强版for循环遍历*/
		//外层遍历的二维数组
		for (int[] ages : studentAges3) {
			//内层循环遍历每个一维数组
			for (int a : ages) {
				System.out.print(a+",");
			}
			System.out.println();
		}
		
		System.out.println("---------------------------------------------");
		/*用for循环配合Arrays.toString()历*/
		for (int i = 0; i < studentAges3.length; i++) {
			System.out.println(Arrays.toString(studentAges3[i]));
		}

5.二维数组的练习(杨辉三角)

在这里插入图片描述

	//eg:
	public static void main(String[] args) {
		//获得具有从键盘上接收数据的能力
		Scanner input=new Scanner(System.in);
		System.out.println("请输入杨辉三角行数:");
		int row=input.nextInt();
		if (row>0) {
			//声明一个二维数组存杨辉三角
			int[][] nums=new int[row][];
			
			/*初始化杨辉三角*/
			//外层循环控制行数
			for (int i = 0; i < nums.length; i++) {
				//先给二维数组每个一维数组分配空间
				nums[i]=new int[i+1];
				//内层循环控制一维数组中每个值
				for (int j = 0; j < nums[i].length; j++) {
					//如果是当前行的第一个数或最后一个数,值为1
					if (j==0||j==nums[i].length-1) {
						nums[i][j]=1;
					}else{
						nums[i][j]=nums[i-1][j]+nums[i-1][j-1];
					}
					
				}
			}
			
			//输出杨辉三角
			for (int[] ns : nums) {
				for (int n : ns) {
					System.out.print(n+"\t");
				}
				System.out.println();
			}
		} else {
			System.out.println("你输入的行数有误!");
		}
	}

6.(扩展)文档注释

/**注释内容 */,只能用类,方法成员变量的前面.

6.1:解释说明作用

说明这个类,这个方法,这个变量的作用.
在这里插入图片描述

6.2:根据文档注释生成javadoc文档

生成javadoc文档:package explore中选中项目-》鼠标右键-》export-》java/javadoc-》下步-》选中要生成文档注释的项目,同时在destination后面选择 文档生成的目的地-》下一步,下一步-》在vm option选择下写字符编码-encoding UTF-8 -charset UTF-8 -》下一步,点完成。

6.3:方便调用时说明.

7.(扩展)代码出错

java中运行出错叫异常,bug,调试错误叫debug.

  • 1:代码一写完,编辑器就报红色X或者一条红色线,也编译出错.
    原因:代码语法有问题或者标点符号有问题.
  • 2:代码写完后编辑器不报错,但是运行后报错或者输出的结果不是想要的结果.
    原因:程序代码逻辑写得有问题.
  • 3:程序调试(debug):解决运行出错.
    • 3.1:代码调试:
      原理:代码从main方法开始由上到下执行.
      做法:在认为出错的地方输出一条语句.
      System.out.println();
    • 3.2:断点调试:
      作用:调试bug;观察代码执行流程.
      步骤:
      3.2.1:在认为在错误的代码前设置断点.
      3.2.2:启动调试运行.(虫子按纽)
      3.2.3:程序执行到断点会停止下来,让你一步一步执行,观察代码执行流程以及变量变化.
      按F5:单步跳入,跳转到代码的底层去执行.
      按F6:单步跳过,执行完当前行的代码,再执行下一行代码
      3.2.4:通过观察代码执行流程和变量变化,找到错误的地方,解决bug.
      3.2.5:取消断点.

个人笔记,思路,仅供参考

已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 游动-白 设计师:白松林 返回首页