java Note 2021.7.21

最新推荐文章于 2024-07-25 14:31:34 发布
最新推荐文章于 2024-07-25 14:31:34 发布
阅读量82 收藏
点赞数
分类专栏： 笔记 java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51300373/article/details/119053720
版权

文章目录

java Note 2021.7.21

1、方法

1.1、 没有返回值也没有形参的方法
1.2、 没有返回值有形参的方法
修饰符 返回值类型 方法名(形参列表){
	方法体;
}

形参：执行方法的那一方需要调用方提供的数据
    举例：  XX去给我炒一个青椒肉丝   --->  相当于我 调用 XX 烹饪的功能
    那么XX需要我提供青椒还有肉丝，那么这个青椒和肉丝就是XX的烹饪功能的形参
    
    那么在定义方法的时候，必须声明自己需要的数据：   形参
    在调用方法的时候，必须将对应的数据给这个方法：   实参
  
    对应到java中，形参其实就是声明变量
                实参就是具体的值
    			它们的关系就是：将实参赋值给形参
1.3、调用有形参的方法：
类名.方法名(实参列表)

public class Demo1 {
    public static void main(String[] args) {        
    //调用add方法        
    Demo1.add(3,2);
       }   
        /*    
        定义add方法时，指定了两个形参a 与 b    
        它们至少空的变量，是没有值的    
        但是可以在方法体中使用它们,因为要执行方法体，就必须调用方法    
        而调用有形参的方法的时候，必须给形参赋值    
        结果：执行方法体的时候，形参是一定有值的
             */    
             public static void add(int a, int b){        
             System.out.println(a + b);  
              }
}

提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加
例如：第一章 Python 机器学习入门之pandas的使用

练习

1.调用方法打印乘法表，有一个参数，决定乘法表的行数

	/*
	1.调用方法打印乘法表，有一个参数，决定乘法表的行数 
	*/
public class Practise1 {
    public static void main(String[] args) {        
    mt(34);
       }    
    public static void mt(int n){
            for (int i = 1; i <= n; i++) {           
             for (int j = 1; j <= i ; j++) {                
             System.out.print(j + "x" + i + "=" + i*j +" "); 
                       }            
          System.out.println();      
           }  
            }
}

2.调用方法打印星号(矩形)，有两个参数，分别决定星号的行数与列数

public class Practise2 {
    public static void main(String[] args) {        
    stars(5,7);
       }    
    public static void stars(int rows, int cols){        
    for (int i = 0; i < rows; i++) {            
    for (int j = 0; j < cols; j++) {                
    System.out.print("* ");  
             }            
     System.out.println();  
          }  
           }
}
1.4、有返回值的方法
修饰符 返回值类型 方法名(形参列表){ 
					方法体; 
					return 值;//就是指定某个值为 返回值
		}
		注意： 返回值类型 一定要与 返回值的类型匹配

调用有返回值的方法:

注意：如果一个方法有返回值，则可以将调用该方法的代码直接当做值来使用

变量 = 类名.方法名(形参列表);
System.out.println(类名.方法名(形参列表));

public class Demo2 {
    public static void main(String[] args) {
        int result = add(3, 2);
        System.out.println("结果值为:" + result);
    }

    /*
    返回值类型不是void  表示这个方法一定要有返回值
    也就是方法体中必须有return 值.

     方法体中return 值。就是这个方法的返回值
     表示如果你调用add方法，则你会得到两个形参的和
     */
    public static int add(int a, int b){
        return a + b;
    }
}
练习

定义方法，形参接收3个数字，返回最大的那一个

/*
定义方法，形参接收3个数字，返回最大的那一个
 */
public class Practise3 {
    public static void main(String[] args) {
        System.out.println(getMax(9, 8, 5));
    }

    public static int getMax(int a, int b, int c){
//        return a>b?(a>c?a:c):(b>c?b:c);
        if(a > b){
            if(a > c){
                return a;
            }else{
                return c;
            }
        }else {
            if(b > c){
                return b;
            }else{
                return c;
            }
        }

    }
}

定义方法，形参接收两个数字，判断是否相等

/*
定义方法，形参接收两个数字，判断是否相等
 */
public class Practise4 {
    public static void main(String[] args) {
        System.out.println(equals(5,5));
    }
    public static boolean equals(int a, int b){
//        return a==b;
        if(a==b){
            return true;
        }
        return false;

    }
}
注意事项

一个有返回值的方法，方法体中的return必须被执行

2、方法的重载

方法的重载：

在同一个类中，多个方法的方法名一致，但是形参列表不一致

形参列表不一致：

1.类型不一致

2.数量不一致

3.顺序不一致

以上三个条件，满足了任意一个，都形成方法的重载

2.1、没有使用方法的重载
public class Demo3 {
    public static void main(String[] args) {
        //计算两个数字的和
        
        /*
        这种情况下，定义方法与调用方法实质上是没有问题的
        但是对于调用方法，压力很大。因为调用方法需要记住方法名与形参的对应的关系
        如果方法的数量很多，则记起来就很麻烦
        
        解决方案：能不能所有功能类似的方法使用同一个名称
        向这种如果  方法名相同，但是形参列表不一样的情况，就是方法的重载
         */
        add2(3, 2);
        add3(3, 4, 5);
        add4(4,7,1,3);
    }
    public static int add2(int a, int b){
        return a + b;
    }
    public static int add3(int a, int b, int c){
        return a + b + c;
    }
    public static int add4(int a, int b, int c, int d){
        return a + b + c + d;
    }
}
2.2、使用方法的重载
public class Demo3 {
    public static void main(String[] args) {
        add(3, 2);
        add(3, 4, 5);
        add(4,7,1,3);
    }
    /*
    以下三个方法形成了方法的重载
    因为三个方法都叫做add  但是形参列表都不一致
     */
    public static int add(int a, int b){
        return a + b;
    }
    public static int add(int a, int b, int c){
        return a + b + c;
    }
    public static int add(int a, int b, int c, int d){
        return a + b + c + d;
    }
}
练习

定义plus方法形成重载，可以接收两个int参数或者两个string参数，如果是两个int参数打印两个数的和，

如果是两个String参数，打印拼接起来的结果

定义方法打印矩形的星号形成重载，如果只有一个参数，则该参数决定了矩形的行和列

如果有两个参数，则第一个参数决定行，第二个参数决定列

/*
定义方法打印矩形的星号形成重载，如果只有一个参数，则该参数决定了矩形的行和列
如果有两个参数，则第一个参数决定行，第二个参数决定列
 */
public class Practise6 {
    public static void main(String[] args) {
        stars(5);
        stars(2,6);
    }

    public static void stars(int n){
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }

    public static void stars(int m, int n){
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

3、数组

数组就相当于一个容器，可以同时存放多个数据

优点：对自己存放的多个数据可以统一管理

在这里插入图片描述

4、初始化数组

4.1、动态初始化

只声明数组的长度，而不给数组的元素赋值

数据类型[] 变量名 = new 数据类型[长度];
4.2、静态初始化

声明数组的长度的同时也指定每一个元素的值

数据类型[] 变量名 = new 数据类型[]{数据1,数据2....};

也可以简写为：
数据类型[] 变量名 = {数据1,数据2....};

注意：这个简写只对初始化有效

5、获取数组的信息

5.1、获取长度
数组名.length;
5.2、获取数组指定元素的值
数组名[索引];
5.2、遍历数组

取出数组的每一个元素

public class Demo1 {
    public static void main(String[] args) {
        //动态初始化数组
        int[] ary1 = new int[5];//表示创建一个元素类型为int,长度为5的数组
        int[] ary2 = new int[]{1,3,5,7};//表示创建一个指定元素的数组
        int[] ary3 = {2,4,6,8};
        //ary3 = {1,2};会报错  因为这不是对ary3初始化  所以不能使用简写

        //获取数组的长度
        System.out.println(ary2.length);//4
        //获取数组指定索引的元素
        System.out.println(ary3[2]);//6

        //遍历ary2数组
        for (int i=0;i<ary2.length;i++){
            int cell = ary2[i];
            System.out.print(cell + ",");
        }
    }
}
练习

创建一个类，声明一个方法，参数是int[],方法返回包含了该数组每一个元素的字符串

/*
创建一个类，声明一个方法，参数是int[],方法返回包含了该数组每一个元素的字符串
 */
public class ArrayUtil {

    /**
     * 将指定的数组转换为字符串
     * @param ary 指定的数组
     * @return 数组的元素组成的字符串
     */
    public static String toString(int[] ary){
        String str = "";

        //1.遍历数组取出每一个元素
        for (int i = 0; i < ary.length; i++) {
            int cell = ary[i];
            //2.将取出的每一个元素都拼接到字符串上
            str += cell;
            //3.如果不是最后一个元素，则向字符串拼接一个逗号
            if(i!=ary.length-1){//任何一个数组的最后一个元素的索引，一定是这个数组的长度-1
                str += ",";
            }
        }
        return str;
    }
}

public class Demo2 {
    public static void main(String[] args) {
        int[] ary2 = new int[]{1,3,5,7};
        int[] ary3 = {2,4,6,8};

        //注意：调用方法与声明方法不在同一个类，所以不能省略类名了
        String str1 = ArrayUtil.toString(ary2);//调用方法 遍历ary2数组
        System.out.println(str1);

        System.out.println(ArrayUtil.toString(ary3));//调用方法遍历ary3数组
    }
}

6、不同类型的数组的默认值问题

public class Demo3 {
    public static void main(String[] args) {
        /*
        所有的整型数组的元素的默认值都是0
         */
        int[] ary1 = new int[5];
        System.out.println(ArrayUtil.toString(ary1));
        byte[] ary2 = new byte[3];
        for (int i = 0; i < ary2.length; i++) {
            System.out.print(ary2[i] + " ");
        }
        System.out.println();

        /*
            所有浮点型数组的元素的默认值都是0.0
         */
        double[] ary3 = new double[4];
        for (int i = 0; i < ary3.length; i++) {
            System.out.print(ary3[i] + " ");
        }
        System.out.println();
        /*
        字符型数组的元素的默认值是数字0对应的那个字符
         */
        char[] ary4 = new char[4];
        for (int i = 0; i < ary4.length; i++) {
            System.out.print(ary4[i] + " ");
            System.out.print((int)ary4[i]);
        }
        System.out.println();

        /*
        布尔类型数组的元素的默认值是false
         */
        boolean[] ary5 = new boolean[4];
        for (int i = 0; i < ary5.length; i++) {
            System.out.print(ary5[i] + " ");
        }
        System.out.println();

        /*
        所有的引用类型数组的元素的默认值是null
         */
        String[] ary6 = new String[4];
        for (int i = 0; i < ary6.length; i++) {
            System.out.print(ary6[i] + " ");
        }
        System.out.println();
    }
}

7、数组索引的范围问题

public class Demo4 {
    public static void main(String[] args) {
        //创建一个长度为5的数组  索引的范围是:0~4
        int[] ary = new int[5];

        /*
        取出数组中索引为5的元素
        因为该数组没有值为5的索引  所以这里使用的索引越界了
        会出现ArrayIndexOutOfBoundsException
        当程序出现异常，则程序会在出现异常的那一行代码被中断
         */
        System.out.println(ary[5]);

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

8、数组元素的操作

8.1、查找元素

查找指定元素： 数组名[索引]

查找所有元素：遍历数组

8.2、修改元素的值

数组名[索引] = 值;

练习

创建int数组，添加100个元素，值为1~100范围的随机数

然后将每一个元素的值都+1

import java.util.Random;
public class Demo5 {
    public static void main(String[] args) {
        Random random = new Random();

        int[] ary = new int[100];
        //设置数组的元素为1~100范围内的随机整数
        for (int i = 0; i < ary.length; i++) {
            ary[i] = random.nextInt(100) + 1;
        }
        System.out.println(ArrayUtil.toString(ary));

        //将每一个元素的值加1
        for (int i = 0; i < ary.length; i++) {
            ary[i] += 1;
        }
        System.out.println(ArrayUtil.toString(ary));
    }
}

public class Practise {
    public static void main(String[] args) {
        String[] ary = {"周杰伦","昆凌","侯佩岑"};
        //将ary数组的每一个元素值后面加上"同志"两个字
    }
}

public class Practise {
    public static void main(String[] args) {
        String[] ary = {"周杰伦","昆凌","侯佩岑"};
        //将ary数组的每一个元素值后面加上"同志"两个字
        for (int i = 0; i < ary.length; i++) {
            ary[i] += "同志";
        }
        for (int i = 0; i < ary.length; i++) {
            System.out.println(ary[i]);
        }
    }
}
8.3、向数组中添加元素

数组的长度是不可更改的

所以如何才能向一个数组中添加元素呢？

答案：创建一个长度更大的新数组，将原数组的元素复制到新数组中，再向新数组中添加元素

public class Demo6 {
    public static void main(String[] args) {
        int[] ary = {1,3,5,7};
        int value = 9;
        /*
        将调用append方法得到的新数组赋值给ary变量
        ary变量之前存放的是原数组  现在存放的变成了新数组
        这么做的好处：对于使用ary变量的用户来说，给它的感觉是ary数组变大了
         */
        ary = append(ary, value);

        for (int i = 0; i < ary.length; i++) {
            System.out.print(ary[i] + " ");
        }

    }

    /**
     * 将指定值添加到指定的数组的末尾
     * @param ary 指定的数组
     * @param value 指定的值
     * @return 添加了元素的新数组
     */
    public static int[] append(int[] ary, int value){
        //1.创建容量为ary.length+1的新数组
        int[] newAry = new int[ary.length + 1];
        //2.将原数组中的所有元素复制一份到新数组中
        for (int i = 0; i < ary.length; i++) {
            //将原数组的元素复制给新数组的元素
            newAry[i] = ary[i];
        }
        //3.将指定值添加到新数组的末尾
        newAry[newAry.length - 1] = value;
        return newAry;
    }
}

9、数组作为方法的参数

10、 创建数组变量的内容图

public static void methodName(){
    int i = 5;
    int[] ary = {1,3,5,7};
}

在这里插入图片描述

可以发现创建的数组变量，实际上存放的数组的地址值

每次使用这个变量，其实是根据存放的地址值到堆内存中找到对应的数组进行操作

10.1、 java只有值传递

如果将一个基本数据类型的变量赋值给另一个变量，是将这个变量本身的值复制一份给另一个变量

int i = 5;
int j = i;

如果将一个引用类型的变量赋值给另一个变量，是将这个变量存放的地址值复制一份给另一个变量

int[] ary = {1,2,3};
int[] ary2 = ary;
练习
public class Practise2 {
    public static void main(String[] args) {
        int i = 5;
        int[] ary = {1,2,3};

        test1(i);
        System.out.println(i);//5

        test2(ary);
        System.out.println(ary[0]);//2
    }
    public static void test1(int i){
        i++;
    }

    public static void test2(int[] ary){
        ary[0]++;
    }
}

在这里插入图片描述

11添加元素的内存图

在这里插入图片描述

12、删除数组元素

删除数组中指定索引处的元素删除的思路：
1.将数组中需要被删除的元素后面的所有元素，向前移动一位
2.创建一个容量为原数组的长度-1的新数组
3.将原数组的元素(长度-1个)复制到新数组中

public class Demo7 { 
   public static void main(String[] args) {
           int[] ary = {1,3,5,7,9};        ary = delete(ary,0);
           //调用方法删除ary数组中索引为1的元素        
           for (int i = 0; i < ary.length; i++) {            
           System.out.print(ary[i] + " "); 
                 } 
  }   
  				 /**     
  				 * 删除指定数组中指定索引处的元素    
  				 *  * @param ary 指定的数组     
  				 * * @param index 指定的索引     
  				 * * @return 删除元素之后的效果的新数组
  				 *      */    
  		     public static int[] delete(int[] ary,int index){        
  		     //1.将原数组中需要被删除的元素后面的所有元素向前移动一位       
  		      for (int i = index+1; i < ary.length; i++) {
  		                  ary[i-1] = ary[i]; 
  		                        }        
  		         //2.创建长度为原数组的长度-1的新数组        
  		         int[] newAry = new int[ary.length-1];        
  		         //3 将元素值的元素复制到新数组        
  		         for (int i = 0; i < newAry.length; i++) {
  							newAry[i] = ary[i];
  							       }        
  							       return newAry; 
  							         }
}

在这里插入图片描述

练习

生成100个1~100范围的随机整数，将偶数放入一个数组，将奇数放入一个数组将每一个数组中5的倍数都删除


public class demo1 {
    public static void main(String[] args) {
    int[] arr=new int[100];

        Random random=new Random();
        int o=0,j=0;
        for (int i = 0; i < 100; i++) {
            arr[i]=random.nextInt(100)+1;
            if (arr[i]%2==0)
                o++;
            else
                j++;
        }
        System.out.println("===========================");
        System.out.println("得到的原数组为：");
        System.out.println(toString(arr));
        System.out.println("\n===========");
        int[] ji=getJi(arr,j);
        System.out.println("得到的奇数数组为：");
        System.out.println(toString(ji));
        System.out.println("\n===========");
        int[] ou=getOu(arr,o);
        System.out.println("得到的偶数数组为：");
        System.out.println(toString(ou));
        System.out.println("===========================");
        System.out.println("去掉5的倍数后：");
        System.out.println("\n===========");
       ji=getNewArr(ji);
        System.out.println("得到的奇数数组为：");
        System.out.println(toString(ji));
        System.out.println("\n===========");
         ou=getNewArr(ou);
        System.out.println("得到的偶数数组为：");
        System.out.println(toString(ou));
    }
    //除去5的倍数得到的数组
    public static  int[] getNewArr(int[] arr){
        int k=0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]%5!=0) {
                k++;//获取不是5的倍数数组的个数作为新数组的长度
            }else
                arr[i] = 0;//将5的倍数置为0
        }
        int[] newArr=new int[k];
        int k1=0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]!=0){
            newArr[k1]=arr[i];
            k1++;
            }
        }
        return newArr;
    }
    //获取奇数数组
    public  static int[] getJi(int[] arr,int count){
        int[] newArr=new int[count];
        int k=0;
    for (int i = 0; i < arr.length; i++) {
        if (arr[i]%2!=0){
            newArr[k]=arr[i];
            k++;
        }
    }
    return newArr;
}
	//获取偶数数组
    public  static int[] getOu(int[] arr,int count){
        int[] newArr=new int[count];
        int k=0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]%2==0){
                newArr[k]=arr[i];
                k++;
            }
        }
        return newArr;
    }
	//将数组变成字符串输出
    public static String toString(int[] arr){
        String str="";
        for (int i = 0; i < arr.length; i++) {
            str+=arr[i]+" ";
            if ((i+1)%10==0){
                str+="\n";
            }
        }
        return str;
    }
}

输出结果：

在这里插入图片描述

IT_JAVA_123
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java.note.zip
06-12
"Java.note.zip"很可能是一个包含了关于Java学习笔记的压缩文件，它可能包括了各种主题，如基础语法、面向对象编程、集合框架、异常处理、多线程、I/O流、网络编程、数据库连接以及Java高级特性等。 首先，Java的...
Java 对象 note
mygodhome的专栏
01-06 147
创建对象 声明 不为对象分配内存空间，而只是分配一个引用。eg.String name; 实例化 为对象分配内存空间和初始化对象。eg. String name; name = new String("Hi V"); //new分配内存空间，然后调用String 的构造方法，并传递参数“Hi V" 空对象 一个引用变量没有通过new 分配内存空间，这个对象就叫空对象。eg.表示为：...
Java_Note.zip_Java笔记
09-24
这份"Java_Note.zip"压缩包包含了一份详细的Java笔记，对于初学者来说，它是一份宝贵的资源，可以帮助理解语言基础，掌握核心概念，并通过实例加深理解。 笔记可能会涵盖以下几个主要知识点： 1. **Java基础**：这...
java-note.rar_记事本
09-19
"java-note.rar_记事本" 这个标题暗示了这是一个与Java编程语言相关的项目，它创建了一个简易的记事本应用程序。".rar" 是一种常见的压缩文件格式，通常用于打包和分享多个文件。在这个案例中，"java-note.rar" 指的...
java_note.zip_javascript
09-24
这个名为"java_note.zip_javascript"的压缩包显然包含了关于JavaScript学习的笔记或教程，旨在帮助初学者逐步掌握这门语言。JavaScript不同于Java，尽管它们名字相似，但它们在语法和用途上有着显著的区别。...
红米Note7|lineage18.1| 安卓11.0|红米Note7.zip
05-31
标题中的“红米Note7|lineage18.1| 安卓11.0|红米Note7.zip”表明这是一个针对红米Note7手机的系统固件更新，基于LineageOS 18.1定制，适配Android 11操作系统。LineageOS是一款开源的Android定制系统，它提供了许多...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1208
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java-Lambda
lizhiwei21的博客
07-21 502
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 800
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
weixin_43561432的博客
07-24 275
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
淘客返利系统中的服务发现与注册机制详解
技术研究中心
07-22 2164
通过服务注册中心，服务提供者可以将自己注册到注册中心，服务消费者可以从注册中心获取服务提供者的地址，以实现服务调用。本文详细介绍了淘客返利系统中服务发现与注册机制的实现，包括Eureka的配置与代码示例。通过Eureka，我们可以轻松实现服务的注册与发现，确保分布式系统中各个服务之间的通信。在本文中，我们将深入探讨淘客返利系统中的服务发现与注册机制，并结合Java代码进行详细讲解。在我们的淘客返利系统中，我们采用Eureka作为服务发现与注册的工具。在我们的淘客返利系统中，首先需要配置Eureka服务器。
Java实现拼图小游戏
Aishangyuwen的博客
07-22 1354
Java实现拼图小游戏
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 1006
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 241
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
【Java并发编程之美 | 第三篇】Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
踢桃的成长之路
07-21 860
Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
学习笔记---java篇（0723）
m0_70630166的博客
07-23 772
java、数据类型、循环、选择等
4.Jmeter接口性能测试
weixin_43444329的博客
07-23 727
系统用户数：软件系统注册的用户总数（要注意初始化环境）在线用户数：某段视角内访问用户数，这些用户只是咋先，不一定同时做某一件事情。（初始化环境（warm up热机：让系统接近运行的系统，让系统运行更快 磁盘->内存））并发用户数：某一个时间同时向系统提交请求的用户数，场景不一定是同一个。：测试web系统的性能，支持多少并发？在确定并发用户数之前，必须先对用户的业务进行分解，分析出其中的典型业务场景（用户最常用、最关注的业务操作）然后基于场景获得其并发用户数。
c++ 智能指针shared_ptr与make_shared
Txwtech笛克特科
07-25 206
shared_ptr是C++11引入的一种智能指针，‌它允许多个shared_ptr实例共享同一个对象，‌通过引用计数来管理对象的生命周期。‌当最后一个持有对象的shared_ptr被销毁时，‌它会自动删除所指向的对象。‌这种智能指针主要用于解决资源管理问题，‌避免内存泄漏。make_shared是C++标准库中的一个函数，‌用于创建一个shared_ptr智能指针，‌它接受一个或多个参数来构造一个对象，‌并返回一个指向该对象的shared_ptr。类SerialModbus的成员指针。
19.jdk源码阅读之FutureTask
最新发布
前端、移动端、后端源码级底层原理分享
07-25 547
FutureTask 是 Java 并发包中的一个重要类，它实现了 RunnableFuture 接口，结合了 Future 和 Runnable 的特性。FutureTask 通常用于异步任务的执行和结果的获取。
noteexpress.zip
12-28
NoteExpress.zip 是一个压缩文件，里面包含了 NoteExpress 软件的安装文件及相关资源。NoteExpress 是一款文献管理软件，能够帮助用户管理、整理、搜索和引用学术文献。用户可以使用该软件建立自己的文献数据库，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值