数组
容器，可以用来存储同种数据类型的多个值
需要结合隐式转换考虑
容器的类型和存储数据的类型保持一致
数组的定义：
格式一：
数据类型 [] 数组名
int [] array
格式二：
数据类型 数组名 []
int array []
数组初始化：在内存中，为数组容器开辟空间，并将数据存入容器中的过程
数组静态初始化和动态初始化的区别：
动态初始化：手动指定数组长度，由系统给出默认初始化
静态初始化：手动指定数组元素，系统根据元素个数，计算长度
静态初始化：
完整格式：
数据类型 []数组名 = new 数据类型 [ ] {元素1,元素2,元素三,…};
简化格式：
数据类型 []数组名 = {元素1,元素2,元素三,…};
数组长度定义后不变
动态初始化
初始化时只指定数组长度，由系统为数组分配初始值
格式：数据类型[] 数组名 =new 数据类型[数组长度];
数组的地址值：
public class ArrayDemo1 {
public static void main(String[] args) {
int[] arr1 = new int[]{11,12,13,14};
int[] arr2 = {11,12,13,14};
String[] arr3 = new String []{"zhangsan","lisi","wangwu","zhaoliu"};
String[] arr4 = {"zhangsan","lisi","wangwu","zhaoliu"};
double[] arr5 = new double[]{161.5,189.6,179.9,193.8};
double[] arr6 = {161.5,189.6,179.9,193.8};
System.out.println(arr1);//[I@b4c966a
}
}
地址值：[I@b4c966a
地址值的格式含义：[ ：表示是一个数组
I ：表示当前数组里面的元素都是int类型的
@ : 表示一个间隔符号（固定格式）
b4c966a：才是数组真正地址（十六进制）
数组元素访问格式：
数组名[索引];
索引：下标，角标
特点：从0开始，逐个+1，连续不间断
public class ArrayDemo2 {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
//获取数组中的元素
int number = arr[0];
System.out.println(number);
System.out.println(arr[1]);
}
}
数组的内存图：
两个数组指向同一空间的内存图
当两个数组指向同一个小空间时，其中一个数组对小空间中的值发生了改变，那么其他数组再次访问的时候都是修改之后的结果。
数组遍历：
java中，关于数组的一个长度属性，length
调用方式：数组名.length
拓展：
自动生成数组的遍历方式
idea提供的：数组名.fori
常见问题
索引越界
public class ArrayDemo2 {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
//长度5
//最小索引：0
//最大索引：4
System.out.println(arr[10]);
}
}
数组常见操作：
求最值
求和:
import java.util.Random;
public class ArrayDemo3 {
public static void main(String[] args) {
int[] arr = new int[10];
Random r = new Random();
for (int i = 0; i < arr.length; i++) {
int number = r.nextInt(100) + 1;
arr[i] = number;
}
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
System.out.println("所有数据的总和：" + sum);
int temp = sum /arr.length;
System.out.println("平均数"+ temp);
int count = 0;
for (int i = 0; i < arr.length; i++) {
if (temp < arr[i]) {
count++;
}
}
System.out.println("一共有" + count + "个数据比平均数大");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}
交换数据：
定义中间变量
打乱数据：
获取随机索引Random
import java.util.Random;
public class ArrayDemo4 {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
Random r = new Random();
int number = r.nextInt(arr.length);
System.out.println(number);
}
}
实例：
import java.util.Random;
public class ArrayDemo4 {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5};
Random r = new Random();
for (int i = 0; i < arr.length; i++) {
int number = r.nextInt(arr.length);
int temp = arr[i];
arr[i] = arr[number];
arr[number] = temp;
}
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
java内存分配
栈：方法运行时使用的内存，比如main方法运行，进入方法栈中执行
堆：存储对象或者数组，new来创建的，都存储在堆内存中
堆内开发的空间有地址值
方法区：存储可以运行的class文件
本地方法栈：JVM在使用操作系统功能的时候使用
寄存器：给CPU使用
方法
程序中最小的执行单元
main方法,主方法
作用：调用方法（解决代码重复问题） 提高代码复用性、可维护性
把一些代码打包，用的时候就调用
方法定义——一些代码打包
方法调用——手动调用
定义格式
最简单：
public static void 方法名 () {
方法体 (就是打包起来的代码);
}
调用：方法名 () ;
方法必须先定义后调用，否则报错
实例：
public class MethodDemo1 {
public static void main(String[] args) {
//调用方法
playGame();
playGame();
}
//定义一个方法
//放在类内,main方法之外
public static void playGame (){
System.out.println("1");
System.out.println("2");
System.out.println("3");
System.out.println("4");
System.out.println("5");
}
}
public class MethodDemo2 {
public static void main(String[] args) {
student();
}
public static void student(){
System.out.println("张三");
System.out.println("性别男");
System.out.println("20岁");
System.out.println("身高187");
}
}
public class MethodDemo3 {
public static void main(String[] args) {
getSum();
}
public static void getSum(){
int number1 = 10;
int number2 = 20;
int sum = number1 + number2;
System.out.println(sum);
}
}
带参数：
定义：
public static void 方法名(参数) {… …}
调用：
method(变量);
形参：方法定义中参数
实参：方法调用中参数
调用时，形参和实参必须一一对应
带返回值：
格式：
public static 返回值类型方法名(参数) {
方法体;
return 返回值;
}
调用：
直接调用：方法名(实参);
赋值调用：整数类型 变量名 = 方法名 (实参);
输出调用：System.out.println(方法名(实参));
public class MethodDemo4 {
public static void main(String[] args) {
//直接调用
method1(10,30,50);
//赋值调用
int sum = method1(10,30,50);
System.out.println(sum);
//输出调用
System.out.println(method1(10,30,50));;
}
public static int method1(int a, int b,int c) {
return a + b + c;//返回给方法的调用处
}
}
方法注意事项：
方法不调用就不执行
方法与方法是平级关系，不能互相嵌套定义（嵌套调用可以，不能嵌套定义）
方法的编写顺序和执行顺序无关
方法的重载：
在同一类中，定义了多个同名的方法，这些同名的方法具有同种功能
每个方法具有不同参数类型或参数个数
同一个类中，方法名相同，参数不同的方法，与返回值无关
参数不同：个数不同、类型不同、顺序不同
public class MethodDemo5 {
public static void main(String[] args) {
method1((byte)5, (byte)6);
}
public static void method1(byte b1,byte b2) {
System.out.println(b1 == b2);
}
public static void method1(short s1,short s2) {
System.out.println(s1 == s2);
}
public static void method1(int i1,int i2) {
System.out.println(i1 == i2);
}
public static void method1(long o1,long o2) {
System.out.println(o1 == o2);
}
}
练习：
复制数组：
public class MethodDemo6 {
public static void main(String[] args) {
//定义原始数组
int[] arr = {1,2,3,4,5,6,7,8,9};
//调用方法拷贝数据
int [] copyArr = method1(arr,3,7);
//遍历copyArr
for (int i = 0; i < copyArr.length; i++) {
System.out.print(copyArr[i] + " ");
}
}
public static int[] method1(int [] arr,int from,int to) {
//定义数组，动态初始化
int [] newArr = new int[to-from];
//复制数据
//伪造索引的思想
int index = 0;
for (int i = from; i < to; i++) {
newArr[index] = arr[i];
index++;
}
return newArr;
}
}
平方根应用
获取随机数
导包 – Random这个类在哪
import java.util.Random
创建对象
Random r = new Random () ;
上式中只有r是变量名，可以变，其他的都不允许变
接收数据
int number = r.nextInt(随机数范围);
上式中只有number是变量名，可以变，其他都不能变
import java.util.Random;
public class Demo2 {
public static void main(String[] args) {
Random r = new Random();
int number = r.nextInt(9) + 7;// 7~15
System.out.println(number);
}
}
猜数字
import java.util.Random;
import java.util.Scanner;
public class Demo2 {
public static void main(String[] args) {
Random r = new Random();
int number = r.nextInt(100) + 1;// 1~100
Scanner sc = new Scanner(System.in);
while(true){
System.out.println("Enter a number: ");
int guessnumber = sc.nextInt();
if(guessnumber > number) {
System.out.println("大了");
}else if(guessnumber > number) {
System.out.println("小了");
}else {
System.out.println("Guess number is: " + guessnumber);
System.out.println("You guessed correctly!");
break;
}
}
}
}
总结：
本周继续学习java数组和方法相关的基础语法，并进行了相关练习。
下周进行面向对象和管理系统的相关内容的学习。
本周主要问题是学习态度不够积极，学习效率较低，要合理规划时间进行有效学习。