Java学习笔记day14-常用API-数据包装类-二分查找-冒泡排序-递归

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

Day14

常用API
Math类概述

​ Math包含执行基本数字运算的方法

Math类常用方法

方法名说明
public static int abs(int a)返回参数的绝对值
public static double ceil(double a)向上取整
public static double floor(double a)向下取整
public static int round(float a)四舍五入
public static int max(int a,int b)返回两个int值中的较大值
public static int min(int a,int b)返回两个int值中的较小值
public static double pow(double a,double b)返回a的b次幂的值
public static double random()返回值为double的正值[0.0,1.0)

示例：

package math;

public class MathTest {
    public static void main(String[] args) {
        //public static int abs(int a) 返回参数的绝对值
        int abs = Math.abs(-8);
        System.out.println(abs);
        //public static double ceil(double a) 向上取整
        double ceil = Math.ceil(8.5);
        System.out.println(ceil);
        //public static double floor(double a) 向下取整
        double floor = Math.floor(6.4);
        System.out.println(floor);
        //public static int round(float a) 四舍五入
        int round = Math.round(6.45f);
        System.out.println(round);
        //public static int max(int a,int b) 返回两个int值中的较大值
        int max = Math.max(6,8);
        System.out.println(max);
        //public static int min(int a,int b) 返回两个int值中的较小值
        int min = Math.min(6,8);
        System.out.println(min);
        //public static double pow(double a,double b) 返回a的b次幂的值
        double pow = Math.pow(2,3);
        System.out.println(pow);
        //public static double random() 返回值为随机的double的正值[0.0,1.0)
        double random = Math.random();
        System.out.println(random);
    }
}

运行结果：
8
9.0
6.0
6
8
6
8.0
0.9508660591551303
System类概述

​ System不能实例化

System类常用方法

方法名说明
public static void exit(int status)终止当前运行的Java虚拟机，非零表示异常终止
public static long currentTimeMillis()返回当前时间（以毫秒为单位）
arraycopy(数据源数组，起始索引，目的地数组，起始索引，拷贝个数)数组copy

示例：

package system;

public class SystemTest {
    public static void main(String[] args) {
        //public static void exit(int status) 终止当前运行的Java虚拟机，非零表示异常终止
        //System.exit(0);
        //public static long currentTimeMillis() 返回当前时间（以毫秒为单位）
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println(end-start);  //输出结果为for循环所执行的时间
        //arraycopy(数据源数组，起始索引，目的地数组，起始索引，拷贝个数) 数组copy
        int[] arr1 = {1,2,3,4,5};
        int[] arr2 = new int[10];
        //把arr1中的数拷贝到arr2中
        System.arraycopy(arr1,0,arr2,0,arr1.length);
        for (int i = 0; i < arr2.length; i++) {
            System.out.print(arr2[i]+" ");  //结果为：1 2 3 4 5 0 0 0 0 0
        }
        System.out.println();
        //把arr1中的后3个数拷贝到arr2中的后三个位置
        System.arraycopy(arr1,2,arr2,7,3);
        for (int i = 0; i < arr2.length; i++) {
            System.out.print(arr2[i]+" ");  //结果为：1 2 3 4 5 0 0 3 4 5 
        }
    }
}
Object类概述

​ 每个类都可以将Object作为父类。所有类都直接或者间接的继承自该类；

​ 构造方法：public Object()

​ 子类的构造方法默认访问无参构造方法的原因：因为他们的顶级父类只有无参构造方法

​ 打印对象产生地址值的原因：
在这里插入图片描述

总结

  1. Object类是所有类的直接或者间接父类
  2. 直接打印一个对象就是打印这个对象的toString方法的返回值
  3. Object类的toString方法得到的是对象的地址值
  4. 一般会对toString方法进行重写

Object类常用方法

方法名说明
public String toString()返回对象的字符串表示形式。建议所有子类重写该方法，自动生成
public boolean equals(另一个对象)比较对象是否相等。默认比较地址，重写可以比较内容，自动生成

示例：

Student类

package object;

public class Student {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }
}

测试类：

package object;

public class StudentTest {
    public static void main(String[] args) {
        Student s1 = new Student("拉拉裤",101);
        Student s2 = new Student("七宝",8);
        Student s3 = new Student("七宝",8);
        System.out.println(s1==s2);
        System.out.println(s1.equals(s2));
        System.out.println(s3.equals(s2));
    }
}

扩展：

String s1 = "abc";
StringBuilder sb = new StringBuilder("abc");
//此时调用的是String类名中的equals方法，保证参数也是字符串，否则不会比较属性值而直接返回false
System.out.println(s1.equals(sb));  //false
//StringBuilder类中没有重写equals方法，用的就是Object类中的
System.out.println(sb.equals(s1));  //false
Objects类常用方法
方法名说明
public static String toString(对象)返回参数中对象的字符串表示形式
public static String toString(对象,默认字符串)返回对象的字符串表示形式，若对象为空返回默认字符串内容
public static Boolean isNull(对象)判断对象是否为空
public static Boolean nonNull(对象)判断对象是否为非空
Student s1 = new Student("拉拉裤",101);
s1 = null;
String result1 = Objects.toString(s1, "怎么是空呢");
System.out.println(result1); //怎么是空呢

boolean result = Objects.isNull(s1);
System.out.println(result); //true
BigDecimal类

构造方法

方法名说明
BigDecimal(double val)参数为double
BigDecimal(String val)参数为String
BigDecimal bd1 = new BigDecimal(10.0);
BigDecimal bd2 = new BigDecimal("0.5");
System.out.println(bd1);  //10
System.out.println(bd2);  //0.5

BigDecimal类的常用方法

作用：可以用来精确计算

方法名说明
public BigDecimal add(另一个BigDecimal对象)加法
public BigDecimal subtract(另一个BigDecimal对象)减法
public BigDecimal multiply(另一个BigDecimal对象)乘法
public BigDecimal divide(另一个BigDecimal对象)除法
public BigDecimal divide(另一个BigDecimal对象，精确几位，舍入模式)除法

示例：

package bigDecimal;

import java.math.BigDecimal;

public class BigDecimalTest {
    public static void main(String[] args) {
        //若要进行精确运算，要使用字符串构造
        BigDecimal bd1 = new BigDecimal("0.3");
        BigDecimal bd2 = new BigDecimal("0.2");
        BigDecimal add = bd1.add(bd2);
        System.out.println("和为："+add);
        BigDecimal subtract = bd1.subtract(bd2);
        System.out.println("差为："+subtract);
        BigDecimal multiply = bd1.multiply(bd2);
        System.out.println("积为："+multiply);
        BigDecimal divide = bd1.divide(bd2);
        System.out.println("商为："+divide);
        
        //参数1：表示参数运算的另一个对象
        //参数2：表示小数点后精确到多少位
        //参数3：舍入模式
        	//进一法
        	//去尾法
        	//四舍五入法
        BigDecimal d = bd2.divide(bd1,2,BigDecimal.ROUND_UP);  //进一法
        BigDecimal d1 = bd2.divide(bd1,2,BigDecimal.ROUND_FLOOR);  //去尾法
        BigDecimal d2 = bd2.divide(bd1,2,BigDecimal.ROUND_HALF_UP);  //四舍五入
        System.out.println("进一法："+d);
        System.out.println("去尾法："+d1);
        System.out.println("四舍五入："+d2);
    }
}

运行结果：
在这里插入图片描述

基本数据类型包装类
概述

​ 将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。

​ 常用操作之一：用于基本数据类型与字符串之间的转换

基本数据类型包装类
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble
charCharacter
booleanBoolean
Integer获得对象
方法名说明
public Integer(int value)根据int创建Integer对象(过时)
public Integer(String s)根据String值创建Integer对象(过时)
public static Integer valueOf(int i)返回表示指定的int值的Integer实例
public static Integer valueOf(String s)返回一个保存指定值的Integer对象String
package integer;

public class IntegerTest {
    public static void main(String[] args) {
        Integer i1 = new Integer(10);
        Integer i2 = new Integer("10");
        System.out.println(i1); //10
        System.out.println(i2); //10

        Integer i3 = Integer.valueOf(20);
        Integer i4 = Integer.valueOf("20");
        System.out.println(i3); //20
        System.out.println(i4); //20
    }
}
Integer自动装箱和自动拆箱
  • 装箱：把一个基本数据类型变成对应的包装类；
  • 自动：Java底层会帮我们自动调用valueOf方法
  • 拆箱：把一个包装类型，变成对应的基本数据类型

例：

Integer i = 100;  //自动装箱机制
i += 200;  //i = i + 200
		   //会把i这个对象变成基本数据类型100
		   //100 + 200 = 300
		   //把基本数据类型300再次自动装箱变成Integer对象赋值给i
System.out.println(i);//300
Integer的成员方法
  • static int parseInt(Stirng s) 将字符串类型的整数变成int类型的整数

示例：

String s1 = "100";
int i1 = 200;
System.out.println(s1+i1);  //100200  字符串+任意的数据类型，结果都是一个字符串

int i2 = Integer.parseInt(s1);  //可以将字符串类型的整数变成int类型的整数
System.out.println(i2+i1);  //300

//int--->String
//方式一:+""
int i3 = 100;
String s2 = i3+"";
System.out.println(s2+100);  //100100
//方式二:可以调用String类中valueOf方法
String s3 = String.valueOf(i3);
System.out.println(s3+100);  //100100
案例：字符串中数据处理

需求：有一个字符串：“91 27 46 38 50“，把其中的每一个数存到int类型的数组中；

思路：

  1. 定义一个字符串
  2. 把字符串中的数字数据存储到一个int类型的数组中
  3. 遍历数组输出结果
package integer;

public class Anli1 {
    public static void main(String[] args) {
        String s = "91 27 46 38 50";
        //利用split方法对字符串进行切割,将得到的结果存入字符串数组中
        String[] strArr = s.split(" ");
        //定义整型数组用于存储数据
        int[] intArr = new int[strArr.length];
        //遍历字符串数组,并将数组中的字符串数据转换为整型存入整型数组
        for (int i = 0; i < strArr.length; i++) {
            intArr[i] = Integer.parseInt(strArr[i]);
        }
        //遍历整型数组并打印结果
        for (int i = 0; i < intArr.length; i++) {
            System.out.print(intArr[i]+" ");
        }
    }
}

运行结果：
在这里插入图片描述

数组的高级操作
二分查找

步骤：

  1. 定义两个变量，表示要查找的范围。默认min=0，max=最大索引
  2. 循环查找，但是min<=max
  3. 计算出mid的值
  4. 判断mid位置的元素是否为要查找的元素，如果是直接返回对应索引
  5. 如果要查找的值在mid的左半边，那么min值不变，max=mid-1继续下次循环查找
  6. 如果要查找的值在mid的右半边，那么max值不变，min=mid+1继续下次循环查找
  7. 当min>max时，表示要查找的元素在数组中不存在，返回-1
public class BinarySearch {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        int num = 4;
        int index = binarySearchForIndex(arr,num);
        System.out.println(index); //输出结果为3
    }

    private static int binarySearchForIndex(int[] arr, int num) {
        //定义查找的范围
        int min = 0;
        int max = arr.length-1;
        //循环查找
        while (min <= max){
            //计算出中间位置mid
            int mid = (max + min) >> 1; //右移1位，相当于除以2
            //判断mid所指的值与num的值的大小
            if(arr[mid]>num){
                //若mid位置的数大于要查的数，表明目标数在左边
                max = mid - 1;
            }else if(arr[mid]<num){
                //若mid位置的数小于要查的数，表明目标数在右边
                min = mid + 1;
            }else if(arr[mid]==num){
                return mid;
            }
        }
        //如果min>max,表明要查找的值不存在返回-1
        return -1;
    }
}
冒泡排序

​ 相邻的数据两两比较，小的放前面，大的放后面。

例如将数列：3 5 2 1 4按照从小到大的顺序排列，步骤如下：

  1. 相邻的元素两两比较，大的放右边，小的放左边，找到最大值；
  2. 第一次循环结束，最大值已经找到，在数组的最右边；
  3. 下一次只要在剩余的元素找最大值就可以了；
  4. 因为已经确定了5是最大值，所以4跟5无须再进行比较了；
  5. 因为已经确定了5是最大值，4是次大值。所以3无须跟4和5进行比较了；
  6. 同理3,4,5的位置已经确定了，2也无须与这三个值进行比较了；
  7. 最后只剩下一个值1了，肯定就放在最后一个格子中。
  • 如果有n个数据进行排序，总共需要比较n-1次
  • 每一次比较完毕，下一次的比较会少一个数据参与
public class MyBubbleSort {
    public static void main(String[] args) {
        int[] arr = {3,5,2,1,4};
        bubbleSort(arr);
    }

    private static void bubbleSort(int[] arr) {
        //外层循环控制的是次数，比数组的长度少一次
        for (int i = 0; i < arr.length-1; i++) {
            //内循环就是实际循环比较
            //-1是为了让数组不要越界
            //-i每一轮结束后我们就会少比一个数字
            for(int j = 0;j < arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        printArr(arr);
    }

    private static void printArr(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }
}
运行结果:1 2 3 4 5
递归

  • 以编程的角度来看，递归指的是方法定义中调用方法本身的现象。

  • 递归解决问题的思路：

    ​ 把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可以描述出解题过程所需要的多次重复计算。

  • 递归解决问题要找到两个内容：

    • 递归出口：否则会出现内存溢出
    • 递归规则：与原问题相似的规模较小的问题
案例：递归求阶乘

需求：用递归求5的阶乘，并把结果在控制台输出

public class Recursion {
    public static void main(String[] args) {
        int result = getJc(5);
        System.out.println(result);
    }

    private static int getJc(int i) {
        //当i=1时递归结束
        if(i==1){
            return 1;
        }else{
            //递归规则,方法再一次被调用时，参数值会更接近出口
            return i*getJc(i-1);
        }
    }
}
运行结果:120

递归执行步骤分析
在这里插入图片描述

快速排序
  • 冒泡排序算法中，一次循环结束，就相当于确定了当前的最大值，也能确定最大值在数组中应存入的位置。
  • 快速排序算法中，每一次递归时以第一个数为基准数，找到数组中所有比基准数小的，再找到所有比基准数大的。小的全部放左边，大的全部放右边，确定基准数的正确位置。

快速排序步骤：

  1. 从右开始找比基准数小的
  2. 从左开始找比基准数大的
  3. 交换两个值的位置
  4. 右边的继续往左找，左边的继续往右找，直到两边指向同一个索引为止
  5. 基准数归位

示例：

public class MyQuikSort {
    public static void main(String[] args) {
        int[] arr = {6,1,2,7,9,3,4,10,8,5};
        quikSort(arr,0,arr.length-1); //参数为数组以及数组两端的索引
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }

    private static void quikSort(int[] arr, int left, int right) {
        if(right<=left){
            return;
        }
        int l = left;
        int r = right;
        //计算出基准数
        int baseNumber = arr[l];
        while(left!=right){
            //从右边开始找比基准数小的
            while (arr[right]>= baseNumber && right > left){
                right--;
            }
            //从左边开始找比基准数大的
            while (arr[left] <= baseNumber && right > left){
                left++;
            }
            //交换两个值的位置
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
        }
        //基准数归位
        int temp = arr[left];
        arr[left] = arr[l];
        arr[l] = temp;

        quikSort(arr,l,left-1);
        quikSort(arr,left+1,r);
    }
}
运行结果：1 2 3 4 5 6 7 8 9 10
Arrays
  • public static String toString(int[] a) 返回指定数组的内容的的字符串表示形式
  • public static void sort (int[] a) 按照数字顺序排列指定的数组
  • public static int binarySearch(int[] a,int key) 利用二分查找返回指定元素的索引

示例：

import java.util.Arrays;

public class ArraysTest {
    public static void main(String[] args) {
        int[] arr = {2,4,5,1,6,7,3,8};
        //返回指定数组的内容的的字符串表示形式
        String s = Arrays.toString(arr);
        System.out.println(s);

        //按照数字顺序排列指定的数组
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));

        //利用二分查找返回指定元素的索引
        int index = Arrays.binarySearch(arr,5);
        System.out.println(index);
        int index1 = Arrays.binarySearch(arr,10);
        System.out.println(index1);
        //数组必须有序
        //如果要查找的元素存在，那么返回的是这个元素的实际索引
        //如果要查找的元素不存在，那么返回的是(-插入点-1)
            //插入点:如果这个元素在数组中，他应该在哪个索引上，
            // 例如：10在数组中应该在8的后面，即索引8上，则查找10返回的结果为-8-1=-9
    }
}

运行结果：
在这里插入图片描述

练习1

请编程进行以下运算：计算3的5次幂；计算3.3向上取整的结果；计算3.9向下取整的结果；计算6.7四舍五入取整的结果

/*
     请计算3的5次幂
    请计算3.3向上取整的结果
    请计算3.9向下取整的结果
    请计算6.7四舍五入取整的结果
 */
public class Lian1 {
    public static void main(String[] args) {
        //3的5次幂
        double a = Math.pow(3,5);
        System.out.println("3^5="+a);
        //3.2向上取整
        double b = Math.ceil(3.3);
        System.out.println("3.2向下取整为："+b);
        //3.8向下取整
        double c = Math.floor(3.9);
        System.out.println("3.8向下取整为："+c);
        //5.6四舍五入
        int d = Math.round(6.7f);
        System.out.println("6.7四舍五入为："+d);
    }
}

运行结果：
在这里插入图片描述

练习2

定义一个集合，并将1至1千万这1千万个数字添加到集合中，计算这个行为运行的时间；

import java.util.ArrayList;

public class Lian2 {
    public static void main(String[] args) {
        //创建一个集合
        ArrayList list = new ArrayList();
        //记录当前开始时间
        Long start = System.currentTimeMillis();
        //循环向集合中添加1千万个数字
        for (int i = 1; i <= 10000000; i++) {
            list.add(i);
        }
        //记录添加结束时间
        Long end = System.currentTimeMillis();
        //求开始和结束时间差，即可的添加用时
        Long time = end - start;
        System.out.println("向集合中添加一千万个数字用的时间是："+time+"毫秒");
    }
}

运行结果：
在这里插入图片描述

练习3

求以下double数组的平均值(四舍五入保留两位小数)：double[] arr = {0.1,0.2,2.1,3.2,5.56,7.21};

import java.math.BigDecimal;

public class Lian3 {
    public static void main(String[] args) {
        double[] arr = {0.1,0.2,2.1,3.2,5.56,7.21};
        //若要进行精确运算，要使用字符串构造
        BigDecimal sum = new BigDecimal("0");
        for (int i = 0; i < arr.length; i++) {
            //将数组中的数转化成字符串，然后在循环求和
            BigDecimal bd1 = new BigDecimal(arr[i]+"");
            sum = sum.add(bd1);
        }
        //System.out.println(sum);
        BigDecimal l = new BigDecimal(arr.length+"");
        //四舍五入保留两位小数
        BigDecimal divide = sum.divide(l,2,BigDecimal.ROUND_HALF_UP);
        System.out.println("数组的平均值是："+divide);
    }
}

运行结果：
在这里插入图片描述

练习4

在一行中通过键盘输入自己的年龄和身高(要带小数)，年龄和身高中间使用逗号分隔，请利用今天的技术和字符串的切分方法，将键盘输入的数据转成整数和小数；

import java.util.Scanner;

public class Lian4 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入年龄和身高：(年龄是整数，身高是小数，中间使用逗号分隔)");
        String ah = sc.next();
        String[] arr = ah.split(",");
        int age = Integer.parseInt(arr[0]);
        double height = Double.parseDouble(arr[1]);
        System.out.println("转成整数后的年龄是："+age);
        System.out.println("转成小数后的身高是："+height);
    }
}

运行结果：
在这里插入图片描述

练习5

已知数组如下：

int[] arr = {429,55,25,25,27,41,2,5,66,3,64,6,45,8,51};1.使用Arrays对数组元素进行排序并打印排序后的结果；2.使用二分法查找元素2，并打印查询结果；3.使用二分法查找200，并打印查找结果；

import java.util.Arrays;

public class Lian5 {
    public static void main(String[] args) {
        int[] arr = {429,55,25,25,27,41,2,5,66,3,64,6,45,8,51};
        Arrays.sort(arr);
        String s = Arrays.toString(arr);
        System.out.println(s);
        int index1 = Arrays.binarySearch(arr,2);
        System.out.println("元素2在数组中的索引是："+index1);
        int index2 = Arrays.binarySearch(arr,200);
        System.out.println("元素200在数组中的索引是："+index2);
    }
}

运行结果：
在这里插入图片描述

练习6

使用递归计算从1到100之间的所有数之和。

public class Lian6 {
    public static void main(String[] args) {
        int i = 1;
        int sum = sum(i);
        System.out.println(sum); //5050
    }
    public static int sum(int i){
        //i=100时递归结束
        if(i==100){
            return 100;
        }else{
            return i+sum(i+1);
        }
    }
}

猫薄荷>3<
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java数据结构与算法-笔记-代码-课件-资料
05-17
稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、选择排序、...
请定义一个集合,并将1至1千万这1千万个数字添加到集合中，计算这个行为运行的时间，并打印。
weixin_46597615的博客
04-01 94
请定义一个集合,并将1至1千万这1千万个数字添加到集合中，计算这个行为运行的时间，并打印。
编程题【System类】计算一千万个数添加到集合的时间
qq_42553504的博客
04-08 523
import java.util.ArrayList; /** * ## 编程题【System类】 * <p> * 请定义一个集合,并将1至1千万这1千万个数字添加到集合中 * ，计算这个行为运行的时间，并打印。 */ public class Demo1 { public static void main(String[] args) { //起始时间 long start = System.currentTimeMillis(); .
笔记06 - API(Math System BigDecimal)
qq_45181415的博客
12-19 463
day05-课后作业 编程题【Math类】 请编程进行以下运算： 请计算3的5次幂 请计算3.2向上取整的结果 请计算3.8向下取整的结果 请计算5.6四舍五入取整的结果 参考答案: public static void main(String[] args) { System.out.println(Math.pow(3, 5)); System.out.println(Math.ceil(3.2)); System.out.println(Math.flo
定义一个大数组的方法
ekildog的博客
05-07 3943
定义一个大数组的方法： 在网易笔试题中需要定义一个int型的1000000*1000000数组，这个数组已经超过了栈的大小，无法在栈中直接定义 问题描述： 在网易笔试题中需要定义一个int型的1000000*1000000数组 int a[1000000][1000000]; //会报错数组太大 解决方案： 利用malloc定义二维数组 int **p = (int**)malloc(sizeof(int) * 1000000); for (int i = 0; i < 1000000
java数组的api_java程序员常用的11个API，赶紧收藏
weixin_30162121的博客
02-21 758
一、Scanner 类一个可以解析基本类型和字符串的简单文本扫描器。package cn.wxuns;import java.util.Scanner;public class MyScanner {public static void main( String[] args){Scanner myScanner = new Scanner(System.in);System.out.printl...
行业分类-设备装置-一种基于递归自主式复杂任务分解系统及方法.zip
09-03
行业分类-设备装置-一种基于递归自主式复杂任务分解系统及方法.zip
行业分类-设备装置-对角递归神经网络控制器在多平台中的实现方法.zip
08-24
行业分类-设备装置-对角递归神经网络控制器在多平台中的实现方法.zip
java代码-使用Java递归求和1+2+3+...+n的源代码
04-09
java代码-使用Java递归求和1+2+3+...+n的源代码 ——学习参考资料：仅用于个人学习使用！
java-c语法7---method-递归---马克-to-win java视频
05-17
java语法 method 递归 马克-to-win java视频 方法 重载
吃一堑长一智！象棋游戏java编程
m0_57624732的博客
07-13 99
字节跳动 面试前 头条的面试是三家里最专业的，每次面试前有专门的HR和你约时间，确定OK后再进行面试。每次都是通过视频面试，因为都是之前都是电话面或现场面，所以视频面试还是有点不自然。也有人觉得视频面试体验很赞，当然萝卜青菜各有所爱。最坑的二面的时候对方面试官的网络老是掉线，最后很冤枉的挂了（当然有一些点答得不好也是原因之一）。所以还是有点遗憾的。 一面 先自我介绍下 聊项目，逆向系统是什么意思 聊项目，逆向系统用了哪些技术 线程池的线程数怎么确定？ 如果是IO操作为主怎么确定？ 如果计算型操作又怎么确
Arrays中的二分查找（折半查找）
2的32次方
04-01 2665
在java.util.Arrays类中提供了对有序（升序排列）数组的二分查找的方法。由于算法的思路都是一致，所以就以int[]数组的binarySearch方法做分析的例子。binarySearch底层是调用binarySearch0方法，以下是Arrays中的代码/** *a是一个升序排列的数组， *fromIndex是二分查找的a的起始索引 *toIndex是二分查找的a的终止索引 *k
JavaSE基础总结（笔试面试题）
热门推荐
zjf1665119803的博客
11-02 4万+
目录 JavaSE基础 1.对象实例化 2.类的重载： 3.不定长参数，本质是一个数组形式，int...a 4.方法中使用全局变量 this 5.形参列表中的变量是局部变量 6.构造方法的作用： 7.父类和子类中，静态代码块、代码块、构造方法、普通方法执行顺序 8.修饰符修饰范围 9.子类只能继承父类非private的方法 10.instanceof 11.抽象方法不可以被...
java打印语句输出年龄_Java1编写一个程序用于接收从键盘上输入学生的信息（姓名、性别、年龄、身高、体重和总分），接收结束后把学生的信息输出到屏幕上...
weixin_35794520的博客
12-30 2706
package student;import java.util.Scanner;public class Student { public static void main(String[] args) { // TODO 自动生成的方法存根 Students s = new Students(); //创建对象——创建一个Student类型的 s 并为其分配内存 Scanner in = ne...
Java类ArrayList常用API详解
WanAkiko.
07-21 903
ArrayList - 测试类 package JavaCommonUtilityClasses; import JavaCommonUtilityClasses.domain.Singer; import java.util.ArrayList; import java.util.List; /** * ArrayList类常用方法 * <p> * 快捷键生成变量接收值的三种方式：alt + enter 或者 ctrl + alt + v 或者 代码.var + enter *
java二分查找api_JAVA 二分算法只能对数字进行查找吗
weixin_39545895的博客
02-25 629
展开全部2分法查找，前提是要有序，要排序，必然要比较大小，所以只要一32313133353236313431303231363533e59b9ee7ad9431333330336335个类它实现了Comparable接口的compareTo(To)方法(Comparable在java.lang包中)或是实现一个比较器对象接口Comparator(Comparator在java.util包)，都可...
java list二分查找,java中的ArrayList和LinkedList的二分查找速度比
weixin_33916124的博客
03-19 176
package tian;import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.LinkedList; import java.util.List; import java.util.Random; /** * * ArrayList和Linked...
SQL笔记
在每个领域闪耀
02-27 2120
SQL SQL(Structured Query Language)：结构化查询语言。其实就是定义了操作所有关系数据库的一种规则。 通用语法规则 SQL语句可以单行或多行书写，以分号结尾； 可使用空格和缩进来增强语句的可读性； MySQL数据库的SQL语句不区分大小写，关键字建议使用大写； 单行注释：–注释内容 #注释内容（MySQL特有）； 多行注释：/* 注释内容 */ SQL分类 DDL：数据定义语言，用来操作数据库、表、列等； DML：数据操作语言，用来对数据库中表的数据进行增删改
java学习笔记day07-面向对象基础-构造方法
在每个领域闪耀
12-05 994
Day07 面向对象基础 面向对象和面向过程的思想对比 面向过程编程是一种以过程为中心的编程思想，实现功能的每一步，都是自己实现的； 面向对象是一种以对象为中心的编程思想，通过指挥对象实现具体的功能 面向对象思想小结： 客观存在的任何一种事务，都可以看作为程序中的对象 使用面向对象思想可以将复杂的问题简单化 将我们从执行者的位置，变成了指挥者 类和对象 类是对现实生活中一类具有共同属性和行为的事物的抽象 属性：该事物的各种特征 行为：该事物存在的功能（能够做的事情） 类和对象的
python 冒泡排序 交换次数_Python实现交换排序--冒泡排序和快速排序
最新发布
06-07
好的，以下是Python实现冒泡排序并计算交换次数的代码： ```python def bubbleSort(arr): n = len(arr) swap_count = 0 for i in range(n): # 每一轮将最大的数交换到末尾 for j in range(n-i-1): if arr[j] ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值