day06

1.八大基本数据类型
	整型:  byte short  int long 
	浮点:  double  float
	字符: char
	布尔: boolean

2.声明变量的语法格式
	数据类型 变量名字 = 初始化的值;
3.使用for循环打印等腰三角形
	for (int i = 1; i <= 4; i++) {
		for (int j = 1; j <= 4 - i; j++) {
			System.out.print(" ");
		}
		for (int k = 1; k <= (2 * i - 1); k++) {
			System.out.print("*");
		}
		System.out.println();
	}
4.break和continue关键字的简单介绍 
	break： swicth-case  和循环里面 终止 打断
	continue: 循环  结束本次循环 执行下一次循环
5.四种方法的语法格式分别列出来
	无参无返回值的方法: public static void 方法的名字 () {
	
	}  
	public static void 方法名字（数据类型  形参,....） ｛
	｝
	public static 数据类型 方法名字 () {
		return 返回值
	}
	public static 数据类型 方法名字 (数据类型 形参) {
		return 返回值
	}

1.写一个方法，判断一个字符是否是英文字符（大写和小写）

2.写一个方法将一个整数逆序换行打印

		int a = 3456;

		6

		5

		4

		3

3.写一个方法，控制台输入哪一个年份，判断是否是闰年

4.写一个方法判断一个数字是否是正数
5.写一个方法输出1-100之间不能被5整除的数，每5个一行
6.写一个方法求出1-1/2+1/3-1/4……1/100
7.写一个方法 求1+（1+2）+（1+2+3）+（1+2+3+4）+……+（1+2+……+100）

package com.qfedu.b_homework;

import java.util.Scanner;

public class Demo1 {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("输入一个字符:");
		char c = scanner.next().charAt(0);
		isEnglish(c);
	}
	//判断是否是英文字符
	public static void isEnglish (char c) {
		if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')) {
			System.out.println("是英文字符");
		} else {
			System.out.println("不是英文字符");
		}
	}
}

package com.qfedu.b_homework;

public class Demo2 {
	public static void main(String[] args) {
		int i1 = 3456;
		reverse(i1);
	}
	//对一个int类型的数据进行倒序的打印
	public static void reverse (int a) {
		/**
		 * i=3456   3456 != 0 true sout(3456%10) 6  i=i/10 345
		 * i=345    345 != 0 true sout(345%10)  5 i=i/10  34
		 * i=34    34！=0  true sout(34 %10) 4  i=i/10 3
		 * i=3  3!= 0 true  sout(3%10) 3  i=i/10 0
		 * i=0 0!= 0 false 循环结束
		 */
		int i = a;
		while (i != 0) {
			System.out.println(i % 10);
			i = i / 10;
		}
	}

}

今天的内容

数组

1.数组

1.1开发中为啥要有数组

如果开发中出现了大量的同一类型的数据的时候，如果按照现在所学，声明变量的话，进行数据的存储。

这样的话，变量很多。相当麻烦

使用数组：只需要声明一个变量，然后存储多个数据

把他们当成一个容器即可

1.2在Java中如何定义数组

变量:

? 数据类型 变量名字 = 初始化的值;

数组定义的语法格式:

第一种定义方式:

?

数据类型[] 数组变量名字 = {值1， 值2， 值3,......};
或者
数据类型 数组变量名字 []= {值1， 值2， 值3,......};

第二种声明方式:

数据类型[]  数组变量名字 = new 数据类型[容量];

第三种声明方式:

数据类型[] 数组变量名字 = new 数据类型[]{值1, 值2， 值3,.....};
是第一种的简写情况

package com.qfedu.c_array;

public class Demo1 {
	public static void main(String[] args) {
		//使用第一种方式声明数组
		//声明数组并赋值，这个数组里面存了三个值
		int[] arr = {12, 56, 89};
		float f1[] = {34.2f, 89.78f, 76.345f};
		char[] ch1 = {'中', 'a', '2'};
		boolean[] b1 = {false, true, false};
		String[] strs = {"学虎", "腾飞", "狗蛋"};
		
		//使用第二种声明方式
		//声明的这个数组的容量是3，就意味着可以存放3个数据
		//仅仅是声明了一个容器而已。里面还没有放值，但是会存放默认的值
		//如果是int  默认值就是0 [0, 0, 0]
		int[] arr1 = new int[3];
		boolean[] b2 = new boolean[2];//[false,false]
		String[] strs1 = new String[3];
		//[null, null, null]
		//第三种写法
		int[] arr2 = new int[] {34, 56, 7,8};
		
		
		
		
	}

}

脑海里面想到一个问题 第二种声明方式没有对数组进行赋值

1.3对第二种声明方式进行赋值

package com.qfedu.c_array;

import java.util.Arrays;

public class Demo2 {

	public static void main(String[] args) {
		int[] arr = new int[3];//只能存3个元素
		//[0, 0, 0]
		//对空的容器进行赋值
		arr[0] = 12;//[12, 0,0]  将12赋值给下标为0的位置
		arr[1] = 13;//[12, 13, 0]
		//arr[2] = 14;//[12, 13, 14]
		//数组下标越界的
		//arr[3] = 78;
		
		//打印一下看看结果
		System.out.println(arr);//打印的是一个内存地址
		//内存地址对程序友好不？不优化，看不出来你的数据是个啥
		//咋办？有一个超纲的东西可以将内存地址转为字符串
		System.out.println(Arrays.toString(arr));
		
		//对一个String类型的数组进行赋值
		String[] strs1 =  new String[4];
		strs1[0] = "老邢";
		strs1[1] = "骚磊";
		strs1[3] = "老万";
		System.out.println(strs1);
		System.out.println(Arrays.toString(strs1));
		//对一个char 类型数组进行赋值
		//但是唯独char不需要toString
		char[] ch1 = new char[4];
		ch1[0] = 97;
		ch1[1] = 'z';
		ch1[3] = 'x';
		System.out.println(ch1);
		
	}
}

1.4对数组进行取值

package com.qfedu.c_array;

public class Demo3 {
	public static void main(String[] args) {
		int[] arr = {12, 78, 13, 89, 100,200};
		System.out.println(arr[0]);//下标为0的位置上的值
		System.out.println(arr[1]);
		System.out.println(arr[2]);
		System.out.println(arr[3]);
		System.out.println("=========");
		//发现一个特点，下标是有规律的，循环是专门出来重复或者有规律的
		for (int i = 0; i < 4; i++) {
			System.out.println(arr[i]);
		}
		System.out.println("-----------");
		//arr.length   arr的长度 【重点】
		
		System.out.println(arr.length);//6
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}

}

练习: 字符数组 和字符串数组，遍历他们的打印出来

package com.qfedu.c_array;

public class Demo4 {
	public static void main(String[] args) {
		String[] strs1 = {"唐三藏","孙悟空","猪八戒"};
		for (int i = 0; i < strs1.length; i++) {
			//遍历
			System.out.println(strs1[i]);
		}
		System.out.println("=======");
		char[] ch1 = {'中', '过', '系', '是'};
		for (int i = 0; i < ch1.length; i++) {
			System.out.println(ch1[i]);
		}
	}
	

}

回顾

1.声明数组
	三种
	int[] arr = {1,2,3,4};
	int[] arr1 = new int[3];
	int[] arr2 = new int[]{1,2,3,4};
2.对数组赋值
	对第二种进行赋值
	arr1[下标] = 32; 下标从0开始的
3.数组的取值遍历
	可以使用for循环进行遍历
	arr[下标]

1.5二维数组【了解】

package com.qfedu.c_array;

import java.util.Arrays;

public class Demo5 {
	public static void main(String[] args) {
		
		//[1,2,3,4]
		//二维数组  行 列
		//[[1 , 2, 3],
		// [2, 4 , 5]]
		//int[] arr = new int[3];
		int[][] arr = new int[2][3];//总共6个
		arr[0][0] = 1;
		arr[0][1] = 2;
		arr[0][2] = 3;
		arr[1][0] = 2;
		arr[1][1] = 4;
		arr[1][2] = 5;
		System.out.println(arr);
		System.out.println(Arrays.toString(arr));
		//取值 使用循环
		for (int i = 0; i < 2; i++) {//行
			for (int j = 0; j < 3; j++) {
				System.out.println(arr[i][j]);
			}
			
		}
		
		
	}

}

1.6数组可以当成一个方法的参数【重点】

方法的参数可以是八大基本数据类型和String，数据也可以作为方法的参数

语法格式

public static void 方法名字(数据类型[] 形参) {

}

package com.qfedu.c_array;

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

public class Demo6 {
	public static void main(String[] args) {
//		int[] arr = {1,2,3,4};
//		printArr(arr);
		//声明空的数组，然后向里面存值
		int[] arr = new int[5];//1.声明了一个空的数组
		add(arr);//2.对这个空的数组赋值
		//代码走到这一步，arr这个数组有值了没？
		System.out.println(Arrays.toString(arr));//3.打印这数组有哪些数据
	}
	//遍历一个数组  打印数据
	public static void printArr (int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}
	//使用方法对一个空的数组进行赋值
	/**
	 * 
	 * @param arr  是一个空的数组， 对空的数组进行赋值
	 */
	public static void add (int[] arr) {
		Scanner scanner = new Scanner(System.in);
		for (int i = 0; i < arr.length; i++) {
			System.out.println("请输入第" + (i + 1) + "数");
			int i1 = scanner.nextInt();
			arr[i] = i1;
		}
	}

}

1.7数组可以当成一个方法的返回值

public  static 数据类型 方法名字 () {

}

八大基本数据类型和String都可以当成一个方法的返回值

那么数组也是可以的

案例：

? [1,2,3,4]=>[4,3,2,1]

package com.qfedu.c_array;

import java.util.Arrays;

public class Demo7 {
	public static void main(String[] args) {
		int[] arr = reverse();
		System.out.println(Arrays.toString(arr));
	}
	//需求：将一个数组[1,2,3,4]转为[4,3,2,1]
	/**
	 * 
	 * 
	 * @return
	 */
	public static int[] reverse () {
		int[] arr = {1,2,3,4};//原数组
		//定义一个空的数组 用来接收反转以后的数据
		int[] arr1 = new int[arr.length];
		
		//表达式1 :int i = 0, j = 3
		//初始话条件 有两个
		//表达式2: i < arr1.length
		//表达式3:i++, j--  循环条件
		for (int i = 0, j = arr.length - 1; i < arr1.length; i++, j--) {
			arr1[j] = arr[i];
			//arr=[1,2,3,4]
			//arr1=[0,0,0,0]
//			arr1[3] = arr[0];//arr1[0,0,0,1]
//			arr1[2] = arr[1];//arr1[0,0,2,1]
//			arr1[1] = arr[2];//arr1[0,3,2,1]
//			arr1[0] = arr[3];//arr1[4,3,2,1]
		}
		return arr1;
	}

}

1.8数组在内存中如何分配的【了解】

以后还会再讲

目前学到的知识点你只需要关注:栈内存 和堆内存

内存区域的名字	作用
寄存器	给CPU使用的，和开发没有关系
本地方法栈	JVM虚拟机操作咱们的电脑的系统的时候，才会使用
方法区	存储和运行的class文件
堆区	存储的是对象或者数组， 凡是new出来的都存在堆区
方法栈	方法运行的时候使用的内存，比如main方法会进入到方法栈区

栈:存储的是八大基本数据类型的数据

? int a = 20; 这个存在了栈区

? 存储的是对象的引用 scanner 就是一个对象的等号的左边的

? Scanner scanner = new Scanner(System.in);

堆区:

? 凡是new的 都存在堆区

? int[] arr = new int[5];

? arr存在了栈区 new int[5];存在了堆区

? Scanner scanner = new Scanner(System.in);

? scanner 存在了栈区， new Scanner(System.in); 在堆区

2.数组方法循环分支的练习题

需求：定义一个方法，找出一个int数组中的最大值的索引下标

[3,1,2,7,6]=> 最大值的索引下标是3

package com.qfedu.c_array;

public class Demo8 {
	public static void main(String[] args) {
		int[] arr = {3, 2, 6, 1, 7};
		//找出一个int数组中最大值的索引下标
		int maxIndex = 0;//用来接收最大值的下标的
		/**
		 * i=0 0<4 true arr[0] <arr[0] false i++
		 * i=1 1<4 true arr[0] <arr[1] false i++ maxIndex=0
		 * i=2 2<4 true arr[0]<arr[2] true maxIndex=2 i+=
		 * i=3 3<4 true arr[2]<arr[3] false maxIndex=2 i++
		 * i=4 4<4 false 循环结束
		 * 
		 */
		for (int i = 0; i < arr.length; i++) {
			if (arr[maxIndex] < arr[i]) {
				maxIndex = i;
			}
		}
		System.out.println(maxIndex);
		
	}

}

package com.qfedu.c_array;

public class Demo9 {
	public static void main(String[] args) {
		int[] arr = {3,4,2,6,8,7};
		int max = maxIndexOfArray(arr);
		System.out.println(max);
	}
	//求一个数组中的最大值的索引下标
	public static int maxIndexOfArray (int[] arr) {
		int maxIndex = 0;
		for (int i = 0; i < arr.length; i++) {
			if (arr[maxIndex] < arr[i]) {
				maxIndex = i;
			}
		}
		return maxIndex;
	}

}

作业：

我的意见：

如果你有基础想挑战一下，可以写一下

如果是零基础的，建议将今天数组搞懂，去看预习视频。

1.需求：定义一个方法，找出int数组中，最大值的索引下标
[1,2,23,5,6,7,8]  打印出来2
2.需求：定义一个方法，找出int数组中，最小值的索引下标
3.需求：定义一个方法，在指定的int数组中找出指定的数据第一个的下标
		8这个数的下标
[1,2,8,4,5,78,7,8,9]

4. 在一个数组中，找出所有的 指定数据的下标位置 【难】
	找出所有的下标存倒数组中
		8这个数的下标
[1,2,8,4,5,7,8,7,8,9]
5. 完成一个方法，替换掉数组中所有元素为0的元素，替换为指定元素  [1,2,3,0,0,0]
6. 完成一个方法，删除指定下标的元素，要求从删除位置开始，之后的元素整体前移。【难】
	[1,2,3,4,5,6,7]=>[1,2,4,5,6,7,0]
7. 完成一个方法，添加指定元素到指定下标位置，要求从指定下标位置之后的元素，整体向后移动。【难】
	[1,2,3,4,5,0]=>[1,2,250,3,4,5]

8. 找出数组中最大的元素，放到下标为0的位置

9. 在上一道题的基础上，不考虑下标为0的元素。
   找出数组中最大的元素，放到下标为1的位置

想挑战一下，可以写一下

如果是零基础的，建议将今天数组搞懂，去看预习视频。

1.需求：定义一个方法，找出int数组中，最大值的索引下标
[1,2,23,5,6,7,8]  打印出来2
2.需求：定义一个方法，找出int数组中，最小值的索引下标
3.需求：定义一个方法，在指定的int数组中找出指定的数据第一个的下标
		8这个数的下标
[1,2,8,4,5,78,7,8,9]

4. 在一个数组中，找出所有的 指定数据的下标位置 【难】
	找出所有的下标存倒数组中
		8这个数的下标
[1,2,8,4,5,7,8,7,8,9]
5. 完成一个方法，替换掉数组中所有元素为0的元素，替换为指定元素  [1,2,3,0,0,0]
6. 完成一个方法，删除指定下标的元素，要求从删除位置开始，之后的元素整体前移。【难】
	[1,2,3,4,5,6,7]=>[1,2,4,5,6,7,0]
7. 完成一个方法，添加指定元素到指定下标位置，要求从指定下标位置之后的元素，整体向后移动。【难】
	[1,2,3,4,5,0]=>[1,2,250,3,4,5]

8. 找出数组中最大的元素，放到下标为0的位置

9. 在上一道题的基础上，不考虑下标为0的元素。
   找出数组中最大的元素，放到下标为1的位置

1.输出1-100之间不能被5整除的数，每5个一行
2.求出1-1/2+1/3-1/4……1/100
3.求1+（1+2）+（1+2+3）+（1+2+3+4）+……+（1+2+……+100）

1.输出1-100之间不能被5整除的数，每5个一行
public static void main(String[] args) {
        int count = 0;  //统计个数
        //先输出所有的数
        for (int i = 0;i <= 100;i++){
            //过滤不能被5整除的 if语句
            if (i % 5 != 0){
                count++;
                System.out.print(i + " ");
                //判断，满五个换行
                if (count % 5 == 0){
                    System.out.println();
                }
            }
        }
    }

2.求出1-1/2+1/3-1/4……1/100
public static void main(String[] args) {
        double sum = 0;
        for (int i = 1;i <= 100;i++){
            //判断是奇数还是偶数
            if(i % 2 == 0){
                sum -= 1.0/i;   //分子1.0保证精度
            } else {            //分母为奇数
                sum += 1.0/i;
            }
        }
        System.out.println(sum);
    }

3.求1+（1+2）+（1+2+3）+（1+2+3+4）+……+（1+2+……+100）
public static void main(String[] args) {
        int sum = 0;
        for (int i=1;i<=100;i++){
            for (int j=1;j<=i;j++){
                sum += j;
            }
        }
        System.out.println(sum);
    }