记录笔试遇到的问题

最新推荐文章于 2022-12-11 19:21:37 发布
最新推荐文章于 2022-12-11 19:21:37 发布
阅读量170 收藏
点赞数
分类专栏： Java基础 文章标签： java笔试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gj716/article/details/80850156
版权

1.判断一个数字是否为回文数

package com.gj.test;

/**
 * @author Administrator 判断一个数字是否为回文数 <br>
 *         解题思路：将数字倒序排序后，比较是否相等
 * 
 */
public class HuiWenShuTest {

    public static void main(String[] args) {
        int a = 12331;
        boolean flag = isHuiWenShu(a);
        if (flag) {
            System.out.println("数字a是回文数");
        } else {
            System.out.println("数字a不是回文数");
        }
    }

    public static boolean isHuiWenShu(int num) {
        int result = reverseNum(num);
        if (result == num) {
            return true;
        }
        return false;
    }

    public static int reverseNum(int num) {
        int revNum = 0;
        while (num != 0) {
            // 取余数
            revNum = num % 10 + revNum * 10;
            System.out.println("revNum:" + revNum);
            num /= 10;
            System.out.println("num:" + num);
        }
        return revNum;
    }

}

2.遍历一个路径目录下的所有文件

package com.gj.test;

import java.io.File;
import java.io.IOException;

/**
 * @author Administrator 遍历路径：F:\前端表格控件 目录下的所有文件
 * 
 */
public class FileTest {

    public static void main(String[] args) throws IOException {
        String path = "F:\\前端表格控件";
        findFile(path);
    }

    public static void findFile(String path) throws IOException {
        File fl = new File(path);
        // 判断文件目录是否存在
        if (!fl.exists()) {
            System.out.println("file path is not exit");
            return;
        }
        // 判断文件是否是一个目录
        if (!fl.isDirectory()) {
            if (fl.isFile()) {
                System.out.println(fl.getCanonicalFile());
            }
            return;
        }
        String[] list = fl.list();
        for (String temp : list) {
            File dirFile = new File(path, temp);
            if (!dirFile.isDirectory()) {
                if (dirFile.isFile()) {
                    System.out.println(dirFile.getCanonicalFile());
                }
                continue;
            } else {
                findFile(dirFile.getAbsolutePath());
            }
        }

    }

}

3.获取一年后的今天日期

package com.gj.test;

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
import java.util.Calendar;
import java.util.Date;

/**
 * @author Administrator
 * 
 *         获取一年后的今天日期
 * 
 */
public class DateTest {

    public static void main(String[] args) {
        LocalDate today = LocalDate.now();
        System.out.println("今天的日期：" + today);
        int oneYear = 1;
        LocalDate oneYears = today.plus(oneYear, ChronoUnit.YEARS);
        System.out.println("一年后的今天的日期：" + oneYears);

        Calendar calendar = Calendar.getInstance();
        Date cadate = calendar.getTime();
        System.out.println("cadate=" + cadate);
        Date date = new Date(System.currentTimeMillis());
        System.out.println("当前日期：" + date);
        calendar.setTime(date);
        calendar.add(Calendar.YEAR, 1);
        date = calendar.getTime();
        System.out.println("一年后的今天日期：" + date);

    }

}

4.写出输出结果

package com.gj.vo;

public class Parent {
    public Parent() {
        System.out.println("Parent contructor");
    }

    {
        System.out.println("this is parent");
    }

    static {
        System.out.println("hello,parent static");
    }

    public void print() {
        System.out.println("this is Parent print");
    }
}


package com.gj.vo;

public class Son extends Parent {
    public Son() {
        System.out.println("Son contructor");
    }

    {
        System.out.println("this is son");
    }

    static {
        System.out.println("hello son static");
    }

    public void print() {
        System.out.println("this is son print");
    }
}


package com.gj.test;

import com.gj.vo.Parent;
import com.gj.vo.Son;

/**
 * @author Administrator 子类与父类相关问题
 * 
 */
public class FuZiLeiTest {

    public static void main(String[] args) {
        // 问题1，输出的结果是：先是执行父类的静态static块，子类的静态static块，然后是执行父类的{}语句块和构造方法，最后是执行子类的{}语句块和构造方法
        Parent p = new Son();
        // 输出结果：
        /**
         * hello,parent static <br>
         * hello son static<br>
         * this is parent <br>
         * Parent contructor<br>
         * this is son <br>
         * Son contructor <br>
         * 
         */
        p.print();// 输出：this is son print

    }

}

5.Integer类的==

package com.gj.test;

import com.gj.vo.Person;

public class IntegerTest {

    /**
     * @param args
     *            Integer类在内存中有一个值的范围为[-128,127]的对象池。只要Integer对象的值在[-128,127]范围内
     *            ，都是从这个对象池中取。所以只要是这个范围内的Integer对象，只要值相同，就是同一个对象。那么==的结果，就是true。
     *            超过了这个范围，则会new新的Integer对象，尽管值相同，但是已经是不同的对象了
     * 
     */
    public static void main(String[] args) {
        Integer a = 100, b = 100, c = 150, d = 150;
        System.out.println("Integer的上限：" + Integer.MAX_VALUE);
        System.out.println("c.hashcode==" + c.hashCode());
        System.out.println("d.hashcode==" + d.hashCode());
        System.out.println(a == b);// true
        System.out.println(c == d);// false
        System.out.println(c.equals(d));// true

        Float s = 12.2f;
        Float w = 12.2f;
        System.out.println(s == w);// false
        System.out.println(s.equals(w));// true

        Person p1 = new Person();
        Person p2 = new Person();
        System.out.println(p1 == p2);// false
        System.out.println(p1.equals(p2));// false

    }

}

6.冒泡排序算法

package com.gj.test;

/**
 * @author Administrator
 * 
 *         冒泡排序算法
 * 
 */
public class MaoPaoSortTest {

    public static void main(String[] args) {
        int[] arr = { 6, 1, 2, 5, 7, 8, 4 };

        sort2(arr);

        for (int tep : arr) {
            System.out.println(tep);
        }

    }

    // 实现1
    public static void sort1(int[] arr) {
        int temp;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }

        }
    }

    // 实现2
    public static void sort2(int[] arr) {
        int temp;
        for (int i = 0; i < arr.length; i++) {
            for (int j = arr.length - 1; j > i; j--) {
                if (arr[j] < arr[j - 1]) {
                    temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = temp;
                }
            }
        }
    }

}

7、 遍历map

package com.gj.test;

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

/**
 * 遍历map<br>
 * 
 * @author Administrator
 * 
 */
public class MapTest {

    public static void main(String[] args) {
        Map<String, String> map = new HashMap<String, String>();
        // 方法一
        for (Entry<String, String> entry : map.entrySet()) {
            System.out.println("key:" + entry.getKey());
            System.out.println("value:" + entry.getValue());
        }
    }

}

8 . 使用正则表达式匹配一个带两位小数的正数

package com.gj.test;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author Administrator 使用正则表达式匹配一个带两位小数的正数
 * 
 */
public class PatternTest {

    public static void main(String[] args) {
        String a = "233.224";
        // 第一种
        String regexs = "^\\d+(\\.\\d(2))$";
        // 第二种
        String regex = "^[1-9][0-9]*+(\\.[0-9]{2})$";
        Pattern p = Pattern.compile(regex);
        Matcher matcher = p.matcher(a);
        if (matcher.matches()) {
            System.out.println("是带两位小数的正数");
        } else {
            System.out.println("不是带两位小数的正数");
        }

    }

}

9、100除以3,赋值给double变量C,保留两位小数

package com.gj.test;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;

/**
 * @author Administrator 问题： 100除以3,赋值给变量C,保留两位小数
 */
public class RemainTest {

    public static void main(String[] args) {
        // 方法一
        BigDecimal a = new BigDecimal(100);
        BigDecimal b = new BigDecimal(3);
        BigDecimal real = a.divide(b, 2, 4);// 此方法快被舍弃，优先使用下面方法；
                                            // 第二个参数代表保留几位，第三个参数代表舍入模式
        BigDecimal other = a.divide(b, 2, RoundingMode.DOWN);
        System.out.println("real = " + real);// 33.33
        System.out.println("other = " + other);// 33.33
        BigDecimal d = new BigDecimal(14.3628);
        double c = d.setScale(2, BigDecimal.ROUND_DOWN).doubleValue();// 对已知数据进行舍入
        System.out.println("c==" + c);// 14.36

        // ******************/
        // 方法二
        DecimalFormat df = new DecimalFormat("0.00");
        int sx = 100;
        int cs = 3;
        String e = df.format((double) sx / cs);
        double f = Double.valueOf(e);
        System.out.println("e=" + e);
        System.out.println("f=" + f);

    }

}

10、 单例模式实现

package com.gj.test;

/**
 * @author Administrator
 * 
 *         单例模式
 * 
 */
public class Singleton {

    private static Singleton instance;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
            return instance;
        }
        return instance;
    }

}

11、 String类相关问题

package com.gj.test;

/**
 * @author Administrator 比较字符串+整型运算结果;
 */
public class StringTest {

    public static void main(String[] args) {

        // *****比较字符串+整型运算结果***/
        int a = 3;
        int b = 4;
        String c = "";
        c = a + b + c;// 先是两个整型相加，然后转为String与空字符串拼接
        System.out.println("c = a + b + c:" + c);// 7
        c = a + c + b;// a先转成String类型，然后与字符串C进行拼接，然后再将b转为String，与之前结果拼接
        System.out.println("c=a+c+b:" + c);// 374
        c += a;
        System.out.println("c+=a:" + c);// 3743
        c = c + a + b;
        System.out.println("c=c+a+b:" + c);

        // *****比较字符串是否相等***/
        String str1 = "hello";
        String str2 = "he" + new String("llo");
        String str3 = "he" + "llo";
        System.out.println(str1 == str2);// false
        System.out.println(str1 == str3);// true
        System.out.println(str1.equals(str2));// true
        System.out.println(str1.equals(str3));// true

        String name = "hello world";
        reseverString2(name);

    }

    /**
     * 将字符串倒序<br>
     * 
     * @param param
     * @return
     * 
     */
    // 方法一
    public static String reseverString1(String param) {
        System.out.println("开始参数，param:" + param);
        char[] arr = param.toCharArray();
        String result = "";
        for (int i = arr.length - 1; i >= 0; i--) {
            result += arr[i];
        }
        System.out.println("结束参数，result:" + result);
        return result;
    }

    // 方法二
    public static String reseverString2(String param) {
        System.out.println("开始参数，param:" + param);

        StringBuffer sb = new StringBuffer(param);
        StringBuffer result = sb.reverse();

        System.out.println("结束参数，result:" + result.toString());
        return result.toString();
    }
}

12 、对list集合，按照集合里对象的name排序

package com.gj.vo;

import java.io.Serializable;

public class Person implements Serializable {

    private static final long serialVersionUID = 7846874432622658899L;

    private String name;
    private String sale;
    private int age;

    public String getName() {
        return name;
    }

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

    public String getSale() {
        return sale;
    }

    public void setSale(String sale) {
        this.sale = sale;
    }

    public int getAge() {
        return age;
    }

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

}

package com.gj.test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import com.gj.vo.Person;

/**
 * @author Administrator
 * 
 *         对list集合，按照集合里对象的name排序
 * 
 */
public class SortTest {

    public static void main(String[] args) {
        List<Person> list = new ArrayList<Person>();
        Person ps = null;
        for (int i = 1; i < 5; i++) {
            ps = new Person();
            ps.setAge(i);
            ps.setName("Test" + i);
            list.add(ps);
        }
        // 倒序
        Collections.sort(list, new Comparator<Person>() {

            @Override
            public int compare(Person o1, Person o2) {
                if (o1.getName().compareTo(o2.getName()) > 0) {
                    return -1;
                }
                if (o1.getName().compareTo(o2.getName()) < 0) {
                    return 1;
                }
                return 0;
            }
        });

        for (Person p1 : list) {
            System.out.println(p1.getName());
        }

    }

}

13、switch表达式后面的数据类型只能是byte,short，char，int四种整形类型，枚举类型和java.lang.String类型（从java 7才允许）

14、异常处理中，如果一个方法里的try代码块一定抛出异常并被catch捕获，但是catch也抛出异常，finally块直接return,那么调用这个方法的方法是否能捕获到异常？
答案是不能捕获，因为不管try或catch里面是什么代码，最后都会执行finally里面的代码

15、父子类继承问题：

package com.gj.vo;

import java.util.Map;

public class A {
    private Map m;

    public Map getM() {
        return m;
    }

    public void setM(Map m) {
        this.m = m;
    }

    public Map aa() {
        return this.m;
    }

}


package com.gj.vo;

import java.util.Map;

public class B extends A {
    public Map bb() {
        return aa();
    }
}

package com.gj.vo;

public class C extends B {

}

package com.gj.test;

import com.gj.vo.B;
import com.gj.vo.C;

public class ABCTest {

    public static void main(String[] args) {
        C c = new C();
        B b = new B();
        System.out.println(c.aa() == b.aa());// true
        System.out.println(c.bb() == b.aa());// true
        System.out.println(c.aa() == b.getM());// true
        System.out.println(c.getM() == b.aa());// true
    }

}
V非凡
关注
专栏目录
国产化系统中遇到的视频花屏、卡顿以及延迟问题的记录与总结
dvlinker的技术专栏
03-21 3万+
国产化系统中遇到的视频花屏、卡顿以及延迟问题的记录与总结。
笔试中遇到的问题
qq_33287871的博客
08-27 1203
目录1、联合体和结构体大小 1、联合体和结构体大小 一、字节对齐的原因 如果不按照适合平台的要求对数据存放进行对齐，则会在存取效率带来损失。 假设某平台每次读取都从偶地址开始。若不对数据的存放进行对齐，则某些数据可能被存放于奇地址开始的地方。 这种情况下，平台就需要2个读周期，并对两次读取的结果的高低字节进行拼凑，才可能得到该数据。显然效率下降很多。 二、字节对齐的规则 1.常见类型的对齐方式（默认） 类型 对齐方式（变量存放的起始地址相对于结构的起始地址的偏移量） char 偏移量为 size
Java编程思想学习笔记二（1）：static关键字的四种用法
CHENXY
03-13 546
    前文中说到了static关键字，在Java中这是一个很重要的关键字，它有很多的用法，并且在某些特定的情况下使用可以优化程序的性能。本文学习static关键字的应用场景。在这之前了解变量的类型，变量按作用域分为成员变量和局部变量，成员变量也就是全局变量，它是在类中声明的，不属于类中任何一个方法。而局部变量是在类中的方法体中声明的，作用域只是这个方法体。接下来说一下static的作用。一、修饰...
Java期末考试试题及参考答案(03)
谷哥的小弟
12-11 5780
封装就是隐藏对象的属性和实现细节仅对外提供公有的方法。
JVM实探-class文件格式实战（3）
08-21 584
实战演练 先创建一个简单类 package com.weyne.demo.jvm; public class Test { private static String a = "test-a"; public static void main(String[] args) { System.out.println("Hello world"); } } 通过jclasslib可以看到结构体信息 通过Sublime等16进制文件编辑器查看Test.clas
Java学习（12）—— 集合
Archer__13的博客
11-10 1134
Collection：存储一个一个的数据 Map：存储一对（key-value）一对的数据 List：元素有序、可重复的集合 Set：元素无序、不可重复的集合 一. Collection 1. List 2. Set 一. Map ...
java期末练习题
weixin_52796601的博客
01-09 395
1.计算累乘 public class Text { public static void main(String[ ] args){ int n=1,m,s,k=0; while(n<=8){ for(s=1,m=1;m<=n;m++) s=s*m; k=k+s; n++; } System.out.println("1
记录一下遇到的问题
u013713961的博客
05-15 177
最近在用idea学习，记录下自己遇到的问题 1.我在学习springMVC的时候，创建了maven项目，引入依赖之后，启动tomcat，总是提示找不到dispatcherservlet，和那个字符编码过滤器，这两个都是springMVC的依赖包里的类，猜测是jar包没有成功导入或者是没有识别之类的，后来通过百度在pom文件加上了 <packaging>war</packaging> 之后可以识别到前面那两个东西了，在这里记录一下 2.后来在测试页面跳转的时候，发现找不到对应的jsp页
记录遇到的问题以及解决方法
08-13 2699
1. 在使用openwrt编译工具链编译测试程序。 （/opt/toolchain_mspdc2k/bin/arm-openwrt-linux-gcc main.c -o test） 警告信息： arm-openwrt-linux-gcc: warning: environment variable "STAGING_DIR" not defined arm-openwrt-linux-g
面试-技术文档遇到的问题记录
最新发布
07-04
- 文档中应该包含指向更详细资料或相关文档的链接，以便读者可以进一步探索感兴趣的主题或解决问题。 6. **标题与内容一致性**： - 文档的标题应该准确反映其内容。使用简单明了且具有描述性的标题可以帮助读者...
高级java笔试题-android-issues:android开发过程中遇到的问题
06-03
记录android开发过程中遇到的问题。 1.在一个xml中能否使用同一个include多次 android中include标签的使用 2. android button在 linerlayout中底部居中 把button外的权重设为1.0 3.button shape ...
leetcode题库-DayLearnNote:面试笔试题、读书笔记，记录工作、学习过程遇到的任何知识点
06-29
1.3 工作中的问题解决：LeetCode题目模拟了实际工作中遇到的复杂问题，通过解题可以锻炼解决问题的能力。 二、DayLearnNote学习法 2.1 日积月累：DayLearnNote强调每天学习并记录，形成持续学习的习惯。每天攻克...
Java中map的三种遍历方式
勇气与行动
11-21 273
public class Test { public static void main(String[] args) { Map<Integer,String> map = new HashMap<>(); map.put(1,"a"); map.put(2,"b"); map.put(3,"c...
java基础语法练习（第三章）
DecorateCC的博客
04-05 4670
java基础语法练习一级目录二级目录三级目录 一级目录 二级目录 三级目录
Java--static--用法/使用位置/实例
热门推荐
IT利刃出鞘的博客
10-25 1万+
本文用示例介绍Java中的static的用法。
java必须精通第一课
孤君只待两相月
07-05 600
基础知识 数据类型 java是一种强类型语言，这就意味着为每一个变量生命一种类型，在java中一共有八种基本数据类型。其中四种整型，两种浮点型，一种用于表示Unicode编码的字符类型和一种用于表示真假的Boolean类型 在java中整型的类型与运行java代码的机器无关，这就解决了软件从一个平台移植带另一个平台，或者在同一平台的不同系统之间移植给程序员带来的诸多问题。因为java程序必须保证...
J2SE字符串-(““).equals(str)与str.equals(““)
兴趣是最好的老师
08-30 463
https://blog.csdn.net/phenixyf/article/details/51995495
Java面试宝典2010版
旅行人生
07-16 5374
Java面试宝典2010版一. Java基础部分...................................................................................................... 71、一个".java"源
【初学者常见问题】深入理解“==”和equals()
Coder的不平凡
11-25 1585
首先感谢老大在这一方面对我的指引。http://v.youku.com/v_show/id_XNjAzNTczMTI4.html 我将把我对于"=="和equals()体会和实例一起结合让菜鸟们能够深入了解（当然我也是菜鸟，嘻嘻） 长久以来，我看淡很多面试题都有下面类似的题目出现，如： String s=new String(“hello”); String t =new String(“
SQL基础题集：数据库笔试常见问题解析
在数据库笔试题中，我们通常会遇到各种类型的题目，涉及SQL语言的操作、数据结构和算法的理解。以下是针对给定部分题目和知识点的详细解答： 1. 更新日期字段的问题：SQL标准的更新语句是`UPDATE T SET LOGDATE = '...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值