java day04

最新推荐文章于 2024-10-01 18:51:18 发布
最新推荐文章于 2024-10-01 18:51:18 发布
阅读量69 收藏
点赞数
文章标签： java Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59550403/article/details/129149099
版权

一. java基本语法（续）

  1. 数组（一个连续固定大小的空间）

1.1 概念：

数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。

数组既可以存储基本数据类型，也可以存储引用数据类型。

1.2 语句定义格式

1、数据类型[] 数组名

举例：int[] arr; 这里的数组名其实就是一个变量的名，符合标识符的命名规则

2、据类型 数组名[]

举例：int arr[];

注意事项:

推荐使用第一种定义格式，可读性更强，早期的时候很多人使用第二种格式，现在趋向于第一种格式

1.3 初始化

所谓初始化其实就是对数组在内存中开辟一个连续的内存空间并对每个元素分配值。

数组的初始化的方式：

1、动态初始化：

初始化时只指定数组长度，由系统为数组分配初始值

默认值是多少？不同的元素数据类型默认值都一样吗？如果不一样分别是什么呢？

2、静态初始化

初始化时指定每个数组元素的初始值，由系统决定数组长度。

动态初始化：初始化时只指定数组长度，由系统为数组分配初始值

语句定义格式：

数据类型[] 数组名 = new 数据类型[数组的长度]

举例：创建长度为5，存储的是int类型元素的数组

int[] arr = new int[5];

 */
public class ArrayDemo1 {
    public static void main(String[] args) {
        //定义一个可以存储一批int类型元素的数组
//        int[] arr;

        //这里只是定义了，并没有对数组进行初始化，赋予初始化值，所以要想使用一个数组
        //光定义还不行，还要进行初始化
//        System.out.println(arr);


        /**
         * 左边：
         *  int: 表示我要定义的数组中要存储的元素类型是int类型
         *  []:说明它是一个一维数组
         *  arr:给数组起一个名字，符合标识符的命名规则
         *
         *
         * 右边：
         *  new: 就说明在（堆）内存中开辟空间
         *  int:表示我要定义的数组中要存储的元素类型是int类型
         *  []:说明它是一个一维数组
         *  3:表示数组最多能存储3个元素，其实就是数组的容量大小
         *
         */
        //动态初始化
        int[] arr = new int[3];
        //由于完成了初始化，我们就可以对变量进行使用
        //直接打印，获取的是该数组在堆内存中的地址值，是一个十六进制的数
        System.out.println(arr);  // [I@4554617c
        //我们如果就只能获取到地址值对于我们开发人员来说没有任何意义，我们使用数组更多是希望能够利用数组进行存储或者分析数据
        //我们在上面介绍的时候提到一点，动态初始化的时候，系统会自动地为每一个元素赋予默认值
        //我现在就想要知道默认值是多少
        //怎么获取呢？java中的数组每一个元素位置上都有一个标号（下标索引）,从左往右，从0开始
        //语句定义格式：数组名[索引]
        //我们要获取第一个元素的值
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        //在初始化的时候，系统为数组中每一个存储int类型元素的位置上赋予了默认值0

    }
}

package com.shujia.wyh.day04;

/*
        定义两个数组，先定义一个数组，赋值，输出。
        然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。
        然后给第二个数组赋值，再次输出两个数组的名及元素。
 */
public class ArrayDemo3 {
    public static void main(String[] args) {
        //先定义一个数组
        int[] arr1 = new int[3];
        arr1[0] = 11;
        arr1[1] = 22;
        arr1[2] = 33;
        System.out.println(arr1);
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);

        System.out.println("=========================================");
        //然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。
        int[] arr2 = arr1;
        arr2[0] = 100;
        System.out.println("==========================================");
        System.out.println(arr1);
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);
        System.out.println("-----------------------");
        System.out.println(arr2);
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);

    }
}

数组的静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。

语句定义格式：元素的数据类型[] 数组名 = new 元素的数据类型[]{元素1,元素2.....}

简化写法：元素的数据类型[] 数组名 = {元素1,元素2.....}

 */
public class ArrayDemo4 {
    public static void main(String[] args) {
        //标准静态初始化的写法
//        int[] arr = new int[]{11,22,33,44};
        int[] arr;
        arr = new int[]{11,22,33,44};
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);
        System.out.println("=====================================");
//        int[] arr2 = int[3]{1,2,3};   //就相当于动态初始化和静态初始化的混合使用
        //简化写法静态初始化
        int[] arr2 = {100,200,300};
        System.out.println(arr2);
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);

        System.out.println("===============================");
        //简化写法的时候，不允许将初始化与定义分割开来
//        int[] arr3;
//        arr3 = {110,120,130};
//        System.out.println(arr3);
    }
}

1.4 数组常见小问题

package com.shujia.wyh.day04;

public class ArrayDemo5 {
    public static void main(String[] args) {
        //创建一个数组并赋值
        int[] arr = {11,22,33};
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        //取了不该取的索引导致的
//        System.out.println(arr[3]); //ArrayIndexOutOfBoundsException 数组索引越界异常

        arr = null;
        System.out.println(arr[0]); //NullPointerException 空指针异常

    }
}

1.5 数组遍历（依次输出数组中的每一个元素）

/*
        数组遍历(依次输出数组中的每一个元素)
 */
public class ArrayDemo6 {
    public static void main(String[] args) {
        //定义一个数组
//        int[] arr = {11, 22, 33, 3, 312, 41, 321, 41, 4};

//        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]);
//        System.out.println(arr[5]);
//        System.out.println(arr[6]);
//        System.out.println(arr[7]);
//        System.out.println(arr[8]);
        //使用for循环进行遍历
//        for (int i = 0; i <= 8; i++) {
//            System.out.println(arr[i]);
//        }
        System.out.println("======================================");
        //虽然我们可以使用for循环遍历出数组中的元素
        //但是呢这个元素的个数是我们自己能够数清的9个元素，进而推出索引最大是8
        //才写出的for循环
        //当数组中的元素个数很多的时候你还能数清吗？
        int[] arr = {11, 22, 33, 3, 312, 41, 321, 41, 412, 2312, 412, 4431, 3, 1, 21321, 412, 2312, 412, 4};
        //当我们自己数不清的时候，好像就没法用上面的做法了
        //所以我们在想，要想使用for循环，前提不就是想要知道数组的长度么
        //于是乎，java中的数组给我们提供了一个属性来得到数组的长度：length
//        System.out.println(arr.length);
        //[11,22,33,44,55,33]
//        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
//            if(i==0){
//                System.out.print("["+arr[i]+",");
//            }else if(i==arr.length-1){
//                System.out.println(arr[i]+"]");
//            }else {
//                System.out.print(arr[i]+",");
//            }
//        }
        printArray(arr);
        System.out.println("==================");
        printArray(arr);

    }

    /**
     * 编写打印一维int类型的数组的方法
     * 返回值类型：void
     * 参数列表：int[] array
     */
    public static void printArray(int[] array) {
        for (int i = 0; i < array.length; i++) {
//            System.out.println(arr[i]);
            if (i == 0) {
                System.out.print("[" + array[i] + ",");
            } else if (i == array.length - 1) {
                System.out.println(array[i] + "]");
            } else {
                System.out.print(array[i] + ",");
            }
        }
    }
}

package com.shujia.wyh.day04;

/*
代码格式化快捷键：ctrl+alt+L
        数组获取最值(获取数组中的最大值最小值)
        [12,32,12,54,31,2,51,78,100,64,3]
        分析：
            1、获取数组中的第一个数，先将它默认为最大值
            2、向后遍历，拿到每个值与最大值进行比较，如果比最大值还要大，就交换一下
            3、遍历结束后，最大值也就是数组中的最大值
 */
public class ArrayDemo7 {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {12, 32, 12, 54, 31, 2, 51, 78, 100, 64, 3};

        //调用方法获取最大值
        int maxNum = getMaxNumber(arr);
        System.out.println("最大值为：" + maxNum);
        //调用方法返回最小值
        int minNum = getMinNumber(arr);
        System.out.println("最小值为：" + minNum);


    }

    public static int getMinNumber(int[] array) {
        //定义一个变量取第一个值为最大值
        int minNum = array[0];

        //从第二个值开始遍历
        for (int i = 1; i < array.length; i++) {
            if (array[i] < minNum) {
                //直接赋值
                minNum = array[i];
            }
        }

        return minNum;
    }


    public static int getMaxNumber(int[] array) {
        //定义一个变量取第一个值为最大值
        int maxNum = array[0];

        //从第二个值开始遍历
        for (int i = 1; i < array.length; i++) {
            if (array[i] > maxNum) {
                //直接赋值
                maxNum = array[i];
            }
        }

        return maxNum;
    }
}

package com.shujia.wyh.day04;

/*
        数组元素逆序 (就是把元素对调)
        原本数组：[1,2,3,4,5,6,7,8,9]
        逆序：[9,8,7,6,5,4,3,2,1]
 */
public class ArrayDemo8 {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        System.out.println("逆序之前：");
        printArray(arr);

        //将索引0对应的元素与索引length-1-0的元素对调
//        int tmp = arr[0];
//        arr[0] = arr[arr.length-1-0];
//        arr[arr.length-1-0] = tmp;
//
        //将索引1对应的元素与索引length-1-1的元素对调
//        int tmp2 = arr[1];
//        arr[1] = arr[arr.length-1-1];
//        arr[arr.length-1-1] = tmp2;

        //将索引2对应的元素与索引length-1-2的元素对调
//        int tmp3 = arr[2];
//        arr[2] = arr[arr.length-1-2];
//        arr[arr.length-1-2] = tmp3;

        //...
        //将索引i对应的元素与索引length-1-i的元素对调
//        int tmpn = arr[i];
//        arr[i] = arr[arr.length-1-i];
//        arr[arr.length-1-i] = tmpn;

        //直到length/2次为止
//        for (int index = 0; index < arr.length / 2; index++) {
//            int tmpn = arr[index];
//            arr[index] = arr[arr.length - 1 - index];
//            arr[arr.length - 1 - index] = tmpn;
//        }

//        arr = niXu1(arr);
//        System.out.println("逆序后的数组为：");
//        printArray(arr);

        System.out.println("============逆序的第二种解决方案=============");
        arr = niXu2(arr);
        System.out.println("逆序后的数组为：");
        printArray(arr);


    }

    /**
     * 逆序的第二种解决方案：定义头尾指针
     * 返回值类型：int[]
     * 参数列表：int[] array
     */
    public static int[] niXu2(int[] array) {
        for (int start = 0, end = array.length - 1; start < end; start++, end--) {
            int tmp = array[start];
            array[start] = array[end];
            array[end] = tmp;
        }
        return array;
    }


    /**
     * 逆序方法：
     * 返回值类型：int[]
     * 参数列表：int[] array
     */
    public static int[] niXu1(int[] array) {
        for (int index = 0; index < array.length / 2; index++) {
            int tmpn = array[index];
            array[index] = array[array.length - 1 - index];
            array[array.length - 1 - index] = tmpn;
        }

        return array;
    }


    /**
     * 编写打印一维int类型的数组的方法
     * 返回值类型：void
     * 参数列表：int[] array
     */
    public static void printArray(int[] array) {
        for (int i = 0; i < array.length; i++) {
//            System.out.println(arr[i]);
            if (i == 0) {
                System.out.print("[" + array[i] + ",");
            } else if (i == array.length - 1) {
                System.out.println(array[i] + "]");
            } else {
                System.out.print(array[i] + ",");
            }
        }
    }
}

2. 二维数组

2.1 概念：

其实就是元素为一维数组的数组

2.2 语句定义格式：

格式一：数据类型[][] 变量名 = new 数据类型[m][n];

举例：

int[][] arr = new int[3][2];

表示定义了一个二维数组，二维数组中有3个一维数组，每个一维数组的长度为2，每个一维数组中的元素数据类型是int类型

今后可能会遇到的其他二维数组的格式：

int[] arr[] = new int[3][3];

int arr[][] = new int[3][3];

int arr [] [] = new int[3][3];

int [] [] arr = new int[3][2];

格式二：

数据类型[][] 数组名 = new 数据类型[m][];

m代表的是有多少个一维数组。

后续将创建一维数组进行赋值

package com.shujia.wyh.day04;

/*
        公司年销售额求和
        某公司按照季度和月份统计的数据如下：单位(万元)
        第一季度：22,66,44
        第二季度：77,33,88
        第三季度：25,45,65
        第四季度：11,66,99

 */
public class Array2Demo3 {
    public static void main(String[] args) {
        //创建二维数组存储每个季度的值
        int[][] gongsi = new int[][]{{22, 66, 44}, {77, 33, 88}, {25, 35, 65}, {11, 66, 99}};

        //定义一个sum变量接收和
        int sum = 0;
        for (int i = 0; i < gongsi.length; i++) {
            for (int j = 0; j < gongsi[i].length; j++) {
                sum += gongsi[i][j];
            }
        }

        System.out.println("该公司年销售总额为：" + sum + "万元");

        //作业：打印杨辉三角形(行数可以键盘录入)
        /*
                1
                1 1
                1 2 1
                1 3 3  1
                1 4 6  4  1
                1 5 10 10 5  1
                1 6 15 20 15 6 1
         */

    }
}

格式三：

在创建的同时给值

数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2},{...},{......}}

*/
public class Array2Dmo3 {
    public static void main(String[] args) {
        int[][] shujia = new int[][]{{11, 22, 33}, {100, 200, 300, 400}, {1, 2, 3, 4, 5}};

        //二维数组遍历
        for (int i = 0; i < shujia.length; i++) {
            System.out.println("正在遍历" + (i + 1) + "个一维数组元素");
//            shujia[i] 代表的是取到的每一个一维数组
            for (int j = 0; j < shujia[i].length; j++) {
//                System.out.println(shujia[i][j]);
                if (j == 0) {
                    System.out.print("[" + shujia[i][j] + ",");
                } else if (j == shujia[i].length - 1) {
                    System.out.println(shujia[i][j] + "]");
                } else {
                    System.out.print(shujia[i][j] + ",");
                }
            }
        }

    }

3. 思考

package com.shujia.wyh.day04;

/*
        总结：
            1、基本数据类型当作方法的实参传入的时候，方法内部的变化，与方法外部的变量值不受影响
            2、引用数据类型当作方法的实参传入的时候，传入的是地址值，方法内部的变化会影响到地址值真正对应的空间值，
                所以外部的引用数据类型变量的值会发生变化

 */
public class Array2SikaoDemo {
    public static void main(String[] args) {
//        int a = 10;
//        int b = 20;
//        System.out.println("a:" + a + ",b:" + b);  // 10,20
//        change(a, b);
//        System.out.println("a:" + a + ",b:" + b); // a=10,b=20不受方法内部影响

        int[] arr = {1,2,3,4,5};
        change(arr);
        System.out.println(arr[1]); // 4
    }

    public static void change(int a1, int b1) {
        System.out.println("a1:" + a1 + ",b1:" + b1);  // 10,20
        a1 = b1;  //a=20
        b1 = a1 + b1; //b=40
        System.out.println("a1:" + a1 + ",b1:" + b1); // 20,40
    }

    public static void change(int[] arr) {
        //偶数乘2，奇数不变
        for (int x = 0; x < arr.length; x++) {
            if (arr[x] % 2 == 0) {
                arr[x] *= 2;
            }
        }
    }

}
不爱写代码555555
关注
数组快速入门
shhghvvh的博客
09-27 482
数组快速入门
java day of month_Java MonthDay withDayOfMonth()用法及代码示例
weixin_31597865的博客
02-23 1771
MonthDay类的withDayOfMonth(int dayOfMonth)方法用于将传递的dayOfMonth用作参数来更改MonthDay对象的day-of-month，然后该方法返回更改后的MonthDay的副本。如果day-of-month值在指定的月份后无效，则抛出异常改变操作。用法:public MonthDay withDayOfMonth(int dayOfMonth)参数：此...
数组方法练习
weixin_41874888的博客
01-11 458
一、定义打印数组元素方法,按照给定的格式打印[11, 33, 44, 22, 55] 代码如下： public class ArrayMethodTest{ public static void main(String[] args){ int[] arr = {11,33,44,22,55}; printArray(arr); ...
for循环实现数组交换
qq_54182348的博客
05-01 362
public class Demo { public static void main(String[] args) { //定义静态数组 int[] arr = new int[]{12, 13, 14, 15, 16, 90}; for (int start = 0, end = arr.length - 1; start < end; start++, end--) { int temp = arr[start.
Day1-Java入门
热门推荐
aiains的博客
06-27 3万+
CMD常用命令； 用CMD运行电脑程序以及对应的环境配置； 用记事本编写helloworld，用CMD运行； Java环境变量的配置； Notepad++的使用； 初步了解JDK和JRE。
JAVA学习day6
qq_54395021的博客
04-30 2318
多线程：在身边的应用 可以边 看电影边 听音乐边 打游戏 JDK：java development kit （java开发者工具） JRE：java runtime environment （java运行环境） JVM：java virtual machine （java虚拟机）
# Day01-Java基础
Java厂长
07-25 8050
Day01-Java 1、Java主要特点 简单性、跨平台性、分布性、安全性、健壮性、平台独立与可移植性、多线程、动态性、面向对象的编程语言、支持垃圾自动收集处理等，可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用等多个系统中。 2、计算机的高级汇编语言类型： 编译型——c语言 解释型——html 编译型和解释型的结合——java java运行原理源程序进行编译形成字节码文件在一台电脑进行解释程序 java最核心的部分就是虚拟机JVM 3、JVM（Java Visual Machine)
Java 获取 Julian Day (Calendar)
男儿不展风云志，空有天生八尺躯
11-30 2184
/** * 从Calendar获取Julian Day * 算法来源: http://stackoverflow.com/questions/32949757/get-current-julian-day-number-with-gregorian-calendar-in-android */ public static int getJulianDay(Calendar calendar) { int year = calendar.get(C...
【JAVA-Day43】Java常用类Calendar解析
沉淀、分享、成长，让自己和他人都能有所收获！
10-16 2万+
作为博主，我将带您深入探讨Java中的日期处理神器 -。我们将一探这个强大的类库，学会如何处理日期、时区、重复事件、甚至是国际假期。而且，在文章中我会用丰富的表情和Java代码案例来让您轻松掌握这些知识。无论您是初学者还是经验丰富的开发者，本文都将为您提供深刻的见解。通过本文，您已经深入了解了类以及如何在Java中进行高级日期处理。我们讨论了其基本用法、日期操作、时区处理、格式化、重复事件、国际假期、最佳实践以及与新日期时间API的比较。
java的转义字符 day3
qq_48843954的博客
07-28 1万+
从零开始学java day3 关于回车换行的一点小疑问
Javaday02训练
02-08
Java Day02训练是针对Java初学者或有一定基础的学习者设计的一次深入学习活动，旨在强化和巩固Java编程的基础知识。在这个训练中，你将接触到一系列关键的Java编程概念和技术，包括但不限于变量、数据类型、控制流程...
Java基础Day04.xmind
06-29
适合java初学者
java初学者学习源代码day04.zip
07-03
"day04.zip"表明这是学习过程中的第四天内容，通常在学习初期阶段，会涉及变量、数据类型、运算符、控制流（如if语句、循环）、类与对象等基础知识。 1. `ShowTokens.class` 和 `ShowTokens.java`：`.class` 文件是...
一起学Java——Day04.md
04-05
该资源为md格式，需下载typora可打开，该内容讲述的是Java中的循环结构，其中有while循环do-while循环以及for循环，还有break，conrinue两个跳转语句的区别以及Rondom产生随机数字的基本知识
基于Hive和Hadoop的哔哩哔哩网站分析系统
图南的博客
09-27 595
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 240
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 558
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
Java内存布局
阿呆的专栏
10-01 693
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
Java MBeanInstantiator 0day 漏洞分析
"Java 0day Analysis - MBeanInstantiator.findClass 漏洞解析" 在2013年1月，Java社区面临了一个新的重大安全威胁：Java MBeanInstantiator.findClass 0day漏洞。这个漏洞的影响广泛，因为Java在当时已经广泛应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值