数组

最新推荐文章于 2022-08-29 10:19:35 发布

yiiyyy

最新推荐文章于 2022-08-29 10:19:35 发布

阅读量201

点赞数

本文链接：https://blog.csdn.net/weixin_44651031/article/details/96427681

版权

1.Eclipse的使用
1.1：创建Java工程：
第一种：package explorer窗体空白地方右键-》New-》Java proJect-》Project Name：写工程名-》finish。工程名采用帕斯卡命名法。
第二种：菜单栏选File-》New-》Java proJect-》Project Name：写工程名-》finish。工程名采用帕斯卡命名法。
第三种：工具栏New-》Java proJect-》Project Name：写工程名-》finish。工程名采用帕斯卡命名法。

1.2：包：管理Java类，解决不同包中类名重名问题。
包名：域名.公司名/组织名.项目名.架构名。包名全小写
eg:com.qf.day6.demo1
1.2.1：创建名
第一种：创建包：选中项目src目录-》右键-》New-》package-》包名-》finish
第二种：创建类的同时创建包：选中项目src目录-》右键-》New-》class-》Package 中写包名，再在name后面写类名

1.3：创建类：
第一种：创建类的同时创建包：选中项目src目录-》右键-》New-》class-》Package 中写包名，再在name后面写类名
第二种：创建类：选中src下包名-》右键-》New-》class-》在name后面写类名

2.数组：在内存中开辟一段连续的空间存值。
2.1：数组有四个组成部分：数组名，数据类型，元素，索引（下标，从0开始）；
2.2：数组属于引用数据类型。
2.3：同一个数组中数据类型相同，不同的数组数据类型可以是任意的。
2.4：数组一但分配空间，它的长度是固定不变。获得数组的长度：数组名.length
2.5：通过索引访问数组中每个空间的元素：数组名[索引]
数组中索引的范围:0到数组的长度-1.
数组使用时如果索引超过范围会报ArrayIndexOutOfBoundsException
2.6: 数组不赋初值有默认值：String null
int 0
double 0.0
char window系统下默认是空格
boolean false
2.7:数组直接输出，输出的是内存地址。

3.数组的声明，分配空间，赋值，使用
3.1：声明数组的语法：数据类型[] 数组名；(推荐)
数据类型数组名[]；

	eg://声明数组
		String[] studentNames;
		int studentAges[];

3.2：给数组分配空间语法：
3.2.1：分配空间：数组名=new 数据类型[数组长度];

		eg：//给数据分配空间
			studentNames=new String[3];
			studentAges=new int[3];

3.2.2：声明数组的同时分配空间：数据类型[] 数组名=new 数据类型[数组长度];
数据类型数组名[]=new 数据类型[数组长度];
eg://声明数组的同时分配空间

double[] studentHeight=new double[3];

3.3：给数组赋值
3.3.1：静态赋值：当数组中元素已知时就用静态赋值
3.3.1.1：在声明数组的同时给数组分配空间和赋值：
数据类型[] 数组名=new 数据类型[]{值1，值2，…};
eg://静态赋值：声明数组且分配空间和赋值

String[] stuNames=new String[] {"张三","李四","王五"};

3.3.1.2：在声明数组的同时给数组分配空间和赋值：
数据类型[] 数组名={值1，值2，…};
eg://静态赋值：声明数组且分配空间和赋值
int stuAges[]= {18,19,20};

3.3.2：动态赋值：适用于大部分情况
语法：数组名[索引]=值；
eg://动态赋值

			studentNames[0]="aa";
			studentNames[1]="bb";
			studentNames[2]="cc";

3.4：访问数组
3.4.1：用for循环访问数组
eg://访问数组中元素

	for (int i = 0; i < studentNames.length; i++) {
		System.out.println(studentNames[i]);
	}

3.4.2：用增强版的for循环（foreach循环/变态for循环）：只能用来遍历数组/集合
遍历：一个一个的访问数组中每个元素
语法：for(数据类型每个元素的别名:数组名/集合名){
}

eg://访问数组中元素
	for (String s: stuNames) {
		System.out.println(s);
	}

4.n维数组：数组中每个元素是n-1维数组。

5.二维数组：数组中每个元素是一个一维数组。
5.1：二维是一个引用数据类型
5.2：二维数组的组成：数据类型，数组名，元素（数组），索引（二维数组索引，一维数组索引）
5.3：同一个二维数组，数组中每个元素类型相同；不同数据，数据类型可以任意。
5.4：二维数组的空间一但分配，长度固定不变；但是二维数组中每个一维数组的长度不固定。
5.5：二维数组的每个空间访问：二维数组名[二维数组索引]
二维数组中每个空间的一维数组的每个元素访问：二维数组名[二维数组索引][一维数组索引]
二维数组的索引与一维数组的索引都从0开始，范围[0,长度-1]
5.6:二维数组不赋初值有初值，初值与一维数组的初值相同。

6.二维数组的使用
6.1：声明二维数组的语法：数据类型[][] 数组名；
数据类型数组名[][]；
eg://声明二维数组

		String[][] studentNames;
		int studentAges[][];

6.2：给二维数组分配空间：
6.2.1：给二维数组分配空间：数组名=new 数据类型[二维数组的长度][一维数组的长度];
6.2.2：给二维数组分配空间：数组名=new 数据类型[二维数组的长度][];
数组名[二维数组的索引]=new 数据类型[一维数组的长度]
6.2.3：在声明数据的同时分配：
数据类型[][] 数组名=new 数据类型[二维数组的长度][一维数组的长度];
6.2.4:在声明数据的同时分配：
数据类型[][] 数组名=new 数据类型[二维数组的长度][];
数组名[二维数组的索引]=new 数据类型[一维数组的长度]

	eg://给二维数组分配空间	
	studentNames=new String[2][4];
	
	//给二维数组分配空间
	studentAges=new int[3][];
	studentAges[0]=new int[3];
	studentAges[1]=new int[4];
	studentAges[2]=new int[5];
	
	//声明数组的同时分配空间
	double[][] studentHeight=new double[3][4];
	
	//声明数组的同时分配空间
	double[][] studentWeight=new double[3][];
	studentWeight[0]=new double[2];
	studentWeight[1]=new double[4];
	studentWeight[2]=new double[3];

6.3:给二维数组赋值：
6.3.1：二维数组的静态赋值：数组中元素已知
6.3.1.1：二维数组声明和分配空间及静态赋值：
数据类型[][] 数组名=new 数据类型[][]{{值1，值2},{值1，值2},…};
6.3.1.2：数据类型[][] 数组名={{值1，值2，值3},{值1，值2},…};

		eg：//给二维数组静态赋值
	String[][] stuNames2=new String[][] {{"aa","bb"},{"cc","dd","ee"}};
	
	//给二维数组静态赋值
	int[][] stuAges2= {{11,12},{13,14,15},{32,22,44}};

6.3.2：二维数组的动态赋值：
数据名[二维数组的索引][一维数组的索引]=值；

eg://给数组动态赋值
	studentNames[0][0]="张三1";
	studentNames[0][1]="张三2";
	studentNames[0][2]="张三3";
	studentNames[0][3]="张三4";
	studentNames[1][0]="李四1";
	studentNames[1][1]="李四2";
	studentNames[1][2]="李四3";
	studentNames[1][3]="李四4";

6.4：遍历二维数组：
6.4.1：嵌套for循环遍历

		eg://遍历数组,外层循环遍历二维数组
	for (int i = 0; i < stuNames2.length; i++) {
		System.out.println("输出第"+(i+1)+"个班级姓名");
		//内层循环遍历二维数组的每个元素即一维数组
		for (int j = 0; j < stuNames2[i].length; j++) {
			System.out.print(stuNames2[i][j]+"\t");
		}
		//输完一个班的姓名换行
		System.out.println();
	}

6.4.2：嵌套foreach循环遍历

eg://遍历数组,外层循环遍历二维数组
	for(String[] ss1:studentNames) {
		//内层循环遍历二维数组的每个元素即一维数组
		for (String s2:ss1) {
			System.out.print(s2+"\t");
		}
		//输完一个班的姓名换行
		System.out.println();
	}

7.算法：
7.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 = 0; 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);
}

7.2:冒泡排序：每轮两个相邻的数两两相比，互换位置，比出最大的数，然后下一轮再比较出剩下数中最大数。

	eg:public static void main(String[] args) {
	//准备一个数组
	int[] nums= {5,8,1,7,6,3};
	
	/*冒泡排序*/
	//外层循环控制比较的轮数
	for (int i = 0; i < nums.length-1; i++) {//i=1
		//内层循环控制比较的次数
		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+"\t");
	}
}

8.(扩展)数据的工具类：Arrays
8.1:将数组转换为字符串的语法：Arrays.toString(数组名);
8.2：将数组进行升序排序的语法：Arrays.sort(数组名);
8.3：对已排安序的数组进行二分查找法：Arrays.binarySearch(数组名, 要查找的数);
8.4：将原数组指定的长度复制到新数组中：数据类型[] 新数组名=Arrays.copyOf(原数组, 长度);
8.5: 将原数组从指定起始位置复制指定的终止位置,包头不包尾:
数据类型[] 新数组名=Arrays.copyOfRange(nums, 1, 4);

eg:public static void main(String[] args) {
	//准备一个数组
	int[] nums= {5,8,1,7,6,3};
	
	//将数组转换为字符串
	String s1=Arrays.toString(nums);
	System.out.println("排序前："+s1);
	//将数组进行升序排序
	Arrays.sort(nums);
	//排序后
	System.out.println("排序前："+Arrays.toString(nums));
	//对已排序的数组进行二分查找
	int index=Arrays.binarySearch(nums, 4);
	if (index>=0) {
		System.out.println("数组中包含数字4");
	}else {
		System.out.println("数组中不包含数字4");
	}
	//将原数组指定的长度复制到新数组中
	int[] count1=Arrays.copyOf(nums, 3);
	System.out.println("新数组为:"+Arrays.toString(count1));
	
	//将原数组从指定起始位置复制指定的终止位置,包头不包尾
	int[] count2=Arrays.copyOfRange(nums, 1, 4);
	System.out.println("新数组为："+Arrays.toString(count2));
}

9.导入项目到eclipse:package explorer窗体空白地方右键-》import-》General下Existing project into workspace-》next->browser找到要导入的项目-》finish.

10.（扩展）可变参数：参数可以由0个到多个参数组成。数据类型…变量名。
10.1：可变参数在方法中可以直接当作数组来用。
10.2：可变参数由0个到多个参数组成。
10.3：可以参数的实参可以直接传递一个数组。
10.4：一个方法中如果有可变参数，也有其他参数，可变参数只能作为方法的最后一个参数。

eg:/**
 * 可变参数
 * @author sx
 * @version 1.0 2019年6月25日
 */
public class VariableParameter {

	/**
	 * 程序的入口方法
	 * @param args
	 */
	public static void main(String[] args) {
		//准备一个数组
		double[] count= {1,2,3,4};
		//调用有返回值的方法
		double result=add("aa",count);
		System.out.println("和为："+result);
		//调用有返回值的方法
		double result2=add("sx",1,1,3);
		System.out.println("三数之和为："+result2);
	}
	
	/**
	 * 计算几个数之和的方法
	 * @param num1 可变参数
	 * @return double
	 */
	public static double add(String uname,double...num1) {
		//声明一个变量存总和
		double sum=0;
		for (int i = 0; i < num1.length; i++) {
			sum=sum+num1[i];
		}
		return sum;
	}
}

11.(扩展)用文档注释生成api文档：在package explorer窗体选中项目名右键-》Export-》java下 Javadoc-》next-》将要生成api文档的项目前面打勾，再在Destination后面选择文档生成的地方-》next-》next-》在VM options下面写-encoding utf-8 -charset utf-8 -》finish.

yiiyyy

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
数组

1.Eclipse的使用1.1：创建Java工程：第一种：package explorer窗体空白地方右键-》New-》Java proJect-》Project Name：写工程名-》finish。工程名采用帕斯卡命名法。第二种：菜单栏选File-》New-》Java proJect-》Project Name：写工程名-》finish。工程名采用帕斯卡...
复制链接

扫一扫