Java PTA(7)——数组

已于 2024-06-11 20:31:01 修改
阅读量981 收藏 30
点赞数 7
文章标签： java
于 2023-12-21 11:35:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61442114/article/details/135082405
版权

五.数组

数组是数据的有序集合。通过数组，可以将一组相同类型的数据组织在一起，并有助于对这组数据进行有效处理。在java中，数组被作为对象处理。

1.一维数组  

(1) 数组的定义    

一维数组的定义方式为：              

        type arrayName[ ]  或  type[] arrayName；

  • 类型(type)表示数组的类型，称为基类型。可以是Java中任意的数据类型，包括基本类型和复合类型。
  • 数组名arrayName为一个合法的标识，[ ]指明该变量arrayName是一个数组类型变量。  

例如:int intArray[ ]；String[ ] args;      int[] a,b,c;      Date  dateArray[ ]；

       与C、C++不同，Java在定义数组时不发生内存的分配，因此[ ]中不用指出数组中元素的个数，即数组长度，而且对于经过如上定义的一个数组是不能访问数组元素的，必须经过初始化后，才能引用数组的元素。

(2) 数组的初始化    

 一维数组定义之后，必须经过初始化才可以引用。数组的初始化分为静态初始化和动态初始化两种：      

静态初始化：在定义数组的同时对数组元素进行初始化。

例如：          int intArray[]={1,2,3,4,5};          String str[]={“java”,”basic”,”fortran”}; 

动态初始化：使用运算符new为数组分配空间。

        ①对于基类型为基本类型的数组      

                int a[]=new int[10];        

                double b[]=new double[5];      

                String s[]=new String[2];            

        ②对于基类型为复合类型的数组，需要经过两步内存空间分配。      

                首先： 为数组分配内存空间      

                然后：  为每个元素分配内存空间      

                Student stu[];

                stu=new Student[2];

                stu[0]=new Student(“李明”) ；

                stu[1]=new Student (“王伟”);

    另外，与C、C++中不同，Java对数组元素要进行越界检查以保证安全性。同时，对于每个数组都有一个属性length指明它的长度，例如：        

intArray.length指明数组intArray的长度。

2.多维数组

在任何语言中，多维数组都被看作数组的数组。比 如二维数组是一个特殊的一维数组，其每一个元素 又是一个一维数组。我们主要以二维数组为例来说 明，高维数组与此类似。

(1) 二维数组的定义

二维数组的定义方式              

        type arrayName[ ][ ]；     例如：     int intArray[ ][ ]；

 也可以采用另一种定义方式：type[ ][ ] arrayName;

与一维数组一样，这时对数组元素也没有分配内存，同样要使用运算符new来分配内存，然后才可以访问每个元素。

 (2) 二维数组的初始化

 二维数组的初始化也分为静态和动态两种。      

静态初始化：在定义数组的同时为数组分配空间。      

        int  intArray[ ][ ]={{1,2},{2,3},{3,4}};

        不必指出数组每一维的大小，系统会根据初始化时给出的初始值的个数自动算出数组每一维的大小。

动态初始化：对高维数组来说，分配内存空间有下面两种方法：

        1.直接为每一维分配空间，如：      

                type  arrayName[ ][ ]=new type[arraylength1][arraylength2]

                例如：       int a[ ][ ]=new int[2][3]；

        2.从最高维开始（而且必须从最高维开始），分别为每一维分配空间，如：      

                String s[ ][ ]=new String[2][ ];      

                s[0]=new String[2];      

                s[0][0]=new String(“Good”);      

                s[0][1]=new String(“Luck”);      

                s[1]=new String[3];      

                s[1][0]=new String(“to”);    

                s[1][1]=new String(“you”);      

                s[1][2]=new String(“!”);

3、数组操作的常用方法 

在java.util包中的Arrays类提供了一些操作数组的方法

——java.util.Arrays

int binarySearch(type a[], type key)

        数组a必须已经排序，否则返回值无意义

        当数组a中有重复的值时，该方法返回的值不确定

        如果key存在，则返回它在数组a中的位置

        如果不存在，则返回它的“-(插入位置-1)”

void fill(type a[], type val)     

void fill(type a[], int fromIndx, int toIndex, type val)

        包括a[fromIndx]，但不包括a[toIndex]

         fromIndx== toIndex时，范围是一个空的范围

boolean equals(type a[], type a2[])

        两个数组变量指向同一个数组对象则返回true

        两个null数组是相等的

 void sort(type a[])   

 void sort(type a[], int fromIndx, int toIndex)     

void sort(type a[], Comparator c)     

void sort(type a[], int fromIndx, int toIndex, Comparator c)

        包括a[fromIndx]，但不包括a[toIndex]

        fromIndx== toIndex时，范围是一个空的范围

        排序算法都具有n*log(n)的计算复杂性，效率高

        排序算法都保证稳定，即排序算法不会改变相等元素的顺序

        对不同类型的数组，算法的实现并不完全相同

调用Arrays.sort();

数组的复制

——java.lang.System

void arraycopy(Object src, int src_position, Object dst, int dst_position, int length)

范围不能越界

可对任何同类型的数组进行复制

数组复制过程中做严格的类型检查

更详细的内容参见JDK文档

4.题目

（1）单选题

1.1 关于一维数组的定义形式，哪个是错误的？

A.int intArr=new int[10];

B.int intArr[]=new int[10];

C.int intArr[]={1,2,3,4,5};

D.int intArr[]=new int[]{1,2,3,4,5};

E.int intArr[]={1,2,3,4,5};

1.2 数组的定义为：int[] arr=new int[10];
如何获得数组的长度？

A.arr.length()

B.arr.size()

C.arr.length

D.arr.size

1.3 执行完以下代码int[ ] x = new int[25]；后，以下哪项说明是正确的( )

A.x[24]为0

B.x[24]未定义

C.x[25]为0

D.x[0]没有数值存在

1.4 关于char类型的数组，说法正确的是( )。

A.其数组的默认值是'A'

B.可以仅通过数组名来访问数组

C.数组不能转换为字符串

D.可以存储整型数值

1.5 下面关于数组声明和初始化的语句那个有语法错误？（   ）

A.int a1[]={3,4,5};

B.String a2[]={"string1","string1","string1"};

C.String a3[]=new String(3);

D.int[][] a4=new int[3][3];

1.6 若int a[][]={{123,345,334},{1,2},{3,4}}; 则 a[2][1]=（ ）。

A.1

B.3

C.2

D.4

（2）程序填空题

2.1 求一个二维数组中每行的最大值和每行的和

以下程序的功能是求一个二维数组中每行的最大值和每行的和。

输入样例

3 
1 2 3 
6 5 4 
7 9 8

输出样例

1  2  3  3  6
6  5  4  6 15
7  9  8  9 24

import java.util.Scanner;

public class Main {

        public static void main(String[] args) {

                Scanner sc=new Scanner(   System.in    );

                int n=sc.nextInt();

                int a[][]=new int[n][n];

                int b[]=new int[n];

                int c[]=new int[n];

                for(int i=0;i<a.length;i++){

                        for(int j=0;j<   a[i].length     ;j++){

                                a[i][j]=sc.nextInt();

                        }

                }

                int max,s;

                for(int i=0;i<a.length;i++){

                        max=a[i][0];

                        s=0  ;    //2 分

                        for(int j=0;j<a[i].length;j++){

                                if(a[i][j]>max){

                                        max=a[i][j]  ;        //2 分

                                }

                                s+=a[i][j];

                        }

                        b[i]=max;

                        c[i]=s;

                }

                for(int i=0;i<a.length;i++){

                        for(int j=0;j<a[i].length;j++){

                                System.out.printf("%3d",    a[i][j]   );

                        }

                        System.out.printf("%3d%3d",b[i],c[i]);

                        System.out.println();

                }

        }

}

2.2 输出Fibonacci数列

用数组来求Fibonacci数列问题，打印前20项数列，每行打印4个数。

public class Main {

        public static void main(String[] args) {

                int f[]=new int[20];

                f[0]=1;

                f[1]=1;

                for(int i=2;i<20;i++){

                        f[i] = f[i - 2] + f[i - 1] ;//3 分

                }

                for(  int i = 0 ;i<20;i++){

                        System.out.printf("%12d",f[i]);

                        if(    (i+1)%4==0    )

                                System.out.println();

                }

        }

}

（3）函数题

3.1人口统计

本题运行时要求键盘输入10个人员的信息（每一个人信息包括：姓名，性别，年龄，民族），要求同学实现一个函数，统计民族是“汉族”的人数。

函数接口定义：

public static int numofHan(String data[])

其中 data[] 是传入的参数。 data[]中的每一个元素都是一个完整的人员信息字符串，该字符串由“姓名，性别，年龄，民族”，各项之间用英文半角的逗号分隔。函数须返回 值是汉族的人数。

裁判测试程序样例：

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        final int HUMANNUM=10;
        String persons[]=new String[HUMANNUM];
        Scanner in=new Scanner(System.in);
        for(int i=0;i<persons.length;i++)
            persons[i]=in.nextLine();
        int result=numofHan(persons);
        System.out.println(result);
    
    }
    
    /*在此处给出函数numofHan()*/
    

}

输入样例：

Tom_1,男,19,汉族
Tom_2,女,18,汉族
Tom_3,男,20,满族
Tom_4,男,18,汉族
Tom_5,男,19,汉族人
Tom_6,女,17,汉族
Tom_7,男,19,蒙古族
汉族朋友_1,男,18,汉族
Tom_8,male,19,老外
Tom_9,female,20,汉族

输出样例：

7

代码：

 public static int numofHan(String data[]){
      int n=0;

       for(int i=0 ; i<data.length ; i++){
           if(data[i].indexOf("汉族")>=0){//也可以写成data[i].indexOf("汉族",5)>=0
                 n++;
           }
       }

       return n;   
   }

indexOf() 方法有以下四种形式：

  • public int indexOf(int ch): 返回指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。

  • public int indexOf(int ch, int fromIndex): 返回从 fromIndex 位置开始查找指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。

  • int indexOf(String str): 返回指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。

  • int indexOf(String str, int fromIndex): 返回从 fromIndex 位置开始查找指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1。

（4）编程题

4.1 使用二维数组实现Matrix(矩阵)。

使用二维数组实现Matrix(矩阵)。

1. 定义Matrix(矩阵)类，要求如下：   
   a) 变量：matrix(int型二维数组)，row(行数)，column(列数)；   
   b) 方法：实现两个矩阵的乘法，所有方法将返回操作后的结果矩阵。(两个矩阵的乘法：一个m×n的矩阵a（m,n)乘一个n×p的矩阵b（n,p)，会得到一个m×p的矩阵c（m,p)。矩阵的行数和列数自定。）   
   c) 定义构造方法。     
     
2. 编写主类，测试Matrix类。包括：构建对象，测试每一个方法，并将测试结果输出到屏幕上。

输入格式:

按下面格式输入行数、列数和矩阵:
矩阵1：

2 3
1 2 3 
4 5 6

矩阵2：

3 2
7 8 
9 0
1 2

输出格式:

按下面格式输出乘积矩阵，每行后面有一个空格符和回车换行符：

28 14 
79 44

输入样例:

2 3
1 2 3 
4 5 6
3 2
7 8 
9 0
1 2

输出样例:

28 14 
79 44

代码：

import java.util.*;
public class Main{
    public static void main(String []args){
        Scanner s = new Scanner(System.in);
        int n1 = s.nextInt();
        int m1 = s.nextInt();
        int a1[][] = new int[n1][m1];
        for(int i =0;i<n1;i++){
            for(int j=0;j<m1;j++){
                a1[i][j] = s.nextInt();
            }
        }
        Matrix a= new Matrix(n1,m1,a1);

        int n2 = s.nextInt();
        int m2 = s.nextInt();
        int a2[][] = new int[n2][m2];
        for(int i =0;i<n2;i++){
            for(int j=0;j<m2;j++){
                a2[i][j] = s.nextInt();
            }
        }
        Matrix b = new Matrix(n2,m2,a2);

        Matrix c = new Matrix(a.row,b.column,new int[a.row][b.column]);
        c = c.multiply(a,b);

        for(int i =0;i<c.row;i++){
            for(int j=0;j<c.column;j++){
                System.out.print(c.matrix[i][j]+" ");
            }
            System.out.println();
        }
    }

}

 class Matrix{
    int [][] matrix;
    int row;
    int column;

    Matrix(int row,int column, int[][]matrix){
        this.row = row;
        this.column = column;
        this.matrix = matrix;
    }
    Matrix(){

    }

    public Matrix multiply(Matrix m1,Matrix m2){
        Matrix mat=new Matrix( m1.row, m2.column,new int[m1.row][m2.column]);
        for (int i = 0; i < m1.row; i++) {
            for (int j = 0; j < m2.column; j++) {
                for (int k = 0; k <m1.column; k++) {
                    mat.matrix[i][j] += m1.matrix[i][k]*m2.matrix[k][j];
                }
            }
        }
        return mat;
    }
}

 注意：

public Matrix multiply(Matrix m1,Matrix m2){
        Matrix mat=new Matrix( m1.row, m2.column,new int[m1.row][m2.column]);
        for (int i = 0; i < m1.row; i++) {
            for (int j = 0; j < m2.column; j++) {
                for (int k = 0; k <m1.column; k++) {
                    mat.matrix[i][j] += m1.matrix[i][k]*m2.matrix[k][j];
                }
            }
        }
        return mat;
    }

4.2 程序改错1：对象与数组

修改如下程序的语法错误和逻辑错误，使程序运行结果如下：

运行结果.png

//--------------------Main.java
 public class Student {
    private String name; 
    private double score;

    public  String getName(){
        return name;
    }
    
    public void setName(String name){
        this.name = name;
    }
    
    public double getScore(){
        return score;
    }
    
    public void setScore(double score){
        this.score =score;
    }
    
    public void  toString( ){
        return  this.name + "--" +this.score ;
    }
    
}

public class Main {
    public static void main(String args[])    {    
        String []name = {"Tom","Jim","Apple","Rose","Jack"    ,"Lucy"};
        double [] score = {98,76,85,66,72};
        
        Student [] sGroup = new Student[ name.length ];
        
        for( int i = 0 ; i < sGroup.length ; i++)
            sGroup[i] = new Student (name[i], score[i]);
        
        System.out.println("Student");
        for( int i = 0 ; i < sGroup.length ; i++)
            System.out.println(sGroup[i]);
            
        System.out.println("end");
    }
}

输入格式:

无。

输出格式:

Student
Tom--98.0
Jim--76.0
Apple--85.0
Rose--66.0
Jack--72.0
Lucy--0.0
end

输入样例:

无

输出样例:

Student
Tom--98.0
Jim--76.0
Apple--85.0
Rose--66.0
Jack--72.0
Lucy--0.0
end

代码：

class Student {
    private String name;
    private double score;

    //添加构造器
    Student(String n, double s){
        name = n;
        score = s;
    }
    public  String getName(){
        return name;
    }

    public void setName(String name){
        this.name = name;
    }

    public double getScore(){
        return score;
    }

    public void setScore(double score){
        this.score =score;
    }

    public String  toString( ){
        return  this.name + "--" +this.score ;
    }

}

public class Main {
    public static void main(String args[])    {
        String []name = {"Tom","Jim","Apple","Rose","Jack"    ,"Lucy"};
        double [] score = {98,76,85,66,72};

        Student [] sGroup = new Student[ name.length ];

        for( int i = 0 ; i < sGroup.length ; i++){
        //注意"Lucy"的成绩问题
            if(i < score.length){
                sGroup[i] = new Student (name[i], score[i]);
            }
            else{
                sGroup[i] = new Student (name[i], 0);
            }
        }

        System.out.println("Student");
        for( int i = 0 ; i < sGroup.length ; i++)
            System.out.println(sGroup[i]);

        System.out.println("end");
    }
}

4.3 数组乱炖

定义一个整型数组a，数组的长度n通过键盘输入，并通过键盘给数组a赋值，赋值后完成下列操作：

1.一次性输出整个数组a的元素

2.将数组a的数据复制到数组b中

3.对数组a进行排序，并一次性输出排序后数组a的元素

4.通过键盘输入一个数，判断该数是否存在数组中，如果存在输出该数所在的下标，不存在输入no

5.对数组a中的下标为0的元素到下标为2个（不包括2）数组元素，赋值为9，然后一次性输出整个数组的值

6.判断数组a和数组b是否相同(数组元素内容相同），如果相同输出yes，否则输出no

输入格式:

第一行输入数组a的长度
第二行输入数组a的各个元素（用空格隔开）
第三行输入要查询的元素

输出格式:

对每一组输入，在第一行输出数组a。
第二行输出数组b
第三行输出排序后的数组a
第四行输出查询后结果
第五行输出填充数据后的数组a
第六行输出两个数组判断的结果

输入样例:

在这里给出一组输入。例如：

5
2 1 3 5 6
7

5
4 3 7 6 8
7

输出样例:

在这里给出相应的输出。例如：

[2, 1, 3, 5, 6]
[2, 1, 3, 5, 6]
[1, 2, 3, 5, 6]
no
[9, 9, 3, 5, 6]
no

[4, 3, 7, 6, 8]
[4, 3, 7, 6, 8]
[3, 4, 6, 7, 8]
3
[9, 9, 6, 7, 8]
no

代码：

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

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n= sc.nextInt();
        if (n>0){
            int[] a=new int[n];
            int[] b=new int[n];
            for (int i = 0; i < n; i++) {
                a[i]= sc.nextInt();
            }
            System.out.println(Arrays.toString(a));
            System.arraycopy(a, 0, b, 0, a.length);
            System.out.println(Arrays.toString(b));
            Arrays.sort(a);
            System.out.println(Arrays.toString(a));
            int m= Arrays.binarySearch(a,sc.nextInt());//这里不能使用顺序查找
            if(m>-1) System.out.println(m);//下标有效则找到
            else System.out.println("no");
            if (n>=2){
                a[0]=9;
                a[1]=9;
            }
            System.out.println(Arrays.toString(a));
            if (Arrays.equals(a,b)) System.out.println("yes");
            else System.out.println("no");
        }
    }
}

770-0
关注
  • 7
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
7-11 数组元素的操作 (10分) java pta
m0_46553277的博客
10-30 733
本题目要求对一个20位长的数组进行操作，当输入一个0-19的整数时，把该位上的数据删除，然后依次把后面的数组中的数据依次前移，把最后一位填0。 输入格式: 输入一个整数（0-19）。 输出格式: 使用Arrays.toString输出。 输入样例: 在这里给出一组输入。例如： 13 输出样例: 在这里给出相应的输出。例如： [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 15, 16, 17, 18, 19, 0] import java.util.Ar
Java基础：（七）数组
地球村
08-17 1087
创建数组 数组是相同类型数据的有序集合 1.相同类型的若干个数据,按照一定先后次序排列组合而成。 2.其中,每一个数据称作一个数组元素 3.每个数组元素可以通过一个下标来访问它们 数组特点 1.其长度是确定的。数组一旦被创建，它的大小就是不可以改变的 2.其元素必须是相同类型,不允许出现混合类型 3.数组中的元素可以是任何数据类型，包括基本类型和引用类型 数组属引用类型 length, elem...
java判断两个数组的长度是否完全相同——pta
qq_63033414的博客
03-30 1387
此题如下： 代码如下： package cn.demo; import java.util.Scanner; public class Main3 { public static void main(String[] args) { int j; Scanner sc = new Scanner(System.in); int amount1 = sc.nextInt(); int[] number1 = new int[amount1]; for(int i=0;i<num
java——数组和方法
linjiayina的博客
10-04 1145
根据用户的"包裹参数"计算运费 运费计算的业务说明： 一个包裹的参数包括：重量（kg）、长度（cm）、宽度（cm）、高度（cm）。 邮寄包裹的规格需满足： 重量不大于200kg，长度不大于200cm，宽度不大于200cm，高度不大于200cm。 包裹邮费计算规则： 首重是2元。 重量小于100kg，费用 = 续重，0.8元/kg。 重量在100kg~150kg之间，费用 = 续重，0.75元/kg...
PTA 乙级——1008数组元素循环右移问题 C++实现 （取模&取余）
qq_45677518的博客
09-25 301
题目 一个数组A中存有N（>0）个整数，在不允许使用另外数组的前提下，将每个整数循环向右移M（≥0）个位置，即将A中的数据由（A​0​​A​1​​⋯A​N−1​​）变换为（A​N−M​​⋯A​N−1​​A​0​​A​1​​⋯A​N−M−1​​）（最后M个数循环移至最前面的M个位置）。如果需要考虑程序移动数据的次数尽量少，要如何设计移动的方法？ 代码 #include <iostream...
java面向对象基础——字符串 pta7-7 字符串加密 (15 分)
qq_51326035的博客
03-29 1003
import java.util.Scanner; public class Main{ public static void main(String[] args) { Scanner sc=new Scanner(System.in); String a =sc.nextLine();char[] s=a.toCharArray();//读入待加密字符串 StringBuffer ss= new StringBuffer(); String num1=sc.nextLine();//读入加密数字（类型是
PTA（JAVA）——1009 说反话 (20 分)
L1799096464的博客
09-08 350
PTA（JAVA）——1009 说反话 (20 分) 给定一句英语，要求你编写程序，将句中所有单词的顺序颠倒输出。 输入格式： 测试输入包含一个测试用例，在一行内给出总长度不超过 80 的字符串。字符串由若干单词和若干空格组成，其中单词是由英文字母（大小写有区分）组成的字符串，单词之间用 1 个空格分开，输入保证句子末尾没有多余的空格。 输出格式： 每个测试用例的输出占一行，输出倒序后的句子。 输...
PTA（JAVA）——1012 数字分类 (20 分)
L1799096464的博客
09-08 445
PTA（JAVA）——1012 数字分类 (20 分) 给定一系列正整数，请按要求对数字进行分类，并输出以下 5 个数字： A​1​​ = 能被 5 整除的数字中所有偶数的和； A​2​​ = 将被 5 除后余 1 的数字按给出顺序进行交错求和，即计算 n​1​​−n​2​​+n​3​​−n​4​​⋯； A​3​​ = 被 5 除后余 2 的数字的个数； A​4​​ = 被 5 除后余 3 的数字...
PTA（JAVA）——1005 继续(3n+1)猜想 (25 分)
L1799096464的博客
09-07 270
PTA（JAVA）——1005 继续(3n+1)猜想 (25 分) 卡拉兹(Callatz)猜想已经在1001中给出了描述。在这个题目里，情况稍微有些复杂。 当我们验证卡拉兹猜想的时候，为了避免重复计算，可以记录下递推过程中遇到的每一个数。例如对 n=3 进行验证的时候，我们需要计算 3、5、8、4、2、1，则当我们对 n=5、8、4、2 进行验证的时候，就可以直接判定卡拉兹猜想的真伪，而不需要重...
spring事务详细讲解-深入浅出
小电玩
09-08 316
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1160
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
okhttp，retrofit,rxjava 是如何配合工作的 作用分别是什么
追梦的鱼儿
09-04 683
OkHttp、Retrofit 和 RxJava 是 Android 开发中常用的三种库，它们各自有不同的作用，并且可以很好地配合工作来实现网络请求和响应的处理。
JAVA基础：数据类型、命名规范
weixin_53755148的博客
09-05 1300
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
自定义Stater
m0_63624484的博客
09-07 653
我们平时在导入依赖的时候，大部分导入的都是xxx-spring-boot-stater。那是因为它们都基于spring的规则将写好的框架定义成一个stater，这样方便springboot引用它们写好的功能。那我们为什么也要自定义stater呢？
基于JavaWeb开发的JavaSpringboot+Vue实现前后端分离房屋租赁系统
央顺科技官方博客
09-05 509
2021年处于信息科技高速发展的大背景之下。在今天，缺少手机和电脑几乎已经成为不可能的事情，人们生活中已经难以离开手机和电脑。针对增加的成本管理和操作,各大商家非常有必要建立自己的网上房屋租赁平台系统，这既可以让更多的人体验到网络所带来的方便，也有助于提高房屋的租赁。在经过几十年的高速发展后，互联网已成为最流行、最普及的媒体，每天的信息流量甚至能比得上过去十年。其以便捷的信息交换、快速的沟通速度，悄然地改变着会员的消费方式。
MyBatis面试
Tony_yitao的博客
09-09 376
MyBatis面试
C++位图的实现与详解
最新发布
2301_80468112的博客
09-09 257
在讲解位图之前我们先来看一道很经典的面试题。给40亿个不重复的无符号整数，没排过序。给一个无符号整数，如何快速判断一个数是否在这40亿个数中。我们有以下两种种解决方法：1. 遍历，时间复杂度O(N)。（太慢）2. 排序(O(NlogN))，利用二分查找: logN。深入分析:解题思路2是否可行，我们先算算40亿个数据大概需要多少内存。
SpringBoot总结
2302_77073236的博客
09-06 188
都做成图了，方便理解和掌握全局关系。
pta c语言结构体数组处理
12-13
针对pta c语言结构体数组处理，可以使用结构体数组来存储学生的信息，然后对学生的成绩进行求和和排序。下面是一个示例代码： ```c #include struct student { char name[20]; int score[3]; int sum; }; ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值