Java随堂小记05

最新推荐文章于 2024-09-21 10:38:43 发布
最新推荐文章于 2024-09-21 10:38:43 发布
阅读量139 收藏
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48245161/article/details/113779068
版权

Java随堂小记05

数组

每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问他们
在这里插入图片描述

定义： int [] nums;

存放10个int类型的数据： nums = new int[10];

    int[] nums = new int[10];//和Scanner s1=new Scanner（System.in）一样

package www.Dongyi.Scanner;

public class Demo8 {
    public static void main(String[] args) {
        int[] nums = new int[10];
        nums[0] = 1;
        nums[1] = 2;
        nums[2] = 3;
        nums[3] = 4;
        nums[4] = 5;
        nums[5] = 6;
        nums[6] = 7;
        nums[7] = 8;
        nums[8] = 9;
        nums[9] = 10;

        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum+=nums[i];
        }
        System.out.println(sum);
    }
}

数组的常见异常

1. 数组下标越界异常：ArrayIndexOutOfBoundsException

下标的合法区间：[0,length - 1];

public static void main(String[] args) {
	int[] x = { 1, 2, 3 };
	System.out.println(x[3]);
}
  1. 空指针异常：NullPointerException
public static void main(String[] args) {
	int[] x = { 1, 2, 3 };
	x = null;
	System.out.println(x[1]);
}

三种数组的初始化

在这里插入图片描述

1、静态初始化：创建 + 赋值
int[] arr1 = { 1, 2, 3, 4, 5 };
int[] arr2 = new int[] { 1, 2, 3, 4, 5 };

2、动态初始化:包含默认初始化,即未赋值的系统会自动为你赋值0
int[] arr3=new int[3];
arr3[0]=1;
arr3[1]=2;
System.out.println(b[1]);//值为0

数组的使用

增强型for循环,省略了下标，不利于操作数组元素

package www.Dongyi.Scanner;

public class DemArrays {
    public static void main(String[] args) {
         int[] arrays = {1,2,3,4,5};
        for (int array : arrays) {
            System.out.println(array);
        }
    }
}

翻转数组：

package www.Dongyi.Scanner;

public class DemArray02 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
        printArray(arrays);//打印
        System.out.println();//先输出再换行
        int[] reverse = reverse(arrays);
        printArray(reverse);//打印
    }

    public static void printArray(int[] arrays){//打印
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+" ");
        }
    }
    public static int[] reverse(int[] arrays){//逆置
        for (int i=0;i< arrays.length/2;i++) {
            int temp = arrays[i];
            arrays[i] = arrays[arrays.length-i-1];
            arrays[arrays.length-i-1]=temp;
        }
        return arrays;
    }
}

二维数组

遍历

package www.Dongyi.Scanner;

public class DemoArrays03 {
    public static void main(String[] args) {
        int[][] array = {{1,2},{2,3},{3,4},{4,5}};
        printArray(array);
    }

    public static void printArray(int[][] arrays){//打印
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j < arrays[i].length; j++) {
                System.out.print(arrays[i][j]+" ");
            }
            System.out.println();
        }
    }
}

Arrays类

导包：import java.util.Arrays

打印数组：Arrays.toString（变量名）

package www.Dongyi.Scanner;

import java.util.Arrays;

public class DemoToString {
        public static void main(String[] args) {
            int[] arr = {1,3,56,78,4245,53675,786,46};
            System.out.println(arr);//[I@1b6d3586，这是一个hashcode，输出对象
            System.out.println(Arrays.toString(arr));
            System.out.println("===============================");
            printArray(arr);
        }
       public static void printArray(int[] arr){
            for (int i=0;i<arr.length;i++){
                if(i==0){
                    System.out.print("[");
                }
                if(i== arr.length-1){
                    System.out.print(arr[i]+"]");
                }else {
                    System.out.print(arr[i]+", ");
                }
            }
       }
}

升序排序：Arrays.sort(arr)

        int[] arr ={23,26,46,889,357,295,725};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));

冒泡排序

package www.Dongyi.Scanner;

import java.util.Arrays;

public class bubbleSort {
    public static void main(String[] args) {
        int[] arr ={23,76,46,889,357,295,725};
        System.out.println("排序前");
        System.out.println(Arrays.toString(arr));
        System.out.println("排序后");
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void bubbleSort(int[] arr){
        boolean flag = false;//通过flag标识位减少没有意义的比较
        int temp=0;
        for(int i=0;i< arr.length;i++){
            for (int j=0;j< arr.length-i-1;j++){
                if(arr[j]>arr[j+1]){
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                    flag=true;
                }
            }
            if (flag==false){
                break;
            }
        }
    }
}

数组填充:Arrays.fill()

import java.util.Arrays;
public class ArrayFill {
    public static void main(String[] args) {
        int[] a = {37,45,67,23,7};

        //数组填充
     Arrays.fill(a,0);
      System.out.println(Arrays.toString(a));

        //指定填充
      Arrays.fill(a,2,4,0);//下边2到4变为0
       System.out.println(Arrays.toString(a));
    }
}

稀疏棋盘

for.each循环，遍历数组的简单写法

package www.Dongyi.Scanner;

public class DemoArrays04 {
        public static void main(String[] args) {
            //1、创建一个二维数组11*11   0：没有棋子  1：黑棋    2：白棋
            int[][] array = new int[11][11];
            array[1][2] = 1;
            array[2][3] = 2;

            System.out.println("原始数组：");
            for (int[] ints : array) {
                for (int anInt : ints) {
                    System.out.print(anInt+"\t");
                }
                System.out.println();
            }

            //获取有效值的个数
            int sum = 0;
            for (int i = 0; i < array.length; i++) {
                for (int j = 0; j < array[i].length; j++) {
                    if(array[i][j]!=0){
                        sum++;
                    }
                }
            }
            System.out.println("有效值个数："+sum);

            //2.创建一个稀疏数组
            int[][] array2 = new int[sum+1][3];//3列，分别是行、列、有效值

            array2[0][0] = 11;//总共有11行
            array2[0][1] = 11;//总共有11列
            array2[0][2] = sum;//有效值是sum个

            int count = 0;
            for (int i = 0; i < array.length; i++) {
                for (int j = 0; j < array[i].length; j++) {
                    if(array[i][j]!=0){
                        count++;
                        array2[count][0] = i;//行
                        array2[count][1] = j;//列
                        array2[count][2] = array[i][j];//有效值
                    }
                }
            }
            //打印稀疏数组
            System.out.println("稀疏数组：");
            System.out.println("行\t"+"列\t"+"有效值\t");
            for (int i = 0; i < array2.length; i++) {
                for (int j = 0; j < 3; j++) {
                    System.out.print(array2[i][j]+"\t");
                }
                System.out.println();
            }
            System.out.println("===========================");
            System.out.println("还原");
            //1.读取稀疏数组
            int[][] array3 = new int[array2[0][0]][array2[0][1]];//第0行0列：总行数   第0行1列：总列数

            //2.给元素还原它的值
            for(int i = 1;i< array2.length;i++){
                array3[array2[i][0]][array2[i][1]] = array2[i][2];
                //array3[行][列] = 有效值
                //即把有效值按照有效值坐标的位置赋值给新数组，其余系统默认为0
            }
            System.out.println("还原数组：");
            for (int[] ints : array3) {
                for (int anInt : ints) {
                    System.out.print(anInt+"\t");
                }
                System.out.println();
            }
        }
    }
阿董ddd
关注
专栏目录
Java随堂小记06
weixin_48245161的博客
02-13 450
Java-面向对象面向对象基础方法值传递和引用传递类与对象 面向对象基础 1、面向对象编程：oop 2、面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据 3、对象是具体的实例，类是抽象的，是对象的模板 4、 类 = 属性 + 方法 5、三大特性：封装、继承、多态 6、break和return的区别： break用于跳出switch和结束循环 return用于结束方法体 方法 静态方法：直接通过类名去调用方法 public class Dem01 { public static voi
Java随堂小记08
weixin_48245161的博客
03-07 370
Java随堂小记08instanceof强制转换 instanceof instanceof 用来测试一个对象是否为一个类的实例 对象必须为引用类型，不能是基本类型 如果a能转换成右边的class类型，则返回true，否则返回false package www.Dongyi.oop.Demo7; public class Application { public static void main(String[] args) { //Object > Person &g
Java随堂小记02
weixin_48245161的博客
02-07 295
Java随堂小记自增、自减运算符初识Math类逻辑运算符位运算符赋值运算符包机制JavaDos生成文档 自增、自减运算符 又叫一元运算符 public class Demo1 { public static void main(String[] args) { int a = 1; int b = a++;//先赋值后自增 int c = ++a;//先自增后赋值 System.out.println(b); Syste
Java随堂小记03
weixin_48245161的博客
02-08 403
Java随堂小记流程控制switchwhilewhile和do whilefor循环小案例（自己写）增强for循环break、continue、gotobreak：可用于任何循环语句中强行退出最近的循环，只是跳出循环，并不代表程序结束continue：用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判断goto练习：打印三角形反编译 流程控制 equals：判断字符串相等，不能用== switch JDK7的新特性，switch支持字符串类型了 记得break！！ 使用Sca
Java随堂小记04
weixin_48245161的博客
02-09 246
Java随堂小记方法方法重载可变参数（又叫不定项参数）递归 方法 设计方法的原则：设计方法时最好保持方法的原子性，就是一个方法只完成一个功能，这样利于后期的扩展。 main方法要干净，通过调用方法。main方法做一些底层的东西 实现两个数比大小 package www.Dongyi.Scanner; import java.util.Scanner; public class Demo3 { public static void main(String[] args) { Sca
Java随堂小记01
weixin_48245161的博客
02-06 224
Java随堂小记JDK7的新特性：变量常量命名规则运算符（只做补充） JDK7的新特性： 数字之间可以用下划分割，不会被输出 如： 1000000000可以写成10_0000_0000 变量 public class Demo1 { //类变量 static static double salary = 10000;//salary工资 //属性：变量 //实例变量：从属于对象;不初始化会返回默认值 0 0.0 //布尔值：默认是false /
Java随堂小记07
weixin_48245161的博客
03-06 278
Java随堂小记07封装继承Objectsuper方法重写多态 封装 程序设计追求高内聚，低耦合高内聚：类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。 封装（数据的隐藏） 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。 属性私有，get/set 快捷键alt+insert package www.Dongyi.oop; public class Demo2 { public static void main(Strin
Java随堂小记09（GUI）
weixin_48245161的博客
03-15 735
Java随堂小记09异常处理机制自定义异常 异常处理机制 检查性异常：程序员无法预见的。如打开一个不存在文件时异常发生。编译时不能被简单地忽略 运行时异常：运行时异常是可能被程序员避免的异常。编译时可以被忽略 错误：错误不是异常，而是脱离程序员控制的问题。通常在代码中被忽略 快捷键：Ctrl + Alt + T 自动补全异常 throw：主动抛出异常，在方法体内使用 throws：方法中处理不了这个异常，方法上抛出异常（像极了甩锅的你） finally：善后工作 e.printStackTrace
java-随堂小记
liuxiaowei
06-07 620
待更新
Java transient关键字使用小记
09-02
在Java编程语言中，`transient`关键字是一个非常重要的概念，它与对象的序列化过程紧密相关。序列化是将一个对象的状态转换为字节流，以便存储或在网络中传输。当一个类实现了`Serializable`接口，该类的对象就可以...
linux+java+python3+numpy+stl的3d打印小记
04-11
在本项目中，我们将探索如何利用Linux操作系统，Java编程语言，Python3，NumPy库以及STL文件格式来实现3D打印技术。这是一个跨学科的综合应用，涉及到计算机科学、软件开发以及制造技术。 首先，Linux是开源的操作...
Java企业面试题3
m0_74972727的博客
09-15 883
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
Arthas sysenv（查看JVM的环境变量）
最新发布
刘大猫
09-21 187
Arthas sysenv（查看JVM的环境变量）
JDK17新增语法特性
2201_76124988的博客
09-20 521
从springboot3.0开始，已经不支持JDK8，转变为JDK17参考资料：官方博客。
faiss安装 （CPU版本）
CSDN_WHB的博客
09-20 175
faiss版本 faiss-v1.7.4。
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
weixin_43860634的博客
09-14 905
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
面试突击-多线程和IO专题(至尊典藏版)
人生若只初相见@的博客
09-18 1448
金九银十多线程和IO大厂面试专题
Gradle
xiaocaij_icai的博客
09-15 256
");
protobuff使用小记
05-31
Protobuf是一种高效的序列化协议，可以用于数据交换和数据存储。它的主要优势是大小小，速度快，可扩展性强。下面是使用Protobuf的一些小记： 1. 定义消息格式 首先，需要定义消息格式，以便Protobuf可以将数据序列化和反序列化。消息格式定义在.proto文件中，使用protobuf语言编写。例如，下面是一个简单的消息格式定义： ``` syntax = "proto3"; message Person { string name = 1; int32 age = 2; } ``` 这个消息格式定义了一个名为Person的消息，包含两个字段：name和age。 2. 生成代码 一旦消息格式定义好，就可以使用Protobuf编译器生成代码。编译器将根据消息格式定义生成相应的代码，包括消息类、序列化和反序列化方法等。可以使用以下命令生成代码： ``` protoc --java_out=. message.proto ``` 这将生成一个名为message.pb.java的Java类，该类包含Person消息的定义以及相关方法。 3. 序列化和反序列化 一旦生成了代码，就可以使用Protobuf序列化和反序列化数据。例如，下面是一个示例代码，将一个Person对象序列化为字节数组，并将其反序列化为另一个Person对象： ``` Person person = Person.newBuilder() .setName("Alice") .setAge(25) .build(); byte[] bytes = person.toByteArray(); Person deserializedPerson = Person.parseFrom(bytes); ``` 这个示例代码创建了一个Person对象，将其序列化为字节数组，然后将其反序列化为另一个Person对象。在这个过程中，Protobuf使用生成的代码执行序列化和反序列化操作。 以上是使用Protobuf的一些基本步骤和注意事项，希望对你有所帮助！
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值