一.数组
1.数组的定义与初始化
1.一维数组的初始化
初始化格式如下代码(在下面代码中，数据类型以int举例)
package com.array;
public class ArrayTest14 {
public static void main(String[] args) {
//一维数组静态初始化的完整格式
int[] arr1 = new int[]{1,2,3};
// int[] arr1;
// arr = new int[]{1,2,3};
//一维数组静态初始化的简化格式
int[] arr2 = {1,2,3};
//一维数组的动态初始化
int[] arr3 = new int[3];
// int[] arr3;
// arr3 = new int[3];
}
}
2.二维数组的初始化
二维数组进行动态初始化时，二维数组需要存储一维数组的地址个数需被确定，而一维数组中所需存储的元素个数可以不确定。
注意动态初始化格式：
数据类型[][] 数组名 = new 数据类型[存放一维数组地址个数][一维数组中元素个数];
package com.array;
public class ArrayTest15 {
public static void main(String[] args) {
//二维数组的静态初始化的完整格式
int[][] arr1 = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
// int[][] arr1;
// arr1 = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
//二维数组的静态初始化的简化格式
int[][] arr2 = {{1,2,3},{4,5,6},{7,8,9}};
//二维数组的动态初始化
int[][] arr3 = new int[3][];
//二维数组存储一维数组地址的个数在初始化时必须定义好，
// 而一维数组中所需存储的元素个数可不定义。
}
}
2.数组初始化各种数据类型的默认值
整型byte short int long的默认值为0
浮点型float double的默认值为0.0
字符型char的默认值是空字符
String类的初始值是null
注意空字符与null值是不一样的
3.数组动态初始化与静态初始化在内存中的差别
两种初始化方式内存所需完成的任务是不一样的，所以接下来说一下二者的差异。
1.动态初始化时由我们自己定义的内存的长度，内存自动为数组进行初始化赋值(各个类型初始化默认值在上面的内容已经提到)。
2.静态初始化时我们直接将数据赋值给数组，内存自动计算我们所赋数据的长度来给数组内存的长度进行初始化。
4.数组的操作
1.一维数组
需要注意的是：数组索引都是从0开始到数组长度减一的位置结束。
赋值操作：数组名[索引] = 需要赋入数组的值;
获取数组长度：数组名.length（通过.length属性可以得出数组的长度）
一维数组常用的其它操作：
package com.array;
public class ArrayTest14 {
public static void main(String[] args) {
int[] arr = new int[]{1,2,3};
//数组元素的遍历
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
//数组元素的等值查找
int x = 3;
int index = -1;
for (int i = 0; i < arr.length; i++) {
if(arr[i] == x){
index = i;
}
}
if (index != -1) {
System.out.println("所找值的索引"+index);
}else {
System.out.println("没有这个值");
}
}
}
2.二维数组
赋值操作：数组名[一维数组的索引][一维数组元素的索引];
获取一维数组个数：数组名.length
获取一维数组中元素的个数：数组名[一维数组的索引].length
二维数组常用的其它操作：
package com.array;
public class ArrayTest15 {
public static void main(String[] args) {
int[][] arr1 = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
//二维数组的遍历
for (int i = 0; i < arr1.length; i++) {
for (int j = 0; j < arr1[1].length; j++) {
System.out.println(arr1[i][j]);
}
}
//二维数组的等值查找
int x = 8;
int index = -1;
for (int i = 0; i < arr1.length; i++) {
for (int j = 0; j < arr1[2].length; j++) {
if (arr1[i][j] == x){
index = j;
}
}
if(index != -1){
System.out.println("这个值是索引为"+i+"的一维数组中索引为"+index+"的元素");
}
}
if(index == -1) {
System.out.println("没有这个值");
}
}
}
二.ArrayList的定义与简单应用
1.ArrayList的定义
1.需要注意的是：ArrayList集合不可以使用基本数据类型来定义，但是可以通过类与一些引用类型（列如String类）来定义集合中存储的元素。若没有指定任何类，那么集合可以同时存储各种数据类型的元素。
package com.arraylist;
import java.util.ArrayList;
public class ArrayListTest01 {
public static void main(String[] args) {
//不指定类与引用类型的方式，集合中可以存储多种数据类型的数据。
ArrayList list = new ArrayList<>();
list.add(123);
list.add("你好");
System.out.println(list);
ArrayList<String> list1 = new ArrayList<>();
list1.add("我");
list1.add("爱");
list1.add("你");
list1.add("中");
list1.add("国");
System.out.println(list1);
}
}
2.集合中常用的方法
1.remove(指定元素)删除指定元素，返回是否删除成功。
2.remove(Index)删除索引指定的元素，返回被删除的元素。
3.set(int 索引,"修改的元素")修改索引指定的元素，返回被修改的元素。
4.get(Index)获取索引指定的元素。
5.size()返回集合元素的个数。
6.add(需添加的元素)将元素添加到集合的末尾。
7.add(Index,元素)将元素添加到相应索引的位置。
注意：这些方法都是通过集合名.方法名来进行调用。
package com.arraylist;
import java.util.ArrayList;
public class ArrayListTest01 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
//添加元素
list.add("我");
list.add("爱");
list.add("你");
list.add("中");
list.add("国");
//修改元素
list.set(3,"祖");
//获取数组长度
int l = list.size();
//通过索引删除元素(remove方法也可以通过传入需要删除的值来进行元素的删除)
list.remove(2);
//集合的遍历
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i));
}
System.out.println();//换行
//打印整个集合
System.out.println(list);
}
}
3.数组与ArrayList的区别
1.数组的容量大小是确定的，而ArrayList集合是可以进行动态扩容的。
2.数组内只可以存储相同数据类型的数据，而集合可以存储各种数据类型的数据。
扩展
数组的扩容操作：数组扩容是通过在方法中创建一个新的数组，将原本的数组的元素放入新数组中，再调用方法将新数组的所有元素赋入原本的数组中，这样就实现了数组的扩容。
数组与链表的对比：
1. 存储方式：
- 数组是一种连续存储的数据结构，它在内存中占据一块连续的空间，可以通过索引直接访问元素。
- 链表是一种非连续存储的数据结构，它通过指针将元素连接起来，每个元素存储下一个元素的地址。
2. 插入和删除操作：
- 在数组中，插入和删除操作可能需要移动大量元素，特别是在数组的中间或开头进行操作时，需要移动后续元素，时间复杂度为O(n)。
- 在链表中，插入和删除操作可以在O(1)的时间复杂度内完成，只需要修改相邻元素的指针即可。
3. 时间复杂度：
- 数组可以通过索引直接访问元素，时间复杂度为O(1)。
- 链表需要从头节点开始依次遍历，时间复杂度为O(n)。
当涉及到数组和链表的查找与插入时，它们的时间复杂度有所不同。
数组的查找时间复杂度为O(1)，因为可以通过索引直接访问元素，无需遍历整个数据结构。
数组的插入时间复杂度取决于插入位置。在最坏的情况下，如果需要在数组的开头或中间插入元素，那么需要将插入位置后的所有元素向后移动，时间复杂度为O(n)。在最好的情况下，如果在数组末尾插入元素，则时间复杂度为O(1)。
链表的查找时间复杂度为O(n)，因为需要从头节点开始依次遍历链表来查找目标元素。
链表的插入时间复杂度为O(1)，因为可以在常量时间内完成插入操作，只需要修改相邻元素的指针即可。
4. 空间复杂度：
- 数组的空间复杂度与元素数量成正比。
- 链表的空间复杂度可能会略高于元素数量，因为需要额外存储指针。
总的来说，数组适合随机访问元素，而链表适合频繁的插入和删除操作。在实际应用中，需要根据具体的需求来选择合适的数据结构。
public static void main(String[] args) {
int[] arr = new int[3];
//扩容前遍历
for (int i = 0; i < arr.length; i++) {
System.out.println(i);
}
arr = kR(arr);
System.out.println("****************************");
//扩容后遍历
for (int i = 0; i < arr.length; i++) {
System.out.println(i);
}
}
public static int[] kR(int[] arr){
int[] arr1 = new int[4];
for (int i = 0; i < arr.length; i++) {
arr1[i] = arr[i];
}
return arr1;
}
}
三.方法
1.方法的概念与定义
1.方法的概念：方法（method）是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集。
2.方法的定义
public static 返回值类型 方法名(参数) {
方法体;
return 数据 ;
}
//方法的通用定义格式，定义方法时需要注意需不需要返回值，返回值的类型与是否统一。若不需要返回值则将返回值类型改成void，方法体中的return语句也可以省略。
3. 定义方法需要注意的是
1.方法不能嵌套定义，但是可以写在同一个类中。
2.void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据
2.方法重载
1.方法重载的概念
方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载。
1.多个方法在同一个类中。
2.多个方法具有相同的方法名。
3.多个方法的参数的数据类型不同，参数的数量不同以及参数的顺序不同。
2.方法重载注意事项
1.重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式。
2.重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载(返回值类型不同，但是方法名与参数的数量，类型，顺序相同都不能构成方法重载)
3.方法调用：方法名(参数);
package com.method;
public class method {
public static void main(String[] args) {
//通过 方法名(参数);实现方法的调用
int num = returnNum(666);
System.out.println(num);
}
public static int returnNum(int num){
//方法体是用于实现方法功能的模块
return num;
}
}
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
