目录

1.数组基础

1.1. 引入数组

1.2 数组的初始值与创建

1.3 数组练习

2. 数组扩容

2.1 自定义数组扩容

2.2 系统定义的数组扩容方法

3.数组中的方法封装

3.1 关于方法的传参

3.2 可变参数

3.3 方法的返回值返回数组

4.排序

4.1排序基础

4.2冒泡排序

4.3选择排序

4.4插入排序

4.5系统提供的排序

4.6一维数组练习(斐波拉契数列)

5.二维数组

5.1基本概述

​5.2二维数组的创建

5.3二维数组的赋值与取值

5.4二维数组的遍历

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

1.数组基础

1.1. 引入数组

引言：为什么使用数组？
        需求： 请存储全班的成绩
        根据变量存： int score1=66;  int score2=68;  int score3=77; ...
        弊端： 60个学生成绩，则需要60个变量，冗余太多
假设每个同学的成绩都+1分？  如何处理？
        弊端：每个变量，都需要做+1操作，不方便管理
引入数组：
        概念：一组连续的内存空间，用于存储相同类型的元素
        数组特点：类型相同，长度固定

===========================案例1============================
public class ArrayTest1 {
	public static void main(String[] args) {
		//需求： 请存储全班的成绩
		//数组是引用类型：往往需要先开辟空间，然后再存值
		int[] arr = new int[3]; //定义3个int类型的数组空间  
		//通过下标给数组元素赋值(存值)与取值   下标范围：0~长度-1
		arr[0] = 66;   //赋值
		arr[1] = 68;
		arr[2] = 77;
		//arr[3] = 99;  //ArrayIndexOutOfBoundsException: 数组越界异常
		//打印输出的优化---循环打印(遍历)
		System.out.println("数组长度："+arr.length);  //3
		for(int i=0;i

===========================案例2============================
//案例2：给每个学生成绩都+1
public class ArrayTest2 {
	public static void main(String[] args) {
		int[] arr = new int[3]; //定义3个int类型的数组空间  
		//通过下标给数组元素赋值(存值)与取值   下标范围：0~长度-1
		arr[0] = 66;   //赋值
		arr[1] = 68;
		arr[2] = 77;
		for(int i=0;i

1.2 数组的初始值与创建

=======================数组的初始值========================
//数组的初始值问题：
public class Test1 {
	public static void main(String[] args) {
		int[] a = new int[3];  //创建3个存int值的空间
		System.out.println(a[0]);  //0   int类型初始为0
		
		double[] b = new double[3];
		System.out.println(b[0]);  //0.0 double类型初始值	
		
		boolean[] c = new boolean[3];
		System.out.println(c[0]);  //false
		
		char[] d = new char[3];
		System.out.println(d[0]);  //码值为0对应的字符
		
		String[] e = new String[3];
		System.out.println(e[0]);  //String类型初始为 null
	}
}

=======================数组的创建========================

//数组的创建:
public class Test2 {
	public static void main(String[] args) {
		//----------动态赋值(有了空间，再一个个赋值)-----------
		//1.先声明，后创建空间
		int[] a;
		a = new int[3];
		
		//2.声明的同时，创建空间-（常用）
		int[] c = new int[3];
		
		//------------静态赋值(有了空间的同时赋值)-------------
		//3.创建空间的同时进行赋值
		int[] d = new int[]{1,3,5}; //数组的长度，由值的个数决定
		
		//4.创建空间的同时进行赋值（简化版-常用）
		int[] e = {1,3,5};
	}
}

1.3 数组练习

=======================案例1========================
//案例1：给定一个整数数组，统计数组元素的平均分
//分析：先遍历数组的所有元素； 再求和   在除以长度
public class Test1 {
	public static void main(String[] args) {
		int[] a = {68,75,83,63};
		double sum = 0;  //求和，初始为0
		int len = a.length;
		for(int i=0;i 
=======================案例2========================
//案例2：给定一个整数数组，输入一个整数n，如果在数组中存在，则输出下标；否则打印-1
//例如：      7   3  8  2  6
//录入1   -1     录入8   2
public class Test2 {
	public static void main(String[] args) {
		int[] a = {7,3,8,2,6};
		Scanner sc = new Scanner(System.in);
		System.out.print("请输入一个值:");
		int n = sc.nextInt();
		int index = -1;  //记录下标
		for(int i=0;i
 
2. 数组扩容 
 
 
数组扩容：
         从前面的数组特点中可知，数组的长度是固定的
         如果需要给数组扩容的话，需要重新创建空间
 扩容思路是： 创建一个比原数组更大的空间，再将原数组元素拷贝进来
 
 
2.1 自定义数组扩容 
public class Test1 {
	public static void main(String[] args) {
		int[] src = {1,3,5};
		int[] dest = new int[src.length+3];  //定义目标数组，比原数组空间要大
		for(int i=0;i返回扩容数组
	}
}
 
2.2 系统定义的数组扩容方法 
 
=================系统提供的扩容方法调用==================
public class Test2 {
	public static void main(String[] args) {
		int[] src = {1,3,5};  //原数组
		
		//-------扩容方式1-------
		//int[] dest = new int[src.length+3];  //目标数组
		//参数1：原数组  2.原的起始位置-一般为0   
		//3.目标数组   4.目标起始位置-一般为0    5.拷贝长度--一般是原数组长度
		//System.arraycopy(src, 0, dest, 0, src.length);
		
		//------扩容方式2------
		//参数1：原数组    参数2：要扩容的长度    返回值：扩容的目标数组
		int[] dest = Arrays.copyOf(src, src.length+3);
		
		for(int i=0;i 
3.数组中的方法封装 
3.1 关于方法的传参 
=====================传基本类型(值传递)=====================

//案例：通过方法调用，将变量以参数传入，在方法实现中改变参数值；
//在main方法打印该变量,看该变量的值是否进行改变?
//值传递： 形参的改变，不会影响实参
public class Test1 {
	public static void main(String[] args) {
		int a = 3;
		change(a);
		System.out.println("最终结果:"+a);  //3
	}

	private static void change(int a) {
		a = 5;
	}
}
 
 
=====================传引用类型(地址传递)=====================
//案例2：将数组以参数传递，在方法实现中改变数组的元素
//在main方法中打印数组，查看是否改变?
//地址传递：形参的改变会影响实参
public class Test2 {
	public static void main(String[] args) {
		int[] a = {1,3,5};
		change(a);
		System.out.println(a[0]);  //9
	}

	private static void change(int[] a) {
		a[0] = 9;
	}
}
 
 
 
3.2 可变参数 
//可变参数：
//1，先从普通数组参数进行演变
//案例：通过方法封装，来打印数组
//可变参数： 可以接收可变化的实参   格式： int... a
public class Test3 {
	public static void main(String[] args) {
		//int[] a = {1,3,5};
		//printArray(new int[]{1,3,5});  //打印数组
		
		printArray(1,3,5);  //本质传入new数组
	}

	//可变参数---本质：数组   使用反编译工具，查看
	private static void printArray(int...a) {  
		for(int i=0;i
 
3.3 方法的返回值返回数组 
//案例：在main方法中，传入一个原数组；在方法实现中对原数组进行扩容；
//且将扩容的数组返回
public class Test1 {
	public static void main(String[] args) {
		int[] a = {1,3,5};
		int[] b = copyOf(a,a.length+3);
		
		//在Arrays类中已经写好了数组的打印： 
		//toString: 将数组转字符串返回
		System.out.println(Arrays.toString(a));  //1,3,5
		
		System.out.println(Arrays.toString(b));  //1,3,5,0,0,0
	}


	private static int[] copyOf(int[] a,int len) { //输入原数组，及扩容长度
		//创建一个扩容数组
		int[] b = new int[len];
		//将原数组循环拷贝的扩容数组中
		for(int i=0;i
 
4.排序 
4.1排序基础 
=====================排序基础======================
//案例1：交换两个变量的值；例如：a=3,b=5 交换后：a=5,b=3
//分析：借一个变量
public class SortBasic {
	public static void main(String[] args) {
		int a = 3;
		int b = 5;
		System.out.println("交换前: a="+a+";b="+b);
		//注意：赋值操作，右边看成值，左边看成变量
		int t = a; //t=3
		    a = b; //a=5
		    b = t; //b=3
		System.out.println("交换后: a="+a+";b="+b);
	}
}
 
4.2冒泡排序 
 
//冒泡排序：相邻两数两两比较，大的放右边，比较完一轮后，最右边的数为最大值；以此类推共比较(长度-1)轮
public class MaoPao {
	public static void main(String[] args) {
		int[] a= {3,1,5,2,9,7,4,6};
		for(int i=0;ia[j+1]) {
					int t=a[j];
					a[j] = a[j+1];
					a[j+1] = t;
				}
			}
			//System.out.println("第"+(i+1)+"轮："+Arrays.toString(a));
		}
		System.out.println("排序后:"+Arrays.toString(a));
	}
}
 
4.3选择排序 
 
 
工作原理：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。
 
 
​
 
 
 
//选择排序：假设第一个元素为最小，依次与后面元素比较；比较完一轮确定第一个位置元素是最小的；
//       假设第二个元素最小，依次与后面元素比较，以此类推；共比较(长度-1)轮
public class XuanXe {
	public static void main(String[] args) {
		
		int[] a = {3,1,5,2,9,7,6,4};
		
		for(int i=0;i1;i++) {   //外层代表轮数
			for(int j=1+i;j//内存代表每轮比较次数
				if(a[i]>a[j]) {
					int t = a[i];
					a[i] = a[j];
					a[j] = t;
				}
			}
			//System.out.println("第"+(i+1)+"轮："+Arrays.toString(a));
			
		}
		System.out.println("排序后："+Arrays.toString(a));
	}
}		
 
 
4.4插入排序 
​
 
4.5系统提供的排序 
 
 
======================系统提供的排序======================

//系统提供的排序方法(系统写好了具体实现，我们只需要调用即可)
public class SystemSort {
	public static void main(String[] args) {
		int[] a = {3,1,5,2,6};
		Arrays.sort(a);  //系统提供的升序排列
		System.out.println(Arrays.toString(a));
		
		//假设系统提供升序排列后，我们需要降序排列，如何做？
		//分析：收尾交换，交换长度/2次
		int len = a.length;
		for(int i=0;i 
 
4.6一维数组练习(斐波拉契数列) 
 
 
======================一维数组练习(斐波拉契数列)======================
//思考： 之前使用过的斐波拉契数列，使用数组来操作：
//0  1  1  2  3   5  8  13 ... 
//规则：第一项为0，第二项为1，后面的第三项等于第一项+第二项
//分析： 将斐波拉契数列看成是数组的元素，循环遍历，并定好规则即可
public class FeiBo {
	public static void main(String[] args) {
		System.out.print("请输入项数:");
		Scanner sc = new Scanner(System.in);
		int len = sc.nextInt();  //项数，相当于数组中长度
		int[] a = new int[len];
		for(int i=0;i 
 
5.二维数组 
5.1基本概述 
 
 
二维数组：一维数组的一维数组，可以看成一维数组中的元素又是一个一维数组
 
 
5.2二维数组的创建 
======================二维数组的创建======================
//二维数组的创建:
public class Test3 {
	public static void main(String[] args) {
		//----动态赋值-----
		//1.先声明再创建空间
		int[][] a;
		a = new int[2][3];
		
		//2.声明的同时创建空间 (常用)
		int[][] b = new int[2][3];
		
		//3.创建空间的同时给定行长度
		int[][] c = new int[2][];
		c[0]=new int[]{3,5,8};
		c[1]=new int[]{1,5,7}; 
		
		//----静态赋值-----
		//4.创建空间的同时进行赋值
		int[][] d = {{1,2,5},{4,6,8}};  //二行三列的二维数组
		
		//注意：第三种和第四种可以指定不规则的列（了解），循环遍历是一样的   例如：下面静态赋值的操作: 
		int[][] e = {{1,2,5},{4,6}};
		for(int i=0;i 
5.3二维数组的赋值与取值 
======================二维数组的赋值与取值======================
public class Test1 {
	public static void main(String[] args) {
		//二维数组的操作：可以看成行和列的操作,长度由行长度和列长度，下标有行下标和列下标
		int[][] a = new int[2][3];  //2是行长度  3是列长度
		//赋值
		a[0][0] = 4;  //二维数组赋值    行下标范围：0~行长度-1   列下标范围：0~列长度-1
		a[0][1] = 2;
		a[0][2] = 6;
		//a[0][3] = 7;  //列下标溢出
		a[1][0] = 8;
		//取值
		System.out.println(a[0][0]+"--"+a[0][1]+"--"+a[0][2]);
		System.out.println(a[1][0]+"--"+a[1][1]+"--"+a[1][2]);
		//System.out.println(a[2][0]); //行下标溢出
		//注意： 一般二维数组的排列，往往人为的设计成行和列的排列，方便我们操作
	}
}
 
5.4二维数组的遍历 
======================二维数组的遍历======================
//二维数组的循环遍历
public class Test2 {
	public static void main(String[] args) {
		//二维数组的操作：可以看成行和列的操作,长度由行长度和列长度，下标有行下标和列下标
		int[][] a = new int[2][3];  //2是行长度  3是列长度
		//赋值
		a[0][0] = 4;  //二维数组赋值    行下标范围：0~行长度-1   列下标范围：0~列长度-1
		a[0][1] = 2;
		a[0][2] = 6;
		//a[0][3] = 7;  //列下标溢出
		a[1][0] = 8;
		//循环遍历
		for(int i=0;i
 
5.5二维数组的练习(杨辉三角) 
 
//杨辉三角
public class Test1 {
	public static void main(String[] args) {
		System.out.print("请输入杨辉三角的行：");
		Scanner sc = new Scanner(System.in);
		int row = sc.nextInt();
		int[][] a = new int[row][row];
		for(int i=0;i