牛客真题错题总结-JAVA

请问以下哪个方法用于定义线程的执行体（）：run()

==判断的是内存地址，integer在赋予int数值-127到128之间的数可以直接调用cache，所以内存地址一样，超过这个范围就new了一个对象，所以内存地址就不一样了就返回了false

<<：是逻辑左移，右边补0，符号位和其他未一样要移动，数学意义：在数字没有溢出的前提下，对于正数和负数，左移一位都相当于乘以2的1次方，左移n位就相当于乘以2的n次方

java对I/O访问所提供的同步处理机制是过滤流。

如果想列出当前目录以及子目录下所有扩展名为”.txt”的文件，那么可以使用一下哪个命令:
Linux find命令用来在指定目录下查找文件。

定义了一系列算法，并将每个算法都封装起来，使他们可以相互替换是指策略模式。

虚拟内存的容量只受计算机地址位数的限制。

若处理器有32位地址，则他的虚拟地址空间位2的32次方=4G

按照二叉树的定义，具有3个节点的二叉树有5种

缓存系统中主要使用的数据结构是hashMap

简述java语言中，ArrayList,Vector,LinklList的关系与区别
相同：ArrayList，LinkedList,Vector这三个类都实现了java.util,List接口，同在java.util包下，他们都允许Null值，区别ArrayList和Vector是采用数组的方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，都允许直接序号索引元素，但是插入数据要设计到数组元素移动等内存操作，所以索引数据快插入数据慢，Vector由于使用了synchronized方法，是线程安全的，所以性能上比ArrayList要差。LinkedList使用双向链表实现存储，按序号索引数据需要进行向前或向后遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快！ArrayList和LinkedList都不是线程安全的。

无限制创建线程的不足有哪些？
1.线程生命周期的开销非常高，线程的创建和销毁都是有代价的，线程的创建过程都需要时间，并且需要JVM和操作系统提供一些辅助操作，如果请求的到达率非常高而且请求的处理过程是轻量级的，那么位每个请求创建一个新线程将消耗大量的计算资源；2.资源消耗。活跃的线程会消耗系统资源，尤其内存，如果运行的线程数多于可用的处理器数量，那么这些线程将闲置，大量空闲的线程会占用许多内存，给垃圾回收器带来压力，而且大量线程竞争CPU资源时还会产生其他的性能开销。3.稳定性，在可创建的线程数量上存在一个限制，破坏了这些限制可能会抛出OutOfMemoryError异常，要想从这些错误中恢复过来是非常危险的，更简单的方式是通过构造程序来避免超出这些限制。

有一座高度是n级台阶的楼梯，从下往上走，每跨一步只能向上1级或者2级台阶，要求用程序来求出一共有多少钟走法。

import java.util.Scanner;

public class jieti {

    public static void main(String[] args1)
    {
        Scanner sc = new Scanner(System.in);
        int i= sc.nextInt();
        int count = qiuJie(i);
        System.out.println(count);
    }
    private static int qiuJie(int i)
    {
        if(i == 1|| i == 0)
            return 1;
        else
            return qiuJie(i-1)+qiuJie(i-2);
    }
}

创建两个线程，其中一个输出1-52，另外一个输出A-Z。输出格式要求：12A 34B 56C 78D

import java.util.concurrent.atomic.AtomicInteger;

public class twoThread {
    public static volatile boolean flag = false;
    public static AtomicInteger time = new AtomicInteger();
    public static void main(String[] args)
    {
        new Thread(()->
        {
            for(int i=1;i<53;i=i+2)
            {
                if(!flag&&(time.get()==0||time.incrementAndGet()%2==0))
                {
                    System.out.println(i);
                    System.out.println(i+1);
                    flag=true;
                }
                else
                {
                    i=i-2;
                }
            }
        }).start();
        new Thread(
                ()->
                {
                    for(int i=0;i<26;i++)
                    {
                        if(flag&&(time.get()==1||time.incrementAndGet()%2==1))
                        {
                            System.out.println((char)(i+'A'));
                            System.out.println(' ');
                            flag=false;
                        }
                        else
                        {
                            i--;
                        }
                    }
                }
        ).start();
    }
}

原地翻转句子中单词的顺序，但单词内容的顺序不变。

import java.util.Scanner;

public class transformDanci {
    public static void main(String[] argc)
    {
        Scanner sc = new Scanner(System.in);
        String target = sc.nextLine();
        String reserve = reserve(target);
        System.out.println(reserve);

    }
    public static String reserve(String str)
    {
        String []ss =str.split("");
        StringBuffer s = new StringBuffer("");
        for(int i = ss.length-1;i>=0;i--)
        {
            s.append(ss[i]+" ");
        }
        return s.toString();
    }
}

输入一个正整数数组，将他们链接起来排成一个数，输出能排出的所有数字中最小的一个。

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

public class getMinNum {
    public static void main(String[] argc)
    {
        ConnectArray();
    }
    public static void ConnectArray()
    {
        String str=new Scanner(System.in).next();
        String[] numbers = str.split(",");
        Arrays.sort(numbers, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                if(o1.length() == o2.length())
                {
                    return o1.compareTo(o2);
                }
                return (o1+o2).compareTo((o2+o1));
            }
        });
        for(String s:numbers)
        {
            System.out.printf("%s",s);
        }
    }
}

有为N件物品，他们的重量W分别是W1,w2,wn他们的价值分别是v1,v2,…vn每件物品数量有且仅有一个，现在给你个承重为M的背包，求背包里装入的物品具有的价值最大总和

    import java.util.Scanner;

    public class tanxin {
        public static void main(String[] argc)
        {
            Scanner sc = new Scanner(System.in);
            int n = sc.nextInt();
            int d = sc.nextInt();
            int[] value=new int[n+1];
            int[] weight=new int[n+1];
            for(int i=1;i<=n;i++)
            {
                weight[i]=sc.nextInt();
            }
            for(int i=1;i<=n;i++)
            {
                value[i]=sc.nextInt();
            }
            int[][]dp = new int[n+1][d+1];
            dp[0][d]=0;
            for(int i =1;i<=n;i++)
            {
                for(int j=d;j>=weight[i];j--)
                {
                    dp[i][j]=Integer.max(dp[i-1][j],dp[i-1][j-weight[i]]+value[i]);
                }
            }
            System.out.println(dp[n][d]);
        }
    }