Java学习第六天笔记
1复习 数组概述与格式
A:为什么要有数组
现在需要统计某公司员工的工资情况,例如计算平均工资、找到最高工资等。假设该公司有80名员工,
用前面所学的知识,程序首先需要声明80个变量来分别记住每位员工的工资,然后在进行操作,这样做会显得很麻烦。
为了解决这种问题,Java就提供了数组供我们使用
结论:数组是存储多个变量(元素)的东西(容器)
这多个变量的数据类型要一致
B:数组概念
数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
数组既可以存储基本数据类型,也可以存储引用数据类型(后面讲解)。
C:数组定义格式
格式1: 数据类型[] 数组名;
格式2: 数据类型 数组名[];
举例:
int[] a; 定义了一个int类型的数组a;
int a[]; 定义了一个int类型的a数组;
推荐使用第一种定义方式。
public class MyDemo {
//ctrl+alt+空格 可以手动提示
public static void main(String[] args) {
//方法:对一段功能逻辑的封装,以实现重复调用,提高代码的复用性。
//1.方法定义在类中
//2.方法跟方法是平级关系,不能嵌套定义。
//3.方法不调用不执行。
//retrun 结束并返回,如果方法明确了返回值类型,那么必须由retrun带回一个与明确类型一致的结果。
//如果是void 那么retrun可以省略不写。
//你以后定义一个方法,要明确两个东西 返回值 参数
//方法重载:允许一个类中,定义多个同名方法,只要他们的参数个数或参数类型不同即可。跟返回值类型没关系。
//数组:是一个容器,可以存储多个相同数据类型的元素。
//数组即可以存储基本数据类型,也可以存储引用数据类型
//引用数据类型:数组 类 接口 等
//数组必须初始化才能使用。
//所谓初始化,就是为数组开辟内存空间,并未数组元素赋值。
/* B:
初始化的分类:
a:
动态初始化:
只指定长度,由系统给出初始化值
b:
静态初始化:
给出初始化值,由系统决定长度
数组的元素会编有索引,从0开始。
我们根据索引可以获取数组元素的值,也可以给数组元素重新赋值。
*/
}
}
2.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使用)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-33IIDnaM-1586269524976)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\1586268828927.png)]
3数组的初始化
A:什么是数组的初始化
Java中的数组必须先初始化,然后才能使用。
所谓初始化:就是为数组中的数组元素分配内存空间,并为每个数组元素赋值。
B:初始化的分类:
a:动态初始化: 只指定长度,由系统给出初始化值
b:静态初始化: 给出初始化值,由系统决定长度
注意事项: 这两种方式,只能使用一种,不能进行动静结合
C:动态初始化的格式:
数据类型[] 数组名 = new 数据类型[数组长度];
数组长度其实就是数组中元素的个数。
举例: int[] arr = new int[3]; 定义了一个int类型的数组arr,这个数组可以存放3个int类型的值。
D:案例演示
输出数组名称和数组元素
动态初始化
public static void main(String[] args) {
//数组的动态初始化
int[] arr=new int[3];
//方式2 不推荐
//int arr2[] = new int[3];
}
数组的静态初始化
A:静态初始化的格式:
格式:数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
举例: int[] arr = new int[]{1,2,3};
简化格式:
数据类型[] 数组名 = {元素1,元素2,…};
举例: int[] arr = {1,2,3};
B:画图演示
a:定义一个数组,输出数组名称和数组中的元素值
public static void main(String[] args) {
//数组的静态初始化:由系统计算长度,由我们给元素赋值
int[] arr=new int[]{10,20,30,40,50};
System.out.println(arr);
arr[0]=100;
System.out.println(arr[0]);
System.out.println(arr[4]);
//数组的静态初始化 简写语法 省略掉new
int[] arr2 = {10, 20, 30, 40, 50};
}
3数组的内存分配(一个数组、两个数组、三个数组)
A:定义一个数组,输出数组名称和数组中的元素值,给数组赋值,再次输出数组名称和数组中的元素值
B:定义两个数组,分别输出数组名称和数组中的元素值,分别给两个数组赋值,再次输出数组名称和数组中的元素值J
C:定义第一个数组,定义完毕后,给数组元素赋值。赋值完毕后,再输出数组名称和元素。
定义第二个数组,定义完毕后,给数组元素赋值。赋值完毕后,再输出数组名称和元素。
定义第三个数组,把第一个数组的地址值赋值给它。(注意类型一致),通过第三个数组的名称去把元素重新赋值。
最后,再次输出第一个数组数组名称和元素。
public static void main(String[] args) {
//创建一个数组,看他在内存中如何分配
int[] arr=new int[3];
//打印数组的地址值
System.out.println(arr);
arr[0]=10;
arr[1]=20;
arr[2]=30;
int one=arr[0];
int two = arr[1];
int three = arr[2];
System.out.println(one);
System.out.println(two);
System.out.println(three);
}
public static void main(String[] args) {
int[] arr1 = new int[3];
System.out.println(arr1);
arr1[0]=200;
int[] arr2 = new int[3];
System.out.println(arr2);
arr2[1]=300;
System.out.println(arr1[0]);//200
System.out.println(arr1[1]); //0
System.out.println(arr1[2]); //0
System.out.println(arr2[0]);//0
System.out.println(arr2[1]);//300
System.out.println(arr2[2]);//0
}
public static void main(String[] args) {
int[] arr1=new int[3];
arr1[0]=10;
arr1[1] = 20;
arr1[2] = 30;
int[] arr2 = new int[3];
arr2[0] = 100;
arr2[1] = 200;
arr2[2] = 300;
int[] arr3=arr1;//在数组内存图中,arr3 new出的东西指向arr1的地制值
arr3[0]=60;
arr3[1]=500;
System.out.println(arr1[0]); //60
System.out.println(arr1[1]); //500
System.out.println(arr1[2]); //30
System.out.println("=============================");
System.out.println(arr2[0]); //100
System.out.println(arr2[1]); //200
System.out.println(arr2[2]); //300
System.out.println("=============================");
System.out.println(arr3[0]); //60
System.out.println(arr3[1]); //500
System.out.println(arr3[2]); //30
System.out.println("====================");
//输出数组的地址值
System.out.println(arr1);
System.out.println(arr2);
System.out.println(arr3);
//判断两个地址值是否相等
System.out.println(arr1==arr3);
}
4数组的越界和空指针问题
A:案例演示
a:ArrayIndexOutOfBoundsException:数组索引越界异常
原因:你访问了不存在的索引。
b:NullPointerException:空指针异常
原因:数组已经不在指向堆内存了。而你还用数组名去访问元素。
public static void main(String[] args) {
//数组角标越界问题
//数组一旦定义,那么数组的长度 就不可变化了。
//当你访问了没有对应角标的元素,你会出现角标越界
int[] arr=new int[2];//0 1
//ArrayIndexOutOfBoundsException 数组角标越界异常
//arr[2]=200; //报错
//ArrayIndexOutOfBoundsException 数组角标越界异常
// System.out.println(arr[10]); 报错
System.out.println("==========================");
//空指针异常:NullPointerException 空指针异常
arr = null; //把数组引用人为置null
//arr就指向不到,堆内存的那块空间了
System.out.println(arr.length); //报空指针异常
arr[0]=100;
//如果放在最后,也就是数组用完之后置空,可以让垃圾回收器及早的回收数组的这块空间
// arr = null; //把数组引用人为置null
}
5获取数组中的最大值、最小值
public static void main(String[] args) {
//获取数组中的最大值或最小值
int[] arr = {200, 2100, 300, 800, 8000, -1, 100, 6000, 50};
/* int[] arr = {200,1200};
//获取数组中的最大值
int max=arr[0]>arr[1]?arr[0]:arr[1];
System.out.println(max);*/
//定义一个参照的数
int max = arr[0]; //200
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) { //2100>200
max = arr[i]; // max=8000
}
}
System.out.println("最大值是" + max);
System.out.println("======================");
int min = arr[0]; //200
for (int i = 1; i < arr.length; i++) {
if (arr[i] < min) {
min = arr[i];
}
}
System.out.println("最小值是" + min);
}
6数组的默认属性和数组遍历
public static void main(String[] args) {
//数组的一个默认属性 length 可以获取数组长度
int[] arr=new int[3];
arr[arr.length-1]=100;
//length 数组自带的一个属性,可以动态获取数组的长度
int len=arr.length;
System.out.println(len);
//获取数组的最后一个元素
System.out.println(arr[2]);
//数组最后一个元素的索引=数组的长度-1
System.out.println(arr[arr.length-1]);
}
数组遍历
public static void main(String[] args) {
int[] arr={100,200,300,400,500,600,700};
//获取数组中每一个元素
/* System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);*/
//通过循环,去获取数组中的每一个元素,也叫做数组的遍历
//arr.length.fori 数组遍历快速生成
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
System.out.println("==========================");
//数组的反向遍历 arr.length-1.forr 反向遍历快速生成
for(int i=arr.length-1;i>=0;i--){
System.out.println(arr[i]);
}
}
7数据反转
public static void main(String[] args) {
//1.反转数组中的元素
int[] arr={50,100,200,300,400,500,600,700};
//600 500 400 300 200 100
//思路:遍历一半,首位尾元素交换值 采用中间变量来交换值
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;
}
System.out.println("=================================");
//遍历数组
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+",");
}
}
8根据键盘录入索引查找对应元素
public static void main(String[] args) {
/* A:
案例演示:
数组查表法(根据键盘录入索引, 查找对应星期)
//根据索引找对应的元素
*/
String[] week={"星期一","星期二","星期三","星期四","星期五","星期六","星期日"};
Scanner scanner = new Scanner(System.in);
System.out.println("请输入索引 0-6");
int index= scanner.nextInt();
String ele=getElement(index,week);
System.out.println(ele);
}
private static String getElement(int index, String[] week) {
if(index>=0&&index<=6){
String str = week[index];
return str;
}else{
return "你乱输入,没有查到";
}
}
9根据元素查对应索引
public static void main(String[] args) {
String[] week = {"星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日"};
//根据元素查对应的索引
Scanner scanner = new Scanner(System.in);
System.out.println("请输入星期 星期一--------星期日");
//录入字符串的方法
String s = scanner.nextLine();
int index=getIndex(s,week);//方法调用
System.out.println("该元素对应的索引是:"+index);
}
private static int getIndex(String s, String[] week) {
int index=-1;
for (int i = 0; i < week.length; i++) {
if(week[i].equals(s)){ //"星期三"=="星期三" 这个 == 有可能判断不出来两个字符串是否相等
index=i;
break;
}
}
return index; //-1 就代表没找到
}
private static int getIndex2(String s, String[] week) {
for (int i = 0; i < week.length; i++) {
if (week[i].equals(s)) { //"星期三"=="星期三" 这个 == 有可能判断不出来两个字符串是否相等
return i;
}
}
return -1; //-1 就代表没找到
}
if(week[i].equals(s)){ //"星期三"=="星期三" 这个 == 有可能判断不出来两个字符串是否相等
index=i;
break;
}
}
return index; //-1 就代表没找到
}
private static int getIndex2(String s, String[] week) {
for (int i = 0; i < week.length; i++) {
if (week[i].equals(s)) { //"星期三"=="星期三" 这个 == 有可能判断不出来两个字符串是否相等
return i;
}
}
return -1; //-1 就代表没找到
}