Java入门之数组

最新推荐文章于 2024-05-28 21:00:23 发布

侵蚀Emotion

最新推荐文章于 2024-05-28 21:00:23 发布

阅读量115

点赞数

文章标签：排序算法算法

本文链接：https://blog.csdn.net/weixin_45232963/article/details/125111970

版权

一、数组

1.作用

作用:
    存放一组数据类型相同的数

2.要求

要求:
    数组长度不变

3.长度

长度:
    数组存放数据的个数

4.元素

元素:
    数组中存放的数据,一个数据称为一个元素

5.下标(索引值)

下标:元素(数据)在数组中的位置,从0开始,到数组长度-1

6.数组的声明

声明:
    数据类型[] 数组名;

//数组的声明
double[] scores;

7.数组的赋值

1)动态

创建方式1:
        数组名 = new 数据类型[数组长度];
        注意:基本数据类型默认用0填充,引用数据类型默认用null填充

//动态创建1
scores = new double[70];

创建方式2:
        数组名 = new 数据类型[]{元素1,元素2,...};
        注意:这种方式创建的数组,数组长度就是创建时元素的个数

//动态创建2
scores = new double[] {60,95,99,5};

2)静态

创建方式:
        数据类型[] 数组名= {元素1,元素2,...};
        注意:这种方法必须将声明与赋值在同一行

//数组的静态创建
String[] names = {"张三","李四","王麻子"};

8.数组的使用

1)获取长度

语法:
    数组名.length

代码

public class Demo01 {
	public static void main(String[] args) {
		//静态创建一个数组
		int[] nums = {21,13,8,34,5,55,89};
		
		//获取数组长度
		int length = nums.length;
		System.out.println("数组长度为:"+length);
	}
}

结果

2)修改

语法:
    数组名[下标] = 新值;

代码

public class Demo02 {
	public static void main(String[] args) {
		//静态创建一个数组
		int[] nums = {21,13,8,34,5,55,89};
		System.out.println("修改前:"+nums[4]);
		//修改元素
		nums[4] = 144;
		System.out.println("修改后:"+nums[4]);
	}
}

结果

3)查询

语法:
    数组名[下标];

代码

public class Demo03 {
	public static void main(String[] args) {
		//静态创建一个数组
		int[] nums = {21,13,8,34,5,55,89};
		//查询下标为4的元素
		System.out.println("下标为4:"+nums[4]);
	}
}

结果

4)遍历

遍历:将数组中的元素挨个取出
注意:下标不能越界,如果越界会出现数组下标越界异常

遍历方式1:
         for(int i = 0; i < 数组长度 ; i ++){
            System.out.println(数组名[i]);
         }

代码

public class Demo04 {
	public static void main(String[] args) {
		//静态创建一个数组
		int[] nums = {21,13,8,34,5,55,89};
		//遍历方式1
		for (int i = 0; i < nums.length; i++) {
			System.out.println(nums[i]);
		}
	}
}

结果

可以添加if语句,改变输出格式

代码

public class Demo05 {
	public static void main(String[] args) {
		//静态创建一个数组
		int[] nums = {21,13,8,34,5,55,89};
		//遍历方式1
		System.out.print("数组为:[");
		for (int i = 0; i < nums.length; i++) {
			if (i==nums.length-1) {
				System.out.print(nums[i]+"]");
			}else {
				System.out.print(nums[i]+",");
			}
		}
	}
}

结果

遍历方式2:
         foreach
         语法:
             for(遍历出的数据类型 变量名:要遍历的数组名){
                System.out.println(变量名);
             }
         变量名:记录的是便出的数据

代码

public class Demo06 {
	public static void main(String[] args) {
		//静态创建一个数组
		int[] nums = {21,13,8,34,5,55,89};
		//遍历方式2
		for (int i : nums) {
			System.out.println(i);
		}
	}
}

结果

5)查找

查找数组中是否存在指定的值
        1)遍历数组
        2)使用数组中遍历时得到的元素与指定数据进行比较

代码

使用foerach遍历数组时,只能将遍历到的数据与查找的数据进行比较,判断是否存在
如果存在,不能输出查找数据在数组中的下标

public class Demo07 {
	public static void main(String[] args) {
		//静态创建一个数组
		int[] nums = {21,13,8,34,5,55,89};
		int n = 55;
		find(nums, n);
	}
	public static void find(int[] nums,int num) {
		/**
		 * 查找数组中是否存在指定的值
         *		1)遍历数组
         *		2)使用数组中遍历时得到的元素与指定数据进行比较
		 */
		//1)遍历数组
		for (int i : nums) {
			//2)判断数组遍历时得到的元素与指定数据是否相等
			if (i == num) {
				System.out.println("该元素存在");
				return;
			}
		}
		System.out.println("该元素不存在");
	}
}

结果

使用for循环遍历数组时,使用的是数组中下标所在的数组与查找的数据进行比较
如果存在可以返回查找数据在数组中的下标

public class Demo08 {
	public static void main(String[] args) {
		//静态创建一个数组
		int[] nums = {21,13,8,34,5,55,89};
		int n = 3;
		find(nums, n);
	}
	public static void find(int[] nums,int num) {
		/**
		 * 查找数组中是否存在指定的值
         *		1)遍历数组
         *		2)使用数组中遍历时得到的元素与指定数据进行比较
		 */
		//1)遍历数组
		for (int i = 0; i < nums.length; i++) {
			//判断
			if (num == nums[i]) {
				System.out.println("该元素存在,下标为"+i);
                return;//结束方法
			}
		}
		//不存在则输出-1
		System.out.println("不存在");
	}
}

结果

6)拷贝

作用:将数组A中的元素复制到数组B中
步骤:
    1)创建数组A
    2)创建数组B,数组B的长度就是数组A的长度
    3)循环遍历数组A中的数据,并一一取出
    4)将取出的数据赋值给数组B中的对应位置

代码

public class Demo09 {
	public static void main(String[] args) {
		//静态创建一个数组
		int[] aNums = {21,13,8,34,5,55,89};
		int[] bNums = new int[aNums.length];
		copy(aNums, bNums);
		
	}
	public static void copy(int[] aNums,int[] bNums) {
		/**
		 * 步骤:
		 *		1)有个数组A
		 *		2)创建数组B,数组B的长度就是数组A的长度
		 *		3)循环遍历数组A中的数据,并取出
		 *		4)将取出的数据赋值给数组B中对应位置
		 */
		//3)循环遍历数组A
		System.out.println("数组A:");
		for (int i = 0; i < aNums.length; i++) {
			System.out.println(aNums[i]);
			//4)将取出的数据赋值给数组B中对应位置
			bNums[i]=aNums[i];
		}
		//循环遍历数组B
		System.out.println("数组B:");
		for (int num : bNums) {
			System.out.println(num);
		}
	}
}

结果

7)扩容

作用:将数组A中的数据复制到数组B中,数组B的长度大于数组A的长度
     并且在复制完成后,将数组B复制给数组A

步骤:
    1)创建需要扩容的数组A
    2)创建数组B,数组B的长度大于数组A的长度
    3)循环遍历数组A中的数据,并一一取出
    4)将数组A取出的数据赋值给数组B中对应位置
    5)将数组B赋值给数组A

代码

public class Demo10 {
	public static void main(String[] args) {
		//静态创建一个数组
		int[] aNums = {21,13,8,34,5,55,89};
		int[] bNums = new int[aNums.length+10];
		capacity(aNums, bNums);
		
	}
	public static void capacity(int[] aNums,int[] bNums) {
		/**
		 *步骤:
		 *		1)创建需要扩容的数组A
		 *		2)创建数组B,数组B的长度大于数组A的长度
		 *		3)循环遍历数组A中的数据,并一一取出
		 *		4)将数组A取出的数据赋值给数组B中对应位置
		 *		5)将数组B赋值给数组A
		 */
        System.out.println("数组A旧的长度:"+aNums.length);
		//3)循环遍历数组A
		for (int i = 0; i < aNums.length; i++) {
			//4)将取出的数据赋值给数组B中对应位置
			bNums[i]=aNums[i];
		}
		//将数组B赋值给数组A
		aNums = bNums;
		//循环遍历数组B
		System.out.println("数组B:");
		for (int num : bNums) {
			System.out.println(num);
		}
		//输出长度
		System.out.println("数组A新的长度:"+aNums.length);
		System.out.println("数组B的长度:"+bNums.length);
	}
}

结果

8)可变参数

作用:解决了形参长度固定的问题
语法:
    数据类型...变量名
使用的注意事项:
              1)只能在形参中使用
              2)只能在形参末尾使用
              3)一个方法中只能有一个可变参数

代码

public class Demo01 {
	public static void main(String[] args) {
		sum(21,13,8,34,5,55,89);
		/**
		 * 可变参数的本质就是数组
		 */
		//静态创建一个数组
		int[] nums = {21,13,8,34,5,55,89};
		sum(nums);
	}
	public static void sum(int... nums) {
		int sum = 0;
		for (int i = 0; i < nums.length; i++) {
			sum +=nums[i];
		}
		System.out.println(sum);
	}
}

结果

9.算法相关

算法:将数学公式应用在代码中
作用:提高代码效率

名词:
	空间复杂度
		算法占据内存的大小,越小学好
	时间复杂度
		算法执行代码的时间,越短越好

案例:1~100的和

代码

public class Demo01 {
	public static void main(String[] args) {
		sum01();
		sum02();
		
	}
	public static void sum01() {
		int sum = 0;
		for (int i = 1; i < 101; i++) {
			sum +=i;
		}
		System.out.println("for循环求和:"+sum);
	}
	public static void sum02() {
		/**
		 * 求和公式:(首项+末项)*项数/2
		 */
		int sum = (1+100)*100/2;
		System.out.println("算法求和:"+sum);
	}
}

结果

1)寻找最值

步骤:
    1)创建数组
    2)假设数组中第n个数是最大值
    3)遍历数组,将取出的数据与假设的最大值比较输出
    4)如果遍历出的数据有比假设的最大值大的数据,将这个数

代码

public class Demo01 {
	public static void main(String[] args) {
		/**
		 * 寻找最大值
		 */
		//1)静态创建一个数组
		int[] nums = {21,13,34,5,89,55,8,144,3,1,2};
		//2)假设数组中第0个数是最大值
		int max = nums[0];
		//遍历数组,循环比较
		for (int i = 0; i < nums.length; i++) {
			//判断最大值是否小于数组中遍历出的数据
			if (max<nums[i]) {
				//如果小于,则将它赋值给max
				max = nums[i];
			}
		}
		System.out.println("数组中的最大值是:"+max);
	}
}

结果

2)交换位置

步骤:
    1)创建数组
    2)定义一个中间变量
    3)中间变量接收nums[i]
    4)nums[i]接收nums[i+1]
    5)nums[i+1]接收nums[i]

public class Demo01 {
	public static void main(String[] args) {
		/**
		 * 寻找最大值
		 */
		//1)静态创建一个数组
		int[] nums = {21,13,34,5,89,55,8,144,3,1,2};
		System.out.println("交换前:");
		for (int i : nums) {
			System.out.println(i);
		}
		//遍历数组
		for (int i = 0; i < nums.length-1; i++) {
			/**
			 * 交换位置
			 */
			//判断前一个数是否大于后一个数
			if (nums[i] > nums[i+1]) {
				//定义中间变量
				int temp = nums[i];
				nums[i] = nums[i+1];
				nums[i+1] = temp;
			}	
		}
		//遍历数组
		System.out.println("交换后:");
		for (int i : nums) {
			System.out.println(i);
		}
	}
}

结果

案例:将数组由大到小依次排序

代码

public class Demo02 {
	public static void main(String[] args) {
		/**
		 * 将数组从大到小排序
		 */
		//1)静态创建一个数组
		int[] nums = {21,13,34,5,89,55,8,144,3,1,2};
		
		for (int j = 0; j < nums.length; j++) {
			//定义最大值的下标
			int maxIndex = j;
			//寻找最大值的下标
			for (int i = j; i < nums.length; i++) {
				//将遍历出的数据一一比较
				//如果定义的最大值小于数组中的数
				if (nums[maxIndex] < nums[i]) {
					//将最大值的下标赋给max
					maxIndex = i;
				}
			}
			//如果定义的最大值下标不等于找出的最大值下标
			if (j != maxIndex) {
				//交换位置
				int temp = nums[j];
				nums[j] = nums[maxIndex];
				nums[maxIndex] = temp;
			}
		}
		//遍历输出
		for (int i : nums) {
			System.out.println(i);
		}
	}
}

结果

3)将最值放到数组尾部

冒泡排序

冒泡排序思想:
            对所有相邻数据进行比效，如果是逆顺（a[j]>a[j+1]），则将其交换，达到有序化;

代码

public class MaoPaoSort {
	public static void main(String[] args) {
		/**
		 * 冒泡排序
		 */
		//静态创建数组
		int[] nums = {21,13,34,5,89,55,8,144,3,1,2};
		//排序前遍历数组
		System.out.println("排序前:");
		for (int i : nums) {
			System.out.print(i+" ");
		}
		for (int i = 0; i < nums.length-1; i++) {
			//遍历数组,比较相邻两数的大小关系
			for (int j = 0; j < nums.length-1; j++) {
				//如果前一个数大于后一个数
				if (nums[j]>nums[j+1]) {
					//交换位置
					int temp = nums[j];
					nums[j] = nums[j+1];
					nums[j+1] = temp;
				}
			}
		}
		//遍历数组
		System.out.println("\n排序后:");
		for (int num : nums) {
			System.out.print(num+" ");
		}
	}
}

结果

选择排序

选择排序思想:
            从头至尾扫描序列，找出最大的一个元素，和第一个元素交换
            接着从剩下的元素中找出最大的一个元素，和第二个元素交换
            以此类推,达到有序化

代码

public class ChoiceSort {
	public static void main(String[] args) {
		/**
		 * 选择排序
		 */
		//静态创建数组
		int[] nums = {21,13,34,5,89,55,8,144,3,1,2};
		//排序前
		System.out.println("排序前:");
		for (int num : nums) {
			System.out.print(num+" ");
		}
		//选择排序
		for (int j = 0; j < nums.length; j++) {
			//1)定义要交换的位置
			int index = j;
			//2)定义第一个元素是最大值
			int maxIndex = j;
			//循环遍历数组,找到真正的最大值
			for (int i = j; i < nums.length; i++) {
				if (nums[i]>nums[maxIndex]) {
					//将找出的最大值的下标赋给maxIndex
					maxIndex = i;
				}
			}
			//如果最大值的下标与要交换的位置不同,交换位置
			if (index != maxIndex) {
				//交换位置
				int temp = nums[index];
				nums[index] = nums[maxIndex];
				nums[maxIndex] = temp;
			}
		}
		//排序后
		System.out.println("\n排序后:");
		for (int num : nums) {
			System.out.print(num+" ");
		}
	}
}

结果

10.二维数组

1)作用

作用:
    是将一维数组作为元素存放的数组,称为二维数组

2)声明

声明:
    数据类型[][] 数组名;

3)创建

动态创建:
        数组名 = new 数据类型[二维数组中一维数组的个数][一维数组元素的个数];
        数组名 = new 数据类型[][]{{值1,值2,...},{值3,值4,值5,..},...};

静态创建:
        数据类型[][] 数组名 = {{值1,值2,...},{值3,值4,值5,..},...};

4)使用

使用:
    长度:
        数组名.length
    注意:
        二维数组的长度是其中一维数组的个数
    取值:
        数组名[元素所在的一维数组在二维中的下标][元素在一维数组中的下标]
    改值:
        数组名[元素所在的一维数组在二维中的下标][元素在一维数组中的下标] = 新值;

5)二维数组的遍历

    //遍历二维数组
	for (int i = 0; i < 二维数组长度; i++) {
	    //取出二维数组中的一维数组
		int[] 一维数组名 = 二维数组名[i]; 
		//遍历一维数组
		for (int j = 0; j < 一维数组名; j++) {
			//取出一维数组中的元素
			int 元素名 = 一维数组名[j];
			//打印元素到控制台
			System.out.print(元素名+",");
		}

代码

public class Demo03 {
	public static void main(String[] args) {
        int[][] nums = new int[][] {{1,2,},{3,4,5},{6,7,8,9}};
        //遍历二维数组
		for (int i = 0; i < nums.length; i++) {
			//取出二维数组中的一维数组
			int[] ns = nums[i]; 
			//遍历一维数组
			for (int j = 0; j < ns.length; j++) {
				//取出一维数组中的元素
				int n1 = ns[j];
				//打印元素到控制台
				System.out.print(n1+",");
			}
			//换行便于观察
			System.out.println();
		}
	}
}

结果

6)杨辉三角

杨辉三角
       1
       1  1  
       1  2  1  
       1  3  3  1 
       1  4  6  4  1
       1  5  10 10 5  1

代码

public class YangHuiDemo {
	public static void main(String[] args) {
		int[][]yh = new int[6][6]; 
		//前两行
		yh[0][0]=1;
		yh[1][0]=1;
		yh[1][1]=1;
		//遍历二维数组
		for (int i = 2; i < yh.length; i++) {
			for (int j = 0; j < yh[i].length; j++) {
				//判断对角线元素为1
				if (j==0 || i==j) {
					yh[i][j]=1;
				}else {
                    //上一行正上方的数和前一个数的和
					yh[i][j]=yh[i-1][j]+yh[i-1][j-1];
				}
			}
		}
		//遍历二维数组
		for (int i = 0; i < yh.length; i++) {
			for (int j = 0; j < yh[i].length; j++) {
				System.out.print(yh[i][j]+"\t");
			}
			System.out.println();
		}
	}
}

结果