1、数组
1.1数组的介绍：
数组就是存储数据长度固定的容器，存储多个数据的数据类型要一致。
1.2数组的定义：
1.2.1 第一种格式
数据类型[ ] 数组名
示例：
int[] arr; double[] arr; char[] arr;
1.2.2 第二种格式
数据类型 数组名[]
示例：
int arr[]; double arr[]; char arr[];
1.3数组的初始化：
1.3.1动态初始化数组
数组动态初始化就是只给定数组的长度，由系统给出默认初始化值
1.3.1 动态初始化格式
数据类型[] 数组名 = new 数据类型[数组长度];
int[] arr = new int[3];
1.3.2 动态初始化格式详解
-
等号左边：
-
int:数组的数据类型
-
[ ]:代表这是一个数组
-
arr:代表数组的名称
-
-
等号右边：
-
new:为数组开辟内存空间
-
int:数组的数据类型
-
[ ]:代表这是一个数组
-
5:代表数组的长度
-
package com.wedu.array; public class Demo2Array { /* 数组的动态初始化: 在初始化的时候, 需要手动指定数组的长度, 系统会为数组容器分配初始值. 动态初始化格式: 数据类型[] 数组名 = new 数据类型[数组的长度]; 注意: 打印数组变量的时候, 会打印出数组的内存地址 [I@10f87f48 : @ : 分隔符 [ : 当前的空间是一个数组类型 I : 当前数组容器中所存储的数据类型 10f87f48 : 十六进制内存地址 0 1 2 3 4 5 6 7 8 9 a b c d e f */ public static void main(String[] args) { // 数据类型[] 数组名 = new 数据类型[数组的长度]; // 通过new关键字创建了一个int类型的数组容器, 该容器可以存储5个int类型的整数, 该容器被arr数组变量所记录 int[] arr = new int[5]; // [I@10f87f48 System.out.println(arr); byte[] bArr = new byte[3]; // [B@b4c966a System.out.println(bArr); } }
-
1.3.3静态初始化数组
在创建数组时，直接将元素确定
-
完整版格式
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...}; -
简化版格式
数据类型[] 数组名 = {元素1,元素2,...};
示例代码
package com.wedu.array2;
public class Demo1Array {
/*
数组静态初始化 : 初始化时指定每个数组元素的初始值，由系统决定数组长度
完整格式:
数据类型[] 数组名 = new 数据类型[]{数据1,数据2,数据3...};
简化格式:
数据类型[] 数组名 = {数据1,数据2,数据3...};
*/
public static void main(String[] args) {
// 数据类型[] 数组名 = new 数据类型[]{数据1,数据2,数据3...};
int[] arr = new int[]{11,22,33};
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
// 数据类型[] 数组名 = {数据1,数据2,数据3...};
int[] arr2 = {44,55,66};
System.out.println(arr2);
System.out.println(arr2[0]);
System.out.println(arr2[1]);
System.out.println(arr2[2]);
}
}1.4数组的元素访问
1.4.1什么是索引
每一个存储到数组的元素，都会自动的拥有一个编号，从0开始。
这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。
1.4.2访问数组元素的格式
数组名[索引];
示例代码
package com.wedu.array;
public class Demo3ArrayIndex {
/*
数组动态初始化:
初始化的时候, 手动指定数组长度, 系统会为数组容器分配初始值.
数组的元素访问格式:
数组名[索引]
索引: 数组中数据的编号方式, 编号从0开始
作用: 访问数组容器中的空间位置
注意:
数组在创建完毕后, 即使没有赋值, 也可以取出, 但取出的元素都是默认初始化值.
*/
public static void main(String[] args) {
int[] arr = new int[3]; // 0 1 2
System.out.println(arr); // 数组的内存地址 [I@10f87f48
// 数组名[索引] 访问数组容器中的空间位置
System.out.println(arr[0]); // 0 系统自动分配的默认初始化值
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println("--------------");
// 数组名[索引]
arr[0] = 11;
arr[1] = 22;
arr[2] = 33;
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}1.4.2数组的遍历
-
数组遍历：就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。
public class ArrayTest01 { public static void main(String[] args) { int[] arr = { 1, 2, 3, 4, 5 }; 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]); } }以上代码是可以将数组中每个元素全部遍历出来，但是如果数组元素非常多，这种写法肯定不行，因此我们需要改造成循环的写法。数组的索引是 0 到 lenght-1 ，可以作为循环的条件出现。
public class ArrayTest01 { public static void main(String[] args) { //定义数组 int[] arr = {11, 22, 33, 44, 55}; //使用通用的遍历格式 for(int x=0; x<arr.length; x++) { System.out.println(arr[x]); } } }
1.5数组的两个常见问题
1.5.1索引越界
索引越界异常
-
出现原因
public class ArrayDemo { public static void main(String[] args) { int[] arr = new int[3]; System.out.println(arr[3]); } }数组长度为3，索引范围是0~2，但是我们却访问了一个3的索引。
程序运行后，将会抛出ArrayIndexOutOfBoundsException 数组越界异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。
-
解决方案
将错误的索引修改为正确的索引范围即可！
1.5.2空指针异常
-
出现原因
public class ArrayDemo { public static void main(String[] args) { int[] arr = new int[3]; //把null赋值给数组 arr = null; System.out.println(arr[0]); } }arr = null 这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时候会抛出 NullPointerException 空指针异常。在开发中，空指针异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。
-
解决方案
给数组一个真正的堆内存空间引用即可！
1.6基础练习
1.6.1数据交换
案例需求
已知两个整数变量a = 10，b = 20，使用程序实现这两个变量的数据交换 最终输出a = 20，b = 10;
package com.wedu.test;
public class Test1 {
/*
需求：已知两个整数变量a = 10，b = 20，使用程序实现这两个变量的数据交换
最终输出a = 20，b = 10;
思路：
1. 定义一个三方变量temp，将a原本记录的值，交给temp记录 （a的值，不会丢了）
2. 使用 a 变量记录 b 的值，（第一步交换完毕，b的值也丢不了了）
3. 使用 b 变量记录 temp的值，也就是a原本的值 （交换完毕）
4. 输出 a 和 b 变量即可
*/
/*
动态初始化格式：
数据类型[][] 变量名 = new 数据类型[m][n];
m表示这个二维数组，可以存放多少个一维数组
n表示每一个一维数组，可以存放多少个元素
*/
public static void main(String[] args) {
int a = 10;
int b = 20;
// 将a原本记录的值，交给temp记录 （a的值，不会丢了）
int temp = a;
// 用 a 变量记录 b 的值，（第一步交换完毕，b的值也丢不了了）
a = b;
// 使用 b 变量记录 temp的值，也就是a原本的值 （交换完毕）
b = temp;
// 输出 a 和 b 变量即可
System.out.println("a=" + a);
System.out.println("b=" + b);
}
}1.6.2数组反转
案例需求：
请将”我” “爱” “中”“国”存入数组，然后正着和反着输出
package CombinedTraning;
import java.util.Scanner;
public class qwe {
public static void main(String[] args) {
//1.请将”我” “爱” “中”“国”存入数组，然后正着和反着输出
String[] arr={"我","爱","中","国"};
//正向
for (String s : arr) {
System.out.print(s+" ");
}
//定义两个指针
int left=0;
int right= arr.length-1;
for (int i = 0; i < arr.length; i++) {
if (left<right) {
String temp = arr[left];
arr[left] = arr[right];
arr[right] = temp;
}
left++;right--;
}
System.out.println();
//逆向
for (String s : arr) {
System.out.print(s+" ");
}
}
}1.7二维数组
1.7.1 二维数组概述
概述 : 二维数组也是一种容器，不同于一维数组，该容器存储的都是一维数组容器
1.7.2静态初始化
*完整格式 :** 数据类型[][] 变量名 = new 数据类型[][]{ {元素1, 元素2...} , {元素1, 元素2...}
**简化格式 :** 数据类型[][] 变量名 = { {元素1, 元素2...} , {元素1, 元素2...} ...};
代码实现
package com.wedu.demo;
public class Demo3Array {
/*
完整格式：数据类型[][] 变量名 = new 数据类型[][]{ {元素1, 元素2...} , {元素1, 元素2...} ...};
简化格式: 数据类型[][] 变量名 = { {元素1, 元素2...} , {元素1, 元素2...} ...};
*/
public static void main(String[] args) {
int[] arr1 = {11,22,33};
int[] arr2 = {44,55,66};
int[][] arr = {{11,22,33}, {44,55,66}};
System.out.println(arr[0][2]);
int[][] array = {arr1,arr2};
System.out.println(array[0][2]);
}
}1.7.3二维数组的动态初始化
动态初始化格式：
数据类型[][] 变量名 = new 数据类型[m][n];
m表示这个二维数组，可以存放多少个一维数组
n表示每一个一维数组，可以存放多少个元素
package com.wedu.demo;
public class Demo1Array {
/*
动态初始化格式：
数据类型[][] 变量名 = new 数据类型[m][n];
m表示这个二维数组，可以存放多少个一维数组
n表示每一个一维数组，可以存放多少个元素
*/
public static void main(String[] args) {
// 数据类型[][] 变量名 = new 数据类型[m][n];
int[][] arr = new int[3][3];
/*
[[I@10f87f48
@ : 分隔符
10f87f48 : 十六进制内存地址
I : 数组中存储的数据类型
[[ : 几个中括号就代表的是几维数组
*/
System.out.println(arr);
/*
二维数组存储一维数组的时候, 存储的是一维数组的内存地址
*/
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[0][0]);
System.out.println(arr[1][1]);
System.out.println(arr[2][2]);
// 向二维数组中存储元素
arr[0][0] = 11;
arr[0][1] = 22;
arr[0][2] = 33;
arr[1][0] = 11;
arr[1][1] = 22;
arr[1][2] = 33;
arr[2][0] = 11;
arr[2][1] = 22;
arr[2][2] = 33;
// 从二维数组中取出元素并打印
System.out.println(arr[0][0]);
System.out.println(arr[0][1]);
System.out.println(arr[0][2]);
System.out.println(arr[1][0]);
System.out.println(arr[1][1]);
System.out.println(arr[1][2]);
System.out.println(arr[2][0]);
System.out.println(arr[2][1]);
System.out.println(arr[2][2]);
}
}1.7.4二维数组访问元素的细节问题
问题 : 二维数组中存储的是一维数组, 那能不能存入 [提前创建好的一维数组] 呢 ?
代码实现：
package com.wedu.demo;
public class Demo2Array {
/*
问题: 二维数组中存储的是一维数组, 那能不能存入 [提前创建好的一维数组] 呢 ?
答 : 可以的
*/
public static void main(String[] args) {
int[] arr1 = {11,22,33};
int[] arr2 = {44,55,66};
int[] arr3 = {77,88,99,100};
int[][] arr = new int[3][3];
arr[2][3] = 100;
arr[0] = arr1;
arr[1] = arr2;
arr[2] = arr3;
System.out.println(arr[1][2]);
System.out.println(arr[2][3]);
}
}1.7.5二维数组的遍历
案例需求
求一个3*3矩阵对角线元素之和，要求矩形里面的值为随机赋值
代码实现
int[][] dimensionalArray=new int[3][3];
Random r=new Random();
for (int i = 0; i < dimensionalArray.length; i++) {
for (int j = 0; j < dimensionalArray[i].length; j++) {
dimensionalArray[i][j]=r.nextInt(10);//随机赋值0~10
}
}
//打印出来
for (int i = 0; i < dimensionalArray.length; i++) {
for (int j = 0; j < dimensionalArray.length; j++) {
System.out.print(dimensionalArray[i][j]+" ");
}
System.out.println();
}
//对角线元素求和
int sum1=0;
int sum2=0;
int sum3=0;
for (int i = 0; i < dimensionalArray.length; i++) {
//正对角线
sum1+=dimensionalArray[i][i];
//副对角线
sum2+=dimensionalArray[i][2-i];
}
//中间的元素算了两次，得减去一次
sum3=(sum1+sum2)-dimensionalArray[1][1];
System.out.println("对角线元素之和为："+sum3);2、ArrayList集合
（浅浅了解）
3、方法（函数）
3.1方法概述
方法（method）是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集
-
注意：
-
方法必须先创建才可以使用，该过程成为方法定义
-
方法创建后并不是直接可以运行的，需要手动使用后，才执行，该过程成为方法调用
-
3.2方法的定义和调用
3.2.1无参数方法的定义和调用
定义格式：
public static void 方法名 ( ) {
// 方法体;
}
范例：
public static void method ( ) {
// 方法体;
}
调用格式：
方法名();
method();
-
注意：
方法必须先定义，后调用，否则程序将报错
3.3带参数方法的定义和调用
-
定义格式：
参数：由数据类型和变量名组成 - 数据类型 变量名
参数范例：int a
public static void 方法名 (参数1) { 方法体; } public static void 方法名 (参数1, 参数2, 参数3...) { 方法体; } -
范例：
public static void isEvenNumber(int number){ ... } public static void getMax(int num1, int num2){ ... }-
注意：
方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序将报错 方法定义时，多个参数之间使用逗号( ，)分隔
-
-
调用格式：
方法名(参数)； 方法名(参数1,参数2);
-
范例：
isEvenNumber(10); getMax(10,20);
-
方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序将报错
-
方法练习：判断一个数是奇数还是偶数
public class Demo1Method {
/*
带参数方法的定义格式:
public static void 方法名 ( 参数 ) { … … }
public static void 方法名 ( 数据类型 变量名 ) { … … }
带参数方法的调用格式:
方法名 ( 参数 ) ;
方法名 ( 变量名/常量值 ) ;
tips: 参数可以是一个, 也可以是多个.
需求: 判断一个数是奇数还是偶数
*/
public static void main(String[] args) {
isEvenNumber(10);
}
public static void isEvenNumber(int num){
if(num % 2 == 0){
System.out.println("偶数");
}else{
System.out.println("奇数");
}
}
}3.4带返回值方法的定义和调用
-
定义格式
public static 数据类型 方法名 ( 参数 ) { return 数据 ; } -
范例
public static boolean isEvenNumber( int number ) { return true ; } public static int getMax( int a, int b ) { return 100 ; }-
注意：
-
方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错
-
-
-
调用格式
方法名 ( 参数 ) ; 数据类型 变量名 = 方法名 ( 参数 ) ;
-
范例
isEvenNumber ( 5 ) ; boolean flag = isEvenNumber ( 5 );
-
注意：
-
方法的返回值通常会使用变量接收，否则该返回值将无意义
-
-
-
案例需求：设计一个方法可以获取两个数的较大值，数据来自于参数
-
思路：
-
定义一个方法，声明两个形参接收计算的数值，求出结果并返回
-
使用 if 语句 得出 a 和 b 之间的最大值，根据情况return具体结果
-
在main()方法中调用定义好的方法并使用 【 变量保存 】
-
-
代码：
public static void main(String[] args) { // 3. 在main()方法中调用定义好的方法并使用 【 变量保存 】 System.out.println(getMax(10,20)); // 输出调用 int result = getMax(10,20); System.out.println(result); for(int i = 1; i <= result; i++){ System.out.println("HelloWorld"); } } // 方法可以获取两个数的较大值 public static int getMax(int a, int b){ if(a > b){ return a; }else{ return b; } } }
3.5方法的重载
-
方法重载概念
方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载
-
多个方法在同一个类中
-
多个方法具有相同的方法名
-
多个方法的参数不相同，类型不同或者数量不同
-
-
注意：
-
重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式
-
重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载
-
正确范例：
public class MethodDemo { public static void fn(int a) { //方法体 } public static int fn(double a) { //方法体 } } public class MethodDemo { public static float fn(int a) { //方法体 } public static int fn(int a , int b) { //方法体 } }方法重载练习：
-
需求：使用方法重载的思想，设计比较两个整数是否相同的方法，兼容全整数类型（byte,short,int,long）
-
思路：
①定义比较两个数字的是否相同的方法compare()方法，参数选择两个int型参数
②定义对应的重载方法，变更对应的参数类型，参数变更为两个long型参数
③定义所有的重载方法，两个byte类型与两个short类型参数
④完成方法的调用，测试运行结果
-
public class MethodTest {
public static void main(String[] args) {
//调用方法
System.out.println(compare(10, 20));
System.out.println(compare((byte) 10, (byte) 20));
System.out.println(compare((short) 10, (short) 20));
System.out.println(compare(10L, 20L));
}
//int
public static boolean compare(int a, int b) {
System.out.println("int");
return a == b;
}
//byte
public static boolean compare(byte a, byte b) {
System.out.println("byte");
return a == b;
}
//short
public static boolean compare(short a, short b) {
System.out.println("short");
return a == b;
}
//long
public static boolean compare(long a, long b) {
System.out.println("long");
return a == b;
}
}（简易版思维导图）
扫一扫
1383
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
