Javase易错

1.在运行过程中，Java解释器自动导入的包java.lang
2.一个以.java为后缀的源文件：只有一个于文件名相同的类，可以包含其他类
3.注意匿名内部类。
4.构造方法可以用private修饰，单例模式。
5.以.java为后缀的源文件可以包含其他类。

 

合并两个有序数组于A数组中，保证后返回A

//两个有序数组A，B，将A扩容，将B数组放入A数组,最后返回有序的数组A
    public static 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]=0){
            A[k]=B[j];
            k--;
            j--;
        }
        while(i>=0){
            A[k]=A[i];
            k--;
            i--;

        }
    }

 

字符集合

public class 字符集合 {
    //字符集合
    public static String setstring (String str) {
        // write code here
        StringBuilder sb=new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            char ch=str.charAt(i);
            if(!sb.toString().contains(ch+"")){//这一步真是关键，
                sb.append(ch);
            }

        }
        return sb.toString();

    }
    public static String setString1(String str){
        StringBuilder sb=new StringBuilder();
        int[] array =new int[127];
        for (int i = 0; i < str.length(); i++) {
            char ch=str.charAt(i);
            if(array[ch]==0){
                //代表这个字符没出现过
                sb.append(ch);
                array[ch]=1;
            }

        }
        return sb.toString();

    }

    public static void main(String[] args) {
        String str="Abbcd";

        System.out.println(setString1(str));
    }

}

 和为s的两个数字

public class 和为s的两个数字 {
    public int[] twoSum(int[] nums,int target){
        int i=0;
        int j=nums.length;
        while(itarget){
                j--;
            }else{
                break;
            }
        }
        return new int[]{nums[i],nums[j]};
    }

}

回文字符串

/**
 * Throwable:是异常体系的顶层，派生出两个重要的子类，Error和Exception
 * Error:Java虚拟机无法解决的问题：JVM内部错误，资源耗尽，栈溢出错误，
 * Exception:异常产生后程序员可以通过代码进行处理
 * **/
public class 回文字符串 {
    public static  boolean isPalinddrome(String s){
        s=s.toLowerCase();
        int left=0;
        int right=s.length()-1;
        while(left

动态绑定

class B{
    public B(){
        func();
    }
    public void func(){
        System.out.println("B.func");
    }
}

class D extends B{
    private int num=1;
    @Override
    public void func() {
        super.func();//默认生成
        System.out.println("D.func()"+num);//打印出来是0
    }

}

/**
 *
 * 事实上，在调用D的构造方法的时候，
 * 会先帮助父类进行构造，回去调用B的构造方法，会发生动态绑定
 * 相当于就没有利用private int num=1这句话。
 * 所以打印出0,
 *
 * **/
public class 动态绑定 {
    public static void main(String[] args) {
        System.out.println(1);
        D d =new D();
        System.out.println("");
    }

}

 旋转数组中的最小数字

/**
     * 把一个数组最开始的若干个元素搬到数组的末尾，就是左旋,输入一个递增排序
     * 的数组的一个旋转，输出旋转数组的最小元素，例如：{3，4，5，1，2}是{1，2，3，4，5}
     * 的一个旋转，该数组最小值是1
     * */
  

    public static int min(int[] array){
        int begin=0;
        int end=array.length-1;
        //考虑还没有特殊的旋转
        if(array[begin]>1);
            if(array[mid]>=array[begin]){
                //左侧有序
                begin=mid;
            }else{
                end=mid;
            }

        }
        return array[end];
    }

位运算符小结的题

/**
 * 获取奇偶数 x&1=1就是奇数，是偶数的话最低位是0，x&1=0
 * 获取进制位是1还是0
 * 交换两个整数变量地值
 * 不判断语句，求证书的绝对值
 * 异或：不进位的加法
 *
 * & 两个都是1才是1
 * ^ 同0异1
 * | 有1为1
 * 对于int类型，1<<35和1<<3是相同的
 *
 * 相同两个数字^的结果是0
 *
 * **/
public class 位运算 {

    /**找出唯一成对的数
     * 1-N这N个数放在含有N+1个元素的数组中，只有唯一的一个元素重复，
     * 其他都只出现一次，每个数组元素只能访问一次，找出这个元素
     * **/

    /**
     * 也就是说数组中N+1个元素
     * （1……^k^k……N）^（1……^k……^N）,最终结果就是k
     * ***/
    public static int f(int[] arr){
        int x1=0;
        for (int i = 1; i < arr.length; i++) {
            x1=x1^i;
        }
        for (int i = 0; i < arr.length; i++) {
            x1=x1^arr[i];
        }
        return x1;
    }
    //你也可以用map或者数组来写
    public static int f1(int[] arr){
        int[] count=new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            count[arr[i]]++;
        }
        for (int i = 0; i < count.length; i++) {
            if(count[i]==2){
                return i;//return arr[i]或者i都是可以的
            }
        }
        return -1;
    }

    /**
     * 将整数的奇偶位交换--二进制
     * eg:9
     * 0001001
     *    0110->6
     *
     *
     * ***/
    public static int func(int num){
        //取出奇数位与1010 1010 1010……
        int ou=num&0xaaaaaaaa;
        //取出偶数位与0101 0101 0101……
        int ji=num&0x55555555;
        return (ou>>1)^(ji<<1);
    }
    /***
     * 求一个数字中二进制中1的个数
     *
     * **/
    public static int func2(int n){
        //解法一
//        int count=0;
//        for (int i = 0; i < 32; i++) {
//            if((n&(1<