Java语言基础(数组概述和定义格式说明)
A:为什么要有数组
现在需要统计某公司员工的工资情况，例如计算平均工资、找到最高工资等。假设该公司有80名员工，
用前面所学的知识，程序首先需要声明80个变量来分别记住每位员工的工资，然后在进行操作，这样做会显得很麻烦。
为了解决这种问题，Java就提供了数组供我们使用
结论：
数组是存储多个变量(元素)的东西(容器)
这多个变量的数据类型要一致
B:数组概念
数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
数组既可以存储基本数据类型，也可以存储引用数据类型(后面讲解)。
C:数组定义格式
格式1： 数据类型[] 数组名；
格式2： 数据类型 数组名[];
举例：
int[] a； 定义了一个int类型的数组a；
int a[]; 定义了一个int类型的a数组；
推荐使用第一种定义方式。
Java语言基础(数组的初始化动态初始化)
A:什么是数组的初始化
Java中的数组必须先初始化,然后才能使用。
所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
B:初始化的分类：
a:动态初始化: 只指定长度，由系统给出初始化值
b:静态初始化: 给出初始化值，由系统决定长度
注意事项： 这两种方式，只能使用一种，不能进行动静结合
C:动态初始化的格式：
数据类型[] 数组名 = new 数据类型[数组长度];
数组长度其实就是数组中元素的个数。
举例： int[] arr = new int[3]; 定义了一个int类型的数组arr，这个数组可以存放3个int类型的值。
Java语言基础(Java中的内存分配以及栈和堆的区别)
Java虚拟机在执行Java程序的过程中会把它管理的内存划分成若干个不同的数据区域
A:栈: 存放的是局部变量
局部变量：在方法定义中或者方法声明上的变量都是局部变量。
B:堆: 存放的是所有new出来的东西
特点：
a: 每一个new出来的东西都会为其分配一个地址值。
b: 每一个变量都有一个默认的值
byte，short，int，long -- 0
float，double -- 0.0
char -- '\u0000'
boolean -- false
引用数据类型 -- null
c: 使用完毕就变成了垃圾，等待垃圾回收器对其回收
C:方法区:(面向对象部分讲解)
D:本地方法区:(和系统相关)
E:寄存器:(cpu使用)
Java虚拟机在执行Java程序的过程中会将其管理的内存划分为若干个不同的数据区域，这些区域有各自
的用途、创建和销毁的时间，有些区域随虚拟机进程的启动而存在，有些区域则是依赖用户线程的启动和
结束来建立和销毁。Java虚拟机所管理的内存包括以下几个运行时数据区域，如图：
Java语言基础(数组的内存图解1一个数组)
Java语言基础(数组的内存图解2二个数组)
Java语言基础(数组的内存图解3三个引用2个数组)
Java语言基础(数组的初始化静态初始化及内存图)
静态初始化的格式：
格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
举例： int[] arr = new int[]{1,2,3};
简化格式：
数据类型[] 数组名 = {元素1,元素2,…};
举例： int[] arr = {1,2,3};
B:画图演示
a：定义一个数组，输出数组名称和数组中的元素值
Java语言基础(数组操作的两个常见小问题越界和空指针)
案例演示
a:ArrayIndexOutOfBoundsException:数组索引越界异常
原因：你访问了不存在的索引。
b:NullPointerException:空指针异常
原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。package org.westos.demo2; public class MyTest { public static void main(String[] args) { //你使用数组时，经常会遇到，数组角标越界异常 int[] arr = new int[]{20, 200, 30}; System.out.println(arr); arr = null; //人为置null System.out.println(arr.length);//NullPointerException 空指针异常 //取元素的时候，角标不对 ArrayIndexOutOfBoundsException 数组索引越界异常 //System.out.println(arr[3]); // arr[4] = 2000; ArrayIndexOutOfBoundsException 数组索引越界异常 } }
Java语言基础(数组的操作1遍历)
数组遍历：就是依次输出数组中的每一个元素。
package org.westos.demo2; public class MyTest2 { public static void main(String[] args) { int[] arr = new int[]{10, 20, 30, 40, 50, 60}; /* System.out.println(arr[0]); System.out.println(arr[1]); System.out.println(arr[2]); System.out.println(arr[3]); System.out.println(arr[4]); System.out.println(arr[5]); */ //数组的遍历 for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } System.out.println("====================================="); //数组的反向遍历 60 50 40 30 20 10 for (int i = arr.length - 1; i >= 0; i--) { System.out.println(arr[i]); } } }
Java语言基础(数组的操作2获取最值)
package org.westos.demo2; public class MyTest3 { public static void main(String[] args) { int[] arr = {10, 20, 6000, 300, 50, 15000, 96, 63}; //获取数组中的最大值 //定义一个参照的元素 int max = arr[0]; for (int i = 1; i < arr.length; i++) { if (arr[i] > max) { max = arr[i]; } } System.out.println("最大值是：" + max); } }package org.westos.demo2; public class MyTest4 { public static void main(String[] args) { int[] arr = {10, 20, 6000, 300, 50, 15000, 96, 63}; int max = getMax(arr);//alt+enter 自动补全 System.out.println("最大值是：" + max); int[] arr2 = {0, -10, 10, 20, 6000, 300, 50, 15000, 96, 63}; int min = getMin(arr2); System.out.println("最小值是：" + min); } public static int getMax(int[] arr) { //获取数组中的最大值 //定义一个参照的元素 int max = arr[0]; for (int i = 1; i < arr.length; i++) { if (arr[i] > max) { max = arr[i]; } } return max; } public static int getMin(int[] arr) { //获取数组中的最大值 //定义一个参照的元素 int min = arr[0]; for (int i = 1; i < arr.length; i++) { if (arr[i] < min) { min = arr[i]; } } return min; } }
Java语言基础(数组的操作3反转)
package org.westos.demo3; public class MyTest { public static void main(String[] args) { // A: // 案例演示: // 数组元素反转(就是把元素对调) //思路：首尾元素，交换值（采用中间变量来交换）遍历一半 int[] arr = {10, 20, 30, 40, 50, 60}; //{60，50,40,30,20,10} for (int i = 0; i < arr.length / 2; i++) { int t = arr[i]; arr[i] = arr[arr.length - 1 - i]; arr[arr.length - 1 - i] = t; } for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } } }
package org.westos.demo3; public class MyTest2 { public static void main(String[] args) { int[] arr = {10, 20, 30, 40, 50, 60, 70, 80, 90}; //{60，50,40,30,20,10} for (int i = 0, j = arr.length - 1; i < j; i++, j--) { int t = arr[i]; arr[i] = arr[j]; arr[j] = t; } for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } } }
package org.westos.demo3; public class MyTest3 { public static void main(String[] args) { // A: // 案例演示: // 数组元素反转(就是把元素对调) //思路：首尾元素，交换值（采用中间变量来交换）遍历一半 int[] arr = {10, 20, 30, 40, 50, 60}; //{60，50,40,30,20,10} //看 听 看懂了 听懂了，--- 自认为掌握了 //调用方法 reverseArr(arr); //遍历 for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } } public static void reverseArr(int[] arr) { for (int i = 0; i < arr.length / 2; i++) { int t = arr[i]; arr[i] = arr[arr.length - 1 - i]; arr[arr.length - 1 - i] = t; } } }
Java语言基础(数组的操作4查表法)
package org.westos.demo4;
import java.util.Scanner;
public class MyTest {
public static void main(String[] args) {
// 案例演示: 数组查表法(根据键盘录入索引,查找对应星期) 根据索引找元素
//定义字符串数组
String[] week = {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期天"};
Scanner sc = new Scanner(System.in);
System.out.println("请输入索引 0--6");
int index = sc.nextInt();
String yuansu = getEle(index, week);
System.out.println(yuansu);
}
public static String getEle(int suoyin, String[] arr) {
if (suoyin >= 0 && suoyin <= 6) {
String ele = arr[suoyin];
return ele;
} else {
return "你查找的元素不存在，请检查你的索引是否输入正确";
}
}
}
Java语言基础(数组的操作5基本查找)
package org.westos.demo4;
import java.util.Scanner;
public class MyTest2 {
public static void main(String[] args) {
//定义字符串数组
//根据元素查索引
String[] week = {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期天"};
Scanner sc = new Scanner(System.in);
System.out.println("请输入星期");
// nextLine();录入的是字符串
String s = sc.nextLine();
int index = getIndexByEle(s, week);
System.out.println("该元素的索引是：" + index);
}
/**
* @param ele 要找的元素
* @param arr 数组
* @return
*/
public static int getIndexByEle(String ele, String[] arr) {
for (int i = 0; i < arr.length; i++) {
//判断两个字符串，字面上的内容是否一样，不要用 == 号 ，用 equals()方法来判断
if (arr[i].equals(ele)) { //星期一 == 星期一 判断字面上内容是否相同，判别不出来，要调用 equals()方法来判断
return i;
}
}
return -1; //-1 约定俗成 -1 表示没找到
}
}
Java语言基础(二维数组概述和格式1的讲解)
A:二维数组概述
我们学校的Java基础班每个班有很多个学生，所以，可以用数组来存储，而我们又同时有很多个Java基础班。
这个也应该用一个数组来存储。如何来表示这样的数据呢?Java就提供了二维数组供我们使用
由此可见：其实二维数组其实就是每一个元素为一维数组的数组。
B:二维数组格式1
数据类型[][] 变量名 = new 数据类型[m][n];
m表示这个二维数组有多少个一维数组 必须写上
n表示每一个一维数组的元素个数 可选
举例:
int[][] arr = new int[3][2];
定义了一个二维数组arr
这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]
每个一维数组有2个元素，可以通过arr[m][n]来获取
表示获取第m+1个一维数组的第n+1个元素
C:注意事项
A:以下格式也可以表示二维数组
a:数据类型 数组名[][] = new 数据类型[m][n];
b:数据类型[] 数组名[] = new 数据类型[m][n];
这两种格式不推荐使用
B:注意下面定义的区别
int x,y;
int[] x,y[];
区别是:
int[] x,y[];//定义了两个数组 一个是一维数组x 一个是二维数组y
x=new int[3];
y=new int[3][];
D:案例演示
定义二维数组，输出二维数组名称，输出每一个一维数组名称，输出二维数组的2个元素package org.westos.demo1; public class MyTest { public static void main(String[] args) { //二维数组：元素为一维数组的数组。就是的元素他是一维数组，那么这个数组我们叫做二维数组。 //二维数组的动态初始化语法 // 2 表示二维数组的长度是 2 // 3 表示二维数组中一维数组的长度，那么3这个参数，写与不写还是有区别的。 int[][] arr = new int[2][3]; //其他的写法 int arr2[][] = new int[2][3]; int[] arr3[] = new int[2][3]; } }
Java语言基础(二维数组格式2的讲解及其内存图解)
package org.westos.demo1; public class MyTest2 { public static void main(String[] args) { //二维数组：元素为一维数组的数组。就是的元素他是一维数组，那么这个数组我们叫做二维数组。 //二维数组的动态初始化语法 // 2 表示二维数组的长度是 2 // 3 表示二维数组中一维数组的长度，那么3这个参数，写与不写还是有区别的。 int[][] arr = new int[2][3]; System.out.println(arr[0]); //取的是二维数组中的第一个一维数组 System.out.println(arr[1]); //取的是二维数组中的第二个一维数组 arr[0][0] = 20; arr[0][1] = 30; arr[0][2] = 40; System.out.println(arr[0][0]); System.out.println(arr[0][1]); System.out.println(arr[0][2]); arr[1][0] = 90; arr[1][1] = 100; arr[1][2] = 600; System.out.println(arr[1][0]); System.out.println(arr[1][1]); System.out.println(arr[1][2]); //引用数据类型：数组，类，接口，都属于引用数据类型， 简单些，需要new的都属于引用数据类型。 } }
Java语言基础(二维数组格式3的讲解及其内存图解)
A:二维数组格式3
数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}...};
简化版:
数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
这个格式属于静态初始化:由我们指定具体的元素值,由系统给分配长度
举例:
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
int[][] arr = {{1,2,3},{5,6},{7}};
B:案例演示
定义一个二维数组,打印每一个二维数组中的一维数组,在打印每一个二维数组中的元素package org.westos.demo1; public class MyTest3 { public static void main(String[] args) { //二维数组：元素为一维数组的数组。就是的元素他是一维数组，那么这个数组我们叫做二维数组。 //二维数组的动态初始化语法 // 2 表示二维数组的长度是 2 // 3 表示二维数组中一维数组的长度 如果不指定，那么就不会帮你初始化二维数组中的一维数组。。 int[][] arr = new int[2][]; System.out.println(arr[0]); //取的是二维数组中的第一个一维数组 System.out.println(arr[1]); //取的是二维数组中的第二个一维数组 int[] aa = new int[2]; aa[0] = 100; aa[1] = 200; arr[0] = aa; int[] bb = new int[2]; bb[0] = 30; bb[1] = 50; arr[1] = bb; System.out.println(arr[0]); //取的是二维数组中的第一个一维数组 System.out.println(arr[1]); //取的是二维数组中的第二个一维数组 arr[0][0] = 20; arr[0][1] = 30; arr[1][0] = 50; arr[1][1] = 60; int a = arr[0][0]; int b = arr[0][1]; int c = arr[1][0]; int d = arr[1][1]; System.out.println(a); System.out.println(b); System.out.println(c); System.out.println(d); } }
Java语言基础(二维数组练习1遍历)
A:案例演示
需求：二维数组遍历
外循环控制的是二维数组的长度，其实就是一维数组的个数。
内循环控制的是一维数组的长度。
package org.westos.demo4;
public class MyTest {
public static void main(String[] args) {
int[][] arr = new int[][]{{20, 30}, {50, 30, 39, 36}, {2, 5, 3, 5, 9}};
/*
System.out.println(arr[0][0]);
System.out.println(arr[0][1]);
System.out.println(arr[1][0]);
System.out.println(arr[1][1]);*/
//二维数组的遍历
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
for (int j = 0; j < arr[i].length; j++) {
System.out.println(arr[i][j]);
}
}
}
}
Java语言基础(二维数组练习2求和)
package org.wetos.demo;
public class MyTest3 {
public static void main(String[] args) {
//ctrl+shift+/ 多行注释
/* A:
案例演示
需求：公司年销售额求和
某公司按照季度和月份统计的数据如下：单位(万元)
第一季度：22, 66, 44
第二季度：77, 33, 88
第三季度：25, 45, 65
第四季度：11, 66, 99*/
int[][] arr = new int[4][3];
//ctrl+ / 单行注释
// arr[0][0] = 22;
// arr[0][1] = 66;
// arr[0][2] = 44;
arr[0] = new int[]{22, 66, 44};
arr[1] = new int[]{77, 33, 88};
arr[2] = new int[]{25, 45, 65};
arr[3] = new int[]{11, 66, 99};
//遍历求和
int sum = 0;
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
sum = sum + arr[i][j];
}
}
System.out.println("总销售额是：" + sum + "万元");
System.out.println("================================");
int[][] arr2 = {{22, 66, 44}, {77, 33, 88}, {25, 45, 65}, {11, 66, 99}};
//int x, y; //定义了两个int 类型的变量，一个x 一个y
//定义了两个数组，一个是一维数组x 一个是二维数组y
int[] x, y[];
x = new int[2];
y = new int[2][3];
}
}
B:需求：打印杨辉三角形(行数可以键盘录入)
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1分析：看这种图像的规律
A:任何一行的第一列和最后一列都是1
B:从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。步骤：
A:首先定义一个二维数组。行数如果是n，我们把列数也先定义为n。
这个n的数据来自于键盘录入。
B:给这个二维数组任何一行的第一列和最后一列赋值为1
C:按照规律给其他元素赋值
从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
D:遍历这个二维数组。package org.wetos.demo2; import java.util.Scanner; public class MyTest { public static void main(String[] args) { /* B: 需求：打印杨辉三角形(行数可以键盘录入) 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 1 6 15 20 15 6 1 规律：1.每一行的首尾元素都是1 2. 从第三行开始，第二列开始 中间的数字，等于他上一行的前一列和上一行的本列之和 */ Scanner sc = new Scanner(System.in); System.out.println("请输入行数"); int n = sc.nextInt(); //定义二维数组，让行数和列数一样 int[][] arr = new int[n][n]; //1.首尾元素为1 for (int i = 0; i < arr.length; i++) { arr[i][0] = 1; //arr[i][arr.length - 1] = 1; arr[i][i] = 1; } //设置中间元素 //从第三行开始，第二列开始，中间的数字，等于他上一行的前一列和上一行的本列之和 for (int i = 2; i < arr.length; i++) { for (int j = 1; j <= i - 1; j++) { arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j]; } } //3.打印三角形 for (int i = 0; i < arr.length; i++) { for (int j = 0; j <= i; j++) { System.out.print(arr[i][j] + "\t"); } System.out.println(); } } }
递归的概念
A:递归概述: 方法定义中调用方法本身的现象
B:递归注意事项
要有出口，否则就是死递归
次数不能太多，否则就内存溢出
14万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
