学习笔记——Java基础

数组

解决 : 将数据进行存储 ----》引入∶数组

数组的作用:

数组用来存储数据的，在程序设计中，为了处理方便，数组用来将相同类型的若干数据组织起来。这个若干数据的集合我们称之为数组。

public class Exam5 {
    public static void main(String[] args) {
        int[] score = new int[5];
        int sum = 0;
        Scanner sc =  new Scanner(System.in);
        System.out.print("请输入五位学员的成绩：");
        for (int i = 0; i < 5; i++) {
            score[i] = sc.nextInt();
            sum = sum + score[i];
        }
        System.out.println(score[4]);
        // 这里可以读取到数组存储的数据，不会再循环后找不到
        System.out.println("平均分是："+(double)sum/score.length);
    }
}

数组声明：

int [] arr ; int arr[].

数组只声明，不赋值相当于没有定义，不存在内存中；

比如：int[] arr = null; // 此处数组赋值为空，存在。

正常定义数组是 栈中的空间指向堆中的空间，如果定义为null的话，相当于在堆中没有开辟空间，在栈中存的是null。

栈：存放局部变量，形参

堆：new出来的东西

数值创建：

arr = new int[4]; // 给数组开辟一个长度为4的空间。

编译期声明和创建会被合为一句话 : int [ ] arr = new int[4] ;

数组的内存分析：

int [ ] arr = new int[4] ;

堆中存放——>new出来的东西

等号右边的先执行，先在堆中开辟一个空间

arr地址 (16进制) 指向数组下标为 0 的数据存放的地址，然后通过下标取值，int中一个数据占用4个字节，所以其他元素的地址是第一个元素地址加上4乘上下标

数组有默认的初始化值，要看是什么类型的数组:

基本数据类型的数组:

byte[]: 0; short[]:0; int[]:0; long[]:0; float[]:0.0; double[]:0.0

​ char[] : '\u0000'; (\：转义符；u：unicode码) boolean[] : false
引用数据类型的数组: null（string,objecct...）

数组特点：

1.长度是确定的。数组一旦被创建，它的大小就是不可以改变的；

2.其元素的类型必须是相同类型，不允许出现混合类型；

3.数组类型可以是任何数据类型，包括基本类型和引用类型；

4.数组有索引的:索引从0开始，到数组.length-1结束；

5.数组变量相当于引用类型，数组也是对象；

6.按照位置查询的时候，效率非常高。

数组变量属于引用类型,数组也是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中存储的。

数组的遍历：

1.常用for循环：

for(int i=0 ; i<=9 ;i++){
	System.out.println(”第"+(i+l)+"个学生的成绩为:"+scores[i]);
}

2.增强for循环：

（对scores数组进行遍历，遍历出来每个元素都用int类型的num接收）

for (int num: scores){
	system.out.println(num);
}

增强for循环:

优点:代码简单

缺点:单纯的增强 for循环不能涉及跟索引相关的操作

数组的初始化：

静态初始化：

除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。

int[] arr = {12,23,451};

int[] arr = new int[]{12,23,45};

注意:

1.new int[3]{12,23,457}; -----> 错误

2.int[arr ]; arr = {12,23,45]; --->错误(编译不能识别是一个数组)

动态初始化：

数组定义与为数组元素分配空间并赋值的操作分开进行。

int[] arr ;

arr = new int[3]；

arr[0] = 12;

arr[1] = 23;

arr[2] = 45;

默认初始化：

int[] arr = new int[3]

此时数组各个元素均为默认值。

数组的应用：

1. 求数组最大值：

public class Exam7 {
    public static void main(String[] args) {
        int[] arr = {25, 14, 23, 89, 65};
        System.out.println(getMaxNum(arr));
    }
    //定义一个获取数组中最大值的方法，只需要传入形参arr
    public static int getMaxNum(int[] arr) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }
}

内存分析：

步骤:

​ 1、程序两个方法，先走main方法，则在栈中为main方法开辟一个栈帧；

​ 2、main中有一个数组，则在堆中为数组开辟一个空间，存放数组元素，各个元素对应自己的地址以及index;

​ 3、然后在main方法开辟的栈帧中有一个局部变量arr,arr的地址指向堆中arr[0]的地址；

​ 4、开始调用getMaxNum方法，同时将arr这个实参传给getMaxNum方法；

  java方法中的一切都是值传递，所以将实参arr的地址传给getMaxNum方法

​ 5、在栈中为getMaxNum方法开辟一个栈帧，首先入栈的是arr,所以将main中实参arr的地址传给getMaxNum栈帧中的arr，所以getMaxNum中的arr也可以指向堆中的数组了；

​ 6、给max赋值为arr[0]，然后对数组逐步循环判断，循环结束后，return max返回到方法调用处，即输出max，与此同时为getMaxNum开辟的栈帧全部消失，但是堆中的数据不会消失。

方法的实参传递给形参的时候一定要注意:

一切都是值传递:

如果是基本数据类型，那么传递的就是字面值；

如果是引用数据类型，那么传递的就是地址值。

2. 查询问题：

查询指定位置的元素：

查询指定元素的位置：

定义一个方法，查询指定元素：

用for循环以及if判断即可，此处略。

3. 添加元素：

逻辑：

添加元素，需要从后面开始移动元素

import java.util.Arrays;
import java.util.Scanner;

public class Exam8 {
    public static void main(String[] args) {
        int[] arr = {25, 14, 23, 89, 65, 38};
        System.out.print("数组增加前：");
        for (int i = 0; i < arr.length; i++) {
            if (i < arr.length - 1) {
                System.out.print(arr[i] + ",");
            } else {
                System.out.print(arr[i]);
            }
        }
        //System.out.print(Arrays.toString(arr));
        //使用Arrays中的toString方法可以将数组转变为：[25, 14, 23, 89, 65, 38]
        Scanner sc = new Scanner(System.in);
        System.out.print("\n请输入要插入哪个元素位置之后：");
        int j = sc.nextInt();
        System.out.print("请输入要插入的数：");
        int ele = sc.nextInt();

        insertEle(arr, j, ele);

        System.out.print("数组增加后：");
        for (int i = 0; i < arr.length; i++) {
            if (i < arr.length - 1) {
                System.out.print(arr[i] + ",");
            } else {
                System.out.print(arr[i]);
            }
        }
    }
    
    public static void insertEle(int[] arr, int j, int ele){
        for (int i = arr.length - 1; i > j; i--) {
            arr[i] = arr[i - 1];
        }
        arr[j] = ele;
    }
}

4. 删除操作：

逻辑：

删除一个元素后，删除位置之后的元素往前移动位置，最后一个位置为数组类型的默认值。

import java.util.Arrays;
import java.util.Scanner;

public class Exam9 {
    public static void main(String[] args) {
        int[] arr = {25, 14, 23, 89, 65, 38};
        System.out.print("数组删除前：");
        System.out.print(Arrays.toString(arr));

        Scanner sc = new Scanner(System.in);
        System.out.print("\n请输入要删除元素的位置：");
        int j = sc.nextInt();

        delEle(arr, j);

        System.out.print("数组删除后：");
        System.out.print(Arrays.toString(arr));
    }

    public static void delEle(int[] arr, int j) {
        for (int i = j; i <= arr.length-2;i++){
            arr[i] = arr[i+1];
        }
        arr[arr.length-1]= 0;
    }
}

main方法讲解

[1] main方法:程序的入口，在同一个类中，如果有多个方法，那么虚拟机就会识别main方法，从这个方法作为程

序的入口

[2] main方法格式严格要求:

public static void main(String[] args){}

public static --->修饰符，暂时用这个-->面向对象一章void --->代表方法没有返回值对应的类型void

main --->见名知意名字

String[] args ---> 形参 ---》不确定因索

[3] 问题:程序中是否可以有其他的方法也叫main方法?

可以，构成了方法的重载。

​

可变参数

1、概念：作用提供了一个方法，参数的个数是可变的，解决了部分的方法重载问题。

int...num ; double...num ; boolean...num ;

2、方法内对可变参数的处理和数组一样；

3、可变参数 与 单独参数一起时，可变参数需要放在单独的参数前面才能正常编译运行；

4、不建议使用。

Arrays类

方便对于数组的操作

1、toString ：

对数组进行遍历查看的，返回的是一个字符串，这个字符串比较好看。

System.out.println (Arrays.tostring (arr));

2、binarySearch :

二分法查找 : 找出指定数组中的指定元素对应的索引

这个方法的使用前提 : 一定要查看的是一个有序的数组

sort : 排序 --> 升序

Arrays.sort(arr) ;
system.out.println(Arrays.tostring(arr)) ;
system.out.println(Arrays.binarySearch(arr,4));

3、 copyof :

完成数组的复制

int[] arr2= {1,3,7,2,4,8};
int[] newArr = Arrays.copyof(arr2,4) ;
//System.arraycopy(arr2,0,newArr,0，arr2.length);
//第一个0代表从原数组那个位置开始，第二个0代表从新数组那个位置开始，arr2.length代表长度
system.out.println(Arrays.toString(newArr)) ;
//结果为[1,3,7,2]

4、copyOfRange :

区间复制

int[]arr2= {1,3,7,2,4,8};
int[] newArr2 = Arrays.copyOfRange(arr2,1,4);
// [1,4)-->1,2,3 位置
system.out.println(Arrays.tostring(newArr2)) ;
//结果为[3,7,2]

5、equals :

比较两个数组的值是否一样

int[] arr3 = { 1,3,7,2,4,8 );
int[] arr4 = { 1,3,7,2,4,8 };
system.out.println(Arrays.equals(arr3,arr4)); 
// true
System.out.println(arr3==arr4);
//false ==比较左右两侧的值是否相等，比较的是左右的地址值，返回值是false

6、fill :

数组的填充

int[] arr5 = {1,3,7,2,4,8};
Arrays.fail(arr5,10);
System.out.println(arr5);
//将10填进arr5里面的每一个位置
//区间的填充可以用该方法的重载fill(int a,int fromIndex,int toIndex,int value)

数组的复制

System.arraycopy(src,srcPos ,dest ,destPos ,length )

src-源数组。

srcPos -源数组中的起始位置。

dest -目标数组。

destPos -目标数据中的起始位置。

length -要复制的数组元素的数量。

import java.util.Arrays;

public class TestArray{
public static void main (string [] args){
//给一个源数组:
int[] srcArr= {11,22,33,44,55, 66,77,88};
//给一个目标数组:
int[] destArr = new int[ 10];
//复制:
system. arraycopy (srcArr,1,destArr,3,3);
//遍历查看目标数组:
system. out.println (Arrays.toString (destArr));
}
//结果：[0,0,0,22,33,44,0,0,0,0]

二维数组

数组里面放数组

栈中指向第一个堆中的数据，该数据是下一个数组的地址，同时栈也可以指向第二个数组的地址。

二维数组的遍历：

//方式1:外层普通for循环+内层普通for循环:
for(int i= 0;i < arr. length; i++){
	for(int j = 0;j<arr[i].length;j++){
        system.out.print(arr[i][j]+"\t");
    }
		system.out.println();
}

//方式2:外层普通for循环+内层增强for循环:
for (int i=0;i<arr.length;i++){
	for (int num : arr[i]){
		system.out.print(num+"\t") ;
    }
		system.out.println();
}

  //方式3:外层增强for循环+内层增强for循环:
for(int [] a :arr){
	for (int num:a){
		system.out.print(num+"\t") ;
    }
		system.out.println() ;
}

//方式4:外层增强for循环+内层普通for循环:
for(int [] a : arr){
	for (int i=0 ;i<a.length;i++){
		system.out.print (a[i]+"lt");
	}
		system.out.println();
)

二维数组的初始化

1、静态初始化

除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。

eg:

int[][] arr = {{1,23},{4,5,6},{4,5,6,7,8,9,9}};
int[][] arr =new int[][]{{1,2},{4,5,6},{4,5,6,7,8,9,9}};

2、动态初始化

3、默认初始化

教组是引用类型,它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。