笔试强训day1~day5|选择&编程题模糊/易错知识点汇总

已于 2022-11-28 10:46:03 修改
阅读量364 收藏 3
点赞数 2
分类专栏： 笔试强训 文章标签： jvm java 算法
于 2022-11-28 09:43:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/moteandsunlight/article/details/128074115
版权

文章目录

选择题

方法通常存储在进程中的哪一区（C）

A. 堆区 B. 栈区 C. 全局区 D. 方法区

相关知识：JVM内存模型

img

jvm内存模型

Math.round(11.5) 等于多少 (). Math.round(-11.5) 等于多少 ( C).

A. 11 ,-11 B 11 ,-12 C 12 ,-11 D 12 ,-12

相关知识：Math库round、floor、ceil以及取整运算

1.round：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oTxGisRQ-1669599460435)(F:\typora插图\image-20221127154325134.png)]

round 表示"四舍五入"，算法为Math.floor(x+0.5) ，即将原来的数字加上 0.5 后再向下取整，所以 Math.round(11.5) 的结果为 12，Math.round(-11.5) 的结果为 -11,Math.round(-11.2)的结果为-12.0.

2.floor：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pKhNcKuI-1669599460436)(F:\typora插图\image-20221127154538923.png)]

floor() 方法可对一个数进行下舍入，返回给定参数最大的整数，该整数小于或等给定的参数。

3.ceil：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JEOPLBF3-1669599460437)(F:\typora插图\image-20221127154720677.png)]

ceil() 方法可对一个数进行上舍入，返回值大于或等于给定的参数，类型为双精度浮点型

4.取整操作

直接舍去小数

====================================================

区别：

取整操作，无论操作数是正数还是负数，直接舍去小数

向上取整，即ceil方法，操作数是整数时是本身，否则是大于此数的最小整数，无论正负

向下取整：即floor方法，操作数为整数的时候是本身，否则就是不大于此数的最大整数，无论正负。

=====================================================

取整时，操作数为正数时，相当于向下取整，操作数为负数时，相当于向上取整。

round，当小数部分小于0.5，相当于向下取整，小数部分大于等于0.5，相当于向上取整

下列哪一种叙述是正确的（D）

A abstract修饰符可修饰字段、方法和类

B 抽象方法的body部分必须用一对大括号{ }包住

C 声明抽象方法，大括号可有可无

D 声明抽象方法不可写出大括号

相关知识：abstract关键字的使用|抽象类、抽象方法的定义

1.abstract关键字使用

是抽象修饰符。只能修饰类和方法，不能用来修饰属性/字段。

修饰类，表示当前类为抽象类；修饰方法，表示当前方法为抽象方法。

2.抽象类

抽象类不能实例化，但可以接收子类对象。它生来就是为了被继承。子类继承此类，重写父类抽象方法、写abstract关键字二选一。

访问权限：抽象类不能被private修饰，其他访问权限修饰限定符可以用，但是注意配套子类的访问权限修饰限定符。另外我们不写权限修饰符，默认是public，也就是说抽象类的访问权限最小就是protectd了。

抽象类中可以没有抽象方法

抽象类中也可以有非抽象方法，普通方法、构造方法，供子类在创建对象时，初始化父类的属性。

关于静态方法：抽象类中可以有静态方法，但是不能有静态抽象方法

3.抽象方法

抽象类中被abstract方法修饰的方法叫做抽象方法。

抽象方法不可以被final和static修饰，因为抽象方法需要被重写。

抽象类中的抽象方法只有声明，不能实现。

下面选项中,哪些是interface中合法方法定义?(ACD)

A public void main(String [] args);

B private int getSum();

C boolean setFlag(Boolean [] test);

D public float get(int x);

选项中哪一行代码可以替换 //add code here 而不产生编译错误（A）

public abstract class MyClass {
    public int constInt = 5;
    //add code here
    public void method() {
    }
}

A public abstract void method(int a);

B consInt=constInt+5;

C public int method();

D public abstract void anotherMethod(){}

相关知识：接口的定义|接口中方法的限制

1.接口的定义

与类定义相似，只是关键字从class变成了interface。

不能直接实例化，使用方法是类实现这个接口，使用implements关键字实现。

默认修饰限定符是public abstract，接口不能被private、private、final、static修饰。

接口中不能含有非抽象方法。但是从jdk1.8之后，接口中允许有静态具体方法和权限为default的具体方法。jdk1.9开始，允许将方法定义为private，使得某些复用的代码不会把方法暴露出去。

实现此接口的类必须重写接口中（抽象）方法。
JAVA所有的除定义或声明语句之外的任何语句都必须在方法内部，不存在游离在方法外的非声明/定义语句。

2.接口中方法的限制

默认都是public abstract。写成abstract/public abstrct/public都等价于public abstrct。

1.8开始允许有静态方法和默认方法这两种具体实现的方法；1.9开始允许有私有方法声明。

在创建派生类对象，构造函数的执行顺序（A ）

A 基类构造函数，派生类对象成员构造函数，派生类本身的构造函数

B 派生类本身的构造函数，基类构造函数，对象成员构造函数

C 基类构造函数，派生类本身的构造函数，派生类对象成员构造函数

D 对象成员构造函数，基类构造函数，派生类本身的构造函数

名词区分：与C/C++知识点有重合，略…

下面属于软件定义阶段任务的是（A）

A 需求分析

B 软件测试

C 详细设计

D 系统维护

这里是属于、是属于、是属于！！！！不是不属于😭

相关知识点：软件测试基础

软件生命周期分为 3 个阶段：

软件定义阶段，任务是确定软件开发工作必须完成的目标，确定工程的可行性；

软件开发阶段，任务是具体完成设计和实现定义阶 段所定义的软件，通常包括总体设计、详细设计、编码和测试；

软件维护阶段，任务是使软件在运行中持久地满足用户的需要。

以下代码结果是什么？（C）

public class foo {
    public static void main(String sgf[]) {
        StringBuffer a=new StringBuffer("A");
        StringBuffer b=new StringBuffer("B");
        operate(a,b);
        System.out.println(a+"."+b);
    }
    static void operate(StringBuffer x,StringBuffer y) {
        x.append(y);
        y=x;
    }
}

A 代码可以编译运行，输出“AB.AB”。

B 代码可以编译运行，输出“A.A”。

C 代码可以编译运行，输出“AB.B”。

D 代码可以编译运行，输出“A.B”。

相关知识：值传递、引用传递

值传递：是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。

引用传递：是指在调用函数时将实际参数的地址直接传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。

java中没有指针的概念，因此没有引用传递的概念。

这道题中a、b（是引用的副本，Java中没有引用传递）传入operate()函数中，但最后a指向的对象的值发生了变化，而b指向的对象的值没有发生变化，这是因 为x.append(y);改变了a指向的对象的值，而y=x;并没有改变b指向对象的值，指向将y指向了x所指向的对象（之前y和b指向同一个对象）。

下列哪个说法是正确的（D）

A .ConcurrentHashMap使用synchronized关键字保证线程安全

B. HashMap实现了Collction接口

C .Array.asList方法返回java.util.ArrayList对象

D. SimpleDateFormat是线程不安全的

相关知识：ArrayList源码|线程安全的类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eRlwRYD9-1669599460438)(F:\typora插图\image-20221127172354582.png)]

以下说法错误的是（D）

A 虚拟机中没有泛型，只有普通类和普通方法

B 所有泛型类的类型参数在编译时都会被擦除

C 创建泛型对象时请指明类型，让编译器尽早的做参数检查

D 泛型的类型擦除机制意味着不能在运行时动态获取List中T的实际类型

相关知识：泛型的擦除机制

编程题

1.组队竞赛

题目链接

解法一：排序，控制取的条件

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        while(in.hasNextInt()){
            int n=in.nextInt();
            int[] arr=new int[3*n];
            for(int i=0;i<3*n;i++){
                arr[i]=in.nextInt();
            }
            Arrays.sort(arr);
            long ret=0;
            for(int i=n;i<3*n;i+=2){
                ret+=arr[i];
            }
            System.out.println(ret);
        }
    }
}

解法二：优先级队列

本质上还是排序，跳着取数据

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        while(in.hasNextInt()){
            PriorityQueue<Integer> q=new PriorityQueue<>(new Comparator<Integer>(){
                public int compare(Integer o1,Integer o2){
                    return o2.compareTo(o1);
                }
            });
            int n=in.nextInt();
            for(int i=0;i<3*n;i++){
                int tmp=in.nextInt();
                q.offer(tmp);
            }
            long ret=0;
            for(int i=0;i<n;i++){
                q.poll();
                ret+=q.poll();
            }
            System.out.println(ret);
        }
    }
}

2.删除字符串公共字符【方法一&方法二重点理解掌握】

题目链接

方法一：哈希set取差集，set里边放置的是“被减数”，然后用stringbuilder

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        while(in.hasNextLine()){
            String s1=in.nextLine();
            String s2=in.nextLine();
            Set<Character> set=new HashSet<>();
            for(int i=0;i<s2.length();i++){
                set.add(s2.charAt(i));
            }
            StringBuilder str=new StringBuilder();
            for(int i=0;i<s1.length();i++){
                char ch=s1.charAt(i);
                if(set.contains(ch)){
                    continue;
                }
                str.append(ch);
            }
            System.out.println(str.toString());
        }
    }
}

方法二：哈希数组映射

加加==》加入所有的，减减==》去除s2出现的，遍历如果不为0（没有被删除），就打印输出

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        while(in.hasNextLine()){
            String s1=in.nextLine();
            String s2=in.nextLine();
            int[] hash=new int[256];
            for(char ch:s1.toCharArray()){
                hash[ch]++;
            }
            for(char ch:s2.toCharArray()){
                hash[ch]=0;
            }
            for(char ch:s1.toCharArray()){
                if(hash[ch]!=0){
                    System.out.print(ch);
                }
            }
            System.out.println();
        }
    }
}

方法三：其他容器的利用

public class Main {
    /**
     * 双list解法
     * @param args
     */
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextLine()) {// 注意，如果输入是多个测试用例，请通过while循环处理多个测试用例
            String a=in.nextLine();
            String b=in.nextLine();
            List<Character> list=new ArrayList<>();
            List<Character> list2=new ArrayList<>();
            char[] str=a.toCharArray();
            char[] str2=b.toCharArray();
            for(int i=0;i<str.length;i++){
                list.add(str[i]);
            }
            for(int i=0;i<str2.length;i++){
                list2.add(str2[i]);
            }
            list.removeAll(list2);
            StringBuilder sb=new StringBuilder();
            for(int i=0;i<list.size();i++){
                sb.append(list.get(i));
            }
            System.out.println(sb);
        }
    }
}

3.排序子序列

题目链接

方法一：遍历分三种情况处理

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        while(in.hasNextInt()){
            int n=in.nextInt();
            int[] array=new int[n+1];
            for(int i=0;i<n;i++){
                array[i]=in.nextInt();
            }
            int ret=0;
            int j=0;
            while(j<n){
                if(array[j]<array[j+1]){
                    while(j<n&&array[j]<array[j+1]){
                        j++;
                    }
                    ret++;
                }else if(array[j]>array[j+1]){
                    while(j<n&&array[j]>array[j+1]){
                        j++;
                    }
                    ret++;
                }else{
                     ;   
                }
                j++;
            }
            System.out.println(ret);
        }        
    }
}

方法二：滑动窗口

4.倒置字符串【重点理解掌握第二种】

题目链接

方法一：split+倒序拼接+toString

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        while(in.hasNextLine()){
            String str=in.nextLine();
            String[] s=str.split(" ");
            StringBuilder ret=new StringBuilder();
            for(int i=s.length-1;i>=0;i--){
                ret.append(s[i]);
                if(i>0){
                    ret.append(" ");
                }
            }
            System.out.println(ret.toString());
        }
    }
}

方法二：

整体翻转+每个单词反转===》双指针+指定区间反转

import java.util.*;
public class Main{
    private static void reverse(char[] s,int left,int right){
        while(left<right){
            char tmp=s[left];
            s[left]=s[right];
            s[right]=tmp;
            left++;
            right--;
        }
    }
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        while(in.hasNextLine()){
            String str=in.nextLine();
            char[] s=str.toCharArray();
            reverse(s,0,s.length-1);
            int i=0;
            while(i<s.length){
                int j=i;
                while(j<s.length&&s[j]!=' '){
                    j++;
                }
                if(j<s.length){
                    reverse(s,i,j-1);
                    i=j+1;
                }else{
                    reverse(s,i,j-1);
                    i=j;
                }
            }
            str=new String(s);//利用String的构造方法将字符数组转成字符串
            System.out.println(str);
        }
    }
}

5.字符串中找出连续最长的数字串

题目链接

方法一：借助中间变量cur

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        while(in.hasNextLine()){
            String s=in.nextLine();
            String cur="";
            String ret="";
            int i=0;
            for(;i<s.length();i++){
                char ch=s.charAt(i);
                if(ch>='0'&&ch<='9'){
                    cur+=ch+"";//只能拼接字符串，不能拼接字符
                }else{
                    if(cur.length()>ret.length()){
                        ret=cur;
                    }else{
                        cur="";
                    }
                }
            }
            if(i==s.length()&&cur.length()>ret.length()){
                ret=cur;
            }
            System.out.println(ret);
        }
    }
}

方法二：借助计数器

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        while(in.hasNextLine()){
            String str=in.nextLine();
            String ret=func(str);
            System.out.println(ret);
        }
    }
    public static String func(String str){
        int count=0;
        int max=0;
        int right=0;
        for(int left=0;left<str.length();left++){
            if(str.charAt(left)>='0'&&str.charAt(left)<='9'){
                count++;
                if(max<count){
                    max=count;
                    right=left;
                }
            }else{
                count=0;
            }
        }
        return str.substring(right-max+1,right+1);//选定位置截取为子串，不需要加入到集合中，跟滑动窗口有点像
    }
}

6.数组中出现超过一半的数字

题目链接

假设一定存在这样的数字

如果不一定存在【需要拿到之后再遍历，看count是不是大于数组长度的一半】

方法一：排序取中法

import java.util.*;
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
*
* @param numbers int整型一维数组
* @return int整型
*/
    public int MoreThanHalfNum_Solution (int[] numbers) {
        // write code here
        Arrays.sort(numbers);
        return numbers[numbers.length/2];
    }
}

方法二：打擂台法找众数

count就是血条

import java.util.*;
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
*
* @param numbers int整型一维数组
* @return int整型
*/
    public int MoreThanHalfNum_Solution(int[] array) {
            int ret = array[0];
            int count = 1;

            for (int i = 1; i < array.length; i++) {
                if (count == 0) {
                    ret = array[i];
                    count++;
                } else{
                    if(ret==array[i]){
                        count++;
                    }else{
                        count--;
                    }
                }
            }
            return ret;
        }
    }
}

7.进制转换

题目链接

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 进制转换
     * @param M int整型 给定整数
     * @param N int整型 转换到的进制
     * @return string字符串
     */
    public String solve (int m, int n) {
        // write code here
        StringBuilder s=new StringBuilder();
        String table="0123456789ABCDEF";
        boolean tag=false;
        if(m<0){
            m=-m;
            tag=true;
        }
        while(m!=0){
            s.append(table.charAt(m%n));
            m=m/n;
        }
        if(tag){
            s.append("-");
        }
        s.reverse();
        return s.toString();
    }
}

8.统计回文

题目链接

20/25

import java.util.*;
    public class Main{
        public static void main(String[] args){
            Scanner in=new Scanner(System.in);
            while(in.hasNextLine()){
                String a=in.nextLine();
                String b=in.nextLine();
                int index=0;
                int ret=0;
                while(index<a.length()){
                String tmp = a.substring(0,index)+b+a.substring(index);
                if(func(tmp)){
                	ret++;
                }
                	index++;
                }
                System.out.println(ret);
        }
    }
    private static boolean func(String a){
        char[] s=a.toCharArray();
        if(s.length<=1){
        	return true;
        }
        int left=0;
        int right=s.length-1;
        while(left<right){
            if(s[left]!=s[right]){
            	return false;
            }
            left++;
            right--;
        }
        return true;
    }
}

AC代码

import java.util.*;
    public class Main{
        public static void main(String[] args){
            Scanner in=new Scanner(System.in);
            while(in.hasNextLine()){
                String a=in.nextLine();
                String b=in.nextLine();
                int ret=0;
                for(int i=0;i<=a.length();i++){
                    StringBuilder tmp=new StringBuilder(a);
                    tmp.insert(i,b);
                    if(func(tmp.toString())){
                        ret++;
                    }
                }
                System.out.println(ret);
        }
    }
    private static boolean func(String a){
        char[] s=a.toCharArray();
        if(s.length<=1){
        	return true;
        }
        int left=0;
        int right=s.length-1;
        while(left<right){
            if(s[left]!=s[right]){
            	return false;
            }
            left++;
            right--;
        }
        return true;
    }
}

9.连续最大和

22.5/25

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        while(in.hasNextInt()){
            int n=in.nextInt();
            int[] nums=new int[n];
            int sum=0;
            for(int i=0;i<n;i++){
                nums[i]=in.nextInt();
                sum+=nums[i];
            }
            int ret=subArrayMaxSum(nums,sum);
            System.out.println(ret);
        }
    }
    private static int subArrayMaxSum(int[] nums,int sum){
        for(int i=0;i<nums.length;i++){
            int subSum=0;
            int j=i;
            for(;j<nums.length;j++){
                subSum+=nums[j];
                sum=Math.max(sum,subSum);
            }
        }
        return sum;
    }
}

AC代码

题目链接

import java.util.*;
public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param array int整型一维数组 
     * @return int整型
     */
    public int FindGreatestSumOfSubArray (int[] nums) {
        // write code here
        int ret=nums[0];
        int sum=nums[0];
        for(int i=1;i<nums.length;i++){
            if(sum<0){
                sum=nums[i];
            }else{
                sum+=nums[i];
            }
            ret=Math.max(ret,sum);
        }
        return ret;
    }
}
安苒_
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
笔试题错题总结1
reaaal的博客
07-31 137
文章目录块级元素和行内元素相关HTML5新增表单类型 <.input type="" />from元素的属性css属性继承有继承性的属性所有元素可以继承的属性内联元素可以继承的属性块级元素可以继承的属性 块级元素和行内元素相关 块级元素不能放在p标签里面 有几个特殊的块级元素只能包含内联元素，不能包含块级元素。如h1，h2，h3，h4，h5，h6，p，dt li内可以包含div a标签可以包含任何元素，除了自身 HTML5新增表单类型 <.input type="" /> em
笔试强训——Day2
weixin_63056061的博客
10-20 141
A 在子类构造方法中使用super（）显示调用父类的构造方法，super（）必须写在子类构造方法的第一行，否则编译不通过。D this（）和super（）可以在static环境中使用，包括static方法和static语句块。第二行包括n个整数A_i(1 ≤ A_i ≤ 10^9),表示数组A的每个数字。C this（）和super（）可以同时出现在一个构造函数中。C 第1、2、3行能通过编译，但第2、3行运行时出错。B 第1、2行能通过编译，但第3行编译出错。D 第1行，第2行和第3行的声明都是正确的。
C语言易错点整理
hanwangyyds的博客
08-25 4666
本文涵盖了博主在平常写C语言题目时经常犯的一些错误，在这里帮大家整理出来，一些易错点会帮大家标识出来，希望大家看完这篇文章后有所得，引以为戒~
笔试练习day01
weixin_73567058的博客
10-01 240
一、选择题 　 1、格式化输出 　 2、逻辑判断--短路原则 　 3、赋值语句 　 4、左移、异或 二、编程题 　 1、组队竞赛 　 2、删除公共字符https://www.nowcoder.com/questionTerminal/248ccf8b479c49a98790db17251e39bb。易错点：条件判断位置出现赋值语句时，不要错想成等式判断；赋值语句的值为等号右边的值。知识点：格式化输出，%m.ns。，组队竞赛，
笔试强训day2选择题
05-10
"Java笔试强训Day2选择题知识点总结" 本节笔试强训Day2选择题主要涵盖了Java语言的基础知识点，包括继承、方法调用、变量声明、静态方法、抽象类和构造方法等。下面是对每个知识点的详细解释： 1. Java继承机制 ...
笔试强训选择题错误总结
08-25
笔试强训选择题错误总结
baidu.rar_C 笔试 答案_C++笔试编程题_c 笔试题_百度笔试_笔试题
09-21
《百度笔试题解析——C/C++编程篇》 在编程领域，尤其是对于互联网巨头百度这样的公司，技术面试和笔试是筛选优秀人才的重要环节。这份“baidu.rar”压缩包文件包含了百度公司过去笔试中出现的一些C、C++编程题目及...
校招C&C++笔试题大全
01-08
这些公司的笔试题通常设计巧妙，涵盖的知识点广泛，既包括基础语法，也涉及数据结构、算法、操作系统、网络等多个领域。通过刷这些题目，学生们可以提前了解并适应实际考试的难度和形式，提高答题速度和准确性。尤其...
华为专业能力笔试面试高频知识点和题库.rar
05-18
本资源“华为专业能力笔试面试高频知识点和题库.rar”包含了华为近几年的热门笔试和面试题目，旨在帮助应聘者熟悉并掌握相关知识点，提高通过率。 一、编程题与解答 “华为研发工程师编程题及答案.pdf”涵盖了华为...
JAVA之JVM入门
一个老Java开发的自白
08-27 839
Java虚拟机（JVM）作为Java平台的核心，自1996年起历经多代发展，如Sun Classic VM、HotSpot VM等，每代都提升了性能与功能。HotSpot VM成为主流，引入JIT编译器和多种垃圾收集器（如CMS、G1、ZGC），优化线程调度与同步。垃圾收集器如CMS、G1、ZGC等，分别通过并发执行、动态调整与低停顿时间等技术，解决了长时间GC停顿、频繁Minor GC、Full GC及内存溢出与碎片等问题，保障了Java应用的性能与稳定性。JVM的持续演进与创新，为Java语言在各类场景
Clickhouse集群化（五）clickhouse语法学习
weixin_40663313的博客
08-26 782
求利用率。
JVM（Java Virtual Machine，Java虚拟机）
2401_83447580的博客
08-27 759
JVM（Java Virtual Machine，Java虚拟机）是Java平台的核心组成部分，它负责运行Java程序。JVM使得Java程序能够“一次编写，到处运行”（Write Once, Run Anywhere），这是Java语言的一个重要特性。JVM通过在不同的操作系统上提供统一的运行时环境来实现这一特性。
Tomcat服务器的JVM设置
fengjing81的专栏
08-25 501
Tomcat服务器的JVM设置需要综合考虑应用的内存需求、服务器的硬件配置以及垃圾回收策略等因素。上述参数只是一些通用建议，具体设置时应根据实际情况进行调整。此外，随着Tomcat和JVM版本的更新，可能会有新的参数和策略出现，建议查阅最新的官方文档以获取最新信息。
linux系统编程：数据库
最新发布
qq_65425321的博客
08-29 877
create table 表名（列名1 数据类型 ，列名2 数据类型， 类名3 数据类型);insert into 表名 values(值1， 值2， 值3);column_value: 查找到的一行数据的每一列值的地址的集合。文件----------------------》硬盘：程序运行结束、掉电数据不丢失。arg：当执行select语句时，使用到，传递给回调函数的第一个参数。column_name：查找到的一行数据的每一列列名的地址的集合。外连接 LEFT OUTER JOIN。
chapter08-面向对象编程——（Object类详解）——day09
hlllllllhhhhh的博客
08-26 459
引用的都是同一个地址，所以返回true。
JVM 方法区存放那些内容
小湘西的博客
08-23 402
类结构信息字段信息方法信息方法的常量池静态变量运行时常量池。
【jvm】虚拟机栈是如何运行的
王佑辉的博客
08-25 454
栈帧是方法执行时的内存模型，包含了方法执行所需的各种信息。1.入栈：当一个方法被调用时，会创建一个新的栈帧，并将其压入当前线程的虚拟机栈顶。1.虚拟机栈是Java程序运行时环境中的一个重要组成部分，它主要负责存储线程执行方法时的局部变量、操作数栈、动态链接、方法出口等信息。4.虚拟机栈的运行原理遵循了栈数据结构的基本特性——后进先出（LIFO），确保了方法调用的正确顺序和方法局部变量的有效管理。2.JVM虚拟机栈是Java程序运行时环境中的一个关键组件，它通过栈帧的入栈和出栈过程来支持方法的调用和执行。
【面试】jvm静态变量和局部变量对比
王佑辉的博客
08-26 443
1.静态变量：随着类的加载而加载到JVM的方法区（静态区），当类被卸载时才会销毁。2.局部变量：存储在JVM的栈内存中，具体为栈帧中的局部变量表部分。1.在Java虚拟机（JVM）中，静态变量（类变量）和局部变量是两种不同类型的变量，它们在多个方面存在显著的区别。2.局部变量：定义在方法体内或方法参数中，属于方法或代码块。2.局部变量：每个线程的栈帧都是独立的，局部变量存储在栈帧的局部变量表中，因此不存在线程安全问题。1.静态变量：存储在JVM的方法区（静态区），这是一个所有线程共享的内存区域。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值