JavaSE题

奇数位于偶数之前

调整数组顺序使得奇数位于偶数之前。调整之后，不关心大小顺序。
如数组：[1,2,3,4,5,6]
调整后可能是：[1, 5, 3, 4, 2, 6]

import java.util.Arrays;
public class Test {
    public static void func(int[] array){
        int i=0;
        int j=array.length-1;
        while(i<j){
            while(array[i]%2==1&&i<j){//防止越界
                i++;
            }
            while(array[j]%2==0&&i<j){
                j--;
            }
            int tmp=array[i];
            array[i]=array[j];
            array[j]=tmp;
        }
    }
    public static void main(String[] args) {
        int[] array={1,2,3,4,5,6};
        func(array);
        System.out.println(Arrays.toString(array));
    }
}

两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

import java.util.Arrays;
public class Test {
    public static int[] twoSum(int[] array,int k){
        int[] ret=new int[2];
        for (int i = 0; i < array.length-1; i++) {
            for (int j = i+1; j <array.length; j++) {
                if(array[i]+array[j]==k){
                    ret[0]=i;
                    ret[1]=j;
                    return ret;
                }
            }
        }
        return ret;
    }
    public static void main(String[] args) {
        int[] array={2,7,11,15};
        int target=9;
        int[] ret=twoSum(array,9);
        System.out.println(Arrays.toString(ret));
    }
}

[0, 1]

多数元素

给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。
你可以假设数组是非空的，并且给定的数组总是存在多数元素。
示例1：
输入：[2,2,1,1,1,2,2]
输出：2

投票法：
public class Test {
    public static int majorityNum(int[] array){
        int k=array[0];
        int count=0;
        for (int i = 0; i <array.length; i++) {
            if(array[i]==k){
                count++;
            }else{
                count--;
            }
            if(count==0){
                k=array[i+1];
            }
        }
        return k;
    }
    public static void main(String[] args) {
        int[] array={2,2,1,1,1,2,2};
        int ret=majorityNum(array);
        System.out.println(ret);
    }
}

存在连续三个奇数的数组

给你一个整数数组 arr，请你判断数组中是否存在连续三个元素都是奇数的情况：如果存在，请返回 true ；否则，返回 false 。
示例 1：
输入：arr = [1,2,34,3,4,5,7,23,12]
输出：true
解释：存在连续三个元素都是奇数的情况，即 [5,7,23] 。

public class Test {
    public static boolean func1(int[] array){
        int count=0;
        for (int i = 0; i < array.length; i++) {
            if(array[i]%2==1){
                count++;
                if(count==3){
                    return true;
                }
            }else{
                count=0;
            }
        }
        return false;
    }
    public static void main(String[] args) {
        int[] array={1,2,34,3,4,5,7,23,12};
        boolean ret=func1(array);
        System.out.println(ret);
    }
}

类和对象

1.

public class Test { 
    public int aMethod(){
        static int i = 0;
        i++; 
        return i;
    } 
public static void main(String args[]){
    Test test = new Test(); 
    test.aMethod(); 
    int j = test.aMethod();
    System.out.println(j);
    } 
}

编译失败

原因：静态变量是类变量，随着类加载而被创建。方法中的变量是局部变量，调用这个方法时才被创建。这两种性质是相冲突的。
结论：Java中不能定义局部的静态变量

2.

关于以下程序代码的说明正确的是()

 public class HasStatic {// 1
	private static int x = 100;// 2
	public static void main(String args[]) {// 3
		HasStatic hsl = new HasStatic();// 4
		hsl.x++;// 5
		HasStatic hs2 = new HasStatic();// 6
		hs2.x++;// 7
		hsl = new HasStatic();// 8
		hsl.x++;// 9
		HasStatic.x--;// 10
		System.out.println(" x=" + x);// 11
	}
}

A.程序通过编译，输出结果为:x=102
B.程序通过编译，输出结果为:x=103
C.10行不能通过编译.因为x星私有静态变量
D.5行不能通过编译.因为引用了私有静态变量

答案：A

本题中的x是静态变量，是类变量只有一份，题目所有对x的操作都是同一份，静态变量应该通过类名访问，题目使用对象引用进行访问不会报错，但是不建议。

3.

选C

Ctrl+Alt+L格式化代码

String类

指出下列程序运行的结果（）

public class Example{
    String str = new String("good");
    char[ ] ch = { 'a' , 'b' , 'c' };
    public static void main(String args[]){
        Example ex = new Example();
        ex.change(ex.str,ex.ch);
        System.out.print(ex.str + " and ");
        System.out.print(ex.ch);
    }
    public void change(String str,char ch[ ]){
        str = "test ok";
        ch[0] = 'g';
    }
}
题目内容：
A .good and abc
B .good and gbc
C .test ok and abc
D .test ok and gbc

选B

387. 字符串中的第一个唯一字符(leetcode)

给定一个字符串 s ，找到 它的第一个不重复的字符，并返回它的索引 。如果不存在，则返回 -1 。

 

示例 1：

输入: s = "leetcode"
输出: 0

class Solution {
    public int firstUniqChar(String s) {
        int[] arr=new int [26];
        for(int i=0;i<s.length();i++){
            char ch=s.charAt(i);
            arr[ch-'a']++;
        }
        for(int i=0;i<s.length();i++){
            char ch=s.charAt(i);
            if(arr[ch-'a']==1){
                return i;
            }
        }
        return -1;
    }
}

创建一个计数数组

HJ1 字符串最后一个单词的长度 (牛客网)

描述
计算字符串最后一个单词的长度，单词以空格隔开，字符串长度小于5000。（注：字符串末尾不以空格为结尾）
输入描述：

输入一行，代表要计算的字符串，非空，长度小于5000。
输出描述：

输出一个整数，表示输入字符串最后一个单词的长度。
示例1
输入：

hello nowcoder

输出：

8

说明：

最后一个单词为nowcoder，长度为8   

import java.io.InputStream;
import java.util.Scanner;
public class Main{
     public  static void  main(String [] args){
        Scanner scanner=new Scanner(System.in);
        String  str=scanner.nextLine();
        String[] ret=str.split(" ");
         int len=ret[ret.length-1].length();
         System.out.println(len);
     }
}

import java.io.InputStream;
import java.util.Scanner;
public class Main{
     public  static void  main(String [] args){
        Scanner scanner=new Scanner(System.in);
        String  str=scanner.nextLine();
         int index=-1;
        for(int i=str.length()-1;i>=0;i--)
        {
            if(str.charAt(i)==' ')
            {
                index=i;
                break;
            }
        }
         int len=str.length()-1-index;
         System.out.println(len);
     }
}

125. 验证回文串

如果在将所有大写字符转换为小写字符、并移除所有非字母数字字符之后，短语正着读和反着读都一样。则可以认为该短语是一个回文串。

字母和数字都属于字母数字字符。

给你一个字符串 s，如果它是回文串，返回 true ；否则，返回 false 。
示例 1：

输入: "A man, a plan, a canal: Panama"
输出：true
解释："amanaplanacanalpanama" 是回文串。

class Solution {
    public static boolean isEffective(char ch){
        return Character.isLetterOrDigit(ch);
    }
    public boolean isPalindrome(String s) {
        int left=0;
        int right=s.length()-1;
        s=s.toLowerCase();
        while(left<right){
            while(left<right&&!isEffective(s.charAt(left))){
                left++;//跳过空格等非法字符
            }
            while(left<right&&!isEffective(s.charAt(right))){
                right--;
            }
            if(s.charAt(left)!=s.charAt(right)){
                return false;
            }
            left++;
            right--;
        }
        return true;
    }
}

有效性，和大小写

434. 字符串中的单词数(leetcode)

统计字符串中的单词个数，这里的单词指的是连续的不是空格的字符。
请注意，你可以假定字符串里不包括任何不可打印的字符。
示例:

输入: "Hello, my name is John"
输出: 5
解释: 这里的单词是指连续的不是空格的字符，所以 "Hello," 算作 1 个单词。

class Solution {
    public int countSegments(String s) {
        
        
        int count=0;
        for(int i=0;i<s.length();i++){
            if((i==0||s.charAt(i-1)==' ')&&s.charAt(i)!=' '){
                count++;
            }
        }
        return count;
    }
}

class Solution {
    public int countSegments(String s) {
        if(s.length()==0){
            return 0;
        }
        
        String[] ret=s.split(" ");
        int count=0;
        for(int i=0;i<ret.length;i++){
            if(ret[i]!=""){
                count++;
            }
        }
        return count;
    }
}

class Solution {
    public String toLowerCase(String s) {
        StringBuilder sb=new StringBuilder();
        for(int i=0;i<s.length();i++){
            char ch=s.charAt(i);
            if(ch>='A'&&ch<='Z'){
                sb.append(ch+=32);
            }else{
                sb.append(ch);
            }
        }
        return sb.toString();
    }
}

代码运行结果

用命令方式运行以下代码的运行结果是（）
public class f{
public static void main(String[] args){
String foo1 = args[1];
String foo2 = args[2];
String foo3 = args[3];
}
}
命令: java f a b c
A 程序编译错误
B a b c
C 程序运行错误
D f

C

在args数组输入3个元素a,b,c。那么数组的下标是0~2，所以args[3]是数组越界异常，是运行时错误，所以选C

OR46 字符集合(牛客网)

描述
输入一个字符串，求出该字符串包含的字符集合，按照字母输入的顺序输出。

数据范围：输入的字符串长度满足 1 \le n \le 100 \1≤n≤100  ，且只包含大小写字母，区分大小写。

本题有多组输入
输入描述：
每组数据输入一个字符串，字符串最大长度为100，且只包含字母，不可能为空串，区分大小写。
输出描述：
每组数据一行，按字符串原有的字符顺序，输出字符集合，即重复出现并靠后的字母不输出。
示例1
输入：
abcqweracb
输出：
abcqwer

import java.util.Scanner;
public class Main {
    public static String func(String str) {
        boolean[] arr = new boolean[255];
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            char ch = str.charAt(i);
            if (arr[ch] == false) {
                sb.append(ch);
                arr[ch] = true;
            }
        }
        return sb.toString();
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextLine()) {
            String str = scanner.nextLine();
            String ret = func(str);
            System.out.println(ret);

        }
    }
}

NC22 合并两个有序的数组(牛客网)

描述
给出一个有序的整数数组 A 和有序的整数数组 B ，请将数组 B 合并到数组 A 中，变成一个有序的升序数组

数据范围： 0 \le n,m \le 1000≤n,m≤100，|A_i| <=100∣A 
i
​
 ∣<=100， |B_i| <= 100∣B 
i
​
 ∣<=100

注意：
1.保证 A 数组有足够的空间存放 B 数组的元素， A 和 B 中初始的元素数目分别为 m 和 n，A的数组空间大小为 m+n
2.不要返回合并的数组，将数组 B 的数据合并到 A 里面就好了，且后台会自动将合并后的数组 A 的内容打印出来，所以也不需要自己打印
3. A 数组在[0,m-1]的范围也是有序的
示例1
输入：
[4,5,6],[1,2,3]
返回值：
[1,2,3,4,5,6]
说明：
A数组为[4,5,6]，B数组为[1,2,3]，后台程序会预先将A扩容为[4,5,6,0,0,0]，B还是为[1,2,3]，m=3，n=3，传入到函数merge里面，然后请同学完成merge函数，将B的数据合并A里面，最后后台程序输出A数组 

import java.util.*;
public class Solution {
    public void merge(int A[], int m, int B[], int n) {
        int i = m - 1;
        int j = n - 1;
        int k = m + n - 1;
        while (i >= 0 && j >= 0) {
            if (A[i] > B[j]) {
                A[k] = A[i];
                k--;
                i--;
            } else {
                A[k] = B[j];
                k--;
                j--;
            }
        }
        while (j >= 0) {
            A[k] = B[j];
            k--;
            j--;
        }
        while (i >= 0) {
            A[k] = A[i];
            k--;
            i--;
        }
    }
}

倒着排

异常

第一题

有关下述Java代码描述正确的选项是____。
public class TestClass {

  private static void testMethod(){

    System.out.println("testMethod");

  }

  public static void main(String[] args) {

    ((TestClass)null).testMethod();

  }

}

运行正常，输出testMethod

第二题

下面有关JAVA异常类的描述，说法错误的是？
A. 异常的继承结构：基类为Throwable，Error和Exception继承Throwable，RuntimeException和IOException等继承Exception
B.非RuntimeException一般是外部错误(非Error)，其必须被 try{}catch语句块所捕获
C. Error类体系描述了Java运行系统中的内部错误以及资源耗尽的情形，Error不需要捕捉
D.RuntimeException体系包括错误的类型转换、数组越界访问和试图访问空指针等等，必须被 try{}catch语句块所捕获

选D
受查异常必须被 try{}catch语句块所捕获，而非受查异常(运行时异常)则没有这个要求