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, 值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};
}
}
脑海里面想到一个问题 第二种声明方式没有对数组进行赋值
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);
}
}
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[下标]
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]);
}
}
}
}
方法的参数可以是八大基本数据类型和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;
}
}
}
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;
}
}
以后还会再讲
目前学到的知识点你只需要关注:栈内存 和堆内存
内存区域的名字 | 作用 |
---|---|
寄存器 | 给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); 在堆区
需求:定义一个方法,找出一个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的位置