Day05--数组+变量

最新推荐文章于 2024-04-08 09:49:25 发布

北大青鸟码农

最新推荐文章于 2024-04-08 09:49:25 发布

阅读量473

点赞数

分类专栏：数组变量文章标签： java 数组

本文链接：https://blog.csdn.net/weixin_47307932/article/details/111711958

版权

数组同时被 2 个专栏收录

2 篇文章 0 订阅

订阅专栏

变量

1 篇文章 0 订阅

订阅专栏

Day05–数组+变量

一、方法

1.概述

被命名的代码块标志是（）
好处:提高代码的复用性

2.语法

	方法的修饰符 方法的返回值 方法名([参数列表]){
		方法体
	}

3.方法调用流程

在这里插入图片描述

4.使用

1）方法的调用

package cn.tedu.method;
//测试  方法的调用
/*
 * 总结
 * 1.方法什么时候执行？--当被调用时
 * 2.方法定义的语法？--修饰符 返回值 方法名（参数列表）{方法体}
 * */
public class Test02_Method1 {
	public static void main(String[] args) {
		System.out.println(1);
		System.out.println(2);
		//复制一行：ctrl+alt+↓
		//删除一行：ctrl+d
		hello();//调用了指定的方法
		System.out.println(3);
		System.out.println(4);
	}
	//创建方法
	//语法：方法的修饰符 方法的返回值 方法名（参数列表）{方法体}
	public static void hello() {
		System.out.println("hello");
	}
	public static void wow() {	//此方法不调用，故不会被执行，方法被调用了才会被执行
		System.out.println("wow");
	}
}

package cn.tedu.method;
//测试 方法的调用
public class Test4_Method {

	public static void main(String[] args) {
	System.out.println(1);
	System.out.println(2);
	System.out.println(3);
	fun();//调用指定的方法
	System.out.println(4);
	}
	//创建fun()---执行时间节点：是被调用时
	/*语法：
	 * 修饰符  返回值  方法名(【参数】){
        方法体;
	}
	*/
	public static void fun() {
		System.out.println(5);
		System.out.println(6);
	}
}

2）方法的传参

package cn.tedu.method;
//测试  方法的传参调用
public class Test03_Method2 {
	public static void main(String[] args) {
		add(5);//调用方法
		add2(5,10);//TODO 调用方法
		add3(5,10,"tony");//TODO 调用方法
	}
	
	//TODO 创建add(参数类型 参数名)--参数类型必须和5的类型匹配
	public static void add(int i) {
		System.out.println(i*i);
	}
	
	//TODO 创建add2（参数类型 参数名，参数类型 参数名）
	public static void add2(int i,int j) {
		System.out.println(i);
		System.out.println(j);
	}
	
	//TODO 创建add3（参数类型 参数名，参数类型 参数名，参数类型 参数名）	
	public static void add3(int i,int j,String k) {
		System.out.println(i);
		System.out.println(j);
		System.out.println(k);
	}
}

package cn.tedu.method;
// 测试 方法传参
public class Test5_Method {
	public static void main(String[] args) {
		add1(10);//调用了指定的方法
		add2("jack");
		add3(10,5);
		add4(10,5,"jack");
		add5("jack",10,5);
	}
	//TODO 创建方法
			/*语法：
			 * 修饰符  返回值  方法名(参数类型 参数名){
		        方法体;
			}
			//TODO 参数类型 必须和10和4 的类型保持一致
			*/
	//TODO 创建add1(参数类型 参数名)--参数类型必须和整数10的类型匹配
	public static void add1(int x) {
		System.out.println(x);
		System.out.println(x*x);
	}
	//TODO 创建add2(参数类型 参数名)--参数类型必须和字符串jack的类型匹配
	public static void add2(String x) {
		System.out.println(x);
	}
	//TODO 创建add3(参数类型 参数名)--参数类型必须和整数10和5的类型匹配
	public static void add3(int x,int y) {
		System.out.println(x);
		System.out.println(y);
	}
	//TODO 创建add4(参数类型 参数名)--参数类型必须和整数10和5还有字符串jack的类型匹配
	public static void add4(int x,int y,String z) {
		System.out.println(x);
		System.out.println(y);
		System.out.println(z);
		System.out.println(x+y+z);//TODO 加号在这的作用是先求和在拼接字符串
	}
	// 两个字符串都是拼接字符串的作用
	//TODO 创建add5(参数类型 参数名)--参数类型必须和字符串jack还有整数10和5的类型匹配
	public static void add5(String x,int y,int z) {
		System.out.println(x);
		System.out.println(y);
		System.out.println(z);
		System.out.println(x+y+z);//TODO 加号在这的作用是直接拼接字符串
	}
}

3）方法的返回值

package cn.tedu.method;
//测试  方法的返回值
/*
 * 总结. 
 * 1.通过return关键字，把结果返回给调用位置
 * 2.如果方法没有返回值就写void，有返回值写啥？--要看返回的数据类型
 * */
public class Test04_Method3 {
	public static void main(String[] args) {
		//3.使用变量，接收add()返回来的结果
		int result = add(1,2);
		System.out.println(result);
		
		String res2=add2("tony",1,2);
		System.out.println(res2);
		
		String res3=add3("tony");
		System.out.println(res3);
	}
	
	//1.如果方法需要，把结果返回，
	//	方法返回值的位置，应该写返回数据的数据类型
	public static int add(int i ,int j) {
		return i+j;//2.return把结果返回给调用位置
	}
	public static String add2(String a,int b,int c) {
		return a+b+c;
	}
	public static String add3(String a) {
		return a;
	}
}

package cn.tedu.method;
// 测试 方法返回值
public class Test6_Method {
	public static void main(String[] args) {
		//2,不处理sum返回来的结果
		sum(10,5);
		//3,res保存了sum返回来的结果
		int res =sum(10,5);
		System.out.println(res);//15
		
		//练习1
		
		String s = add(1,2);
		System.out.println(s);
		
		//练习2
		int x =print("jack",1,2);
		System.out.println(x);
		}
	public static String add(int c,int d) {
		return "";
	}
			
	public static int print(String a,int b,int c)	{
		return b+c;//只能输出int 整数类型的b或者c或者b+c等等
	}
	/*语法：
	 * 修饰符  返回值  方法名(参数类型 参数名){
        方法体;
	}*/
	
	//创建sum()--把执行的结果返回
	//1，如果方法需要返回值，返回值的位置--写返回值的类型
	public static int sum(int a,int b) {
		return a+b;//1,使用return 关键字 ，返回给调用
	}
}

5.方法重载/overload

概述
- 在一个类里的现象,方法名相同,但是参数列表不同(个数/类型)
- 好处:体现了程序的灵活性…啥类型数据都可以打印
练习

package cn.tedu.method;
//测试   方法重载overload
/*
 * 总结
 * 1.方法重载--同一个类里方法名相同，参数列表不同
 * 2.程序会根据参数的个数、参数的类型自动匹配同名的add()
 * */
public class Test05_Overload1 {
	public static void main(String[] args) {
		//2.程序会根据参数的个数，参数的类型自动匹配同名的add()
		int result1=add(1,2,3);//匹配add(int a,int b,int c)
		int result2=add(5,6);//匹配add(int a,int b)
		int result3=add(8);//匹配add(int a)
		String result4=add(5,8,"tony");//匹配add(int a,int b,String c)
		String result5=add("tony",5,8);//匹配add(String a,int b,int c)
		
		System.out.println(result1);
		System.out.println(result2);
		System.out.println(result3);
		System.out.println(result4);
		System.out.println(result5);
	}
	//1.提供重载的add()--同一个类里方法名相同，参数列表（指的是数据类型或参数个数）不同
	public static int add(int a,int b,int c) {
		return a+b+c;
	}
	public static int add(int a,int b) {
		return a+b;
	}
	public static int add(int a) {
		return a;
	}
	public static String add(int a,int b,String c) {
		return a+b+c;
	}
	public static String add(String a,int b,int c) {
		return a+b+c;
	}
}

package cn.tedu.method;
//测试  重载
public class Test06_Overload2 {
	public static void main(String[] args) {
		int res1=print(10);
		double res2=print(1.1);
		boolean res3=print(true);
		char res4=print('中');
		String res5=print("hello");
	
		System.out.println(res1);
		System.out.println(res2);
		System.out.println(res3);
		System.out.println(res4);
		System.out.println(res5);
	}
	public static int print(int a) {
		return a;
	}
	public static double print(double a) {
		return a;
	}
	public static boolean print(boolean a) {
		return a;
	}
	public static char print(char a) {
		return a;
	}
	public static String print(String a) {
		return a;
	}
}

二、数组

1.课前回顾

先回顾一下两种数据类型吧：
**基本数据类型：**int, short,double, float,long,char,byte,boolean；(8种)
引用数据类型：类，接口，数组，String等

2.概述

英文Array,标志[]
存储多个相同类型的数据
数组有下标/索引/脚标,默认是从0开始
数组一旦创建，长度不可变

3.创建数组

动态初始化语法:数组类型[] 数组名 = new 数组类型[容量/数组长度];
静态初始化语法：①数组类型[] 数组名= new 数组类型[]{元素1,元素2,…,元素n,};②数组类型[] 数组名= {元素1,元素2,…,元素n,};

		//动态初始化
			int[] a = new int[5];//语法：数组类型[] 数组名= new 数组类型[ length ];
		//静态初始化
			int[] a = new int[]{1,2,3,4,5};//语法：数组类型[] 数组名= new 数组类型[]{元素1,元素2,…,元素n,};
			int[] a = {1,2,3,4,5};//语法：数组类型[] 数组名= {元素1,元素2,…,元素n,};

注意事项

1.数组必须先初始化，才能使用，因为初始化是表示在内存中分配空间；

2.所谓初始化就是给元素分配内存，并为每个元素赋初始值。

3.初始化数组有两种方式，静态初始化和动态初始化；

4.但是无论以哪中方式，一旦初始化完成，数组的长度就固定了，不能再改变，除非重新初始化。也就说数组是定长的！

4.数组的内存图

在这里插入图片描述

5.练习

package cn.tedu.method;
import java.util.Arrays;
//测试  数组
public class Test07_Array1 {
	public static void main(String[] args) {
		//数组中存入hello
		
		//TODO 动态初始化
		char[] arr1 = new char[5];
		arr1[0]='h';
		arr1[1]='e';
		arr1[2]='l';
		arr1[3]='l';
		arr1[4]='o';
		System.out.println(arr1);
		System.out.println(arr1[0]);
		arr1[0]='H';
		System.out.println(arr1[0]);
		System.out.println(arr1);
		//报错，ArrayIndexOutOfBoundsException:5     数组越界
		//访问了不存在的下标
		//arr1[5]='h';
		System.out.println(arr1.length);//获取数组长度
		System.out.println("=================================================");
		
		//TODO 静态初始化
		char[] arr2=new char[] {'h','e','l','l','o'};
		System.out.println(arr2);
		
		char[] arr3= {'h','e','l','l','o'};//静态初始化
		System.out.println(arr3);
	}
}

package cn.tedu.basic;

//数组 静态初始化-动态初始化
import java.util.Arrays;

public class Test1 {

	public static void main(String[] args) {
		// --动态初始化
		int[] a = new int[5];// a是引用类型的变量--不是int类型，是引用类型
		System.out.println(a);// 输出[I@15db9742--这是int[]数组的地址值
		System.out.println(Arrays.toString(a));// 默认值是5个0；
		// 静态初始化--(两种方法)
		int[] b = new int[] { 1, 2, 3, 4, 5 };
		System.out.println(Arrays.toString(b));
		int[] c = { 1, 2, 3, 4, 5 };
		System.out.println(Arrays.toString(c));

		// 练习：把hello 存入数组里
		// char类型的默认值是\u0000;

		// 静态初始化(两种方法)
		char[] x = new char[] { 'h', 'e', 'l', 'l', 'o' };
		System.out.println(x);
		System.out.println(x.length);// 获取x[]数组的长度

		char[] y = { 'h', 'e', 'l', 'l', 'o' };
		System.out.println(y);
		System.out.println(y.length - 1);// 获取y[]数组下标的最大值
		// 动态初始化
		char[] z = new char[5];

		z[0] = 'h';// 修改z数组中，0下标对应的数据；
		z[1] = 'e';// 修改z数组中，1下标对应的数据；
		z[2] = 'l';// 修改z数组中，2下标对应的数据；
		z[3] = 'l';// 修改z数组中，3下标对应的数据；
		z[4] = 'o';// 修改z数组中，4下标对应的数据；

		// 获取z数组中，0下标对应的值
		System.out.println(z);
		System.out.println(z.length);// 获取z[]数组的长度
		System.out.println(z.length - 1);// 获取z[]数组下标的最大值
	}
}

三、数组遍历

1.概述

从头到尾，依次访问数组的位置。
注：除了char以外，其他类型的数组syso[ 数组名 ]输出的都是地址码，只有char会自动遍历

2.语法

for(int i=0;i<a.length;i++){
       syso(a[i]);
}

3.练习

1）入门案例

	public static void method() {
		//1.创建对象
		int[] a = new int[] {1,2,3,4,5};
		//2.打印数组里的数据
		System.out.println(a[0]);
		System.out.println(a[1]);
		System.out.println(a[2]);
		System.out.println(a[3]);
		System.out.println(a[a.length-1]);//下标的取值范围[0,length-1)
		System.out.println(a);
		//3.使用循环结构--根据下标遍历数组里的数据
		/*
		 * int i =0;  是指从下标为0的位置开始
		 * i<b.length;  是指下标的取值范围是<=数组的长度-1
		 * i++   是指下标的变化规律是按照+1递增
		 * i   表示下标
		 * */
		int[] b=new int[5];
		for(int i =0;i<b.length;i++) {
			b[i]=i+1;
		}
		System.out.println(Arrays.toString(b));
	}

// 创建方法
	public static void method() {
		// 1，静态创建数组
		String[] a = new String[] { "杨幂", "迪丽热巴", "古力娜扎", "肖战", "皮皮霞" };
		// 2,遍历数组
		/*
		 * int i=0 从下标为0的位置开始循环; i<a.length 指的是下标最大值是<长度； 
		 *或者
         *<=a.length-1 i++ 下标的变化规律
		 * 依次递增
		 */
		for (int i = 0; i <= a.length - 1; i++) {
			// 打印a数组中i下标对应的元素
			System.out.println(a[i]);
		}
	}

2)输出每个月的天数

	public static void month() {
		//1.定义数组存储月份以及每个月的天数
		String[] month = {"一","二","三","四","五","六","七","八","九","十","十一","十二"};
		int[] day= {31,29,31,30,31,30,31,31,30,31,30,31};
		//2.遍历输出--根据下标
		for(int i =0;i<day.length;i++) {
			//获取数组里的数据
			System.out.println(month[i]+"月份共有"+day[i]+"天。");
		}
	}

// 输出每个月的天数
	public static void method2() {
		// 1，定义数组，存入12个数
		int[] a = new int[] { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
		// 2，根据下标，遍历数组
		for (int i = 0; i <= a.length - 1; i++) {
			System.out.println(i + 1 + "月有" + a[i] + "天");
		}
	}

3)遍历数组，存入1到10

	public static void saveNum() {
		System.out.println("====================存入数字1~10====================");
		//1.定义数组用来以后存入数组
		int[] arr = new int[10];
		//2.遍历数组
		for(int i =0;i<arr.length;i++) {
			arr[i]=i+1;
		}
		//3.输出
		System.out.println(arr);//arr是引用类型的变量，存的地址值是[I@6d06d69c
		System.out.println(Arrays.toString(arr));

4)创建随机数组

	public static void random() {
		//获取100以内的随机值的数组
		Random random =new Random();//声明随机数的时候括号内不写参数
		int[] a = new int[10];
		for(int i=0;i<a.length;i++) {
			a[i]=1+random.nextInt(100);//赋值的时候括号内写入参数
		}
		System.out.println(Arrays.toString(a));
	}

//TODO 定义数组 并存入随机数
	public static int[] method3() {
		// 1，动态定义数组，存数据;
		int[] a = new int[5];
		// 2，遍历数组，获取每个数据;
		for (int i = 0; i <= a.length - 1; i++) {
		// 3,把默认值改成随机数;
			a[i] = new Random().nextInt(100);
		}
		// 4，打印数据;
		for (int i = 0; i <= a.length - 1; i++) {
			System.out.print(a[i] + "、");
		}
		return a;// 把a返回给外界调用；
	}

5)定义数组–打印随机数组里面的奇数(用到4中的method3()了)

package cn.tedu.basic;

import java.util.Random;
//测试 数组的遍历
public class Test3 {

	public static void main(String[] args) {
		// method3();//定义数组 并存入随机数
		int[] x = method3();
		method4(x);// 定义数组 并打印随机数里面的奇数
	}

	//TODO 定义数组 并存入随机数
	public static int[] method3() {
		// 1，动态定义数组，存数据;
		int[] a = new int[5];
		// 2，遍历数组，获取每个数据;
		for (int i = 0; i <= a.length - 1; i++) {
			// 3,把默认值改成随机数;
			a[i] = new Random().nextInt(100);
		}
		// 4，打印数据;
		for (int i = 0; i <= a.length - 1; i++) {
			System.out.print(a[i] + "、");
		}
		return a;// 把a返回给外界调用；
	}

	//TODO 定义数组 并打印随机数里面的奇数
	public static void method4(int[] a) {
		System.out.println();

		for (int i = 0; i < a.length; i++) {
			if (a[i] % 2 == 1) {
				System.out.println(a[i] + "、");
			}
		}
	}
}

*案例总结

package cn.tedu.basic;

import java.util.Random;
import java.util.Arrays;

//测试  数组的遍历
public class Test01_ArrayTerverse1 {
	public static void main(String[] args) {
		//调用方法：入门案例
		method();

		//调用方法：输出每个月的天数		
		month();

		//调用方法：遍历数组，存入1到10
		saveNum();

		//调用方法：创建随机数组
		random();
	}

	//遍历的入门案例
	public static void method() {
		System.out.println("====================入门案例====================");
		//1.创建对象
		int[] a = new int[] {1,2,3,4,5};

		//2.打印数组里的数据
		System.out.println(a[0]);
		System.out.println(a[1]);
		System.out.println(a[2]);
		System.out.println(a[3]);
		System.out.println(a[a.length-1]);//下标的取值范围[0,length-1)
		System.out.println(a);

		//3.使用循环结构--根据下标遍历数组里的数据
		/*
		 * int i =0;  是指从下标为0的位置开始
		 * i<b.length;  是指下标的取值范围是<=数组的长度-1
		 * i++   是指下标的变化规律是按照+1递增
		 * i   表示下标
		 * */
		int[] b=new int[5];
		for(int i =0;i<b.length;i++) {
			b[i]=i+1;
		}
        
        //增强for:::语法简洁+效率高
		//语法：for(遍历得到的数据的类型 变量名：要遍历的数组名){循环体}
		System.out.println();
		for(int x:a) {
			System.out.println(x);
		}
		System.out.println();

		System.out.println(Arrays.toString(b));
	}

	//输出每个月的天数
	public static void month() {
		System.out.println("====================输出每个月的天数====================");
		//1.定义数组存储月份以及每个月的天数
		String[] month = {"一","二","三","四","五","六","七","八","九","十","十一","十二"};
		int[] day= {31,29,31,30,31,30,31,31,30,31,30,31};
		//2.遍历输出--根据下标
		for(int i =0;i<day.length;i++) {
			//获取数组里的数据
			System.out.println(month[i]+"月份共有"+day[i]+"天。");
		}
	}

	//遍历数组，存入1到10
	public static void saveNum() {
		System.out.println("====================存入数字1~10====================");
		//1.定义数组用来以后存入数组
		int[] arr = new int[10];
		//2.遍历数组
		for(int i =0;i<arr.length;i++) {
			arr[i]=i+1;
		}
		//3.输出
		System.out.println(arr);//arr是引用类型的变量，存的地址值是[I@6d06d69c
		System.out.println(Arrays.toString(arr));
	}

	//创建随机数组
	public static void random() {
		System.out.println("====================创建随机数组====================");
		//获取100以内的随机值的数组
		Random random =new Random();
		int[] a = new int[10];
		for(int i=0;i<a.length;i++) {
			a[i]=1+random.nextInt(100);
		}
		System.out.println(Arrays.toString(a));
	}
}

四、数组工具类Arrays

1.概述

为数组的常见操作提供了各种方便的方法

2.常用方法

toString()–把数组里的数据变成串展示
sort()–把无序的数组排序
copyOf()–复制数组

3.测试

package cn.tedu.basic;
//测试 数组工具类Arrays
import java.util.Arrays;
public class Test4 {

	public static void main(String[] args) {
		method();//toString()
		method2();//sort()
		method3();//copyOf()
	}
    //toString()--TODO 把数组里的数据变成串展示
	public static void method() {
		//创建数组 动态定义数组--存数据
		String [] a= {"1","2","3","4","5","6"}; 
		//遍历数组
		//for(int i=0;i<a.length;i++) {
		//}
		//TODO 使用工具类Arrays.toString(数组)方法展示a数组里的数据
		System.out.println(Arrays.toString(a));	
	}
	
	//sort()-- TODO 把无序的数组排序
	public static void method2() {
		//1,定义数组
		int [] a= {95,77,99,81,1};
		//2，TODO 使用工具类 Arrays.sort(数组)方法进行排序
		Arrays.sort(a);
		//3,打印 TODO 使用工具类Arrays.toString(数组)方法展示a数组里的已排序好数据
		System.out.println(Arrays.toString(a));
	}	
	//copyOf()-- TODO 复制数组
	public static void method3() {
		//1,准备原数组
		int[] a= {1,2,3,4,5};
		
		//2,调用方法完成复制
		int[] b=Arrays.copyOf(a, 9);
		System.out.println(Arrays.toString(b));
		//[1, 2, 3, 4, 5, 0, 0, 0, 0]--扩容--新数组的长度>原数组长度
		
		int[] c=Arrays.copyOf(a, 2);
		System.out.println(Arrays.toString(c));
		//[1, 2]--缩容--新数组的长度<原数组长度
	}	
}

package cn.tedu.array;

import java.util.Arrays;
/*
 * TODO 为什么copyOf()有返回值，sort()没有返回值？
 * 数组一旦创建,长度不可变
 * 所以copyOf()改变了数组的长度相当于返回了一个新的数组
 * */
/*
 * 总结：
 * 1.toString(?)--要展示数据的数组
 * 2.sort(?)--要被排序的数组
 * 3.copyOf(1,2)--1是原数组名，2是新数组的长度
 * */
//测试  工具类Arrays
public class Test02_Arrays {
	public static void main(String[] args) {
		int[] a = {55,88,44,66,77,99,11,22,33,58,69,74,12};
		method(a);
		method2(a);
		method3(a);
	}
	
	//toString()--打印数组里的数据
	public static void method(int[] x) {
		System.out.println("不使用Arrays方法：");
		for(int i=0;i<x.length;i++) {
			//打印数组里的数据
			System.out.print(x[i]+",");
		}
		System.out.println();
		//使用工具类打印数组里的数据
		//toString(n)--可以把指定数组n里的数据变成字符串展示
		System.out.println("使用Arrays方法：");
		System.out.println(Arrays.toString(x));
		System.out.println();
	}
	
	//sort()--给数组排序
	public static void method2(int[] x) {
		//sort(n)--对指定的数组n排序，默认是从小到大
		Arrays.sort(x);//调用方法对数组排序
		System.out.println(Arrays.toString(x));
		System.out.println();
	}
	
	//copyOf()--复制数组
	public static void method3(int[] x) {
		//第一个参数是要一个原数组，第二个参数是新的长度
		int[] y =Arrays.copyOf(x , 5);//缩容----[55, 88, 44, 66, 77]
		int[] z =Arrays.copyOf(x , 20);//扩容----[55, 88, 44, 66, 77, 99, 11, 22, 33, 58, 69, 74, 12, 0, 0, 0, 0, 0, 0, 0]
		System.out.println(Arrays.toString(y));
		System.out.println(Arrays.toString(z));
		System.out.println(x.length);//结果还是13，不管缩容还是扩容，对原数组的长度没有改变
	}
}

拓展

1.求数组里的奇数的个数

package cn.tedu.method;
import java.util.Scanner;
//求数组里的奇数的个数
public class Test08_Array2 {
	public static void main(String[] args) {
		System.out.println("请随机输入十个数字：");
		Scanner num = new Scanner(System.in);
		//创建数组并接收数值
		int[] arr = new int[10];
		int count=0;//用来存储奇数的数量
		for(int i =0;i<arr.length;i++) {
			arr[i]=num.nextInt();
			//判断是否为奇数并记录
			if(arr[i]%2==1) {
				count++;
			}
		}
		System.out.println("该数组中所有奇数的数量为："+count);//输出奇数的数量
	}
}

2.求数组里的偶数的和

package cn.tedu.method;
import java.util.Scanner;
//求数组里的偶数的和
public class Test09_Arrays1 {
	public static void main(String[] args) {
		//接受用户数据
		System.out.println("请输入十个随机的数字：");
		Scanner num = new Scanner(System.in);
		//声明数组并接受数据
		int[] arr = new int[10];//创建数组用来接收数据
		int sum = 0;//声明一个变量用来求和
		for(int i=0;i<arr.length;i++) {
			arr[i]=num.nextInt();
			//判断求和
			if(arr[i]%2==0) {
				sum=sum+arr[i];
			}
		}
		//输出
		System.out.println("该数组中所有偶数的和为："+sum);
	}
}

3.对十个数字进行排序

package review;

import java.util.Arrays;
import java.util.Scanner;

//对十个数字进行排序
public class Test04_Array3 {
	public static void main(String[] args) {
		//接收终端输入的数据
		System.out.println("请输入十个随机的数字");
		Scanner scanner =new Scanner(System.in);
		//生命数组并把输入的数据赋值给数组
		int[] arr = new int[10];
		for(int i =0;i<arr.length;i++) {
			arr[i]=scanner.nextInt();
		}
		//		System.out.println(Arrays.toString(arr));//数字已存入数组

//i=0时，条件满足，执行内循环；j=1，条件满足，执行判断：arr[0]和arr[1]比较交换，然后和arr[2]比较交换....然后和arr[9]比较交换
//i=1时，条件满足，执行内循环；j=2，条件满足，执行判断：arr[1]和arr[2]比较交换，然后和arr[3]比较交换....然后和arr[9]比较交换
//i=2时，条件满足，执行内循环：j=3，条件满足，执行判断：arr[2]和arr[3]比较交换，然后和arr[4]比较交换....然后和arr[9]比较交换
//i=3时，条件满足，执行内循环：j=4，条件满足，执行判断：arr[3]和arr[4]比较交换，然后和arr[5]比较交换....然后和arr[9]比较交换
//i=4时，条件满足，执行内循环：j=5，条件满足，执行判断：arr[4]和arr[5]比较交换，然后和arr[6]比较交换....然后和arr[9]比较交换
//i=5时，条件满足，执行内循环：j=6，条件满足，执行判断：arr[5]和arr[6]比较交换，然后和arr[7]比较交换....然后和arr[9]比较交换
//i=6时，条件满足，执行内循环：j=7，条件满足，执行判断：arr[6]和arr[7]比较交换，然后和arr[8]比较交换，然后和arr[9]比较交换
//i=7时，条件满足，执行内循环：j=8，条件满足，执行判断：arr[7]和arr[8]比较交换，然后和arr[9]比较交换
//i=8时，条件满足，执行内循环：j=9，条件满足，执行判断：arr[8]和arr[9]比较交换
//i=9时，条件满足，执行内循环：j=10，条件不满足，内循环结束
//i=10时，条件不满足，循环结束

		//声明变量用来判断交换数据
		int temp;
		for(int i=0;i<arr.length;i++) {
			for(int j=i+1;j<arr.length;j++) {
				if(arr[i]>arr[j]) {
					temp=arr[i];
					arr[i]=arr[j];
					arr[j]=temp;
				}
			}
		}
		System.out.println("排序后的数组为："+Arrays.toString(arr));
	}
}

4.实参和形参的区别

实参：是进行方法调用时，传入的实际参数

public static void main(String[] args) {
		add3(5,10,"tony");//括号内的就是实参--调用方法时实际具体要设置的值
	}

形参：是定义方法时，参数列表里规定的参数的类型

public static void add3(int i,int j,String k) {//括号内的就是形参--创建方法时的类型
		System.out.println(i);
		System.out.println(j);
		System.out.println(k);
	}

5.随机打印数组里的数据

public static void random() {
		//接收数据
		System.out.println("请随机输入十个数字：");
		Scanner sca = new Scanner(System.in);
		//输出随机的参数
		int arg = new Random().nextInt(10);
		//声明数组并遍历
		int[] arr = new int[10];
		for(int i=0;i<arr.length;i++) {
			arr[i]=sca.nextInt();
		}
		//输出
		System.out.println("生成的该数组的所有元素为："+Arrays.toString(arr));
		System.out.println("生成的随机数为："+arg);
		Arrays.sort(arr);
		System.out.println("排序后为："+Arrays.toString(arr));
		System.out.println("随机打印数组中的数据为："+arr[arg]);
	}

6.获取数组里的最大值最小值

public static void limit() {
		//接收数据
		System.out.println("请输入十个随机的数字：");
		Scanner sca = new Scanner(System.in);
		//声明数组并遍历
		int[] arr = new int[10];
		for(int i=0;i<arr.length;i++) {
			arr[i]=sca.nextInt();
		}
		//排序并输出
		Arrays.sort(arr);
		System.out.println("该数组中的最小值为："+arr[0]+"，最大值为："+arr[arr.length-1]);
	}

package cn.tedu.lianxi;

//获取数组里的最大值最小值
public class Test8 {

	public static void main(String[] args) {
		int[] arr = { 4, 47, 32, 546, 143 };
		int num = arr[0];
		for (int i = 0; i < arr.length; i++) {
			if (num < arr[i]) {
				num = arr[i];
			}
			/*
			 * if(num>arr[i]) { num=arr[i]; }
			 */
		}
		System.out.println("最大值:" + num);
		// System.out.println("最小值："+ num);
	}
}

7.统计数组里的数据总和和平均值

public static void average() {
		//接受数据
		System.out.println("请输入十个随机的数字：");
		Scanner sca = new Scanner(System.in);
		//声明数组并遍历
		int sum=0;
		double ave=0;
		int[] arr =new int[10];
		for(int i =0;i<arr.length;i++) {
			arr[i]=sca.nextInt();
			sum=sum+arr[i];
			ave=sum/arr.length;
		}
		System.out.println("该数组所有数据总和为："+sum);
		System.out.println("该数组的平均值为："+ave);
	}

8.模拟数组复制

public static void copy() {
		//接受数据
		System.out.println("请输入十个随机的数字：");
		Scanner sca = new Scanner(System.in);
		int[] arr = new int[10];
		for(int i =0;i<arr.length;i++) {
			arr[i]=sca.nextInt();
		}
//输出的时候需要重新声明一个新的数组用来存储长度改变后的数组，相当于重新创建了一个数组，因为数组一旦创建，长度不能改变
		int[] arr2=Arrays.copyOf(arr, 15);//扩容
		System.out.println("扩容后"+Arrays.toString(arr2));
		int[] arr3=Arrays.copyOf(arr, 5);//缩容
		System.out.println("缩容后"+Arrays.toString(arr3));
		System.out.println("此时的arr数组还是："+Arrays.toString(arr));
	}

9.测试成员变量和局部变量(以及基本类型和引用类型的输出默认值)

package cn.tedu.basic;
// 测试 变量--成员变量--局部变量
public class Test3 {
	     /*2，成员变量：类里 方法外+作用在整个类里+可以不初始化，也会有默认值
	      * 可以不用初始化-所以可以不用赋值
	      * 它自己有默认值
	      * 作用在整个类中都有效
	     */
	static	String name;//引用类型输出默认值都为null
	static	int num ;//输出默认值0
	static  short a;//输出变量值0
	static  double m;//输出默认值0.0
	static  char n;//输出\u0000--解析不出来
	static  boolean b; //输出false
	
	int age =20 ;//成员变量--根据就近原则--所以输出方法里面的10
	
	public static void main(String[] args) {
		/*1，局部变量：方法里+必须初始化+只在方法里有效
		 * 初始化的意思就是必须赋值--就是变量必须有变量值
		 * 只在方法里有效
		*/
		int age	=10 ;
		//3，当成员变量名和局部变量名 相同时 ，就近原则，优先使用局部变量
		System.out.println(age);		
		System.out.println(name);		
		System.out.println(num);		
		System.out.println(a);		
		System.out.println(m);
		System.out.println(n);
		System.out.println(b);
	}
}

10.在java中数组遍历的三种方式

for循环遍历

通常遍历数组都是使用for循环来实现。遍历一维数组很简单，遍历二维数组需要使用双层for循环，通过数组的length属性可获得数组的长度。

程序示例：

Arrays工具类中toString静态方法遍历

利用Arrays工具类中的toString静态方法可以将一维数组转化为字符串形式并输出。

程序示例：

foreach语句遍历

增强for循环/foreach循环

语法：for（数组的数据类型变量名：循环的容器）{sout直接输出}

java5之后，Java提供了一种更简洁的循环：foreach循环，这种循环遍历数组和集合更加简洁。使用foreach循环遍历数组时，无须获得数组和集合长度，无须根据索引来访问数组元素，foreach循环自动遍历数组和集合的每一个元素。

注意：使用foreach循环迭代数组元素时，并不能改变数组元素的值，因此不要对foreach的循环变量赋值。例如：

错误程序案例

public static void main(String [] args){

int [] arr={1,2,3,4,5};

    for(int a:arr){

      a=0;

      System.out.print(a);

    }

    System.out.print(“\n”+a[0]);

}

运行结果：

00000

1

从上面结果可以看出，由于在foreach循环中对数组进行赋值，结果导致不能正确遍历数组元素。而且当再次访问第一个数组元素时，发现数组元素依然没有改变。

正确程序示例：

11.在Java中数组工具类Arrays类

Java中的数组工具类Arrays类包括各种各样的静态方法，来帮助我们对数组进行排序，查找，复制，扩容等一系列操作。

Arrays的遍历输出方法

int[] arr = {22, 11, 33, 9, 60};
		//Arrays的遍历输出方法
		System.out.println(Arrays.toString(arr));//[22, 11, 33, 9, 60]

Arrays的排序方法

int[] arr = {22, 11, 33, 9, 60};
//Arrays的排序方法
Arrays.sort(arr);//排序方法
System.out.println(Arrays.toString(arr));//排序后输出
//[9, 11, 22, 33, 60]

Arrays的复制方法

int[] arr = {22, 11, 66, 88, 99, 44};
//定义新数组复制原数组的元素
int[] newArr = Arrays.copyOf(arr, arr.length);//arr为复制来源，arr.length为复制的长度
System.out.println(Arrays.toString(newArr));
//[22, 11, 66, 88, 99, 44]

int[] newArr2 = Arrays.copyOf(arr, arr.length-2);
System.out.println(Arrays.toString(newArr2));
//[22, 11, 66, 88]

//选择性复制
int[] copyArr = Arrays.copyOfRange(arr, 2, 5);//从原数组下标为2的元素开始到下标为5的元素结束，此处左闭右开原则，即[2,5)
System.out.println(Arrays.toString(copyArr));//[66, 88, 99]

// System的arraycopy方法,这是一个本地方法,底层不由Java实现,由C语言实现
int[] arr = {22, 11, 66, 88, 99, 44};
int[] dest = {0, 2, 4};
System.arraycopy(arr, 2, dest, 0 ,3);
//从arr数组下标为2的元素开始，复制到dest数组，复制的元素从dest数组中下标为0的元素开始，复制3个元素
//复制后遍历输出
System.out.println(Arrays.toString(dest));
//[66, 88, 99]

Arrays的数组扩容缩容方法

//数组扩容
int[] arr = {22, 11, 66, 88, };
//定义新数组为扩容后的数组
int[] newArr = Arrays.copyOf(arr, arr.length + 1);
System.out.println(Arrays.toString(newArr));//[22, 11, 66, 88, 0]
//扩容后的元素为0

//数组缩容
//定义新数组为缩容后的数组
int[] newArr2 = Arrays.copyOf(arr, arr.length - 1);
System.out.println(Arrays.toString(newArr2));//[22, 11, 66]

//扩容缩容都是从原数组最后一个元素开始

Arrays中的填充方法

int[] arr = {22, 11, 66, 88, 99};
// 将数组中的元素全部填充为200
Arrays.fill(arr, 200);
System.out.println(Arrays.toString(arr));//[200, 200, 200, 200, 200]

//填充数组的一部分
Arrays.fill(arr, 2, 4, 100);//将原数组中下标为2的元素开始到4为止全部用100填充，此处左闭右开原则，[2,4)
System.out.println(Arrays.toString(arr));//[22, 11, 100, 100, 99]

Arrays的二分法查找

int[] arr = {22, 11 , 33 , 9 ,60};
//因为是二分法查找，需要先排序
Arrays.sort(arr);//[9, 11, 22, 33, 60]
//二分法查找
int index = Arrays.binarySearch(arr, 33);
System.out.println(index);//输出结果为3
//查找结果为33在排序后的数组的下标

int[] arr2 = {2, 4, 6, 8, 10, 20};
int index2 = Arrays.binarySearch(arr2, 10);
System.out.println(index2);//输出结果为4