JAVA数组 day03

最新推荐文章于 2024-11-03 11:01:20 发布

大数据白白

最新推荐文章于 2024-11-03 11:01:20 发布

阅读量76

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_53597801/article/details/125929942

版权

数组

静态初始化数组

定义数组后直接赋值
格式：数据类型[] 数组名 = new 数据类型[]{元素1，元素2......}；

//例如
double [] source = new double[]{89,54,65,14,8}

也可以简化为：数据类型 [] 数组名 = {元素1，元素2，.....}

//例如
int [] souce = {54,12,96,45,74}

注意：数组变量名中储存的是地址即数组在内存中的地址，数组是引用类型

数组的访问

public class ArrayDome {
    public static void main(String[] args) {
        int[] arr = {111,22,33,44};
        arr[2] = 555;
        System.out.println(arr[2]);
        System.out.println(arr.length);
    }
}

注意：数组中的元素类型必须是相同类型的
注意：数据类型[] 数组名也可以写成数据类型数组名[]
注意：数组一旦被定义出来，程序执行过程中长度、类型就被固定了不可更改

动态初始化数组

定义数组时只给类型与长度
格式：数据类型[] 数组名 = new 数据类型[长度]

数组的遍历

遍历便利就是一个一个得的访问数据

数组的案例

求和

public class ArrayDome {
    public static void main(String[] args) {
        int[] arr = new int[]{1,2,3,4,5,6};
        int sum = 0;
        for (int i=0;i< arr.length;i++) {
            sum +=arr[i];
            System.out.println(arr[i]);
        }
        System.out.println(sum);

    }
}

求最值

package Array;

public class ArrayDome {
    public static void main(String[] args) {
        //数组元素求最值
        int[] arr = new int[]{10,24,34,48,45,6};
        int max = arr[0];
        for (int i=0;i< arr.length;i++) {
            max = max>arr[i]?max:arr[i];
        }
        System.out.println(max);
    }
}

猜数字游戏

package Array;
import java.util.Random;
import java.util.Scanner;
public class ArrayDome {
    public static void main(String[] args) {
        //猜字小游戏
        int[] arr = new int[5];
        Random r = new Random();
        Scanner sc = new Scanner(System.in);
        for (int i=0;i< arr.length;i++) {
            arr[i] = r.nextInt(20)+1;
        }
        OUT:
        while (true){
            System.out.print("请输入一个在1-20之间的整数");
            int guess = sc.nextInt();
            for (int i = 0; i < arr.length; i++) {
                if(arr[i]==guess){
                    System.out.println("你猜中了");
                    break OUT;//结束OUT下的循环
                    }
                }
            System.out.println("数组中不存在这个数,再猜");
            }
        System.out.println("数组中的内容为");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"\t");
        }
        }
    }

随机排名

package Array;
import java.util.*;
public class ArrayDome1 {
    public static void main(String[] args) {
        //随机打乱工号
        Random r = new Random();
        Scanner sc =new Scanner(System.in);
        int[] job_number = new int[5];
        for (int i = 0; i < job_number.length; i++) {
            System.out.print("请输入第"+i+"未员工的工号");
            int number = sc.nextInt();
            job_number[i] = number;
        }
        for (int i = 0; i < job_number.length; i++) {
            int index = r.nextInt(job_number.length);
            int temp = job_number[index];
            job_number[index]=job_number[i];
            job_number[i]=temp;
        }
        for (int i = 0; i < job_number.length; i++) {
            System.out.print(job_number[i]+"\t");
        }
    }
}

冒泡排序

package Array;

public class Arraydome2 {
    public static void main(String[] args) {
        int[] arr = new int[] {4,8,7,7,10,11,12,6,9,11,12,1,5};
        for (int i=1;i<=arr.length;i++){
            for (int j=0;j<arr.length-1;j++){
                if (arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"\t");
        }
    }
}

数组内存图

Java内存分配

栈

栈内存首先是一片内存区域，存储的都是局部变量，凡是定义在方法中的都是局部变量（方法外的是全局变量），for循环内部定义的也是局部变量，是先加载函数才能进行局部变量的定义，所以方法先进栈，然后再定义变量，变量有自己的作用域，一旦离开作用域，变量就会被释放。栈内存的更新速度很快，因为局部变量的生命周期都很短。

堆

存储的是数组和对象（其实数组就是对象），凡是new建立的都是在堆中，堆中存放的都是实体（对象），实体用于封装数据，而且是封装多个（实体的多个属性），如果一个数据消失，这个实体也没有消失，还可以用，所以堆是不会随时释放的，但是栈不一样，栈里存放的都是单个变量，变量被释放了，那就没有了。堆里的实体虽然不会被释放，但是会被当成垃圾，Java有垃圾回收机制不定时的收取。

方法区

存放class文件的地方，所有方法都在里面

本地方法栈

寄存器

数组使用的常见问题

问题一：如果访问的最大索引超过最大索引，会报错ArrayIndexOutOfBroundsException
如果数组变量中没有存储数组的地址,而是null,在访问数组信息时会出现NullPointerException(空指针异常)

DeBug工具的使用

断点调试工具

方法

方法是生么

方法是一种语法结构他可以把一段代码封装成一个功能，以便反复调用。

使用方法的好处

提高代码的复用性
让程序逻辑清晰

方法定义的格式

修饰符返回值的类型方法名（形参列表）{

方法体代码

return 返回值；

}

注意：没有返回值也可以使用return立即跳出此方法

示例：

package Method;

public class MethodDome {
    public static void main(String[] args) {
        System.out.println(add(1,2));
    }
    public static int add(int a,int b){
        int c = a+b;
        return c;
    }
}

注意：不要将定义的方法放到main方法中
注意：返回值类型必须与返回值的类型相对应
注意：没有返回值类型必须声明时void
注意：如果声明了返回值类型就必须有return
注意：一个方法中return后面的代码不会被执行。
目前先使用public static

案例

判断输入数字是偶数还是奇数

package Method;

public class MethodDome {
    public static void main(String[] args) {
        check(5);
    }
    public static void check(int input){
        if (input%2==1){
            System.out.println("是奇数");
        }else{
            System.out.println("是偶数");
        }
    }
}

返回任意整形数组的·最大值

package Method;

public class MethodDome {
    public static void main(String[] args) {
    int[] arr = {1,3,5,7,3,4,6,8};
        System.out.println(getArrayMax(arr));
    }
    public static int getArrayMax(int[] arr){
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i]>max){
                max = arr[i];
            }
        }
        return max;
    }
}

注意：参数列表中传输的是列表的地址

方法的传递机制

基本数据类型的传递机制

java基本数据类型的参数传递机制：值传递

在传输实参给方法的形参的时候，并不是传输实参本身，而是传输实参变量中储存的值。
形参：如定义的变量
实参：如在定义方法时，“（）”中所声明的参数

引用数据类型的传递机制

java引用数据类型的参数传递机制：值传递

传递的是地址，Array在方法中值被改变，main也会被改变

案例

打印像这样的数组[1,4,2,5,1,5,9]

package Method;

public class ArrayPrint {
    public static void main(String[] args) {
        int[] arr = {5,4,1,8,6,8,1,5};
        ArrayPrint(arr);
    }
    public static void ArrayPrint(int[] arr){
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (arr!=null && arr.length>0){
                System.out.print(i==arr.length-1 ? arr[i]:arr[i]+", ");
            }
        }
        System.out.print("]");
    }
}

设计一个方法可以接收整型数组，和要查询的元素值;最终要返回元素在该数组中的索引，如果数组中不存在该元素则返回-1。不存在该元素则返回-1.

package Method;

public class GetIndex {
    public static void main(String[] args) {
        int[] arr = {1,5,8,11,6,7,18};
        getIndex(arr,8);
    }
    public static int getIndex(int[] arr,int input){
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]==input){
                System.out.println(i);
                return i;
            }
        }
        return -1;
    }
}

方法重载

同一个类中，出现多个同名的方法，但是形参的列表是不同的，那么这种方法就是方法重载

案例

package Method;

public class GetIndex {
    public static void main(String[] args) {
        fire();
        fire("M国");
        fire(9, "M国");
    }
    public static void fire(){
        System.out.println("发射一枚武器");
        }
    public static void fire(String Loaction){
        System.out.println("发射一枚武器到"+Loaction);
    }
    public static void fire(int number, String Loaction){
        System.out.println("发射"+number+"枚武器到"+Loaction);
    }
    }

方法重载的优势
可读性强

方法重载的识别技巧

基础篇案例

买飞机票

package com.practise;
import java.util.Scanner;
public class Tese1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入购买的原价");
        double money = sc.nextInt();
        System.out.println("请输入购买的月份");
        int month = sc.nextInt();
        System.out.println("请输入购买的仓位");
        String type = sc.next();
        System.out.println(calc(money,month,type));
    }
    public static double calc(double money, int month, String type){
        //旺季
        if(month>=5 && month<=10){
            switch(type){
                case "经济舱":
                    money *=0.85;
                break;
                case "头等舱":
                    money *=0.9;
                    break;
                default:
                    System.out.println("您的输入有误");
                    break;
            }
        }else if(month==11 || month==12 || month<5 && month>0){
            //淡季
            switch(type){
                case "经济舱":
                    money *=0.65;

                break;
                case "头等舱":
                    money *=0.7;
                break;
                default:
                    System.out.println("您的输入有误");
                    break;
            }
        }else {
            System.out.println("您的输入有误");
        }
        return money;
    }
}

打印素数

package com.practise;

public class Tese2 {
    public static void main(String[] args) {
        numer(100,200);
    }
    public static void numer(int start, int end){
        for (int i = start; i <end ; i++) {
            boolean flag =true;
            for (int j = 2; j < i/2; j++) {
                if(i%j==0){
                    flag = false;
                    break;
                }
            }
            if (flag){
                System.out.print(i+" ");
            }
        }
    }
}

生成验证码

 package com.practise;
import java.util.Random;
public class Test3 {
    public static void main(String[] args) {
        System.out.println(createCode(10));
    }
    public static String createCode(int n){
        Random r = new Random();
        String code = "";
        for (int i = 0; i < n; i++) {
            int type = r.nextInt(3);
            switch(type){
                case 0:
                    code +=  r.nextInt(10);
                    break;
                case 1:
                    code += (char) (r.nextInt(26)+65);
                    break;
                case 2:
                    code += (char) (r.nextInt(26)+97);
                    break;
            }
        }
        return code;
    }
}

双色球

package com.practise;
import java.sql.SQLOutput;
import java.util.*;
public class Test4 {
    public static void main(String[] args) {
        lunckNumber();
    }
    public static void lunckNumber(){
        Random r = new Random();
        Scanner sc = new Scanner(System.in);
        int[] lunckNumber = new int[7];
        int[] lunckNumberResult = new int[7];
        int red = 0;
        for (int i = 0; i < 7; i++) {
            if (i==0) {
                lunckNumber[i] = r.nextInt(1, 33);
            }
            else if (i==6){
                lunckNumber[i] = r.nextInt(1,16);
            }else {
                lunckNumber[i] = r.nextInt(1, 33);
            }
        }
        for (int i = 0; i < lunckNumber.length; i++) {
            if (i==6){
                System.out.print("请输入蓝球数字");
                lunckNumberResult[i] = sc.nextInt();
            }else {
                System.out.print("请输入第"+(i+1)+"个红球数字");
                lunckNumberResult[i] = sc.nextInt();
            }
        }
        for (int i = 0; i < lunckNumber.length; i++) {
            if(i==6){
                if (lunckNumber[i]==lunckNumberResult[i]){
                    System.out.print("蓝球中  ");
                }else {
                    System.out.print("蓝球未中  ");
                }
            }else {
                for (int i1 = 0; i1 < lunckNumberResult.length-1; i1++) {
                    if(lunckNumber[i]==lunckNumberResult[i1]){
                        red +=1;

                    }
                }
            }
        }System.out.println("红球中了"+red+"个");
        System.out.print("选的号码是：");
        for (int i = 0; i < lunckNumber.length; i++) {
            System.out.print(lunckNumberResult[i]+" ");
        }
        System.out.println();
        System.out.print("中奖号码是：");
        for (int i = 0; i < lunckNumber.length; i++) {
            System.out.print(lunckNumber[i]+" ");
    }
}
}