栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Java入门之数组

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Java入门之数组

目录

一、数组

1.作用

2.要求

3.长度

4.元素

5.下标(索引值)

6.数组的声明

7.数组的赋值

1)动态

2)静态

8.数组的使用

1)获取长度

2)修改

3)查询

4)遍历

5)查找

6)拷贝

7)扩容

8)可变参数

9.算法相关

 1)寻找最值

2)交换位置

3)将最值放到数组尾部

冒泡排序

选择排序

10.二维数组

1)作用

2)使用

3)杨辉三角


一、数组

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)遍历数组
		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)遍历数组
		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) {
		
		//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) {
		
        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() {
		
		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 

结果

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

结果

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/950617.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号