习题

最新推荐文章于 2024-08-23 17:31:58 发布

欢欢**

最新推荐文章于 2024-08-23 17:31:58 发布

阅读量267

点赞数 1

分类专栏： Java

本文链接：https://blog.csdn.net/yihjh/article/details/104461774

版权

Java 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

1313

给你一个以行程长度编码压缩的整数列表 nums 。

考虑每对相邻的两个元素 [a, b] = [nums[2*i], nums[2*i+1]] （其中 i >= 0 ），每一对都表示解压后有 a 个值为 b 的元素。

请你返回解压后的列表。

示例：

输入：nums = [1,2,3,4]
输出：[2,4,4,4]
解释：第一对 [1,2] 代表着 2 的出现频次为 1，所以生成数组 [2]。
第二对 [3,4] 代表着 4 的出现频次为 3，所以生成数组 [4,4,4]。
最后将它们串联到一起 [2] + [4,4,4] = [2,4,4,4]。

提示：

   2 <= nums.length <= 100
   nums.length % 2 == 0
   1 <= nums[i] <= 100

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/decompress-run-length-encoded-list
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

import java.util.Arrays;
class Solution1313 {
    public static void main(String[] args){
        int[] nums={1,2,3,4};
        int[] res=decompressRLElist(nums);
        System.out.println(Arrays.toString(res));
    }
    public static int[] decompressRLElist(int[] nums) {
        int len=0;
        //遍历偶数角标 累加得到新数组的长度
        for(int i=0;i<nums.length;i+=2){
            len+=nums[i];
        }
        int[] res=new int[len];
        //遍历奇数角标 获取需要被多次写入的数据
        //1 2 3 4 5 6
        //2 4 4 4 6 6 6 6 6
        int index=0;
        for(int i=1;i<=nums.length;i+=2){
            for(int j=0;j<nums[i-1];j++){
                res[index++]=nums[i];
            }
        }
        return res;
    }
}

1295

输入：nums = [12,345,2,6,7896]
输出：2
解释：
12 是 2 位数字（位数为偶数）
345 是 3 位数字（位数为奇数）
2 是 1 位数字（位数为奇数）
6 是 1 位数字位数为奇数）
7896 是 4 位数字（位数为偶数）
因此只有 12 和 7896 是位数为偶数的数字

示例 2：

输入：nums = [555,901,482,1771]
输出：1
解释：
只有 1771 是位数为偶数的数字。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/find-numbers-with-even-number-of-digits
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution1295 {
    public int findNumbers(int[] nums) {
        int count=0;
        for(int i=0;i<nums.length;i++){
            if((nums[i]+"").length()%2==0){
                count++;
            }
        }
        return count;
    }
}

1013

给定一个整数数组 A，只有我们可以将其划分为三个和相等的非空部分时才返回 true，否则返回 false。

形式上，如果我们可以找出索引 i+1 < j 且满足 (A[0] + A[1] + ... + A[i] == A[i+1] + A[i+2] + ... + A[j-1] == A[j] + A[j-1] + ... + A[A.length - 1]) 就可以将数组三等分。

示例 1：

输出：[0,2,1,-6,6,-7,9,1,2,0,1]
输出：true
解释：0 + 2 + 1 = -6 + 6 - 7 + 9 + 1 = 2 + 0 + 1

示例 2：

输入：[0,2,1,-6,6,7,9,-1,2,0,1]
输出：false

示例 3：

输入：[3,3,6,5,-2,2,5,1,-9,4]
输出：true
解释：3 + 3 = 6 = 5 - 2 + 2 + 5 + 1 - 9 + 4

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/partition-array-into-three-parts-with-equal-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution1013 {
    public boolean canThreePartsEqualSum(int[] A) {
        int sum=0;
        for(int num:A){
            sum+=num;
        }
        int key=sum/3;
        int group=0;
        for(int i=0;i<A.length;i++){
            key-=A[i];
            if(key==0){
                group++;
                key=sum/3;
            }
        }
        return group==3;
    }
}

905

给定一个非负整数数组 A，返回一个数组，在该数组中， A 的所有偶数元素之后跟着所有奇数元素。

你可以返回满足此条件的任何数组作为答案。

示例：

输入：[3,1,2,4]
输出：[2,4,3,1]
输出 [4,2,3,1]，[2,4,1,3] 和 [4,2,1,3] 也会被接受。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/sort-array-by-parity
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution905 {
    public int[] sortArrayByParity(int[] A) {
        int left=0;
        int right=A.length-1;
        while(left<right){
            if(A[left]%2==1&&A[right]%2==0){        
                int temp=A[left];
                A[left]=A[right];
                A[right]=temp;
            }else if(A[left]%2==0&&A[right]%2==1){  
                left++;
                right--;
            }else if(A[left]%2==0&&A[right]%2==0){
                left++;
            }else{
                right--;
            }
        }
        return A;
    }
}

724

给定一个整数类型的数组 nums，请编写一个能够返回数组“中心索引”的方法。

我们是这样定义数组中心索引的：数组中心索引的左侧所有元素相加的和等于右侧所有元素相加的和。

如果数组不存在中心索引，那么我们应该返回 -1。如果数组有多个中心索引，那么我们应该返回最靠近左边的那一个。

示例 1:

输入:
nums = [1, 7, 3, 6, 5, 6]
输出: 3
解释:
索引3 (nums[3] = 6) 的左侧数之和(1 + 7 + 3 = 11)，与右侧数之和(5 + 6 = 11)相等。
同时, 3 也是第一个符合要求的中心索引。

示例 2:

输入:
nums = [1, 2, 3]
输出: -1
解释:
数组中不存在满足此条件的中心索引。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/find-pivot-index
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution724 {
    public int pivotIndex(int[] nums) {
        int sum=0;
        for(int num:nums){
            sum+=num;
        }
        int leftSum=0;
        int rightSum=0;
        for(int i=0;i<nums.length;i++){
            if(i==0){
                leftSum=0;
            }else{
                leftSum+=nums[i-1];
            }
            rightSum=sum-nums[i]-leftSum;
            if(rightSum==leftSum){
                return i;
            }
        }
        return -1;
    }
}

674

给定一个未经排序的整数数组，找到最长且连续的的递增序列。

示例 1:

输入: [1,3,5,4,7]
输出: 3
解释: 最长连续递增序列是 [1,3,5], 长度为3。
尽管 [1,3,5,7] 也是升序的子序列, 但它不是连续的，因为5和7在原数组里被4隔开。

示例 2:

输入: [2,2,2,2,2]
输出: 1
解释: 最长连续递增序列是 [2], 长度为1。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-continuous-increasing-subsequence
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution674 {
    public static void main(String[] args){
        int[] nums={2,2,2,2};
        int len=findLengthOfLCIS(nums);
        System.out.println(len);
    }
    public static int findLengthOfLCIS(int[] nums) {
        if(nums.length==0||nums.length==1){
            return nums.length;
        }
        int maxL=0;
        int maxR=0;
        int l=0;
        int r=0;
        int maxCount=1;
        int count=1;
        for(int i=0;i<nums.length-1;i++){
            if(nums[i+1]>nums[i]){
                count++;
                r=i+1;
            }else{
                count=1;
                l=i+1;
                r=i+1;
            }
            if(count>maxCount){
                maxCount=count;
                maxL=l;
                maxR=r;
            }
        }
        System.out.println(maxL+"~"+maxR);
        return maxCount;
    }
}

283

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

示例:

输入: [0,1,0,3,12]
输出: [1,3,12,0,0]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/move-zeroes
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution283 {
    public void moveZeroes(int[] nums) {
        int k=0;
        int temp=0;
        for(int i=0;i<nums.length;i++){
            if(nums[i]!=0){
                temp=nums[i];
                nums[i]=nums[k];
                nums[k]=temp;
                k++;
            }
        }
    }
}

209

给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的连续子数组。如果不存在符合条件的连续子数组，返回 0。

示例:

输入: s = 7, nums = [2,3,1,2,4,3]
输出: 2
解释: 子数组 [4,3] 是该条件下的长度最小的连续子数组

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/minimum-size-subarray-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution209 {
    public int minSubArrayLen(int s, int[] nums) {
        int len=0;
        int i=0;
        int sum=0;
        for(int j=0;j<nums.length;j++){
            sum+=nums[j];
            while(sum>=s){
                len=len==0?(j-i+1):Math.min(len,j-i+1);
                sum-=nums[i];
                i++;
            }
        }
        return len;
    }
}

169

给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。

你可以假设数组是非空的，并且给定的数组总是存在多数元素。

示例 1:

输入: [3,2,3]
输出: 3

示例 2:

输入: [2,2,1,1,1,2,2]
输出: 2

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/majority-element
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution169 {
    public int majorityElement(int[] nums) {
        //不使用排序 在O(n)解决
        int m=nums[0];
        int count=1;
        for(int i=1;i<nums.length;i++){
            if(nums[i]==m){
                count++;
            }else{
                count--;
                if(count==0){
                    m=nums[i];
                    count=1;
                }
            }
        }
        return m;
    }
}

给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。

最高位数字存放在数组的首位，数组中每个元素只存储单个数字。

你可以假设除了整数 0 之外，这个整数不会以零开头。

示例 1:

输入: [1,2,3]
输出: [1,2,4]
解释: 输入数组表示数字 123。

示例 2:

输入: [4,3,2,1]
输出: [4,3,2,2]
解释: 输入数组表示数字 4321。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/plus-one
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

import java.util.Arrays;
class Solution66 {
    public static void main(String[] args){
        int[] digits={9,8,7,6,5,4,3,2,1,0};
        System.out.println(Arrays.toString(plusOne(digits)));
    }
    public static int[] plusOne(int[] digits) {
        int carry=1;
        for(int i=digits.length-1;i>=0;i--){
            int num=digits[i]+carry;
            digits[i]=num%10;
            carry=num/10;
            if(carry==0){
                break;
            }
        }
        if(carry==1){   //只能说明数组当中肯定是全9
            int[] arr=new int[digits.length+1];
            arr[0]=1;
            return arr;
        }
        return digits;

        //错误的思路 整形溢出
        /*
        int num=0;
        for(int i=0;i<digits.length;i++){
            num=num*10+digits[i];
        }
        num=num+1;//124
        int[] arr=new int[(""+num).length()];
        for(int i=arr.length-1;i>=0;i--){
            arr[i]=num%10;
            num/=10;
        }
        return arr;
        */
    }
}

1342

给你一个非负整数 num ，请你返回将它变成 0 所需要的步数。如果当前数字是偶数，你需要把它除以 2 ；否则，减去 1 。

示例 1：

输入：num = 14
输出：6
解释：
步骤 1) 14 是偶数，除以 2 得到 7 。
步骤 2） 7 是奇数，减 1 得到 6 。
步骤 3） 6 是偶数，除以 2 得到 3 。
步骤 4） 3 是奇数，减 1 得到 2 。
步骤 5） 2 是偶数，除以 2 得到 1 。
步骤 6） 1 是奇数，减 1 得到 0 。

示例 2：

输入：num = 8
输出：4
解释：
步骤 1） 8 是偶数，除以 2 得到 4 。
步骤 2） 4 是偶数，除以 2 得到 2 。
步骤 3） 2 是偶数，除以 2 得到 1 。
步骤 4） 1 是奇数，减 1 得到 0 。

示例 3：

输入：num = 123
输出：12

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/number-of-steps-to-reduce-a-number-to-zero
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
    public int numberOfSteps (int num) {
        int count = 0;
        while (num != 0){
            if (num % 2 == 0){
                count++;
                num /= 2;
            }else {
                count++;
                num -= 1;
            }
        }
        return count;
    }
}

判断一个数是否为奇数，当他等于0时结束。

1281

给你一个整数 n，请你帮忙计算并返回该整数「各位数字之积」与「各位数字之和」的差。

示例 1：

输入：n = 234
输出：15
解释：
各位数之积 = 2 * 3 * 4 = 24
各位数之和 = 2 + 3 + 4 = 9
结果 = 24 - 9 = 15

示例 2：

输入：n = 4421
输出：21
解释：
各位数之积 = 4 * 4 * 2 * 1 = 32
各位数之和 = 4 + 4 + 2 + 1 = 11
结果 = 32 - 11 = 21

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/subtract-the-product-and-sum-of-digits-of-an-integer
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
    public int subtractProductAndSum(int n) {
        int ji = 1;
        int add = 0;
        int num ;
        while (n!= 0){
           num = n % 10;
           n /= 10;
           ji = num * ji;
           add = num + add;
        }
        return ji - add;
    }
}

计算机软件主要分为系统软件与应用软件两大类。系统软件主要包括操作系统、语言处理系统、数据库管理系统和系统辅助处理程序。应用软件主要包括办公软件和多媒体处理软件。Java是一门面向对象编程语言，属于计算机语言。故正确答案为D选项。

因为没有break，所以就可以一直进行下去。

instanceof通过返回一个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例，
而Object是所有类的父类。

重载要求方法的参数列表需要不一样（个数，或者参数类型），修改参数名或者修改返回值以及访问权限并没有用

在同一个java原文件中，可以有多个class类，但是只有有一个公共的 public class

input和output指的是对于程序而言。input是从文件读取进来，output是输出到文件。

1.finally{}代码块比return先执行。

2.多个return是按顺序执行的的，多个return执行了一个后，后面的return就不会执行了。

3. 记住一点，不管有不有异常抛出， finally都会在return返回前执行。

桥接模式：

定义：将抽象部分与它的实现部分分离，使它们都可以独立地变化。

意图：将抽象与实现解耦。

桥接模式所涉及的角色
1. Abstraction ：定义抽象接口，拥有一个Implementor类型的对象引用
2. RefinedAbstraction ：扩展Abstraction中的接口定义
3. Implementor ：是具体实现的接口，Implementor和RefinedAbstraction接口并不一定完全一致，实际上这两个接口可以完全不一样Implementor提供具体操作方法，而Abstraction提供更高层次的调用
4. ConcreteImplementor ：实现Implementor接口，给出具体实现

Jdk中的桥接模式：JDBC
JDBC连接数据库的时候，在各个数据库之间进行切换，基本不需要动太多的代码，甚至丝毫不动，原因就是JDBC提供了统一接口，每个数据库提供各自的实现，用一个叫做数据库驱动的程序来桥接就行了

volatile是java中的一个类型修饰符。它是被设计用来修饰被不同线程访问和修改的变量。如果不加入volatile，基本上会导致这样的结果：要么无法编写多线程程序，要么编译器失去大量优化的机会。

1，可见性

可见性指的是在一个线程中对该变量的修改会马上由工作内存（Work Memory）写回主内存（Main Memory），所以会马上反应在其它线程的读取操作中。顺便一提，工作内存和主内存可以近似理解为实际电脑中的高速缓存和主存，工作内存是线程独享的，主存是线程共享的。

2，禁止指令重排序优化

禁止指令重排序优化。大家知道我们写的代码（尤其是多线程代码），由于编译器优化，在实际执行的时候可能与我们编写的顺序不同。编译器只保证程序执行结果与源代码相同，却不保证实际指令的顺序与源代码相同。这在单线程看起来没什么问题，然而一旦引入多线程，这种乱序就可能导致严重问题。volatile关键字就可以从语义上解决这个问题。

注意，禁止指令重排优化这条语义直到jdk1.5以后才能正确工作。此前的JDK中即使将变量声明为volatile也无法完全避免重排序所导致的问题。所以，在jdk1.5版本前，双重检查锁形式的单例模式是无法保证线程安全的。因此，下面的单例模式的代码，在JDK1.5之前是不能保证线程安全的。

A选项- 标准写法，正确

1

public class A extends B implements C

B选项- implements接的是接口类而A此处的定义又是class
循环矛盾，必然错误

1

public class A implements A B

C选项- 正确，一个类可以实现多个接口（但是题目拼写有误- -）

1

public class A implements B,C,D

D选项- 错误。

1

public implements B

Hashtable的方法都是synchrnized修饰的线程安全，

ConcurrentHashMap并发容器，JDK7采用分段锁，JDK8采用CAS算法，线程安全，建议使用，Connections工具类提供了一个方法synchrnizedMap可以把Map同步，本质就是给每一个方法加上synchrnized关键字进行同步

编译型语言和解释性语言：编译型语言在程序执行之前，先会通过编译器对程序执行一个编译的过程，把程序转变成机器语言。运行时就不需要翻译，而直接执行就可以了。最典型的例子就是C语言。

解释型语言就没有这个编译的过程，而是在程序运行的时候，通过解释器对程序逐行作出解释，然后直接运行，最典型的例子是Ruby。但是，随着Java等基于虚拟机的语言的兴起，我们又不能把语言纯粹地分成解释型和编译型这两种，用Java来举例，Java首先是通过编译器编译成字节码文件，然后在运行时通过解释器给解释成机器文件。所以我们说Java是一种先编译后解释的语言。

静态联编是指编译时多态，动态联编是指运行时多态，看网上多指C++。

java字符串可以拼接，这个溢出的限定不好判断，但是数组是一定可以溢出的

私有:java虚拟机栈，程序计数器，本地方法栈共享:java堆，方法区

AB

C： JAVA程序中public修饰的类名必须与文件名一样

D： JAVA程序的main方法中，不管有多少条语句都必须用{}（大括号）括起来

A：静态成员变量或静态代码块>main方法>非静态成员变量或非静态代码块>构造方法

B：think in java中提到构造器本身并没有任何返回值。

C: 构造方法的主要作用是完成对类的对象的初始化工作。

D: 一般在创建(new)新对象时，系统会自动调用构造方法。

bootstrap classloader －引导（也称为原始）类加载器，它负责加载Java的核心类。 extension classloader －扩展类加载器，它负责加载JRE的扩展目录（JAVA_HOME/jre/lib/ext或者由java.ext.dirs系统属性指定的）中JAR的类包。 system classloader －系统（也称为应用）类加载器，它负责在JVM被启动时，加载来自在命令java中的-classpath或者java.class.path系统属性或者 CLASSPATH*作系统属性所指定的JAR类包和类路径。

1.session用来表示用户会话，session对象在服务端维护，一般tomcat设定session生命周期为30分钟，超时将失效，也可以主动设置无效； 2.cookie存放在客户端，可以分为内存cookie和磁盘cookie。内存cookie在浏览器关闭后消失，磁盘cookie超时后消失。当浏览器发送请求时，将自动发送对应cookie信息，前提是请求url满足cookie路径； 3.可以将sessionId存放在cookie中，也可以通过重写url将sessionId拼接在url。因此可以查看浏览器cookie或地址栏url看到sessionId； 4.请求到服务端时，将根据请求中的sessionId查找session，如果可以获取到则返回，否则返回null或者返回新构建的session，老的session依旧存在，请参考API。

HttpSessionAttributeListener：可以实现此侦听器接口获取此web应用程序中会话属性列表更改的通知；

HttpSessionBindingListener：当该对象从一个会话中被绑定或者解绑时通知该对象，这个对象由HttpSessionBindingEvent对象通知。这可能是servlet程序显式地从会话中解绑定属性的结果，可能是由于会话无效，也可能是由于会话超时；

HttpSessionObjectListener：没有该接口API；

HttpSessionListener：当web应用程序中的活动会话列表发生更改时通知该接口的实现类，为了接收该通知事件，必须在web应用程序的部署描述符中配置实现类；

HttpSessionActivationListener：绑定到会话的对象可以侦听容器事件，通知它们会话将被钝化，会话将被激活。需要一个在虚拟机之间迁移会话或持久会话的容器来通知所有绑定到实现该接口会话的属性。